Solr调研总结(转)

开发类型

全文检索相关开发

Solr版本

4.2

文件内容

本文介绍solr的功能使用及相关注意事项;主要包括以下内容:环境搭建及调试、两个核心配置文件介绍、中文分词器配置、维护索引、查询索引,高亮显示、拼写检查、搜索建议、分组统计、自动聚类、相似匹配、拼音检索等功能的使用方法。

在代码文本框中如有显示不全的,请在文本框中按Ctrl+A再复制.

版本

作者/修改人

日期

V1.0

gzk

2013-06-04

属性名称

描述

Indexed

Indexed Field 可以进行搜索和排序。你还可以在 indexed Field 上运行 Solr
分析过程，此过程可修改内容以改进或更改结果。

Stored

stored Field
内容保存在索引中。这对于检索和醒目显示内容很有用，但对于实际搜索则不是必需的。例如，很多应用程序存储指向内容位置的指针而不是存储实际的文件内容。

<fieldType name="string"    
class="solr.StrField" sortMissingLast="true"/>

<fieldType name="boolean"    
class="solr.BoolField" sortMissingLast="true"/>

<fieldType name="int"    
class="solr.TrieIntField" precisionStep="0"    
positionIncrementGap="0"/>

<fieldType name="text_general"    
class="solr.TextField" positionIncrementGap="100">

<analyzer type="index">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter    
class="solr.StopFilterFactory" ignoreCase="true"    
words="stopwords.txt" enablePositionIncrements="true"    
/>

<filter    
class="solr.LowerCaseFilterFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter    
class="solr.StopFilterFactory" ignoreCase="true"    
words="stopwords.txt" enablePositionIncrements="true"    
/>

<filter    
class="solr.SynonymFilterFactory"    
synonyms="synonyms.txt" ignoreCase="true"    
expand="true"/>

<filter    
class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

属性

描述

name

标识而已

class

和其他属性决定了这个fieldType的实际行为。

sortMissingLast

设置成true没有该field的数据排在有该field的数据之后，而不管请求时的排序规则,
默认是设置成false。

sortMissingFirst

跟上面倒过来呗。 默认是设置成false

analyzer

字段类型指定的分词器

type

当前分词用用于的操作.index代表生成索引时使用的分词器query代码在查询时使用的分词器

tokenizer

分词器类

filter

分词后应用的过滤器 
过滤器调用顺序和配置相同.

<field name="id"     type="string"
indexed="true" stored="true"     required="true"
multiValued="false"/>

<field name="path"    
type="text_smartcn" indexed="false"     stored="true"
multiValued="false" termVector="true"     />

<field name="content"    
type="text_smartcn" indexed="false"     stored="true"
multiValued="false"     termVector="true"/>

<field name ="text" type     ="text_ik"
indexed ="true" stored ="false"     multiValued
="true"/>

<field name ="pinyin" type    
="text_pinyin" indexed ="true" stored     ="false"
multiValued ="false"/>

<field name="_version_"     type="long"
indexed="true" stored="true"/>

<dynamicField name="*_i"     type="int"
indexed="true" stored="true"/>

<dynamicField name="*_l"     type="long"
indexed="true" stored="true"/>

<dynamicField name="*_s"    
type="string" indexed="true" stored="true"     />

<copyField source="content"    
dest="pinyin"/>

<copyField source="content"    
dest="text"/>

<copyField source="pinyin"    
dest="text"/>

属性

描述

name

字段类型名

class

java类名

indexed

缺省true。
说明这个数据应被搜索和排序，如果数据没有indexed，则stored应是true。

stored

缺省true。说明这个字段被包含在搜索结果中是合适的。如果数据没有stored,则indexed应是true。

omitNorms

字段的长度不影响得分和在索引时不做boost时，设置它为true。

一般文本字段不设置为true。

termVectors

如果字段被用来做more like this
和highlight的特性时应设置为true。

compressed

字段是压缩的。这可能导致索引和搜索变慢，但会减少存储空间，只有StrField和TextField是可以压缩，这通常适合字段的长度超过200个字符。

multiValued

字段多于一个值的时候，可设置为true。

positionIncrementGap

和multiValued一起使用，设置多个值之间的虚拟空白的数量

属性

描述

useCompoundFile

通过将很多 Lucene 内部文件整合到一个文件来减少使用中的文件的数量。这可有助于减少   Solr
使用的文件句柄数目，代价是降低了性能。除非是应用程序用完了文件句柄，否则   false 的默认值应该就已经足够。

ramBufferSizeMB

在添加或删除文档时，为了减少频繁的更些索引,Solr会选缓存在内存中,当内存中的文件大于设置的值,才会更新到索引库。较大的值可使索引时间变快但会牺牲较多的内存。如两个值同时设置,满足一个就会进行刷新索引.

maxBufferedDocs

mergeFactor

决定低水平的 Lucene 段被合并的频率。较小的值（最小为
2）使用的内存较少但导致的索引时间也更慢。较大的值可使索引时间变快但会牺牲较多的内存。

maxIndexingThreads

indexWriter生成索引时使用的最大线程数

unlockOnStartup

unlockOnStartup 告知   Solr
忽略在多线程环境中用来保护索引的锁定机制。在某些情况下，索引可能会由于不正确的关机或其他错误而一直处于锁定，这就妨碍了添加和更新。将其设置为
  true 可以禁用启动锁定，进而允许进行添加和更新。

lockType

single: 在只读索引或是没有其它进程修改索引时使用.

native: 使用操作系统本地文件锁,不能使用多个Solr在同一个JVM中共享一个索引.

simple :使用一个文本文件锁定索引.

属性

描述

maxBooleanClauses

最大的BooleanQuery数量. 当值超出时，抛出  
TooManyClausesException.注意这个是全局的,如果是多个SolrCore都会使用一个值,每个Core里设置不一样的化,会使用最后一个的.

filterCache

filterCache存储了无序的lucene   document id集合，1.存储了filter  
queries(“fq”参数)得到的document   id集合结果。2还可用于facet查询3.
3）如果配置了useFilterForSortedQuery，那么如果查询有filter，则使用filterCache。

queryResultCache

缓存搜索结果,一个文档ID列表

documentCache

缓存Lucene的Document对象,不会自热

fieldValueCache

字段缓存使用文档ID进行快速访问。默认情况下创建fieldValueCache即使这里没有配置。

enableLazyFieldLoading

若应用程序预期只会检索 Document 上少数几个   Field，那么可以将属性设置为
true。延迟加载的一个常见场景大都发生在应用程序返回和显示一系列搜索结果的时候，用户常常会单击其中的一个来查看存储在此索引中的原始文档。初始的
显示常常只需要显示很短的一段信息。若考虑到检索大型 Document 的代价，除非必需，否则就应该避免加载整个文档。

queryResultWindowSize

一次查询中存储最多的doc的id数目.

queryResultMaxDocsCached

查询结果doc的最大缓存数量,
例如要求每页显示10条,这里设置是20条,也就是说缓存里总会给你多出10条的数据.让你点示下一页时很快拿到数据.

listener

选项定义   newSearcher 和   firstSearcher
事件，您可以使用这些事件来指定实例化新搜索程序或第一个搜索程序时应该执行哪些查询。如果应用程序期望请求某些特定的查询，那么在创建新搜索程序或第一
个搜索程序时就应该反注释这些部分并执行适当的查询。

useColdSearcher

是否使用冷搜索,为false时使用自热后的searcher

maxWarmingSearchers

最大自热searcher数量

<lib    
dir="../../../contrib/analysis-extras/lib"    
regex=".*\.jar" />

<fieldType name="text_smartcn"    
class="solr.TextField" positionIncrementGap="0">

<analyzer type="index">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

</analyzer>

</fieldType>

<field name ="text" type    
="text_smartcn" indexed ="true" stored     ="false"
multiValued ="true"/>

<fieldType name="text_ik"    
class="solr.TextField">

<analyzer    
class="org.wltea.analyzer.lucene.IKAnalyzer"/>

</fieldType>

<field name ="text" type     ="text_ik"
indexed ="true" stored ="false"     multiValued
="true"/>

System.setProperty("solr.solr.home",    
"E:\\Work\\solr-4.2.0-src\\solr\\example\\solr");

CoreContainer.Initializer initializer = new
    CoreContainer.Initializer();

CoreContainer      coreContainer =
initializer.initialize();

SolrServer      server = new
EmbeddedSolrServer(coreContainer, "");

SolrInputDocument doc = new SolrInputDocument();

doc.setField("id", "ABC");

doc.setField("content", "中华人民共和国");

server.add(doc);

server.commit();//这句一般不用加因为我们可以通过在配置文件中的

//autoCommit来提高性能

server.deleteById(id);

//或是使用批量删除

server.deleteById(ids);

server.deleteByQuery("*.*");//这样就删除了所有文档索引

//”*.*”就查询所有内容的,介绍查询时会详细说明.

server.optimize();//不要频繁的调用..尽量在无人使用时调用.

http://localhost:8983/solr/
   
collection1/select?q=*%3A*&wt=xml&indent=true

<?xml version="1.0"    
encoding="UTF-8"?>

<response>

<lst name="responseHeader">

<int    
name="status">0</int>

<int    
name="QTime">0</int>

<lst     name="params">

<str    
name="indent">true</str>

<str    
name="q">*:*</str>

<str    
name="wt">xml</str>

</lst>

</lst>

<result name="response"    
numFound="17971" start="0">

<doc>

<str    
name="path">E:\Reduced\军事\1539.txt</str>

<str    
name="category_s">2</str>

<int    
name="browseCount_i">-1423701734</int>

<long    
name="modified_l">1162438568000</long>

<long    
name="releasedate_l">1162438568000</long>

