From 549900a0824e2c856b7b7cedc1d447ea854aebf2 Mon Sep 17 00:00:00 2001 From: Chris Male Date: Sat, 27 Oct 2012 15:19:27 +1300 Subject: [PATCH] lucene 4: Converted most Mappers over to FieldType API --- .../lucene/spatial/SpatialStrategy.java | 4 +- .../common/lucene/uid/UidField.java | 2 +- .../index/mapper/DocumentMapper.java | 5 +- .../index/mapper/FieldMapper.java | 19 +- .../mapper/core/AbstractFieldMapper.java | 211 +++++++++++------- .../index/mapper/core/BinaryFieldMapper.java | 32 +-- .../index/mapper/core/BooleanFieldMapper.java | 80 ++++--- .../index/mapper/core/ByteFieldMapper.java | 72 +++--- .../index/mapper/core/DateFieldMapper.java | 72 +++--- .../index/mapper/core/DoubleFieldMapper.java | 70 +++--- .../index/mapper/core/FloatFieldMapper.java | 70 +++--- .../index/mapper/core/IntegerFieldMapper.java | 71 +++--- .../index/mapper/core/LongFieldMapper.java | 70 +++--- .../index/mapper/core/NumberFieldMapper.java | 62 +++-- .../index/mapper/core/ShortFieldMapper.java | 69 +++--- .../index/mapper/core/StringFieldMapper.java | 64 +++--- .../index/mapper/core/TypeParsers.java | 52 +++-- .../index/mapper/geo/GeoShapeFieldMapper.java | 28 ++- .../index/mapper/internal/AllFieldMapper.java | 9 +- .../mapper/internal/BoostFieldMapper.java | 44 ++-- .../index/mapper/internal/IdFieldMapper.java | 75 ++++--- .../mapper/internal/IndexFieldMapper.java | 48 ++-- .../mapper/internal/ParentFieldMapper.java | 30 ++- .../mapper/internal/RoutingFieldMapper.java | 51 +++-- .../mapper/internal/SizeFieldMapper.java | 35 +-- .../mapper/internal/SourceFieldMapper.java | 37 +-- .../index/mapper/internal/TTLFieldMapper.java | 32 +-- .../mapper/internal/TimestampFieldMapper.java | 45 ++-- .../mapper/internal/TypeFieldMapper.java | 57 ++--- .../index/mapper/internal/UidFieldMapper.java | 28 ++- .../index/mapper/ip/IpFieldMapper.java | 66 ++++-- .../index/mapper/object/ObjectMapper.java | 11 +- 32 files changed, 973 insertions(+), 648 deletions(-) diff --git a/src/main/java/org/elasticsearch/common/lucene/spatial/SpatialStrategy.java b/src/main/java/org/elasticsearch/common/lucene/spatial/SpatialStrategy.java index 05dc835c9b3..e31ed96e03a 100644 --- a/src/main/java/org/elasticsearch/common/lucene/spatial/SpatialStrategy.java +++ b/src/main/java/org/elasticsearch/common/lucene/spatial/SpatialStrategy.java @@ -5,7 +5,6 @@ import com.spatial4j.core.shape.Point; import com.spatial4j.core.shape.Rectangle; import com.spatial4j.core.shape.Shape; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; import org.apache.lucene.search.Filter; import org.apache.lucene.search.Query; import org.elasticsearch.common.geo.GeoShapeConstants; @@ -56,12 +55,13 @@ public abstract class SpatialStrategy { * @param shape Shape to convert ints its indexable format * @return Fieldable for indexing the Shape */ - public Fieldable createField(Shape shape) { + public Field createField(Shape shape) { int detailLevel = prefixTree.getLevelForDistance( calcDistanceFromErrPct(shape, distanceErrorPct, GeoShapeConstants.SPATIAL_CONTEXT)); List nodes = prefixTree.getNodes(shape, detailLevel, true); NodeTokenStream tokenStream = nodeTokenStream.get(); tokenStream.setNodes(nodes); + // LUCENE 4 Upgrade: We should pass in the FieldType and use it here return new Field(fieldName.indexName(), tokenStream); } diff --git a/src/main/java/org/elasticsearch/common/lucene/uid/UidField.java b/src/main/java/org/elasticsearch/common/lucene/uid/UidField.java index f0d56957b44..05473665655 100644 --- a/src/main/java/org/elasticsearch/common/lucene/uid/UidField.java +++ b/src/main/java/org/elasticsearch/common/lucene/uid/UidField.java @@ -36,7 +36,7 @@ import java.io.Reader; /** * */ -public class UidField extends AbstractField { +public class UidField extends Field { public static class DocIdAndVersion { public final int docId; diff --git a/src/main/java/org/elasticsearch/index/mapper/DocumentMapper.java b/src/main/java/org/elasticsearch/index/mapper/DocumentMapper.java index e9886d70de5..99b1cc94818 100644 --- a/src/main/java/org/elasticsearch/index/mapper/DocumentMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/DocumentMapper.java @@ -24,7 +24,6 @@ import com.google.common.collect.Maps; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; import org.apache.lucene.search.Filter; import org.elasticsearch.common.Booleans; import org.elasticsearch.common.Nullable; @@ -114,13 +113,13 @@ public class DocumentMapper implements ToXContent { * Called before a field is added to the document. Return true to include * it in the document. */ - boolean beforeFieldAdded(FieldMapper fieldMapper, Fieldable fieldable, ParseContext parseContent); + boolean beforeFieldAdded(FieldMapper fieldMapper, Field fieldable, ParseContext parseContent); } public static class ParseListenerAdapter implements ParseListener { @Override - public boolean beforeFieldAdded(FieldMapper fieldMapper, Fieldable fieldable, Object parseContext) { + public boolean beforeFieldAdded(FieldMapper fieldMapper, Field fieldable, Object parseContext) { return true; } } diff --git a/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java index af1655d0d16..e214b9da591 100644 --- a/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java @@ -21,7 +21,6 @@ package org.elasticsearch.index.mapper; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.index.Term; import org.apache.lucene.search.Filter; @@ -120,17 +119,21 @@ public interface FieldMapper { Names names(); - Field.Index index(); + // LUCENE 4 UPGRADE Consider replacing these all with fieldType() and letting consumer pick and choose boolean indexed(); boolean analyzed(); - Field.Store store(); - boolean stored(); - Field.TermVector termVector(); + boolean storeTermVectors(); + + boolean storeTermVectorOffsets(); + + boolean storeTermVectorPositions(); + + boolean storeTermVectorPayloads(); float boost(); @@ -156,19 +159,19 @@ public interface FieldMapper { /** * Returns the value that will be used as a result for search. Can be only of specific types... . */ - Object valueForSearch(Fieldable field); + Object valueForSearch(Field field); /** * Returns the actual value of the field. */ - T value(Fieldable field); + T value(Field field); T valueFromString(String value); /** * Returns the actual value of the field as string. */ - String valueAsString(Fieldable field); + String valueAsString(Field field); /** * Returns the indexed value. diff --git a/src/main/java/org/elasticsearch/index/mapper/core/AbstractFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/AbstractFieldMapper.java index e63bcbf7806..27bbd04d0d8 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/AbstractFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/AbstractFieldMapper.java @@ -21,11 +21,11 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.index.Term; import org.apache.lucene.search.*; +import org.apache.lucene.util.BytesRef; import org.elasticsearch.ElasticSearchIllegalArgumentException; import org.elasticsearch.common.Nullable; import org.elasticsearch.common.lucene.Lucene; @@ -44,33 +44,60 @@ import java.io.IOException; public abstract class AbstractFieldMapper implements FieldMapper, Mapper { public static class Defaults { - public static final Field.Index INDEX = Field.Index.ANALYZED; - public static final Field.Store STORE = Field.Store.NO; - public static final Field.TermVector TERM_VECTOR = Field.TermVector.NO; + public static final FieldType FIELD_TYPE = new FieldType(); + + static { + FIELD_TYPE.setIndexed(true); + FIELD_TYPE.setTokenized(true); + FIELD_TYPE.setStored(false); + FIELD_TYPE.setStoreTermVectors(false); + FIELD_TYPE.setOmitNorms(false); + FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS); + FIELD_TYPE.freeze(); + } + public static final float BOOST = 1.0f; - public static final boolean OMIT_NORMS = false; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS; } public abstract static class OpenBuilder extends AbstractFieldMapper.Builder { - protected OpenBuilder(String name) { - super(name); + protected OpenBuilder(String name, FieldType fieldType) { + super(name, fieldType); } @Override - public T index(Field.Index index) { + public T index(boolean index) { return super.index(index); } @Override - public T store(Field.Store store) { + public T store(boolean store) { return super.store(store); } @Override - public T termVector(Field.TermVector termVector) { - return super.termVector(termVector); + protected T storeTermVectors(boolean termVectors) { + return super.storeTermVectors(termVectors); + } + + @Override + protected T storeTermVectorOffsets(boolean termVectorOffsets) { + return super.storeTermVectorOffsets(termVectorOffsets); + } + + @Override + protected T storeTermVectorPositions(boolean termVectorPositions) { + return super.storeTermVectorPositions(termVectorPositions); + } + + @Override + protected T storeTermVectorPayloads(boolean termVectorPayloads) { + return super.storeTermVectorPayloads(termVectorPayloads); + } + + @Override + protected T tokenized(boolean tokenized) { + return super.tokenized(tokenized); } @Override @@ -106,35 +133,55 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { public abstract static class Builder extends Mapper.Builder { - protected Field.Index index = Defaults.INDEX; - protected Field.Store store = Defaults.STORE; - protected Field.TermVector termVector = Defaults.TERM_VECTOR; + protected final FieldType fieldType; protected float boost = Defaults.BOOST; - protected boolean omitNorms = Defaults.OMIT_NORMS; protected boolean omitNormsSet = false; protected String indexName; protected NamedAnalyzer indexAnalyzer; protected NamedAnalyzer searchAnalyzer; protected Boolean includeInAll; - protected IndexOptions indexOptions = Defaults.INDEX_OPTIONS; protected boolean indexOptionsSet = false; - protected Builder(String name) { + protected Builder(String name, FieldType fieldType) { super(name); + this.fieldType = fieldType; } - protected T index(Field.Index index) { - this.index = index; + protected T index(boolean index) { + this.fieldType.setIndexed(index); return builder; } - protected T store(Field.Store store) { - this.store = store; + protected T store(boolean store) { + this.fieldType.setStored(store); return builder; } - protected T termVector(Field.TermVector termVector) { - this.termVector = termVector; + protected T storeTermVectors(boolean termVectors) { + this.fieldType.setStoreTermVectors(termVectors); + return builder; + } + + protected T storeTermVectorOffsets(boolean termVectorOffsets) { + this.fieldType.setStoreTermVectors(termVectorOffsets); + this.fieldType.setStoreTermVectorOffsets(termVectorOffsets); + return builder; + } + + protected T storeTermVectorPositions(boolean termVectorPositions) { + this.fieldType.setStoreTermVectors(termVectorPositions); + this.fieldType.setStoreTermVectorPositions(termVectorPositions); + return builder; + } + + protected T storeTermVectorPayloads(boolean termVectorPayloads) { + this.fieldType.setStoreTermVectors(termVectorPayloads); + this.fieldType.setStoreTermVectorPayloads(termVectorPayloads); + return builder; + } + + protected T tokenized(boolean tokenized) { + this.fieldType.setTokenized(tokenized); return builder; } @@ -144,13 +191,13 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { } protected T omitNorms(boolean omitNorms) { - this.omitNorms = omitNorms; + this.fieldType.setOmitNorms(omitNorms); this.omitNormsSet = true; return builder; } protected T indexOptions(IndexOptions indexOptions) { - this.indexOptions = indexOptions; + this.fieldType.setIndexOptions(indexOptions); this.indexOptionsSet = true; return builder; } @@ -191,40 +238,28 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { protected final Names names; - protected final Field.Index index; - - protected final Field.Store store; - - protected final Field.TermVector termVector; - protected float boost; - protected final boolean omitNorms; - - protected final FieldInfo.IndexOptions indexOptions; + protected final FieldType fieldType; protected final NamedAnalyzer indexAnalyzer; protected final NamedAnalyzer searchAnalyzer; - protected AbstractFieldMapper(Names names, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, NamedAnalyzer indexAnalyzer, NamedAnalyzer searchAnalyzer) { + protected AbstractFieldMapper(Names names, float boost, FieldType fieldType, NamedAnalyzer indexAnalyzer, NamedAnalyzer searchAnalyzer) { this.names = names; - this.index = index; - this.store = store; - this.termVector = termVector; this.boost = boost; - this.omitNorms = omitNorms; - this.indexOptions = indexOptions; + this.fieldType = fieldType; + this.fieldType.freeze(); // automatically set to keyword analyzer if its indexed and not analyzed - if (indexAnalyzer == null && !index.isAnalyzed() && index.isIndexed()) { + if (indexAnalyzer == null && !this.fieldType.tokenized() && this.fieldType.indexed()) { this.indexAnalyzer = Lucene.KEYWORD_ANALYZER; } else { this.indexAnalyzer = indexAnalyzer; } // automatically set to keyword analyzer if its indexed and not analyzed - if (searchAnalyzer == null && !index.isAnalyzed() && index.isIndexed()) { + if (searchAnalyzer == null && !this.fieldType.tokenized() && this.fieldType.indexed()) { this.searchAnalyzer = Lucene.KEYWORD_ANALYZER; } else { this.searchAnalyzer = searchAnalyzer; @@ -241,34 +276,39 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { return this.names; } - @Override - public Field.Index index() { - return this.index; - } - - @Override - public Field.Store store() { - return this.store; - } - @Override public boolean stored() { - return store == Field.Store.YES; + return fieldType.stored(); } @Override public boolean indexed() { - return index != Field.Index.NO; + return fieldType.indexed(); } @Override public boolean analyzed() { - return index == Field.Index.ANALYZED; + return fieldType.tokenized(); } @Override - public Field.TermVector termVector() { - return this.termVector; + public boolean storeTermVectors() { + return fieldType.storeTermVectors(); + } + + @Override + public boolean storeTermVectorOffsets() { + return fieldType.storeTermVectorOffsets(); + } + + @Override + public boolean storeTermVectorPositions() { + return fieldType.storeTermVectorPositions(); + } + + @Override + public boolean storeTermVectorPayloads() { + return fieldType.storeTermVectorPayloads(); } @Override @@ -278,12 +318,12 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { @Override public boolean omitNorms() { - return this.omitNorms; + return fieldType.omitNorms(); } @Override public IndexOptions indexOptions() { - return this.indexOptions; + return fieldType.indexOptions(); } @Override @@ -304,12 +344,10 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { @Override public void parse(ParseContext context) throws IOException { try { - Fieldable field = parseCreateField(context); + Field field = parseCreateField(context); if (field == null) { return; } - field.setOmitNorms(omitNorms); - field.setIndexOptions(indexOptions); if (!customBoost()) { field.setBoost(boost); } @@ -321,7 +359,7 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { } } - protected abstract Fieldable parseCreateField(ParseContext context) throws IOException; + protected abstract Field parseCreateField(ParseContext context) throws IOException; /** * Derived classes can override it to specify that boost value is set by derived classes. @@ -341,7 +379,7 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { } @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return valueAsString(field); } @@ -396,17 +434,18 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { @Override public Query rangeQuery(String lowerTerm, String upperTerm, boolean includeLower, boolean includeUpper, @Nullable QueryParseContext context) { + // LUCENE 4 UPGRADE: Perhaps indexedValue() should return a BytesRef? return new TermRangeQuery(names.indexName(), - lowerTerm == null ? null : indexedValue(lowerTerm), - upperTerm == null ? null : indexedValue(upperTerm), + lowerTerm == null ? null : new BytesRef(indexedValue(lowerTerm)), + upperTerm == null ? null : new BytesRef(indexedValue(upperTerm)), includeLower, includeUpper); } @Override public Filter rangeFilter(String lowerTerm, String upperTerm, boolean includeLower, boolean includeUpper, @Nullable QueryParseContext context) { return new TermRangeFilter(names.indexName(), - lowerTerm == null ? null : indexedValue(lowerTerm), - upperTerm == null ? null : indexedValue(upperTerm), + lowerTerm == null ? null : new BytesRef(indexedValue(lowerTerm)), + upperTerm == null ? null : new BytesRef(indexedValue(upperTerm)), includeLower, includeUpper); } @@ -427,14 +466,26 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { return; } AbstractFieldMapper fieldMergeWith = (AbstractFieldMapper) mergeWith; - if (!this.index.equals(fieldMergeWith.index)) { + if (this.indexed() != fieldMergeWith.indexed() || this.analyzed() != fieldMergeWith.analyzed()) { mergeContext.addConflict("mapper [" + names.fullName() + "] has different index values"); } - if (!this.store.equals(fieldMergeWith.store)) { + if (this.stored() != fieldMergeWith.stored()) { mergeContext.addConflict("mapper [" + names.fullName() + "] has different store values"); } - if (!this.termVector.equals(fieldMergeWith.termVector)) { - mergeContext.addConflict("mapper [" + names.fullName() + "] has different term_vector values"); + if (this.analyzed() != fieldMergeWith.analyzed()) { + mergeContext.addConflict("mapper [" + names.fullName() + "] has different tokenize values"); + } + if (this.storeTermVectors() != fieldMergeWith.storeTermVectors()) { + mergeContext.addConflict("mapper [" + names.fullName() + "] has different store_term_vector values"); + } + if (this.storeTermVectorOffsets() != fieldMergeWith.storeTermVectorOffsets()) { + mergeContext.addConflict("mapper [" + names.fullName() + "] has different store_term_vector_offsets values"); + } + if (this.storeTermVectorPositions() != fieldMergeWith.storeTermVectorPositions()) { + mergeContext.addConflict("mapper [" + names.fullName() + "] has different store_term_vector_positions values"); + } + if (this.storeTermVectorPayloads() != fieldMergeWith.storeTermVectorPayloads()) { + mergeContext.addConflict("mapper [" + names.fullName() + "] has different store_term_vector_payloads values"); } if (this.indexAnalyzer == null) { if (fieldMergeWith.indexAnalyzer != null) { @@ -486,6 +537,16 @@ public abstract class AbstractFieldMapper implements FieldMapper, Mapper { } } + protected static String indexTokenizeOptionToString(boolean indexed, boolean tokenized) { + if (!indexed) { + return "no"; + } else if (tokenized) { + return "analyzed"; + } else { + return "not_analyzed"; + } + } + protected void doXContentBody(XContentBuilder builder) throws IOException { builder.field("type", contentType()); if (!names.name().equals(names.indexNameClean())) { diff --git a/src/main/java/org/elasticsearch/index/mapper/core/BinaryFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/BinaryFieldMapper.java index b159364c018..c667c008bda 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/BinaryFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/BinaryFieldMapper.java @@ -20,8 +20,8 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; +import org.apache.lucene.util.BytesRef; import org.elasticsearch.ElasticSearchParseException; import org.elasticsearch.common.Base64; import org.elasticsearch.common.Strings; @@ -50,7 +50,12 @@ public class BinaryFieldMapper extends AbstractFieldMapper { public static class Defaults extends AbstractFieldMapper.Defaults { public static final long COMPRESS_THRESHOLD = -1; - public static final Field.Store STORE = Field.Store.YES; + public static final FieldType BINARY_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + BINARY_FIELD_TYPE.setStored(false); + BINARY_FIELD_TYPE.freeze(); + } } public static class Builder extends AbstractFieldMapper.Builder { @@ -60,8 +65,7 @@ public class BinaryFieldMapper extends AbstractFieldMapper { private long compressThreshold = Defaults.COMPRESS_THRESHOLD; public Builder(String name) { - super(name); - store = Defaults.STORE; + super(name, new FieldType(Defaults.BINARY_FIELD_TYPE)); builder = this; } @@ -82,7 +86,7 @@ public class BinaryFieldMapper extends AbstractFieldMapper { @Override public BinaryFieldMapper build(BuilderContext context) { - return new BinaryFieldMapper(buildNames(context), store, compress, compressThreshold); + return new BinaryFieldMapper(buildNames(context), fieldType, compress, compressThreshold); } } @@ -114,22 +118,22 @@ public class BinaryFieldMapper extends AbstractFieldMapper { private long compressThreshold; - protected BinaryFieldMapper(Names names, Field.Store store, Boolean compress, long compressThreshold) { - super(names, Field.Index.NO, store, Field.TermVector.NO, 1.0f, true, IndexOptions.DOCS_ONLY, null, null); + protected BinaryFieldMapper(Names names, FieldType fieldType, Boolean compress, long compressThreshold) { + super(names, 1.0f, fieldType, null, null); this.compress = compress; this.compressThreshold = compressThreshold; } @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return value(field); } @Override - public byte[] value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public byte[] value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { - return value; + return null; } try { return CompressorFactory.uncompressIfNeeded(new BytesArray(value)).toBytes(); @@ -149,7 +153,7 @@ public class BinaryFieldMapper extends AbstractFieldMapper { } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return null; } @@ -184,7 +188,7 @@ public class BinaryFieldMapper extends AbstractFieldMapper { if (value == null) { return null; } - return new Field(names.indexName(), value); + return new Field(names.indexName(), value, fieldType); } @Override diff --git a/src/main/java/org/elasticsearch/index/mapper/core/BooleanFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/BooleanFieldMapper.java index fceefaafbc1..405ca11df19 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/BooleanFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/BooleanFieldMapper.java @@ -20,8 +20,7 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.elasticsearch.common.Booleans; import org.elasticsearch.common.Strings; @@ -49,7 +48,12 @@ public class BooleanFieldMapper extends AbstractFieldMapper { public static final String CONTENT_TYPE = "boolean"; public static class Defaults extends AbstractFieldMapper.Defaults { - public static final boolean OMIT_NORMS = true; + public static final FieldType BOOLEAN_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + BOOLEAN_FIELD_TYPE.setOmitNorms(true); + BOOLEAN_FIELD_TYPE.freeze(); + } public static final Boolean NULL_VALUE = null; } @@ -58,8 +62,7 @@ public class BooleanFieldMapper extends AbstractFieldMapper { private Boolean nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); - this.omitNorms = Defaults.OMIT_NORMS; + super(name, new FieldType(Defaults.BOOLEAN_FIELD_TYPE)); this.builder = this; } @@ -69,18 +72,33 @@ public class BooleanFieldMapper extends AbstractFieldMapper { } @Override - public Builder index(Field.Index index) { + public Builder index(boolean index) { return super.index(index); } @Override - public Builder store(Field.Store store) { + public Builder store(boolean store) { return super.store(store); } @Override - public Builder termVector(Field.TermVector termVector) { - return super.termVector(termVector); + protected Builder storeTermVectors(boolean termVectors) { + return super.storeTermVectors(termVectors); + } + + @Override + protected Builder storeTermVectorOffsets(boolean termVectorOffsets) { + return super.storeTermVectorOffsets(termVectorOffsets); + } + + @Override + protected Builder storeTermVectorPositions(boolean termVectorPositions) { + return super.storeTermVectorPositions(termVectorPositions); + } + + @Override + protected Builder storeTermVectorPayloads(boolean termVectorPayloads) { + return super.storeTermVectorPayloads(termVectorPayloads); } @Override @@ -96,8 +114,7 @@ public class BooleanFieldMapper extends AbstractFieldMapper { @Override public BooleanFieldMapper build(BuilderContext context) { - return new BooleanFieldMapper(buildNames(context), index, store, - termVector, boost, omitNorms, indexOptions, nullValue); + return new BooleanFieldMapper(buildNames(context), boost, fieldType, nullValue); } } @@ -119,9 +136,8 @@ public class BooleanFieldMapper extends AbstractFieldMapper { private Boolean nullValue; - protected BooleanFieldMapper(Names names, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, Boolean nullValue) { - super(names, index, store, termVector, boost, omitNorms, indexOptions, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); + protected BooleanFieldMapper(Names names, float boost, FieldType fieldType, Boolean nullValue) { + super(names, boost, fieldType, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.nullValue = nullValue; } @@ -131,7 +147,7 @@ public class BooleanFieldMapper extends AbstractFieldMapper { } @Override - public Boolean value(Fieldable field) { + public Boolean value(Field field) { return field.stringValue().charAt(0) == 'T' ? Boolean.TRUE : Boolean.FALSE; } @@ -141,7 +157,7 @@ public class BooleanFieldMapper extends AbstractFieldMapper { } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return field.stringValue().charAt(0) == 'T' ? "true" : "false"; } @@ -184,7 +200,7 @@ public class BooleanFieldMapper extends AbstractFieldMapper { if (value == null) { return null; } - return new Field(names.indexName(), value, store, index, termVector); + return new Field(names.indexName(), value, fieldType); } @Override @@ -195,20 +211,30 @@ public class BooleanFieldMapper extends AbstractFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.BOOLEAN_FIELD_TYPE.indexed() || + analyzed() != Defaults.BOOLEAN_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.BOOLEAN_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.BOOLEAN_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.BOOLEAN_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.BOOLEAN_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.BOOLEAN_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.BOOLEAN_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.BOOLEAN_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (nullValue != null) { builder.field("null_value", nullValue); diff --git a/src/main/java/org/elasticsearch/index/mapper/core/ByteFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/ByteFieldMapper.java index a6acef2e02f..f665688e208 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/ByteFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/ByteFieldMapper.java @@ -19,14 +19,15 @@ package org.elasticsearch.index.mapper.core; +import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -56,6 +57,11 @@ public class ByteFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "byte"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType BYTE_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + BYTE_FIELD_TYPE.freeze(); + } public static final Byte NULL_VALUE = null; } @@ -64,7 +70,7 @@ public class ByteFieldMapper extends NumberFieldMapper { protected Byte nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.BYTE_FIELD_TYPE)); builder = this; } @@ -75,8 +81,9 @@ public class ByteFieldMapper extends NumberFieldMapper { @Override public ByteFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); ByteFieldMapper fieldMapper = new ByteFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, ignoreMalformed(context)); + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; } @@ -102,10 +109,9 @@ public class ByteFieldMapper extends NumberFieldMapper { private String nullValueAsString; - protected ByteFieldMapper(Names names, int precisionStep, String fuzzyFactor, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected ByteFieldMapper(Names names, int precisionStep, String fuzzyFactor, float boost, FieldType fieldType, Byte nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_byte/" + precisionStep, new NumericIntegerAnalyzer(precisionStep)), new NamedAnalyzer("_byte/max", new NumericIntegerAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -118,12 +124,12 @@ public class ByteFieldMapper extends NumberFieldMapper { } @Override - public Byte value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Byte value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return value[0]; + return value.bytes[value.offset]; } @Override @@ -133,7 +139,9 @@ public class ByteFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.intToPrefixCoded(Byte.parseByte(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.intToPrefixCoded(Byte.parseByte(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -216,7 +224,7 @@ public class ByteFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { byte value; float boost = this.boost; if (context.externalValueSet()) { @@ -282,7 +290,7 @@ public class ByteFieldMapper extends NumberFieldMapper { } } } - CustomByteNumericField field = new CustomByteNumericField(this, value); + CustomByteNumericField field = new CustomByteNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -312,20 +320,30 @@ public class ByteFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.BYTE_FIELD_TYPE.indexed() || + analyzed() != Defaults.BYTE_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.BYTE_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.BYTE_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.BYTE_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.BYTE_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.BYTE_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.BYTE_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.BYTE_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -347,15 +365,15 @@ public class ByteFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomByteNumericField(NumberFieldMapper mapper, byte number) { - super(mapper, mapper.stored() ? new byte[]{number} : null); + public CustomByteNumericField(NumberFieldMapper mapper, byte number, FieldType fieldType) { + super(mapper, mapper.stored() ? new byte[]{number} : null, fieldType); this.mapper = mapper; this.number = number; } @Override - public TokenStream tokenStreamValue() { - if (isIndexed) { + public TokenStream tokenStream(Analyzer analyzer) { + if (fieldType().indexed()) { return mapper.popCachedStream().setIntValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/DateFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/DateFieldMapper.java index 4ea4255548d..06bc083bf77 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/DateFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/DateFieldMapper.java @@ -20,12 +20,12 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -63,6 +63,12 @@ public class DateFieldMapper extends NumberFieldMapper { public static class Defaults extends NumberFieldMapper.Defaults { public static final FormatDateTimeFormatter DATE_TIME_FORMATTER = Joda.forPattern("dateOptionalTime"); + public static final FieldType DATE_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + DATE_FIELD_TYPE.freeze(); + } + public static final String NULL_VALUE = null; public static final TimeUnit TIME_UNIT = TimeUnit.MILLISECONDS; @@ -78,7 +84,7 @@ public class DateFieldMapper extends NumberFieldMapper { protected FormatDateTimeFormatter dateTimeFormatter = Defaults.DATE_TIME_FORMATTER; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.DATE_FIELD_TYPE)); builder = this; } @@ -103,8 +109,9 @@ public class DateFieldMapper extends NumberFieldMapper { if (context.indexSettings() != null) { parseUpperInclusive = context.indexSettings().getAsBoolean("index.mapping.date.parse_upper_inclusive", Defaults.PARSE_UPPER_INCLUSIVE); } + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); DateFieldMapper fieldMapper = new DateFieldMapper(buildNames(context), dateTimeFormatter, - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, timeUnit, parseUpperInclusive, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -142,10 +149,9 @@ public class DateFieldMapper extends NumberFieldMapper { protected final TimeUnit timeUnit; protected DateFieldMapper(Names names, FormatDateTimeFormatter dateTimeFormatter, int precisionStep, String fuzzyFactor, - Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + float boost, FieldType fieldType, String nullValue, TimeUnit timeUnit, boolean parseUpperInclusive, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_date/" + precisionStep, new NumericDateAnalyzer(precisionStep, dateTimeFormatter.parser())), new NamedAnalyzer("_date/max", new NumericDateAnalyzer(Integer.MAX_VALUE, dateTimeFormatter.parser()))); @@ -174,12 +180,12 @@ public class DateFieldMapper extends NumberFieldMapper { } @Override - public Long value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Long value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToLong(value); + return Numbers.bytesToLong(value.bytes); } @Override @@ -188,15 +194,15 @@ public class DateFieldMapper extends NumberFieldMapper { } /** - * Dates should return as a string, delegates to {@link #valueAsString(org.apache.lucene.document.Fieldable)}. + * Dates should return as a string. */ @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return valueAsString(field); } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { Long value = value(field); if (value == null) { return null; @@ -206,7 +212,9 @@ public class DateFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.longToPrefixCoded(dateTimeFormatter.parser().parseMillis(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.longToPrefixCoded(dateTimeFormatter.parser().parseMillis(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -297,7 +305,7 @@ public class DateFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { String dateAsString = null; Long value = null; float boost = this.boost; @@ -343,7 +351,7 @@ public class DateFieldMapper extends NumberFieldMapper { } if (value != null) { - LongFieldMapper.CustomLongNumericField field = new LongFieldMapper.CustomLongNumericField(this, timeUnit.toMillis(value)); + LongFieldMapper.CustomLongNumericField field = new LongFieldMapper.CustomLongNumericField(this, timeUnit.toMillis(value), fieldType); field.setBoost(boost); return field; } @@ -356,7 +364,7 @@ public class DateFieldMapper extends NumberFieldMapper { } value = parseStringValue(dateAsString); - LongFieldMapper.CustomLongNumericField field = new LongFieldMapper.CustomLongNumericField(this, value); + LongFieldMapper.CustomLongNumericField field = new LongFieldMapper.CustomLongNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -385,20 +393,30 @@ public class DateFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.DATE_FIELD_TYPE.indexed() || + analyzed() != Defaults.DATE_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.DATE_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.DATE_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.DATE_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.DATE_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.DATE_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.DATE_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.DATE_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); diff --git a/src/main/java/org/elasticsearch/index/mapper/core/DoubleFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/DoubleFieldMapper.java index 93f3b963a52..cded1df85b6 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/DoubleFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/DoubleFieldMapper.java @@ -21,12 +21,12 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -56,6 +56,11 @@ public class DoubleFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "double"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType DOUBLE_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + DOUBLE_FIELD_TYPE.freeze(); + } public static final Double NULL_VALUE = null; } @@ -64,7 +69,7 @@ public class DoubleFieldMapper extends NumberFieldMapper { protected Double nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.DOUBLE_FIELD_TYPE)); builder = this; } @@ -75,8 +80,9 @@ public class DoubleFieldMapper extends NumberFieldMapper { @Override public DoubleFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); DoubleFieldMapper fieldMapper = new DoubleFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -105,10 +111,9 @@ public class DoubleFieldMapper extends NumberFieldMapper { private String nullValueAsString; protected DoubleFieldMapper(Names names, int precisionStep, String fuzzyFactor, - Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + float boost, FieldType fieldType, Double nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_double/" + precisionStep, new NumericDoubleAnalyzer(precisionStep)), new NamedAnalyzer("_double/max", new NumericDoubleAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -121,12 +126,12 @@ public class DoubleFieldMapper extends NumberFieldMapper { } @Override - public Double value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Double value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToDouble(value); + return Numbers.bytesToDouble(value.bytes); } @Override @@ -136,7 +141,10 @@ public class DoubleFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.doubleToPrefixCoded(Double.parseDouble(value)); + long longValue = NumericUtils.doubleToSortableLong(Double.parseDouble(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.longToPrefixCoded(longValue, precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -218,7 +226,7 @@ public class DoubleFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { double value; float boost = this.boost; if (context.externalValueSet()) { @@ -285,7 +293,7 @@ public class DoubleFieldMapper extends NumberFieldMapper { } } - CustomDoubleNumericField field = new CustomDoubleNumericField(this, value); + CustomDoubleNumericField field = new CustomDoubleNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -315,20 +323,30 @@ public class DoubleFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.DOUBLE_FIELD_TYPE.indexed() || + analyzed() != Defaults.DOUBLE_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.DOUBLE_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.DOUBLE_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.DOUBLE_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.DOUBLE_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.DOUBLE_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.DOUBLE_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.DOUBLE_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -350,15 +368,15 @@ public class DoubleFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomDoubleNumericField(NumberFieldMapper mapper, double number) { - super(mapper, mapper.stored() ? Numbers.doubleToBytes(number) : null); + public CustomDoubleNumericField(NumberFieldMapper mapper, double number, FieldType fieldType) { + super(mapper, mapper.stored() ? Numbers.doubleToBytes(number) : null, fieldType); this.mapper = mapper; this.number = number; } @Override public TokenStream tokenStreamValue() { - if (isIndexed) { + if (fieldType().indexed()) { return mapper.popCachedStream().setDoubleValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/FloatFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/FloatFieldMapper.java index 71225c9a41e..820c8d894ef 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/FloatFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/FloatFieldMapper.java @@ -21,12 +21,13 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -57,6 +58,12 @@ public class FloatFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "float"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType FLOAT_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + FLOAT_FIELD_TYPE.freeze(); + } + public static final Float NULL_VALUE = null; } @@ -65,7 +72,7 @@ public class FloatFieldMapper extends NumberFieldMapper { protected Float nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.FLOAT_FIELD_TYPE)); builder = this; } @@ -76,8 +83,9 @@ public class FloatFieldMapper extends NumberFieldMapper { @Override public FloatFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); FloatFieldMapper fieldMapper = new FloatFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -104,10 +112,9 @@ public class FloatFieldMapper extends NumberFieldMapper { private String nullValueAsString; - protected FloatFieldMapper(Names names, int precisionStep, String fuzzyFactor, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected FloatFieldMapper(Names names, int precisionStep, String fuzzyFactor, float boost, FieldType fieldType, Float nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_float/" + precisionStep, new NumericFloatAnalyzer(precisionStep)), new NamedAnalyzer("_float/max", new NumericFloatAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -120,12 +127,12 @@ public class FloatFieldMapper extends NumberFieldMapper { } @Override - public Float value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Float value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToFloat(value); + return Numbers.bytesToFloat(value.bytes); } @Override @@ -135,7 +142,10 @@ public class FloatFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.floatToPrefixCoded(Float.parseFloat(value)); + int intValue = NumericUtils.floatToSortableInt(Float.parseFloat(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.intToPrefixCoded(intValue, precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -213,7 +223,7 @@ public class FloatFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { float value; float boost = this.boost; if (context.externalValueSet()) { @@ -280,7 +290,7 @@ public class FloatFieldMapper extends NumberFieldMapper { } } - CustomFloatNumericField field = new CustomFloatNumericField(this, value); + CustomFloatNumericField field = new CustomFloatNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -311,20 +321,30 @@ public class FloatFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.FLOAT_FIELD_TYPE.indexed() || + analyzed() != Defaults.FLOAT_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.FLOAT_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.FLOAT_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.FLOAT_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.FLOAT_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.FLOAT_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.FLOAT_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.FLOAT_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -346,15 +366,15 @@ public class FloatFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomFloatNumericField(NumberFieldMapper mapper, float number) { - super(mapper, mapper.stored() ? Numbers.floatToBytes(number) : null); + public CustomFloatNumericField(NumberFieldMapper mapper, float number, FieldType fieldType) { + super(mapper, mapper.stored() ? Numbers.floatToBytes(number) : null, fieldType); this.mapper = mapper; this.number = number; } @Override public TokenStream tokenStreamValue() { - if (isIndexed) { + if (fieldType().indexed()) { return mapper.popCachedStream().setFloatValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/IntegerFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/IntegerFieldMapper.java index 3ecb8a0f4be..c61355478e3 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/IntegerFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/IntegerFieldMapper.java @@ -21,12 +21,12 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -57,6 +57,12 @@ public class IntegerFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "integer"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType INTEGER_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + INTEGER_FIELD_TYPE.freeze(); + } + public static final Integer NULL_VALUE = null; } @@ -65,7 +71,7 @@ public class IntegerFieldMapper extends NumberFieldMapper { protected Integer nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.INTEGER_FIELD_TYPE)); builder = this; } @@ -76,8 +82,9 @@ public class IntegerFieldMapper extends NumberFieldMapper { @Override public IntegerFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); IntegerFieldMapper fieldMapper = new IntegerFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -104,10 +111,10 @@ public class IntegerFieldMapper extends NumberFieldMapper { private String nullValueAsString; - protected IntegerFieldMapper(Names names, int precisionStep, String fuzzyFactor, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected IntegerFieldMapper(Names names, int precisionStep, String fuzzyFactor, + float boost, FieldType fieldType, Integer nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_int/" + precisionStep, new NumericIntegerAnalyzer(precisionStep)), new NamedAnalyzer("_int/max", new NumericIntegerAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -120,12 +127,12 @@ public class IntegerFieldMapper extends NumberFieldMapper { } @Override - public Integer value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Integer value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToInt(value); + return Numbers.bytesToInt(value.bytes); } @Override @@ -135,7 +142,9 @@ public class IntegerFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.intToPrefixCoded(Integer.parseInt(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.intToPrefixCoded(Integer.parseInt(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -218,7 +227,7 @@ public class IntegerFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { int value; float boost = this.boost; if (context.externalValueSet()) { @@ -285,7 +294,7 @@ public class IntegerFieldMapper extends NumberFieldMapper { } } - CustomIntegerNumericField field = new CustomIntegerNumericField(this, value); + CustomIntegerNumericField field = new CustomIntegerNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -315,20 +324,30 @@ public class IntegerFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.INTEGER_FIELD_TYPE.indexed() || + analyzed() != Defaults.INTEGER_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.INTEGER_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.INTEGER_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.INTEGER_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.INTEGER_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.INTEGER_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.INTEGER_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.INTEGER_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -350,15 +369,15 @@ public class IntegerFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomIntegerNumericField(NumberFieldMapper mapper, int number) { - super(mapper, mapper.stored() ? Numbers.intToBytes(number) : null); + public CustomIntegerNumericField(NumberFieldMapper mapper, int number, FieldType fieldType) { + super(mapper, mapper.stored() ? Numbers.intToBytes(number) : null, fieldType); this.mapper = mapper; this.number = number; } @Override public TokenStream tokenStreamValue() { - if (isIndexed) { + if (fieldType().indexed()) { return mapper.popCachedStream().setIntValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/LongFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/LongFieldMapper.java index 40d35b528ad..f3348a05f39 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/LongFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/LongFieldMapper.java @@ -21,12 +21,13 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -57,6 +58,12 @@ public class LongFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "long"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType LONG_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + LONG_FIELD_TYPE.freeze(); + } + public static final Long NULL_VALUE = null; } @@ -65,7 +72,7 @@ public class LongFieldMapper extends NumberFieldMapper { protected Long nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.LONG_FIELD_TYPE)); builder = this; } @@ -76,8 +83,9 @@ public class LongFieldMapper extends NumberFieldMapper { @Override public LongFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); LongFieldMapper fieldMapper = new LongFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -104,10 +112,10 @@ public class LongFieldMapper extends NumberFieldMapper { private String nullValueAsString; - protected LongFieldMapper(Names names, int precisionStep, String fuzzyFactor, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected LongFieldMapper(Names names, int precisionStep, String fuzzyFactor, + float boost, FieldType fieldType, Long nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_long/" + precisionStep, new NumericLongAnalyzer(precisionStep)), new NamedAnalyzer("_long/max", new NumericLongAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -120,12 +128,12 @@ public class LongFieldMapper extends NumberFieldMapper { } @Override - public Long value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Long value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToLong(value); + return Numbers.bytesToLong(value.bytes); } @Override @@ -135,7 +143,9 @@ public class LongFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.longToPrefixCoded(Long.parseLong(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.longToPrefixCoded(Long.parseLong(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -218,7 +228,7 @@ public class LongFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { long value; float boost = this.boost; if (context.externalValueSet()) { @@ -284,7 +294,7 @@ public class LongFieldMapper extends NumberFieldMapper { } } } - CustomLongNumericField field = new CustomLongNumericField(this, value); + CustomLongNumericField field = new CustomLongNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -314,20 +324,30 @@ public class LongFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.LONG_FIELD_TYPE.indexed() || + analyzed() != Defaults.LONG_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.LONG_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.LONG_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.LONG_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.LONG_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.LONG_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.LONG_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.LONG_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -349,15 +369,15 @@ public class LongFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomLongNumericField(NumberFieldMapper mapper, long number) { - super(mapper, mapper.stored() ? Numbers.longToBytes(number) : null); + public CustomLongNumericField(NumberFieldMapper mapper, long number, FieldType fieldType) { + super(mapper, mapper.stored() ? Numbers.longToBytes(number) : null, fieldType); this.mapper = mapper; this.number = number; } @Override public TokenStream tokenStreamValue() { - if (isIndexed) { + if (fieldType().indexed()) { return mapper.popCachedStream().setLongValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/NumberFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/NumberFieldMapper.java index f9403d819ce..3d6909e5df6 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/NumberFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/NumberFieldMapper.java @@ -20,10 +20,8 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.NumericTokenStream; -import org.apache.lucene.document.AbstractField; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.Filter; import org.apache.lucene.search.Query; @@ -48,9 +46,17 @@ public abstract class NumberFieldMapper extends AbstractFieldM public static class Defaults extends AbstractFieldMapper.Defaults { public static final int PRECISION_STEP = NumericUtils.PRECISION_STEP_DEFAULT; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType NUMBER_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + NUMBER_FIELD_TYPE.setTokenized(false); + NUMBER_FIELD_TYPE.setOmitNorms(true); + NUMBER_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + NUMBER_FIELD_TYPE.setStoreTermVectors(false); + NUMBER_FIELD_TYPE.freeze(); + } + public static final String FUZZY_FACTOR = null; public static final Explicit IGNORE_MALFORMED = new Explicit(false, false); } @@ -63,15 +69,12 @@ public abstract class NumberFieldMapper extends AbstractFieldM private Boolean ignoreMalformed; - public Builder(String name) { - super(name); - this.index = Defaults.INDEX; - this.omitNorms = Defaults.OMIT_NORMS; - this.indexOptions = Defaults.INDEX_OPTIONS; + public Builder(String name, FieldType fieldType) { + super(name, fieldType); } @Override - public T store(Field.Store store) { + public T store(boolean store) { return super.store(store); } @@ -134,10 +137,10 @@ public abstract class NumberFieldMapper extends AbstractFieldM }; protected NumberFieldMapper(Names names, int precisionStep, @Nullable String fuzzyFactor, - Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + float boost, FieldType fieldType, Explicit ignoreMalformed, NamedAnalyzer indexAnalyzer, NamedAnalyzer searchAnalyzer) { - super(names, index, store, Field.TermVector.NO, boost, boost != 1.0f || omitNorms, indexOptions, indexAnalyzer, searchAnalyzer); + // LUCENE 4 UPGRADE: Since we can't do anything before the super call, we have to push the boost check down to subclasses + super(names, boost, fieldType, indexAnalyzer, searchAnalyzer); if (precisionStep <= 0 || precisionStep >= maxPrecisionStep()) { this.precisionStep = Integer.MAX_VALUE; } else { @@ -176,7 +179,7 @@ public abstract class NumberFieldMapper extends AbstractFieldM } @Override - protected Fieldable parseCreateField(ParseContext context) throws IOException { + protected Field parseCreateField(ParseContext context) throws IOException { RuntimeException e; try { return innerParseCreateField(context); @@ -193,7 +196,7 @@ public abstract class NumberFieldMapper extends AbstractFieldM } } - protected abstract Fieldable innerParseCreateField(ParseContext context) throws IOException; + protected abstract Field innerParseCreateField(ParseContext context) throws IOException; /** * Use the field query created here when matching on numbers. @@ -242,12 +245,12 @@ public abstract class NumberFieldMapper extends AbstractFieldM * Override the default behavior (to return the string, and return the actual Number instance). */ @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return value(field); } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { Number num = value(field); return num == null ? null : num.toString(); } @@ -283,28 +286,13 @@ public abstract class NumberFieldMapper extends AbstractFieldM } // used to we can use a numeric field in a document that is then parsed twice! - public abstract static class CustomNumericField extends AbstractField { + public abstract static class CustomNumericField extends Field { protected final NumberFieldMapper mapper; - public CustomNumericField(NumberFieldMapper mapper, byte[] value) { + public CustomNumericField(NumberFieldMapper mapper, byte[] value, FieldType fieldType) { + super(mapper.names().indexName(), value, fieldType); this.mapper = mapper; - this.name = mapper.names().indexName(); - fieldsData = value; - - isIndexed = mapper.indexed(); - isTokenized = mapper.indexed(); - indexOptions = FieldInfo.IndexOptions.DOCS_ONLY; - omitNorms = mapper.omitNorms(); - - if (value != null) { - isStored = true; - isBinary = true; - binaryLength = value.length; - binaryOffset = 0; - } - - setStoreTermVector(Field.TermVector.NO); } @Override diff --git a/src/main/java/org/elasticsearch/index/mapper/core/ShortFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/ShortFieldMapper.java index 237b8b08d25..83281a4bc00 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/ShortFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/ShortFieldMapper.java @@ -21,12 +21,13 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Nullable; @@ -57,6 +58,11 @@ public class ShortFieldMapper extends NumberFieldMapper { public static final String CONTENT_TYPE = "short"; public static class Defaults extends NumberFieldMapper.Defaults { + public static final FieldType SHORT_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + SHORT_FIELD_TYPE.freeze(); + } public static final Short NULL_VALUE = null; } @@ -65,7 +71,7 @@ public class ShortFieldMapper extends NumberFieldMapper { protected Short nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.SHORT_FIELD_TYPE)); builder = this; } @@ -76,8 +82,9 @@ public class ShortFieldMapper extends NumberFieldMapper { @Override public ShortFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); ShortFieldMapper fieldMapper = new ShortFieldMapper(buildNames(context), - precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, nullValue, + precisionStep, fuzzyFactor, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -104,10 +111,10 @@ public class ShortFieldMapper extends NumberFieldMapper { private String nullValueAsString; - protected ShortFieldMapper(Names names, int precisionStep, String fuzzyFactor, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected ShortFieldMapper(Names names, int precisionStep, String fuzzyFactor, + float boost, FieldType fieldType, Short nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, fuzzyFactor, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, fuzzyFactor, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_short/" + precisionStep, new NumericIntegerAnalyzer(precisionStep)), new NamedAnalyzer("_short/max", new NumericIntegerAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -120,12 +127,12 @@ public class ShortFieldMapper extends NumberFieldMapper { } @Override - public Short value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Short value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToShort(value); + return Numbers.bytesToShort(value.bytes); } @Override @@ -135,7 +142,9 @@ public class ShortFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.intToPrefixCoded(Short.parseShort(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.intToPrefixCoded(Short.parseShort(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -218,7 +227,7 @@ public class ShortFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { short value; float boost = this.boost; if (context.externalValueSet()) { @@ -284,7 +293,7 @@ public class ShortFieldMapper extends NumberFieldMapper { } } } - CustomShortNumericField field = new CustomShortNumericField(this, value); + CustomShortNumericField field = new CustomShortNumericField(this, value, fieldType); field.setBoost(boost); return field; } @@ -314,20 +323,30 @@ public class ShortFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.SHORT_FIELD_TYPE.indexed() || + analyzed() != Defaults.SHORT_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.SHORT_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.SHORT_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.SHORT_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.SHORT_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.SHORT_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.SHORT_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.SHORT_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); @@ -349,15 +368,15 @@ public class ShortFieldMapper extends NumberFieldMapper { private final NumberFieldMapper mapper; - public CustomShortNumericField(NumberFieldMapper mapper, short number) { - super(mapper, mapper.stored() ? Numbers.shortToBytes(number) : null); + public CustomShortNumericField(NumberFieldMapper mapper, short number, FieldType fieldType) { + super(mapper, mapper.stored() ? Numbers.shortToBytes(number) : null, fieldType); this.mapper = mapper; this.number = number; } @Override public TokenStream tokenStreamValue() { - if (isIndexed) { + if (fieldType().indexed()) { return mapper.popCachedStream().setIntValue(number); } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/core/StringFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/core/StringFieldMapper.java index 636d07e92d8..eb69e9b6757 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/StringFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/StringFieldMapper.java @@ -21,7 +21,7 @@ package org.elasticsearch.index.mapper.core; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.Filter; import org.elasticsearch.common.Strings; @@ -47,6 +47,12 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al public static final String CONTENT_TYPE = "string"; public static class Defaults extends AbstractFieldMapper.Defaults { + public static final FieldType STRING_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + STRING_FIELD_TYPE.freeze(); + } + // NOTE, when adding defaults here, make sure you add them in the builder public static final String NULL_VALUE = null; public static final int POSITION_OFFSET_GAP = 0; @@ -64,7 +70,7 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al protected int ignoreAbove = Defaults.IGNORE_ABOVE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.STRING_FIELD_TYPE)); builder = this; } @@ -113,16 +119,16 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al // if the field is not analyzed, then by default, we should omit norms and have docs only // index options, as probably what the user really wants // if they are set explicitly, we will use those values - if (index == Field.Index.NOT_ANALYZED) { + if (fieldType.indexed() && fieldType.tokenized()) { if (!omitNormsSet) { - omitNorms = true; + fieldType.setOmitNorms(true); } if (!indexOptionsSet) { - indexOptions = IndexOptions.DOCS_ONLY; + fieldType.setIndexOptions(IndexOptions.DOCS_ONLY); } } StringFieldMapper fieldMapper = new StringFieldMapper(buildNames(context), - index, store, termVector, boost, omitNorms, indexOptions, nullValue, + boost, fieldType, nullValue, indexAnalyzer, searchAnalyzer, searchQuotedAnalyzer, positionOffsetGap, ignoreAbove); fieldMapper.includeInAll(includeInAll); return fieldMapper; @@ -176,18 +182,16 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al private int ignoreAbove; - protected StringFieldMapper(Names names, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected StringFieldMapper(Names names, float boost, FieldType fieldType, String nullValue, NamedAnalyzer indexAnalyzer, NamedAnalyzer searchAnalyzer) { - this(names, index, store, termVector, boost, omitNorms, indexOptions, nullValue, indexAnalyzer, + this(names, boost, fieldType, nullValue, indexAnalyzer, searchAnalyzer, searchAnalyzer, Defaults.POSITION_OFFSET_GAP, Defaults.IGNORE_ABOVE); } - protected StringFieldMapper(Names names, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, + protected StringFieldMapper(Names names, float boost, FieldType fieldType, String nullValue, NamedAnalyzer indexAnalyzer, NamedAnalyzer searchAnalyzer, NamedAnalyzer searchQuotedAnalyzer, int positionOffsetGap, int ignoreAbove) { - super(names, index, store, termVector, boost, omitNorms, indexOptions, indexAnalyzer, searchAnalyzer); + super(names, boost, fieldType, indexAnalyzer, searchAnalyzer); this.nullValue = nullValue; this.positionOffsetGap = positionOffsetGap; this.searchQuotedAnalyzer = searchQuotedAnalyzer != null ? searchQuotedAnalyzer : this.searchAnalyzer; @@ -209,7 +213,7 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al } @Override - public String value(Fieldable field) { + public String value(Field field) { return field.stringValue(); } @@ -219,7 +223,7 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return value(field); } @@ -291,7 +295,7 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al context.ignoredValue(names.indexName(), value); return null; } - Field field = new Field(names.indexName(), false, value, store, index, termVector); + Field field = new Field(names.indexName(), value, fieldType); field.setBoost(boost); return field; } @@ -317,20 +321,30 @@ public class StringFieldMapper extends AbstractFieldMapper implements Al @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.STRING_FIELD_TYPE.indexed() || + analyzed() != Defaults.STRING_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.STRING_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.STRING_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.STRING_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.STRING_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.STRING_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.STRING_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.STRING_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (nullValue != null) { builder.field("null_value", nullValue); diff --git a/src/main/java/org/elasticsearch/index/mapper/core/TypeParsers.java b/src/main/java/org/elasticsearch/index/mapper/core/TypeParsers.java index 2bcdf14eec1..1ffd78d532c 100644 --- a/src/main/java/org/elasticsearch/index/mapper/core/TypeParsers.java +++ b/src/main/java/org/elasticsearch/index/mapper/core/TypeParsers.java @@ -19,8 +19,6 @@ package org.elasticsearch.index.mapper.core; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.Field.Index; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.elasticsearch.ElasticSearchParseException; import org.elasticsearch.common.Strings; @@ -68,11 +66,21 @@ public class TypeParsers { } else if (propName.equals("store")) { builder.store(parseStore(name, propNode.toString())); } else if (propName.equals("index")) { - builder.index(parseIndex(name, propNode.toString())); + parseIndex(name, propNode.toString(), builder); + } else if (propName.equals("tokenized")) { + builder.tokenized(nodeBooleanValue(propNode)); } else if (propName.equals("term_vector")) { - builder.termVector(parseTermVector(name, propNode.toString())); + parseTermVector(name, propNode.toString(), builder); } else if (propName.equals("boost")) { builder.boost(nodeFloatValue(propNode)); + } else if (propName.equals("store_term_vectors")) { + builder.storeTermVectors(nodeBooleanValue(propNode)); + } else if (propName.equals("store_term_vector_offsets")) { + builder.storeTermVectorOffsets(nodeBooleanValue(propNode)); + } else if (propName.equals("store_term_vector_positions")) { + builder.storeTermVectorPositions(nodeBooleanValue(propNode)); + } else if (propName.equals("store_term_vector_payloads")) { + builder.storeTermVectorPayloads(nodeBooleanValue(propNode)); } else if (propName.equals("omit_norms")) { builder.omitNorms(nodeBooleanValue(propNode)); } else if (propName.equals("omit_term_freq_and_positions")) { @@ -122,48 +130,46 @@ public class TypeParsers { return Joda.forPattern(node.toString()); } - public static Field.TermVector parseTermVector(String fieldName, String termVector) throws MapperParsingException { + public static void parseTermVector(String fieldName, String termVector, AbstractFieldMapper.Builder builder) throws MapperParsingException { termVector = Strings.toUnderscoreCase(termVector); if ("no".equals(termVector)) { - return Field.TermVector.NO; + builder.storeTermVectors(false); } else if ("yes".equals(termVector)) { - return Field.TermVector.YES; + builder.storeTermVectors(true); } else if ("with_offsets".equals(termVector)) { - return Field.TermVector.WITH_OFFSETS; + builder.storeTermVectorOffsets(true); } else if ("with_positions".equals(termVector)) { - return Field.TermVector.WITH_POSITIONS; + builder.storeTermVectorPositions(true); } else if ("with_positions_offsets".equals(termVector)) { - return Field.TermVector.WITH_POSITIONS_OFFSETS; + builder.storeTermVectorPositions(true); + builder.storeTermVectorOffsets(true); } else { throw new MapperParsingException("Wrong value for termVector [" + termVector + "] for field [" + fieldName + "]"); } } - public static Field.Index parseIndex(String fieldName, String index) throws MapperParsingException { + public static void parseIndex(String fieldName, String index, AbstractFieldMapper.Builder builder) throws MapperParsingException { index = Strings.toUnderscoreCase(index); if ("no".equals(index)) { - return Field.Index.NO; + builder.index(false); } else if ("not_analyzed".equals(index)) { - return Field.Index.NOT_ANALYZED; + builder.index(true); + builder.tokenized(false); } else if ("analyzed".equals(index)) { - return Field.Index.ANALYZED; + builder.index(true); + builder.tokenized(true); } else { throw new MapperParsingException("Wrong value for index [" + index + "] for field [" + fieldName + "]"); } } - public static Field.Store parseStore(String fieldName, String store) throws MapperParsingException { + public static boolean parseStore(String fieldName, String store) throws MapperParsingException { if ("no".equals(store)) { - return Field.Store.NO; + return false; } else if ("yes".equals(store)) { - return Field.Store.YES; + return true; } else { - boolean value = nodeBooleanValue(store); - if (value) { - return Field.Store.YES; - } else { - return Field.Store.NO; - } + return nodeBooleanValue(store); } } diff --git a/src/main/java/org/elasticsearch/index/mapper/geo/GeoShapeFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/geo/GeoShapeFieldMapper.java index a9782c6c2d3..880420a130b 100644 --- a/src/main/java/org/elasticsearch/index/mapper/geo/GeoShapeFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/geo/GeoShapeFieldMapper.java @@ -1,7 +1,7 @@ package org.elasticsearch.index.mapper.geo; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo; import org.elasticsearch.ElasticSearchIllegalArgumentException; import org.elasticsearch.common.Strings; @@ -55,6 +55,18 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { public static final int GEOHASH_LEVELS = GeohashPrefixTree.getMaxLevelsPossible(); public static final int QUADTREE_LEVELS = QuadPrefixTree.DEFAULT_MAX_LEVELS; public static final double DISTANCE_ERROR_PCT = 0.025d; + + public static final FieldType GEO_SHAPE_FIELD_TYPE = new FieldType(); + + static { + GEO_SHAPE_FIELD_TYPE.setIndexed(true); + GEO_SHAPE_FIELD_TYPE.setTokenized(false); + GEO_SHAPE_FIELD_TYPE.setStored(false); + GEO_SHAPE_FIELD_TYPE.setStoreTermVectors(false); + GEO_SHAPE_FIELD_TYPE.setOmitNorms(true); + GEO_SHAPE_FIELD_TYPE.setIndexOptions(FieldInfo.IndexOptions.DOCS_ONLY); + GEO_SHAPE_FIELD_TYPE.freeze(); + } } public static class Builder extends AbstractFieldMapper.Builder { @@ -66,7 +78,7 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { private SpatialPrefixTree prefixTree; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.GEO_SHAPE_FIELD_TYPE)); } public Builder tree(String tree) { @@ -96,7 +108,7 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { throw new ElasticSearchIllegalArgumentException("Unknown prefix tree type [" + tree + "]"); } - return new GeoShapeFieldMapper(buildNames(context), prefixTree, distanceErrorPct); + return new GeoShapeFieldMapper(buildNames(context), prefixTree, distanceErrorPct, fieldType); } } @@ -123,13 +135,13 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { private final SpatialStrategy spatialStrategy; - public GeoShapeFieldMapper(FieldMapper.Names names, SpatialPrefixTree prefixTree, double distanceErrorPct) { - super(names, Field.Index.NOT_ANALYZED, Field.Store.NO, Field.TermVector.NO, 1, true, FieldInfo.IndexOptions.DOCS_ONLY, null, null); + public GeoShapeFieldMapper(FieldMapper.Names names, SpatialPrefixTree prefixTree, double distanceErrorPct, FieldType fieldType) { + super(names, 1, fieldType, null, null); this.spatialStrategy = new TermQueryPrefixTreeStrategy(names, prefixTree, distanceErrorPct); } @Override - protected Fieldable parseCreateField(ParseContext context) throws IOException { + protected Field parseCreateField(ParseContext context) throws IOException { return spatialStrategy.createField(GeoJSONShapeParser.parse(context.parser())); } @@ -162,7 +174,7 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { } @Override - public String value(Fieldable field) { + public String value(Field field) { throw new UnsupportedOperationException("GeoShape fields cannot be converted to String values"); } @@ -172,7 +184,7 @@ public class GeoShapeFieldMapper extends AbstractFieldMapper { } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { throw new UnsupportedOperationException("GeoShape fields cannot be converted to String values"); } diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java index 85c88c7525b..9c9dd11858d 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java @@ -21,7 +21,6 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.index.Term; import org.apache.lucene.search.Query; @@ -195,7 +194,7 @@ public class AllFieldMapper extends AbstractFieldMapper implements Interna } @Override - protected Fieldable parseCreateField(ParseContext context) throws IOException { + protected Field parseCreateField(ParseContext context) throws IOException { if (!enabled) { return null; } @@ -229,7 +228,7 @@ public class AllFieldMapper extends AbstractFieldMapper implements Interna } @Override - public Void value(Fieldable field) { + public Void value(Field field) { return null; } @@ -239,12 +238,12 @@ public class AllFieldMapper extends AbstractFieldMapper implements Interna } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return null; } @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return null; } diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/BoostFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/BoostFieldMapper.java index 97ef611857f..21a0c7fdcf8 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/BoostFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/BoostFieldMapper.java @@ -20,12 +20,12 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; -import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.document.FieldType; import org.apache.lucene.search.Filter; import org.apache.lucene.search.NumericRangeFilter; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.Query; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.common.Nullable; import org.elasticsearch.common.Numbers; @@ -59,8 +59,13 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern public static class Defaults extends NumberFieldMapper.Defaults { public static final String NAME = "_boost"; public static final Float NULL_VALUE = null; - public static final Field.Index INDEX = Field.Index.NO; - public static final Field.Store STORE = Field.Store.NO; + + public static final FieldType BOOST_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + BOOST_FIELD_TYPE.setIndexed(false); + BOOST_FIELD_TYPE.setStored(false); + } } public static class Builder extends NumberFieldMapper.Builder { @@ -68,10 +73,8 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern protected Float nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.BOOST_FIELD_TYPE)); builder = this; - index = Defaults.INDEX; - store = Defaults.STORE; } public Builder nullValue(float nullValue) { @@ -82,7 +85,7 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern @Override public BoostFieldMapper build(BuilderContext context) { return new BoostFieldMapper(name, buildIndexName(context), - precisionStep, index, store, boost, omitNorms, indexOptions, nullValue); + precisionStep, boost, fieldType, nullValue); } } @@ -110,14 +113,12 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern } protected BoostFieldMapper(String name, String indexName) { - this(name, indexName, Defaults.PRECISION_STEP, Defaults.INDEX, Defaults.STORE, - Defaults.BOOST, Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Defaults.NULL_VALUE); + this(name, indexName, Defaults.PRECISION_STEP, Defaults.BOOST, new FieldType(Defaults.BOOST_FIELD_TYPE), Defaults.NULL_VALUE); } - protected BoostFieldMapper(String name, String indexName, int precisionStep, Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, - Float nullValue) { - super(new Names(name, indexName, indexName, name), precisionStep, null, index, store, boost, omitNorms, indexOptions, + protected BoostFieldMapper(String name, String indexName, int precisionStep, + float boost, FieldType fieldType, Float nullValue) { + super(new Names(name, indexName, indexName, name), precisionStep, null, boost, fieldType, Defaults.IGNORE_MALFORMED, new NamedAnalyzer("_float/" + precisionStep, new NumericFloatAnalyzer(precisionStep)), new NamedAnalyzer("_float/max", new NumericFloatAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -129,12 +130,12 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern } @Override - public Float value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Float value(Field field) { + BytesRef value = field.binaryValue(); if (value == null) { return null; } - return Numbers.bytesToFloat(value); + return Numbers.bytesToFloat(value.bytes); } @Override @@ -144,7 +145,10 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern @Override public String indexedValue(String value) { - return NumericUtils.floatToPrefixCoded(Float.parseFloat(value)); + int intValue = NumericUtils.floatToSortableInt(Float.parseFloat(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.intToPrefixCoded(intValue, precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -230,13 +234,13 @@ public class BoostFieldMapper extends NumberFieldMapper implements Intern } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { final float value = parseFloatValue(context); if (Float.isNaN(value)) { return null; } context.doc().setBoost(value); - return new FloatFieldMapper.CustomFloatNumericField(this, value); + return new FloatFieldMapper.CustomFloatNumericField(this, value, fieldType); } private float parseFloatValue(ParseContext context) throws IOException { diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java index d20b47dc267..58008e8314d 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java @@ -23,8 +23,9 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; +import org.apache.lucene.index.Term; import org.apache.lucene.search.*; import org.elasticsearch.common.Nullable; import org.elasticsearch.common.Strings; @@ -56,10 +57,17 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = IdFieldMapper.NAME; public static final String INDEX_NAME = IdFieldMapper.NAME; - public static final Field.Index INDEX = Field.Index.NO; - public static final Field.Store STORE = Field.Store.NO; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType ID_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + ID_FIELD_TYPE.setIndexed(false); + ID_FIELD_TYPE.setStored(false); + ID_FIELD_TYPE.setOmitNorms(true); + ID_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + ID_FIELD_TYPE.freeze(); + } + public static final String PATH = null; } @@ -68,12 +76,8 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern private String path = Defaults.PATH; public Builder() { - super(Defaults.NAME); + super(Defaults.NAME, new FieldType(Defaults.ID_FIELD_TYPE)); indexName = Defaults.INDEX_NAME; - store = Defaults.STORE; - index = Defaults.INDEX; - omitNorms = Defaults.OMIT_NORMS; - indexOptions = Defaults.INDEX_OPTIONS; } public Builder path(String path) { @@ -83,7 +87,7 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern @Override public IdFieldMapper build(BuilderContext context) { - return new IdFieldMapper(name, indexName, index, store, termVector, boost, omitNorms, indexOptions, path); + return new IdFieldMapper(name, indexName, boost, fieldType, path); } } @@ -106,21 +110,19 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern private final String path; public IdFieldMapper() { - this(Defaults.NAME, Defaults.INDEX_NAME, Defaults.INDEX); + this(Defaults.NAME, Defaults.INDEX_NAME, new FieldType(Defaults.ID_FIELD_TYPE)); } - public IdFieldMapper(Field.Index index) { - this(Defaults.NAME, Defaults.INDEX_NAME, index); + public IdFieldMapper(FieldType fieldType) { + this(Defaults.NAME, Defaults.INDEX_NAME, fieldType); } - protected IdFieldMapper(String name, String indexName, Field.Index index) { - this(name, indexName, index, Defaults.STORE, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Defaults.PATH); + protected IdFieldMapper(String name, String indexName, FieldType fieldType) { + this(name, indexName, Defaults.BOOST, fieldType, Defaults.PATH); } - protected IdFieldMapper(String name, String indexName, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, String path) { - super(new Names(name, indexName, indexName, name), index, store, termVector, boost, omitNorms, indexOptions, Lucene.KEYWORD_ANALYZER, + protected IdFieldMapper(String name, String indexName, float boost, FieldType fieldType, String path) { + super(new Names(name, indexName, indexName, name), boost, fieldType, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.path = path; } @@ -130,12 +132,12 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern } public String value(Document document) { - Fieldable field = document.getFieldable(names.indexName()); + Field field = (Field) document.getField(names.indexName()); return field == null ? null : value(field); } @Override - public String value(Fieldable field) { + public String value(Field field) { return field.stringValue(); } @@ -145,7 +147,7 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return value(field); } @@ -184,14 +186,14 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern } Collection queryTypes = context.queryTypes(); if (queryTypes.size() == 1) { - PrefixQuery prefixQuery = new PrefixQuery(UidFieldMapper.TERM_FACTORY.createTerm(Uid.createUid(Iterables.getFirst(queryTypes, null), value))); + PrefixQuery prefixQuery = new PrefixQuery(new Term(UidFieldMapper.NAME, Uid.createUid(Iterables.getFirst(queryTypes, null), value))); if (method != null) { prefixQuery.setRewriteMethod(method); } } BooleanQuery query = new BooleanQuery(); for (String queryType : queryTypes) { - PrefixQuery prefixQuery = new PrefixQuery(UidFieldMapper.TERM_FACTORY.createTerm(Uid.createUid(queryType, value))); + PrefixQuery prefixQuery = new PrefixQuery(new Term(UidFieldMapper.NAME, Uid.createUid(queryType, value))); if (method != null) { prefixQuery.setRewriteMethod(method); } @@ -207,11 +209,11 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern } Collection queryTypes = context.queryTypes(); if (queryTypes.size() == 1) { - return new PrefixFilter(UidFieldMapper.TERM_FACTORY.createTerm(Uid.createUid(Iterables.getFirst(queryTypes, null), value))); + return new PrefixFilter(new Term(UidFieldMapper.NAME, Uid.createUid(Iterables.getFirst(queryTypes, null), value))); } XBooleanFilter filter = new XBooleanFilter(); for (String queryType : queryTypes) { - filter.addShould(new PrefixFilter(UidFieldMapper.TERM_FACTORY.createTerm(Uid.createUid(queryType, value)))); + filter.addShould(new PrefixFilter(new Term(UidFieldMapper.NAME, Uid.createUid(queryType, value)))); } return filter; } @@ -256,16 +258,16 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern throw new MapperParsingException("Provided id [" + context.id() + "] does not match the content one [" + id + "]"); } context.id(id); - if (index == Field.Index.NO && store == Field.Store.NO) { + if (!fieldType.indexed() && !fieldType.stored()) { return null; } - return new Field(names.indexName(), false, context.id(), store, index, termVector); + return new Field(names.indexName(), context.id(), fieldType); } else { // we are in the pre/post parse phase - if (index == Field.Index.NO && store == Field.Store.NO) { + if (!fieldType.indexed() && !fieldType.stored()) { return null; } - return new Field(names.indexName(), false, context.id(), store, index, termVector); + return new Field(names.indexName(), context.id(), fieldType); } } @@ -277,15 +279,16 @@ public class IdFieldMapper extends AbstractFieldMapper implements Intern @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // if all are defaults, no sense to write it at all - if (store == Defaults.STORE && index == Defaults.INDEX && path == Defaults.PATH) { + if (fieldType.stored() == Defaults.ID_FIELD_TYPE.stored() && + fieldType.indexed() == Defaults.ID_FIELD_TYPE.indexed() && path == Defaults.PATH) { return builder; } builder.startObject(CONTENT_TYPE); - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (fieldType.stored() != Defaults.ID_FIELD_TYPE.stored()) { + builder.field("store", fieldType.stored()); } - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (fieldType.indexed() != Defaults.ID_FIELD_TYPE.indexed()) { + builder.field("index", fieldType.indexed()); } if (path != Defaults.PATH) { builder.field("path", path); diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java index f7765276a33..6b752125316 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java @@ -21,7 +21,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.Term; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.elasticsearch.common.Strings; @@ -48,10 +48,18 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = IndexFieldMapper.NAME; public static final String INDEX_NAME = IndexFieldMapper.NAME; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final Field.Store STORE = Field.Store.NO; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType INDEX_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + INDEX_FIELD_TYPE.setIndexed(true); + INDEX_FIELD_TYPE.setTokenized(false); + INDEX_FIELD_TYPE.setStored(false); + INDEX_FIELD_TYPE.setOmitNorms(true); + INDEX_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + INDEX_FIELD_TYPE.freeze(); + } + public static final boolean ENABLED = false; } @@ -60,12 +68,8 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int private boolean enabled = Defaults.ENABLED; public Builder() { - super(Defaults.NAME); + super(Defaults.NAME, new FieldType(Defaults.INDEX_FIELD_TYPE)); indexName = Defaults.INDEX_NAME; - index = Defaults.INDEX; - store = Defaults.STORE; - omitNorms = Defaults.OMIT_NORMS; - indexOptions = Defaults.INDEX_OPTIONS; } public Builder enabled(boolean enabled) { @@ -75,7 +79,7 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int @Override public IndexFieldMapper build(BuilderContext context) { - return new IndexFieldMapper(name, indexName, store, termVector, boost, omitNorms, indexOptions, enabled); + return new IndexFieldMapper(name, indexName, boost, fieldType, enabled); } } @@ -103,13 +107,11 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int } protected IndexFieldMapper(String name, String indexName) { - this(name, indexName, Defaults.STORE, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Defaults.ENABLED); + this(name, indexName, Defaults.BOOST, new FieldType(Defaults.INDEX_FIELD_TYPE), Defaults.ENABLED); } - public IndexFieldMapper(String name, String indexName, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions, boolean enabled) { - super(new Names(name, indexName, indexName, name), Defaults.INDEX, store, termVector, boost, omitNorms, indexOptions, Lucene.KEYWORD_ANALYZER, + public IndexFieldMapper(String name, String indexName, float boost, FieldType fieldType, boolean enabled) { + super(new Names(name, indexName, indexName, name), boost, fieldType, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.enabled = enabled; } @@ -119,12 +121,12 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int } public String value(Document document) { - Fieldable field = document.getFieldable(names.indexName()); + Field field = (Field) document.getField(names.indexName()); return field == null ? null : value(field); } @Override - public String value(Fieldable field) { + public String value(Field field) { return field.stringValue(); } @@ -134,7 +136,7 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return value(field); } @@ -176,7 +178,7 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int if (!enabled) { return null; } - return new Field(names.indexName(), context.index(), store, index); + return new Field(names.indexName(), context.index(), fieldType); } @Override @@ -187,12 +189,12 @@ public class IndexFieldMapper extends AbstractFieldMapper implements Int @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // if all defaults, no need to write it at all - if (store == Defaults.STORE && enabled == Defaults.ENABLED) { + if (stored() == Defaults.INDEX_FIELD_TYPE.stored() && enabled == Defaults.ENABLED) { return builder; } builder.startObject(CONTENT_TYPE); - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.INDEX_FIELD_TYPE.stored()) { + builder.field("store", stored()); } if (enabled != Defaults.ENABLED) { builder.field("enabled", enabled); diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java index e846a6e47ff..8ddac5397bd 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java @@ -20,7 +20,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.index.Term; import org.apache.lucene.search.ConstantScoreQuery; @@ -49,9 +49,17 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = ParentFieldMapper.NAME; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType PARENT_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + PARENT_FIELD_TYPE.setIndexed(true); + PARENT_FIELD_TYPE.setTokenized(false); + PARENT_FIELD_TYPE.setStored(true); + PARENT_FIELD_TYPE.setOmitNorms(true); + PARENT_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + PARENT_FIELD_TYPE.freeze(); + } } public static class Builder extends Mapper.Builder { @@ -97,8 +105,8 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter private final String type; protected ParentFieldMapper(String name, String indexName, String type) { - super(new Names(name, indexName, indexName, name), Defaults.INDEX, Field.Store.YES, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); + super(new Names(name, indexName, indexName, name), Defaults.BOOST, new FieldType(Defaults.PARENT_FIELD_TYPE), + Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.type = type; } @@ -130,7 +138,7 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter // we are in the parsing of _parent phase String parentId = context.parser().text(); context.sourceToParse().parent(parentId); - return new Field(names.indexName(), Uid.createUid(context.stringBuilder(), type, parentId), store, index); + return new Field(names.indexName(), Uid.createUid(context.stringBuilder(), type, parentId), fieldType); } // otherwise, we are running it post processing of the xcontent String parsedParentId = context.doc().get(Defaults.NAME); @@ -141,7 +149,7 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter throw new MapperParsingException("No parent id provided, not within the document, and not externally"); } // we did not add it in the parsing phase, add it now - return new Field(names.indexName(), Uid.createUid(context.stringBuilder(), type, parentId), store, index); + return new Field(names.indexName(), Uid.createUid(context.stringBuilder(), type, parentId), fieldType); } else if (parentId != null && !parsedParentId.equals(Uid.createUid(context.stringBuilder(), type, parentId))) { throw new MapperParsingException("Parent id mismatch, document value is [" + Uid.createUid(parsedParentId).id() + "], while external value is [" + parentId + "]"); } @@ -151,7 +159,7 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter } @Override - public Uid value(Fieldable field) { + public Uid value(Field field) { return Uid.createUid(field.stringValue()); } @@ -161,12 +169,12 @@ public class ParentFieldMapper extends AbstractFieldMapper implements Inter } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return field.stringValue(); } @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { String fieldValue = field.stringValue(); if (fieldValue == null) { return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/RoutingFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/RoutingFieldMapper.java index 8435027ac10..dabfdf34fbd 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/RoutingFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/RoutingFieldMapper.java @@ -21,7 +21,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.elasticsearch.common.Strings; import org.elasticsearch.common.lucene.Lucene; @@ -47,10 +47,18 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = "_routing"; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final Field.Store STORE = Field.Store.YES; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType ROUTING_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + ROUTING_FIELD_TYPE.setIndexed(true); + ROUTING_FIELD_TYPE.setTokenized(false); + ROUTING_FIELD_TYPE.setStored(true); + ROUTING_FIELD_TYPE.setOmitNorms(true); + ROUTING_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + ROUTING_FIELD_TYPE.freeze(); + } + public static final boolean REQUIRED = false; public static final String PATH = null; } @@ -62,9 +70,7 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I private String path = Defaults.PATH; public Builder() { - super(Defaults.NAME); - store = Defaults.STORE; - index = Defaults.INDEX; + super(Defaults.NAME, new FieldType(Defaults.ROUTING_FIELD_TYPE)); } public Builder required(boolean required) { @@ -79,7 +85,7 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I @Override public RoutingFieldMapper build(BuilderContext context) { - return new RoutingFieldMapper(store, index, required, path); + return new RoutingFieldMapper(fieldType, required, path); } } @@ -107,11 +113,11 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I private final String path; public RoutingFieldMapper() { - this(Defaults.STORE, Defaults.INDEX, Defaults.REQUIRED, Defaults.PATH); + this(new FieldType(Defaults.ROUTING_FIELD_TYPE), Defaults.REQUIRED, Defaults.PATH); } - protected RoutingFieldMapper(Field.Store store, Field.Index index, boolean required, String path) { - super(new Names(Defaults.NAME, Defaults.NAME, Defaults.NAME, Defaults.NAME), index, store, Defaults.TERM_VECTOR, 1.0f, Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Lucene.KEYWORD_ANALYZER, + protected RoutingFieldMapper(FieldType fieldType, boolean required, String path) { + super(new Names(Defaults.NAME, Defaults.NAME, Defaults.NAME, Defaults.NAME), 1.0f, fieldType, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.required = required; this.path = path; @@ -130,12 +136,12 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I } public String value(Document document) { - Fieldable field = document.getFieldable(names.indexName()); + Field field = (Field) document.getField(names.indexName()); return field == null ? null : value(field); } @Override - public String value(Fieldable field) { + public String value(Field field) { return field.stringValue(); } @@ -145,7 +151,7 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return value(field); } @@ -160,7 +166,7 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I if (path != null && routing != null) { // we have a path, check if we can validate we have the same routing value as the one in the doc... String value = null; - Fieldable field = context.doc().getFieldable(path); + Field field = (Field) context.doc().getField(path); if (field != null) { value = field.stringValue(); if (value == null) { @@ -209,7 +215,7 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I context.ignoredValue(names.indexName(), routing); return null; } - return new Field(names.indexName(), routing, store, index); + return new Field(names.indexName(), routing, fieldType); } } return null; @@ -224,15 +230,16 @@ public class RoutingFieldMapper extends AbstractFieldMapper implements I @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // if all are defaults, no sense to write it at all - if (index == Defaults.INDEX && store == Defaults.STORE && required == Defaults.REQUIRED && path == Defaults.PATH) { + if (indexed() == Defaults.ROUTING_FIELD_TYPE.indexed() && + stored() == Defaults.ROUTING_FIELD_TYPE.stored() && required == Defaults.REQUIRED && path == Defaults.PATH) { return builder; } builder.startObject(CONTENT_TYPE); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.ROUTING_FIELD_TYPE.indexed()) { + builder.field("index", indexed()); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.ROUTING_FIELD_TYPE.stored()) { + builder.field("store", stored()); } if (required != Defaults.REQUIRED) { builder.field("required", required); diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/SizeFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/SizeFieldMapper.java index de1fbb8a87f..b782af60542 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/SizeFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/SizeFieldMapper.java @@ -20,7 +20,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.elasticsearch.common.Strings; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.index.mapper.*; @@ -40,16 +40,23 @@ public class SizeFieldMapper extends IntegerFieldMapper implements RootMapper { public static class Defaults extends IntegerFieldMapper.Defaults { public static final String NAME = CONTENT_TYPE; public static final boolean ENABLED = false; + + public static final FieldType SIZE_FIELD_TYPE = new FieldType(IntegerFieldMapper.Defaults.INTEGER_FIELD_TYPE); + + static { + SIZE_FIELD_TYPE.freeze(); + } } public static class Builder extends Mapper.Builder { protected boolean enabled = Defaults.ENABLED; - protected Field.Store store = Defaults.STORE; + protected final FieldType fieldType; public Builder() { super(Defaults.NAME); + fieldType = new FieldType(Defaults.SIZE_FIELD_TYPE); builder = this; } @@ -58,14 +65,14 @@ public class SizeFieldMapper extends IntegerFieldMapper implements RootMapper { return builder; } - public Builder store(Field.Store store) { - this.store = store; + public Builder store(boolean store) { + this.fieldType.setStored(store); return builder; } @Override public SizeFieldMapper build(BuilderContext context) { - return new SizeFieldMapper(enabled, store); + return new SizeFieldMapper(enabled, fieldType); } } @@ -89,12 +96,12 @@ public class SizeFieldMapper extends IntegerFieldMapper implements RootMapper { private final boolean enabled; public SizeFieldMapper() { - this(Defaults.ENABLED, Defaults.STORE); + this(Defaults.ENABLED, new FieldType(Defaults.SIZE_FIELD_TYPE)); } - public SizeFieldMapper(boolean enabled, Field.Store store) { - super(new Names(Defaults.NAME), Defaults.PRECISION_STEP, Defaults.FUZZY_FACTOR, Defaults.INDEX, store, - Defaults.BOOST, Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Defaults.NULL_VALUE, + public SizeFieldMapper(boolean enabled, FieldType fieldType) { + super(new Names(Defaults.NAME), Defaults.PRECISION_STEP, Defaults.FUZZY_FACTOR, + Defaults.BOOST, fieldType, Defaults.NULL_VALUE, Defaults.IGNORE_MALFORMED); this.enabled = enabled; } @@ -133,28 +140,28 @@ public class SizeFieldMapper extends IntegerFieldMapper implements RootMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { if (!enabled) { return null; } if (context.flyweight()) { return null; } - return new CustomIntegerNumericField(this, context.source().length()); + return new CustomIntegerNumericField(this, context.source().length(), fieldType); } @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // all are defaults, no need to write it at all - if (enabled == Defaults.ENABLED && store == Defaults.STORE) { + if (enabled == Defaults.ENABLED && stored() == Defaults.SIZE_FIELD_TYPE.stored()) { return builder; } builder.startObject(contentType()); if (enabled != Defaults.ENABLED) { builder.field("enabled", enabled); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.SIZE_FIELD_TYPE.stored()) { + builder.field("store", stored()); } builder.endObject(); return builder; diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/SourceFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/SourceFieldMapper.java index b818f99b285..85f03491a53 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/SourceFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/SourceFieldMapper.java @@ -22,7 +22,8 @@ package org.elasticsearch.index.mapper.internal; import com.google.common.base.Objects; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; +import org.apache.lucene.document.StoredField; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.elasticsearch.ElasticSearchParseException; import org.elasticsearch.common.Strings; @@ -67,10 +68,17 @@ public class SourceFieldMapper extends AbstractFieldMapper implements In public static final boolean ENABLED = true; public static final long COMPRESS_THRESHOLD = -1; public static final String FORMAT = null; // default format is to use the one provided - public static final Field.Index INDEX = Field.Index.NO; - public static final Field.Store STORE = Field.Store.YES; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType SOURCE_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + SOURCE_FIELD_TYPE.setIndexed(false); + SOURCE_FIELD_TYPE.setStored(true); + SOURCE_FIELD_TYPE.setOmitNorms(true); + SOURCE_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + SOURCE_FIELD_TYPE.freeze(); + } + public static final String[] INCLUDES = Strings.EMPTY_ARRAY; public static final String[] EXCLUDES = Strings.EMPTY_ARRAY; } @@ -190,8 +198,7 @@ public class SourceFieldMapper extends AbstractFieldMapper implements In } protected SourceFieldMapper(String name, boolean enabled, String format, Boolean compress, long compressThreshold, String[] includes, String[] excludes) { - super(new Names(name, name, name, name), Defaults.INDEX, Defaults.STORE, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); + super(new Names(name, name, name, name), Defaults.BOOST, new FieldType(Defaults.SOURCE_FIELD_TYPE), Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); this.enabled = enabled; this.compress = compress; this.compressThreshold = compressThreshold; @@ -237,7 +244,7 @@ public class SourceFieldMapper extends AbstractFieldMapper implements In if (!enabled) { return null; } - if (store == Field.Store.NO) { + if (!stored()) { return null; } if (context.flyweight()) { @@ -335,21 +342,21 @@ public class SourceFieldMapper extends AbstractFieldMapper implements In } } assert source.hasArray(); - return new Field(names().indexName(), source.array(), source.arrayOffset(), source.length()); + return new StoredField(names().indexName(), source.array(), source.arrayOffset(), source.length()); } public byte[] value(Document document) { - Fieldable field = document.getFieldable(names.indexName()); + Field field = (Field) document.getField(names.indexName()); return field == null ? null : value(field); } - public byte[] nativeValue(Fieldable field) { - return field.getBinaryValue(); + public byte[] nativeValue(Field field) { + return field.binaryValue().bytes; } @Override - public byte[] value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public byte[] value(Field field) { + byte[] value = field.binaryValue().bytes; if (value == null) { return value; } @@ -366,7 +373,7 @@ public class SourceFieldMapper extends AbstractFieldMapper implements In } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { throw new UnsupportedOperationException(); } diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/TTLFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/TTLFieldMapper.java index 86bdc43775f..1f647fd2769 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/TTLFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/TTLFieldMapper.java @@ -20,7 +20,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Strings; import org.elasticsearch.common.unit.TimeValue; @@ -47,8 +47,16 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R public static class Defaults extends LongFieldMapper.Defaults { public static final String NAME = TTLFieldMapper.CONTENT_TYPE; - public static final Field.Store STORE = Field.Store.YES; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; + + public static final FieldType TTL_FIELD_TYPE = new FieldType(LongFieldMapper.Defaults.LONG_FIELD_TYPE); + + static { + TTL_FIELD_TYPE.setStored(true); + TTL_FIELD_TYPE.setIndexed(true); + TTL_FIELD_TYPE.setTokenized(false); + TTL_FIELD_TYPE.freeze(); + } + public static final boolean ENABLED = false; public static final long DEFAULT = -1; } @@ -59,9 +67,7 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R private long defaultTTL = Defaults.DEFAULT; public Builder() { - super(Defaults.NAME); - store = Defaults.STORE; - index = Defaults.INDEX; + super(Defaults.NAME, new FieldType(Defaults.TTL_FIELD_TYPE)); } public Builder enabled(boolean enabled) { @@ -76,7 +82,7 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R @Override public TTLFieldMapper build(BuilderContext context) { - return new TTLFieldMapper(store, index, enabled, defaultTTL, ignoreMalformed(context)); + return new TTLFieldMapper(fieldType, enabled, defaultTTL, ignoreMalformed(context)); } } @@ -105,12 +111,12 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R private long defaultTTL; public TTLFieldMapper() { - this(Defaults.STORE, Defaults.INDEX, Defaults.ENABLED, Defaults.DEFAULT, Defaults.IGNORE_MALFORMED); + this(new FieldType(Defaults.TTL_FIELD_TYPE), Defaults.ENABLED, Defaults.DEFAULT, Defaults.IGNORE_MALFORMED); } - protected TTLFieldMapper(Field.Store store, Field.Index index, boolean enabled, long defaultTTL, Explicit ignoreMalformed) { + protected TTLFieldMapper(FieldType fieldType, boolean enabled, long defaultTTL, Explicit ignoreMalformed) { super(new Names(Defaults.NAME, Defaults.NAME, Defaults.NAME, Defaults.NAME), Defaults.PRECISION_STEP, - Defaults.FUZZY_FACTOR, index, store, Defaults.BOOST, Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, + Defaults.FUZZY_FACTOR, Defaults.BOOST, fieldType, Defaults.NULL_VALUE, ignoreMalformed); this.enabled = enabled; this.defaultTTL = defaultTTL; @@ -126,7 +132,7 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R // Overrides valueForSearch to display live value of remaining ttl @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { long now; SearchContext searchContext = SearchContext.current(); if (searchContext != null) { @@ -178,7 +184,7 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException, AlreadyExpiredException { + protected Field innerParseCreateField(ParseContext context) throws IOException, AlreadyExpiredException { if (enabled) { long ttl = context.sourceToParse().ttl(); if (ttl <= 0 && defaultTTL > 0) { // no ttl provided so we use the default value @@ -194,7 +200,7 @@ public class TTLFieldMapper extends LongFieldMapper implements InternalMapper, R throw new AlreadyExpiredException(context.index(), context.type(), context.id(), timestamp, ttl, now); } // the expiration timestamp (timestamp + ttl) is set as field - return new CustomLongNumericField(this, expire); + return new CustomLongNumericField(this, expire, fieldType); } } return null; diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/TimestampFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/TimestampFieldMapper.java index 9c6ce847168..7cfd91ad77f 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/TimestampFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/TimestampFieldMapper.java @@ -20,7 +20,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.elasticsearch.common.Explicit; import org.elasticsearch.common.Strings; import org.elasticsearch.common.joda.FormatDateTimeFormatter; @@ -50,8 +50,16 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap public static class Defaults extends DateFieldMapper.Defaults { public static final String NAME = "_timestamp"; - public static final Field.Store STORE = Field.Store.NO; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; + + public static final FieldType TIMESTAMP_FIELD_TYPE = new FieldType(DateFieldMapper.Defaults.DATE_FIELD_TYPE); + + static { + TIMESTAMP_FIELD_TYPE.setStored(false); + TIMESTAMP_FIELD_TYPE.setIndexed(true); + TIMESTAMP_FIELD_TYPE.setTokenized(false); + TIMESTAMP_FIELD_TYPE.freeze(); + } + public static final boolean ENABLED = false; public static final String PATH = null; public static final FormatDateTimeFormatter DATE_TIME_FORMATTER = Joda.forPattern(DEFAULT_DATE_TIME_FORMAT); @@ -64,9 +72,7 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap private FormatDateTimeFormatter dateTimeFormatter = Defaults.DATE_TIME_FORMATTER; public Builder() { - super(Defaults.NAME); - store = Defaults.STORE; - index = Defaults.INDEX; + super(Defaults.NAME, new FieldType(Defaults.TIMESTAMP_FIELD_TYPE)); } public Builder enabled(boolean enabled) { @@ -90,7 +96,7 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap if (context.indexSettings() != null) { parseUpperInclusive = context.indexSettings().getAsBoolean("index.mapping.date.parse_upper_inclusive", Defaults.PARSE_UPPER_INCLUSIVE); } - return new TimestampFieldMapper(store, index, enabled, path, dateTimeFormatter, parseUpperInclusive, ignoreMalformed(context)); + return new TimestampFieldMapper(fieldType, enabled, path, dateTimeFormatter, parseUpperInclusive, ignoreMalformed(context)); } } @@ -120,13 +126,13 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap private final String path; public TimestampFieldMapper() { - this(Defaults.STORE, Defaults.INDEX, Defaults.ENABLED, Defaults.PATH, Defaults.DATE_TIME_FORMATTER, Defaults.PARSE_UPPER_INCLUSIVE, Defaults.IGNORE_MALFORMED); + this(new FieldType(Defaults.TIMESTAMP_FIELD_TYPE), Defaults.ENABLED, Defaults.PATH, Defaults.DATE_TIME_FORMATTER, Defaults.PARSE_UPPER_INCLUSIVE, Defaults.IGNORE_MALFORMED); } - protected TimestampFieldMapper(Field.Store store, Field.Index index, boolean enabled, String path, + protected TimestampFieldMapper(FieldType fieldType, boolean enabled, String path, FormatDateTimeFormatter dateTimeFormatter, boolean parseUpperInclusive, Explicit ignoreMalformed) { super(new Names(Defaults.NAME, Defaults.NAME, Defaults.NAME, Defaults.NAME), dateTimeFormatter, - Defaults.PRECISION_STEP, Defaults.FUZZY_FACTOR, index, store, Defaults.BOOST, Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, + Defaults.PRECISION_STEP, Defaults.FUZZY_FACTOR, Defaults.BOOST, fieldType, Defaults.NULL_VALUE, TimeUnit.MILLISECONDS /*always milliseconds*/, parseUpperInclusive, ignoreMalformed); this.enabled = enabled; @@ -149,12 +155,12 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap * Override the default behavior to return a timestamp */ @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return value(field); } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { Long value = value(field); if (value == null) { return null; @@ -186,14 +192,14 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { if (enabled) { long timestamp = context.sourceToParse().timestamp(); if (!indexed() && !stored()) { context.ignoredValue(names.indexName(), String.valueOf(timestamp)); return null; } - return new LongFieldMapper.CustomLongNumericField(this, timestamp); + return new LongFieldMapper.CustomLongNumericField(this, timestamp, fieldType); } return null; } @@ -206,16 +212,17 @@ public class TimestampFieldMapper extends DateFieldMapper implements InternalMap @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // if all are defaults, no sense to write it at all - if (index == Defaults.INDEX && store == Defaults.STORE && enabled == Defaults.ENABLED && path == Defaults.PATH + if (indexed() == Defaults.TIMESTAMP_FIELD_TYPE.indexed() && + stored() == Defaults.TIMESTAMP_FIELD_TYPE.stored() && enabled == Defaults.ENABLED && path == Defaults.PATH && dateTimeFormatter.format().equals(Defaults.DATE_TIME_FORMATTER.format())) { return builder; } builder.startObject(CONTENT_TYPE); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.TIMESTAMP_FIELD_TYPE.indexed()) { + builder.field("index", indexed()); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.TIMESTAMP_FIELD_TYPE.stored()) { + builder.field("store", stored()); } if (enabled != Defaults.ENABLED) { builder.field("enabled", enabled); diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java index 59d232bfec8..55c5ae5916d 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java @@ -21,7 +21,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.index.Term; import org.apache.lucene.search.DeletionAwareConstantScoreQuery; @@ -56,26 +56,29 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = TypeFieldMapper.NAME; public static final String INDEX_NAME = TypeFieldMapper.NAME; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final Field.Store STORE = Field.Store.NO; - public static final boolean OMIT_NORMS = true; - public static final IndexOptions INDEX_OPTIONS = IndexOptions.DOCS_ONLY; + + public static final FieldType TYPE_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + TYPE_FIELD_TYPE.setIndexed(true); + TYPE_FIELD_TYPE.setTokenized(false); + TYPE_FIELD_TYPE.setStored(false); + TYPE_FIELD_TYPE.setOmitNorms(true); + TYPE_FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_ONLY); + TYPE_FIELD_TYPE.freeze(); + } } public static class Builder extends AbstractFieldMapper.Builder { public Builder() { - super(Defaults.NAME); + super(Defaults.NAME, new FieldType(Defaults.TYPE_FIELD_TYPE)); indexName = Defaults.INDEX_NAME; - index = Defaults.INDEX; - store = Defaults.STORE; - omitNorms = Defaults.OMIT_NORMS; - indexOptions = Defaults.INDEX_OPTIONS; } @Override public TypeFieldMapper build(BuilderContext context) { - return new TypeFieldMapper(name, indexName, index, store, termVector, boost, omitNorms, indexOptions); + return new TypeFieldMapper(name, indexName, boost, fieldType); } } @@ -94,23 +97,21 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte } protected TypeFieldMapper(String name, String indexName) { - this(name, indexName, Defaults.INDEX, Defaults.STORE, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS); + this(name, indexName, Defaults.BOOST, new FieldType(Defaults.TYPE_FIELD_TYPE)); } - public TypeFieldMapper(String name, String indexName, Field.Index index, Field.Store store, Field.TermVector termVector, - float boost, boolean omitNorms, IndexOptions indexOptions) { - super(new Names(name, indexName, indexName, name), index, store, termVector, boost, omitNorms, indexOptions, Lucene.KEYWORD_ANALYZER, + public TypeFieldMapper(String name, String indexName, float boost, FieldType fieldType) { + super(new Names(name, indexName, indexName, name), boost, fieldType, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); } public String value(Document document) { - Fieldable field = document.getFieldable(names.indexName()); + Field field = (Field) document.getField(names.indexName()); return field == null ? null : value(field); } @Override - public String value(Fieldable field) { + public String value(Field field) { return field.stringValue(); } @@ -120,7 +121,7 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return value(field); } @@ -135,8 +136,8 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte @Override public Filter fieldFilter(String value, @Nullable QueryParseContext context) { - if (index == Field.Index.NO) { - return new PrefixFilter(UidFieldMapper.TERM_FACTORY.createTerm(Uid.typePrefix(value))); + if (!indexed()) { + return new PrefixFilter(new Term(UidFieldMapper.NAME, Uid.typePrefix(value))); } return new TermFilter(names().createIndexNameTerm(value)); } @@ -176,10 +177,10 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte @Override protected Field parseCreateField(ParseContext context) throws IOException { - if (index == Field.Index.NO && store == Field.Store.NO) { + if (!indexed() && !stored()) { return null; } - return new Field(names.indexName(), false, context.type(), store, index, termVector); + return new Field(names.indexName(), context.type(), fieldType); } @Override @@ -190,15 +191,15 @@ public class TypeFieldMapper extends AbstractFieldMapper implements Inte @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { // if all are defaults, no sense to write it at all - if (store == Defaults.STORE && index == Defaults.INDEX) { + if (stored() == Defaults.TYPE_FIELD_TYPE.stored() && indexed() == Defaults.TYPE_FIELD_TYPE.indexed()) { return builder; } builder.startObject(CONTENT_TYPE); - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.TYPE_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.TYPE_FIELD_TYPE.indexed()) { + builder.field("index", indexed()); } builder.endObject(); return builder; diff --git a/src/main/java/org/elasticsearch/index/mapper/internal/UidFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/internal/UidFieldMapper.java index fca40d673ae..c821eb51b57 100644 --- a/src/main/java/org/elasticsearch/index/mapper/internal/UidFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/internal/UidFieldMapper.java @@ -20,7 +20,7 @@ package org.elasticsearch.index.mapper.internal; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.document.FieldType; import org.apache.lucene.index.FieldInfo; import org.apache.lucene.index.Term; import org.elasticsearch.common.lucene.Lucene; @@ -47,9 +47,17 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal public static class Defaults extends AbstractFieldMapper.Defaults { public static final String NAME = UidFieldMapper.NAME; - public static final Field.Index INDEX = Field.Index.NOT_ANALYZED; - public static final boolean OMIT_NORMS = true; - public static final FieldInfo.IndexOptions INDEX_OPTIONS = FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS; // we store payload (otherwise, we really need just docs) + + public static final FieldType UID_FIELD_TYPE = new FieldType(AbstractFieldMapper.Defaults.FIELD_TYPE); + + static { + UID_FIELD_TYPE.setIndexed(true); + UID_FIELD_TYPE.setTokenized(false); + UID_FIELD_TYPE.setStored(true); + UID_FIELD_TYPE.setOmitNorms(true); + UID_FIELD_TYPE.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS); // we store payload (otherwise, we really need just docs) + UID_FIELD_TYPE.freeze(); + } } public static class Builder extends Mapper.Builder { @@ -90,8 +98,8 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal } protected UidFieldMapper(String name, String indexName) { - super(new Names(name, indexName, indexName, name), Defaults.INDEX, Field.Store.YES, Defaults.TERM_VECTOR, Defaults.BOOST, - Defaults.OMIT_NORMS, Defaults.INDEX_OPTIONS, Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); + super(new Names(name, indexName, indexName, name), Defaults.BOOST, new FieldType(Defaults.UID_FIELD_TYPE), + Lucene.KEYWORD_ANALYZER, Lucene.KEYWORD_ANALYZER); } @Override @@ -115,7 +123,7 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal // since we did not have the uid in the pre phase, we did not add it automatically to the nested docs // as they were created we need to make sure we add it to all the nested docs... if (context.docs().size() > 1) { - UidField uidField = (UidField) context.rootDoc().getFieldable(UidFieldMapper.NAME); + UidField uidField = (UidField) context.rootDoc().getField(UidFieldMapper.NAME); assert uidField != null; // we need to go over the docs and add it... for (int i = 1; i < context.docs().size(); i++) { @@ -141,7 +149,7 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal } @Override - protected Fieldable parseCreateField(ParseContext context) throws IOException { + protected Field parseCreateField(ParseContext context) throws IOException { context.uid(Uid.createUid(context.stringBuilder(), context.type(), context.id())); // so, caching uid stream and field is fine // since we don't do any mapping parsing without immediate indexing @@ -152,7 +160,7 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal } @Override - public Uid value(Fieldable field) { + public Uid value(Field field) { return Uid.createUid(field.stringValue()); } @@ -162,7 +170,7 @@ public class UidFieldMapper extends AbstractFieldMapper implements Internal } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { return field.stringValue(); } diff --git a/src/main/java/org/elasticsearch/index/mapper/ip/IpFieldMapper.java b/src/main/java/org/elasticsearch/index/mapper/ip/IpFieldMapper.java index 5cf1ebdacc4..7ec2d05aa1e 100644 --- a/src/main/java/org/elasticsearch/index/mapper/ip/IpFieldMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/ip/IpFieldMapper.java @@ -21,9 +21,11 @@ package org.elasticsearch.index.mapper.ip; import org.apache.lucene.analysis.NumericTokenStream; import org.apache.lucene.document.Field; +import org.apache.lucene.document.FieldType; import org.apache.lucene.document.Fieldable; import org.apache.lucene.index.FieldInfo.IndexOptions; import org.apache.lucene.search.*; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.NumericUtils; import org.elasticsearch.ElasticSearchIllegalArgumentException; import org.elasticsearch.common.Explicit; @@ -86,6 +88,12 @@ public class IpFieldMapper extends NumberFieldMapper { public static class Defaults extends NumberFieldMapper.Defaults { public static final String NULL_VALUE = null; + + public static final FieldType IP_FIELD_TYPE = new FieldType(NumberFieldMapper.Defaults.NUMBER_FIELD_TYPE); + + static { + IP_FIELD_TYPE.freeze(); + } } public static class Builder extends NumberFieldMapper.Builder { @@ -93,7 +101,7 @@ public class IpFieldMapper extends NumberFieldMapper { protected String nullValue = Defaults.NULL_VALUE; public Builder(String name) { - super(name); + super(name, new FieldType(Defaults.IP_FIELD_TYPE)); builder = this; } @@ -104,8 +112,9 @@ public class IpFieldMapper extends NumberFieldMapper { @Override public IpFieldMapper build(BuilderContext context) { + fieldType.setOmitNorms(fieldType.omitNorms() || boost != 1.0f); IpFieldMapper fieldMapper = new IpFieldMapper(buildNames(context), - precisionStep, index, store, boost, omitNorms, indexOptions, nullValue, ignoreMalformed(context)); + precisionStep, boost, fieldType, nullValue, ignoreMalformed(context)); fieldMapper.includeInAll(includeInAll); return fieldMapper; } @@ -130,10 +139,9 @@ public class IpFieldMapper extends NumberFieldMapper { private String nullValue; protected IpFieldMapper(Names names, int precisionStep, - Field.Index index, Field.Store store, - float boost, boolean omitNorms, IndexOptions indexOptions, + float boost, FieldType fieldType, String nullValue, Explicit ignoreMalformed) { - super(names, precisionStep, null, index, store, boost, omitNorms, indexOptions, + super(names, precisionStep, null, boost, fieldType, ignoreMalformed, new NamedAnalyzer("_ip/" + precisionStep, new NumericIpAnalyzer(precisionStep)), new NamedAnalyzer("_ip/max", new NumericIpAnalyzer(Integer.MAX_VALUE))); this.nullValue = nullValue; @@ -145,8 +153,8 @@ public class IpFieldMapper extends NumberFieldMapper { } @Override - public Long value(Fieldable field) { - byte[] value = field.getBinaryValue(); + public Long value(Field field) { + byte[] value = field.binaryValue().bytes; if (value == null) { return null; } @@ -159,15 +167,15 @@ public class IpFieldMapper extends NumberFieldMapper { } /** - * IPs should return as a string, delegates to {@link #valueAsString(org.apache.lucene.document.Fieldable)}. + * IPs should return as a string. */ @Override - public Object valueForSearch(Fieldable field) { + public Object valueForSearch(Field field) { return valueAsString(field); } @Override - public String valueAsString(Fieldable field) { + public String valueAsString(Field field) { Long value = value(field); if (value == null) { return null; @@ -177,7 +185,9 @@ public class IpFieldMapper extends NumberFieldMapper { @Override public String indexedValue(String value) { - return NumericUtils.longToPrefixCoded(ipToLong(value)); + BytesRef bytesRef = new BytesRef(); + NumericUtils.longToPrefixCoded(ipToLong(value), precisionStep(), bytesRef); + return bytesRef.utf8ToString(); } @Override @@ -241,7 +251,7 @@ public class IpFieldMapper extends NumberFieldMapper { } @Override - protected Fieldable innerParseCreateField(ParseContext context) throws IOException { + protected Field innerParseCreateField(ParseContext context) throws IOException { String ipAsString; if (context.externalValueSet()) { ipAsString = (String) context.externalValue(); @@ -264,7 +274,7 @@ public class IpFieldMapper extends NumberFieldMapper { } final long value = ipToLong(ipAsString); - return new LongFieldMapper.CustomLongNumericField(this, value); + return new LongFieldMapper.CustomLongNumericField(this, value, fieldType); } @Override @@ -291,20 +301,30 @@ public class IpFieldMapper extends NumberFieldMapper { @Override protected void doXContentBody(XContentBuilder builder) throws IOException { super.doXContentBody(builder); - if (index != Defaults.INDEX) { - builder.field("index", index.name().toLowerCase()); + if (indexed() != Defaults.IP_FIELD_TYPE.indexed() || + analyzed() != Defaults.IP_FIELD_TYPE.tokenized()) { + builder.field("index", indexTokenizeOptionToString(indexed(), analyzed())); } - if (store != Defaults.STORE) { - builder.field("store", store.name().toLowerCase()); + if (stored() != Defaults.IP_FIELD_TYPE.stored()) { + builder.field("store", stored()); } - if (termVector != Defaults.TERM_VECTOR) { - builder.field("term_vector", termVector.name().toLowerCase()); + if (storeTermVectors() != Defaults.IP_FIELD_TYPE.storeTermVectors()) { + builder.field("store_term_vector", storeTermVectors()); } - if (omitNorms != Defaults.OMIT_NORMS) { - builder.field("omit_norms", omitNorms); + if (storeTermVectorOffsets() != Defaults.IP_FIELD_TYPE.storeTermVectorOffsets()) { + builder.field("store_term_vector_offsets", storeTermVectorOffsets()); } - if (indexOptions != Defaults.INDEX_OPTIONS) { - builder.field("index_options", indexOptionToString(indexOptions)); + if (storeTermVectorPositions() != Defaults.IP_FIELD_TYPE.storeTermVectorPositions()) { + builder.field("store_term_vector_positions", storeTermVectorPositions()); + } + if (storeTermVectorPayloads() != Defaults.IP_FIELD_TYPE.storeTermVectorPayloads()) { + builder.field("store_term_vector_payloads", storeTermVectorPayloads()); + } + if (omitNorms() != Defaults.IP_FIELD_TYPE.omitNorms()) { + builder.field("omit_norms", omitNorms()); + } + if (indexOptions() != Defaults.IP_FIELD_TYPE.indexOptions()) { + builder.field("index_options", indexOptionToString(indexOptions())); } if (precisionStep != Defaults.PRECISION_STEP) { builder.field("precision_step", precisionStep); diff --git a/src/main/java/org/elasticsearch/index/mapper/object/ObjectMapper.java b/src/main/java/org/elasticsearch/index/mapper/object/ObjectMapper.java index b44353dda87..c64acbcdd86 100644 --- a/src/main/java/org/elasticsearch/index/mapper/object/ObjectMapper.java +++ b/src/main/java/org/elasticsearch/index/mapper/object/ObjectMapper.java @@ -22,7 +22,8 @@ package org.elasticsearch.index.mapper.object; import com.google.common.collect.ImmutableMap; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; -import org.apache.lucene.document.Fieldable; +import org.apache.lucene.index.IndexableField; +import org.apache.lucene.index.Term; import org.apache.lucene.search.Filter; import org.elasticsearch.ElasticSearchIllegalStateException; import org.elasticsearch.common.Strings; @@ -304,7 +305,7 @@ public class ObjectMapper implements Mapper, AllFieldMapper.IncludeInAll { this.mappers = copyOf(mappers); } this.nestedTypePath = "__" + fullPath; - this.nestedTypeFilter = new TermFilter(TypeFieldMapper.TERM_FACTORY.createTerm(nestedTypePath)); + this.nestedTypeFilter = new TermFilter(new Term(TypeFieldMapper.NAME, nestedTypePath)); } @Override @@ -412,7 +413,7 @@ public class ObjectMapper implements Mapper, AllFieldMapper.IncludeInAll { if (nested.isNested()) { Document nestedDoc = new Document(); // pre add the uid field if possible (id was already provided) - Fieldable uidField = context.doc().getFieldable(UidFieldMapper.NAME); + Field uidField = (Field) context.doc().getField(UidFieldMapper.NAME); if (uidField != null) { // we don't need to add it as a full uid field in nested docs, since we don't need versioning // we also rely on this for UidField#loadVersion @@ -465,7 +466,7 @@ public class ObjectMapper implements Mapper, AllFieldMapper.IncludeInAll { if (nested.isNested()) { Document nestedDoc = context.switchDoc(restoreDoc); if (nested.isIncludeInParent()) { - for (Fieldable field : nestedDoc.getFields()) { + for (IndexableField field : nestedDoc.getFields()) { if (field.name().equals(UidFieldMapper.NAME) || field.name().equals(TypeFieldMapper.NAME)) { continue; } else { @@ -476,7 +477,7 @@ public class ObjectMapper implements Mapper, AllFieldMapper.IncludeInAll { if (nested.isIncludeInRoot()) { // don't add it twice, if its included in parent, and we are handling the master doc... if (!(nested.isIncludeInParent() && context.doc() == context.rootDoc())) { - for (Fieldable field : nestedDoc.getFields()) { + for (IndexableField field : nestedDoc.getFields()) { if (field.name().equals(UidFieldMapper.NAME) || field.name().equals(TypeFieldMapper.NAME)) { continue; } else {