org.apache.solr.schema

## Class TrieField

- java.lang.Object
- - org.apache.solr.schema.FieldProperties
  - - org.apache.solr.schema.FieldType
    - - org.apache.solr.schema.PrimitiveFieldType
      - - org.apache.solr.schema.TrieField

- Direct Known Subclasses:
    TrieDateField, TrieDoubleField, TrieFloatField, TrieIntField, TrieLongField

      public class TrieField
      extends PrimitiveFieldType

  Provides field types to support for Lucene's `LegacyIntField`, `LegacyLongField`, `LegacyFloatField` and `LegacyDoubleField`. See `LegacyNumericRangeQuery` for more details. It supports integer, float, long, double and date types.

  For each number being added to this field, multiple terms are generated as per the algorithm described in the above link. The possible number of terms increases dramatically with lower precision steps. For the fast range search to work, trie fields must be indexed.

  Trie fields are sortable in numerical order and can be used in function queries.

  Note that if you use a precisionStep of 32 for int/float and 64 for long/double/date, then multiple terms will not be generated, range search will be no faster than any other number field, but sorting will still be possible.

  Since:
    solr 1.4
  See Also:
    `LegacyNumericRangeQuery`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `TrieField.TrieTypes`

    - ### Nested classes/interfaces inherited from class org.apache.solr.schema.FieldType

      `FieldType.DefaultAnalyzer, FieldType.MultiValueSelector`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `DEFAULT_PRECISION_STEP`
    `protected int` | `precisionStep`
    `protected int` | `precisionStepArg`
    `protected TrieField.TrieTypes` | `type`

    - ### Fields inherited from class org.apache.solr.schema.FieldType

      `ANALYZER, args, CHAR_FILTER, CHAR_FILTERS, CLASS_NAME, docValuesFormat, falseProperties, FILTER, FILTERS, INDEX, INDEX_ANALYZER, MULTI_TERM, MULTI_TERM_ANALYZER, POLY_FIELD_SEPARATOR, postingsFormat, properties, QUERY, QUERY_ANALYZER, similarity, SIMILARITY, similarityFactory, TOKENIZER, trueProperties, TYPE, TYPE_NAME, typeName`

    - ### Fields inherited from class org.apache.solr.schema.FieldProperties

      `BINARY, DOC_VALUES, INDEXED, MULTIVALUED, OMIT_NORMS, OMIT_POSITIONS, OMIT_TF_POSITIONS, REQUIRED, SORT_MISSING_FIRST, SORT_MISSING_LAST, STORE_OFFSETS, STORE_TERMOFFSETS, STORE_TERMPAYLOADS, STORE_TERMPOSITIONS, STORE_TERMVECTORS, STORED, TOKENIZED, USE_DOCVALUES_AS_STORED`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TrieField()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `checkSchemaField(SchemaField field)` Check's `SchemaField` instances constructed using this field type to ensure that they are valid.
    `IndexableField` | `createField(SchemaField field, Object value, float boost)` Used for adding a document when a field needs to be created from a type and a string.
    `List<IndexableField>` | `createFields(SchemaField sf, Object value, float boost)` Given a `SchemaField`, create one or more `IndexableField` instances
    `Query` | `getFieldQuery(QParser parser, SchemaField field, String externalVal)` Returns a Query instance for doing searches against a field.
    `static String` | `getMainValuePrefix(FieldType ft)` expert internal use, subject to change.
    `FieldType.LegacyNumericType` | `getNumericType()` Return the numeric type of this field, or null if this field is not a numeric field.
    `int` | `getPrecisionStep()`
    `Query` | `getRangeQuery(QParser parser, SchemaField field, String min, String max, boolean minInclusive, boolean maxInclusive)` Returns a Query instance for doing range searches on this field type.
    `ValueSource` | `getSingleValueSource(FieldType.MultiValueSelector choice, SchemaField field, QParser parser)` Method for dynamically building a ValueSource based on a single value of a multivalued field.
    `protected ValueSource` | `getSingleValueSource(SortedSetSelector.Type choice, SchemaField field)` Helper method that will only be called for multivalued Trie fields that have doc values.
    `SortField` | `getSortField(SchemaField field, boolean top)` Returns the SortField instance that should be used to sort fields of this type.
    `TrieField.TrieTypes` | `getType()`
    `UninvertingReader.Type` | `getUninversionType(SchemaField sf)` DocValues is not enabled for a field, but it's indexed, docvalues can be constructed on the fly (uninverted, aka fieldcache) on the first request to sort, facet, etc.
    `ValueSource` | `getValueSource(SchemaField field, QParser qparser)` called to get the default value source (normally, from the Lucene FieldCache.)
    `CharsRef` | `indexedToReadable(BytesRef indexedForm, CharsRefBuilder charsRef)` Given an indexed term, append the human readable representation
    `String` | `indexedToReadable(String _indexedForm)` Given an indexed term, return the human readable representation
    `protected void` | `init(IndexSchema schema, Map<String,String> args)` subclasses should initialize themselves with the args provided and remove valid arguments.
    `boolean` | `isTokenized()` Returns true if fields of this type should be tokenized
    `boolean` | `multiValuedFieldCache()` Returns true if a single field value of this type has multiple logical values for the purposes of faceting, sorting, etc.
    `void` | `readableToIndexed(CharSequence val, BytesRefBuilder result)` Given the readable value, return the term value that will match it.
    `String` | `readableToIndexed(String val)` Given the readable value, return the term value that will match it.
    `String` | `storedToIndexed(IndexableField f)` Given the stored field, return the indexed form
    `String` | `storedToReadable(IndexableField f)` Given the stored field, return the human readable representation
    `String` | `toExternal(IndexableField f)` Convert the stored-field format to an external (string, human readable) value
    `String` | `toInternal(String val)` Convert an external value (from XML update command or from query string) into the internal format for both storing and indexing (which can be modified by any analyzers).
    `Object` | `toObject(IndexableField f)` Convert the stored-field format to an external object.
    `Object` | `toObject(SchemaField sf, BytesRef term)`
    `void` | `write(TextResponseWriter writer, String name, IndexableField f)` calls back to TextResponseWriter to write the field value

    - ### Methods inherited from class org.apache.solr.schema.FieldType

      `createField, getAnalyzerProperties, getClassArg, getDocValuesFormat, getIndexAnalyzer, getIndexOptions, getNamedPropertyValues, getNonFieldPropertyArgs, getPostingsFormat, getPrefixQuery, getQueryAnalyzer, getRewriteMethod, getSimilarity, getSimilarityFactory, getStringSort, getTypeName, hasProperty, isExplicitAnalyzer, isExplicitQueryAnalyzer, isMultiValued, isPolyField, marshalBase64SortValue, marshalSortValue, marshalStringSortValue, restrictProps, setArgs, setIndexAnalyzer, setIsExplicitAnalyzer, setIsExplicitQueryAnalyzer, setQueryAnalyzer, setSimilarity, supportsAnalyzers, toNativeType, toString, unmarshalBase64SortValue, unmarshalSortValue, unmarshalStringSortValue, useDocValuesAsStored`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_PRECISION_STEP

          public static final int DEFAULT_PRECISION_STEP

      See Also:
        Constant Field Values

    - #### precisionStepArg

          protected int precisionStepArg

    - #### precisionStep

          protected int precisionStep

    - #### type

          protected TrieField.TrieTypes type

  - ### Constructor Detail

    - #### TrieField

          public TrieField()

  - ### Method Detail

    - #### init

          protected void init(IndexSchema schema,
                              Map<String,String> args)

      Description copied from class: `FieldType`
      subclasses should initialize themselves with the args provided and remove valid arguments. leftover arguments will cause an exception. Common boolean properties have already been handled.
      Overrides:
        `init` in class `PrimitiveFieldType`

    - #### toObject

          public Object toObject(IndexableField f)

      Description copied from class: `FieldType`
      Convert the stored-field format to an external object.
      Overrides:
        `toObject` in class `FieldType`
      See Also:
        `FieldType.toInternal(java.lang.String)`

    - #### getSortField

          public SortField getSortField(SchemaField field,
                                        boolean top)

      Description copied from class: `FieldType`
      Returns the SortField instance that should be used to sort fields of this type.
      Specified by:
        `getSortField` in class `FieldType`
      See Also:
        `SchemaField.checkSortability()`

    - #### getUninversionType

          public UninvertingReader.Type getUninversionType(SchemaField sf)

      Description copied from class: `FieldType`
      DocValues is not enabled for a field, but it's indexed, docvalues can be constructed on the fly (uninverted, aka fieldcache) on the first request to sort, facet, etc. This specifies the structure to use.
      Specified by:
        `getUninversionType` in class `FieldType`
      Parameters:
        `sf` - field instance
      Returns:
        type to uninvert, or `null` (to disallow uninversion for the field)

    - #### getValueSource

          public ValueSource getValueSource(SchemaField field,
                                            QParser qparser)

      Description copied from class: `FieldType`
      called to get the default value source (normally, from the Lucene FieldCache.)
      Overrides:
        `getValueSource` in class `FieldType`

    - #### getSingleValueSource

          public final ValueSource getSingleValueSource(FieldType.MultiValueSelector choice,
                                                        SchemaField field,
                                                        QParser parser)

      Description copied from class: `FieldType`
      Method for dynamically building a ValueSource based on a single value of a multivalued field. The default implementation throws an error except in the trivial case where this method is used on a `SchemaField` that is in fact not-multivalued, in which case it delegates to `FieldType.getValueSource(org.apache.solr.schema.SchemaField, org.apache.solr.search.QParser)`
      Overrides:
        `getSingleValueSource` in class `FieldType`
      See Also:
        `FieldType.MultiValueSelector`

    - #### getSingleValueSource

          protected ValueSource getSingleValueSource(SortedSetSelector.Type choice,
                                                     SchemaField field)

      Helper method that will only be called for multivalued Trie fields that have doc values. Default impl throws an error indicating that selecting a single value from this multivalued field is not supported for this field type
      Parameters:
        `choice` - the selector Type to use, will never be null
        `field` - the field to use, guaranteed to be multivalued.
      See Also:
        `FieldType.getSingleValueSource(MultiValueSelector,SchemaField,QParser)`

    - #### write

          public void write(TextResponseWriter writer,
                            String name,
                            IndexableField f)
                     throws IOException

      Description copied from class: `FieldType`
      calls back to TextResponseWriter to write the field value
      Specified by:
        `write` in class `FieldType`
      Throws:
        `IOException`

    - #### isTokenized

          public boolean isTokenized()

      Description copied from class: `FieldType`
      Returns true if fields of this type should be tokenized
      Overrides:
        `isTokenized` in class `FieldType`

    - #### multiValuedFieldCache

          public boolean multiValuedFieldCache()

      Description copied from class: `FieldType`
      Returns true if a single field value of this type has multiple logical values for the purposes of faceting, sorting, etc. Text fields normally return true since each token/word is a logical value.
      Overrides:
        `multiValuedFieldCache` in class `FieldType`

    - #### getPrecisionStep

          public int getPrecisionStep()

      Returns:
        the precisionStep used to index values into the field

    - #### getType

          public TrieField.TrieTypes getType()

      Returns:
        the type of this field

    - #### getNumericType

          public FieldType.LegacyNumericType getNumericType()

      Description copied from class: `FieldType`
      Return the numeric type of this field, or null if this field is not a numeric field.
      Overrides:
        `getNumericType` in class `FieldType`

    - #### getRangeQuery

          public Query getRangeQuery(QParser parser,
                                     SchemaField field,
                                     String min,
                                     String max,
                                     boolean minInclusive,
                                     boolean maxInclusive)

      Description copied from class: `FieldType`
      Returns a Query instance for doing range searches on this field type. `SolrQueryParser` currently passes part1 and part2 as null if they are '*' respectively. minInclusive and maxInclusive are both true currently by SolrQueryParser but that may change in the future. Also, other QueryParser implementations may have different semantics.

      Sub-classes should override this method to provide their own range query implementation. They should strive to handle nulls in part1 and/or part2 as well as unequal minInclusive and maxInclusive parameters gracefully.

      Overrides:
        `getRangeQuery` in class `FieldType`
      Parameters:
        `parser` - the `QParser` calling the method
        `field` - the schema field
        `min` - the lower boundary of the range, nulls are allowed.
        `max` - the upper boundary of the range, nulls are allowed
        `minInclusive` - whether the minimum of the range is inclusive or not
        `maxInclusive` - whether the maximum of the range is inclusive or not
      Returns:
        a Query instance to perform range search according to given parameters

    - #### getFieldQuery

          public Query getFieldQuery(QParser parser,
                                     SchemaField field,
                                     String externalVal)

      Description copied from class: `FieldType`
      Returns a Query instance for doing searches against a field.
      Overrides:
        `getFieldQuery` in class `FieldType`
      Parameters:
        `parser` - The `QParser` calling the method
        `field` - The `SchemaField` of the field to search
        `externalVal` - The String representation of the value to search
      Returns:
        The `Query` instance. This implementation returns a `TermQuery` but overriding queries may not

    - #### storedToReadable

          public String storedToReadable(IndexableField f)

      Description copied from class: `FieldType`
      Given the stored field, return the human readable representation
      Overrides:
        `storedToReadable` in class `FieldType`

    - #### readableToIndexed

          public String readableToIndexed(String val)

      Description copied from class: `FieldType`
      Given the readable value, return the term value that will match it.
      Overrides:
        `readableToIndexed` in class `FieldType`

    - #### readableToIndexed

          public void readableToIndexed(CharSequence val,
                                        BytesRefBuilder result)

      Description copied from class: `FieldType`
      Given the readable value, return the term value that will match it.
      Overrides:
        `readableToIndexed` in class `FieldType`

    - #### toInternal

          public String toInternal(String val)

      Description copied from class: `FieldType`
      Convert an external value (from XML update command or from query string) into the internal format for both storing and indexing (which can be modified by any analyzers).
      Overrides:
        `toInternal` in class `FieldType`
      See Also:
        `FieldType.toExternal(org.apache.lucene.index.IndexableField)`

    - #### toExternal

          public String toExternal(IndexableField f)

      Description copied from class: `FieldType`
      Convert the stored-field format to an external (string, human readable) value
      Overrides:
        `toExternal` in class `FieldType`
      See Also:
        `FieldType.toInternal(java.lang.String)`

    - #### indexedToReadable

          public String indexedToReadable(String _indexedForm)

      Description copied from class: `FieldType`
      Given an indexed term, return the human readable representation
      Overrides:
        `indexedToReadable` in class `FieldType`

    - #### indexedToReadable

          public CharsRef indexedToReadable(BytesRef indexedForm,
                                            CharsRefBuilder charsRef)

      Description copied from class: `FieldType`
      Given an indexed term, append the human readable representation
      Overrides:
        `indexedToReadable` in class `FieldType`

    - #### toObject

          public Object toObject(SchemaField sf,
                                 BytesRef term)

      Overrides:
        `toObject` in class `FieldType`

    - #### storedToIndexed

          public String storedToIndexed(IndexableField f)

      Description copied from class: `FieldType`
      Given the stored field, return the indexed form
      Overrides:
        `storedToIndexed` in class `FieldType`

    - #### createField

          public IndexableField createField(SchemaField field,
                                            Object value,
                                            float boost)

      Description copied from class: `FieldType`
      Used for adding a document when a field needs to be created from a type and a string.

      By default, the indexed value is the same as the stored value (taken from toInternal()). Having a different representation for external, internal, and indexed would present quite a few problems given the current Lucene architecture. An analyzer for adding docs would need to translate internal->indexed while an analyzer for querying would need to translate external->indexed.

      The only other alternative to having internal==indexed would be to have internal==external. In this case, toInternal should convert to the indexed representation, toExternal() should do nothing, and createField() should *not* call toInternal, but use the external value and set tokenized=true to get Lucene to convert to the internal(indexed) form.

      :TODO: clean up and clarify this explanation.
      Overrides:
        `createField` in class `FieldType`
      See Also:
        `FieldType.toInternal(java.lang.String)`

    - #### createFields

          public List<IndexableField> createFields(SchemaField sf,
                                                   Object value,
                                                   float boost)

      Description copied from class: `FieldType`
      Given a `SchemaField`, create one or more `IndexableField` instances
      Overrides:
        `createFields` in class `FieldType`
      Parameters:
        `sf` - the `SchemaField`
        `value` - The value to add to the field
        `boost` - The boost to apply
      Returns:
        An array of `IndexableField`
      See Also:
        `FieldType.createField(SchemaField, Object, float)`, `FieldType.isPolyField()`

    - #### getMainValuePrefix

          public static String getMainValuePrefix(FieldType ft)

      expert internal use, subject to change. Returns null if no prefix or prefix not needed, or the prefix of the main value of a trie field that indexes multiple precisions per value.

    - #### checkSchemaField

          public void checkSchemaField(SchemaField field)

      Description copied from class: `FieldType`
      Check's `SchemaField` instances constructed using this field type to ensure that they are valid.

      This method is called by the `SchemaField` constructor to check that its initialization does not violate any fundemental requirements of the `FieldType`. The default implementation does nothing, but subclasses may chose to throw a `SolrException` if invariants are violated by the `SchemaField.`

      Overrides:
        `checkSchemaField` in class `FieldType`

Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.