<str    
name="content">
[俄罗斯lenta网站2006年2月9日报道]俄空军副总司令比热耶夫中将称，2006年春天独联体国家防空系统打击范围向西推进150千米，侦察范围
向西推进400千米。　　2006年3月白俄罗斯4个S-300PS防空导弹营担负战斗任务，使独联体防空系统作战范围得以向西推进。比热耶夫中将还宣
布，近期乌兹别克斯坦可能加入独联体防空系统。　　独联体国家防空系统建于9年前，共有9个国家参加该组织。目前只有亚美尼亚、白俄罗斯、哈萨克斯坦、吉
尔吉斯、俄罗斯和塔吉克斯坦支持该体系。　　乌克兰、乌兹别克斯坦与俄罗斯在双边基础上合作，格鲁吉亚和土库曼最近7年不参加独联体国家对空防
御。</str>

<str    
name="id">E3798D82-EAB6-2BEA-D7E2-79FBD102E845</str>

<long    
name="_version_">1436361868021071872</long></doc>

…

</result>

</response>

SolrQuery query = new SolrQuery();

query.set("q","*.*");

QueryResponse rsp =server.query(query)

SolrDocumentList list = rsp.getResults();

for (int i = 0; i < list.size(); i++) {

SolrDocument sd =
list.get(i);

String id     = (String)
sd.getFieldValue("id");

System.out.println(id);

}

名称

描述

q

查询字符串，必须的。

fq

filter query。使用Filter Query可以充分利用Filter Query
Cache，提高检索性能。作用：在q查询符合结果中同时是fq查询符合的，例如：q=mm&fq=date_time:[20081001
  TO 20091031]，找关键字mm，并且date_time是20081001到20091031之间的。

fl

field list。指定返回结果字段。以空格“ ”或逗号“,”分隔。

start

用于分页定义结果起始记录数，默认为0。

rows

用于分页定义结果每页返回记录数，默认为10。

sort

排序，格式:sort=<field  
name>+<desc|asc>[,<field name>+<desc|asc>]…
。示例：（inStock desc, price asc）表示先 “inStock”   降序, 再 “price”
升序，默认是相关性降序。

df

默认的查询字段，一般默认指定。

q.op

覆盖schema.xml的defaultOperator（有空格时用"AND"还是用"OR"操作逻辑），一般默认指定。必须大写

wt

writer
type。指定查询输出结构格式，默认为“xml”。在solrconfig.xml中定义了查询输出格式：xml、json、python、ruby、php、phps、custom。

qt

query type，指定查询使用的Query Handler，默认为“standard”。

explainOther

设置当debugQuery=true时，显示其他的查询说明。

defType

设置查询解析器名称。

timeAllowed

设置查询超时时间。

omitHeader

设置是否忽略查询结果返回头信息，默认为“false”。

indent

返回的结果是否缩进，默认关闭，用   indent=true|on
开启，一般调试json,php,phps,ruby输出才有必要用这个参数。

version

查询语法的版本，建议不使用它，由服务器指定默认值。

debugQuery

设置返回结果是否显示Debug信息。

<?xml version="1.0" encoding="UTF-8"?>

<response>

<lst name="responseHeader">

  <int name="status">0</int>

  <int name="QTime">2</int>

  <lst name="params">

    <str name="fl">content path</str>

    <str name="indent">true</str>

    <str name="start">0</str>

    <str name="q">中国</str>

    <str name="hl.simple.pre"><em></str>

    <str name="hl.simple.post"></em></str>

    <str name="hl.fl">content</str>

    <str name="wt">xml</str>

    <str name="hl">true</str>

    <str name="rows">1</str>

  </lst>

</lst>

<result name="response" numFound="6799" start="0">

  <doc>

    <str name="path">E:\Reduced\IT\630.txt</str>

    <str name="content">　　本报讯 中国银联股份有限公司和中国电信集团日前在北京签署全面战略合作协议。这标志着中国银联和中国电信将在通信服务、信息增值服务、新型支付产品合作开发等领域建立全面合作伙伴关系。　　据悉，双方签署的全面战略合作协议主要内容是：中国银联将选择中国电信作为通信信息服务的主要提供商，双方围绕提高中国银联内部通信的水平和销售网络的服务水平开展全面、深入的合作；中国电信选择中国银联作为银行卡转接支付服务的主要提供商，并围绕开发、推广新型支付终端产品和增值服务开展全面合作。（辛华）</str></doc>

</result>

<lst name="highlighting">

  <lst name="7D919C61-03B3-4B6F-2D10-9E3CC92D2852">

    <arr name="content">

      <str>　　本报讯 <em>中国</em>银联股份有限公司和<em>中国</em>电信集团日前在北京签署全面战略合作协议。这标志着<em>中国</em>银联和<em>中国</em>电信将在通信服务、信息增值服务、新型支付产品合作开发等领域建立全面合作伙伴关系。　　据悉，双方签署</str>

    </arr>

  </lst>

</lst>

</response>

SolrQuery query = new SolrQuery();

query.set("q","*.*");

query.setHighlight(true); // 开启高亮组件

query.addHighlightField("content");//    
高亮字段

query.setHighlightSimplePre(PRE_TAG);// 标记

query.setHighlightSimplePost(POST_TAG);

QueryResponse rsp =server.query(query)

//…上面取结果的代码

//取出高亮结果

if (rsp.getHighlighting() != null) {

if    
(rsp.getHighlighting().get(id) != null) {//先通过结果中的ID到高亮集合中取出文档高亮信息

Map<String,
List<String>> map =    
rsp.getHighlighting().get(id);//取出高亮片段

if     (map.get(name) !=
null) {

for    
(String s : map.get(name)) {

System.out.println(s);

}

}

}

<searchComponent name="spellcheck" class="solr.SpellCheckComponent">

     <str name="queryAnalyzerFieldType">text_spell</str> 

     <lst name="spellchecker"> 

       <str name="name">direct</str> 

       <str name="field">spell</str> 

       <str name="classname">solr.DirectSolrSpellChecker</str> 

       <str name="distanceMeasure">internal</str> 

       <float name="accuracy">0.5</float> 

       <int name="maxEdits">2</int> 

       <int name="minPrefix">1</int> 

       <int name="maxInspections">5</int> 

       <int name="minQueryLength">2</int> 

       <float name="maxQueryFrequency">0.01</float> 

</lst> 

  </searchComponent> 

  <requestHandler name="/spell" class="solr.SearchHandler" startup="lazy"> 

     <lst name="defaults"> 

         <str name="spellcheck.dictionary">direct</str> 

          <str name="spellcheck">on</str>  

          <str name="spellcheck.collate">true</str> 

         <str name="spellcheck.collateExtendedResults">true</str>   

     </lst> 

     <arr name="last-components"> 

       <str>spellcheck</str> 

     </arr> 

   </requestHandler>

<?xml version="1.0" encoding="UTF-8"?>  

  <response>  

    <lst name="responseHeader">  

      <int name="status">0</int>  

      <int name="QTime">0</int>  

    </lst>  

    <result name="response" numFound="0" start="0"/>  

    <lst name="spellcheck">  

      <lst name="suggestions">  

        <lst name="beijink">  

          <int name="numFound">1</int>  

          <int name="startOffset">0</int>  

          <int name="endOffset">3</int>  

          <arr name="suggestion">  

            <str>beijing</str>  

          </arr>  

        </lst>  

      </lst>  

    </lst>  

  </response>

SolrQuery query = new SolrQuery();

query.set("q","*.*");

query.set("qt", "/spell");

QueryResponse rsp =server.query(query)

//…上面取结果的代码

SpellCheckResponse spellCheckResponse =    
rsp.getSpellCheckResponse();

if (spellCheckResponse != null) {

String     collation =
spellCheckResponse.getCollatedResult();

}

<searchComponent     
name="suggest"     class="solr.SpellCheckComponent">

<str    
name="queryAnalyzerFieldType">string</str>

<lst    
name="spellchecker">

<str name="name">suggest</str>

<str    
name="classname">org.apache.solr.spelling.suggest.Suggester</str>

<str
name="lookupImpl">org.apache.solr.spelling.suggest.tst.TSTLookup</str>

<str name="field">text</str>

<float name="threshold">0.0001</float>

<str    
name="spellcheckIndexDir">spellchecker</str>

<str name="comparatorClass">freq</str>

<str name="buildOnOptimize">true</str>

<!--<str    
name="buildOnCommit">true</str>-->

</lst>

</searchComponent>

<requestHandler     
name="/suggest" class="solr.SearchHandler"    
startup="lazy">

<lst    
name="defaults">

<str name="spellcheck">true</str>

<str
name="spellcheck.dictionary">suggest</str>

<str    
name="spellcheck.onlyMorePopular">true</str>

<str    
name="spellcheck.extendedResults">false</str>

<str name="spellcheck.count">10</str>

<str
name="spellcheck.collate">true</str>

</lst>

<arr    
name="components">

<str>suggest</str>

</arr>

</requestHandler>

<?xml version="1.0" encoding="UTF-8"?>

<response>

<lst name="responseHeader">

  <int name="status">0</int>

  <int name="QTime">4</int>

</lst>

<lst name="spellcheck">

  <lst name="suggestions">

    <lst name="中国">

      <int name="numFound">4</int>

      <int name="startOffset">0</int>

      <int name="endOffset">2</int>

      <arr name="suggestion">

        <str>中国队</str>

        <str>中国证监会</str>

        <str>中国足协</str>

        <str>中国银行</str>

      </arr>

    </lst>

  </lst>

</lst>

</response>

SolrQuery query = new SolrQuery();

query.set("q", token);

query.set("qt", "/suggest");

query.set("spellcheck.count",    
"10");

QueryResponse response = server.query(query);

SpellCheckResponse spellCheckResponse =    
response.getSpellCheckResponse();

if (spellCheckResponse != null) {

List<SpellCheckResponse.Suggestion> suggestionList =
    spellCheckResponse.getSuggestions();

for (SpellCheckResponse.Suggestion
    suggestion : suggestionList) {

List<String> suggestedWordList = suggestion.getAlternatives();

for (int     i =
0; i < suggestedWordList.size(); i++) {

String
    word = suggestedWordList.get(i);

}

}

return results;

}

<types>

<fieldType
    name="string" class="solr.StrField"    
omitNorms="true"/>

<fieldType
    name="tokened" class="solr.TextField" >

<analyzer>

……

</analyzer>

</fieldType>

</types>

<fields>

<field name="cpu"
    type="string" indexed="true"    
stored="false"/>

<field
name="cpuCopy”     type=" tokened" indexed="true"
    stored="true"/>

</fields>

<copyField     source="cpu" dest="cpuCopy"/>

<requestHandler     name="standard"
class="solr.SearchHandler"     default="true">

……

<arr     name="components">

<str>自定义组件名</str>

<str>facet</str>

……

</arr>

</requestHandler>

<?xml version="1.0" encoding="UTF-8"?>

<response>

<lst name="responseHeader">

  <int name="status">0</int>

  <int name="QTime">1</int>

  <lst name="params">

    <str name="facet">true</str>

    <str name="indent">true</str>

    <str name="start">0</str>

    <str name="q">*:*</str>

<arr name="facet.field"> 

   <str>category_s</str> 

   <str>modified_l</str> 

</arr>

    <str name="wt">xml</str>

    <str name="rows">0</str>

  </lst>

</lst>

<result name="response" numFound="17971" start="0">

</result>

<lst name="facet_counts">

  <lst name="facet_queries"/>

  <lst name="facet_fields">

    <lst name="category_s">

      <int name="0">5991</int>

      <int name="1">5990</int>

      <int name="2">5990</int>

</lst>

    <lst name="modified_l">

      <int name="1162438554000">951</int>

      <int name="1162438556000">917</int>

      <int name="1162438548000">902</int>

      <int name="1162438546000">674</int>

    </lst>

  </lst>

  <lst name="facet_dates"/>

  <lst name="facet_ranges"/>

</lst>

</response>

f.字段名.参数名=参数值

f.cpu.facet.prefix=Intel

&facet=on

&facet.date=date

&facet.date.start=2009-1-1T0:0:0Z

&facet.date.end=2010-1-1T0:0:0Z

&facet.date.gap=%2B1MONTH

&facet.date.other=all

<lst     name="facet_counts">

<lst    
name="facet_queries"/>

<lst    
name="facet_fields"/>

<lst    
name="facet_dates">

<int    
name="2009-01-01T00:00:00Z">5</int>

<int name="2009-02-01T00:00:00Z">7</int>

<int name="2009-03-01T00:00:00Z">4</int>

<int name="2009-04-01T00:00:00Z">3</int>

<int name="2009-05-01T00:00:00Z">7</int>

<int name="2009-06-01T00:00:00Z">3</int>

<int name="2009-07-01T00:00:00Z">6</int>

<int name="2009-08-01T00:00:00Z">7</int>

<int name="2009-09-01T00:00:00Z">2</int>

<int name="2009-10-01T00:00:00Z">4</int>

<int name="2009-11-01T00:00:00Z">1</int>

<int name="2009-12-01T00:00:00Z">5</int>

<str name="gap">+1MONTH</str>

<date name="end">2010-01-01T00:00:00Z</date>

<int name="before">180</int>

<int name="after">5</int>

<int name="between">54</int>

</lst>

</lst>

&facet=on

&facet.query=date:[2009-1-1T0:0:0Z     TO
2009-2-1T0:0:0Z]

&facet.query=date:[2009-4-1T0:0:0Z     TO
2009-5-1T0:0:0Z]

<lst     name="facet_counts">

<lst    
name="facet_queries">

<int     name="date:[2009-1-1T0:0:0Z TO
2009-2-1T0:0:0Z]">5</int>

