anchor.diff:              dataSource="null"
               baseDir="/my/document/directory">
   
  -      <!-- this processor extracts content using Xpath from each file found -->
  +      <!-- this processor extracts content using XPath from each file found -->
   
         <entity name="nested" processor="XPathEntityProcessor"
                 forEach="/rootelement" url="${f.fileAbsolutePath}" >
  
positive.code: 
  The types of data sources available are described below.
  
  [[UploadingStructuredDataStoreDatawiththeDataImportHandler-ContentStreamDataSource]]
  === ContentStreamDataSource
  
  This takes the POST data as the data source. This can be used with any EntityProcessor that uses a `DataSource<Reader>`.
  
  [[UploadingStructuredDataStoreDatawiththeDataImportHandler-FieldReaderDataSource]]
  === FieldReaderDataSource
  
  This can be used where a database field contains XML which you wish to process using the XPathEntityProcessor. You would set up a configuration with both JDBC and FieldReader data sources, and two entities, as follows:
  
negative.code: 
  The URLDataSource type accepts these optional parameters:
  
  baseURL::
  Specifies a new baseURL for pathnames. You can use this to specify host/port changes between Dev/QA/Prod environments. Using this attribute isolates the changes to be made to the `solrconfig.xml`
  
  connectionTimeout::
  Specifies the length of time in milliseconds after which the connection should time out. The default value is 5000ms.
  
  encoding::
  By default the encoding in the response header is used. You can use this property to override the default encoding.
  
  readTimeout::
  Specifies the length of time in milliseconds after which a read operation should time out. The default value is 10000ms.
  
  
  == Entity Processors
  
  Entity processors extract data, transform it, and add it to a Solr index. Examples of entities include views or tables in a data store.
  
  Each processor has its own set of attributes, described in its own section below. In addition, there are several attributes common to all entities which may be specified:
  
  dataSource::
  The name of a data source. If there are multiple data sources defined, use this attribute with the name of the data source for this entity.
  
  name::
  Required. The unique name used to identify an entity.
  
  pk::
  The primary key for the entity. It is optional, and required only when using delta-imports. It has no relation to the uniqueKey defined in `schema.xml` but they can both be the same.
  +
  This attribute is mandatory if you do delta-imports and then refer to the column name in `${dataimporter.delta.<column-name>}` which is used as the primary key.
  
  processor::
  Default is <<The SQL Entity Processor,SqlEntityProcessor>>. Required only if the datasource is not RDBMS.
  
  onError::
  Defines what to do if an error is encountered.
  +
  Permissible values are:
  
  abort::: Stops the import.
  
  skip::: Skips the current document.
  
  continue::: Ignores the error and processing continues.
  
  preImportDeleteQuery::
  Before a `full-import` command, use this query this to cleanup the index instead of using `\*:*`. This is honored only on an entity that is an immediate sub-child of `<document>`.
  
  postImportDeleteQuery::
  Similar to `preImportDeleteQuery`, but it executes after the import has completed.
  
  rootEntity::
  By default the entities immediately under `<document>` are root entities. If this attribute is set to false, the entity directly falling under that entity will be treated as the root entity (and so on). For every row returned by the root entity, a document is created in Solr.
  
  transformer::
  Optional. One or more transformers to be applied on this entity.
  
  cacheImpl::
  Optional. A class (which must implement `DIHCache`) to use for caching this entity when doing lookups from an entity which wraps it. Provided implementation is `SortedMapBackedCache`.
  
  cacheKey::
  The name of a property of this entity to use as a cache key if `cacheImpl` is specified.
  
  cacheLookup::
  An entity + property name that will be used to lookup cached instances of this entity if `cacheImpl` is specified.
  
  where::
  An alternative way to specify `cacheKey` and `cacheLookup` concatenated with '='.
  +
  For example, `where="CODE=People.COUNTRY_CODE"` is equivalent to `cacheKey="CODE" cacheLookup="People.COUNTRY_CODE"`
  
  child="true"::
  Enables indexing document blocks aka <<uploading-data-with-index-handlers.adoc#uploading-data-with-index-handlers,Nested Child Documents>> for searching with <<other-parsers.adoc#other-parsers,Block Join Query Parsers>>. It can be only specified on the `<entity>` element under another root entity. It switches from default behavior (merging field values) to nesting documents as children documents.
  +
  Note: parent `<entity>` should add a field which is used as a parent filter in query time.
  
  join="zipper"::
  Enables merge join, aka "zipper" algorithm, for joining parent and child entities without cache. It should be specified at child (nested) `<entity>`. It implies that parent and child queries return results ordered by keys, otherwise it throws an exception. Keys should be specified either with `where` attribute or with `cacheKey` and `cacheLookup`.
  
  === Entity Caching
  Caching of entities in DIH is provided to avoid repeated lookups for same entities again and again. The default `SortedMapBackedCache` is a `HashMap` where a key is a field in the row and the value is a bunch of rows for that same key.
  
  In the example below, each `manufacturer` entity is cached using the `id` property as a cache key. Cache lookups will be performed for each `product` entity based on the product's `manu` property. When the cache has no data for a particular key, the query is run and the cache is populated
  
  [source,xml]
  ----
  