Index: lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java =================================================================== --- lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java (revision 1369134) +++ lucene/demo/src/java/org/apache/lucene/demo/IndexFiles.java (working copy) @@ -190,7 +190,7 @@ // so that the text of the file is tokenized and indexed, but not stored. // Note that FileReader expects the file to be in UTF-8 encoding. // If that's not the case searching for special characters will fail. - doc.add(new TextField("contents", new BufferedReader(new InputStreamReader(fis, "UTF-8")), Field.Store.NO)); + doc.add(new TextField("contents", new BufferedReader(new InputStreamReader(fis, "UTF-8")))); if (writer.getConfig().getOpenMode() == OpenMode.CREATE) { // New index, so we just add the document (no old document can be there): Index: lucene/core/src/test/org/apache/lucene/search/spans/TestPayloadSpans.java =================================================================== --- lucene/core/src/test/org/apache/lucene/search/spans/TestPayloadSpans.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/search/spans/TestPayloadSpans.java (working copy) @@ -256,7 +256,7 @@ newIndexWriterConfig(TEST_VERSION_CURRENT, new TestPayloadAnalyzer())); Document doc = new Document(); - doc.add(new TextField("content", new StringReader("a b c d e f g h i j a k"), Field.Store.NO)); + doc.add(new TextField("content", new StringReader("a b c d e f g h i j a k"))); writer.addDocument(doc); IndexReader reader = writer.getReader(); @@ -293,7 +293,7 @@ newIndexWriterConfig(TEST_VERSION_CURRENT, new TestPayloadAnalyzer())); Document doc = new Document(); - doc.add(new TextField("content", new StringReader("a b a d k f a h i k a k"), Field.Store.NO)); + doc.add(new TextField("content", new StringReader("a b a d k f a h i k a k"))); writer.addDocument(doc); IndexReader reader = writer.getReader(); IndexSearcher is = newSearcher(reader); @@ -328,7 +328,7 @@ newIndexWriterConfig(TEST_VERSION_CURRENT, new TestPayloadAnalyzer())); Document doc = new Document(); - doc.add(new TextField("content", new StringReader("j k a l f k k p a t a k l k t a"), Field.Store.NO)); + doc.add(new TextField("content", new StringReader("j k a l f k k p a t a k l k t a"))); writer.addDocument(doc); IndexReader reader = writer.getReader(); IndexSearcher is = newSearcher(reader); Index: lucene/core/src/test/org/apache/lucene/search/TestSort.java =================================================================== --- lucene/core/src/test/org/apache/lucene/search/TestSort.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/search/TestSort.java (working copy) @@ -196,7 +196,7 @@ if (data[i][11] != null) doc.add (new StringField ("parser", data[i][11], Field.Store.NO)); for(IndexableField f : doc.getFields()) { - if (!f.fieldType().omitNorms()) { + if (f.fieldType().indexed() && !f.fieldType().omitNorms()) { ((Field) f).setBoost(2.0f); } } @@ -239,7 +239,7 @@ doc.add(new SortedBytesDocValuesField("string2", new BytesRef(num2))); doc.add (new Field ("tracer2", num2, onlyStored)); for(IndexableField f2 : doc.getFields()) { - if (!f2.fieldType().omitNorms()) { + if (f2.fieldType().indexed() && !f2.fieldType().omitNorms()) { ((Field) f2).setBoost(2.0f); } } @@ -255,7 +255,7 @@ doc.add (new Field ("tracer2_fixed", num2Fixed, onlyStored)); for(IndexableField f2 : doc.getFields()) { - if (!f2.fieldType().omitNorms()) { + if (f2.fieldType().indexed() && !f2.fieldType().omitNorms()) { ((Field) f2).setBoost(2.0f); } } Index: lucene/core/src/test/org/apache/lucene/search/TestPositionIncrement.java =================================================================== --- lucene/core/src/test/org/apache/lucene/search/TestPositionIncrement.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/search/TestPositionIncrement.java (working copy) @@ -206,7 +206,7 @@ RandomIndexWriter writer = new RandomIndexWriter(random(), dir, new MockPayloadAnalyzer()); Document doc = new Document(); doc.add(new TextField("content", new StringReader( - "a a b c d e a f g h i j a b k k"), Field.Store.NO)); + "a a b c d e a f g h i j a b k k"))); writer.addDocument(doc); final IndexReader readerFromWriter = writer.getReader(); Index: lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java =================================================================== --- lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java (working copy) @@ -1542,4 +1542,73 @@ iw.close(); dir.close(); } + + public void testBoostOmitNorms() throws Exception { + Directory dir = newDirectory(); + IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random())); + iwc.setMergePolicy(newLogMergePolicy()); + IndexWriter iw = new IndexWriter(dir, iwc); + Document doc = new Document(); + doc.add(new StringField("field1", "sometext", Field.Store.YES)); + doc.add(new TextField("field2", "sometext", Field.Store.NO)); + doc.add(new StringField("foo", "bar", Field.Store.NO)); + iw.addDocument(doc); // add an 'ok' document + try { + doc = new Document(); + // try to boost with norms omitted + List list = new ArrayList(); + list.add(new IndexableField() { + + @Override + public String name() { + return "foo"; + } + + @Override + public IndexableFieldType fieldType() { + return StringField.TYPE_NOT_STORED; + } + + @Override + public float boost() { + return 5f; + } + + @Override + public BytesRef binaryValue() { + return null; + } + + @Override + public String stringValue() { + return "baz"; + } + + @Override + public Reader readerValue() { + return null; + } + + @Override + public Number numericValue() { + return null; + } + + @Override + public TokenStream tokenStream(Analyzer analyzer) throws IOException { + return null; + } + }); + iw.addDocument(list); + fail("didn't get any exception, boost silently discarded"); + } catch (UnsupportedOperationException expected) { + // expected + } + DirectoryReader ir = DirectoryReader.open(iw, false); + assertEquals(1, ir.numDocs()); + assertEquals("sometext", ir.document(0).get("field1")); + ir.close(); + iw.close(); + dir.close(); + } } Index: lucene/core/src/test/org/apache/lucene/index/TestDoc.java =================================================================== --- lucene/core/src/test/org/apache/lucene/index/TestDoc.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/index/TestDoc.java (working copy) @@ -186,7 +186,7 @@ File file = new File(workDir, fileName); Document doc = new Document(); InputStreamReader is = new InputStreamReader(new FileInputStream(file), "UTF-8"); - doc.add(new TextField("contents", is, Field.Store.NO)); + doc.add(new TextField("contents", is)); writer.addDocument(doc); writer.commit(); is.close(); Index: lucene/core/src/test/org/apache/lucene/document/TestDocument.java =================================================================== --- lucene/core/src/test/org/apache/lucene/document/TestDocument.java (revision 1369134) +++ lucene/core/src/test/org/apache/lucene/document/TestDocument.java (working copy) @@ -290,33 +290,4 @@ // expected } } - - public void testBoost() throws Exception { - Directory dir = newDirectory(); - IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random())); - iwc.setMergePolicy(newLogMergePolicy()); - IndexWriter iw = new IndexWriter(dir, iwc); - Document doc = new Document(); - doc.add(new StringField("field1", "sometext", Field.Store.YES)); - doc.add(new TextField("field2", "sometext", Field.Store.NO)); - doc.add(new StringField("foo", "bar", Field.Store.NO)); - iw.addDocument(doc); // add an 'ok' document - try { - doc = new Document(); - // try to boost with norms omitted - StringField field = new StringField("foo", "baz", Field.Store.NO); - field.setBoost(5.0f); - doc.add(field); - iw.addDocument(doc); - fail("didn't get any exception, boost silently discarded"); - } catch (UnsupportedOperationException expected) { - // expected - } - DirectoryReader ir = DirectoryReader.open(iw, false); - assertEquals(1, ir.numDocs()); - assertEquals("sometext", ir.document(0).get("field1")); - ir.close(); - iw.close(); - dir.close(); - } } Index: lucene/core/src/test/org/apache/lucene/document/TestField.java =================================================================== --- lucene/core/src/test/org/apache/lucene/document/TestField.java (revision 0) +++ lucene/core/src/test/org/apache/lucene/document/TestField.java (working copy) @@ -0,0 +1,618 @@ +package org.apache.lucene.document; + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.StringReader; + +import org.apache.lucene.analysis.CannedTokenStream; +import org.apache.lucene.analysis.Token; +import org.apache.lucene.util.BytesRef; +import org.apache.lucene.util.LuceneTestCase; + +// sanity check some basics of fields +public class TestField extends LuceneTestCase { + + public void testByteDocValuesField() throws Exception { + ByteDocValuesField field = new ByteDocValuesField("foo", (byte) 5); + + trySetBoost(field); + field.setByteValue((byte) 6); // ok + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6, field.numericValue().byteValue()); + } + + public void testDerefBytesDocValuesField() throws Exception { + DerefBytesDocValuesField field = new DerefBytesDocValuesField("foo", new BytesRef("bar")); + + trySetBoost(field); + trySetByteValue(field); + field.setBytesValue("fubar".getBytes("UTF-8")); + field.setBytesValue(new BytesRef("baz")); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(new BytesRef("baz"), field.binaryValue()); + } + + public void testDoubleField() throws Exception { + Field fields[] = new Field[] { + new DoubleField("foo", 5d, Field.Store.NO), + new DoubleField("foo", 5d, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + field.setDoubleValue(6d); // ok + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6d, field.numericValue().doubleValue(), 0.0d); + } + } + + public void testDoubleDocValuesField() throws Exception { + DoubleDocValuesField field = new DoubleDocValuesField("foo", 5d); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + field.setDoubleValue(6d); // ok + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6d, field.numericValue().doubleValue(), 0.0d); + } + + public void testFloatDocValuesField() throws Exception { + FloatDocValuesField field = new FloatDocValuesField("foo", 5f); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + field.setFloatValue(6f); // ok + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6f, field.numericValue().floatValue(), 0.0f); + } + + public void testFloatField() throws Exception { + Field fields[] = new Field[] { + new FloatField("foo", 5f, Field.Store.NO), + new FloatField("foo", 5f, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + field.setFloatValue(6f); // ok + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6f, field.numericValue().floatValue(), 0.0f); + } + } + + public void testIntDocValuesField() throws Exception { + IntDocValuesField field = new IntDocValuesField("foo", 5); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + field.setIntValue(6); // ok + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6, field.numericValue().intValue()); + } + + public void testIntField() throws Exception { + Field fields[] = new Field[] { + new IntField("foo", 5, Field.Store.NO), + new IntField("foo", 5, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + field.setIntValue(6); // ok + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6, field.numericValue().intValue()); + } + } + + public void testLongDocValuesField() throws Exception { + LongDocValuesField field = new LongDocValuesField("foo", 5L); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + field.setLongValue(6); // ok + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6L, field.numericValue().longValue()); + } + + public void testLongField() throws Exception { + Field fields[] = new Field[] { + new LongField("foo", 5L, Field.Store.NO), + new LongField("foo", 5L, Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + field.setLongValue(6); // ok + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6L, field.numericValue().longValue()); + } + } + + public void testPackedLongDocValuesField() throws Exception { + PackedLongDocValuesField field = new PackedLongDocValuesField("foo", 5L); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + field.setLongValue(6); // ok + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(6L, field.numericValue().longValue()); + } + + public void testShortDocValuesField() throws Exception { + ShortDocValuesField field = new ShortDocValuesField("foo", (short)5); + + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + field.setShortValue((short) 6); // ok + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals((short)6, field.numericValue().shortValue()); + } + + public void testSortedBytesDocValuesField() throws Exception { + SortedBytesDocValuesField field = new SortedBytesDocValuesField("foo", new BytesRef("bar")); + + trySetBoost(field); + trySetByteValue(field); + field.setBytesValue("fubar".getBytes("UTF-8")); + field.setBytesValue(new BytesRef("baz")); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(new BytesRef("baz"), field.binaryValue()); + } + + public void testStraightBytesDocValuesField() throws Exception { + StraightBytesDocValuesField field = new StraightBytesDocValuesField("foo", new BytesRef("bar")); + + trySetBoost(field); + trySetByteValue(field); + field.setBytesValue("fubar".getBytes("UTF-8")); + field.setBytesValue(new BytesRef("baz")); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(new BytesRef("baz"), field.binaryValue()); + } + + public void testStringField() throws Exception { + Field fields[] = new Field[] { + new StringField("foo", "bar", Field.Store.NO), + new StringField("foo", "bar", Field.Store.YES) + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + field.setStringValue("baz"); + trySetTokenStreamValue(field); + + assertEquals("baz", field.stringValue()); + } + } + + public void testTextFieldString() throws Exception { + Field fields[] = new Field[] { + new TextField("foo", "bar", Field.Store.NO), + new TextField("foo", "bar", Field.Store.YES) + }; + + for (Field field : fields) { + field.setBoost(5f); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + field.setStringValue("baz"); + field.setTokenStream(new CannedTokenStream(new Token("foo", 0, 3))); + + assertEquals("baz", field.stringValue()); + assertEquals(5f, field.boost(), 0f); + } + } + + public void testTextFieldReader() throws Exception { + Field field = new TextField("foo", new StringReader("bar")); + + field.setBoost(5f); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + field.setReaderValue(new StringReader("foobar")); + trySetShortValue(field); + trySetStringValue(field); + field.setTokenStream(new CannedTokenStream(new Token("foo", 0, 3))); + + assertNotNull(field.readerValue()); + assertEquals(5f, field.boost(), 0f); + } + + /* TODO: this is pretty expert and crazy + * see if we can fix it up later + public void testTextFieldTokenStream() throws Exception { + } + */ + + public void testStoredFieldBytes() throws Exception { + Field fields[] = new Field[] { + new StoredField("foo", "bar".getBytes("UTF-8")), + new StoredField("foo", "bar".getBytes("UTF-8"), 0, 3), + new StoredField("foo", new BytesRef("bar")), + /* new StoredField("foo", "10"), + new StoredField("foo", 10), + new StoredField("foo", 10F), + new StoredField("foo", 10L), + new StoredField("foo", 10D) */ + }; + + for (Field field : fields) { + trySetBoost(field); + trySetByteValue(field); + field.setBytesValue("baz".getBytes("UTF-8")); + field.setBytesValue(new BytesRef("baz")); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(new BytesRef("baz"), field.binaryValue()); + } + } + + public void testStoredFieldString() throws Exception { + Field field = new StoredField("foo", "bar"); + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + field.setStringValue("baz"); + trySetTokenStreamValue(field); + + assertEquals("baz", field.stringValue()); + } + + public void testStoredFieldInt() throws Exception { + Field field = new StoredField("foo", 1); + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + field.setIntValue(5); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(5, field.numericValue().intValue()); + } + + public void testStoredFieldDouble() throws Exception { + Field field = new StoredField("foo", 1D); + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + field.setDoubleValue(5D); + trySetIntValue(field); + trySetFloatValue(field); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(5D, field.numericValue().doubleValue(), 0.0D); + } + + public void testStoredFieldFloat() throws Exception { + Field field = new StoredField("foo", 1F); + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + field.setFloatValue(5f); + trySetLongValue(field); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(5f, field.numericValue().floatValue(), 0.0f); + } + + public void testStoredFieldLong() throws Exception { + Field field = new StoredField("foo", 1L); + trySetBoost(field); + trySetByteValue(field); + trySetBytesValue(field); + trySetBytesRefValue(field); + trySetDoubleValue(field); + trySetIntValue(field); + trySetFloatValue(field); + field.setLongValue(5); + trySetReaderValue(field); + trySetShortValue(field); + trySetStringValue(field); + trySetTokenStreamValue(field); + + assertEquals(5L, field.numericValue().longValue()); + } + + private void trySetByteValue(Field f) { + try { + f.setByteValue((byte) 10); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetBytesValue(Field f) { + try { + f.setBytesValue(new byte[] { 5, 5 }); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetBytesRefValue(Field f) { + try { + f.setBytesValue(new BytesRef("bogus")); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetDoubleValue(Field f) { + try { + f.setDoubleValue(Double.MAX_VALUE); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetIntValue(Field f) { + try { + f.setIntValue(Integer.MAX_VALUE); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetLongValue(Field f) { + try { + f.setLongValue(Long.MAX_VALUE); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetFloatValue(Field f) { + try { + f.setFloatValue(Float.MAX_VALUE); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetReaderValue(Field f) { + try { + f.setReaderValue(new StringReader("BOO!")); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetShortValue(Field f) { + try { + f.setShortValue(Short.MAX_VALUE); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetStringValue(Field f) { + try { + f.setStringValue("BOO!"); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetTokenStreamValue(Field f) { + try { + f.setTokenStream(new CannedTokenStream(new Token("foo", 0, 3))); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } + + private void trySetBoost(Field f) { + try { + f.setBoost(5.0f); + fail(); + } catch (IllegalArgumentException expected) { + // expected + } + } +} Property changes on: lucene/core/src/test/org/apache/lucene/document/TestField.java ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native Index: lucene/core/src/java/org/apache/lucene/document/Field.java =================================================================== --- lucene/core/src/java/org/apache/lucene/document/Field.java (revision 1369134) +++ lucene/core/src/java/org/apache/lucene/document/Field.java (working copy) @@ -377,6 +377,11 @@ * @see org.apache.lucene.search.similarities.DefaultSimilarity#encodeNormValue(float) */ public void setBoost(float boost) { + if (boost != 1.0f) { + if (type.indexed() == false || type.omitNorms()) { + throw new IllegalArgumentException("You cannot set an index-time boost on an unindexed field, or one that omits norms"); + } + } this.boost = boost; } Index: lucene/core/src/java/org/apache/lucene/document/StoredField.java =================================================================== --- lucene/core/src/java/org/apache/lucene/document/StoredField.java (revision 1369134) +++ lucene/core/src/java/org/apache/lucene/document/StoredField.java (working copy) @@ -49,6 +49,7 @@ super(name, value, TYPE); } + // TODO: not great but maybe not a big problem? public StoredField(String name, int value) { super(name, TYPE); fieldsData = value; Index: lucene/core/src/java/org/apache/lucene/document/TextField.java =================================================================== --- lucene/core/src/java/org/apache/lucene/document/TextField.java (revision 1369134) +++ lucene/core/src/java/org/apache/lucene/document/TextField.java (working copy) @@ -47,8 +47,8 @@ // TODO: add sugar for term vectors...? /** Creates a new TextField with Reader value. */ - public TextField(String name, Reader reader, Store store) { - super(name, reader, store == Store.YES ? TYPE_STORED : TYPE_NOT_STORED); + public TextField(String name, Reader reader) { + super(name, reader, TYPE_NOT_STORED); } /** Creates a new TextField with String value. */ Index: solr/core/src/java/org/apache/solr/update/DocumentBuilder.java =================================================================== --- solr/core/src/java/org/apache/solr/update/DocumentBuilder.java (revision 1369134) +++ solr/core/src/java/org/apache/solr/update/DocumentBuilder.java (working copy) @@ -235,7 +235,7 @@ SchemaField sfield = schema.getFieldOrNull(name); boolean used = false; float boost = field.getBoost(); - boolean omitNorms = sfield != null && sfield.omitNorms(); + boolean applyBoost = sfield != null && sfield.indexed() && !sfield.omitNorms(); // Make sure it has the correct number if( sfield!=null && !sfield.multiValued() && field.getValueCount() > 1 ) { @@ -244,9 +244,9 @@ sfield.getName() + ": " +field.getValue() ); } - if (omitNorms && boost != 1.0F) { + if (applyBoost == false && boost != 1.0F) { throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, - "ERROR: "+getID(doc, schema)+"cannot set an index-time boost, norms are omitted for field " + + "ERROR: "+getID(doc, schema)+"cannot set an index-time boost, unindexed or norms are omitted for field " + sfield.getName() + ": " +field.getValue() ); } @@ -260,7 +260,7 @@ hasField = true; if (sfield != null) { used = true; - addField(out, sfield, v, omitNorms ? 1F : docBoost*boost); + addField(out, sfield, v, applyBoost ? docBoost*boost : 1f); } // Check if we should copy this field to any other fields. @@ -282,7 +282,7 @@ if( val instanceof String && cf.getMaxChars() > 0 ) { val = cf.getLimitedValue((String)val); } - addField(out, destinationField, val, destinationField.omitNorms() ? 1F : docBoost*boost); + addField(out, destinationField, val, destinationField.indexed() && !destinationField.omitNorms() ? docBoost*boost : 1F); } // In lucene, the boost for a given field is the product of the Index: solr/core/src/java/org/apache/solr/schema/CurrencyField.java =================================================================== --- solr/core/src/java/org/apache/solr/schema/CurrencyField.java (revision 1369134) +++ solr/core/src/java/org/apache/solr/schema/CurrencyField.java (working copy) @@ -136,9 +136,9 @@ IndexableField[] f = new IndexableField[field.stored() ? 3 : 2]; SchemaField amountField = getAmountField(field); - f[0] = amountField.createField(String.valueOf(value.getAmount()), amountField.omitNorms() ? 1F : boost); + f[0] = amountField.createField(String.valueOf(value.getAmount()), amountField.indexed() && !amountField.omitNorms() ? boost : 1F); SchemaField currencyField = getCurrencyField(field); - f[1] = currencyField.createField(value.getCurrencyCode(), currencyField.omitNorms() ? 1F : boost); + f[1] = currencyField.createField(value.getCurrencyCode(), currencyField.indexed() && !currencyField.omitNorms() ? boost : 1F); if (field.stored()) { org.apache.lucene.document.FieldType customType = new org.apache.lucene.document.FieldType(); @@ -148,7 +148,7 @@ if (storedValue.indexOf(",") < 0) { storedValue += "," + defaultCurrency; } - f[2] = createField(field.getName(), storedValue, customType, boost); + f[2] = createField(field.getName(), storedValue, customType, 1F); } return f; Index: solr/core/src/java/org/apache/solr/schema/PointType.java =================================================================== --- solr/core/src/java/org/apache/solr/schema/PointType.java (revision 1369134) +++ solr/core/src/java/org/apache/solr/schema/PointType.java (working copy) @@ -83,7 +83,8 @@ if (field.indexed()) { for (int i=0; i