<int name="date:[2009-4-1T0:0:0Z TO
2009-5-1T0:0:0Z]">3</int>

</lst>

<lst    
name="facet_fields"/>

<lst    
name="facet_dates"/>

</lst>

&facet=on

&facet.query=date:[2009-1-1T0:0:0Z     TO
2009-2-1T0:0:0Z]

&facet.query=price:[* TO 5000]

<lst     name="facet_counts">

<lst    
name="facet_queries">

<int     name="date:[2009-1-1T0:0:0Z TO
2009-2-1T0:0:0Z]">5</int>

<int name="price:[* TO 5000]">116</int>

</lst>

<lst    
name="facet_fields"/>

<lst    
name="facet_dates"/>

</lst>

&facet=on

&facet.query=cpu:[A TO G]

<lst name="facet_counts">

<lst    
name="facet_queries">

<int     name="cpu:[A TO G]">11</int>

</lst>

<lst    
name="facet_fields"/>

<lst    
name="facet_dates"/>

</lst>

&facet=on

&facet.field={!key=中央处理器}cpu

&facet.field={!key=显卡}videoCard

<lst     name="facet_counts">

<lst    
name="facet_queries"/>

<lst    
name="facet_fields">

<lst     name="中央处理器">

<int     name="Intel 酷睿2双核    
T6600">48</int>

<int     name="Intel 奔腾双核 T4300">28</int>

<int name="Intel 酷睿2双核    
P8700">18</int>

<int name="Intel 酷睿2双核    
T6570">11</int>

<int name="Intel 酷睿2双核    
T6670">11</int>

<int name="Intel 奔腾双核 T4400">9</int>

<int name="Intel 酷睿2双核    
P7450">9</int>

<int name="Intel 酷睿2双核    
T5870">8</int>

<int name="Intel 赛扬双核 T3000">7</int>

<int name="Intel 奔腾双核 SU4100">6</int>

<int name="Intel 酷睿2双核    
P8400">6</int>

<int name="Intel 酷睿2双核    
SU7300">5</int>

<int name="Intel 酷睿 i3 330M">4</int>

</lst>

<lst     name="显卡">

<int     name="ATI Mobility Radeon HD
4">63</int>

<int     name="NVIDIA GeForce G
105M">24</int>

<int name="NVIDIA GeForce GT    
240M">21</int>

<int name="NVIDIA GeForce G 103M">8</int>

<int name="NVIDIA GeForce GT 220M">8</int>

<int name="NVIDIA GeForce 9400M G">7</int>

<int name="NVIDIA GeForce G 210M">6</int>

</lst>

</lst>

<lst    
name="facet_dates"/>

</lst>

&fq=screenSize:14

&facet=on

&facet.field=screenSize

<lst     name="facet_counts">

<lst    
name="facet_queries"/>

<lst    
name="facet_fields">

<lst     name=" screenSize">

<int     name="14.0">107</int>

<int name="10.2">0</int>

<int name="11.1">0</int>

<int name="11.6">0</int>

<int name="12.1">0</int>

<int name="13.1">0</int>

<int name="13.3">0</int>

<int name="14.1">0</int>

<int name="15.4">0</int>

<int name="15.5">0</int>

<int name="15.6">0</int>

<int name="16.0">0</int>

<int name="17.0">0</int>

<int name="17.3">0</int>

</lst>

</lst>

<lst    
name="facet_dates"/>

</lst>

&fq={!tag=aa}screenSize:14

&facet=on

&facet.field={!ex=aa}screenSize

<lst     name="facet_counts">

<lst    
name="facet_queries"/>

<lst    
name="facet_fields">

<lst     name=" screenSize">

<int     name="14.0">107</int>

<int name="14.1">40</int>

<int name="13.3">34</int>

<int name="15.6">22</int>

<int name="15.4">8</int>

<int name="11.6">6</int>

<int name="12.1">5</int>

<int name="16.0">5</int>

<int name="15.5">3</int>

<int name="17.0">3</int>

<int name="17.3">3</int>

<int name="10.2">1</int>

<int name="11.1">1</int>

<int name="13.1">1</int>

</lst>

</lst>

<lst    
name="facet_dates"/>

</lst>

//初始化查询对象

String q = “*.*”;

SolrQuery query = new     SolrQuery(q);

query.setIncludeScore(false);//是否按每组数量高低排序

query.setFacet(true);//是否分组查询

query.setRows(0);//设置返回结果条数，如果你时分组查询，你就设置为0

query.addFacetField(“modified_l”);//增加分组字段   q

query.addFacetQuery (“category_s[0     TO 1]”);

QueryResponse rsp =     server.query(query);

…

//取出结果

List<FacetField.Count> list =
rsp.getFacetField(“modified_l”).getValues();

Map<String, Integer> list = rsp.getFacetQuery();

<searchComponent name="clustering"

enable="${solr.clustering.enabled:true}"

class="solr.clustering.ClusteringComponent" >

<lst
name="engine">

<str name="name">default</str>

<str
name="carrot.algorithm">org.carrot2.clustering.lingo.LingoClusteringAlgorithm</str>

<str    
name="LingoClusteringAlgorithm.desiredClusterCountBase">30</str><!--2~100-->

<str
   
name="LingoClusteringAlgorithm.clusterMergingThreshold">0.70</str><!--0~1-->

<str
name="LingoClusteringAlgorithm.scoreWeight">0</str><!--0~1-->

<str
   
name="LingoClusteringAlgorithm.labelAssigner">org.carrot2.clustering.lingo.SimpleLabelAssigner</str><!--org.carrot2.clustering.lingo.UniqueLabelAssigner
    -->

<str
   
name="LingoClusteringAlgorithm.phraseLabelBoost">1.5</str><!--0~10-->

<str
   
name="LingoClusteringAlgorithm.phraseLengthPenaltyStart">8</str><!--2~8-->

<str
   
name="LingoClusteringAlgorithm.phraseLengthPenaltyStop">8</str><!--2~8-->

<str
   
name="TermDocumentMatrixReducer.factorizationQuality">HIGH</str><!--LOW,MEDIUM,HIGH-->

<!--

org.carrot2.matrix.factorization.PartialSingularValueDecompositionFactory

org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationEDFactory

org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationKLFactory

org.carrot2.matrix.factorization.LocalNonnegativeMatrixFactorizationFactory

