Module org.elasticsearch.server
Package org.elasticsearch.index.mapper

Class DocumentParserContext

java.lang.Object
org.elasticsearch.index.mapper.DocumentParserContext
public abstract class DocumentParserContext extends Object
Context used when parsing incoming documents. Holds everything that is needed to parse a document as well as the lucene data structures and mappings to be dynamically created as the outcome of parsing a document.

  • Constructor Details

  • Method Details

    • indexSettings

      public final IndexSettings indexSettings()

    • indexAnalyzers

      public final IndexAnalyzers indexAnalyzers()

    • root

      public final RootObjectMapper root()

    • parent

      public final ObjectMapper parent()

    • mappingLookup

      public final MappingLookup mappingLookup()

    • getMetadataMapper

      public final MetadataFieldMapper getMetadataMapper(String mapperName)

    • dynamicTemplateParserContext

      public final MappingParserContext dynamicTemplateParserContext(DateFormatter dateFormatter)

    • sourceToParse

      public final SourceToParse sourceToParse()

    • routing

      public final String routing()

    • addIgnoredField

      public final void addIgnoredField(String field)
      Add the given field to the set of ignored fields.

    • getIgnoredFields

      public final Collection<String> getIgnoredFields()
      Return the collection of fields that have been ignored so far.

    • addIgnoredField

      public final void addIgnoredField(IgnoredSourceFieldMapper.NameValue values)
      Add the given ignored values to the corresponding list.

    • getIgnoredFieldValues

      public final Collection<IgnoredSourceFieldMapper.NameValue> getIgnoredFieldValues()
      Return the collection of values for fields that have been ignored so far.

    • addIgnoredFieldFromContext

      public final DocumentParserContext addIgnoredFieldFromContext(IgnoredSourceFieldMapper.NameValue ignoredFieldWithNoSource) throws IOException
      Adds an ignored field from the parser context, capturing an object or an array. In case of nested arrays, i.e. capturing an array within an array, elements tracked as ignored fields may interfere with the rest, as ignored source contents take precedence over regular field contents with the same leaf name. To prevent missing array elements from synthetic source, all array elements get recorded in ignored source. Otherwise, just the value in the current parsing context gets captured. In both cases, a new parser sub-context gets created from the current DocumentParserContext and returned, indicating that the source for the sub-context has been captured, to avoid double-storing parts of its contents to ignored source.
      Throws:
      IOException

    • maybeCloneForArray

      public final DocumentParserContext maybeCloneForArray(Mapper mapper) throws IOException
      Clones the current context to mark it as an array, if it's not already marked, or restore it if it's within a nested object. Applies to synthetic source only.
      Throws:
      IOException

    • addToFieldNames

      public final void addToFieldNames(String field)
      Add the given field to the _field_names field Use this if an exists query run against the field cannot use docvalues or norms.

    • version

      public final org.apache.lucene.document.Field version()

    • version

      public final void version(org.apache.lucene.document.Field version)

    • id

      public final String id()

    • id

      public final void id(String id)

    • seqID

      public final SeqNoFieldMapper.SequenceIDFields seqID()

    • canAddIgnoredField

      public final boolean canAddIgnoredField()

    • documentDescription

      public final String documentDescription()
      Description on the document being parsed used in error messages. Not called unless there is an error.

    • getMapper

      public Mapper getMapper(String name)

    • dynamic

      public ObjectMapper.Dynamic dynamic()

    • markFieldAsAppliedFromTemplate

      public void markFieldAsAppliedFromTemplate(String fieldName)

    • isFieldAppliedFromTemplate

      public boolean isFieldAppliedFromTemplate(String name)

    • markFieldAsCopyTo

      public void markFieldAsCopyTo(String fieldName)

    • isCopyToDestinationField

      public boolean isCopyToDestinationField(String name)

    • addDynamicMapper

      public final boolean addDynamicMapper(Mapper mapper)
      Add a new mapper dynamically created while parsing.
      Returns:
      returns true if the mapper could be created, false if the dynamic mapper has been ignored due to the field limit
      Throws:
      IllegalArgumentException - if the field limit has been exceeded. This can happen when dynamic is set to ObjectMapper.Dynamic.TRUE or ObjectMapper.Dynamic.RUNTIME.

    • hasDynamicMappersOrRuntimeFields

      public final boolean hasDynamicMappersOrRuntimeFields()
      Returns:
      true if either getDynamicMappers() or getDynamicRuntimeFields() will return a non-empty result

    • hasDynamicMappers

      public final boolean hasDynamicMappers()
      Returns:
      true if either getDynamicMappers() will return a non-empty mapper list

    • getDynamicMappers

      public final List<Mapper> getDynamicMappers()
      Get dynamic mappers created as a result of parsing an incoming document. Responsible for exposing all the newly created fields that need to be merged into the existing mappings. Used to create the required mapping update at the end of document parsing. Consists of a all Mappers that will need to be added to their respective parent ObjectMappers in order to become part of the resulting dynamic mapping update.

    • getDynamicMappers

      public final List<Mapper> getDynamicMappers(String fieldName)
      Returns the dynamic Consists of a flat set of Mappers associated with a field name that will need to be added to their respective parent ObjectMappers in order to become part of the resulting dynamic mapping update.
      Parameters:
      fieldName - Full field name with dot-notation.
      Returns:
      List of Mappers or null

    • updateDynamicMappers

      public void updateDynamicMappers(String name, List<Mapper> mappers)

    • getDynamicRuntimeFields

      public final List<RuntimeField> getDynamicRuntimeFields()
      Get dynamic runtime fields created while parsing. Holds a flat set of RuntimeFields. Runtime fields get dynamically mapped when ObjectMapper.Dynamic.RUNTIME is used, or when dynamic templates specify a runtime section.

    • nonRootDocuments

      public abstract Iterable<LuceneDocument> nonRootDocuments()
      Returns an Iterable over all non-root documents. If there are no non-root documents the iterable will return an empty iterator.

    • updateRoot

      public final RootObjectMapper.Builder updateRoot()
      Returns:
      a RootObjectMapper.Builder to be used to construct a dynamic mapping update

    • isWithinCopyTo

      public boolean isWithinCopyTo()

    • createChildContext

      public final DocumentParserContext createChildContext(ObjectMapper parent)

    • createNestedContext

      public final DocumentParserContext createNestedContext(NestedObjectMapper nestedMapper)
      Return a new context that will be used within a nested document.

    • switchDoc

      public final DocumentParserContext switchDoc(LuceneDocument document)
      Return a new context that has the provided document as the current document.

    • createCopyToContext

      public final DocumentParserContext createCopyToContext(String copyToField, LuceneDocument doc) throws IOException
      Return a context for copy_to directives
      Parameters:
      copyToField - the name of the field to copy to
      doc - the document to target
      Throws:
      IOException

    • createFlattenContext

      public final DocumentParserContext createFlattenContext(String fieldName)
      Return a context for flattening subobjects
      Parameters:
      fieldName - the name of the field to be flattened

    • switchParser

      public final DocumentParserContext switchParser(XContentParser parser)
      Clone this context, replacing the XContentParser with the passed one
      Parameters:
      parser - the replacement parser
      Returns:
      a new context with a replaced parser

    • getRoutingFields

      public RoutingFields getRoutingFields()
      The collection of dimensions for this document.

    • path

      public abstract ContentPath path()

    • createDynamicMapperBuilderContext

      public final MapperBuilderContext createDynamicMapperBuilderContext()
      Creates a context to build dynamic mappers

    • parser

      public abstract XContentParser parser()

    • rootDoc

      public abstract LuceneDocument rootDoc()

    • doc

      public abstract LuceneDocument doc()

    • addDoc

      protected abstract void addDoc(LuceneDocument doc)

    • findDynamicTemplate

      public final DynamicTemplate findDynamicTemplate(String fieldName, DynamicTemplate.XContentFieldType matchType)
      Find a dynamic mapping template for the given field and its matching type
      Parameters:
      fieldName - the name of the field
      matchType - the expecting matchType of the field
      Returns:
      the matching template; otherwise returns null
      Throws:
      DocumentParsingException - if the given field has a dynamic template name specified, but no template matches that name.