diff options
| author | James An | 2016-08-14 17:34:23 -0400 |
|---|---|---|
| committer | James An | 2016-08-14 17:34:23 -0400 |
| commit | 95354675d0f8dac88f42131f9f4dba36d9f017a7 (patch) | |
| tree | efe789fd8719db55714b28afcda0ccf1ef69a0d4 | |
| parent | 39e1aac068f36c4a2c7b0e5e542bbf9eb7022095 (diff) | |
| download | aur-95354675d0f8dac88f42131f9f4dba36d9f017a7.tar.gz | |
Added a couple patches to add support for Solr 6.x and updated to the latest.
| -rw-r--r-- | 2711685-support-solr6-3.patch | 2767 | ||||
| -rw-r--r-- | 2711685-support-solr6-search-api-solr-4.patch | 2767 | ||||
| -rw-r--r-- | PKGBUILD | 9 |
3 files changed, 5540 insertions, 3 deletions
diff --git a/2711685-support-solr6-3.patch b/2711685-support-solr6-3.patch new file mode 100644 index 000000000000..2ecfdfd924d0 --- /dev/null +++ b/2711685-support-solr6-3.patch @@ -0,0 +1,2767 @@ +diff --git a/conf/6.x/elevate.xml b/conf/6.x/elevate.xml +new file mode 100644 +index 0000000..71ea000 +--- /dev/null ++++ b/conf/6.x/elevate.xml +@@ -0,0 +1,31 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++ ++<!-- ++ This file allows you to boost certain search items to the top of search ++ results. You can find out an item's ID by searching directly on the Solr ++ server. The item IDs are in general constructed as follows: ++ Search API: ++ $document->id = $index_id . '-' . $item_id; ++ Apache Solr Search Integration: ++ $document->id = $site_hash . '/' . $entity_type . '/' . $entity->id; ++ ++ If you want this file to be automatically re-loaded when a Solr commit takes ++ place (e.g., if you have an automatic script active which updates elevate.xml ++ according to newly-indexed data), place it into Solr's data/ directory. ++ Otherwise, place it with the other configuration files into the conf/ ++ directory. ++ ++ See http://wiki.apache.org/solr/QueryElevationComponent for more information. ++--> ++ ++<elevate> ++<!-- Example for ranking the node #1 first in searches for "example query": --> ++<!-- ++ <query text="example query"> ++ <doc id="default_node_index-1" /> ++ <doc id="7v3jsc/node/1" /> ++ </query> ++--> ++<!-- Multiple <query> elements can be specified, contained in one <elevate>. --> ++<!-- <query text="...">...</query> --> ++</elevate> +diff --git a/conf/6.x/mapping-ISOLatin1Accent.txt b/conf/6.x/mapping-ISOLatin1Accent.txt +new file mode 100644 +index 0000000..b92d03c +--- /dev/null ++++ b/conf/6.x/mapping-ISOLatin1Accent.txt +@@ -0,0 +1,14 @@ ++# This file contains character mappings for the default fulltext field type. ++# The source characters (on the left) will be replaced by the respective target ++# characters before any other processing takes place. ++# Lines starting with a pound character # are ignored. ++# ++# For sensible defaults, use the mapping-ISOLatin1Accent.txt file distributed ++# with the example application of your Solr version. ++# ++# Examples: ++# "À" => "A" ++# "\u00c4" => "A" ++# "\u00c4" => "\u0041" ++# "æ" => "ae" ++# "\n" => " " +diff --git a/conf/6.x/protwords.txt b/conf/6.x/protwords.txt +new file mode 100644 +index 0000000..cda8581 +--- /dev/null ++++ b/conf/6.x/protwords.txt +@@ -0,0 +1,7 @@ ++#----------------------------------------------------------------------- ++# This file blocks words from being operated on by the stemmer and word delimiter. ++& ++< ++> ++' ++" +diff --git a/conf/6.x/schema.xml b/conf/6.x/schema.xml +new file mode 100644 +index 0000000..d813d12 +--- /dev/null ++++ b/conf/6.x/schema.xml +@@ -0,0 +1,693 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++ ++<!-- ++ This is the Solr schema file. This file should be named "schema.xml" and ++ should be in the conf directory under the solr home ++ (i.e. ./solr/conf/schema.xml by default) ++ or located where the classloader for the Solr webapp can find it. ++ ++ For more information, on how to customize this file, please see ++ http://wiki.apache.org/solr/SchemaXml ++--> ++ ++<schema name="drupal-4.4-solr-6.x" version="1.5"> ++ <!-- attribute "name" is the name of this schema and is only used for ++ display purposes. Applications should change this to reflect the nature ++ of the search collection. ++ version="1.2" is Solr's version number for the schema syntax and ++ semantics. It should not normally be changed by applications. ++ ++ 1.0: multiValued attribute did not exist, all fields are multiValued by ++ nature ++ 1.1: multiValued attribute introduced, false by default ++ 1.2: omitTermFreqAndPositions attribute introduced, true by default ++ except for text fields. ++ 1.3: removed optional field compress feature ++ 1.4: autoGeneratePhraseQueries attribute introduced to drive ++ QueryParser behavior when a single string produces multiple ++ tokens. Defaults to off for version >= 1.4 ++ 1.5: omitNorms defaults to true for primitive field types ++ (int, float, boolean, string...) ++ --> ++ ++ <types> ++ <!-- field type definitions. The "name" attribute is ++ just a label to be used by field definitions. The "class" ++ attribute and any other attributes determine the real ++ behavior of the fieldType. ++ Class names starting with "solr" refer to java classes in the ++ org.apache.solr.analysis package. ++ --> ++ ++ <!-- The StrField type is not analyzed, but indexed/stored verbatim. ++ - StrField and TextField support an optional compressThreshold which ++ limits compression (if enabled in the derived fields) to values which ++ exceed a certain size (in characters). ++ --> ++ <fieldType name="string" class="solr.StrField" sortMissingLast="true"/> ++ ++ <!-- boolean type: "true" or "false" --> ++ <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true"/> ++ <!--Binary data type. The data should be sent/retrieved in as Base64 encoded Strings --> ++ <fieldtype name="binary" class="solr.BinaryField"/> ++ ++ <!-- The optional sortMissingLast and sortMissingFirst attributes are ++ currently supported on types that are sorted internally as strings. ++ - If sortMissingLast="true", then a sort on this field will cause documents ++ without the field to come after documents with the field, ++ regardless of the requested sort order (asc or desc). ++ - If sortMissingFirst="true", then a sort on this field will cause documents ++ without the field to come before documents with the field, ++ regardless of the requested sort order. ++ - If sortMissingLast="false" and sortMissingFirst="false" (the default), ++ then default lucene sorting will be used which places docs without the ++ field first in an ascending sort and last in a descending sort. ++ --> ++ ++ <!-- numeric field types that can be sorted, but are not optimized for range queries --> ++ <fieldType name="integer" class="solr.TrieIntField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="float" class="solr.TrieFloatField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" positionIncrementGap="0"/> ++ ++ <!-- ++ Note: ++ These should only be used for compatibility with existing indexes (created with older Solr versions) ++ or if "sortMissingFirst" or "sortMissingLast" functionality is needed. Use Trie based fields instead. ++ ++ Numeric field types that manipulate the value into ++ a string value that isn't human-readable in its internal form, ++ but with a lexicographic ordering the same as the numeric ordering, ++ so that range queries work correctly. ++ --> ++ <fieldType name="sint" class="solr.TrieIntField" sortMissingLast="true"/> ++ <fieldType name="sfloat" class="solr.TrieFloatField" sortMissingLast="true"/> ++ <fieldType name="slong" class="solr.TrieLongField" sortMissingLast="true"/> ++ <fieldType name="sdouble" class="solr.TrieDoubleField" sortMissingLast="true"/> ++ ++ <!-- ++ Numeric field types that index each value at various levels of precision ++ to accelerate range queries when the number of values between the range ++ endpoints is large. See the javadoc for NumericRangeQuery for internal ++ implementation details. ++ ++ Smaller precisionStep values (specified in bits) will lead to more tokens ++ indexed per value, slightly larger index size, and faster range queries. ++ A precisionStep of 0 disables indexing at different precision levels. ++ --> ++ <fieldType name="tint" class="solr.TrieIntField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tfloat" class="solr.TrieFloatField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tlong" class="solr.TrieLongField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tdouble" class="solr.TrieDoubleField" precisionStep="8" positionIncrementGap="0"/> ++ ++ <!-- ++ The ExternalFileField type gets values from an external file instead of the ++ index. This is useful for data such as rankings that might change frequently ++ and require different update frequencies than the documents they are ++ associated with. ++ --> ++ <fieldType name="file" keyField="id" defVal="1" stored="false" indexed="false" class="solr.ExternalFileField" valType="float"/> ++ ++ <!-- The format for this date field is of the form 1995-12-31T23:59:59Z, and ++ is a more restricted form of the canonical representation of dateTime ++ http://www.w3.org/TR/xmlschema-2/#dateTime ++ The trailing "Z" designates UTC time and is mandatory. ++ Optional fractional seconds are allowed: 1995-12-31T23:59:59.999Z ++ All other components are mandatory. ++ ++ Expressions can also be used to denote calculations that should be ++ performed relative to "NOW" to determine the value, ie... ++ ++ NOW/HOUR ++ ... Round to the start of the current hour ++ NOW-1DAY ++ ... Exactly 1 day prior to now ++ NOW/DAY+6MONTHS+3DAYS ++ ... 6 months and 3 days in the future from the start of ++ the current day ++ ++ Consult the TrieDateField javadocs for more information. ++ ++ Note: For faster range queries, consider the tdate type ++ --> ++ <fieldType name="date" class="solr.TrieDateField" precisionStep="0" positionIncrementGap="0" sortMissingLast="true" omitNorms="true"/> ++ ++ <!-- A Trie based date field for faster date range queries and date faceting. --> ++ <fieldType name="tdate" class="solr.TrieDateField" precisionStep="6" positionIncrementGap="0"/> ++ ++ <!-- solr.TextField allows the specification of custom text analyzers ++ specified as a tokenizer and a list of token filters. Different ++ analyzers may be specified for indexing and querying. ++ ++ The optional positionIncrementGap puts space between multiple fields of ++ this type on the same document, with the purpose of preventing false phrase ++ matching across fields. ++ ++ For more info on customizing your analyzer chain, please see ++ http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters ++ --> ++ ++ <!-- One can also specify an existing Analyzer class that has a ++ default constructor via the class attribute on the analyzer element ++ <fieldType name="text_greek" class="solr.TextField"> ++ <analyzer class="org.apache.lucene.analysis.el.GreekAnalyzer"/> ++ </fieldType> ++ --> ++ ++ <!-- A text field that only splits on whitespace for exact matching of words --> ++ <fieldType name="text_ws" class="solr.TextField" omitNorms="true" positionIncrementGap="100"> ++ <analyzer> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- A text field that uses WordDelimiterFilter to enable splitting and matching of ++ words on case-change, alpha numeric boundaries, and non-alphanumeric chars, ++ so that a query of "wifi" or "wi fi" could match a document containing "Wi-Fi". ++ Synonyms and stopwords are customized by external files, and stemming is enabled. ++ Duplicate tokens at the same position (which may result from Stemmed Synonyms or ++ WordDelim parts) are removed. ++ --> ++ <fieldType name="text" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <!-- in this example, we will only use synonyms at query time ++ <filter class="solr.SynonymFilterFactory" synonyms="index_synonyms.txt" ignoreCase="true" expand="false"/> ++ --> ++ <!-- Case insensitive stop word removal. --> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="1" ++ catenateNumbers="1" ++ catenateAll="0" ++ splitOnCaseChange="0" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="multiterm"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="1" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- An unstemmed text field - good if one does not know the language of the field --> ++ <fieldType name="text_und" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="1" ++ catenateNumbers="1" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ <analyzer type="multiterm"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- Edge N gram type - for example for matching against queries with results ++ KeywordTokenizer leaves input string intact as a single term. ++ see: http://www.lucidimagination.com/blog/2009/09/08/auto-suggest-from-popular-queries-using-edgengrams/ ++ --> ++ <fieldType name="edge_n2_kw_text" class="solr.TextField" omitNorms="true" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.EdgeNGramFilterFactory" minGramSize="2" maxGramSize="25" /> ++ </analyzer> ++ <analyzer type="query"> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ <!-- Setup simple analysis for spell checking --> ++ ++ <fieldType name="textSpell" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer> ++ <tokenizer class="solr.StandardTokenizerFactory" /> ++ <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/> ++ <filter class="solr.LengthFilterFactory" min="4" max="20" /> ++ <filter class="solr.LowerCaseFilterFactory" /> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory" /> ++ </analyzer> ++ </fieldType> ++ ++ <!-- This is an example of using the KeywordTokenizer along ++ With various TokenFilterFactories to produce a sortable field ++ that does not include some properties of the source text ++ --> ++ <fieldType name="sortString" class="solr.TextField" sortMissingLast="true" omitNorms="true"> ++ <analyzer> ++ <!-- KeywordTokenizer does no actual tokenizing, so the entire ++ input string is preserved as a single token ++ --> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <!-- The LowerCase TokenFilter does what you expect, which can be ++ when you want your sorting to be case insensitive ++ --> ++ <filter class="solr.LowerCaseFilterFactory" /> ++ <!-- The TrimFilter removes any leading or trailing whitespace --> ++ <filter class="solr.TrimFilterFactory" /> ++ <!-- The PatternReplaceFilter gives you the flexibility to use ++ Java Regular expression to replace any sequence of characters ++ matching a pattern with an arbitrary replacement string, ++ which may include back refrences to portions of the orriginal ++ string matched by the pattern. ++ ++ See the Java Regular Expression documentation for more ++ infomation on pattern and replacement string syntax. ++ ++ http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/package-summary.html ++ ++ <filter class="solr.PatternReplaceFilterFactory" ++ pattern="(^\p{Punct}+)" replacement="" replace="all" ++ /> ++ --> ++ </analyzer> ++ </fieldType> ++ ++ <!-- The "RandomSortField" is not used to store or search any ++ data. You can declare fields of this type it in your schema ++ to generate pseudo-random orderings of your docs for sorting ++ or function purposes. The ordering is generated based on the field ++ name and the version of the index. As long as the index version ++ remains unchanged, and the same field name is reused, ++ the ordering of the docs will be consistent. ++ If you want different psuedo-random orderings of documents, ++ for the same version of the index, use a dynamicField and ++ change the field name in the request. ++ --> ++ <fieldType name="rand" class="solr.RandomSortField" indexed="true" /> ++ ++ <!-- Fulltext type for matching words based on how they sound – i.e., ++ "phonetic matching". ++ --> ++ <fieldType name="phonetic" class="solr.TextField" > ++ <analyzer> ++ <tokenizer class="solr.StandardTokenizerFactory"/> ++ <filter class="solr.DoubleMetaphoneFilterFactory" inject="false"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- since fields of this type are by default not stored or indexed, ++ any data added to them will be ignored outright. --> ++ <fieldType name="ignored" stored="false" indexed="false" multiValued="true" class="solr.StrField" /> ++ ++ <!-- This point type indexes the coordinates as separate fields (subFields) ++ If subFieldType is defined, it references a type, and a dynamic field ++ definition is created matching *___<typename>. Alternately, if ++ subFieldSuffix is defined, that is used to create the subFields. ++ Example: if subFieldType="double", then the coordinates would be ++ indexed in fields myloc_0___double,myloc_1___double. ++ Example: if subFieldSuffix="_d" then the coordinates would be indexed ++ in fields myloc_0_d,myloc_1_d ++ The subFields are an implementation detail of the fieldType, and end ++ users normally should not need to know about them. ++ --> ++ <fieldType name="point" class="solr.PointType" dimension="2" subFieldType="tdouble"/> ++ ++ <!-- A specialized field for geospatial search. If indexed, this fieldType must not be multivalued. --> ++ <fieldType name="location" class="solr.LatLonType" subFieldType="tdouble"/> ++ ++ <!-- A Geohash is a compact representation of a latitude longitude pair in a single field. ++ See http://wiki.apache.org/solr/SpatialSearch ++ --> ++ <fieldtype name="geohash" class="solr.GeoHashField"/> ++ ++ <!-- Improved location type which supports advanced functionality like ++ filtering by polygons or other shapes, indexing shapes, multi-valued ++ fields, etc. ++ --> ++ <fieldType name="location_rpt" class="solr.SpatialRecursivePrefixTreeFieldType" ++ geo="true" distErrPct="0.025" maxDistErr="0.001" distanceUnits="kilometers" /> ++ ++ <!-- Spatial rectangle (bounding box) field. It supports most spatial predicates, and has ++ special relevancy modes: score=overlapRatio|area|area2D (local-param to the query). DocValues is recommended for ++ relevancy. --> ++ <fieldType name="bbox" class="solr.BBoxField" ++ geo="true" distanceUnits="kilometers" numberType="_bbox_coord" /> ++ <fieldType name="_bbox_coord" class="solr.TrieDoubleField" precisionStep="8" docValues="true" stored="false"/> ++ ++ </types> ++ ++ <!-- Following is a dynamic way to include other types, added by other contrib modules --> ++ <xi:include href="schema_extra_types.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback></xi:fallback> ++ </xi:include> ++ ++ <!-- Valid attributes for fields: ++ name: mandatory - the name for the field ++ type: mandatory - the name of a field type from the <types> fieldType ++ section ++ indexed: true if this field should be indexed (searchable or sortable) ++ stored: true if this field should be retrievable ++ docValues: true if this field should have doc values. Doc values are ++ useful for faceting, grouping, sorting and function queries. Although not ++ required, doc values will make the index faster to load, more ++ NRT-friendly and more memory-efficient. They however come with some ++ limitations: they are currently only supported by StrField, UUIDField ++ and all Trie*Fields, and depending on the field type, they might ++ require the field to be single-valued, be required or have a default ++ value (check the documentation of the field type you're interested in ++ for more information) ++ multiValued: true if this field may contain multiple values per document ++ omitNorms: (expert) set to true to omit the norms associated with ++ this field (this disables length normalization and index-time ++ boosting for the field, and saves some memory). Only full-text ++ fields or fields that need an index-time boost need norms. ++ Norms are omitted for primitive (non-analyzed) types by default. ++ termVectors: [false] set to true to store the term vector for a ++ given field. ++ When using MoreLikeThis, fields used for similarity should be ++ stored for best performance. ++ termPositions: Store position information with the term vector. ++ This will increase storage costs. ++ termOffsets: Store offset information with the term vector. This ++ will increase storage costs. ++ required: The field is required. It will throw an error if the ++ value does not exist ++ default: a value that should be used if no value is specified ++ when adding a document. ++ --> ++ <fields> ++ ++ <!-- The document id is usually derived from a site-spcific key (hash) and the ++ entity type and ID like: ++ Search Api : ++ The format used is $document->id = $index_id . '-' . $item_id ++ Apache Solr Search Integration ++ The format used is $document->id = $site_hash . '/' . $entity_type . '/' . $entity->id; ++ --> ++ <field name="id" type="string" indexed="true" stored="true" required="true" /> ++ ++ <!-- Add Solr Cloud version field as mentioned in ++ http://wiki.apache.org/solr/SolrCloud#Required_Config ++ --> ++ <field name="_version_" type="long" indexed="true" stored="true" multiValued="false"/> ++ ++ <!-- Search Api specific fields --> ++ <!-- item_id contains the entity ID, e.g. a node's nid. --> ++ <field name="item_id" type="string" indexed="true" stored="true" /> ++ <!-- index_id is the machine name of the search index this entry belongs to. --> ++ <field name="index_id" type="string" indexed="true" stored="true" /> ++ <!-- copyField commands copy one field to another at the time a document ++ is added to the index. It's used either to index the same field differently, ++ or to add multiple fields to the same field for easier/faster searching. --> ++ <!-- Since sorting by ID is explicitly allowed, store item_id also in a sortable way. --> ++ <copyField source="item_id" dest="sort_search_api_id" /> ++ ++ <!-- Apache Solr Search Integration specific fields --> ++ <!-- entity_id is the numeric object ID, e.g. Node ID, File ID --> ++ <field name="entity_id" type="long" indexed="true" stored="true" /> ++ <!-- entity_type is 'node', 'file', 'user', or some other Drupal object type --> ++ <field name="entity_type" type="string" indexed="true" stored="true" /> ++ <!-- bundle is a node type, or as appropriate for other entity types --> ++ <field name="bundle" type="string" indexed="true" stored="true"/> ++ <field name="bundle_name" type="string" indexed="true" stored="true"/> ++ <field name="site" type="string" indexed="true" stored="true"/> ++ <field name="hash" type="string" indexed="true" stored="true"/> ++ <field name="url" type="string" indexed="true" stored="true"/> ++ <!-- label is the default field for a human-readable string for this entity (e.g. the title of a node) --> ++ <field name="label" type="text" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <!-- The string version of the title is used for sorting --> ++ <copyField source="label" dest="sort_label"/> ++ ++ <!-- content is the default field for full text search - dump crap here --> ++ <field name="content" type="text" indexed="true" stored="true" termVectors="true"/> ++ <field name="teaser" type="text" indexed="false" stored="true"/> ++ <field name="path" type="string" indexed="true" stored="true"/> ++ <field name="path_alias" type="text" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ ++ <!-- These are the fields that correspond to a Drupal node. The beauty of having ++ Lucene store title, body, type, etc., is that we retrieve them with the search ++ result set and don't need to go to the database with a node_load. --> ++ <field name="tid" type="long" indexed="true" stored="true" multiValued="true"/> ++ <field name="taxonomy_names" type="text" indexed="true" stored="false" termVectors="true" multiValued="true" omitNorms="true"/> ++ <!-- Copy terms to a single field that contains all taxonomy term names --> ++ <copyField source="tm_vid_*" dest="taxonomy_names"/> ++ ++ <!-- Here, default is used to create a "timestamp" field indicating ++ when each document was indexed.--> ++ <field name="timestamp" type="tdate" indexed="true" stored="true" default="NOW" multiValued="false"/> ++ ++ <!-- This field is used to build the spellchecker index --> ++ <field name="spell" type="textSpell" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- copyField commands copy one field to another at the time a document ++ is added to the index. It's used either to index the same field differently, ++ or to add multiple fields to the same field for easier/faster searching. --> ++ <copyField source="label" dest="spell"/> ++ <copyField source="content" dest="spell"/> ++ ++ <copyField source="ts_*" dest="spell"/> ++ <copyField source="tm_*" dest="spell"/> ++ ++ <!-- Dynamic field definitions. If a field name is not found, dynamicFields ++ will be used if the name matches any of the patterns. ++ RESTRICTION: the glob-like pattern in the name attribute must have ++ a "*" only at the start or the end. ++ EXAMPLE: name="*_i" will match any field ending in _i (like myid_i, z_i) ++ Longer patterns will be matched first. if equal size patterns ++ both match, the first appearing in the schema will be used. --> ++ ++ <!-- A set of fields to contain text extracted from HTML tag contents which we ++ can boost at query time. --> ++ <dynamicField name="tags_*" type="text" indexed="true" stored="false" omitNorms="true"/> ++ ++ <!-- For 2 and 3 letter prefix dynamic fields, the 1st letter indicates the data type and ++ the last letter is 's' for single valued, 'm' for multi-valued --> ++ ++ <!-- We use long for integer since 64 bit ints are now common in PHP. --> ++ <dynamicField name="is_*" type="long" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="im_*" type="long" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of floats can be saved in a regular float field --> ++ <dynamicField name="fs_*" type="float" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="fm_*" type="float" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of doubles can be saved in a regular double field --> ++ <dynamicField name="ps_*" type="double" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="pm_*" type="double" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of booleans can be saved in a regular boolean field --> ++ <dynamicField name="bm_*" type="boolean" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="bs_*" type="boolean" indexed="true" stored="true" multiValued="false"/> ++ <!-- Regular text (without processing) can be stored in a string field--> ++ <dynamicField name="ss_*" type="string" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="sm_*" type="string" indexed="true" stored="true" multiValued="true"/> ++ <!-- Normal text fields are for full text - the relevance of a match depends on the length of the text --> ++ <dynamicField name="ts_*" type="text" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tm_*" type="text" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <!-- Unstemmed text fields for full text - the relevance of a match depends on the length of the text --> ++ <dynamicField name="tus_*" type="text_und" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tum_*" type="text_und" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <!-- These text fields omit norms - useful for extracted text like taxonomy_names --> ++ <dynamicField name="tos_*" type="text" indexed="true" stored="true" multiValued="false" termVectors="true" omitNorms="true"/> ++ <dynamicField name="tom_*" type="text" indexed="true" stored="true" multiValued="true" termVectors="true" omitNorms="true"/> ++ <!-- Special-purpose text fields --> ++ <dynamicField name="tes_*" type="edge_n2_kw_text" indexed="true" stored="true" multiValued="false" omitTermFreqAndPositions="true" /> ++ <dynamicField name="tem_*" type="edge_n2_kw_text" indexed="true" stored="true" multiValued="true" omitTermFreqAndPositions="true" /> ++ <dynamicField name="tws_*" type="text_ws" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="twm_*" type="text_ws" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- trie dates are preferred, so give them the 2 letter prefix --> ++ <dynamicField name="ds_*" type="tdate" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="dm_*" type="tdate" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="its_*" type="tlong" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="itm_*" type="tlong" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="fts_*" type="tfloat" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ftm_*" type="tfloat" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="pts_*" type="tdouble" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ptm_*" type="tdouble" indexed="true" stored="true" multiValued="true"/> ++ <!-- Binary fields can be populated using base64 encoded data. Useful e.g. for embedding ++ a small image in a search result using the data URI scheme --> ++ <dynamicField name="xs_*" type="binary" indexed="false" stored="true" multiValued="false"/> ++ <dynamicField name="xm_*" type="binary" indexed="false" stored="true" multiValued="true"/> ++ <!-- In rare cases a date rather than tdate is needed for sortMissingLast --> ++ <dynamicField name="dds_*" type="date" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ddm_*" type="date" indexed="true" stored="true" multiValued="true"/> ++ <!-- Sortable fields, good for sortMissingLast support & ++ We use long for integer since 64 bit ints are now common in PHP. --> ++ <dynamicField name="iss_*" type="slong" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ism_*" type="slong" indexed="true" stored="true" multiValued="true"/> ++ <!-- In rare cases a sfloat rather than tfloat is needed for sortMissingLast --> ++ <dynamicField name="fss_*" type="sfloat" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="fsm_*" type="sfloat" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="pss_*" type="sdouble" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="psm_*" type="sdouble" indexed="true" stored="true" multiValued="true"/> ++ <!-- In case a 32 bit int is really needed, we provide these fields. 'h' is mnemonic for 'half word', i.e. 32 bit on 64 arch --> ++ <dynamicField name="hs_*" type="integer" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="hm_*" type="integer" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="hss_*" type="sint" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="hsm_*" type="sint" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="hts_*" type="tint" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="htm_*" type="tint" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- Unindexed string fields that can be used to store values that won't be searchable --> ++ <dynamicField name="zs_*" type="string" indexed="false" stored="true" multiValued="false"/> ++ <dynamicField name="zm_*" type="string" indexed="false" stored="true" multiValued="true"/> ++ ++ <!-- Fields for location searches. ++ http://wiki.apache.org/solr/SpatialSearch#geodist_-_The_distance_function --> ++ <dynamicField name="points_*" type="point" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="pointm_*" type="point" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="locs_*" type="location" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="locm_*" type="location" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="geos_*" type="geohash" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="geom_*" type="geohash" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="bboxs_*" type="bbox" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="bboxm_*" type="bbox" indexed="true" stored="true" multiValued="true" /> ++ <dynamicField name="rpts_*" type="location_rpt" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="rptm_*" type="location_rpt" indexed="true" stored="true" multiValued="true" /> ++ ++ <!-- Special fields for Solr 5 functionality. --> ++ <dynamicField name="phons_*" type="phonetic" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="phonm_*" type="phonetic" indexed="true" stored="true" multiValued="true" /> ++ ++ <!-- External file fields --> ++ <dynamicField name="eff_*" type="file"/> ++ ++ <!-- Sortable version of the dynamic string field --> ++ <dynamicField name="sort_*" type="sortString" indexed="true" stored="false"/> ++ <copyField source="ss_*" dest="sort_*"/> ++ ++ <!-- A random sort field --> ++ <dynamicField name="random_*" type="rand" indexed="true" stored="true"/> ++ ++ <!-- This field is used to store access information (e.g. node access grants), as opposed to field data --> ++ <dynamicField name="access_*" type="integer" indexed="true" stored="false" multiValued="true"/> ++ ++ <!-- The following causes solr to ignore any fields that don't already match an existing ++ field name or dynamic field, rather than reporting them as an error. ++ Alternately, change the type="ignored" to some other type e.g. "text" if you want ++ unknown fields indexed and/or stored by default --> ++ <dynamicField name="*" type="ignored" multiValued="true" /> ++ ++ </fields> ++ ++ <!-- Following is a dynamic way to include other fields, added by other contrib modules --> ++ <xi:include href="schema_extra_fields.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback></xi:fallback> ++ </xi:include> ++ ++ <!-- Field to use to determine and enforce document uniqueness. ++ Unless this field is marked with required="false", it will be a required field ++ --> ++ <uniqueKey>id</uniqueKey> ++ ++ <!-- Similarity is the scoring routine for each document vs. a query. ++ A custom Similarity or SimilarityFactory may be specified here, but ++ the default is fine for most applications. ++ For more info: http://wiki.apache.org/solr/SchemaXml#Similarity ++ --> ++ <!-- ++ <similarity class="com.example.solr.CustomSimilarityFactory"> ++ <str name="paramkey">param value</str> ++ </similarity> ++ --> ++ ++ <!-- DEPRECATED: The defaultSearchField is consulted by various query parsers ++ when parsing a query string that isn't explicit about the field. Machine ++ (non-user) generated queries are best made explicit, or they can use the ++ "df" request parameter which takes precedence over this. ++ Note: Un-commenting defaultSearchField will be insufficient if your request ++ handler in solrconfig.xml defines "df", which takes precedence. That would ++ need to be removed. ++ <defaultSearchField>content</defaultSearchField> --> ++ ++ <!-- DEPRECATED: The defaultOperator (AND|OR) is consulted by various query ++ parsers when parsing a query string to determine if a clause of the query ++ should be marked as required or optional, assuming the clause isn't already ++ marked by some operator. The default is OR, which is generally assumed so it ++ is not a good idea to change it globally here. The "q.op" request parameter ++ takes precedence over this. ++ <solrQueryParser defaultOperator="OR"/> --> ++ ++</schema> +diff --git a/conf/6.x/schema_extra_fields.xml b/conf/6.x/schema_extra_fields.xml +new file mode 100644 +index 0000000..02b3655 +--- /dev/null ++++ b/conf/6.x/schema_extra_fields.xml +@@ -0,0 +1,23 @@ ++<fields> ++<!-- ++ Example: Adding German dynamic field types to our Solr Schema. ++ If you enable this, make sure you have a folder called lang containing ++ stopwords_de.txt and synonyms_de.txt. ++ This also requires to enable the content in schema_extra_types.xml. ++--> ++<!-- ++ <field name="label_de" type="text_de" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <field name="content_de" type="text_de" indexed="true" stored="true" termVectors="true"/> ++ <field name="teaser_de" type="text_de" indexed="false" stored="true"/> ++ <field name="path_alias_de" type="text_de" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <field name="taxonomy_names_de" type="text_de" indexed="true" stored="false" termVectors="true" multiValued="true" omitNorms="true"/> ++ <field name="spell_de" type="text_de" indexed="true" stored="true" multiValued="true"/> ++ <copyField source="label_de" dest="spell_de"/> ++ <copyField source="content_de" dest="spell_de"/> ++ <dynamicField name="tags_de_*" type="text_de" indexed="true" stored="false" omitNorms="true"/> ++ <dynamicField name="ts_de_*" type="text_de" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tm_de_*" type="text_de" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <dynamicField name="tos_de_*" type="text_de" indexed="true" stored="true" multiValued="false" termVectors="true" omitNorms="true"/> ++ <dynamicField name="tom_de_*" type="text_de" indexed="true" stored="true" multiValued="true" termVectors="true" omitNorms="true"/> ++--> ++</fields> +diff --git a/conf/6.x/schema_extra_types.xml b/conf/6.x/schema_extra_types.xml +new file mode 100644 +index 0000000..bd716b8 +--- /dev/null ++++ b/conf/6.x/schema_extra_types.xml +@@ -0,0 +1,34 @@ ++<types> ++<!-- ++ Example: Adding German language field types to our Solr Schema. ++ If you enable this, make sure you have a folder called lang containing ++ stopwords_de.txt and synonyms_de.txt. ++ ++ For examples from other languages, see ++ ./server/solr/configsets/sample_techproducts_configs/conf/schema.xml ++ from your Solr installation. ++--> ++<!-- ++ <fieldType name="text_de" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.StopFilterFactory" words="lang/stopwords_de.txt" format="snowball" ignoreCase="true"/> ++ <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" splitOnCaseChange="1" splitOnNumerics="1" catenateWords="1" catenateNumbers="1" catenateAll="0" protected="protwords.txt" preserveOriginal="1"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.GermanLightStemFilterFactory"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="lang/synonyms_de.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" words="lang/stopwords_de.txt" format="snowball" ignoreCase="true"/> ++ <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" splitOnCaseChange="1" splitOnNumerics="1" catenateWords="0" catenateNumbers="0" catenateAll="0" protected="protwords.txt" preserveOriginal="1"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.GermanLightStemFilterFactory"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ </fieldType> ++--> ++</types> +diff --git a/conf/6.x/solrconfig.xml b/conf/6.x/solrconfig.xml +new file mode 100644 +index 0000000..54946ad +--- /dev/null ++++ b/conf/6.x/solrconfig.xml +@@ -0,0 +1,1792 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++<!-- ++ Licensed to the Apache Software Foundation (ASF) under one or more ++ contributor license agreements. See the NOTICE file distributed with ++ this work for additional information regarding copyright ownership. ++ The ASF licenses this file to You under the Apache License, Version 2.0 ++ (the "License"); you may not use this file except in compliance with ++ the License. You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ See the License for the specific language governing permissions and ++ limitations under the License. ++--> ++ ++<!-- ++ For more details about configurations options that may appear in ++ this file, see http://wiki.apache.org/solr/SolrConfigXml. ++--> ++<config name="drupal-4.4-solr-6.x" > ++ <!-- In all configuration below, a prefix of "solr." for class names ++ is an alias that causes solr to search appropriate packages, ++ including org.apache.solr.(search|update|request|core|analysis) ++ ++ You may also specify a fully qualified Java classname if you ++ have your own custom plugins. ++ --> ++ ++ <!-- Set this to 'false' if you want solr to continue working after ++ it has encountered an severe configuration error. In a ++ production environment, you may want solr to keep working even ++ if one handler is mis-configured. ++ ++ You may also set this to false using by setting the system ++ property: ++ ++ -Dsolr.abortOnConfigurationError=false ++ --> ++ <abortOnConfigurationError>${solr.abortOnConfigurationError:true}</abortOnConfigurationError> ++ ++ <!-- Controls what version of Lucene various components of Solr ++ adhere to. Generally, you want to use the latest version to ++ get all bug fixes and improvements. It is highly recommended ++ that you fully re-index after changing this setting as it can ++ affect both how text is indexed and queried. ++ --> ++ <luceneMatchVersion>${solr.luceneMatchVersion:LUCENE_60}</luceneMatchVersion> ++ ++ <!-- <lib/> directives can be used to instruct Solr to load any Jars ++ identified and use them to resolve any "plugins" specified in ++ your solrconfig.xml or schema.xml (ie: Analyzers, Request ++ Handlers, etc...). ++ ++ All directories and paths are resolved relative to the ++ instanceDir. ++ ++ Please note that <lib/> directives are processed in the order ++ that they appear in your solrconfig.xml file, and are "stacked" ++ on top of each other when building a ClassLoader - so if you have ++ plugin jars with dependencies on other jars, the "lower level" ++ dependency jars should be loaded first. ++ ++ If a "./lib" directory exists in your instanceDir, all files ++ found in it are included as if you had used the following ++ syntax... ++ ++ <lib dir="./lib" /> ++ --> ++ ++ <!-- A "dir" option by itself adds any files found in the directory to the ++ classpath, this is useful for including all jars in a directory. ++ --> ++ <lib dir="${solr.contrib.dir:../../../contrib}/extraction/lib" /> ++ <lib dir="${solr.contrib.dir:../../../contrib}/clustering/lib/" /> ++ ++ <!-- The velocity library has been known to crash Solr in some ++ instances when deployed as a war file to Tomcat. Therefore all ++ references have been removed from the default configuration. ++ @see http://drupal.org/node/1612556 ++ --> ++ <!-- <lib dir="../../contrib/velocity/lib" /> --> ++ ++ <!-- When a regex is specified in addition to a directory, only the ++ files in that directory which completely match the regex ++ (anchored on both ends) will be included. ++ --> ++ <!--<lib dir="../../dist/" regex="apache-solr-cell-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-clustering-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-dataimporthandler-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-langid-\d.*\.jar" />--> ++ <!-- <lib dir="../../dist/" regex="apache-solr-velocity-\d.*\.jar" /> --> ++ ++ <!-- If a dir option (with or without a regex) is used and nothing ++ is found that matches, it will be ignored ++ --> ++ <!--<lib dir="../../contrib/clustering/lib/" />--> ++ <!--<lib dir="/total/crap/dir/ignored" />--> ++ ++ <!-- an exact path can be used to specify a specific file. This ++ will cause a serious error to be logged if it can't be loaded. ++ --> ++ <!-- ++ <lib path="../a-jar-that-does-not-exist.jar" /> ++ --> ++ ++ <!-- Data Directory ++ ++ Used to specify an alternate directory to hold all index data ++ other than the default ./data under the Solr home. If ++ replication is in use, this should match the replication ++ configuration. ++ --> ++ <dataDir>${solr.data.dir:}</dataDir> ++ ++ <!-- The DirectoryFactory to use for indexes. ++ ++ solr.StandardDirectoryFactory is filesystem ++ based and tries to pick the best implementation for the current ++ JVM and platform. solr.NRTCachingDirectoryFactory, the default, ++ wraps solr.StandardDirectoryFactory and caches small files in memory ++ for better NRT performance. ++ ++ One can force a particular implementation via solr.MMapDirectoryFactory, ++ solr.NIOFSDirectoryFactory, or solr.SimpleFSDirectoryFactory. ++ ++ solr.RAMDirectoryFactory is memory based, not ++ persistent, and doesn't work with replication. ++ --> ++ <directoryFactory name="DirectoryFactory" ++ class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}"/> ++ ++ <!-- The CodecFactory for defining the format of the inverted index. ++ The default implementation is SchemaCodecFactory, which is the official ++ Lucene index format, but hooks into the schema to provide per-field ++ customization of the postings lists and per-document values in the ++ fieldType element (postingsFormat/docValuesFormat). Note that most of the ++ alternative implementations are experimental, so if you choose to ++ customize the index format, it's a good idea to convert back to the ++ official format e.g. via IndexWriter.addIndexes(IndexReader) before ++ upgrading to a newer version to avoid unnecessary reindexing. ++ --> ++ <codecFactory class="solr.SchemaCodecFactory"/> ++ ++ <!-- To enable dynamic schema REST APIs, use the following for <schemaFactory>: ++ ++ <schemaFactory class="ManagedIndexSchemaFactory"> ++ <bool name="mutable">true</bool> ++ <str name="managedSchemaResourceName">managed-schema</str> ++ </schemaFactory> ++ ++ When ManagedIndexSchemaFactory is specified, Solr will load the schema from ++ the resource named in 'managedSchemaResourceName', rather than from schema.xml. ++ Note that the managed schema resource CANNOT be named schema.xml. If the managed ++ schema does not exist, Solr will create it after reading schema.xml, then rename ++ 'schema.xml' to 'schema.xml.bak'. ++ ++ Do NOT hand edit the managed schema - external modifications will be ignored and ++ overwritten as a result of schema modification REST API calls. ++ ++ When ManagedIndexSchemaFactory is specified with mutable = true, schema ++ modification REST API calls will be allowed; otherwise, error responses will be ++ sent back for these requests. ++ --> ++ <schemaFactory class="ClassicIndexSchemaFactory"/> ++ ++ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ Index Config - These settings control low-level behavior of indexing ++ Most example settings here show the default value, but are commented ++ out, to more easily see where customizations have been made. ++ ++ Note: This replaces <indexDefaults> and <mainIndex> from older versions ++ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --> ++ <indexConfig> ++ <!-- maxFieldLength was removed in 4.0. To get similar behavior, include a ++ LimitTokenCountFilterFactory in your fieldType definition. E.g. ++ <filter class="solr.LimitTokenCountFilterFactory" maxTokenCount="10000"/> ++ --> ++ <!-- Maximum time to wait for a write lock (ms) for an IndexWriter. Default: 1000 --> ++ <!-- <writeLockTimeout>1000</writeLockTimeout> --> ++ ++ <!-- The maximum number of simultaneous threads that may be ++ indexing documents at once in IndexWriter; if more than this ++ many threads arrive they will wait for others to finish. ++ Default in Solr/Lucene is 8. --> ++ <!-- <maxIndexingThreads>8</maxIndexingThreads> --> ++ ++ <!-- Expert: Enabling compound file will use less files for the index, ++ using fewer file descriptors on the expense of performance decrease. ++ Default in Lucene is "true". Default in Solr is "false" (since 3.6) --> ++ <!-- <useCompoundFile>false</useCompoundFile> --> ++ ++ <!-- ramBufferSizeMB sets the amount of RAM that may be used by Lucene ++ indexing for buffering added documents and deletions before they are ++ flushed to the Directory. ++ maxBufferedDocs sets a limit on the number of documents buffered ++ before flushing. ++ If both ramBufferSizeMB and maxBufferedDocs is set, then ++ Lucene will flush based on whichever limit is hit first. ++ The default is 100 MB. --> ++ <ramBufferSizeMB>32</ramBufferSizeMB> ++ <!-- <maxBufferedDocs>1000</maxBufferedDocs> --> ++ ++ <!-- Expert: Merge Policy ++ ++ The Merge Policy in Lucene controls how merging is handled by ++ Lucene. The default in Solr 3.3 is TieredMergePolicy. ++ ++ The default in 2.3 was the LogByteSizeMergePolicy, ++ previous versions used LogDocMergePolicy. ++ ++ LogByteSizeMergePolicy chooses segments to merge based on ++ their size. The Lucene 2.2 default, LogDocMergePolicy chose ++ when to merge based on number of documents ++ ++ Other implementations of MergePolicy must have a no-argument ++ constructor ++ --> ++ <mergePolicy class="org.apache.lucene.index.LogByteSizeMergePolicy"/> ++ ++ <!-- Expert: Merge Scheduler ++ ++ The Merge Scheduler in Lucene controls how merges are ++ performed. The ConcurrentMergeScheduler (Lucene 2.3 default) ++ can perform merges in the background using separate threads. ++ The SerialMergeScheduler (Lucene 2.2 default) does not. ++ --> ++ <!-- ++ <mergeScheduler class="org.apache.lucene.index.ConcurrentMergeScheduler"/> ++ --> ++ ++ <!-- Merge Factor ++ The merge factor controls how many segments will get merged at a time. ++ For TieredMergePolicy, mergeFactor is a convenience parameter which ++ will set both MaxMergeAtOnce and SegmentsPerTier at once. ++ For LogByteSizeMergePolicy, mergeFactor decides how many new segments ++ will be allowed before they are merged into one. ++ --> ++ <mergeFactor>4</mergeFactor> ++ ++ <!-- LockFactory ++ ++ This option specifies which Lucene LockFactory implementation ++ to use. ++ ++ single = SingleInstanceLockFactory - suggested for a ++ read-only index or when there is no possibility of ++ another process trying to modify the index. ++ native = NativeFSLockFactory - uses OS native file locking. ++ Do not use when multiple solr webapps in the same ++ JVM are attempting to share a single index. ++ simple = SimpleFSLockFactory - uses a plain file for locking ++ ++ Defaults: 'native' is default for Solr3.6 and later, otherwise ++ 'simple' is the default ++ ++ More details on the nuances of each LockFactory... ++ http://wiki.apache.org/lucene-java/AvailableLockFactories ++ --> ++ <lockType>${solr.lock.type:native}</lockType> ++ ++ <!-- Expert: Controls how often Lucene loads terms into memory ++ Default is 128 and is likely good for most everyone. ++ --> ++ <!-- <termIndexInterval>256</termIndexInterval> --> ++ ++ <!-- If true, IndexReaders will be reopened (often more efficient) ++ instead of closed and then opened. ++ --> ++ <reopenReaders>true</reopenReaders> ++ ++ <!-- Commit Deletion Policy ++ ++ Custom deletion policies can be specified here. The class must ++ implement org.apache.lucene.index.IndexDeletionPolicy. ++ ++ http://lucene.apache.org/java/2_9_1/api/all/org/apache/lucene/index/IndexDeletionPolicy.html ++ ++ The default Solr IndexDeletionPolicy implementation supports ++ deleting index commit points on number of commits, age of ++ commit point and optimized status. ++ ++ The latest commit point should always be preserved regardless ++ of the criteria. ++ --> ++ <deletionPolicy class="solr.SolrDeletionPolicy"> ++ <!-- The number of commit points to be kept --> ++ <str name="maxCommitsToKeep">1</str> ++ <!-- The number of optimized commit points to be kept --> ++ <str name="maxOptimizedCommitsToKeep">0</str> ++ <!-- ++ Delete all commit points once they have reached the given age. ++ Supports DateMathParser syntax e.g. ++ --> ++ <!-- ++ <str name="maxCommitAge">30MINUTES</str> ++ <str name="maxCommitAge">1DAY</str> ++ --> ++ </deletionPolicy> ++ ++ <!-- Lucene Infostream ++ ++ To aid in advanced debugging, Lucene provides an "InfoStream" ++ of detailed information when indexing. ++ ++ Setting the value to true will instruct the underlying Lucene ++ IndexWriter to write its info stream to solr's log. By default, ++ this is enabled here, and controlled through log4j.properties. ++ --> ++ <infoStream>true</infoStream> ++ ++ </indexConfig> ++ ++ <!-- JMX ++ ++ This example enables JMX if and only if an existing MBeanServer ++ is found, use this if you want to configure JMX through JVM ++ parameters. Remove this to disable exposing Solr configuration ++ and statistics to JMX. ++ ++ For more details see http://wiki.apache.org/solr/SolrJmx ++ --> ++ <!-- <jmx /> --> ++ <!-- If you want to connect to a particular server, specify the ++ agentId ++ --> ++ <!-- <jmx agentId="myAgent" /> --> ++ <!-- If you want to start a new MBeanServer, specify the serviceUrl --> ++ <!-- <jmx serviceUrl="service:jmx:rmi:///jndi/rmi://localhost:9999/solr"/> ++ --> ++ ++ <!-- The default high-performance update handler --> ++ <updateHandler class="solr.DirectUpdateHandler2"> ++ ++ <!-- AutoCommit ++ ++ Perform a <commit/> automatically under certain conditions. ++ Instead of enabling autoCommit, consider using "commitWithin" ++ when adding documents. ++ ++ http://wiki.apache.org/solr/UpdateXmlMessages ++ ++ maxDocs - Maximum number of documents to add since the last ++ commit before automatically triggering a new commit. ++ ++ maxTime - Maximum amount of time that is allowed to pass ++ since a document was added before automaticly ++ triggering a new commit. ++ --> ++ <autoCommit> ++ <maxDocs>${solr.autoCommit.MaxDocs:10000}</maxDocs> ++ <maxTime>${solr.autoCommit.MaxTime:120000}</maxTime> ++ </autoCommit> ++ ++ <!-- softAutoCommit is like autoCommit except it causes a ++ 'soft' commit which only ensures that changes are visible ++ but does not ensure that data is synced to disk. This is ++ faster and more near-realtime friendly than a hard commit. ++ --> ++ <autoSoftCommit> ++ <maxDocs>${solr.autoSoftCommit.MaxDocs:2000}</maxDocs> ++ <maxTime>${solr.autoSoftCommit.MaxTime:10000}</maxTime> ++ </autoSoftCommit> ++ ++ <!-- Update Related Event Listeners ++ ++ Various IndexWriter related events can trigger Listeners to ++ take actions. ++ ++ postCommit - fired after every commit or optimize command ++ postOptimize - fired after every optimize command ++ --> ++ <!-- The RunExecutableListener executes an external command from a ++ hook such as postCommit or postOptimize. ++ ++ exe - the name of the executable to run ++ dir - dir to use as the current working directory. (default=".") ++ wait - the calling thread waits until the executable returns. ++ (default="true") ++ args - the arguments to pass to the program. (default is none) ++ env - environment variables to set. (default is none) ++ --> ++ <!-- This example shows how RunExecutableListener could be used ++ with the script based replication... ++ http://wiki.apache.org/solr/CollectionDistribution ++ --> ++ <!-- ++ <listener event="postCommit" class="solr.RunExecutableListener"> ++ <str name="exe">solr/bin/snapshooter</str> ++ <str name="dir">.</str> ++ <bool name="wait">true</bool> ++ <arr name="args"> <str>arg1</str> <str>arg2</str> </arr> ++ <arr name="env"> <str>MYVAR=val1</str> </arr> ++ </listener> ++ --> ++ <!-- Enables a transaction log, currently used for real-time get. ++ "dir" - the target directory for transaction logs, defaults to the ++ solr data directory. --> ++ <updateLog> ++ <str name="dir">${solr.data.dir:}</str> ++ <!-- if you want to take control of the synchronization you may specify ++ the syncLevel as one of the following where ''flush'' is the default. ++ Fsync will reduce throughput. ++ <str name="syncLevel">flush|fsync|none</str> ++ --> ++ </updateLog> ++ </updateHandler> ++ ++ <!-- IndexReaderFactory ++ ++ Use the following format to specify a custom IndexReaderFactory, ++ which allows for alternate IndexReader implementations. ++ ++ ** Experimental Feature ** ++ ++ Please note - Using a custom IndexReaderFactory may prevent ++ certain other features from working. The API to ++ IndexReaderFactory may change without warning or may even be ++ removed from future releases if the problems cannot be ++ resolved. ++ ++ ** Features that may not work with custom IndexReaderFactory ** ++ ++ The ReplicationHandler assumes a disk-resident index. Using a ++ custom IndexReader implementation may cause incompatibility ++ with ReplicationHandler and may cause replication to not work ++ correctly. See SOLR-1366 for details. ++ ++ --> ++ <!-- ++ <indexReaderFactory name="IndexReaderFactory" class="package.class"> ++ <str name="someArg">Some Value</str> ++ </indexReaderFactory > ++ --> ++ ++ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ Query section - these settings control query time things like caches ++ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --> ++ <query> ++ <!-- Max Boolean Clauses ++ ++ Maximum number of clauses in each BooleanQuery, an exception ++ is thrown if exceeded. ++ ++ ** WARNING ** ++ ++ This option actually modifies a global Lucene property that ++ will affect all SolrCores. If multiple solrconfig.xml files ++ disagree on this property, the value at any given moment will ++ be based on the last SolrCore to be initialized. ++ ++ --> ++ <maxBooleanClauses>1024</maxBooleanClauses> ++ ++ <!-- Slow Query Threshold (in millis) ++ ++ At high request rates, logging all requests can become a bottleneck ++ and therefore INFO logging is often turned off. However, it is still ++ useful to be able to set a latency threshold above which a request ++ is considered "slow" and log that request at WARN level so we can ++ easily identify slow queries. ++ --> ++ <slowQueryThresholdMillis>-1</slowQueryThresholdMillis> ++ ++ <!-- Solr Internal Query Caches ++ ++ There are two implementations of cache available for Solr, ++ LRUCache, based on a synchronized LinkedHashMap, and ++ FastLRUCache, based on a ConcurrentHashMap. ++ ++ FastLRUCache has faster gets and slower puts in single ++ threaded operation and thus is generally faster than LRUCache ++ when the hit ratio of the cache is high (> 75%), and may be ++ faster under other scenarios on multi-cpu systems. ++ --> ++ ++ <!-- Filter Cache ++ ++ Cache used by SolrIndexSearcher for filters (DocSets), ++ unordered sets of *all* documents that match a query. When a ++ new searcher is opened, its caches may be prepopulated or ++ "autowarmed" using data from caches in the old searcher. ++ autowarmCount is the number of items to prepopulate. For ++ LRUCache, the autowarmed items will be the most recently ++ accessed items. ++ ++ Parameters: ++ class - the SolrCache implementation LRUCache or ++ (LRUCache or FastLRUCache) ++ size - the maximum number of entries in the cache ++ initialSize - the initial capacity (number of entries) of ++ the cache. (see java.util.HashMap) ++ autowarmCount - the number of entries to prepopulate from ++ and old cache. ++ --> ++ <filterCache class="solr.FastLRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="0"/> ++ ++ <!-- Query Result Cache ++ ++ Caches results of searches - ordered lists of document ids ++ (DocList) based on a query, a sort, and the range of documents requested. ++ --> ++ <queryResultCache class="solr.LRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="32"/> ++ ++ <!-- Document Cache ++ ++ Caches Lucene Document objects (the stored fields for each ++ document). Since Lucene internal document ids are transient, ++ this cache will not be autowarmed. ++ --> ++ <documentCache class="solr.LRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="0"/> ++ ++ <!-- Field Value Cache ++ ++ Cache used to hold field values that are quickly accessible ++ by document id. The fieldValueCache is created by default ++ even if not configured here. ++ --> ++ <!-- ++ <fieldValueCache class="solr.FastLRUCache" ++ size="512" ++ autowarmCount="128" ++ showItems="32" /> ++ --> ++ ++ <!-- Custom Cache ++ ++ Example of a generic cache. These caches may be accessed by ++ name through SolrIndexSearcher.getCache(),cacheLookup(), and ++ cacheInsert(). The purpose is to enable easy caching of ++ user/application level data. The regenerator argument should ++ be specified as an implementation of solr.CacheRegenerator ++ if autowarming is desired. ++ --> ++ <!-- ++ <cache name="myUserCache" ++ class="solr.LRUCache" ++ size="4096" ++ initialSize="1024" ++ autowarmCount="1024" ++ regenerator="com.mycompany.MyRegenerator" ++ /> ++ --> ++ ++ <!-- Lazy Field Loading ++ ++ If true, stored fields that are not requested will be loaded ++ lazily. This can result in a significant speed improvement ++ if the usual case is to not load all stored fields, ++ especially if the skipped fields are large compressed text ++ fields. ++ --> ++ <enableLazyFieldLoading>true</enableLazyFieldLoading> ++ ++ <!-- Use Filter For Sorted Query ++ ++ A possible optimization that attempts to use a filter to ++ satisfy a search. If the requested sort does not include ++ score, then the filterCache will be checked for a filter ++ matching the query. If found, the filter will be used as the ++ source of document ids, and then the sort will be applied to ++ that. ++ ++ For most situations, this will not be useful unless you ++ frequently get the same search repeatedly with different sort ++ options, and none of them ever use "score" ++ --> ++ <!-- ++ <useFilterForSortedQuery>true</useFilterForSortedQuery> ++ --> ++ ++ <!-- Result Window Size ++ ++ An optimization for use with the queryResultCache. When a search ++ is requested, a superset of the requested number of document ids ++ are collected. For example, if a search for a particular query ++ requests matching documents 10 through 19, and queryWindowSize is 50, ++ then documents 0 through 49 will be collected and cached. Any further ++ requests in that range can be satisfied via the cache. ++ --> ++ <queryResultWindowSize>20</queryResultWindowSize> ++ ++ <!-- Maximum number of documents to cache for any entry in the ++ queryResultCache. ++ --> ++ <queryResultMaxDocsCached>200</queryResultMaxDocsCached> ++ ++ <!-- Query Related Event Listeners ++ ++ Various IndexSearcher related events can trigger Listeners to ++ take actions. ++ ++ newSearcher - fired whenever a new searcher is being prepared ++ and there is a current searcher handling requests (aka ++ registered). It can be used to prime certain caches to ++ prevent long request times for certain requests. ++ ++ firstSearcher - fired whenever a new searcher is being ++ prepared but there is no current registered searcher to handle ++ requests or to gain autowarming data from. ++ ++ --> ++ <!-- QuerySenderListener takes an array of NamedList and executes a ++ local query request for each NamedList in sequence. ++ --> ++ <listener event="newSearcher" class="solr.QuerySenderListener"> ++ <arr name="queries"> ++ <!-- ++ <lst><str name="q">solr</str><str name="sort">price asc</str></lst> ++ <lst><str name="q">rocks</str><str name="sort">weight asc</str></lst> ++ --> ++ </arr> ++ </listener> ++ <listener event="firstSearcher" class="solr.QuerySenderListener"> ++ <arr name="queries"> ++ <lst> ++ <str name="q">solr rocks</str><str name="start">0</str><str name="rows">10</str> ++ </lst> ++ </arr> ++ </listener> ++ ++ <!-- Use Cold Searcher ++ ++ If a search request comes in and there is no current ++ registered searcher, then immediately register the still ++ warming searcher and use it. If "false" then all requests ++ will block until the first searcher is done warming. ++ --> ++ <useColdSearcher>false</useColdSearcher> ++ ++ <!-- Max Warming Searchers ++ ++ Maximum number of searchers that may be warming in the ++ background concurrently. An error is returned if this limit ++ is exceeded. ++ ++ Recommend values of 1-2 for read-only slaves, higher for ++ masters w/o cache warming. ++ --> ++ <maxWarmingSearchers>2</maxWarmingSearchers> ++ ++ </query> ++ ++ <!-- Request Dispatcher ++ ++ This section contains instructions for how the SolrDispatchFilter ++ should behave when processing requests for this SolrCore. ++ ++ handleSelect affects the behavior of requests such as /select?qt=XXX ++ ++ handleSelect="true" will cause the SolrDispatchFilter to process ++ the request and will result in consistent error handling and ++ formatting for all types of requests. ++ ++ handleSelect="false" will cause the SolrDispatchFilter to ++ ignore "/select" requests and fallback to using the legacy ++ SolrServlet and it's Solr 1.1 style error formatting ++ --> ++ <requestDispatcher handleSelect="true" > ++ <!-- Request Parsing ++ ++ These settings indicate how Solr Requests may be parsed, and ++ what restrictions may be placed on the ContentStreams from ++ those requests ++ ++ enableRemoteStreaming - enables use of the stream.file ++ and stream.url parameters for specifying remote streams. ++ ++ multipartUploadLimitInKB - specifies the max size (in KiB) of ++ Multipart File Uploads that Solr will allow in a Request. ++ ++ formdataUploadLimitInKB - specifies the max size (in KiB) of ++ form data (application/x-www-form-urlencoded) sent via ++ POST. You can use POST to pass request parameters not ++ fitting into the URL. ++ ++ addHttpRequestToContext - if set to true, it will instruct ++ the requestParsers to include the original HttpServletRequest ++ object in the context map of the SolrQueryRequest under the ++ key "httpRequest". It will not be used by any of the existing ++ Solr components, but may be useful when developing custom ++ plugins. ++ ++ *** WARNING *** ++ The settings below authorize Solr to fetch remote files, You ++ should make sure your system has some authentication before ++ using enableRemoteStreaming="true" ++ ++ --> ++ <requestParsers enableRemoteStreaming="true" ++ multipartUploadLimitInKB="2048000" ++ formdataUploadLimitInKB="2048" ++ addHttpRequestToContext="false"/> ++ ++ <!-- HTTP Caching ++ ++ Set HTTP caching related parameters (for proxy caches and clients). ++ ++ The options below instruct Solr not to output any HTTP Caching ++ related headers ++ --> ++ <httpCaching never304="true" /> ++ <!-- If you include a <cacheControl> directive, it will be used to ++ generate a Cache-Control header (as well as an Expires header ++ if the value contains "max-age=") ++ ++ By default, no Cache-Control header is generated. ++ ++ You can use the <cacheControl> option even if you have set ++ never304="true" ++ --> ++ <!-- ++ <httpCaching never304="true" > ++ <cacheControl>max-age=30, public</cacheControl> ++ </httpCaching> ++ --> ++ <!-- To enable Solr to respond with automatically generated HTTP ++ Caching headers, and to response to Cache Validation requests ++ correctly, set the value of never304="false" ++ ++ This will cause Solr to generate Last-Modified and ETag ++ headers based on the properties of the Index. ++ ++ The following options can also be specified to affect the ++ values of these headers... ++ ++ lastModFrom - the default value is "openTime" which means the ++ Last-Modified value (and validation against If-Modified-Since ++ requests) will all be relative to when the current Searcher ++ was opened. You can change it to lastModFrom="dirLastMod" if ++ you want the value to exactly correspond to when the physical ++ index was last modified. ++ ++ etagSeed="..." is an option you can change to force the ETag ++ header (and validation against If-None-Match requests) to be ++ different even if the index has not changed (ie: when making ++ significant changes to your config file) ++ ++ (lastModifiedFrom and etagSeed are both ignored if you use ++ the never304="true" option) ++ --> ++ <!-- ++ <httpCaching lastModifiedFrom="openTime" ++ etagSeed="Solr"> ++ <cacheControl>max-age=30, public</cacheControl> ++ </httpCaching> ++ --> ++ </requestDispatcher> ++ ++ <!-- Request Handlers ++ ++ http://wiki.apache.org/solr/SolrRequestHandler ++ ++ Incoming queries will be dispatched to a specific handler by name ++ based on the path specified in the request. ++ ++ Legacy behavior: If the request path uses "/select" but no Request ++ Handler has that name, and if handleSelect="true" has been specified in ++ the requestDispatcher, then the Request Handler is dispatched based on ++ the qt parameter. Handlers without a leading '/' are accessed this way ++ like so: http://host/app/[core/]select?qt=name If no qt is ++ given, then the requestHandler that declares default="true" will be ++ used or the one named "standard". ++ ++ If a Request Handler is declared with startup="lazy", then it will ++ not be initialized until the first request that uses it. ++ ++ --> ++ <!-- SearchHandler ++ ++ http://wiki.apache.org/solr/SearchHandler ++ ++ For processing Search Queries, the primary Request Handler ++ provided with Solr is "SearchHandler" It delegates to a sequent ++ of SearchComponents (see below) and supports distributed ++ queries across multiple shards ++ --> ++ <!--<requestHandler name="/select" class="solr.SearchHandler">--> ++ <!-- default values for query parameters can be specified, these ++ will be overridden by parameters in the request ++ --> ++ <!--<lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <int name="rows">10</int> ++ </lst>--> ++ <!-- In addition to defaults, "appends" params can be specified ++ to identify values which should be appended to the list of ++ multi-val params from the query (or the existing "defaults"). ++ --> ++ <!-- In this example, the param "fq=instock:true" would be appended to ++ any query time fq params the user may specify, as a mechanism for ++ partitioning the index, independent of any user selected filtering ++ that may also be desired (perhaps as a result of faceted searching). ++ ++ NOTE: there is *absolutely* nothing a client can do to prevent these ++ "appends" values from being used, so don't use this mechanism ++ unless you are sure you always want it. ++ --> ++ <!-- ++ <lst name="appends"> ++ <str name="fq">inStock:true</str> ++ </lst> ++ --> ++ <!-- "invariants" are a way of letting the Solr maintainer lock down ++ the options available to Solr clients. Any params values ++ specified here are used regardless of what values may be specified ++ in either the query, the "defaults", or the "appends" params. ++ ++ In this example, the facet.field and facet.query params would ++ be fixed, limiting the facets clients can use. Faceting is ++ not turned on by default - but if the client does specify ++ facet=true in the request, these are the only facets they ++ will be able to see counts for; regardless of what other ++ facet.field or facet.query params they may specify. ++ ++ NOTE: there is *absolutely* nothing a client can do to prevent these ++ "invariants" values from being used, so don't use this mechanism ++ unless you are sure you always want it. ++ --> ++ <!-- ++ <lst name="invariants"> ++ <str name="facet.field">cat</str> ++ <str name="facet.field">manu_exact</str> ++ <str name="facet.query">price:[* TO 500]</str> ++ <str name="facet.query">price:[500 TO *]</str> ++ </lst> ++ --> ++ <!-- If the default list of SearchComponents is not desired, that ++ list can either be overridden completely, or components can be ++ prepended or appended to the default list. (see below) ++ --> ++ <!-- ++ <arr name="components"> ++ <str>nameOfCustomComponent1</str> ++ <str>nameOfCustomComponent2</str> ++ </arr> ++ --> ++ <!--</requestHandler>--> ++ ++ <!-- A request handler that returns indented JSON by default --> ++ <requestHandler name="/query" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <str name="wt">json</str> ++ <str name="indent">true</str> ++ <str name="df">text</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- ++ The export request handler is used to export full sorted result sets. ++ Do not change these defaults. ++ --> ++ ++ <requestHandler name="/export" class="solr.SearchHandler"> ++ <lst name="invariants"> ++ <str name="rq">{!xport}</str> ++ <str name="wt">xsort</str> ++ <str name="distrib">false</str> ++ </lst> ++ ++ <arr name="components"> ++ <str>query</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- A Robust Example ++ ++ This example SearchHandler declaration shows off usage of the ++ SearchHandler with many defaults declared ++ ++ Note that multiple instances of the same Request Handler ++ (SearchHandler) can be registered multiple times with different ++ names (and different init parameters) ++ --> ++ <!-- ++ <requestHandler name="/browse" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str>--> ++ ++ <!-- VelocityResponseWriter settings --> ++ <!--<str name="wt">velocity</str> ++ ++ <str name="v.template">browse</str> ++ <str name="v.layout">layout</str> ++ <str name="title">Solritas</str> ++ ++ <str name="defType">edismax</str> ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ title^10.0 description^5.0 keywords^5.0 author^2.0 resourcename^1.0 ++ </str> ++ <str name="mm">100%</str> ++ <str name="q.alt">*:*</str> ++ <str name="rows">10</str> ++ <str name="fl">*,score</str> ++ <str name="mlt.qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ <str name="mlt.fl">text,features,name,sku,id,manu,cat</str> ++ <int name="mlt.count">3</int> ++ ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ ++ <str name="facet">on</str> ++ <str name="facet.field">cat</str> ++ <str name="facet.field">manu_exact</str> ++ <str name="facet.query">ipod</str> ++ <str name="facet.query">GB</str> ++ <str name="facet.mincount">1</str> ++ <str name="facet.pivot">cat,inStock</str> ++ <str name="facet.range.other">after</str> ++ <str name="facet.range">price</str> ++ <int name="f.price.facet.range.start">0</int> ++ <int name="f.price.facet.range.end">600</int> ++ <int name="f.price.facet.range.gap">50</int> ++ <str name="facet.range">popularity</str> ++ <int name="f.popularity.facet.range.start">0</int> ++ <int name="f.popularity.facet.range.end">10</int> ++ <int name="f.popularity.facet.range.gap">3</int> ++ <str name="facet.range">manufacturedate_dt</str> ++ <str name="f.manufacturedate_dt.facet.range.start">NOW/YEAR-10YEARS</str> ++ <str name="f.manufacturedate_dt.facet.range.end">NOW</str> ++ <str name="f.manufacturedate_dt.facet.range.gap">+1YEAR</str> ++ <str name="f.manufacturedate_dt.facet.range.other">before</str> ++ <str name="f.manufacturedate_dt.facet.range.other">after</str>--> ++ ++ <!-- Highlighting defaults --> ++ <!--<str name="hl">on</str> ++ <str name="hl.fl">text features name</str> ++ <str name="f.name.hl.fragsize">0</str> ++ <str name="f.name.hl.alternateField">name</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ </arr>--> ++ <!-- ++ <str name="url-scheme">httpx</str> ++ --> ++ <!--</requestHandler>--> ++ <!-- trivia: the name pinkPony requestHandler was an agreement between the Search API and the ++ apachesolr maintainers. The decision was taken during the Drupalcon Munich codesprint. ++ --> ++ <requestHandler name="pinkPony" class="solr.SearchHandler" default="true"> ++ <lst name="defaults"> ++ <str name="defType">edismax</str> ++ <str name="df">content</str> ++ <str name="echoParams">explicit</str> ++ <bool name="omitHeader">true</bool> ++ <float name="tie">0.01</float> ++ <!-- Don't abort searches for the pinkPony request handler (set in solrcore.properties) --> ++ <int name="timeAllowed">${solr.pinkPony.timeAllowed:-1}</int> ++ <str name="q.alt">*:*</str> ++ ++ <!-- By default, don't spell check --> ++ <str name="spellcheck">false</str> ++ <!-- Defaults for the spell checker when used --> ++ <str name="spellcheck.onlyMorePopular">true</str> ++ <str name="spellcheck.extendedResults">false</str> ++ <!-- The number of suggestions to return --> ++ <str name="spellcheck.count">1</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ <str>elevator</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- The more like this handler offers many advantages over the standard handler, ++ when performing moreLikeThis requests.--> ++ <requestHandler name="mlt" class="solr.MoreLikeThisHandler"> ++ <lst name="defaults"> ++ <str name="df">content</str> ++ <str name="mlt.mintf">1</str> ++ <str name="mlt.mindf">1</str> ++ <str name="mlt.minwl">3</str> ++ <str name="mlt.maxwl">15</str> ++ <str name="mlt.maxqt">20</str> ++ <str name="mlt.match.include">false</str> ++ <!-- Abort any searches longer than 2 seconds (set in solrcore.properties) --> ++ <int name="timeAllowed">${solr.mlt.timeAllowed:2000}</int> ++ </lst> ++ </requestHandler> ++ ++ <!-- A minimal query type for doing luene queries --> ++ <requestHandler name="standard" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="df">content</str> ++ <str name="echoParams">explicit</str> ++ <bool name="omitHeader">true</bool> ++ </lst> ++ </requestHandler> ++ ++ <!-- Update Request Handler. ++ ++ http://wiki.apache.org/solr/UpdateXmlMessages ++ ++ The canonical Request Handler for Modifying the Index through ++ commands specified using XML, JSON, CSV, or JAVABIN ++ ++ Note: Since solr1.1 requestHandlers requires a valid content ++ type header if posted in the body. For example, curl now ++ requires: -H 'Content-type:text/xml; charset=utf-8' ++ ++ To override the request content type and force a specific ++ Content-type, use the request parameter: ++ ?update.contentType=text/csv ++ ++ This handler will pick a response format to match the input ++ if the 'wt' parameter is not explicit ++ --> ++ <!--<requestHandler name="/update" class="solr.UpdateRequestHandler"> ++ </requestHandler>--> ++ <initParams path="/update/**,/query,/select,/tvrh,/elevate,/spell,/browse"> ++ <lst name="defaults"> ++ <str name="df">text</str> ++ </lst> ++ </initParams> ++ ++ <initParams path="/update/json/docs"> ++ <lst name="defaults"> ++ <!--this ensures that the entire json doc will be stored verbatim into one field--> ++ <str name="srcField">_src_</str> ++ <!--This means a the uniqueKeyField will be extracted from the fields and ++ all fields go into the 'df' field. In this config df is already configured to be 'text' ++ --> ++ <str name="mapUniqueKeyOnly">true</str> ++ </lst> ++ ++ </initParams> ++ ++ <!-- CSV Update Request Handler ++ http://wiki.apache.org/solr/UpdateCSV ++ --> ++ <requestHandler name="/update/csv" ++ class="solr.CSVRequestHandler" ++ startup="lazy" /> ++ ++ <!-- JSON Update Request Handler ++ http://wiki.apache.org/solr/UpdateJSON ++ --> ++ <requestHandler name="/update/json" ++ class="solr.JsonUpdateRequestHandler" ++ startup="lazy" /> ++ ++ <!-- Solr Cell Update Request Handler ++ ++ http://wiki.apache.org/solr/ExtractingRequestHandler ++ ++ --> ++ <requestHandler name="/update/extract" ++ startup="lazy" ++ class="solr.extraction.ExtractingRequestHandler" > ++ <lst name="defaults"> ++ <!-- All the main content goes into "text"... if you need to return ++ the extracted text or do highlighting, use a stored field. --> ++ <str name="fmap.content">text</str> ++ <str name="lowernames">true</str> ++ <str name="uprefix">ignored_</str> ++ ++ <!-- capture link hrefs but ignore div attributes --> ++ <str name="captureAttr">true</str> ++ <str name="fmap.a">links</str> ++ <str name="fmap.div">ignored_</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- XSLT Update Request Handler ++ Transforms incoming XML with stylesheet identified by tr= ++ --> ++ <requestHandler name="/update/xslt" ++ startup="lazy" ++ class="solr.XsltUpdateRequestHandler"/> ++ ++ <!-- Field Analysis Request Handler ++ ++ RequestHandler that provides much the same functionality as ++ analysis.jsp. Provides the ability to specify multiple field ++ types and field names in the same request and outputs ++ index-time and query-time analysis for each of them. ++ ++ Request parameters are: ++ analysis.fieldname - field name whose analyzers are to be used ++ ++ analysis.fieldtype - field type whose analyzers are to be used ++ analysis.fieldvalue - text for index-time analysis ++ q (or analysis.q) - text for query time analysis ++ analysis.showmatch (true|false) - When set to true and when ++ query analysis is performed, the produced tokens of the ++ field value analysis will be marked as "matched" for every ++ token that is produces by the query analysis ++ --> ++ <requestHandler name="/analysis/field" ++ startup="lazy" ++ class="solr.FieldAnalysisRequestHandler" /> ++ ++ <!-- Document Analysis Handler ++ ++ http://wiki.apache.org/solr/AnalysisRequestHandler ++ ++ An analysis handler that provides a breakdown of the analysis ++ process of provided documents. This handler expects a (single) ++ content stream with the following format: ++ ++ <docs> ++ <doc> ++ <field name="id">1</field> ++ <field name="name">The Name</field> ++ <field name="text">The Text Value</field> ++ </doc> ++ <doc>...</doc> ++ <doc>...</doc> ++ ... ++ </docs> ++ ++ Note: Each document must contain a field which serves as the ++ unique key. This key is used in the returned response to associate ++ an analysis breakdown to the analyzed document. ++ ++ Like the FieldAnalysisRequestHandler, this handler also supports ++ query analysis by sending either an "analysis.query" or "q" ++ request parameter that holds the query text to be analyzed. It ++ also supports the "analysis.showmatch" parameter which when set to ++ true, all field tokens that match the query tokens will be marked ++ as a "match". ++ --> ++ <requestHandler name="/analysis/document" ++ class="solr.DocumentAnalysisRequestHandler" ++ startup="lazy" /> ++ ++ <!-- Admin Handlers ++ ++ As of Solr 5.0.0, the "/admin/" handlers are registered implicitly. ++ --> ++ <!-- <requestHandler name="/admin/" class="solr.admin.AdminHandlers" /> --> ++ <!-- This single handler is equivalent to the following... --> ++ <!-- ++ <requestHandler name="/admin/luke" class="solr.admin.LukeRequestHandler" /> ++ <requestHandler name="/admin/system" class="solr.admin.SystemInfoHandler" /> ++ <requestHandler name="/admin/plugins" class="solr.admin.PluginInfoHandler" /> ++ <requestHandler name="/admin/threads" class="solr.admin.ThreadDumpHandler" /> ++ <requestHandler name="/admin/properties" class="solr.admin.PropertiesRequestHandler" /> ++ <requestHandler name="/admin/file" class="solr.admin.ShowFileRequestHandler" > ++ --> ++ <!-- If you wish to hide files under ${solr.home}/conf, explicitly ++ register the ShowFileRequestHandler using the definition below. ++ NOTE: The glob pattern ('*') is the only pattern supported at present, *.xml will ++ not exclude all files ending in '.xml'. Use it to exclude _all_ updates ++ --> ++ <!-- ++ <requestHandler name="/admin/file" ++ class="solr.admin.ShowFileRequestHandler" > ++ <lst name="invariants"> ++ <str name="hidden">synonyms.txt</str> ++ <str name="hidden">anotherfile.txt</str> ++ <str name="hidden">*</str> ++ </lst> ++ </requestHandler> ++ --> ++ <!-- ++ Enabling this request handler (which is NOT a default part of the admin handler) will allow the Solr UI to edit ++ all the config files. This is intended for secure/development use ONLY! Leaving available and publically ++ accessible is a security vulnerability and should be done with extreme caution! ++ --> ++ <!-- ++ <requestHandler name="/admin/fileedit" class="solr.admin.EditFileRequestHandler" > ++ <lst name="invariants"> ++ <str name="qt">pinkPony</str> ++ <str name="q">solrpingquery</str> ++ <str name="omitHeader">false</str> ++ </lst> ++ <lst name="defaults"> ++ <str name="echoParams">all</str> ++ </lst> ++ <!- An optional feature of the PingRequestHandler is to configure the ++ handler with a "healthcheckFile" which can be used to enable/disable ++ the PingRequestHandler. ++ relative paths are resolved against the data dir ++ --> ++ <!-- <str name="healthcheckFile">server-enabled.txt</str> --> ++ <!-- </requestHandler> ++ --> ++ ++ <!-- Echo the request contents back to the client --> ++ <requestHandler name="/debug/dump" class="solr.DumpRequestHandler" > ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <str name="echoHandler">true</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Solr Replication ++ ++ The SolrReplicationHandler supports replicating indexes from a ++ "master" used for indexing and "slaves" used for queries. ++ ++ http://wiki.apache.org/solr/SolrReplication ++ ++ In the example below, remove the <lst name="master"> section if ++ this is just a slave and remove the <lst name="slave"> section ++ if this is just a master. ++ --> ++ <requestHandler name="/replication" class="solr.ReplicationHandler" > ++ <lst name="master"> ++ <str name="enable">${solr.replication.master:false}</str> ++ <str name="replicateAfter">commit</str> ++ <str name="replicateAfter">startup</str> ++ <str name="confFiles">${solr.replication.confFiles:schema.xml,mapping-ISOLatin1Accent.txt,protwords.txt,stopwords.txt,synonyms.txt,elevate.xml}</str> ++ </lst> ++ <lst name="slave"> ++ <str name="enable">${solr.replication.slave:false}</str> ++ <str name="masterUrl">${solr.replication.masterUrl:http://localhost:8983/solr}/replication</str> ++ <str name="pollInterval">${solr.replication.pollInterval:00:00:60}</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Realtime get handler, guaranteed to return the latest stored fields of ++ any document, without the need to commit or open a new searcher. The ++ current implementation relies on the updateLog feature being enabled. ++ --> ++ <requestHandler name="/get" class="solr.RealTimeGetHandler"> ++ <lst name="defaults"> ++ <str name="omitHeader">true</str> ++ <str name="wt">json</str> ++ <str name="indent">true</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Search Components ++ ++ Search components are registered to SolrCore and used by ++ instances of SearchHandler (which can access them by name) ++ ++ By default, the following components are available: ++ ++ <searchComponent name="query" class="solr.QueryComponent" /> ++ <searchComponent name="facet" class="solr.FacetComponent" /> ++ <searchComponent name="mlt" class="solr.MoreLikeThisComponent" /> ++ <searchComponent name="highlight" class="solr.HighlightComponent" /> ++ <searchComponent name="stats" class="solr.StatsComponent" /> ++ <searchComponent name="debug" class="solr.DebugComponent" /> ++ ++ Default configuration in a requestHandler would look like: ++ ++ <arr name="components"> ++ <str>query</str> ++ <str>facet</str> ++ <str>mlt</str> ++ <str>highlight</str> ++ <str>stats</str> ++ <str>debug</str> ++ </arr> ++ ++ If you register a searchComponent to one of the standard names, ++ that will be used instead of the default. ++ ++ To insert components before or after the 'standard' components, use: ++ ++ <arr name="first-components"> ++ <str>myFirstComponentName</str> ++ </arr> ++ ++ <arr name="last-components"> ++ <str>myLastComponentName</str> ++ </arr> ++ ++ NOTE: The component registered with the name "debug" will ++ always be executed after the "last-components" ++ ++ --> ++ ++ <!-- A request handler for demonstrating the spellcheck component. ++ ++ NOTE: This is purely as an example. The whole purpose of the ++ SpellCheckComponent is to hook it into the request handler that ++ handles your normal user queries so that a separate request is ++ not needed to get suggestions. ++ ++ IN OTHER WORDS, THERE IS REALLY GOOD CHANCE THE SETUP BELOW IS ++ NOT WHAT YOU WANT FOR YOUR PRODUCTION SYSTEM! ++ ++ See http://wiki.apache.org/solr/SpellCheckComponent for details ++ on the request parameters. ++ --> ++ <requestHandler name="/spell" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <!-- Solr will use suggestions from both the 'default' spellchecker ++ and from the 'wordbreak' spellchecker and combine them. ++ collations (re-written queries) can include a combination of ++ corrections from both spellcheckers --> ++ <str name="spellcheck.dictionary">default</str> ++ <str name="spellcheck.dictionary">wordbreak</str> ++ <str name="spellcheck.onlyMorePopular">false</str> ++ <str name="spellcheck.extendedResults">false</str> ++ <str name="spellcheck.count">1</str> ++ <str name="spellcheck.alternativeTermCount">5</str> ++ <str name="spellcheck.maxResultsForSuggest">5</str> ++ <str name="spellcheck.collate">true</str> ++ <str name="spellcheck.collateExtendedResults">true</str> ++ <str name="spellcheck.maxCollationTries">10</str> ++ <str name="spellcheck.maxCollations">5</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- This is disabled by default because it currently causes long startup times on ++ big indexes, even when never used. See SOLR-6679 for background. ++ ++ To use this suggester, set the "solr.suggester.enabled=true" system property ++ --> ++ <searchComponent name="suggest" class="solr.SuggestComponent" ++ enable="${solr.suggester.enabled:false}" > ++ <lst name="suggester"> ++ <str name="name">mySuggester</str> ++ <str name="lookupImpl">FuzzyLookupFactory</str> ++ <str name="dictionaryImpl">DocumentDictionaryFactory</str> ++ <str name="field">cat</str> ++ <str name="weightField">price</str> ++ <str name="suggestAnalyzerFieldType">string</str> ++ </lst> ++ </searchComponent> ++ ++ <requestHandler name="/suggest" class="solr.SearchHandler" ++ startup="lazy" enable="${solr.suggester.enabled:false}" > ++ <lst name="defaults"> ++ <str name="suggest">true</str> ++ <str name="suggest.count">10</str> ++ </lst> ++ <arr name="components"> ++ <str>suggest</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Term Vector Component ++ ++ http://wiki.apache.org/solr/TermVectorComponent ++ --> ++ <searchComponent name="tvComponent" class="solr.TermVectorComponent"/> ++ ++ <!-- A request handler for demonstrating the term vector component ++ ++ This is purely as an example. ++ ++ In reality you will likely want to add the component to your ++ already specified request handlers. ++ --> ++ <requestHandler name="/tvrh" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <bool name="tv">true</bool> ++ </lst> ++ <arr name="last-components"> ++ <str>tvComponent</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Clustering Component ++ ++ http://wiki.apache.org/solr/ClusteringComponent ++ ++ This relies on third party jars which are notincluded in the ++ release. To use this component (and the "/clustering" handler) ++ Those jars will need to be downloaded, and you'll need to set ++ the solr.cluster.enabled system property when running solr... ++ ++ java -Dsolr.clustering.enabled=true -jar start.jar ++ --> ++ <!-- <searchComponent name="clustering" ++ enable="${solr.clustering.enabled:false}" ++ class="solr.clustering.ClusteringComponent" > --> ++ <!-- Declare an engine --> ++ <!--<lst name="engine">--> ++ <!-- The name, only one can be named "default" --> ++ <!--<str name="name">default</str>--> ++ ++ <!-- Class name of Carrot2 clustering algorithm. ++ ++ Currently available algorithms are: ++ ++ * org.carrot2.clustering.lingo.LingoClusteringAlgorithm ++ * org.carrot2.clustering.stc.STCClusteringAlgorithm ++ * org.carrot2.clustering.kmeans.BisectingKMeansClusteringAlgorithm ++ ++ See http://project.carrot2.org/algorithms.html for the ++ algorithm's characteristics. ++ --> ++ <!--<str name="carrot.algorithm">org.carrot2.clustering.lingo.LingoClusteringAlgorithm</str>--> ++ ++ <!-- Overriding values for Carrot2 default algorithm attributes. ++ ++ For a description of all available attributes, see: ++ http://download.carrot2.org/stable/manual/#chapter.components. ++ Use attribute key as name attribute of str elements ++ below. These can be further overridden for individual ++ requests by specifying attribute key as request parameter ++ name and attribute value as parameter value. ++ --> ++ <!--<str name="LingoClusteringAlgorithm.desiredClusterCountBase">20</str>--> ++ ++ <!-- Location of Carrot2 lexical resources. ++ ++ A directory from which to load Carrot2-specific stop words ++ and stop labels. Absolute or relative to Solr config directory. ++ If a specific resource (e.g. stopwords.en) is present in the ++ specified dir, it will completely override the corresponding ++ default one that ships with Carrot2. ++ ++ For an overview of Carrot2 lexical resources, see: ++ http://download.carrot2.org/head/manual/#chapter.lexical-resources ++ --> ++ <!--<str name="carrot.lexicalResourcesDir">clustering/carrot2</str>--> ++ ++ <!-- The language to assume for the documents. ++ ++ For a list of allowed values, see: ++ http://download.carrot2.org/stable/manual/#section.attribute.lingo.MultilingualClustering.defaultLanguage ++ --> ++ <!--<str name="MultilingualClustering.defaultLanguage">ENGLISH</str> ++ </lst> ++ <lst name="engine"> ++ <str name="name">stc</str> ++ <str name="carrot.algorithm">org.carrot2.clustering.stc.STCClusteringAlgorithm</str> ++ </lst> ++ </searchComponent>--> ++ ++ <!-- A request handler for demonstrating the clustering component ++ ++ This is purely as an example. ++ ++ In reality you will likely want to add the component to your ++ already specified request handlers. ++ --> ++ <!--<requestHandler name="/clustering" ++ startup="lazy" ++ enable="${solr.clustering.enabled:false}" ++ class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <bool name="clustering">true</bool> ++ <str name="clustering.engine">default</str> ++ <bool name="clustering.results">true</bool>--> ++ <!-- The title field --> ++ <!--<str name="carrot.title">name</str>--> ++ <!--<str name="carrot.url">id</str>--> ++ <!-- The field to cluster on --> ++ <!--<str name="carrot.snippet">features</str>--> ++ <!-- produce summaries --> ++ <!--<bool name="carrot.produceSummary">true</bool>--> ++ <!-- the maximum number of labels per cluster --> ++ <!--<int name="carrot.numDescriptions">5</int>--> ++ <!-- produce sub clusters --> ++ <!--<bool name="carrot.outputSubClusters">false</bool>--> ++ ++ <!--<str name="defType">edismax</str> ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ <str name="q.alt">*:*</str> ++ <str name="rows">10</str> ++ <str name="fl">*,score</str> ++ </lst> ++ <arr name="last-components"> ++ <str>clustering</str> ++ </arr> ++ </requestHandler>--> ++ ++ <!-- Terms Component ++ ++ http://wiki.apache.org/solr/TermsComponent ++ ++ A component to return terms and document frequency of those ++ terms ++ --> ++ <searchComponent name="terms" class="solr.TermsComponent"/> ++ ++ <!-- A request handler for demonstrating the terms component --> ++ <requestHandler name="/terms" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <bool name="terms">true</bool> ++ </lst> ++ <arr name="components"> ++ <str>terms</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Query Elevation Component ++ ++ http://wiki.apache.org/solr/QueryElevationComponent ++ ++ a search component that enables you to configure the top ++ results for a given query regardless of the normal lucene ++ scoring. ++ --> ++ <searchComponent name="elevator" class="solr.QueryElevationComponent" > ++ <!-- pick a fieldType to analyze queries --> ++ <str name="queryFieldType">string</str> ++ <str name="config-file">elevate.xml</str> ++ </searchComponent> ++ ++ <!-- A request handler for demonstrating the elevator component --> ++ <requestHandler name="/elevate" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ </lst> ++ <arr name="last-components"> ++ <str>elevator</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Highlighting Component ++ ++ http://wiki.apache.org/solr/HighlightingParameters ++ --> ++ <searchComponent class="solr.HighlightComponent" name="highlight"> ++ <highlighting> ++ <!-- Configure the standard fragmenter --> ++ <!-- This could most likely be commented out in the "default" case --> ++ <fragmenter name="gap" ++ default="true" ++ class="solr.highlight.GapFragmenter"> ++ <lst name="defaults"> ++ <int name="hl.fragsize">100</int> ++ </lst> ++ </fragmenter> ++ ++ <!-- A regular-expression-based fragmenter ++ (for sentence extraction) ++ --> ++ <fragmenter name="regex" ++ class="solr.highlight.RegexFragmenter"> ++ <lst name="defaults"> ++ <!-- slightly smaller fragsizes work better because of slop --> ++ <int name="hl.fragsize">70</int> ++ <!-- allow 50% slop on fragment sizes --> ++ <float name="hl.regex.slop">0.5</float> ++ <!-- a basic sentence pattern --> ++ <str name="hl.regex.pattern">[-\w ,/\n\"']{20,200}</str> ++ </lst> ++ </fragmenter> ++ ++ <!-- Configure the standard formatter --> ++ <formatter name="html" ++ default="true" ++ class="solr.highlight.HtmlFormatter"> ++ <lst name="defaults"> ++ <str name="hl.simple.pre"><![CDATA[<strong>]]></str> ++ <str name="hl.simple.post"><![CDATA[</strong>]]></str> ++ </lst> ++ </formatter> ++ ++ <!-- Configure the standard encoder --> ++ <encoder name="html" ++ class="solr.highlight.HtmlEncoder" /> ++ ++ <!-- Configure the standard fragListBuilder --> ++ <fragListBuilder name="simple" ++ default="true" ++ class="solr.highlight.SimpleFragListBuilder"/> ++ ++ <!-- Configure the single fragListBuilder --> ++ <fragListBuilder name="single" ++ class="solr.highlight.SingleFragListBuilder"/> ++ ++ <!-- default tag FragmentsBuilder --> ++ <fragmentsBuilder name="default" ++ default="true" ++ class="solr.highlight.ScoreOrderFragmentsBuilder"> ++ <!-- ++ <lst name="defaults"> ++ <str name="hl.multiValuedSeparatorChar">/</str> ++ </lst> ++ --> ++ </fragmentsBuilder> ++ ++ <!-- multi-colored tag FragmentsBuilder --> ++ <fragmentsBuilder name="colored" ++ class="solr.highlight.ScoreOrderFragmentsBuilder"> ++ <lst name="defaults"> ++ <str name="hl.tag.pre"><![CDATA[ ++ <b style="background:yellow">,<b style="background:lawgreen">, ++ <b style="background:aquamarine">,<b style="background:magenta">, ++ <b style="background:palegreen">,<b style="background:coral">, ++ <b style="background:wheat">,<b style="background:khaki">, ++ <b style="background:lime">,<b style="background:deepskyblue">]]></str> ++ <str name="hl.tag.post"><![CDATA[</b>]]></str> ++ </lst> ++ </fragmentsBuilder> ++ ++ <boundaryScanner name="default" ++ default="true" ++ class="solr.highlight.SimpleBoundaryScanner"> ++ <lst name="defaults"> ++ <str name="hl.bs.maxScan">10</str> ++ <str name="hl.bs.chars">.,!? 	 </str> ++ </lst> ++ </boundaryScanner> ++ ++ <boundaryScanner name="breakIterator" ++ class="solr.highlight.BreakIteratorBoundaryScanner"> ++ <lst name="defaults"> ++ <!-- type should be one of CHARACTER, WORD(default), LINE and SENTENCE --> ++ <str name="hl.bs.type">WORD</str> ++ <!-- language and country are used when constructing Locale object. --> ++ <!-- And the Locale object will be used when getting instance of BreakIterator --> ++ <str name="hl.bs.language">en</str> ++ <str name="hl.bs.country">US</str> ++ </lst> ++ </boundaryScanner> ++ </highlighting> ++ </searchComponent> ++ ++ <!-- Update Processors ++ ++ Chains of Update Processor Factories for dealing with Update ++ Requests can be declared, and then used by name in Update ++ Request Processors ++ ++ http://wiki.apache.org/solr/UpdateRequestProcessor ++ ++ --> ++ <!-- Deduplication ++ ++ An example dedup update processor that creates the "id" field ++ on the fly based on the hash code of some other fields. This ++ example has overwriteDupes set to false since we are using the ++ id field as the signatureField and Solr will maintain ++ uniqueness based on that anyway. ++ ++ --> ++ <!-- ++ <updateRequestProcessorChain name="dedupe"> ++ <processor class="solr.processor.SignatureUpdateProcessorFactory"> ++ <bool name="enabled">true</bool> ++ <str name="signatureField">id</str> ++ <bool name="overwriteDupes">false</bool> ++ <str name="fields">name,features,cat</str> ++ <str name="signatureClass">solr.processor.Lookup3Signature</str> ++ </processor> ++ <processor class="solr.LogUpdateProcessorFactory" /> ++ <processor class="solr.RunUpdateProcessorFactory" /> ++ </updateRequestProcessorChain> ++ --> ++ ++ <!-- Language identification ++ ++ This example update chain identifies the language of the incoming ++ documents using the langid contrib. The detected language is ++ written to field language_s. No field name mapping is done. ++ The fields used for detection are text, title, subject and description, ++ making this example suitable for detecting languages form full-text ++ rich documents injected via ExtractingRequestHandler. ++ See more about langId at http://wiki.apache.org/solr/LanguageDetection ++ --> ++ <!-- ++ <updateRequestProcessorChain name="langid"> ++ <processor class="org.apache.solr.update.processor.TikaLanguageIdentifierUpdateProcessorFactory"> ++ <str name="langid.fl">text,title,subject,description</str> ++ <str name="langid.langField">language_s</str> ++ <str name="langid.fallback">en</str> ++ </processor> ++ <processor class="solr.LogUpdateProcessorFactory" /> ++ <processor class="solr.RunUpdateProcessorFactory" /> ++ </updateRequestProcessorChain> ++ --> ++ ++ <!-- Response Writers ++ ++ http://wiki.apache.org/solr/QueryResponseWriter ++ ++ Request responses will be written using the writer specified by ++ the 'wt' request parameter matching the name of a registered ++ writer. ++ ++ The "default" writer is the default and will be used if 'wt' is ++ not specified in the request. ++ --> ++ <!-- The following response writers are implicitly configured unless ++ overridden... ++ --> ++ <!-- ++ <queryResponseWriter name="xml" ++ default="true" ++ class="solr.XMLResponseWriter" /> ++ <queryResponseWriter name="json" class="solr.JSONResponseWriter"/> ++ <queryResponseWriter name="python" class="solr.PythonResponseWriter"/> ++ <queryResponseWriter name="ruby" class="solr.RubyResponseWriter"/> ++ <queryResponseWriter name="php" class="solr.PHPResponseWriter"/> ++ <queryResponseWriter name="phps" class="solr.PHPSerializedResponseWriter"/> ++ <queryResponseWriter name="csv" class="solr.CSVResponseWriter"/> ++ --> ++ ++ <queryResponseWriter name="json" class="solr.JSONResponseWriter"> ++ <!-- For the purposes of the tutorial, JSON responses are written as ++ plain text so that they are easy to read in *any* browser. ++ If you expect a MIME type of "application/json" just remove this override. ++ --> ++ <str name="content-type">text/plain; charset=UTF-8</str> ++ </queryResponseWriter> ++ ++ <!-- ++ Custom response writers can be declared as needed... ++ --> ++ <!-- The solr.velocity.enabled flag is used by Solr's test cases so that this response writer is not ++ loaded (causing an error if contrib/velocity has not been built fully) --> ++ <!-- <queryResponseWriter name="velocity" class="solr.VelocityResponseWriter" enable="${solr.velocity.enabled:true}"/> --> ++ ++ <!-- XSLT response writer transforms the XML output by any xslt file found ++ in Solr's conf/xslt directory. Changes to xslt files are checked for ++ every xsltCacheLifetimeSeconds. ++ --> ++ <queryResponseWriter name="xslt" class="solr.XSLTResponseWriter"> ++ <int name="xsltCacheLifetimeSeconds">5</int> ++ </queryResponseWriter> ++ ++ <!-- Query Parsers ++ ++ http://wiki.apache.org/solr/SolrQuerySyntax ++ ++ Multiple QParserPlugins can be registered by name, and then ++ used in either the "defType" param for the QueryComponent (used ++ by SearchHandler) or in LocalParams ++ --> ++ <!-- example of registering a query parser --> ++ <!-- ++ <queryParser name="myparser" class="com.mycompany.MyQParserPlugin"/> ++ --> ++ ++ <!-- Function Parsers ++ ++ http://wiki.apache.org/solr/FunctionQuery ++ ++ Multiple ValueSourceParsers can be registered by name, and then ++ used as function names when using the "func" QParser. ++ --> ++ <!-- example of registering a custom function parser --> ++ <!-- ++ <valueSourceParser name="myfunc" ++ class="com.mycompany.MyValueSourceParser" /> ++ --> ++ ++ <!-- Legacy config for the admin interface --> ++ <admin> ++ <defaultQuery>*:*</defaultQuery> ++ ++ <!-- configure a healthcheck file for servers behind a ++ loadbalancer ++ --> ++ <!-- ++ <healthcheck type="file">server-enabled</healthcheck> ++ --> ++ </admin> ++ ++ <!-- Following is a dynamic way to include other components or any customized solrconfig.xml stuff, added by other contrib modules --> ++ <xi:include href="solrconfig_extra.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback> ++ <!-- Spell Check ++ ++ The spell check component can return a list of alternative spelling ++ suggestions. This component must be defined in ++ solrconfig_extra.xml if present, since it's used in the search handler. ++ ++ http://wiki.apache.org/solr/SpellCheckComponent ++ --> ++ <searchComponent name="spellcheck" class="solr.SpellCheckComponent"> ++ ++ <str name="queryAnalyzerFieldType">textSpell</str> ++ ++ <!-- a spellchecker built from a field of the main index --> ++ <lst name="spellchecker"> ++ <str name="name">default</str> ++ <str name="field">spell</str> ++ <str name="spellcheckIndexDir">spellchecker</str> ++ <str name="buildOnOptimize">true</str> ++ </lst> ++ </searchComponent> ++ </xi:fallback> ++ </xi:include> ++ ++</config> +diff --git a/conf/6.x/solrconfig_extra.xml b/conf/6.x/solrconfig_extra.xml +new file mode 100644 +index 0000000..c5bc3ac +--- /dev/null ++++ b/conf/6.x/solrconfig_extra.xml +@@ -0,0 +1,80 @@ ++<!-- Spell Check ++ ++ The spell check component can return a list of alternative spelling ++ suggestions. ++ ++ http://wiki.apache.org/solr/SpellCheckComponent ++ --> ++<searchComponent name="spellcheck" class="solr.SpellCheckComponent"> ++ ++<str name="queryAnalyzerFieldType">textSpell</str> ++ ++<!-- Multiple "Spell Checkers" can be declared and used by this ++ component ++ --> ++ ++<!-- a spellchecker built from a field of the main index, and ++ written to disk ++ --> ++<lst name="spellchecker"> ++ <str name="name">default</str> ++ <str name="field">spell</str> ++ <str name="spellcheckIndexDir">spellchecker</str> ++ <str name="buildOnOptimize">true</str> ++ <!-- uncomment this to require terms to occur in 1% of the documents in order to be included in the dictionary ++ <float name="thresholdTokenFrequency">.01</float> ++ --> ++</lst> ++ ++<!-- ++ Adding German spellhecker index to our Solr index ++ This also requires to enable the content in schema_extra_types.xml and schema_extra_fields.xml ++--> ++<!-- ++<lst name="spellchecker"> ++ <str name="name">spellchecker_de</str> ++ <str name="field">spell_de</str> ++ <str name="spellcheckIndexDir">./spellchecker_de</str> ++ <str name="buildOnOptimize">true</str> ++</lst> ++--> ++ ++<!-- a spellchecker that uses a different distance measure --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="name">jarowinkler</str> ++ <str name="field">spell</str> ++ <str name="distanceMeasure"> ++ org.apache.lucene.search.spell.JaroWinklerDistance ++ </str> ++ <str name="spellcheckIndexDir">spellcheckerJaro</str> ++ </lst> ++ --> ++ ++<!-- a spellchecker that use an alternate comparator ++ ++ comparatorClass be one of: ++ 1. score (default) ++ 2. freq (Frequency first, then score) ++ 3. A fully qualified class name ++ --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="name">freq</str> ++ <str name="field">lowerfilt</str> ++ <str name="spellcheckIndexDir">spellcheckerFreq</str> ++ <str name="comparatorClass">freq</str> ++ <str name="buildOnCommit">true</str> ++ --> ++ ++<!-- A spellchecker that reads the list of words from a file --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="classname">solr.FileBasedSpellChecker</str> ++ <str name="name">file</str> ++ <str name="sourceLocation">spellings.txt</str> ++ <str name="characterEncoding">UTF-8</str> ++ <str name="spellcheckIndexDir">spellcheckerFile</str> ++ </lst> ++ --> ++</searchComponent> +diff --git a/conf/6.x/solrcore.properties b/conf/6.x/solrcore.properties +new file mode 100644 +index 0000000..fb8d7d0 +--- /dev/null ++++ b/conf/6.x/solrcore.properties +@@ -0,0 +1,20 @@ ++# Defines Solr properties for this specific core. ++solr.replication.master=false ++solr.replication.slave=false ++solr.replication.pollInterval=00:00:60 ++solr.replication.masterUrl=http://localhost:8983/solr ++solr.replication.confFiles=schema.xml,mapping-ISOLatin1Accent.txt,protwords.txt,stopwords.txt,synonyms.txt,elevate.xml ++solr.mlt.timeAllowed=2000 ++# You should not set your luceneMatchVersion to anything lower than your Solr ++# Version. ++solr.luceneMatchVersion=6.0 ++solr.pinkPony.timeAllowed=-1 ++# autoCommit after 10000 docs ++solr.autoCommit.MaxDocs=10000 ++# autoCommit after 2 minutes ++solr.autoCommit.MaxTime=120000 ++# autoSoftCommit after 2000 docs ++solr.autoSoftCommit.MaxDocs=2000 ++# autoSoftCommit after 10 seconds ++solr.autoSoftCommit.MaxTime=10000 ++solr.contrib.dir=../../../contrib +diff --git a/conf/6.x/stopwords.txt b/conf/6.x/stopwords.txt +new file mode 100644 +index 0000000..d7f243e +--- /dev/null ++++ b/conf/6.x/stopwords.txt +@@ -0,0 +1,4 @@ ++# Contains words which shouldn't be indexed for fulltext fields, e.g., because ++# they're too common. For documentation of the format, see ++# http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters#solr.StopFilterFactory ++# (Lines starting with a pound character # are ignored.) +diff --git a/conf/6.x/synonyms.txt b/conf/6.x/synonyms.txt +new file mode 100644 +index 0000000..7d22eea +--- /dev/null ++++ b/conf/6.x/synonyms.txt +@@ -0,0 +1,3 @@ ++# Contains synonyms to use for your index. For the format used, see ++# http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters#solr.SynonymFilterFactory ++# (Lines starting with a pound character # are ignored.) diff --git a/2711685-support-solr6-search-api-solr-4.patch b/2711685-support-solr6-search-api-solr-4.patch new file mode 100644 index 000000000000..1f21617951b1 --- /dev/null +++ b/2711685-support-solr6-search-api-solr-4.patch @@ -0,0 +1,2767 @@ +diff --git a/solr-conf/6.x/elevate.xml b/solr-conf/6.x/elevate.xml +new file mode 100644 +index 0000000..71ea000 +--- /dev/null ++++ b/solr-conf/6.x/elevate.xml +@@ -0,0 +1,31 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++ ++<!-- ++ This file allows you to boost certain search items to the top of search ++ results. You can find out an item's ID by searching directly on the Solr ++ server. The item IDs are in general constructed as follows: ++ Search API: ++ $document->id = $index_id . '-' . $item_id; ++ Apache Solr Search Integration: ++ $document->id = $site_hash . '/' . $entity_type . '/' . $entity->id; ++ ++ If you want this file to be automatically re-loaded when a Solr commit takes ++ place (e.g., if you have an automatic script active which updates elevate.xml ++ according to newly-indexed data), place it into Solr's data/ directory. ++ Otherwise, place it with the other configuration files into the conf/ ++ directory. ++ ++ See http://wiki.apache.org/solr/QueryElevationComponent for more information. ++--> ++ ++<elevate> ++<!-- Example for ranking the node #1 first in searches for "example query": --> ++<!-- ++ <query text="example query"> ++ <doc id="default_node_index-1" /> ++ <doc id="7v3jsc/node/1" /> ++ </query> ++--> ++<!-- Multiple <query> elements can be specified, contained in one <elevate>. --> ++<!-- <query text="...">...</query> --> ++</elevate> +diff --git a/solr-conf/6.x/mapping-ISOLatin1Accent.txt b/solr-conf/6.x/mapping-ISOLatin1Accent.txt +new file mode 100644 +index 0000000..b92d03c +--- /dev/null ++++ b/solr-conf/6.x/mapping-ISOLatin1Accent.txt +@@ -0,0 +1,14 @@ ++# This file contains character mappings for the default fulltext field type. ++# The source characters (on the left) will be replaced by the respective target ++# characters before any other processing takes place. ++# Lines starting with a pound character # are ignored. ++# ++# For sensible defaults, use the mapping-ISOLatin1Accent.txt file distributed ++# with the example application of your Solr version. ++# ++# Examples: ++# "À" => "A" ++# "\u00c4" => "A" ++# "\u00c4" => "\u0041" ++# "æ" => "ae" ++# "\n" => " " +diff --git a/solr-conf/6.x/protwords.txt b/solr-conf/6.x/protwords.txt +new file mode 100644 +index 0000000..cda8581 +--- /dev/null ++++ b/solr-conf/6.x/protwords.txt +@@ -0,0 +1,7 @@ ++#----------------------------------------------------------------------- ++# This file blocks words from being operated on by the stemmer and word delimiter. ++& ++< ++> ++' ++" +diff --git a/solr-conf/6.x/schema.xml b/solr-conf/6.x/schema.xml +new file mode 100644 +index 0000000..d813d12 +--- /dev/null ++++ b/solr-conf/6.x/schema.xml +@@ -0,0 +1,693 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++ ++<!-- ++ This is the Solr schema file. This file should be named "schema.xml" and ++ should be in the conf directory under the solr home ++ (i.e. ./solr/solr-conf/schema.xml by default) ++ or located where the classloader for the Solr webapp can find it. ++ ++ For more information, on how to customize this file, please see ++ http://wiki.apache.org/solr/SchemaXml ++--> ++ ++<schema name="drupal-4.4-solr-6.x" version="1.5"> ++ <!-- attribute "name" is the name of this schema and is only used for ++ display purposes. Applications should change this to reflect the nature ++ of the search collection. ++ version="1.2" is Solr's version number for the schema syntax and ++ semantics. It should not normally be changed by applications. ++ ++ 1.0: multiValued attribute did not exist, all fields are multiValued by ++ nature ++ 1.1: multiValued attribute introduced, false by default ++ 1.2: omitTermFreqAndPositions attribute introduced, true by default ++ except for text fields. ++ 1.3: removed optional field compress feature ++ 1.4: autoGeneratePhraseQueries attribute introduced to drive ++ QueryParser behavior when a single string produces multiple ++ tokens. Defaults to off for version >= 1.4 ++ 1.5: omitNorms defaults to true for primitive field types ++ (int, float, boolean, string...) ++ --> ++ ++ <types> ++ <!-- field type definitions. The "name" attribute is ++ just a label to be used by field definitions. The "class" ++ attribute and any other attributes determine the real ++ behavior of the fieldType. ++ Class names starting with "solr" refer to java classes in the ++ org.apache.solr.analysis package. ++ --> ++ ++ <!-- The StrField type is not analyzed, but indexed/stored verbatim. ++ - StrField and TextField support an optional compressThreshold which ++ limits compression (if enabled in the derived fields) to values which ++ exceed a certain size (in characters). ++ --> ++ <fieldType name="string" class="solr.StrField" sortMissingLast="true"/> ++ ++ <!-- boolean type: "true" or "false" --> ++ <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true"/> ++ <!--Binary data type. The data should be sent/retrieved in as Base64 encoded Strings --> ++ <fieldtype name="binary" class="solr.BinaryField"/> ++ ++ <!-- The optional sortMissingLast and sortMissingFirst attributes are ++ currently supported on types that are sorted internally as strings. ++ - If sortMissingLast="true", then a sort on this field will cause documents ++ without the field to come after documents with the field, ++ regardless of the requested sort order (asc or desc). ++ - If sortMissingFirst="true", then a sort on this field will cause documents ++ without the field to come before documents with the field, ++ regardless of the requested sort order. ++ - If sortMissingLast="false" and sortMissingFirst="false" (the default), ++ then default lucene sorting will be used which places docs without the ++ field first in an ascending sort and last in a descending sort. ++ --> ++ ++ <!-- numeric field types that can be sorted, but are not optimized for range queries --> ++ <fieldType name="integer" class="solr.TrieIntField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="float" class="solr.TrieFloatField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/> ++ <fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" positionIncrementGap="0"/> ++ ++ <!-- ++ Note: ++ These should only be used for compatibility with existing indexes (created with older Solr versions) ++ or if "sortMissingFirst" or "sortMissingLast" functionality is needed. Use Trie based fields instead. ++ ++ Numeric field types that manipulate the value into ++ a string value that isn't human-readable in its internal form, ++ but with a lexicographic ordering the same as the numeric ordering, ++ so that range queries work correctly. ++ --> ++ <fieldType name="sint" class="solr.TrieIntField" sortMissingLast="true"/> ++ <fieldType name="sfloat" class="solr.TrieFloatField" sortMissingLast="true"/> ++ <fieldType name="slong" class="solr.TrieLongField" sortMissingLast="true"/> ++ <fieldType name="sdouble" class="solr.TrieDoubleField" sortMissingLast="true"/> ++ ++ <!-- ++ Numeric field types that index each value at various levels of precision ++ to accelerate range queries when the number of values between the range ++ endpoints is large. See the javadoc for NumericRangeQuery for internal ++ implementation details. ++ ++ Smaller precisionStep values (specified in bits) will lead to more tokens ++ indexed per value, slightly larger index size, and faster range queries. ++ A precisionStep of 0 disables indexing at different precision levels. ++ --> ++ <fieldType name="tint" class="solr.TrieIntField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tfloat" class="solr.TrieFloatField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tlong" class="solr.TrieLongField" precisionStep="8" positionIncrementGap="0"/> ++ <fieldType name="tdouble" class="solr.TrieDoubleField" precisionStep="8" positionIncrementGap="0"/> ++ ++ <!-- ++ The ExternalFileField type gets values from an external file instead of the ++ index. This is useful for data such as rankings that might change frequently ++ and require different update frequencies than the documents they are ++ associated with. ++ --> ++ <fieldType name="file" keyField="id" defVal="1" stored="false" indexed="false" class="solr.ExternalFileField" valType="float"/> ++ ++ <!-- The format for this date field is of the form 1995-12-31T23:59:59Z, and ++ is a more restricted form of the canonical representation of dateTime ++ http://www.w3.org/TR/xmlschema-2/#dateTime ++ The trailing "Z" designates UTC time and is mandatory. ++ Optional fractional seconds are allowed: 1995-12-31T23:59:59.999Z ++ All other components are mandatory. ++ ++ Expressions can also be used to denote calculations that should be ++ performed relative to "NOW" to determine the value, ie... ++ ++ NOW/HOUR ++ ... Round to the start of the current hour ++ NOW-1DAY ++ ... Exactly 1 day prior to now ++ NOW/DAY+6MONTHS+3DAYS ++ ... 6 months and 3 days in the future from the start of ++ the current day ++ ++ Consult the TrieDateField javadocs for more information. ++ ++ Note: For faster range queries, consider the tdate type ++ --> ++ <fieldType name="date" class="solr.TrieDateField" precisionStep="0" positionIncrementGap="0" sortMissingLast="true" omitNorms="true"/> ++ ++ <!-- A Trie based date field for faster date range queries and date faceting. --> ++ <fieldType name="tdate" class="solr.TrieDateField" precisionStep="6" positionIncrementGap="0"/> ++ ++ <!-- solr.TextField allows the specification of custom text analyzers ++ specified as a tokenizer and a list of token filters. Different ++ analyzers may be specified for indexing and querying. ++ ++ The optional positionIncrementGap puts space between multiple fields of ++ this type on the same document, with the purpose of preventing false phrase ++ matching across fields. ++ ++ For more info on customizing your analyzer chain, please see ++ http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters ++ --> ++ ++ <!-- One can also specify an existing Analyzer class that has a ++ default constructor via the class attribute on the analyzer element ++ <fieldType name="text_greek" class="solr.TextField"> ++ <analyzer class="org.apache.lucene.analysis.el.GreekAnalyzer"/> ++ </fieldType> ++ --> ++ ++ <!-- A text field that only splits on whitespace for exact matching of words --> ++ <fieldType name="text_ws" class="solr.TextField" omitNorms="true" positionIncrementGap="100"> ++ <analyzer> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- A text field that uses WordDelimiterFilter to enable splitting and matching of ++ words on case-change, alpha numeric boundaries, and non-alphanumeric chars, ++ so that a query of "wifi" or "wi fi" could match a document containing "Wi-Fi". ++ Synonyms and stopwords are customized by external files, and stemming is enabled. ++ Duplicate tokens at the same position (which may result from Stemmed Synonyms or ++ WordDelim parts) are removed. ++ --> ++ <fieldType name="text" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <!-- in this example, we will only use synonyms at query time ++ <filter class="solr.SynonymFilterFactory" synonyms="index_synonyms.txt" ignoreCase="true" expand="false"/> ++ --> ++ <!-- Case insensitive stop word removal. --> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="1" ++ catenateNumbers="1" ++ catenateAll="0" ++ splitOnCaseChange="0" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="multiterm"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="1" ++ preserveOriginal="1"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.SnowballPorterFilterFactory" language="English" protected="protwords.txt"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- An unstemmed text field - good if one does not know the language of the field --> ++ <fieldType name="text_und" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="1" ++ catenateNumbers="1" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ <analyzer type="multiterm"> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" ++ ignoreCase="true" ++ words="stopwords.txt" ++ /> ++ <filter class="solr.WordDelimiterFilterFactory" ++ protected="protwords.txt" ++ generateWordParts="1" ++ generateNumberParts="1" ++ catenateWords="0" ++ catenateNumbers="0" ++ catenateAll="0" ++ splitOnCaseChange="0"/> ++ <filter class="solr.LengthFilterFactory" min="2" max="100" /> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- Edge N gram type - for example for matching against queries with results ++ KeywordTokenizer leaves input string intact as a single term. ++ see: http://www.lucidimagination.com/blog/2009/09/08/auto-suggest-from-popular-queries-using-edgengrams/ ++ --> ++ <fieldType name="edge_n2_kw_text" class="solr.TextField" omitNorms="true" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.EdgeNGramFilterFactory" minGramSize="2" maxGramSize="25" /> ++ </analyzer> ++ <analyzer type="query"> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ </analyzer> ++ </fieldType> ++ <!-- Setup simple analysis for spell checking --> ++ ++ <fieldType name="textSpell" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer> ++ <tokenizer class="solr.StandardTokenizerFactory" /> ++ <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/> ++ <filter class="solr.LengthFilterFactory" min="4" max="20" /> ++ <filter class="solr.LowerCaseFilterFactory" /> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory" /> ++ </analyzer> ++ </fieldType> ++ ++ <!-- This is an example of using the KeywordTokenizer along ++ With various TokenFilterFactories to produce a sortable field ++ that does not include some properties of the source text ++ --> ++ <fieldType name="sortString" class="solr.TextField" sortMissingLast="true" omitNorms="true"> ++ <analyzer> ++ <!-- KeywordTokenizer does no actual tokenizing, so the entire ++ input string is preserved as a single token ++ --> ++ <tokenizer class="solr.KeywordTokenizerFactory"/> ++ <!-- The LowerCase TokenFilter does what you expect, which can be ++ when you want your sorting to be case insensitive ++ --> ++ <filter class="solr.LowerCaseFilterFactory" /> ++ <!-- The TrimFilter removes any leading or trailing whitespace --> ++ <filter class="solr.TrimFilterFactory" /> ++ <!-- The PatternReplaceFilter gives you the flexibility to use ++ Java Regular expression to replace any sequence of characters ++ matching a pattern with an arbitrary replacement string, ++ which may include back refrences to portions of the orriginal ++ string matched by the pattern. ++ ++ See the Java Regular Expression documentation for more ++ infomation on pattern and replacement string syntax. ++ ++ http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/package-summary.html ++ ++ <filter class="solr.PatternReplaceFilterFactory" ++ pattern="(^\p{Punct}+)" replacement="" replace="all" ++ /> ++ --> ++ </analyzer> ++ </fieldType> ++ ++ <!-- The "RandomSortField" is not used to store or search any ++ data. You can declare fields of this type it in your schema ++ to generate pseudo-random orderings of your docs for sorting ++ or function purposes. The ordering is generated based on the field ++ name and the version of the index. As long as the index version ++ remains unchanged, and the same field name is reused, ++ the ordering of the docs will be consistent. ++ If you want different psuedo-random orderings of documents, ++ for the same version of the index, use a dynamicField and ++ change the field name in the request. ++ --> ++ <fieldType name="rand" class="solr.RandomSortField" indexed="true" /> ++ ++ <!-- Fulltext type for matching words based on how they sound – i.e., ++ "phonetic matching". ++ --> ++ <fieldType name="phonetic" class="solr.TextField" > ++ <analyzer> ++ <tokenizer class="solr.StandardTokenizerFactory"/> ++ <filter class="solr.DoubleMetaphoneFilterFactory" inject="false"/> ++ </analyzer> ++ </fieldType> ++ ++ <!-- since fields of this type are by default not stored or indexed, ++ any data added to them will be ignored outright. --> ++ <fieldType name="ignored" stored="false" indexed="false" multiValued="true" class="solr.StrField" /> ++ ++ <!-- This point type indexes the coordinates as separate fields (subFields) ++ If subFieldType is defined, it references a type, and a dynamic field ++ definition is created matching *___<typename>. Alternately, if ++ subFieldSuffix is defined, that is used to create the subFields. ++ Example: if subFieldType="double", then the coordinates would be ++ indexed in fields myloc_0___double,myloc_1___double. ++ Example: if subFieldSuffix="_d" then the coordinates would be indexed ++ in fields myloc_0_d,myloc_1_d ++ The subFields are an implementation detail of the fieldType, and end ++ users normally should not need to know about them. ++ --> ++ <fieldType name="point" class="solr.PointType" dimension="2" subFieldType="tdouble"/> ++ ++ <!-- A specialized field for geospatial search. If indexed, this fieldType must not be multivalued. --> ++ <fieldType name="location" class="solr.LatLonType" subFieldType="tdouble"/> ++ ++ <!-- A Geohash is a compact representation of a latitude longitude pair in a single field. ++ See http://wiki.apache.org/solr/SpatialSearch ++ --> ++ <fieldtype name="geohash" class="solr.GeoHashField"/> ++ ++ <!-- Improved location type which supports advanced functionality like ++ filtering by polygons or other shapes, indexing shapes, multi-valued ++ fields, etc. ++ --> ++ <fieldType name="location_rpt" class="solr.SpatialRecursivePrefixTreeFieldType" ++ geo="true" distErrPct="0.025" maxDistErr="0.001" distanceUnits="kilometers" /> ++ ++ <!-- Spatial rectangle (bounding box) field. It supports most spatial predicates, and has ++ special relevancy modes: score=overlapRatio|area|area2D (local-param to the query). DocValues is recommended for ++ relevancy. --> ++ <fieldType name="bbox" class="solr.BBoxField" ++ geo="true" distanceUnits="kilometers" numberType="_bbox_coord" /> ++ <fieldType name="_bbox_coord" class="solr.TrieDoubleField" precisionStep="8" docValues="true" stored="false"/> ++ ++ </types> ++ ++ <!-- Following is a dynamic way to include other types, added by other contrib modules --> ++ <xi:include href="schema_extra_types.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback></xi:fallback> ++ </xi:include> ++ ++ <!-- Valid attributes for fields: ++ name: mandatory - the name for the field ++ type: mandatory - the name of a field type from the <types> fieldType ++ section ++ indexed: true if this field should be indexed (searchable or sortable) ++ stored: true if this field should be retrievable ++ docValues: true if this field should have doc values. Doc values are ++ useful for faceting, grouping, sorting and function queries. Although not ++ required, doc values will make the index faster to load, more ++ NRT-friendly and more memory-efficient. They however come with some ++ limitations: they are currently only supported by StrField, UUIDField ++ and all Trie*Fields, and depending on the field type, they might ++ require the field to be single-valued, be required or have a default ++ value (check the documentation of the field type you're interested in ++ for more information) ++ multiValued: true if this field may contain multiple values per document ++ omitNorms: (expert) set to true to omit the norms associated with ++ this field (this disables length normalization and index-time ++ boosting for the field, and saves some memory). Only full-text ++ fields or fields that need an index-time boost need norms. ++ Norms are omitted for primitive (non-analyzed) types by default. ++ termVectors: [false] set to true to store the term vector for a ++ given field. ++ When using MoreLikeThis, fields used for similarity should be ++ stored for best performance. ++ termPositions: Store position information with the term vector. ++ This will increase storage costs. ++ termOffsets: Store offset information with the term vector. This ++ will increase storage costs. ++ required: The field is required. It will throw an error if the ++ value does not exist ++ default: a value that should be used if no value is specified ++ when adding a document. ++ --> ++ <fields> ++ ++ <!-- The document id is usually derived from a site-spcific key (hash) and the ++ entity type and ID like: ++ Search Api : ++ The format used is $document->id = $index_id . '-' . $item_id ++ Apache Solr Search Integration ++ The format used is $document->id = $site_hash . '/' . $entity_type . '/' . $entity->id; ++ --> ++ <field name="id" type="string" indexed="true" stored="true" required="true" /> ++ ++ <!-- Add Solr Cloud version field as mentioned in ++ http://wiki.apache.org/solr/SolrCloud#Required_Config ++ --> ++ <field name="_version_" type="long" indexed="true" stored="true" multiValued="false"/> ++ ++ <!-- Search Api specific fields --> ++ <!-- item_id contains the entity ID, e.g. a node's nid. --> ++ <field name="item_id" type="string" indexed="true" stored="true" /> ++ <!-- index_id is the machine name of the search index this entry belongs to. --> ++ <field name="index_id" type="string" indexed="true" stored="true" /> ++ <!-- copyField commands copy one field to another at the time a document ++ is added to the index. It's used either to index the same field differently, ++ or to add multiple fields to the same field for easier/faster searching. --> ++ <!-- Since sorting by ID is explicitly allowed, store item_id also in a sortable way. --> ++ <copyField source="item_id" dest="sort_search_api_id" /> ++ ++ <!-- Apache Solr Search Integration specific fields --> ++ <!-- entity_id is the numeric object ID, e.g. Node ID, File ID --> ++ <field name="entity_id" type="long" indexed="true" stored="true" /> ++ <!-- entity_type is 'node', 'file', 'user', or some other Drupal object type --> ++ <field name="entity_type" type="string" indexed="true" stored="true" /> ++ <!-- bundle is a node type, or as appropriate for other entity types --> ++ <field name="bundle" type="string" indexed="true" stored="true"/> ++ <field name="bundle_name" type="string" indexed="true" stored="true"/> ++ <field name="site" type="string" indexed="true" stored="true"/> ++ <field name="hash" type="string" indexed="true" stored="true"/> ++ <field name="url" type="string" indexed="true" stored="true"/> ++ <!-- label is the default field for a human-readable string for this entity (e.g. the title of a node) --> ++ <field name="label" type="text" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <!-- The string version of the title is used for sorting --> ++ <copyField source="label" dest="sort_label"/> ++ ++ <!-- content is the default field for full text search - dump crap here --> ++ <field name="content" type="text" indexed="true" stored="true" termVectors="true"/> ++ <field name="teaser" type="text" indexed="false" stored="true"/> ++ <field name="path" type="string" indexed="true" stored="true"/> ++ <field name="path_alias" type="text" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ ++ <!-- These are the fields that correspond to a Drupal node. The beauty of having ++ Lucene store title, body, type, etc., is that we retrieve them with the search ++ result set and don't need to go to the database with a node_load. --> ++ <field name="tid" type="long" indexed="true" stored="true" multiValued="true"/> ++ <field name="taxonomy_names" type="text" indexed="true" stored="false" termVectors="true" multiValued="true" omitNorms="true"/> ++ <!-- Copy terms to a single field that contains all taxonomy term names --> ++ <copyField source="tm_vid_*" dest="taxonomy_names"/> ++ ++ <!-- Here, default is used to create a "timestamp" field indicating ++ when each document was indexed.--> ++ <field name="timestamp" type="tdate" indexed="true" stored="true" default="NOW" multiValued="false"/> ++ ++ <!-- This field is used to build the spellchecker index --> ++ <field name="spell" type="textSpell" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- copyField commands copy one field to another at the time a document ++ is added to the index. It's used either to index the same field differently, ++ or to add multiple fields to the same field for easier/faster searching. --> ++ <copyField source="label" dest="spell"/> ++ <copyField source="content" dest="spell"/> ++ ++ <copyField source="ts_*" dest="spell"/> ++ <copyField source="tm_*" dest="spell"/> ++ ++ <!-- Dynamic field definitions. If a field name is not found, dynamicFields ++ will be used if the name matches any of the patterns. ++ RESTRICTION: the glob-like pattern in the name attribute must have ++ a "*" only at the start or the end. ++ EXAMPLE: name="*_i" will match any field ending in _i (like myid_i, z_i) ++ Longer patterns will be matched first. if equal size patterns ++ both match, the first appearing in the schema will be used. --> ++ ++ <!-- A set of fields to contain text extracted from HTML tag contents which we ++ can boost at query time. --> ++ <dynamicField name="tags_*" type="text" indexed="true" stored="false" omitNorms="true"/> ++ ++ <!-- For 2 and 3 letter prefix dynamic fields, the 1st letter indicates the data type and ++ the last letter is 's' for single valued, 'm' for multi-valued --> ++ ++ <!-- We use long for integer since 64 bit ints are now common in PHP. --> ++ <dynamicField name="is_*" type="long" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="im_*" type="long" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of floats can be saved in a regular float field --> ++ <dynamicField name="fs_*" type="float" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="fm_*" type="float" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of doubles can be saved in a regular double field --> ++ <dynamicField name="ps_*" type="double" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="pm_*" type="double" indexed="true" stored="true" multiValued="true"/> ++ <!-- List of booleans can be saved in a regular boolean field --> ++ <dynamicField name="bm_*" type="boolean" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="bs_*" type="boolean" indexed="true" stored="true" multiValued="false"/> ++ <!-- Regular text (without processing) can be stored in a string field--> ++ <dynamicField name="ss_*" type="string" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="sm_*" type="string" indexed="true" stored="true" multiValued="true"/> ++ <!-- Normal text fields are for full text - the relevance of a match depends on the length of the text --> ++ <dynamicField name="ts_*" type="text" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tm_*" type="text" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <!-- Unstemmed text fields for full text - the relevance of a match depends on the length of the text --> ++ <dynamicField name="tus_*" type="text_und" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tum_*" type="text_und" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <!-- These text fields omit norms - useful for extracted text like taxonomy_names --> ++ <dynamicField name="tos_*" type="text" indexed="true" stored="true" multiValued="false" termVectors="true" omitNorms="true"/> ++ <dynamicField name="tom_*" type="text" indexed="true" stored="true" multiValued="true" termVectors="true" omitNorms="true"/> ++ <!-- Special-purpose text fields --> ++ <dynamicField name="tes_*" type="edge_n2_kw_text" indexed="true" stored="true" multiValued="false" omitTermFreqAndPositions="true" /> ++ <dynamicField name="tem_*" type="edge_n2_kw_text" indexed="true" stored="true" multiValued="true" omitTermFreqAndPositions="true" /> ++ <dynamicField name="tws_*" type="text_ws" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="twm_*" type="text_ws" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- trie dates are preferred, so give them the 2 letter prefix --> ++ <dynamicField name="ds_*" type="tdate" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="dm_*" type="tdate" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="its_*" type="tlong" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="itm_*" type="tlong" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="fts_*" type="tfloat" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ftm_*" type="tfloat" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="pts_*" type="tdouble" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ptm_*" type="tdouble" indexed="true" stored="true" multiValued="true"/> ++ <!-- Binary fields can be populated using base64 encoded data. Useful e.g. for embedding ++ a small image in a search result using the data URI scheme --> ++ <dynamicField name="xs_*" type="binary" indexed="false" stored="true" multiValued="false"/> ++ <dynamicField name="xm_*" type="binary" indexed="false" stored="true" multiValued="true"/> ++ <!-- In rare cases a date rather than tdate is needed for sortMissingLast --> ++ <dynamicField name="dds_*" type="date" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ddm_*" type="date" indexed="true" stored="true" multiValued="true"/> ++ <!-- Sortable fields, good for sortMissingLast support & ++ We use long for integer since 64 bit ints are now common in PHP. --> ++ <dynamicField name="iss_*" type="slong" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="ism_*" type="slong" indexed="true" stored="true" multiValued="true"/> ++ <!-- In rare cases a sfloat rather than tfloat is needed for sortMissingLast --> ++ <dynamicField name="fss_*" type="sfloat" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="fsm_*" type="sfloat" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="pss_*" type="sdouble" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="psm_*" type="sdouble" indexed="true" stored="true" multiValued="true"/> ++ <!-- In case a 32 bit int is really needed, we provide these fields. 'h' is mnemonic for 'half word', i.e. 32 bit on 64 arch --> ++ <dynamicField name="hs_*" type="integer" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="hm_*" type="integer" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="hss_*" type="sint" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="hsm_*" type="sint" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="hts_*" type="tint" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="htm_*" type="tint" indexed="true" stored="true" multiValued="true"/> ++ ++ <!-- Unindexed string fields that can be used to store values that won't be searchable --> ++ <dynamicField name="zs_*" type="string" indexed="false" stored="true" multiValued="false"/> ++ <dynamicField name="zm_*" type="string" indexed="false" stored="true" multiValued="true"/> ++ ++ <!-- Fields for location searches. ++ http://wiki.apache.org/solr/SpatialSearch#geodist_-_The_distance_function --> ++ <dynamicField name="points_*" type="point" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="pointm_*" type="point" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="locs_*" type="location" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="locm_*" type="location" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="geos_*" type="geohash" indexed="true" stored="true" multiValued="false"/> ++ <dynamicField name="geom_*" type="geohash" indexed="true" stored="true" multiValued="true"/> ++ <dynamicField name="bboxs_*" type="bbox" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="bboxm_*" type="bbox" indexed="true" stored="true" multiValued="true" /> ++ <dynamicField name="rpts_*" type="location_rpt" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="rptm_*" type="location_rpt" indexed="true" stored="true" multiValued="true" /> ++ ++ <!-- Special fields for Solr 5 functionality. --> ++ <dynamicField name="phons_*" type="phonetic" indexed="true" stored="true" multiValued="false" /> ++ <dynamicField name="phonm_*" type="phonetic" indexed="true" stored="true" multiValued="true" /> ++ ++ <!-- External file fields --> ++ <dynamicField name="eff_*" type="file"/> ++ ++ <!-- Sortable version of the dynamic string field --> ++ <dynamicField name="sort_*" type="sortString" indexed="true" stored="false"/> ++ <copyField source="ss_*" dest="sort_*"/> ++ ++ <!-- A random sort field --> ++ <dynamicField name="random_*" type="rand" indexed="true" stored="true"/> ++ ++ <!-- This field is used to store access information (e.g. node access grants), as opposed to field data --> ++ <dynamicField name="access_*" type="integer" indexed="true" stored="false" multiValued="true"/> ++ ++ <!-- The following causes solr to ignore any fields that don't already match an existing ++ field name or dynamic field, rather than reporting them as an error. ++ Alternately, change the type="ignored" to some other type e.g. "text" if you want ++ unknown fields indexed and/or stored by default --> ++ <dynamicField name="*" type="ignored" multiValued="true" /> ++ ++ </fields> ++ ++ <!-- Following is a dynamic way to include other fields, added by other contrib modules --> ++ <xi:include href="schema_extra_fields.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback></xi:fallback> ++ </xi:include> ++ ++ <!-- Field to use to determine and enforce document uniqueness. ++ Unless this field is marked with required="false", it will be a required field ++ --> ++ <uniqueKey>id</uniqueKey> ++ ++ <!-- Similarity is the scoring routine for each document vs. a query. ++ A custom Similarity or SimilarityFactory may be specified here, but ++ the default is fine for most applications. ++ For more info: http://wiki.apache.org/solr/SchemaXml#Similarity ++ --> ++ <!-- ++ <similarity class="com.example.solr.CustomSimilarityFactory"> ++ <str name="paramkey">param value</str> ++ </similarity> ++ --> ++ ++ <!-- DEPRECATED: The defaultSearchField is consulted by various query parsers ++ when parsing a query string that isn't explicit about the field. Machine ++ (non-user) generated queries are best made explicit, or they can use the ++ "df" request parameter which takes precedence over this. ++ Note: Un-commenting defaultSearchField will be insufficient if your request ++ handler in solrconfig.xml defines "df", which takes precedence. That would ++ need to be removed. ++ <defaultSearchField>content</defaultSearchField> --> ++ ++ <!-- DEPRECATED: The defaultOperator (AND|OR) is consulted by various query ++ parsers when parsing a query string to determine if a clause of the query ++ should be marked as required or optional, assuming the clause isn't already ++ marked by some operator. The default is OR, which is generally assumed so it ++ is not a good idea to change it globally here. The "q.op" request parameter ++ takes precedence over this. ++ <solrQueryParser defaultOperator="OR"/> --> ++ ++</schema> +diff --git a/solr-conf/6.x/schema_extra_fields.xml b/solr-conf/6.x/schema_extra_fields.xml +new file mode 100644 +index 0000000..02b3655 +--- /dev/null ++++ b/solr-conf/6.x/schema_extra_fields.xml +@@ -0,0 +1,23 @@ ++<fields> ++<!-- ++ Example: Adding German dynamic field types to our Solr Schema. ++ If you enable this, make sure you have a folder called lang containing ++ stopwords_de.txt and synonyms_de.txt. ++ This also requires to enable the content in schema_extra_types.xml. ++--> ++<!-- ++ <field name="label_de" type="text_de" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <field name="content_de" type="text_de" indexed="true" stored="true" termVectors="true"/> ++ <field name="teaser_de" type="text_de" indexed="false" stored="true"/> ++ <field name="path_alias_de" type="text_de" indexed="true" stored="true" termVectors="true" omitNorms="true"/> ++ <field name="taxonomy_names_de" type="text_de" indexed="true" stored="false" termVectors="true" multiValued="true" omitNorms="true"/> ++ <field name="spell_de" type="text_de" indexed="true" stored="true" multiValued="true"/> ++ <copyField source="label_de" dest="spell_de"/> ++ <copyField source="content_de" dest="spell_de"/> ++ <dynamicField name="tags_de_*" type="text_de" indexed="true" stored="false" omitNorms="true"/> ++ <dynamicField name="ts_de_*" type="text_de" indexed="true" stored="true" multiValued="false" termVectors="true"/> ++ <dynamicField name="tm_de_*" type="text_de" indexed="true" stored="true" multiValued="true" termVectors="true"/> ++ <dynamicField name="tos_de_*" type="text_de" indexed="true" stored="true" multiValued="false" termVectors="true" omitNorms="true"/> ++ <dynamicField name="tom_de_*" type="text_de" indexed="true" stored="true" multiValued="true" termVectors="true" omitNorms="true"/> ++--> ++</fields> +diff --git a/solr-conf/6.x/schema_extra_types.xml b/solr-conf/6.x/schema_extra_types.xml +new file mode 100644 +index 0000000..bd716b8 +--- /dev/null ++++ b/solr-conf/6.x/schema_extra_types.xml +@@ -0,0 +1,34 @@ ++<types> ++<!-- ++ Example: Adding German language field types to our Solr Schema. ++ If you enable this, make sure you have a folder called lang containing ++ stopwords_de.txt and synonyms_de.txt. ++ ++ For examples from other languages, see ++ ./server/solr/configsets/sample_techproducts_configs/solr-conf/schema.xml ++ from your Solr installation. ++--> ++<!-- ++ <fieldType name="text_de" class="solr.TextField" positionIncrementGap="100"> ++ <analyzer type="index"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.StopFilterFactory" words="lang/stopwords_de.txt" format="snowball" ignoreCase="true"/> ++ <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" splitOnCaseChange="1" splitOnNumerics="1" catenateWords="1" catenateNumbers="1" catenateAll="0" protected="protwords.txt" preserveOriginal="1"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.GermanLightStemFilterFactory"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ <analyzer type="query"> ++ <charFilter class="solr.MappingCharFilterFactory" mapping="mapping-ISOLatin1Accent.txt"/> ++ <tokenizer class="solr.WhitespaceTokenizerFactory"/> ++ <filter class="solr.SynonymFilterFactory" synonyms="lang/synonyms_de.txt" ignoreCase="true" expand="true"/> ++ <filter class="solr.StopFilterFactory" words="lang/stopwords_de.txt" format="snowball" ignoreCase="true"/> ++ <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" splitOnCaseChange="1" splitOnNumerics="1" catenateWords="0" catenateNumbers="0" catenateAll="0" protected="protwords.txt" preserveOriginal="1"/> ++ <filter class="solr.LowerCaseFilterFactory"/> ++ <filter class="solr.GermanLightStemFilterFactory"/> ++ <filter class="solr.RemoveDuplicatesTokenFilterFactory"/> ++ </analyzer> ++ </fieldType> ++--> ++</types> +diff --git a/solr-conf/6.x/solrconfig.xml b/solr-conf/6.x/solrconfig.xml +new file mode 100644 +index 0000000..54946ad +--- /dev/null ++++ b/solr-conf/6.x/solrconfig.xml +@@ -0,0 +1,1792 @@ ++<?xml version="1.0" encoding="UTF-8" ?> ++<!-- ++ Licensed to the Apache Software Foundation (ASF) under one or more ++ contributor license agreements. See the NOTICE file distributed with ++ this work for additional information regarding copyright ownership. ++ The ASF licenses this file to You under the Apache License, Version 2.0 ++ (the "License"); you may not use this file except in compliance with ++ the License. You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ See the License for the specific language governing permissions and ++ limitations under the License. ++--> ++ ++<!-- ++ For more details about configurations options that may appear in ++ this file, see http://wiki.apache.org/solr/SolrConfigXml. ++--> ++<config name="drupal-4.4-solr-6.x" > ++ <!-- In all configuration below, a prefix of "solr." for class names ++ is an alias that causes solr to search appropriate packages, ++ including org.apache.solr.(search|update|request|core|analysis) ++ ++ You may also specify a fully qualified Java classname if you ++ have your own custom plugins. ++ --> ++ ++ <!-- Set this to 'false' if you want solr to continue working after ++ it has encountered an severe configuration error. In a ++ production environment, you may want solr to keep working even ++ if one handler is mis-configured. ++ ++ You may also set this to false using by setting the system ++ property: ++ ++ -Dsolr.abortOnConfigurationError=false ++ --> ++ <abortOnConfigurationError>${solr.abortOnConfigurationError:true}</abortOnConfigurationError> ++ ++ <!-- Controls what version of Lucene various components of Solr ++ adhere to. Generally, you want to use the latest version to ++ get all bug fixes and improvements. It is highly recommended ++ that you fully re-index after changing this setting as it can ++ affect both how text is indexed and queried. ++ --> ++ <luceneMatchVersion>${solr.luceneMatchVersion:LUCENE_60}</luceneMatchVersion> ++ ++ <!-- <lib/> directives can be used to instruct Solr to load any Jars ++ identified and use them to resolve any "plugins" specified in ++ your solrconfig.xml or schema.xml (ie: Analyzers, Request ++ Handlers, etc...). ++ ++ All directories and paths are resolved relative to the ++ instanceDir. ++ ++ Please note that <lib/> directives are processed in the order ++ that they appear in your solrconfig.xml file, and are "stacked" ++ on top of each other when building a ClassLoader - so if you have ++ plugin jars with dependencies on other jars, the "lower level" ++ dependency jars should be loaded first. ++ ++ If a "./lib" directory exists in your instanceDir, all files ++ found in it are included as if you had used the following ++ syntax... ++ ++ <lib dir="./lib" /> ++ --> ++ ++ <!-- A "dir" option by itself adds any files found in the directory to the ++ classpath, this is useful for including all jars in a directory. ++ --> ++ <lib dir="${solr.contrib.dir:../../../contrib}/extraction/lib" /> ++ <lib dir="${solr.contrib.dir:../../../contrib}/clustering/lib/" /> ++ ++ <!-- The velocity library has been known to crash Solr in some ++ instances when deployed as a war file to Tomcat. Therefore all ++ references have been removed from the default configuration. ++ @see http://drupal.org/node/1612556 ++ --> ++ <!-- <lib dir="../../contrib/velocity/lib" /> --> ++ ++ <!-- When a regex is specified in addition to a directory, only the ++ files in that directory which completely match the regex ++ (anchored on both ends) will be included. ++ --> ++ <!--<lib dir="../../dist/" regex="apache-solr-cell-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-clustering-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-dataimporthandler-\d.*\.jar" />--> ++ <!--<lib dir="../../dist/" regex="apache-solr-langid-\d.*\.jar" />--> ++ <!-- <lib dir="../../dist/" regex="apache-solr-velocity-\d.*\.jar" /> --> ++ ++ <!-- If a dir option (with or without a regex) is used and nothing ++ is found that matches, it will be ignored ++ --> ++ <!--<lib dir="../../contrib/clustering/lib/" />--> ++ <!--<lib dir="/total/crap/dir/ignored" />--> ++ ++ <!-- an exact path can be used to specify a specific file. This ++ will cause a serious error to be logged if it can't be loaded. ++ --> ++ <!-- ++ <lib path="../a-jar-that-does-not-exist.jar" /> ++ --> ++ ++ <!-- Data Directory ++ ++ Used to specify an alternate directory to hold all index data ++ other than the default ./data under the Solr home. If ++ replication is in use, this should match the replication ++ configuration. ++ --> ++ <dataDir>${solr.data.dir:}</dataDir> ++ ++ <!-- The DirectoryFactory to use for indexes. ++ ++ solr.StandardDirectoryFactory is filesystem ++ based and tries to pick the best implementation for the current ++ JVM and platform. solr.NRTCachingDirectoryFactory, the default, ++ wraps solr.StandardDirectoryFactory and caches small files in memory ++ for better NRT performance. ++ ++ One can force a particular implementation via solr.MMapDirectoryFactory, ++ solr.NIOFSDirectoryFactory, or solr.SimpleFSDirectoryFactory. ++ ++ solr.RAMDirectoryFactory is memory based, not ++ persistent, and doesn't work with replication. ++ --> ++ <directoryFactory name="DirectoryFactory" ++ class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}"/> ++ ++ <!-- The CodecFactory for defining the format of the inverted index. ++ The default implementation is SchemaCodecFactory, which is the official ++ Lucene index format, but hooks into the schema to provide per-field ++ customization of the postings lists and per-document values in the ++ fieldType element (postingsFormat/docValuesFormat). Note that most of the ++ alternative implementations are experimental, so if you choose to ++ customize the index format, it's a good idea to convert back to the ++ official format e.g. via IndexWriter.addIndexes(IndexReader) before ++ upgrading to a newer version to avoid unnecessary reindexing. ++ --> ++ <codecFactory class="solr.SchemaCodecFactory"/> ++ ++ <!-- To enable dynamic schema REST APIs, use the following for <schemaFactory>: ++ ++ <schemaFactory class="ManagedIndexSchemaFactory"> ++ <bool name="mutable">true</bool> ++ <str name="managedSchemaResourceName">managed-schema</str> ++ </schemaFactory> ++ ++ When ManagedIndexSchemaFactory is specified, Solr will load the schema from ++ the resource named in 'managedSchemaResourceName', rather than from schema.xml. ++ Note that the managed schema resource CANNOT be named schema.xml. If the managed ++ schema does not exist, Solr will create it after reading schema.xml, then rename ++ 'schema.xml' to 'schema.xml.bak'. ++ ++ Do NOT hand edit the managed schema - external modifications will be ignored and ++ overwritten as a result of schema modification REST API calls. ++ ++ When ManagedIndexSchemaFactory is specified with mutable = true, schema ++ modification REST API calls will be allowed; otherwise, error responses will be ++ sent back for these requests. ++ --> ++ <schemaFactory class="ClassicIndexSchemaFactory"/> ++ ++ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ Index Config - These settings control low-level behavior of indexing ++ Most example settings here show the default value, but are commented ++ out, to more easily see where customizations have been made. ++ ++ Note: This replaces <indexDefaults> and <mainIndex> from older versions ++ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --> ++ <indexConfig> ++ <!-- maxFieldLength was removed in 4.0. To get similar behavior, include a ++ LimitTokenCountFilterFactory in your fieldType definition. E.g. ++ <filter class="solr.LimitTokenCountFilterFactory" maxTokenCount="10000"/> ++ --> ++ <!-- Maximum time to wait for a write lock (ms) for an IndexWriter. Default: 1000 --> ++ <!-- <writeLockTimeout>1000</writeLockTimeout> --> ++ ++ <!-- The maximum number of simultaneous threads that may be ++ indexing documents at once in IndexWriter; if more than this ++ many threads arrive they will wait for others to finish. ++ Default in Solr/Lucene is 8. --> ++ <!-- <maxIndexingThreads>8</maxIndexingThreads> --> ++ ++ <!-- Expert: Enabling compound file will use less files for the index, ++ using fewer file descriptors on the expense of performance decrease. ++ Default in Lucene is "true". Default in Solr is "false" (since 3.6) --> ++ <!-- <useCompoundFile>false</useCompoundFile> --> ++ ++ <!-- ramBufferSizeMB sets the amount of RAM that may be used by Lucene ++ indexing for buffering added documents and deletions before they are ++ flushed to the Directory. ++ maxBufferedDocs sets a limit on the number of documents buffered ++ before flushing. ++ If both ramBufferSizeMB and maxBufferedDocs is set, then ++ Lucene will flush based on whichever limit is hit first. ++ The default is 100 MB. --> ++ <ramBufferSizeMB>32</ramBufferSizeMB> ++ <!-- <maxBufferedDocs>1000</maxBufferedDocs> --> ++ ++ <!-- Expert: Merge Policy ++ ++ The Merge Policy in Lucene controls how merging is handled by ++ Lucene. The default in Solr 3.3 is TieredMergePolicy. ++ ++ The default in 2.3 was the LogByteSizeMergePolicy, ++ previous versions used LogDocMergePolicy. ++ ++ LogByteSizeMergePolicy chooses segments to merge based on ++ their size. The Lucene 2.2 default, LogDocMergePolicy chose ++ when to merge based on number of documents ++ ++ Other implementations of MergePolicy must have a no-argument ++ constructor ++ --> ++ <mergePolicy class="org.apache.lucene.index.LogByteSizeMergePolicy"/> ++ ++ <!-- Expert: Merge Scheduler ++ ++ The Merge Scheduler in Lucene controls how merges are ++ performed. The ConcurrentMergeScheduler (Lucene 2.3 default) ++ can perform merges in the background using separate threads. ++ The SerialMergeScheduler (Lucene 2.2 default) does not. ++ --> ++ <!-- ++ <mergeScheduler class="org.apache.lucene.index.ConcurrentMergeScheduler"/> ++ --> ++ ++ <!-- Merge Factor ++ The merge factor controls how many segments will get merged at a time. ++ For TieredMergePolicy, mergeFactor is a convenience parameter which ++ will set both MaxMergeAtOnce and SegmentsPerTier at once. ++ For LogByteSizeMergePolicy, mergeFactor decides how many new segments ++ will be allowed before they are merged into one. ++ --> ++ <mergeFactor>4</mergeFactor> ++ ++ <!-- LockFactory ++ ++ This option specifies which Lucene LockFactory implementation ++ to use. ++ ++ single = SingleInstanceLockFactory - suggested for a ++ read-only index or when there is no possibility of ++ another process trying to modify the index. ++ native = NativeFSLockFactory - uses OS native file locking. ++ Do not use when multiple solr webapps in the same ++ JVM are attempting to share a single index. ++ simple = SimpleFSLockFactory - uses a plain file for locking ++ ++ Defaults: 'native' is default for Solr3.6 and later, otherwise ++ 'simple' is the default ++ ++ More details on the nuances of each LockFactory... ++ http://wiki.apache.org/lucene-java/AvailableLockFactories ++ --> ++ <lockType>${solr.lock.type:native}</lockType> ++ ++ <!-- Expert: Controls how often Lucene loads terms into memory ++ Default is 128 and is likely good for most everyone. ++ --> ++ <!-- <termIndexInterval>256</termIndexInterval> --> ++ ++ <!-- If true, IndexReaders will be reopened (often more efficient) ++ instead of closed and then opened. ++ --> ++ <reopenReaders>true</reopenReaders> ++ ++ <!-- Commit Deletion Policy ++ ++ Custom deletion policies can be specified here. The class must ++ implement org.apache.lucene.index.IndexDeletionPolicy. ++ ++ http://lucene.apache.org/java/2_9_1/api/all/org/apache/lucene/index/IndexDeletionPolicy.html ++ ++ The default Solr IndexDeletionPolicy implementation supports ++ deleting index commit points on number of commits, age of ++ commit point and optimized status. ++ ++ The latest commit point should always be preserved regardless ++ of the criteria. ++ --> ++ <deletionPolicy class="solr.SolrDeletionPolicy"> ++ <!-- The number of commit points to be kept --> ++ <str name="maxCommitsToKeep">1</str> ++ <!-- The number of optimized commit points to be kept --> ++ <str name="maxOptimizedCommitsToKeep">0</str> ++ <!-- ++ Delete all commit points once they have reached the given age. ++ Supports DateMathParser syntax e.g. ++ --> ++ <!-- ++ <str name="maxCommitAge">30MINUTES</str> ++ <str name="maxCommitAge">1DAY</str> ++ --> ++ </deletionPolicy> ++ ++ <!-- Lucene Infostream ++ ++ To aid in advanced debugging, Lucene provides an "InfoStream" ++ of detailed information when indexing. ++ ++ Setting the value to true will instruct the underlying Lucene ++ IndexWriter to write its info stream to solr's log. By default, ++ this is enabled here, and controlled through log4j.properties. ++ --> ++ <infoStream>true</infoStream> ++ ++ </indexConfig> ++ ++ <!-- JMX ++ ++ This example enables JMX if and only if an existing MBeanServer ++ is found, use this if you want to configure JMX through JVM ++ parameters. Remove this to disable exposing Solr configuration ++ and statistics to JMX. ++ ++ For more details see http://wiki.apache.org/solr/SolrJmx ++ --> ++ <!-- <jmx /> --> ++ <!-- If you want to connect to a particular server, specify the ++ agentId ++ --> ++ <!-- <jmx agentId="myAgent" /> --> ++ <!-- If you want to start a new MBeanServer, specify the serviceUrl --> ++ <!-- <jmx serviceUrl="service:jmx:rmi:///jndi/rmi://localhost:9999/solr"/> ++ --> ++ ++ <!-- The default high-performance update handler --> ++ <updateHandler class="solr.DirectUpdateHandler2"> ++ ++ <!-- AutoCommit ++ ++ Perform a <commit/> automatically under certain conditions. ++ Instead of enabling autoCommit, consider using "commitWithin" ++ when adding documents. ++ ++ http://wiki.apache.org/solr/UpdateXmlMessages ++ ++ maxDocs - Maximum number of documents to add since the last ++ commit before automatically triggering a new commit. ++ ++ maxTime - Maximum amount of time that is allowed to pass ++ since a document was added before automaticly ++ triggering a new commit. ++ --> ++ <autoCommit> ++ <maxDocs>${solr.autoCommit.MaxDocs:10000}</maxDocs> ++ <maxTime>${solr.autoCommit.MaxTime:120000}</maxTime> ++ </autoCommit> ++ ++ <!-- softAutoCommit is like autoCommit except it causes a ++ 'soft' commit which only ensures that changes are visible ++ but does not ensure that data is synced to disk. This is ++ faster and more near-realtime friendly than a hard commit. ++ --> ++ <autoSoftCommit> ++ <maxDocs>${solr.autoSoftCommit.MaxDocs:2000}</maxDocs> ++ <maxTime>${solr.autoSoftCommit.MaxTime:10000}</maxTime> ++ </autoSoftCommit> ++ ++ <!-- Update Related Event Listeners ++ ++ Various IndexWriter related events can trigger Listeners to ++ take actions. ++ ++ postCommit - fired after every commit or optimize command ++ postOptimize - fired after every optimize command ++ --> ++ <!-- The RunExecutableListener executes an external command from a ++ hook such as postCommit or postOptimize. ++ ++ exe - the name of the executable to run ++ dir - dir to use as the current working directory. (default=".") ++ wait - the calling thread waits until the executable returns. ++ (default="true") ++ args - the arguments to pass to the program. (default is none) ++ env - environment variables to set. (default is none) ++ --> ++ <!-- This example shows how RunExecutableListener could be used ++ with the script based replication... ++ http://wiki.apache.org/solr/CollectionDistribution ++ --> ++ <!-- ++ <listener event="postCommit" class="solr.RunExecutableListener"> ++ <str name="exe">solr/bin/snapshooter</str> ++ <str name="dir">.</str> ++ <bool name="wait">true</bool> ++ <arr name="args"> <str>arg1</str> <str>arg2</str> </arr> ++ <arr name="env"> <str>MYVAR=val1</str> </arr> ++ </listener> ++ --> ++ <!-- Enables a transaction log, currently used for real-time get. ++ "dir" - the target directory for transaction logs, defaults to the ++ solr data directory. --> ++ <updateLog> ++ <str name="dir">${solr.data.dir:}</str> ++ <!-- if you want to take control of the synchronization you may specify ++ the syncLevel as one of the following where ''flush'' is the default. ++ Fsync will reduce throughput. ++ <str name="syncLevel">flush|fsync|none</str> ++ --> ++ </updateLog> ++ </updateHandler> ++ ++ <!-- IndexReaderFactory ++ ++ Use the following format to specify a custom IndexReaderFactory, ++ which allows for alternate IndexReader implementations. ++ ++ ** Experimental Feature ** ++ ++ Please note - Using a custom IndexReaderFactory may prevent ++ certain other features from working. The API to ++ IndexReaderFactory may change without warning or may even be ++ removed from future releases if the problems cannot be ++ resolved. ++ ++ ** Features that may not work with custom IndexReaderFactory ** ++ ++ The ReplicationHandler assumes a disk-resident index. Using a ++ custom IndexReader implementation may cause incompatibility ++ with ReplicationHandler and may cause replication to not work ++ correctly. See SOLR-1366 for details. ++ ++ --> ++ <!-- ++ <indexReaderFactory name="IndexReaderFactory" class="package.class"> ++ <str name="someArg">Some Value</str> ++ </indexReaderFactory > ++ --> ++ ++ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ Query section - these settings control query time things like caches ++ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --> ++ <query> ++ <!-- Max Boolean Clauses ++ ++ Maximum number of clauses in each BooleanQuery, an exception ++ is thrown if exceeded. ++ ++ ** WARNING ** ++ ++ This option actually modifies a global Lucene property that ++ will affect all SolrCores. If multiple solrconfig.xml files ++ disagree on this property, the value at any given moment will ++ be based on the last SolrCore to be initialized. ++ ++ --> ++ <maxBooleanClauses>1024</maxBooleanClauses> ++ ++ <!-- Slow Query Threshold (in millis) ++ ++ At high request rates, logging all requests can become a bottleneck ++ and therefore INFO logging is often turned off. However, it is still ++ useful to be able to set a latency threshold above which a request ++ is considered "slow" and log that request at WARN level so we can ++ easily identify slow queries. ++ --> ++ <slowQueryThresholdMillis>-1</slowQueryThresholdMillis> ++ ++ <!-- Solr Internal Query Caches ++ ++ There are two implementations of cache available for Solr, ++ LRUCache, based on a synchronized LinkedHashMap, and ++ FastLRUCache, based on a ConcurrentHashMap. ++ ++ FastLRUCache has faster gets and slower puts in single ++ threaded operation and thus is generally faster than LRUCache ++ when the hit ratio of the cache is high (> 75%), and may be ++ faster under other scenarios on multi-cpu systems. ++ --> ++ ++ <!-- Filter Cache ++ ++ Cache used by SolrIndexSearcher for filters (DocSets), ++ unordered sets of *all* documents that match a query. When a ++ new searcher is opened, its caches may be prepopulated or ++ "autowarmed" using data from caches in the old searcher. ++ autowarmCount is the number of items to prepopulate. For ++ LRUCache, the autowarmed items will be the most recently ++ accessed items. ++ ++ Parameters: ++ class - the SolrCache implementation LRUCache or ++ (LRUCache or FastLRUCache) ++ size - the maximum number of entries in the cache ++ initialSize - the initial capacity (number of entries) of ++ the cache. (see java.util.HashMap) ++ autowarmCount - the number of entries to prepopulate from ++ and old cache. ++ --> ++ <filterCache class="solr.FastLRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="0"/> ++ ++ <!-- Query Result Cache ++ ++ Caches results of searches - ordered lists of document ids ++ (DocList) based on a query, a sort, and the range of documents requested. ++ --> ++ <queryResultCache class="solr.LRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="32"/> ++ ++ <!-- Document Cache ++ ++ Caches Lucene Document objects (the stored fields for each ++ document). Since Lucene internal document ids are transient, ++ this cache will not be autowarmed. ++ --> ++ <documentCache class="solr.LRUCache" ++ size="512" ++ initialSize="512" ++ autowarmCount="0"/> ++ ++ <!-- Field Value Cache ++ ++ Cache used to hold field values that are quickly accessible ++ by document id. The fieldValueCache is created by default ++ even if not configured here. ++ --> ++ <!-- ++ <fieldValueCache class="solr.FastLRUCache" ++ size="512" ++ autowarmCount="128" ++ showItems="32" /> ++ --> ++ ++ <!-- Custom Cache ++ ++ Example of a generic cache. These caches may be accessed by ++ name through SolrIndexSearcher.getCache(),cacheLookup(), and ++ cacheInsert(). The purpose is to enable easy caching of ++ user/application level data. The regenerator argument should ++ be specified as an implementation of solr.CacheRegenerator ++ if autowarming is desired. ++ --> ++ <!-- ++ <cache name="myUserCache" ++ class="solr.LRUCache" ++ size="4096" ++ initialSize="1024" ++ autowarmCount="1024" ++ regenerator="com.mycompany.MyRegenerator" ++ /> ++ --> ++ ++ <!-- Lazy Field Loading ++ ++ If true, stored fields that are not requested will be loaded ++ lazily. This can result in a significant speed improvement ++ if the usual case is to not load all stored fields, ++ especially if the skipped fields are large compressed text ++ fields. ++ --> ++ <enableLazyFieldLoading>true</enableLazyFieldLoading> ++ ++ <!-- Use Filter For Sorted Query ++ ++ A possible optimization that attempts to use a filter to ++ satisfy a search. If the requested sort does not include ++ score, then the filterCache will be checked for a filter ++ matching the query. If found, the filter will be used as the ++ source of document ids, and then the sort will be applied to ++ that. ++ ++ For most situations, this will not be useful unless you ++ frequently get the same search repeatedly with different sort ++ options, and none of them ever use "score" ++ --> ++ <!-- ++ <useFilterForSortedQuery>true</useFilterForSortedQuery> ++ --> ++ ++ <!-- Result Window Size ++ ++ An optimization for use with the queryResultCache. When a search ++ is requested, a superset of the requested number of document ids ++ are collected. For example, if a search for a particular query ++ requests matching documents 10 through 19, and queryWindowSize is 50, ++ then documents 0 through 49 will be collected and cached. Any further ++ requests in that range can be satisfied via the cache. ++ --> ++ <queryResultWindowSize>20</queryResultWindowSize> ++ ++ <!-- Maximum number of documents to cache for any entry in the ++ queryResultCache. ++ --> ++ <queryResultMaxDocsCached>200</queryResultMaxDocsCached> ++ ++ <!-- Query Related Event Listeners ++ ++ Various IndexSearcher related events can trigger Listeners to ++ take actions. ++ ++ newSearcher - fired whenever a new searcher is being prepared ++ and there is a current searcher handling requests (aka ++ registered). It can be used to prime certain caches to ++ prevent long request times for certain requests. ++ ++ firstSearcher - fired whenever a new searcher is being ++ prepared but there is no current registered searcher to handle ++ requests or to gain autowarming data from. ++ ++ --> ++ <!-- QuerySenderListener takes an array of NamedList and executes a ++ local query request for each NamedList in sequence. ++ --> ++ <listener event="newSearcher" class="solr.QuerySenderListener"> ++ <arr name="queries"> ++ <!-- ++ <lst><str name="q">solr</str><str name="sort">price asc</str></lst> ++ <lst><str name="q">rocks</str><str name="sort">weight asc</str></lst> ++ --> ++ </arr> ++ </listener> ++ <listener event="firstSearcher" class="solr.QuerySenderListener"> ++ <arr name="queries"> ++ <lst> ++ <str name="q">solr rocks</str><str name="start">0</str><str name="rows">10</str> ++ </lst> ++ </arr> ++ </listener> ++ ++ <!-- Use Cold Searcher ++ ++ If a search request comes in and there is no current ++ registered searcher, then immediately register the still ++ warming searcher and use it. If "false" then all requests ++ will block until the first searcher is done warming. ++ --> ++ <useColdSearcher>false</useColdSearcher> ++ ++ <!-- Max Warming Searchers ++ ++ Maximum number of searchers that may be warming in the ++ background concurrently. An error is returned if this limit ++ is exceeded. ++ ++ Recommend values of 1-2 for read-only slaves, higher for ++ masters w/o cache warming. ++ --> ++ <maxWarmingSearchers>2</maxWarmingSearchers> ++ ++ </query> ++ ++ <!-- Request Dispatcher ++ ++ This section contains instructions for how the SolrDispatchFilter ++ should behave when processing requests for this SolrCore. ++ ++ handleSelect affects the behavior of requests such as /select?qt=XXX ++ ++ handleSelect="true" will cause the SolrDispatchFilter to process ++ the request and will result in consistent error handling and ++ formatting for all types of requests. ++ ++ handleSelect="false" will cause the SolrDispatchFilter to ++ ignore "/select" requests and fallback to using the legacy ++ SolrServlet and it's Solr 1.1 style error formatting ++ --> ++ <requestDispatcher handleSelect="true" > ++ <!-- Request Parsing ++ ++ These settings indicate how Solr Requests may be parsed, and ++ what restrictions may be placed on the ContentStreams from ++ those requests ++ ++ enableRemoteStreaming - enables use of the stream.file ++ and stream.url parameters for specifying remote streams. ++ ++ multipartUploadLimitInKB - specifies the max size (in KiB) of ++ Multipart File Uploads that Solr will allow in a Request. ++ ++ formdataUploadLimitInKB - specifies the max size (in KiB) of ++ form data (application/x-www-form-urlencoded) sent via ++ POST. You can use POST to pass request parameters not ++ fitting into the URL. ++ ++ addHttpRequestToContext - if set to true, it will instruct ++ the requestParsers to include the original HttpServletRequest ++ object in the context map of the SolrQueryRequest under the ++ key "httpRequest". It will not be used by any of the existing ++ Solr components, but may be useful when developing custom ++ plugins. ++ ++ *** WARNING *** ++ The settings below authorize Solr to fetch remote files, You ++ should make sure your system has some authentication before ++ using enableRemoteStreaming="true" ++ ++ --> ++ <requestParsers enableRemoteStreaming="true" ++ multipartUploadLimitInKB="2048000" ++ formdataUploadLimitInKB="2048" ++ addHttpRequestToContext="false"/> ++ ++ <!-- HTTP Caching ++ ++ Set HTTP caching related parameters (for proxy caches and clients). ++ ++ The options below instruct Solr not to output any HTTP Caching ++ related headers ++ --> ++ <httpCaching never304="true" /> ++ <!-- If you include a <cacheControl> directive, it will be used to ++ generate a Cache-Control header (as well as an Expires header ++ if the value contains "max-age=") ++ ++ By default, no Cache-Control header is generated. ++ ++ You can use the <cacheControl> option even if you have set ++ never304="true" ++ --> ++ <!-- ++ <httpCaching never304="true" > ++ <cacheControl>max-age=30, public</cacheControl> ++ </httpCaching> ++ --> ++ <!-- To enable Solr to respond with automatically generated HTTP ++ Caching headers, and to response to Cache Validation requests ++ correctly, set the value of never304="false" ++ ++ This will cause Solr to generate Last-Modified and ETag ++ headers based on the properties of the Index. ++ ++ The following options can also be specified to affect the ++ values of these headers... ++ ++ lastModFrom - the default value is "openTime" which means the ++ Last-Modified value (and validation against If-Modified-Since ++ requests) will all be relative to when the current Searcher ++ was opened. You can change it to lastModFrom="dirLastMod" if ++ you want the value to exactly correspond to when the physical ++ index was last modified. ++ ++ etagSeed="..." is an option you can change to force the ETag ++ header (and validation against If-None-Match requests) to be ++ different even if the index has not changed (ie: when making ++ significant changes to your config file) ++ ++ (lastModifiedFrom and etagSeed are both ignored if you use ++ the never304="true" option) ++ --> ++ <!-- ++ <httpCaching lastModifiedFrom="openTime" ++ etagSeed="Solr"> ++ <cacheControl>max-age=30, public</cacheControl> ++ </httpCaching> ++ --> ++ </requestDispatcher> ++ ++ <!-- Request Handlers ++ ++ http://wiki.apache.org/solr/SolrRequestHandler ++ ++ Incoming queries will be dispatched to a specific handler by name ++ based on the path specified in the request. ++ ++ Legacy behavior: If the request path uses "/select" but no Request ++ Handler has that name, and if handleSelect="true" has been specified in ++ the requestDispatcher, then the Request Handler is dispatched based on ++ the qt parameter. Handlers without a leading '/' are accessed this way ++ like so: http://host/app/[core/]select?qt=name If no qt is ++ given, then the requestHandler that declares default="true" will be ++ used or the one named "standard". ++ ++ If a Request Handler is declared with startup="lazy", then it will ++ not be initialized until the first request that uses it. ++ ++ --> ++ <!-- SearchHandler ++ ++ http://wiki.apache.org/solr/SearchHandler ++ ++ For processing Search Queries, the primary Request Handler ++ provided with Solr is "SearchHandler" It delegates to a sequent ++ of SearchComponents (see below) and supports distributed ++ queries across multiple shards ++ --> ++ <!--<requestHandler name="/select" class="solr.SearchHandler">--> ++ <!-- default values for query parameters can be specified, these ++ will be overridden by parameters in the request ++ --> ++ <!--<lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <int name="rows">10</int> ++ </lst>--> ++ <!-- In addition to defaults, "appends" params can be specified ++ to identify values which should be appended to the list of ++ multi-val params from the query (or the existing "defaults"). ++ --> ++ <!-- In this example, the param "fq=instock:true" would be appended to ++ any query time fq params the user may specify, as a mechanism for ++ partitioning the index, independent of any user selected filtering ++ that may also be desired (perhaps as a result of faceted searching). ++ ++ NOTE: there is *absolutely* nothing a client can do to prevent these ++ "appends" values from being used, so don't use this mechanism ++ unless you are sure you always want it. ++ --> ++ <!-- ++ <lst name="appends"> ++ <str name="fq">inStock:true</str> ++ </lst> ++ --> ++ <!-- "invariants" are a way of letting the Solr maintainer lock down ++ the options available to Solr clients. Any params values ++ specified here are used regardless of what values may be specified ++ in either the query, the "defaults", or the "appends" params. ++ ++ In this example, the facet.field and facet.query params would ++ be fixed, limiting the facets clients can use. Faceting is ++ not turned on by default - but if the client does specify ++ facet=true in the request, these are the only facets they ++ will be able to see counts for; regardless of what other ++ facet.field or facet.query params they may specify. ++ ++ NOTE: there is *absolutely* nothing a client can do to prevent these ++ "invariants" values from being used, so don't use this mechanism ++ unless you are sure you always want it. ++ --> ++ <!-- ++ <lst name="invariants"> ++ <str name="facet.field">cat</str> ++ <str name="facet.field">manu_exact</str> ++ <str name="facet.query">price:[* TO 500]</str> ++ <str name="facet.query">price:[500 TO *]</str> ++ </lst> ++ --> ++ <!-- If the default list of SearchComponents is not desired, that ++ list can either be overridden completely, or components can be ++ prepended or appended to the default list. (see below) ++ --> ++ <!-- ++ <arr name="components"> ++ <str>nameOfCustomComponent1</str> ++ <str>nameOfCustomComponent2</str> ++ </arr> ++ --> ++ <!--</requestHandler>--> ++ ++ <!-- A request handler that returns indented JSON by default --> ++ <requestHandler name="/query" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <str name="wt">json</str> ++ <str name="indent">true</str> ++ <str name="df">text</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- ++ The export request handler is used to export full sorted result sets. ++ Do not change these defaults. ++ --> ++ ++ <requestHandler name="/export" class="solr.SearchHandler"> ++ <lst name="invariants"> ++ <str name="rq">{!xport}</str> ++ <str name="wt">xsort</str> ++ <str name="distrib">false</str> ++ </lst> ++ ++ <arr name="components"> ++ <str>query</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- A Robust Example ++ ++ This example SearchHandler declaration shows off usage of the ++ SearchHandler with many defaults declared ++ ++ Note that multiple instances of the same Request Handler ++ (SearchHandler) can be registered multiple times with different ++ names (and different init parameters) ++ --> ++ <!-- ++ <requestHandler name="/browse" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str>--> ++ ++ <!-- VelocityResponseWriter settings --> ++ <!--<str name="wt">velocity</str> ++ ++ <str name="v.template">browse</str> ++ <str name="v.layout">layout</str> ++ <str name="title">Solritas</str> ++ ++ <str name="defType">edismax</str> ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ title^10.0 description^5.0 keywords^5.0 author^2.0 resourcename^1.0 ++ </str> ++ <str name="mm">100%</str> ++ <str name="q.alt">*:*</str> ++ <str name="rows">10</str> ++ <str name="fl">*,score</str> ++ <str name="mlt.qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ <str name="mlt.fl">text,features,name,sku,id,manu,cat</str> ++ <int name="mlt.count">3</int> ++ ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ ++ <str name="facet">on</str> ++ <str name="facet.field">cat</str> ++ <str name="facet.field">manu_exact</str> ++ <str name="facet.query">ipod</str> ++ <str name="facet.query">GB</str> ++ <str name="facet.mincount">1</str> ++ <str name="facet.pivot">cat,inStock</str> ++ <str name="facet.range.other">after</str> ++ <str name="facet.range">price</str> ++ <int name="f.price.facet.range.start">0</int> ++ <int name="f.price.facet.range.end">600</int> ++ <int name="f.price.facet.range.gap">50</int> ++ <str name="facet.range">popularity</str> ++ <int name="f.popularity.facet.range.start">0</int> ++ <int name="f.popularity.facet.range.end">10</int> ++ <int name="f.popularity.facet.range.gap">3</int> ++ <str name="facet.range">manufacturedate_dt</str> ++ <str name="f.manufacturedate_dt.facet.range.start">NOW/YEAR-10YEARS</str> ++ <str name="f.manufacturedate_dt.facet.range.end">NOW</str> ++ <str name="f.manufacturedate_dt.facet.range.gap">+1YEAR</str> ++ <str name="f.manufacturedate_dt.facet.range.other">before</str> ++ <str name="f.manufacturedate_dt.facet.range.other">after</str>--> ++ ++ <!-- Highlighting defaults --> ++ <!--<str name="hl">on</str> ++ <str name="hl.fl">text features name</str> ++ <str name="f.name.hl.fragsize">0</str> ++ <str name="f.name.hl.alternateField">name</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ </arr>--> ++ <!-- ++ <str name="url-scheme">httpx</str> ++ --> ++ <!--</requestHandler>--> ++ <!-- trivia: the name pinkPony requestHandler was an agreement between the Search API and the ++ apachesolr maintainers. The decision was taken during the Drupalcon Munich codesprint. ++ --> ++ <requestHandler name="pinkPony" class="solr.SearchHandler" default="true"> ++ <lst name="defaults"> ++ <str name="defType">edismax</str> ++ <str name="df">content</str> ++ <str name="echoParams">explicit</str> ++ <bool name="omitHeader">true</bool> ++ <float name="tie">0.01</float> ++ <!-- Don't abort searches for the pinkPony request handler (set in solrcore.properties) --> ++ <int name="timeAllowed">${solr.pinkPony.timeAllowed:-1}</int> ++ <str name="q.alt">*:*</str> ++ ++ <!-- By default, don't spell check --> ++ <str name="spellcheck">false</str> ++ <!-- Defaults for the spell checker when used --> ++ <str name="spellcheck.onlyMorePopular">true</str> ++ <str name="spellcheck.extendedResults">false</str> ++ <!-- The number of suggestions to return --> ++ <str name="spellcheck.count">1</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ <str>elevator</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- The more like this handler offers many advantages over the standard handler, ++ when performing moreLikeThis requests.--> ++ <requestHandler name="mlt" class="solr.MoreLikeThisHandler"> ++ <lst name="defaults"> ++ <str name="df">content</str> ++ <str name="mlt.mintf">1</str> ++ <str name="mlt.mindf">1</str> ++ <str name="mlt.minwl">3</str> ++ <str name="mlt.maxwl">15</str> ++ <str name="mlt.maxqt">20</str> ++ <str name="mlt.match.include">false</str> ++ <!-- Abort any searches longer than 2 seconds (set in solrcore.properties) --> ++ <int name="timeAllowed">${solr.mlt.timeAllowed:2000}</int> ++ </lst> ++ </requestHandler> ++ ++ <!-- A minimal query type for doing luene queries --> ++ <requestHandler name="standard" class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <str name="df">content</str> ++ <str name="echoParams">explicit</str> ++ <bool name="omitHeader">true</bool> ++ </lst> ++ </requestHandler> ++ ++ <!-- Update Request Handler. ++ ++ http://wiki.apache.org/solr/UpdateXmlMessages ++ ++ The canonical Request Handler for Modifying the Index through ++ commands specified using XML, JSON, CSV, or JAVABIN ++ ++ Note: Since solr1.1 requestHandlers requires a valid content ++ type header if posted in the body. For example, curl now ++ requires: -H 'Content-type:text/xml; charset=utf-8' ++ ++ To override the request content type and force a specific ++ Content-type, use the request parameter: ++ ?update.contentType=text/csv ++ ++ This handler will pick a response format to match the input ++ if the 'wt' parameter is not explicit ++ --> ++ <!--<requestHandler name="/update" class="solr.UpdateRequestHandler"> ++ </requestHandler>--> ++ <initParams path="/update/**,/query,/select,/tvrh,/elevate,/spell,/browse"> ++ <lst name="defaults"> ++ <str name="df">text</str> ++ </lst> ++ </initParams> ++ ++ <initParams path="/update/json/docs"> ++ <lst name="defaults"> ++ <!--this ensures that the entire json doc will be stored verbatim into one field--> ++ <str name="srcField">_src_</str> ++ <!--This means a the uniqueKeyField will be extracted from the fields and ++ all fields go into the 'df' field. In this config df is already configured to be 'text' ++ --> ++ <str name="mapUniqueKeyOnly">true</str> ++ </lst> ++ ++ </initParams> ++ ++ <!-- CSV Update Request Handler ++ http://wiki.apache.org/solr/UpdateCSV ++ --> ++ <requestHandler name="/update/csv" ++ class="solr.CSVRequestHandler" ++ startup="lazy" /> ++ ++ <!-- JSON Update Request Handler ++ http://wiki.apache.org/solr/UpdateJSON ++ --> ++ <requestHandler name="/update/json" ++ class="solr.JsonUpdateRequestHandler" ++ startup="lazy" /> ++ ++ <!-- Solr Cell Update Request Handler ++ ++ http://wiki.apache.org/solr/ExtractingRequestHandler ++ ++ --> ++ <requestHandler name="/update/extract" ++ startup="lazy" ++ class="solr.extraction.ExtractingRequestHandler" > ++ <lst name="defaults"> ++ <!-- All the main content goes into "text"... if you need to return ++ the extracted text or do highlighting, use a stored field. --> ++ <str name="fmap.content">text</str> ++ <str name="lowernames">true</str> ++ <str name="uprefix">ignored_</str> ++ ++ <!-- capture link hrefs but ignore div attributes --> ++ <str name="captureAttr">true</str> ++ <str name="fmap.a">links</str> ++ <str name="fmap.div">ignored_</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- XSLT Update Request Handler ++ Transforms incoming XML with stylesheet identified by tr= ++ --> ++ <requestHandler name="/update/xslt" ++ startup="lazy" ++ class="solr.XsltUpdateRequestHandler"/> ++ ++ <!-- Field Analysis Request Handler ++ ++ RequestHandler that provides much the same functionality as ++ analysis.jsp. Provides the ability to specify multiple field ++ types and field names in the same request and outputs ++ index-time and query-time analysis for each of them. ++ ++ Request parameters are: ++ analysis.fieldname - field name whose analyzers are to be used ++ ++ analysis.fieldtype - field type whose analyzers are to be used ++ analysis.fieldvalue - text for index-time analysis ++ q (or analysis.q) - text for query time analysis ++ analysis.showmatch (true|false) - When set to true and when ++ query analysis is performed, the produced tokens of the ++ field value analysis will be marked as "matched" for every ++ token that is produces by the query analysis ++ --> ++ <requestHandler name="/analysis/field" ++ startup="lazy" ++ class="solr.FieldAnalysisRequestHandler" /> ++ ++ <!-- Document Analysis Handler ++ ++ http://wiki.apache.org/solr/AnalysisRequestHandler ++ ++ An analysis handler that provides a breakdown of the analysis ++ process of provided documents. This handler expects a (single) ++ content stream with the following format: ++ ++ <docs> ++ <doc> ++ <field name="id">1</field> ++ <field name="name">The Name</field> ++ <field name="text">The Text Value</field> ++ </doc> ++ <doc>...</doc> ++ <doc>...</doc> ++ ... ++ </docs> ++ ++ Note: Each document must contain a field which serves as the ++ unique key. This key is used in the returned response to associate ++ an analysis breakdown to the analyzed document. ++ ++ Like the FieldAnalysisRequestHandler, this handler also supports ++ query analysis by sending either an "analysis.query" or "q" ++ request parameter that holds the query text to be analyzed. It ++ also supports the "analysis.showmatch" parameter which when set to ++ true, all field tokens that match the query tokens will be marked ++ as a "match". ++ --> ++ <requestHandler name="/analysis/document" ++ class="solr.DocumentAnalysisRequestHandler" ++ startup="lazy" /> ++ ++ <!-- Admin Handlers ++ ++ As of Solr 5.0.0, the "/admin/" handlers are registered implicitly. ++ --> ++ <!-- <requestHandler name="/admin/" class="solr.admin.AdminHandlers" /> --> ++ <!-- This single handler is equivalent to the following... --> ++ <!-- ++ <requestHandler name="/admin/luke" class="solr.admin.LukeRequestHandler" /> ++ <requestHandler name="/admin/system" class="solr.admin.SystemInfoHandler" /> ++ <requestHandler name="/admin/plugins" class="solr.admin.PluginInfoHandler" /> ++ <requestHandler name="/admin/threads" class="solr.admin.ThreadDumpHandler" /> ++ <requestHandler name="/admin/properties" class="solr.admin.PropertiesRequestHandler" /> ++ <requestHandler name="/admin/file" class="solr.admin.ShowFileRequestHandler" > ++ --> ++ <!-- If you wish to hide files under ${solr.home}/conf, explicitly ++ register the ShowFileRequestHandler using the definition below. ++ NOTE: The glob pattern ('*') is the only pattern supported at present, *.xml will ++ not exclude all files ending in '.xml'. Use it to exclude _all_ updates ++ --> ++ <!-- ++ <requestHandler name="/admin/file" ++ class="solr.admin.ShowFileRequestHandler" > ++ <lst name="invariants"> ++ <str name="hidden">synonyms.txt</str> ++ <str name="hidden">anotherfile.txt</str> ++ <str name="hidden">*</str> ++ </lst> ++ </requestHandler> ++ --> ++ <!-- ++ Enabling this request handler (which is NOT a default part of the admin handler) will allow the Solr UI to edit ++ all the config files. This is intended for secure/development use ONLY! Leaving available and publically ++ accessible is a security vulnerability and should be done with extreme caution! ++ --> ++ <!-- ++ <requestHandler name="/admin/fileedit" class="solr.admin.EditFileRequestHandler" > ++ <lst name="invariants"> ++ <str name="qt">pinkPony</str> ++ <str name="q">solrpingquery</str> ++ <str name="omitHeader">false</str> ++ </lst> ++ <lst name="defaults"> ++ <str name="echoParams">all</str> ++ </lst> ++ <!- An optional feature of the PingRequestHandler is to configure the ++ handler with a "healthcheckFile" which can be used to enable/disable ++ the PingRequestHandler. ++ relative paths are resolved against the data dir ++ --> ++ <!-- <str name="healthcheckFile">server-enabled.txt</str> --> ++ <!-- </requestHandler> ++ --> ++ ++ <!-- Echo the request contents back to the client --> ++ <requestHandler name="/debug/dump" class="solr.DumpRequestHandler" > ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ <str name="echoHandler">true</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Solr Replication ++ ++ The SolrReplicationHandler supports replicating indexes from a ++ "master" used for indexing and "slaves" used for queries. ++ ++ http://wiki.apache.org/solr/SolrReplication ++ ++ In the example below, remove the <lst name="master"> section if ++ this is just a slave and remove the <lst name="slave"> section ++ if this is just a master. ++ --> ++ <requestHandler name="/replication" class="solr.ReplicationHandler" > ++ <lst name="master"> ++ <str name="enable">${solr.replication.master:false}</str> ++ <str name="replicateAfter">commit</str> ++ <str name="replicateAfter">startup</str> ++ <str name="confFiles">${solr.replication.confFiles:schema.xml,mapping-ISOLatin1Accent.txt,protwords.txt,stopwords.txt,synonyms.txt,elevate.xml}</str> ++ </lst> ++ <lst name="slave"> ++ <str name="enable">${solr.replication.slave:false}</str> ++ <str name="masterUrl">${solr.replication.masterUrl:http://localhost:8983/solr}/replication</str> ++ <str name="pollInterval">${solr.replication.pollInterval:00:00:60}</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Realtime get handler, guaranteed to return the latest stored fields of ++ any document, without the need to commit or open a new searcher. The ++ current implementation relies on the updateLog feature being enabled. ++ --> ++ <requestHandler name="/get" class="solr.RealTimeGetHandler"> ++ <lst name="defaults"> ++ <str name="omitHeader">true</str> ++ <str name="wt">json</str> ++ <str name="indent">true</str> ++ </lst> ++ </requestHandler> ++ ++ <!-- Search Components ++ ++ Search components are registered to SolrCore and used by ++ instances of SearchHandler (which can access them by name) ++ ++ By default, the following components are available: ++ ++ <searchComponent name="query" class="solr.QueryComponent" /> ++ <searchComponent name="facet" class="solr.FacetComponent" /> ++ <searchComponent name="mlt" class="solr.MoreLikeThisComponent" /> ++ <searchComponent name="highlight" class="solr.HighlightComponent" /> ++ <searchComponent name="stats" class="solr.StatsComponent" /> ++ <searchComponent name="debug" class="solr.DebugComponent" /> ++ ++ Default configuration in a requestHandler would look like: ++ ++ <arr name="components"> ++ <str>query</str> ++ <str>facet</str> ++ <str>mlt</str> ++ <str>highlight</str> ++ <str>stats</str> ++ <str>debug</str> ++ </arr> ++ ++ If you register a searchComponent to one of the standard names, ++ that will be used instead of the default. ++ ++ To insert components before or after the 'standard' components, use: ++ ++ <arr name="first-components"> ++ <str>myFirstComponentName</str> ++ </arr> ++ ++ <arr name="last-components"> ++ <str>myLastComponentName</str> ++ </arr> ++ ++ NOTE: The component registered with the name "debug" will ++ always be executed after the "last-components" ++ ++ --> ++ ++ <!-- A request handler for demonstrating the spellcheck component. ++ ++ NOTE: This is purely as an example. The whole purpose of the ++ SpellCheckComponent is to hook it into the request handler that ++ handles your normal user queries so that a separate request is ++ not needed to get suggestions. ++ ++ IN OTHER WORDS, THERE IS REALLY GOOD CHANCE THE SETUP BELOW IS ++ NOT WHAT YOU WANT FOR YOUR PRODUCTION SYSTEM! ++ ++ See http://wiki.apache.org/solr/SpellCheckComponent for details ++ on the request parameters. ++ --> ++ <requestHandler name="/spell" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <!-- Solr will use suggestions from both the 'default' spellchecker ++ and from the 'wordbreak' spellchecker and combine them. ++ collations (re-written queries) can include a combination of ++ corrections from both spellcheckers --> ++ <str name="spellcheck.dictionary">default</str> ++ <str name="spellcheck.dictionary">wordbreak</str> ++ <str name="spellcheck.onlyMorePopular">false</str> ++ <str name="spellcheck.extendedResults">false</str> ++ <str name="spellcheck.count">1</str> ++ <str name="spellcheck.alternativeTermCount">5</str> ++ <str name="spellcheck.maxResultsForSuggest">5</str> ++ <str name="spellcheck.collate">true</str> ++ <str name="spellcheck.collateExtendedResults">true</str> ++ <str name="spellcheck.maxCollationTries">10</str> ++ <str name="spellcheck.maxCollations">5</str> ++ </lst> ++ <arr name="last-components"> ++ <str>spellcheck</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- This is disabled by default because it currently causes long startup times on ++ big indexes, even when never used. See SOLR-6679 for background. ++ ++ To use this suggester, set the "solr.suggester.enabled=true" system property ++ --> ++ <searchComponent name="suggest" class="solr.SuggestComponent" ++ enable="${solr.suggester.enabled:false}" > ++ <lst name="suggester"> ++ <str name="name">mySuggester</str> ++ <str name="lookupImpl">FuzzyLookupFactory</str> ++ <str name="dictionaryImpl">DocumentDictionaryFactory</str> ++ <str name="field">cat</str> ++ <str name="weightField">price</str> ++ <str name="suggestAnalyzerFieldType">string</str> ++ </lst> ++ </searchComponent> ++ ++ <requestHandler name="/suggest" class="solr.SearchHandler" ++ startup="lazy" enable="${solr.suggester.enabled:false}" > ++ <lst name="defaults"> ++ <str name="suggest">true</str> ++ <str name="suggest.count">10</str> ++ </lst> ++ <arr name="components"> ++ <str>suggest</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Term Vector Component ++ ++ http://wiki.apache.org/solr/TermVectorComponent ++ --> ++ <searchComponent name="tvComponent" class="solr.TermVectorComponent"/> ++ ++ <!-- A request handler for demonstrating the term vector component ++ ++ This is purely as an example. ++ ++ In reality you will likely want to add the component to your ++ already specified request handlers. ++ --> ++ <requestHandler name="/tvrh" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <bool name="tv">true</bool> ++ </lst> ++ <arr name="last-components"> ++ <str>tvComponent</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Clustering Component ++ ++ http://wiki.apache.org/solr/ClusteringComponent ++ ++ This relies on third party jars which are notincluded in the ++ release. To use this component (and the "/clustering" handler) ++ Those jars will need to be downloaded, and you'll need to set ++ the solr.cluster.enabled system property when running solr... ++ ++ java -Dsolr.clustering.enabled=true -jar start.jar ++ --> ++ <!-- <searchComponent name="clustering" ++ enable="${solr.clustering.enabled:false}" ++ class="solr.clustering.ClusteringComponent" > --> ++ <!-- Declare an engine --> ++ <!--<lst name="engine">--> ++ <!-- The name, only one can be named "default" --> ++ <!--<str name="name">default</str>--> ++ ++ <!-- Class name of Carrot2 clustering algorithm. ++ ++ Currently available algorithms are: ++ ++ * org.carrot2.clustering.lingo.LingoClusteringAlgorithm ++ * org.carrot2.clustering.stc.STCClusteringAlgorithm ++ * org.carrot2.clustering.kmeans.BisectingKMeansClusteringAlgorithm ++ ++ See http://project.carrot2.org/algorithms.html for the ++ algorithm's characteristics. ++ --> ++ <!--<str name="carrot.algorithm">org.carrot2.clustering.lingo.LingoClusteringAlgorithm</str>--> ++ ++ <!-- Overriding values for Carrot2 default algorithm attributes. ++ ++ For a description of all available attributes, see: ++ http://download.carrot2.org/stable/manual/#chapter.components. ++ Use attribute key as name attribute of str elements ++ below. These can be further overridden for individual ++ requests by specifying attribute key as request parameter ++ name and attribute value as parameter value. ++ --> ++ <!--<str name="LingoClusteringAlgorithm.desiredClusterCountBase">20</str>--> ++ ++ <!-- Location of Carrot2 lexical resources. ++ ++ A directory from which to load Carrot2-specific stop words ++ and stop labels. Absolute or relative to Solr config directory. ++ If a specific resource (e.g. stopwords.en) is present in the ++ specified dir, it will completely override the corresponding ++ default one that ships with Carrot2. ++ ++ For an overview of Carrot2 lexical resources, see: ++ http://download.carrot2.org/head/manual/#chapter.lexical-resources ++ --> ++ <!--<str name="carrot.lexicalResourcesDir">clustering/carrot2</str>--> ++ ++ <!-- The language to assume for the documents. ++ ++ For a list of allowed values, see: ++ http://download.carrot2.org/stable/manual/#section.attribute.lingo.MultilingualClustering.defaultLanguage ++ --> ++ <!--<str name="MultilingualClustering.defaultLanguage">ENGLISH</str> ++ </lst> ++ <lst name="engine"> ++ <str name="name">stc</str> ++ <str name="carrot.algorithm">org.carrot2.clustering.stc.STCClusteringAlgorithm</str> ++ </lst> ++ </searchComponent>--> ++ ++ <!-- A request handler for demonstrating the clustering component ++ ++ This is purely as an example. ++ ++ In reality you will likely want to add the component to your ++ already specified request handlers. ++ --> ++ <!--<requestHandler name="/clustering" ++ startup="lazy" ++ enable="${solr.clustering.enabled:false}" ++ class="solr.SearchHandler"> ++ <lst name="defaults"> ++ <bool name="clustering">true</bool> ++ <str name="clustering.engine">default</str> ++ <bool name="clustering.results">true</bool>--> ++ <!-- The title field --> ++ <!--<str name="carrot.title">name</str>--> ++ <!--<str name="carrot.url">id</str>--> ++ <!-- The field to cluster on --> ++ <!--<str name="carrot.snippet">features</str>--> ++ <!-- produce summaries --> ++ <!--<bool name="carrot.produceSummary">true</bool>--> ++ <!-- the maximum number of labels per cluster --> ++ <!--<int name="carrot.numDescriptions">5</int>--> ++ <!-- produce sub clusters --> ++ <!--<bool name="carrot.outputSubClusters">false</bool>--> ++ ++ <!--<str name="defType">edismax</str> ++ <str name="qf"> ++ text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4 ++ </str> ++ <str name="q.alt">*:*</str> ++ <str name="rows">10</str> ++ <str name="fl">*,score</str> ++ </lst> ++ <arr name="last-components"> ++ <str>clustering</str> ++ </arr> ++ </requestHandler>--> ++ ++ <!-- Terms Component ++ ++ http://wiki.apache.org/solr/TermsComponent ++ ++ A component to return terms and document frequency of those ++ terms ++ --> ++ <searchComponent name="terms" class="solr.TermsComponent"/> ++ ++ <!-- A request handler for demonstrating the terms component --> ++ <requestHandler name="/terms" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <bool name="terms">true</bool> ++ </lst> ++ <arr name="components"> ++ <str>terms</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Query Elevation Component ++ ++ http://wiki.apache.org/solr/QueryElevationComponent ++ ++ a search component that enables you to configure the top ++ results for a given query regardless of the normal lucene ++ scoring. ++ --> ++ <searchComponent name="elevator" class="solr.QueryElevationComponent" > ++ <!-- pick a fieldType to analyze queries --> ++ <str name="queryFieldType">string</str> ++ <str name="config-file">elevate.xml</str> ++ </searchComponent> ++ ++ <!-- A request handler for demonstrating the elevator component --> ++ <requestHandler name="/elevate" class="solr.SearchHandler" startup="lazy"> ++ <lst name="defaults"> ++ <str name="echoParams">explicit</str> ++ </lst> ++ <arr name="last-components"> ++ <str>elevator</str> ++ </arr> ++ </requestHandler> ++ ++ <!-- Highlighting Component ++ ++ http://wiki.apache.org/solr/HighlightingParameters ++ --> ++ <searchComponent class="solr.HighlightComponent" name="highlight"> ++ <highlighting> ++ <!-- Configure the standard fragmenter --> ++ <!-- This could most likely be commented out in the "default" case --> ++ <fragmenter name="gap" ++ default="true" ++ class="solr.highlight.GapFragmenter"> ++ <lst name="defaults"> ++ <int name="hl.fragsize">100</int> ++ </lst> ++ </fragmenter> ++ ++ <!-- A regular-expression-based fragmenter ++ (for sentence extraction) ++ --> ++ <fragmenter name="regex" ++ class="solr.highlight.RegexFragmenter"> ++ <lst name="defaults"> ++ <!-- slightly smaller fragsizes work better because of slop --> ++ <int name="hl.fragsize">70</int> ++ <!-- allow 50% slop on fragment sizes --> ++ <float name="hl.regex.slop">0.5</float> ++ <!-- a basic sentence pattern --> ++ <str name="hl.regex.pattern">[-\w ,/\n\"']{20,200}</str> ++ </lst> ++ </fragmenter> ++ ++ <!-- Configure the standard formatter --> ++ <formatter name="html" ++ default="true" ++ class="solr.highlight.HtmlFormatter"> ++ <lst name="defaults"> ++ <str name="hl.simple.pre"><![CDATA[<strong>]]></str> ++ <str name="hl.simple.post"><![CDATA[</strong>]]></str> ++ </lst> ++ </formatter> ++ ++ <!-- Configure the standard encoder --> ++ <encoder name="html" ++ class="solr.highlight.HtmlEncoder" /> ++ ++ <!-- Configure the standard fragListBuilder --> ++ <fragListBuilder name="simple" ++ default="true" ++ class="solr.highlight.SimpleFragListBuilder"/> ++ ++ <!-- Configure the single fragListBuilder --> ++ <fragListBuilder name="single" ++ class="solr.highlight.SingleFragListBuilder"/> ++ ++ <!-- default tag FragmentsBuilder --> ++ <fragmentsBuilder name="default" ++ default="true" ++ class="solr.highlight.ScoreOrderFragmentsBuilder"> ++ <!-- ++ <lst name="defaults"> ++ <str name="hl.multiValuedSeparatorChar">/</str> ++ </lst> ++ --> ++ </fragmentsBuilder> ++ ++ <!-- multi-colored tag FragmentsBuilder --> ++ <fragmentsBuilder name="colored" ++ class="solr.highlight.ScoreOrderFragmentsBuilder"> ++ <lst name="defaults"> ++ <str name="hl.tag.pre"><![CDATA[ ++ <b style="background:yellow">,<b style="background:lawgreen">, ++ <b style="background:aquamarine">,<b style="background:magenta">, ++ <b style="background:palegreen">,<b style="background:coral">, ++ <b style="background:wheat">,<b style="background:khaki">, ++ <b style="background:lime">,<b style="background:deepskyblue">]]></str> ++ <str name="hl.tag.post"><![CDATA[</b>]]></str> ++ </lst> ++ </fragmentsBuilder> ++ ++ <boundaryScanner name="default" ++ default="true" ++ class="solr.highlight.SimpleBoundaryScanner"> ++ <lst name="defaults"> ++ <str name="hl.bs.maxScan">10</str> ++ <str name="hl.bs.chars">.,!? 	 </str> ++ </lst> ++ </boundaryScanner> ++ ++ <boundaryScanner name="breakIterator" ++ class="solr.highlight.BreakIteratorBoundaryScanner"> ++ <lst name="defaults"> ++ <!-- type should be one of CHARACTER, WORD(default), LINE and SENTENCE --> ++ <str name="hl.bs.type">WORD</str> ++ <!-- language and country are used when constructing Locale object. --> ++ <!-- And the Locale object will be used when getting instance of BreakIterator --> ++ <str name="hl.bs.language">en</str> ++ <str name="hl.bs.country">US</str> ++ </lst> ++ </boundaryScanner> ++ </highlighting> ++ </searchComponent> ++ ++ <!-- Update Processors ++ ++ Chains of Update Processor Factories for dealing with Update ++ Requests can be declared, and then used by name in Update ++ Request Processors ++ ++ http://wiki.apache.org/solr/UpdateRequestProcessor ++ ++ --> ++ <!-- Deduplication ++ ++ An example dedup update processor that creates the "id" field ++ on the fly based on the hash code of some other fields. This ++ example has overwriteDupes set to false since we are using the ++ id field as the signatureField and Solr will maintain ++ uniqueness based on that anyway. ++ ++ --> ++ <!-- ++ <updateRequestProcessorChain name="dedupe"> ++ <processor class="solr.processor.SignatureUpdateProcessorFactory"> ++ <bool name="enabled">true</bool> ++ <str name="signatureField">id</str> ++ <bool name="overwriteDupes">false</bool> ++ <str name="fields">name,features,cat</str> ++ <str name="signatureClass">solr.processor.Lookup3Signature</str> ++ </processor> ++ <processor class="solr.LogUpdateProcessorFactory" /> ++ <processor class="solr.RunUpdateProcessorFactory" /> ++ </updateRequestProcessorChain> ++ --> ++ ++ <!-- Language identification ++ ++ This example update chain identifies the language of the incoming ++ documents using the langid contrib. The detected language is ++ written to field language_s. No field name mapping is done. ++ The fields used for detection are text, title, subject and description, ++ making this example suitable for detecting languages form full-text ++ rich documents injected via ExtractingRequestHandler. ++ See more about langId at http://wiki.apache.org/solr/LanguageDetection ++ --> ++ <!-- ++ <updateRequestProcessorChain name="langid"> ++ <processor class="org.apache.solr.update.processor.TikaLanguageIdentifierUpdateProcessorFactory"> ++ <str name="langid.fl">text,title,subject,description</str> ++ <str name="langid.langField">language_s</str> ++ <str name="langid.fallback">en</str> ++ </processor> ++ <processor class="solr.LogUpdateProcessorFactory" /> ++ <processor class="solr.RunUpdateProcessorFactory" /> ++ </updateRequestProcessorChain> ++ --> ++ ++ <!-- Response Writers ++ ++ http://wiki.apache.org/solr/QueryResponseWriter ++ ++ Request responses will be written using the writer specified by ++ the 'wt' request parameter matching the name of a registered ++ writer. ++ ++ The "default" writer is the default and will be used if 'wt' is ++ not specified in the request. ++ --> ++ <!-- The following response writers are implicitly configured unless ++ overridden... ++ --> ++ <!-- ++ <queryResponseWriter name="xml" ++ default="true" ++ class="solr.XMLResponseWriter" /> ++ <queryResponseWriter name="json" class="solr.JSONResponseWriter"/> ++ <queryResponseWriter name="python" class="solr.PythonResponseWriter"/> ++ <queryResponseWriter name="ruby" class="solr.RubyResponseWriter"/> ++ <queryResponseWriter name="php" class="solr.PHPResponseWriter"/> ++ <queryResponseWriter name="phps" class="solr.PHPSerializedResponseWriter"/> ++ <queryResponseWriter name="csv" class="solr.CSVResponseWriter"/> ++ --> ++ ++ <queryResponseWriter name="json" class="solr.JSONResponseWriter"> ++ <!-- For the purposes of the tutorial, JSON responses are written as ++ plain text so that they are easy to read in *any* browser. ++ If you expect a MIME type of "application/json" just remove this override. ++ --> ++ <str name="content-type">text/plain; charset=UTF-8</str> ++ </queryResponseWriter> ++ ++ <!-- ++ Custom response writers can be declared as needed... ++ --> ++ <!-- The solr.velocity.enabled flag is used by Solr's test cases so that this response writer is not ++ loaded (causing an error if contrib/velocity has not been built fully) --> ++ <!-- <queryResponseWriter name="velocity" class="solr.VelocityResponseWriter" enable="${solr.velocity.enabled:true}"/> --> ++ ++ <!-- XSLT response writer transforms the XML output by any xslt file found ++ in Solr's conf/xslt directory. Changes to xslt files are checked for ++ every xsltCacheLifetimeSeconds. ++ --> ++ <queryResponseWriter name="xslt" class="solr.XSLTResponseWriter"> ++ <int name="xsltCacheLifetimeSeconds">5</int> ++ </queryResponseWriter> ++ ++ <!-- Query Parsers ++ ++ http://wiki.apache.org/solr/SolrQuerySyntax ++ ++ Multiple QParserPlugins can be registered by name, and then ++ used in either the "defType" param for the QueryComponent (used ++ by SearchHandler) or in LocalParams ++ --> ++ <!-- example of registering a query parser --> ++ <!-- ++ <queryParser name="myparser" class="com.mycompany.MyQParserPlugin"/> ++ --> ++ ++ <!-- Function Parsers ++ ++ http://wiki.apache.org/solr/FunctionQuery ++ ++ Multiple ValueSourceParsers can be registered by name, and then ++ used as function names when using the "func" QParser. ++ --> ++ <!-- example of registering a custom function parser --> ++ <!-- ++ <valueSourceParser name="myfunc" ++ class="com.mycompany.MyValueSourceParser" /> ++ --> ++ ++ <!-- Legacy config for the admin interface --> ++ <admin> ++ <defaultQuery>*:*</defaultQuery> ++ ++ <!-- configure a healthcheck file for servers behind a ++ loadbalancer ++ --> ++ <!-- ++ <healthcheck type="file">server-enabled</healthcheck> ++ --> ++ </admin> ++ ++ <!-- Following is a dynamic way to include other components or any customized solrconfig.xml stuff, added by other contrib modules --> ++ <xi:include href="solrconfig_extra.xml" xmlns:xi="http://www.w3.org/2001/XInclude"> ++ <xi:fallback> ++ <!-- Spell Check ++ ++ The spell check component can return a list of alternative spelling ++ suggestions. This component must be defined in ++ solrconfig_extra.xml if present, since it's used in the search handler. ++ ++ http://wiki.apache.org/solr/SpellCheckComponent ++ --> ++ <searchComponent name="spellcheck" class="solr.SpellCheckComponent"> ++ ++ <str name="queryAnalyzerFieldType">textSpell</str> ++ ++ <!-- a spellchecker built from a field of the main index --> ++ <lst name="spellchecker"> ++ <str name="name">default</str> ++ <str name="field">spell</str> ++ <str name="spellcheckIndexDir">spellchecker</str> ++ <str name="buildOnOptimize">true</str> ++ </lst> ++ </searchComponent> ++ </xi:fallback> ++ </xi:include> ++ ++</config> +diff --git a/solr-conf/6.x/solrconfig_extra.xml b/solr-conf/6.x/solrconfig_extra.xml +new file mode 100644 +index 0000000..c5bc3ac +--- /dev/null ++++ b/solr-conf/6.x/solrconfig_extra.xml +@@ -0,0 +1,80 @@ ++<!-- Spell Check ++ ++ The spell check component can return a list of alternative spelling ++ suggestions. ++ ++ http://wiki.apache.org/solr/SpellCheckComponent ++ --> ++<searchComponent name="spellcheck" class="solr.SpellCheckComponent"> ++ ++<str name="queryAnalyzerFieldType">textSpell</str> ++ ++<!-- Multiple "Spell Checkers" can be declared and used by this ++ component ++ --> ++ ++<!-- a spellchecker built from a field of the main index, and ++ written to disk ++ --> ++<lst name="spellchecker"> ++ <str name="name">default</str> ++ <str name="field">spell</str> ++ <str name="spellcheckIndexDir">spellchecker</str> ++ <str name="buildOnOptimize">true</str> ++ <!-- uncomment this to require terms to occur in 1% of the documents in order to be included in the dictionary ++ <float name="thresholdTokenFrequency">.01</float> ++ --> ++</lst> ++ ++<!-- ++ Adding German spellhecker index to our Solr index ++ This also requires to enable the content in schema_extra_types.xml and schema_extra_fields.xml ++--> ++<!-- ++<lst name="spellchecker"> ++ <str name="name">spellchecker_de</str> ++ <str name="field">spell_de</str> ++ <str name="spellcheckIndexDir">./spellchecker_de</str> ++ <str name="buildOnOptimize">true</str> ++</lst> ++--> ++ ++<!-- a spellchecker that uses a different distance measure --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="name">jarowinkler</str> ++ <str name="field">spell</str> ++ <str name="distanceMeasure"> ++ org.apache.lucene.search.spell.JaroWinklerDistance ++ </str> ++ <str name="spellcheckIndexDir">spellcheckerJaro</str> ++ </lst> ++ --> ++ ++<!-- a spellchecker that use an alternate comparator ++ ++ comparatorClass be one of: ++ 1. score (default) ++ 2. freq (Frequency first, then score) ++ 3. A fully qualified class name ++ --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="name">freq</str> ++ <str name="field">lowerfilt</str> ++ <str name="spellcheckIndexDir">spellcheckerFreq</str> ++ <str name="comparatorClass">freq</str> ++ <str name="buildOnCommit">true</str> ++ --> ++ ++<!-- A spellchecker that reads the list of words from a file --> ++<!-- ++ <lst name="spellchecker"> ++ <str name="classname">solr.FileBasedSpellChecker</str> ++ <str name="name">file</str> ++ <str name="sourceLocation">spellings.txt</str> ++ <str name="characterEncoding">UTF-8</str> ++ <str name="spellcheckIndexDir">spellcheckerFile</str> ++ </lst> ++ --> ++</searchComponent> +diff --git a/solr-conf/6.x/solrcore.properties b/solr-conf/6.x/solrcore.properties +new file mode 100644 +index 0000000..fb8d7d0 +--- /dev/null ++++ b/solr-conf/6.x/solrcore.properties +@@ -0,0 +1,20 @@ ++# Defines Solr properties for this specific core. ++solr.replication.master=false ++solr.replication.slave=false ++solr.replication.pollInterval=00:00:60 ++solr.replication.masterUrl=http://localhost:8983/solr ++solr.replication.confFiles=schema.xml,mapping-ISOLatin1Accent.txt,protwords.txt,stopwords.txt,synonyms.txt,elevate.xml ++solr.mlt.timeAllowed=2000 ++# You should not set your luceneMatchVersion to anything lower than your Solr ++# Version. ++solr.luceneMatchVersion=6.0 ++solr.pinkPony.timeAllowed=-1 ++# autoCommit after 10000 docs ++solr.autoCommit.MaxDocs=10000 ++# autoCommit after 2 minutes ++solr.autoCommit.MaxTime=120000 ++# autoSoftCommit after 2000 docs ++solr.autoSoftCommit.MaxDocs=2000 ++# autoSoftCommit after 10 seconds ++solr.autoSoftCommit.MaxTime=10000 ++solr.contrib.dir=../../../contrib +diff --git a/solr-conf/6.x/stopwords.txt b/solr-conf/6.x/stopwords.txt +new file mode 100644 +index 0000000..d7f243e +--- /dev/null ++++ b/solr-conf/6.x/stopwords.txt +@@ -0,0 +1,4 @@ ++# Contains words which shouldn't be indexed for fulltext fields, e.g., because ++# they're too common. For documentation of the format, see ++# http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters#solr.StopFilterFactory ++# (Lines starting with a pound character # are ignored.) +diff --git a/solr-conf/6.x/synonyms.txt b/solr-conf/6.x/synonyms.txt +new file mode 100644 +index 0000000..7d22eea +--- /dev/null ++++ b/solr-conf/6.x/synonyms.txt +@@ -0,0 +1,3 @@ ++# Contains synonyms to use for your index. For the format used, see ++# http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters#solr.SynonymFilterFactory ++# (Lines starting with a pound character # are ignored.) @@ -16,11 +16,14 @@ optdepends=( 'aegir: meta-Drupal hosting platform' 'solr-undertow: high performance servlet container for Solr') # The mapping-ISOLatin1Accent.txt file is identical in all occurrences in the Solr repo across the head of all its supported branches (3-5.x) -source=("https://raw.githubusercontent.com/apache/lucene-solr/branch_5x/solr/core/src/test-files/solr/collection1/conf/mapping-ISOLatin1Accent.txt" +source=("https://raw.githubusercontent.com/apache/lucene-solr/master/solr/example/example-DIH/solr/solr/ " + "https://www.drupal.org/files/issues/2711685-support-solr6-3.patch" + '0293cb23527acb1e8a307539a8d68021' + "https://www.drupal.org/files/issues/2711685-support-solr6-${_pkgname//_/-}-4.patch" "http://ftp.drupal.org/files/projects/$_pkgname-${_pkgvers[0]}.tar.gz" "http://ftp.drupal.org/files/projects/$_pkgname-${_pkgvers[1]}.tar.gz") -md5sums=('9f3c8a60a4f09327fad22aeff082c2b3' - '0293cb23527acb1e8a307539a8d68021' +md5sums=('f33510d7ab9f75bc8dc5e49d72acea2a' + '479dea32043f12575838eaa6de62f248' '40fccb08f08b0014ff884504ddb7616c') noextract=("${source[@]%%::*}") |