org.carrot2.matrix.factorization.KMeansMatrixFactorizationFactory

-->

<str
   
name="TermDocumentMatrixReducer.factorizationFactory">org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationEDFactory</str>

<str
   
name="TermDocumentMatrixBuilder.maximumMatrixSize">37500</str><!--MinValue5000-->

<str
   
name="TermDocumentMatrixBuilder.titleWordsBoost">2.0</str><!--2~10-->

<str
   
name="TermDocumentMatrixBuilder.maxWordDf">0.9</str><!--0~1-->

<!--org.carrot2.text.vsm.LogTfIdfTermWeighting,org.carrot2.text.vsm.LinearTfIdfTermWeighting-->

<str
   
name="TermDocumentMatrixBuilder.termWeighting">org.carrot2.text.vsm.TfTermWeighting</str>

<str
   
name="MultilingualClustering.defaultLanguage">CHINESE_SIMPLIFIED</str>

<str
   
name="MultilingualClustering.languageAggregationStrategy">org.carrot2.text.clustering.MultilingualClustering.LanguageAggregationStrategy.FLATTEN_MAJOR_LANGUAGE
    </str><!--FLATTEN_ALL,FLATTEN_NONE-->

<str
   
name="GenitiveLabelFilter.enabled">true</str>

<str
   
name="StopWordLabelFilter.enabled">true</str>

<str
   
name="NumericLabelFilter.enabled">true</str>

<str
    name="QueryLabelFilter.enabled">true</str>

<str
   
name="MinLengthLabelFilter.enabled">true</str>

<str
    name="StopLabelFilter.enabled">true</str>

<str
   
name="CompleteLabelFilter.enabled">true</str>

<str
   
name="CompleteLabelFilter.labelOverrideThreshold">0.65</str><!--0~1-->

<str
   
name="DocumentAssigner.exactPhraseAssignment">false</str>

<str
   
name="DocumentAssigner.minClusterSize">2</str><!--1~100-->

<str
    name="merge-resources">true</str>

<str
   
name="CaseNormalizer.dfThreshold">1</str><!--1~100-->

<str
   
name="PhraseExtractor.dfThreshold">1</str><!--1~100-->

<str
   
name="carrot.lexicalResourcesDir">clustering/carrot2</str>

<str
   
name="SolrDocumentSource.solrIdFieldName">id</str>

</lst>

</searchComponent>

<requestHandler    
name="/clustering"

startup="lazy"

enable="${solr.clustering.enabled:true}"

class="solr.SearchHandler">

<lst    
name="defaults">

<str    
name="echoParams">explicit</str>

<bool    
name="clustering">true</bool>

<str    
name="clustering.engine">default</str>

<bool    
name="clustering.results">true</bool>

<str    
name="carrot.title">category_s</str>

<str    
name="carrot.snippet">content</str>

<str    
name="carrot.url">path</str>

<str    
name="carrot.produceSummary">true</str>

</lst>

<arr name="last-components">

<str>clustering</str>

</arr>

</requestHandler>

参数

　说明

　　值域

mlt

在查询时，打开/关闭 MoreLikeThisComponent 的布尔值。

true|false

mlt.count

可选。每一个结果要检索的相似文档数。 　　　　　　　　　

> 0

mlt.fl　　

用于创建 MLT 查询的字段。 　　　　　　　　　　　　　　

任何被储存的或含有检索词向量的字段。

mlt.maxqt

可选。查询词语的最大数量。由于长文档可能会有很多关键词语，这样 MLT 查询可能会很大，从而导致反应缓慢或可怕的
  TooManyClausesException，该参数只保留关键的词语。

> 0

<requestHandler     name="/mlt"
class="solr.MoreLikeThisHandler"> 
   
</requestHandler>

<field     name="content"
type="text_smartcn"     indexed="false" stored="true"
    multiValued="false" termVector="true"/>

SolrQuery  query     = new
SolrQuery();

query.set("qt", "/mlt");

query.set("mlt.fl","content");

query.set("fl", "id,");

query.set("q", "id:
6F398CCD-2DE0-D3B1-9DD6-D4E532FFC531");

query.setStart(0);

query.setRows(5);

QueryResponse      rsp =
server.query(query);

SolrDocumentList list = rsp.getResults();

<fieldType name="text_pinyin"    
class="solr.TextField" positionIncrementGap="0">

<analyzer
type="index">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

<filter
   
class="com.shentong.search.analyzers.PinyinTransformTokenFilterFactory"
    minTermLenght="2" />

<filter    
class="com.shentong.search.analyzers.PinyinNGramTokenFilterFactory"
    minGram="1" maxGram="20" />

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.WhitespaceTokenizerFactory"/>

<filter
class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

<field name     ="pinyin" type
="text_pinyin" indexed ="true"     stored ="false"
multiValued ="false"/>

<copyField source="content" dest="pinyin"/>

<copyField source="text" dest="spell"/>

<?xml version="1.0"     encoding="UTF-8"
?>

<schema name="example"    
version="1.5">

<fields>

<field name="id"
type="string"     indexed="true" stored="true"
required="true"     multiValued="false"/>

<field
name="path" type="text_ik"     indexed="false"
stored="true"     multiValued="false" 
    termVector="true" />

<field
name="content" type="text_ik" indexed="false"    
stored="true" multiValued="false"    
termVector="true"/>

<field name
="text" type ="text_ik" indexed     ="true" stored ="false"
multiValued     ="true"/>

<field
    name ="pinyin" type ="text_pinyin" indexed
    ="true" stored ="false" multiValued    
="false"/>

<field
    name ="py" type ="text_py" indexed ="true"
    stored ="false" multiValued ="false"/>

<field
    name="spell" type="text_spell" indexed="true"
    stored="false" multiValued="false"    
termVector="true"/>

<field
    name="_version_" type="long" indexed="true"
    stored="true"/>

<dynamicField
name="*_i" type="int"     indexed="true"
stored="true"/>

<dynamicField
name="*_is" type="int"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField     name="*_s" type="string"
indexed="true"     stored="true" />

<dynamicField
name="*_ss" type="string"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField
name="*_l" type="long"     indexed="true"
stored="true"/>

<dynamicField
name="*_ls" type="long"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField
name="*_t" type="text_general"     indexed="true"
stored="true"/>

<dynamicField
name="*_txt"     type="text_general" indexed="true"
    stored="true" multiValued="true"/>

<dynamicField
name="*_en" type="text_en"     indexed="true" stored="true"
multiValued="true"/>

<dynamicField
name="*_b" type="boolean"     indexed="true"
stored="true"/>

<dynamicField
name="*_bs" type="boolean"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField
name="*_f" type="float"     indexed="true"
stored="true"/>

<dynamicField
name="*_fs" type="float"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField
name="*_d" type="double"     indexed="true"
stored="true"/>

<dynamicField
name="*_ds" type="double"     indexed="true" stored="true"
    multiValued="true"/>

<!-- Type used to
index the lat and lon components for the     "location"
FieldType -->

<dynamicField
name="*_coordinate"     type="tdouble" indexed="true"
    stored="false"/>

<dynamicField
name="*_dt" type="date"     indexed="true"
stored="true"/>

<dynamicField
name="*_dts" type="date"     indexed="true" stored="true"
    multiValued="true"/>

<dynamicField
name="*_p" type="location"     indexed="true"
stored="true"/>

<!-- some
trie-coded dynamic fields for faster range queries    
-->

<dynamicField
name="*_ti" type="tint"     indexed="true"
stored="true"/>

<dynamicField
name="*_tl" type="tlong"     indexed="true"
stored="true"/>

<dynamicField
name="*_tf" type="tfloat"     indexed="true"
stored="true"/>

<dynamicField
name="*_td" type="tdouble"     indexed="true"
stored="true"/>

<dynamicField
name="*_tdt" type="tdate"     indexed="true"
stored="true"/>

<dynamicField
name="*_pi" type="pint"     indexed="true"
stored="true"/>

<dynamicField
name="*_c" type="currency"     indexed="true"
stored="true"/>

<dynamicField
name="ignored_*" type="ignored"    
multiValued="true"/>

<dynamicField
name="attr_*"     type="text_general" indexed="true"
    stored="true" multiValued="true"/>

<dynamicField
name="random_*"     type="random"/>

</fields>

<uniqueKey>id</uniqueKey>

<copyField source="content"    
dest="spell"/>

<copyField source="content"    
dest="pinyin"/>

<copyField source="content"    
dest="py"/>

<copyField source="path"
dest="text"/>

<copyField source="content"
dest="text"/>

<copyField source="pinyin"
dest="text"/>

<copyField source="py"
dest="text"/>

<defaultSearchField>text</defaultSearchField>

<types>

<fieldType
name="string"     class="solr.StrField"
sortMissingLast="true"/>

<fieldType
name="boolean" class="solr.BoolField"    
sortMissingLast="true"/>

<fieldType
name="int"     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"/>

<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"/>

<fieldType
name="date"     class="solr.TrieDateField"
precisionStep="0"     positionIncrementGap="0"/>

<fieldType
name="tdate"     class="solr.TrieDateField"
precisionStep="6"     positionIncrementGap="0"/>

<fieldtype
name="binary"     class="solr.BinaryField"/>

<fieldType
name="pint"     class="solr.IntField"/>

<fieldType
name="plong"     class="solr.LongField"/>

<fieldType
name="pfloat"     class="solr.FloatField"/>

<fieldType
name="pdouble"     class="solr.DoubleField"/>

<fieldType
name="pdate"     class="solr.DateField"
sortMissingLast="true"/>

<fieldType
name="random"     class="solr.RandomSortField"
indexed="true"/>

<fieldType
name="text_ws"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.WhitespaceTokenizerFactory"/>

</analyzer>

</fieldType>

<fieldType     name="text_general"
class="solr.TextField"    
positionIncrementGap="100">

<analyzer type="index">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="stopwords.txt"
    enablePositionIncrements="true" />

<filter    
class="solr.LowerCaseFilterFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="stopwords.txt"
    enablePositionIncrements="true" />

<filter class="solr.SynonymFilterFactory"
    synonyms="synonyms.txt" ignoreCase="true"
    expand="true"/>

<filter class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

<fieldType     name="text_spell" class="solr.TextField"
>

<analyzer    
class="org.wltea.analyzer.lucene.IKAnalyzer"/>

</fieldType>

<fieldType     name="text_ik" class="solr.TextField">

<analyzer    
class="org.wltea.analyzer.lucene.IKAnalyzer"/>

</fieldType>

<fieldType
name="text_smartcn"     class="solr.TextField"
positionIncrementGap="0">

<analyzer type="index">

<tokenizer
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

</analyzer>

</fieldType>

<fieldType     name="text_pinyin" class="solr.TextField"
    positionIncrementGap="0">

<analyzer type="index">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

<filter
class="com.shentong.search.analyzers.PinyinTransformTokenFilterFactory"
    minTermLenght="2" />

<filter    
class="com.shentong.search.analyzers.PinyinNGramTokenFilterFactory"
    minGram="1" maxGram="20" />

</analyzer>

<analyzer type="query">

<tokenizer
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

<filter    
class="com.shentong.search.analyzers.PinyinTransformTokenFilterFactory"
    minTermLenght="2" />

<filter    
class="com.shentong.search.analyzers.PinyinNGramTokenFilterFactory"
    minGram="1" maxGram="20" />

</analyzer>

</fieldType>

<fieldType     name="text_py" class="solr.TextField"
    positionIncrementGap="0">

<analyzer type="index">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

<filter
class="com.shentong.search.analyzers.PinyinTransformTokenFilterFactory"
    isFirstChar="true" minTermLenght="2" />

</analyzer>

<analyzer type="query">

<tokenizer    
class="org.apache.lucene.analysis.cn.smart.SmartChineseSentenceTokenizerFactory"/>

<filter    
class="org.apache.lucene.analysis.cn.smart.SmartChineseWordTokenFilterFactory"/>

<filter    
class="com.shentong.search.analyzers.PinyinTransformTokenFilterFactory"
    isFirstChar="true" minTermLenght="2" />

</analyzer>

</fieldType>

<fieldType
name="text_en"     class="solr.TextField"
positionIncrementGap="100">

<analyzer type="index">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- 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.

add enablePositionIncrements=true in both the index and
query

analyzers to leave a ‘gap‘ for more accurate phrase
queries.

-->

<filter class="solr.StopFilterFactory"

ignoreCase="true"

words="lang/stopwords_en.txt"

enablePositionIncrements="true"

/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter    
class="solr.EnglishPossessiveFilterFactory"/>

<filter class="solr.KeywordMarkerFilterFactory"
    protected="protwords.txt"/>

<!-- Optionally you may want to use this less
aggressive stemmer instead     of
PorterStemFilterFactory:

<filter    
class="solr.EnglishMinimalStemFilterFactory"/>

-->

<filter
class="solr.PorterStemFilterFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.SynonymFilterFactory"
    synonyms="synonyms.txt" ignoreCase="true"
    expand="true"/>

<filter class="solr.StopFilterFactory"

ignoreCase="true"

words="lang/stopwords_en.txt"

enablePositionIncrements="true"

/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter    
class="solr.EnglishPossessiveFilterFactory"/>

<filter class="solr.KeywordMarkerFilterFactory"
    protected="protwords.txt"/>

<!-- Optionally you may want to use this less
aggressive stemmer     instead of
PorterStemFilterFactory:

<filter    
class="solr.EnglishMinimalStemFilterFactory"/>

-->

<filter
class="solr.PorterStemFilterFactory"/>

</analyzer>

</fieldType>

<fieldType
name="text_en_splitting"     class="solr.TextField"
positionIncrementGap="100"

autoGeneratePhraseQueries="true">

<analyzer type="index">

<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.

add enablePositionIncrements=true in both the index and
query

analyzers to leave a ‘gap‘ for more accurate phrase
queries.

-->

<filter class="solr.StopFilterFactory"

ignoreCase="true"

words="lang/stopwords_en.txt"

enablePositionIncrements="true"

/>

<filter class="solr.WordDelimiterFilterFactory"
    generateWordParts="1" generateNumberParts="1"
    catenateWords="1"

catenateNumbers="1"     catenateAll="0"
splitOnCaseChange="1"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.KeywordMarkerFilterFactory"
    protected="protwords.txt"/>

<filter
class="solr.PorterStemFilterFactory"/>

</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="lang/stopwords_en.txt"

enablePositionIncrements="true"

/>

<filter class="solr.WordDelimiterFilterFactory"
    generateWordParts="1" generateNumberParts="1"
catenateWords="0"

catenateNumbers="0" catenateAll="0"    
splitOnCaseChange="1"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.KeywordMarkerFilterFactory"
    protected="protwords.txt"/>

<filter
class="solr.PorterStemFilterFactory"/>

</analyzer>

</fieldType>

<fieldType
name="text_en_splitting_tight"     class="solr.TextField"
positionIncrementGap="100"

autoGeneratePhraseQueries="true">

<analyzer>

<tokenizer
class="solr.WhitespaceTokenizerFactory"/>

<filter class="solr.SynonymFilterFactory"
    synonyms="synonyms.txt" ignoreCase="true"
    expand="false"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true"
words="lang/stopwords_en.txt"/>

<filter class="solr.WordDelimiterFilterFactory"
    generateWordParts="0" generateNumberParts="0"
    catenateWords="1"

catenateNumbers="1" catenateAll="0"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.KeywordMarkerFilterFactory"
    protected="protwords.txt"/>

<filter    
class="solr.EnglishMinimalStemFilterFactory"/>

<!-- this filter can remove any duplicate tokens
that appear at     the same position - sometimes

possible with WordDelimiterFilter     in conjuncton with
stemming. -->

<filter    
class="solr.RemoveDuplicatesTokenFilterFactory"/>

</analyzer>

</fieldType>

<fieldType
name="text_general_rev"     class="solr.TextField"
positionIncrementGap="100">

<analyzer type="index">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="stopwords.txt"
    enablePositionIncrements="true"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.ReversedWildcardFilterFactory"
    withOriginal="true"

maxPosAsterisk="3" maxPosQuestion="2"
    maxFractionAsterisk="0.33"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.SynonymFilterFactory"
    synonyms="synonyms.txt" ignoreCase="true"
    expand="true"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="stopwords.txt"
    enablePositionIncrements="true"/>

<filter class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

<fieldType
name="alphaOnlySort"     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     references to portions of the
original

string matched by
the     pattern.

See the Java Regular     Expression documentation for
more

information on pattern and     replacement string
syntax.

http://java.sun.com/j2se/1.6.0/docs/api/java/util/regex/package-summary.html

-->

<filter class="solr.PatternReplaceFilterFactory"

pattern="([^a-z])" replacement=""    
replace="all"

/>

</analyzer>

</fieldType>

<fieldtype
name="phonetic" stored="false"     indexed="true"
class="solr.TextField">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.DoubleMetaphoneFilterFactory"
    inject="false"/>

</analyzer>

</fieldtype>

<fieldtype
name="payloads" stored="false"     indexed="true"
class="solr.TextField">

<analyzer>

<tokenizer
class="solr.WhitespaceTokenizerFactory"/>

<!--

The DelimitedPayloadTokenFilter can put payloads on
tokens... for     example,

a token of "foo|1.4"      would be
indexed as "foo" with a payload of 1.4f

Attributes of the DelimitedPayloadTokenFilterFactory :

"delimiter" - a one character delimiter. Default is |
    (pipe)

"encoder" - how to encode the     following value
into a playload

float ->    
org.apache.lucene.analysis.payloads.FloatEncoder,

integer -> o.a.l.a.p.IntegerEncoder

identity ->    
o.a.l.a.p.IdentityEncoder

Fully Qualified class name     implementing PayloadEncoder,
Encoder must have a no arg constructor.

-->

<filter
class="solr.DelimitedPayloadTokenFilterFactory"    
encoder="float"/>

</analyzer>

</fieldtype>

<fieldType
name="lowercase"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.KeywordTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

<fieldType
name="descendent_path"     class="solr.TextField">

<analyzer type="index">

<tokenizer
class="solr.PathHierarchyTokenizerFactory"    
delimiter="/"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.KeywordTokenizerFactory"/>

</analyzer>

</fieldType>

<fieldType
name="ancestor_path"     class="solr.TextField">

<analyzer type="index">

<tokenizer
class="solr.KeywordTokenizerFactory"/>

</analyzer>

<analyzer type="query">

<tokenizer
class="solr.PathHierarchyTokenizerFactory"    
delimiter="/"/>

</analyzer>

</fieldType>

<fieldtype
name="ignored" stored="false"     indexed="false"
multiValued="true"     class="solr.StrField"/>

<fieldType
name="point"     class="solr.PointType" dimension="2"
    subFieldSuffix="_d"/>

<fieldType
name="location"     class="solr.LatLonType"
    subFieldSuffix="_coordinate"/>

<fieldType
name="location_rpt"    
class="solr.SpatialRecursivePrefixTreeFieldType"

geo="true"
    distErrPct="0.025" maxDistErr="0.000009"
    units="degrees"/>

<fieldType
name="currency"     class="solr.CurrencyField"
precisionStep="8"     defaultCurrency="USD"

currencyConfig="currency.xml"/>

<!-- some
examples for different languages (generally ordered by    
ISO code) -->

<!-- Arabic
-->

<fieldType
name="text_ar"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- for any non-arabic -->

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ar.txt"

enablePositionIncrements="true"/>

<!-- normalizes ? to ?, etc -->

<filter
    class="solr.ArabicNormalizationFilterFactory"/>

<filter
class="solr.ArabicStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Bulgarian
-->

<fieldType
name="text_bg"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_bg.txt"

enablePositionIncrements="true"/>

<filter
class="solr.BulgarianStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Catalan
-->

<fieldType
name="text_ca"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- removes l‘, etc -->

<filter class="solr.ElisionFilterFactory"
    ignoreCase="true"    
articles="lang/contractions_ca.txt"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ca.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Catalan"/>

</analyzer>

</fieldType>

<!-- CJK bigram
(see text_ja for a Japanese configuration using    
morphological analysis) -->

<fieldType
name="text_cjk"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- normalize width before bigram, as e.g.
half-width dakuten     combine  -->

<filter class="solr.CJKWidthFilterFactory"/>

<!-- for any non-CJK -->

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.CJKBigramFilterFactory"/>

</analyzer>

</fieldType>

<!-- Czech
-->

<fieldType
name="text_cz"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_cz.txt"

enablePositionIncrements="true"/>

<filter class="solr.CzechStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Danish
-->

<fieldType
name="text_da"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_da.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Danish"/>

</analyzer>

</fieldType>

<!-- German
-->

<fieldType
name="text_de"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_de.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter
class="solr.GermanNormalizationFilterFactory"/>

<filter
class="solr.GermanLightStemFilterFactory"/>

<!-- less aggressive: <filter    
class="solr.GermanMinimalStemFilterFactory"/> -->

<!-- more aggressive: <filter    
class="solr.SnowballPorterFilterFactory" language="German2"/>
    -->

</analyzer>

</fieldType>

<!-- Greek
-->

<fieldType
name="text_el"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- greek specific lowercase for sigma -->

<filter
class="solr.GreekLowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="false" words="lang/stopwords_el.txt"

enablePositionIncrements="true"/>

<filter class="solr.GreekStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Spanish
-->

<fieldType
name="text_es"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_es.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter
class="solr.SpanishLightStemFilterFactory"/>

<!-- more aggressive: <filter    
class="solr.SnowballPorterFilterFactory"    
language="Spanish"/> -->

</analyzer>

</fieldType>

<!-- Basque
-->

<fieldType
name="text_eu"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_eu.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Basque"/>

</analyzer>

</fieldType>

<!-- Persian
-->

<fieldType
name="text_fa"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<!-- for ZWNJ -->

<charFilter
class="solr.PersianCharFilterFactory"/>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter    
class="solr.ArabicNormalizationFilterFactory"/>

<filter    
class="solr.PersianNormalizationFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_fa.txt"

enablePositionIncrements="true"/>

</analyzer>

</fieldType>

<!-- Finnish
-->

<fieldType
name="text_fi"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_fi.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Finnish"/>

<!-- less aggressive: <filter
class="solr.FinnishLightStemFilterFactory"/>    
-->

</analyzer>

</fieldType>

<!-- French
-->

<fieldType
name="text_fr"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- removes l‘, etc     -->

<filter class="solr.ElisionFilterFactory"
    ignoreCase="true"    
articles="lang/contractions_fr.txt"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_fr.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter
class="solr.FrenchLightStemFilterFactory"/>

<!-- less aggressive: <filter    
class="solr.FrenchMinimalStemFilterFactory"/> -->

<!-- more aggressive: <filter    
class="solr.SnowballPorterFilterFactory"    
language="French"/> -->

</analyzer>

</fieldType>

<!-- Irish
-->

<fieldType
name="text_ga"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- removes d‘, etc -->

<filter class="solr.ElisionFilterFactory"
    ignoreCase="true"    
articles="lang/contractions_ga.txt"/>

<!-- removes n-, etc. position increments is
intentionally false!     -->

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/hyphenations_ga.txt"

enablePositionIncrements="false"/>

<filter
class="solr.IrishLowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ga.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Irish"/>

</analyzer>

</fieldType>

<!-- Galician
-->

<fieldType
name="text_gl"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_gl.txt"

enablePositionIncrements="true"/>

<filter
class="solr.GalicianStemFilterFactory"/>

<!-- less aggressive: <filter    
class="solr.GalicianMinimalStemFilterFactory"/> -->

</analyzer>

</fieldType>

<!-- Hindi
-->

<fieldType
name="text_hi"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<!-- normalizes unicode representation -->

<filter    
class="solr.IndicNormalizationFilterFactory"/>

<!-- normalizes variation in spelling -->

<filter    
class="solr.HindiNormalizationFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_hi.txt"

enablePositionIncrements="true"/>

<filter class="solr.HindiStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Hungarian
-->

<fieldType
name="text_hu" class="solr.TextField"    
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_hu.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Hungarian"/>

<!-- less aggressive: <filter    
class="solr.HungarianLightStemFilterFactory"/> -->

</analyzer>

</fieldType>

<!-- Armenian
-->

<fieldType
name="text_hy"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_hy.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Armenian"/>

</analyzer>

</fieldType>

<!-- Indonesian
-->

<fieldType
name="text_id"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_id.txt"

enablePositionIncrements="true"/>

<!-- for a less aggressive approach (only
inflectional suffixes),     set stemDerivational to false
-->

<filter class="solr.IndonesianStemFilterFactory"
    stemDerivational="true"/>

</analyzer>

</fieldType>

<!-- Italian
-->

<fieldType
name="text_it"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<!-- removes l‘, etc -->

<filter class="solr.ElisionFilterFactory"
    ignoreCase="true"    
articles="lang/contractions_it.txt"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_it.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter
class="solr.ItalianLightStemFilterFactory"/>

<!-- more aggressive: <filter
class="solr.SnowballPorterFilterFactory"    
language="Italian"/> -->

</analyzer>

</fieldType>

<!-- Japanese
using morphological analysis (see text_cjk for a    
configuration using bigramming)

NOTE: If you want to optimize search for precision, use
default     operator AND in your query

parser config with <solrQueryParser
    defaultOperator="AND"/> further down in this
file.  Use

OR if you would like to optimize for recall
(default).

-->

<fieldType
name="text_ja" class="solr.TextField"    
positionIncrementGap="100"    
autoGeneratePhraseQueries="false">

<analyzer>

<!-- Kuromoji Japanese morphological
analyzer/tokenizer     (JapaneseTokenizer)

Kuromoji has a search mode     (default) that does
segmentation useful for search.  A heuristic

is used to segment compounds     into its parts and the
compound itself is kept as synonym.

Valid values for attribute     mode are:

normal: regular     segmentation

search: segmentation useful     for search with synonyms
compounds (default)

extended: same as search     mode, but unigrams unknown
words (experimental)

For some applications it might     be good to use search
mode for indexing and normal mode for

queries to reduce recall and prevent     parts
of compounds from being matched and highlighted.

Use <analyzer     type="index"> and <analyzer
type="query"> for     this and mode normal in query.

Kuromoji also has a convenient     user dictionary feature
that allows overriding the statistical

model with your own entries     for segmentation,
part-of-speech tags and readings without a need

to specify weights.  Notice that user dictionaries have not
    been subject to extensive testing.

User dictionary attributes     are:

userDictionary: user     dictionary filename

userDictionaryEncoding: user     dictionary encoding
(default is UTF-8)

See lang/userdict_ja.txt for a     sample user dictionary
file.

Punctuation characters are     discarded by default. 
Use     discardPunctuation="false" to keep them.

See     http://wiki.apache.org/solr/JapaneseLanguageSupport
for more on Japanese     language support.

-->

<tokenizer    
class="solr.JapaneseTokenizerFactory"    
mode="search"/>

<!--<tokenizer
class="solr.JapaneseTokenizerFactory"     mode="search"
    userDictionary="lang/userdict_ja.txt"/>-->

<!-- Reduces inflected verbs and adjectives to their
base/dictionary     forms (辞書形) -->

<filter
class="solr.JapaneseBaseFormFilterFactory"/>

<!-- Removes tokens with certain part-of-speech tags
-->

<filter    
class="solr.JapanesePartOfSpeechStopFilterFactory"    
tags="lang/stoptags_ja.txt"

enablePositionIncrements="true"/>

<!-- Normalizes full-width romaji to half-width and
half-width     kana to full-width (Unicode NFKC subset)
-->

<filter class="solr.CJKWidthFilterFactory"/>

<!-- Removes common tokens typically not useful for
search, but     have a negative effect on ranking
-->

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ja.txt"

enablePositionIncrements="true"/>

<!-- Normalizes common katakana spelling variations
by removing     any last long sound character (U+30FC)
-->

<filter
class="solr.JapaneseKatakanaStemFilterFactory"    
minimumLength="4"/>

<!-- Lower-cases romaji characters -->

<filter class="solr.LowerCaseFilterFactory"/>

</analyzer>

</fieldType>

<!-- Latvian
-->

<fieldType
name="text_lv"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_lv.txt"

enablePositionIncrements="true"/>

<filter
class="solr.LatvianStemFilterFactory"/>

</analyzer>

</fieldType>

<!-- Dutch -->

<fieldType
name="text_nl"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_nl.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.StemmerOverrideFilterFactory"
    dictionary="lang/stemdict_nl.txt"
ignoreCase="false"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Dutch"/>

</analyzer>

</fieldType>

<!-- Norwegian
-->

<fieldType
name="text_no"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_no.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Norwegian"/>

<!-- less aggressive: <filter    
class="solr.NorwegianLightStemFilterFactory"/> -->

<!-- singular/plural: <filter    
class="solr.NorwegianMinimalStemFilterFactory"/> -->

</analyzer>

</fieldType>

<!-- Portuguese
-->

<fieldType
name="text_pt"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_pt.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter    
class="solr.PortugueseLightStemFilterFactory"/>

<!-- less aggressive: <filter    
class="solr.PortugueseMinimalStemFilterFactory"/> -->

<!-- more aggressive: <filter    
class="solr.SnowballPorterFilterFactory"    
language="Portuguese"/> -->

<!-- most aggressive: <filter
class="solr.PortugueseStemFilterFactory"/>    
-->

</analyzer>

</fieldType>

<!-- Romanian
-->

<fieldType
name="text_ro"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ro.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Romanian"/>

</analyzer>

</fieldType>

<!-- Russian
-->

<fieldType
name="text_ru"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_ru.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Russian"/>

<!-- less aggressive: <filter    
class="solr.RussianLightStemFilterFactory"/> -->

</analyzer>

</fieldType>

<!-- Swedish
-->

<fieldType
name="text_sv"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_sv.txt"
    format="snowball"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Swedish"/>

<!-- less aggressive: <filter    
class="solr.SwedishLightStemFilterFactory"/> -->

</analyzer>

</fieldType>

<!-- Thai
-->

<fieldType
name="text_th"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter class="solr.LowerCaseFilterFactory"/>

<filter class="solr.ThaiWordFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="true" words="lang/stopwords_th.txt"

enablePositionIncrements="true"/>

</analyzer>

</fieldType>

<!-- Turkish
-->

<fieldType
name="text_tr"     class="solr.TextField"
positionIncrementGap="100">

<analyzer>

<tokenizer
class="solr.StandardTokenizerFactory"/>

<filter
class="solr.TurkishLowerCaseFilterFactory"/>

<filter class="solr.StopFilterFactory"
    ignoreCase="false" words="lang/stopwords_tr.txt"

enablePositionIncrements="true"/>

<filter class="solr.SnowballPorterFilterFactory"
    language="Turkish"/>

</analyzer>

</fieldType>

</types>

</schema>

<?xml version="1.0"     encoding="UTF-8"
?>

<config>

<luceneMatchVersion>LUCENE_42</luceneMatchVersion>

<lib    
dir="../../../contrib/analysis-extras/lib"    
regex=".*\.jar" />

<lib    
dir="../../../contrib/extraction/lib" regex=".*\.jar"    
/>

<lib     dir="../../../dist/"
regex="solr-cell-\d.*\.jar" />

<lib dir="../../../contrib/clustering/lib/"
    regex=".*\.jar" />

<lib     dir="../../../dist/"
regex="solr-clustering-\d.*\.jar"     />

<lib    
dir="../../../contrib/langid/lib/" regex=".*\.jar"    
/>

<lib     dir="../../../dist/"
regex="solr-langid-\d.*\.jar"     />

<lib    
dir="../../../contrib/velocity/lib" regex=".*\.jar"    
/>

<lib     dir="../../../dist/"
regex="solr-velocity-\d.*\.jar"     />

<lib    
dir="/total/crap/dir/ignored" />

<dataDir>${solr.data.dir:}</dataDir>

<directoryFactory
name="DirectoryFactory"

class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}"/>

<codecFactory
class="solr.SchemaCodecFactory"/>

<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.  -->

<ramBufferSizeMB>100</ramBufferSizeMB>

<maxBufferedDocs>1000</maxBufferedDocs>

<!--     Expert:
Merge Policy

The
    Merge Policy in Lucene controls how merging of segments
is done.

The
    default since Solr/Lucene 3.3 is TieredMergePolicy.

The
    default since Lucene 2.3 was the
LogByteSizeMergePolicy,

Even
    older versions of Lucene used LogDocMergePolicy.

<mergePolicy
class="org.apache.lucene.index.TieredMergePolicy">

<int name="maxMergeAtOnce">100</int>

<int name="segmentsPerTier">100</int>

</mergePolicy>

-->

<!--     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.

Default is 10 for both merge policies.

-->

<mergeFactor>50</mergeFactor>

<!--     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"/>

-->

<!--     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>

<!--     Unlock On
Startup

If
    true, unlock any held write or commit locks on
startup.

This
    defeats the locking mechanism that allows multiple

processes to safely access a lucene index, and should
be used

with
    care. Default is "false".

This
    is not needed if lock type is ‘single‘

-->

<!--

<unlockOnStartup>false</unlockOnStartup>

-->

<!--     Expert:
Controls how often Lucene loads terms into memory

Default is 128 and is likely good for most
everyone.

-->

<!--    
<termIndexInterval>128</termIndexInterval> -->

<!--     If true,
IndexReaders will be reopened (often more efficient)

instead of closed and then opened. Default: true

-->

<!--

<reopenReaders>true</reopenReaders>

-->

<!--     Commit
Deletion Policy

Custom deletion policies can be specified here. The
class must

implement
org.apache.lucene.index.IndexDeletionPolicy.

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 debugging info the specified
file

-->

<!--    
<infoStream file="INFOSTREAM.txt">false</infoStream>
    -->

</indexConfig>

<jmx     />

<updateHandler
class="solr.DirectUpdateHandler2">

<updateLog>

<str    
name="dir">${solr.ulog.dir:}</str>

</updateLog>

<autoCommit>

<maxDocs>1000</maxDocs>

<maxTime>15000</maxTime>

<openSearcher>false</openSearcher>

</autoCommit>

</updateHandler>

<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>

<!--     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="0"/>

<!--     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">static firstSearcher warming in
    solrconfig.xml</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>

<requestDispatcher
handleSelect="false" >

<requestParsers    
enableRemoteStreaming="true"

multipartUploadLimitInKB="2048000"

formdataUploadLimitInKB="2048"/>

<httpCaching
never304="true" />

</requestDispatcher>

<requestHandler
name="/select" class="solr.SearchHandler">

<lst    
name="defaults">

<str name="echoParams">explicit</str>

<int name="rows">10</int>

<str name="df">text</str>

</lst>

</requestHandler>

<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>

<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>

<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>

<!-- Query settings -->

<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="df">text</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

title^10.0 description^5.0 keywords^5.0 author^2.0
resourcename^1.0

</str>

<str    
name="mlt.fl">text,features,name,sku,id,manu,cat,title,description,keywords,author,resourcename</str>

<int name="mlt.count">3</int>

<!-- Faceting defaults -->

<str name="facet">on</str>

<str name="facet.field">cat</str>

<str name="facet.field">manu_exact</str>

<str name="facet.field">content_type</str>

<str name="facet.field">author_s</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">content features title    
name</str>

<str name="hl.encoder">html</str>

<str    
name="hl.simple.pre">&lt;b&gt;</str>

<str    
name="hl.simple.post">&lt;/b&gt;</str>

<str name="f.title.hl.fragsize">0</str>

<str    
name="f.title.hl.alternateField">title</str>

<str name="f.name.hl.fragsize">0</str>

<str    
name="f.name.hl.alternateField">name</str>

<str name="f.content.hl.snippets">3</str>

<str name="f.content.hl.fragsize">200</str>

<str    
name="f.content.hl.alternateField">content</str>

<str name="f.content.hl.maxAlternateFieldLength">750</str>

<!-- Spell checking defaults -->

<str name="spellcheck">on</str>

<str    
name="spellcheck.extendedResults">false</str>

<str name="spellcheck.count">5</str>

<str name="spellcheck.alternativeTermCount">2</str>

<str    
name="spellcheck.maxResultsForSuggest">5</str>

<str name="spellcheck.collate">true</str>

<str    
name="spellcheck.collateExtendedResults">true</str>

<str    
name="spellcheck.maxCollationTries">5</str>

<str    
name="spellcheck.maxCollations">3</str>

</lst>

<!--     append
spellchecking to our list of components -->

<arr    
name="last-components">

<str>spellcheck</str>

</arr>

</requestHandler>

<requestHandler
name="/update"    
class="solr.UpdateRequestHandler">

</requestHandler>

<requestHandler    
name="/update/json"    
class="solr.JsonUpdateRequestHandler">

<lst name="defaults">

<str
name="stream.contentType">application/json</str>

</lst>

</requestHandler>

<requestHandler
name="/update/csv"    
class="solr.CSVRequestHandler">

<lst name="defaults">

<str    
name="stream.contentType">application/csv</str>

</lst>

</requestHandler>

<requestHandler    
name="/update/extract"

startup="lazy"

class="solr.extraction.ExtractingRequestHandler"
>

<lst    
name="defaults">

<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>

<requestHandler
name="/analysis/field"

startup="lazy"

class="solr.FieldAnalysisRequestHandler" />

<requestHandler
name="/analysis/document"

class="solr.DocumentAnalysisRequestHandler"

startup="lazy" />

<requestHandler
name="/admin/"

class="solr.admin.AdminHandlers" />

<requestHandler
name="/admin/ping"    
class="solr.PingRequestHandler">

<lst    
name="invariants">

<str    
name="q">solrpingquery</str>

</lst>

<lst    
name="defaults">

<str    
name="echoParams">all</str>

</lst>

</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>

<requestHandler
name="/replication"     class="solr.ReplicationHandler"
>

</requestHandler>

<!--     spell -->

<searchComponent    
name="spellcheck" class="solr.SpellCheckComponent">

<lst    
name="spellchecker">

<str name="name">direct</str>

<str name="field">spell</str>

<str    
name="classname">solr.DirectSolrSpellChecker</str>

<str name="distanceMeasure">internal</str>

<float
    name="accuracy">0.5</float>

<int name="maxEdits">2</int>

<int name="minPrefix">1</int>

<int name="maxInspections">5</int>

<int name="minQueryLength">2</int>

<float name="maxQueryFrequency">0.001</float>

<str    
name="buildOnCommit">true</str>

</lst>

<lst name="spellchecker">

<!--

Optional, it is required when more than one
spellchecker is     configured.

Select non-default name with spellcheck.dictionary in
request     handler.

name是可选的，如果只有一个spellchecker可以不写name

如果有多个spellchecker，需要在Request    
Handler中指定spellcheck.dictionary

-->

<str    
name="name">default</str>

<!--    
The classname is optional, defaults to IndexBasedSpellChecker -->

<str    
name="classname">solr.IndexBasedSpellChecker</str>

<!--

Load tokens from the following field for spell
checking,

analyzer for the field‘s type as defined in schema.xml
are used

下面这个field名字指的是拼写检查的依据，也就是说要根据哪个Field来检查用户输入。

-->

<str    
name="field">spell</str>

<!--    
Optional, by default use in-memory index (RAMDirectory)

SpellCheck索引文件的存放位置，是可选的，如果不写默认使用内存模式RAMDirectory。

./spellchecker1指的是：corex\data\spellchecker1

-->

<str    
name="spellcheckIndexDir">./spellchecker1</str>

<!--    
Set the accuracy (float) to be used for the suggestions. Default is 0.5
    -->

<str    
name="accuracy">0.7</str>

<!--何时创建拼写索引：buildOnCommit/buildOnOptimize
    -->

<str    
name="buildOnCommit">true</str>

</lst>

<!-- 另一个拼写检查器，使用JaroWinklerDistance距离算法 -->

<lst
    name="spellchecker">

<str name="name">jarowinkler</str>

<str    
name="classname">solr.IndexBasedSpellChecker</str>

<str name="field">spell</str>

<str    
name="distanceMeasure">org.apache.lucene.search.spell.JaroWinklerDistance</str>

<str    
name="spellcheckIndexDir">./spellchecker2</str>

<str name="buildOnCommit">true</str>

</lst>

<!-- 另一个拼写检查器，使用文件内容为检查依据

<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>

<str name="buildOnCommit">true</str>

</lst>-->

<str    
name="queryAnalyzerFieldType">text_spell</str>

</searchComponent>

<queryConverter name="queryConverter"
    class="solr.SpellingQueryConverter"/>

<requestHandler name="/spell"    
class="solr.SearchHandler">

<lst     name="defaults">

<str    
name="spellcheck.dictionary">default</str>

<str
    name="spellcheck.collate">true</str>

<str    
name="spellcheck.onlyMorePopular">true</str>

<str    
name="spellcheck.extendedResults">false</str>

<str    
name="spellcheck.count">10</str>

</lst>

<arr name="last-components">

<str>spellcheck</str>

</arr>

</requestHandler>

<searchComponent  name="suggest"
    class="solr.SpellCheckComponent">

<str    
name="queryAnalyzerFieldType">string</str>

<lst    
name="spellchecker">

<str name="name">suggest</str>

<str    
name="classname">org.apache.solr.spelling.suggest.Suggester</str>

<str    
name="lookupImpl">org.apache.solr.spelling.suggest.tst.TSTLookup</str>

<str name="field">text</str>

<float name="threshold">0.0001</float>

<str name="comparatorClass">freq</str>

<str name="buildOnOptimize">true</str>

<!--<str    
name="buildOnCommit">true</str>-->

</lst>

</searchComponent>

<requestHandler     
name="/suggest" class="solr.SearchHandler"    
startup="lazy">

<lst    
name="defaults">

<str name="spellcheck">true</str>

<str    
name="spellcheck.dictionary">suggest</str>

<str    
name="spellcheck.onlyMorePopular">true</str>

<str    
name="spellcheck.extendedResults">false</str>

<str name="spellcheck.count">10</str>

<!--<str    
name="spellcheck.collate">true</str>-->

</lst>

<arr    
name="components">

<str>suggest</str>

</arr>

</requestHandler>

<requestHandler name="/mlt"    
class="solr.MoreLikeThisHandler">

</requestHandler>

<searchComponent
name="tvComponent"    
class="solr.TermVectorComponent"/>

<requestHandler name="/tvrh"
    class="solr.SearchHandler" startup="lazy">

<lst    
name="defaults">

<str    
name="df">text</str>

<bool
name="tv">true</bool>

</lst>

<arr    
name="last-components">

<str>tvComponent</str>

</arr>

</requestHandler>

<searchComponent
name="clustering"

enable="${solr.clustering.enabled:true}"

class="solr.clustering.ClusteringComponent" >

<lst    
name="engine">

<str name="name">default</str>

<str    
name="carrot.algorithm">org.carrot2.clustering.lingo.LingoClusteringAlgorithm</str>

<str
name="LingoClusteringAlgorithm.desiredClusterCountBase">30</str><!--2~100-->

<str    
name="LingoClusteringAlgorithm.clusterMergingThreshold">0.70</str><!--0~1-->

<str    
name="LingoClusteringAlgorithm.scoreWeight">0</str><!--0~1-->

<str    
name="LingoClusteringAlgorithm.labelAssigner">org.carrot2.clustering.lingo.SimpleLabelAssigner</str><!--org.carrot2.clustering.lingo.UniqueLabelAssigner
    -->

<str    
name="LingoClusteringAlgorithm.phraseLabelBoost">1.5</str><!--0~10-->

<str    
name="LingoClusteringAlgorithm.phraseLengthPenaltyStart">8</str><!--2~8-->

<str    
name="LingoClusteringAlgorithm.phraseLengthPenaltyStop">8</str><!--2~8-->

<str    
name="TermDocumentMatrixReducer.factorizationQuality">HIGH</str><!--LOW,MEDIUM,HIGH-->

<!--

org.carrot2.matrix.factorization.PartialSingularValueDecompositionFactory

org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationEDFactory

org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationKLFactory

org.carrot2.matrix.factorization.LocalNonnegativeMatrixFactorizationFactory

org.carrot2.matrix.factorization.KMeansMatrixFactorizationFactory

-->

<str    
name="TermDocumentMatrixReducer.factorizationFactory">org.carrot2.matrix.factorization.NonnegativeMatrixFactorizationEDFactory</str>

<str    
name="TermDocumentMatrixBuilder.maximumMatrixSize">37500</str><!--MinValue5000-->

<str    
name="TermDocumentMatrixBuilder.titleWordsBoost">2.0</str><!--2~10-->

<str    
name="TermDocumentMatrixBuilder.maxWordDf">0.9</str><!--0~1-->

<!--org.carrot2.text.vsm.LogTfIdfTermWeighting,org.carrot2.text.vsm.LinearTfIdfTermWeighting-->

<str    
name="TermDocumentMatrixBuilder.termWeighting">org.carrot2.text.vsm.TfTermWeighting</str>

<str    
name="MultilingualClustering.defaultLanguage">CHINESE_SIMPLIFIED</str>

<str    
name="MultilingualClustering.languageAggregationStrategy">org.carrot2.text.clustering.MultilingualClustering.LanguageAggregationStrategy.FLATTEN_MAJOR_LANGUAGE
    </str><!--FLATTEN_ALL,FLATTEN_NONE-->

<str    
name="GenitiveLabelFilter.enabled">true</str>

<str    
name="StopWordLabelFilter.enabled">true</str>

<str    
name="NumericLabelFilter.enabled">true</str>

<str    
name="QueryLabelFilter.enabled">true</str>

<str    
name="MinLengthLabelFilter.enabled">true</str>

<str    
name="StopLabelFilter.enabled">true</str>

<str    
name="CompleteLabelFilter.enabled">true</str>

<str    
name="CompleteLabelFilter.labelOverrideThreshold">0.65</str><!--0~1-->

<str    
name="DocumentAssigner.exactPhraseAssignment">false</str>

<str    
name="DocumentAssigner.minClusterSize">2</str><!--1~100-->

<str     name="merge-resources">true</str>

<str    
name="CaseNormalizer.dfThreshold">1</str><!--1~100-->

<str    
name="PhraseExtractor.dfThreshold">1</str><!--1~100-->

<str    
name="carrot.lexicalResourcesDir">clustering/carrot2</str>

<str    
name="SolrDocumentSource.solrIdFieldName">id</str>

</lst>

</searchComponent>

<requestHandler
name="/clustering"

startup="lazy"

enable="${solr.clustering.enabled:true}"

class="solr.SearchHandler">

<lst    
name="defaults">

<str    
name="echoParams">explicit</str>

<bool    
name="clustering">true</bool>

<str    
name="clustering.engine">default</str>

<bool    
name="clustering.results">true</bool>

<str    
name="carrot.title">category_s</str>

<str
    name="carrot.snippet">content</str>

<str
    name="carrot.url">path</str>

<str
    name="carrot.produceSummary">true</str>

</lst>

<arr    
name="last-components">

<str>clustering</str>

</arr>

</requestHandler>

<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>

<bool
name="distrib">false</bool>

</lst>

<arr    
name="components">

<str>terms</str>

</arr>

</requestHandler>

<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>

<str    
name="df">text</str>

</lst>

<arr    
name="last-components">

<str>elevator</str>

</arr>

</requestHandler>

<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\&quot;&apos;]{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[<em>]]></str>

<str
name="hl.simple.post"><![CDATA[</em>]]></str>

</lst>

</formatter>

<!--    
Configure the standard encoder -->

<encoder name="html"

class="solr.highlight.HtmlEncoder" />

<!--    
Configure the standard fragListBuilder -->

<fragListBuilder name="simple"

class="solr.highlight.SimpleFragListBuilder"/>

<!--    
Configure the single fragListBuilder -->

<fragListBuilder name="single"

class="solr.highlight.SingleFragListBuilder"/>

<!--    
Configure the weighted fragListBuilder -->

<fragListBuilder name="weighted"

default="true"

class="solr.highlight.WeightedFragListBuilder"/>

<!--    
default tag FragmentsBuilder -->

<fragmentsBuilder name="default"

default="true"

class="solr.highlight.ScoreOrderFragmentsBuilder">

</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>

<queryResponseWriter
name="json"     class="solr.JSONResponseWriter">

<str    
name="content-type">text/plain; charset=UTF-8</str>

</queryResponseWriter>

<!--

Custom    
response writers can be declared as needed...

-->

<queryResponseWriter name="velocity"    
class="solr.VelocityResponseWriter" startup="lazy"/>

<queryResponseWriter
name="xslt"     class="solr.XSLTResponseWriter">

<int    
name="xsltCacheLifetimeSeconds">5</int>

</queryResponseWriter>

<admin>

<defaultQuery>*:*</defaultQuery>

</admin>

</config>