sunburnt 学习笔记 （四） solr查询

转载请声明出处：http://blog.csdn.net/wbcg111/article/details/47441423

1.Querying Solr（查询Solr）

在本章，我假定你已经solr里面提供的书籍数据加载到你的服务器上了。你可以在 $SOLR_SOURCE_DIR/example/exampledocs/books.csv.看到这些数据 ，你可以通过以下命令将数据加载到你的服务器：

cd example/exampledocs
curl http://localhost:8983/solr/update/csv --data-binary @books.csv  \
-H 'Content-type:text/plain;charset=utf-8'

如果您通过本手册tutorial-stylye学习,您可能要保持书的副本，你可以在编辑器中打开csv文件来检查我们的查询，在例子中,我将假设您已经建立了一个SolrInterface对象指向您的服务器,称为si。

si = SolrInterface(SOLR_SERVER_URL)

2.Searching your solr instance （搜索Solr的实例）

sunburnt使用一个API链接，看起来与Django的ORM是非常相似的。
把book.csv的数据用一个schema描述，就会有如下模式：

Field           Field Type

id              string
cat             string
name            text
price           float
author_t        string
series_t        text
sequence_i      integer
genre_s         string

默认的搜索字段是generated field,称作text,它是由cat和name字段生成的

注

最后的四个字段名字含有后缀，这是因为他们是动态字段，详情见http://blog.csdn.net/wbcg111/article/details/46131847

下面来看在默认搜索字段下一个单词的简单搜索：

si.query("game") #在所有书里面找到titile里面含有"game"的书

也许你想在author_t字段里面搜索叫Martin的作者：

si.query(author_t="Martin")

也许你想搜索title里面含有”game”，author_t是Martin的书:

si.query(name="game",author_t="Martin")

可能你的初始化默认搜索是更加复杂的，有不止一个单词在里面：

si.query(name="game").query(name="thrones")

注 -字符串

sunburnt查询字符串不是solr查询字符串
当你做一个像query(“game”)这样的简单查询时，这仅仅是一个在默认字段上的简单查询，它不是一个solr查询字符串，这就意味着下面的查询可能不是你期望的：

si.query("game thrones")

如果你熟悉solr，你可能期望返回在默认搜索字段里面包含”game”和”thrones”的所有文章，然而事实并非如此。这是一个精准查询，”game thrones”紧邻彼此，中间只能有空格。
如果你想查询包含”game”和”thrones”的所有文章，而不在乎他们的顺序以及是否紧邻彼此，那么你需要如下这般：

si.query("game").query("thrones").

如果你想查询包含”game”或者”thrones”的所有文章，那么请向下看Optional terms and combining queries部分.
以上的查询也可以写为

si.query(name="game").query(author_t="thrones")

你可以以这种方式增加更多的查询，直至到所有的，结果会挑选的标准返回。通常把所有的查询放进一个query()的方式是最简单的，但是在一些复杂的环境中，把每一个字段作为单独的一部分可能是更加有用的。

3.Executing queries and interpreting the response（执行查询和解释响应）

在构建查询方面，sunburnt是懒惰的。在以上部分的例子中不能精确的展现查询，他们仅仅是用正确的参数创建了一个查询对象，为了得到查询的结果，你需要执行它：
response = si.query(“game”).execute()
这会返回一个solr的response对象，如果你把这个对象视为一个列表，那么列表的每个成员就是一个文档，以python字典的形式在里面包含每个字段。
例如，你想执行上面的第一个例子，那么你会看到如下的response:

>>> for result in si.query("game").execute():
...print result

{'author_t': u'George R.R. Martin',
 'cat': (u'book',),
 'genre_s': u'fantasy',
 'id': u'0553573403',
 'inStock': True,
 'name': u'A Game of Thrones',
 'price': 7.9900000000000002,
 'sequence_i': 1,
 'series_t': u'A Song of Ice and Fire'}
{'author_t': u'Orson Scott Card',
 'cat': (u'book',),
 'genre_s': u'scifi',
 'id': u'0812550706',
 'inStock': True,
 'name': u"Ender's Game",
 'price': 6.9900000000000002,
 'sequence_i': 1,
 'series_t': u'Ender'}

solr返回了两条结果，每一个结果是一个字典，每个字典包含我们初始化的所有字段。

注 - 多个字段

因为cat在schema里面被声明为multivalued(多值的)，所以sunburnt也以元组的形式返回cat字段，尽管在这种情况下，这两本书只有一个类别分配给他们，那么cat字段的结果就是一个一元元组。

注-浮点数

在这两种情况下，虽然我们最初提供的价格到小数点后两位，但是Solr存储答案作为一个浮点数。在二进制中，当结果回来时，它受到来自二进制数的共同问题，并且这个答案看起来有点意外。

当然，通常情况下你不想不得结果以字典的形式返回，你想以对象的形式返回。那么你可能需要在你的代码中有如下的class(类)定义：

class Book:
def __init__(self, name, author_t, **other_kwargs):
self.title = name
self.author = author_t
self.other_kwargs = other_kwargs

def __repr__(self):
return 'Book("%s", "%s")' % (title, author)

你可以通过告诉execute()使用类Book作为一个构造函数来让sunburnt返回书的目录，

>>> for result in si.query(“game”).execute(constructor=Book):
... print result

Book("A Game of Thrones", "George R.R. Martin")
Book("Ender's Game", "Orson Scott Card")

构造函数的参数通常会是一个类，但它可以是任何可调用的；它总是被称为构造函数（** response_dict）。
您可以从响应中提取更多信息，而不是简单的结果列表。SolrResponse对象具有以下属性：

• response.status：状态查询。（如果这不是‘0’，那就错了）。

• response.qtime： 花多少毫秒查询。

• response.params：在查询中使用的参数。

结果有以下属性

• response.result：您主要的查询结果。

• response.facet_counts：详情看Faceting。

• response.highlighting:详情看Highlighting。

• response.more_like_these：详情看More Like This。

最后，response.result 自身含有以下属性

• response.result.numfound：符合查询的文档总数。

• response.result.docs：实际结果本身（更容易提取列表（响应））。

• response.result.start：如果文档数量少于numfound，然后这是分页偏移。

4.Pagination(分页)

默认情况下，它将只返回前10个结果（这在solrconfig.xml是可配置的。）。为了得到更多的结果，你需要告诉Solr将进一步通过结果。你用paginate()方法，这需要两个参数，start 和 rows：

si.query("black").paginate(start=10, rows=30)

将查询包含“黑色”的文件，然后返回第十一到第四十的结果。Solr开始计数为0，所以start=10将返回第十一个结果，rows=30将返回30个结果，即到第四十条。

5.Pagination with Django（结合Django分页）

如果您使用sunburnt和Django，你可以利用Django’s Paginator将你的查询结果分页。例如，上面的分页例子可以在一个Django页面如此简单：

from django.core.paginator import Paginator
paginator = Paginator(si.query("black"), 30)    # 每页30条结果

然后得到的页面对象可以用在Django的视图（或其他任何你想要的页码内容），正如在Django文档页面所描述的例子。

注

当与Django paginator一起使用sunbrunt查询对象，你可以链接的任意数量的过滤器或任何其他方法返回一个SolrSearch实例；然而，你不应该叫execute()，因为这将执行查询并返回当前查询结果设置；
为了得到合适的页面，paginator需要能够查询Solr返回结果的总数，然后添加分页选项来对结果进行合适的切分。

6.Returning different fields（返回不同的字段）

默认情况下，solr将会在结果中返回所有的储存字段，你可能只对那些字段的一个子集感兴趣。为了限制Solr返回的字段，你将使用field_limit()方法。

si.query("game").field_limit("id") #仅仅返回id
si.query("game").field_limit(["id", "name"]) # 仅仅返回每篇文档的id和名字

运用同样的方法你也可以得到solr为每篇文章计算的相关性得分

si.query("game").field_limit(score=True) # 在每篇文章中都返回分数
si.query("game").field_limit("id", score=True") # 仅仅返回id和分数

返回的结果就像普通的字典response,但是有不同的选择字段

>>> for result in si.query("game").field_limit("id", score=True"):... 
print result

{'score': 1.1931472000000001, 'id': u'0553573403'}
{'score': 1.1931472000000001, 'id': u'0812550706'}

7.More complex queries（更加复杂的查询）

solr不仅仅能够索引text字段，还能够索引number,booleans和dates等。在3.1版本以后，它可以索引空间点（虽然sunburnt还不具备空间查询的支持）。这意味着你可以使你的文本搜索查询相关的数，布尔值或日期。在我们的书籍例子中，有两个数字类字段，price(浮点数)和sequence_i(整数)，数值域可以查询：

• 精确查询
• 比较查询
• 范围查询

精确查询

不要试图精确查询浮点数除非你真的知道你在做什么http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.htmlsolr允许你这么做，但是你几乎从不这么做。但是对于整数的精确查询是比较好的。

si.query(sequence_i=1) # 在所有书里面查找sequence_i=1的

比较查询

这些需要使用一些语法：

si.query(price__lt=7) # 找到价格小于7的

你既可以在浮点数上利用比较查询，也可以在整数上利用比较查询，语法如下：

• gt :大于 >
• gte ：大于等于 >=
• lt :小于 <
• lte ：小于等于 <=

范围查询

作为比较查询的扩展，您可以查询在一个范围内的值，即在2个不同的数字之间。

si.query(price__range=(5, 7)) # 查询价格在5--7美元的所有书

这个范围查询是包容的-它将返回包含价格为5美元或者7美元的书籍。你也可以做一个专属的搜索：

si.query(price__rangeexc=(5, 7))  #只返回价格为5美元或者7美元的书籍

最后，你也可以做精确查询：

si.query(price__any=True)  

将寻找一本价格为任意的书。你为什么这样做？那么，如果你有一个schema，价格是可选的，那么这个搜索将返回所有的有价格书，并排除任何没有价格的书。

日期查询

你可以用与数字查询类似的方式进行日期查询：精确查询，比较查询和范围查询。示例中的书籍资料不包含任何日期字段，所以我们要看看实例中的硬件数据，包括manufacturedate_dt字段。

不过，要提醒的是，精确搜索的日期与精确搜索浮点数有类似的问题。Solr以微秒级的精度存储所有日期，精确搜索将会失败，除非所要求的日期也是微秒精度的。

si.query(manufacturedate_dt=datetime.datetime(2006, 02, 13))

上面代码将会查询manufacturedate_dt为2006年二月十三日午夜后0微秒的文档。

你可能会更想通过比较或按范围搜索：

si.query(manufacturedate_dt__gt=datetime.datetime(2006, 1, 1))

将会查询manufacturedate_dt为2006年1月1日之后的所有文档

si.query(manufacturedate_dt__range=(datetime.datetime(2006, 1, 1), datetime.datetime(2006, 4, 1))

将会查询manufacturedate_dt在2006年1月1日和2006年4月1日之间的文档。

一个日期的查询可以是任何对象，看起来有点像是一个Python DateTime对象（所以mx.datetime对象也是可以的），或在W3C DateTime的字符串（http://www.w3.org/tr/note-datetime）

si.query(manufacturedate_dt__gte="2006")
si.query(manufacturedate_dt__lt="2009-04-13")
si.query(manufacturedate_dt__range=("2010-03-04 00:34:21", "2011-02-17 09:21:44"))

以上所有的查询将如你的期望，铭记Solr还有工作到微秒级的精度。上面的第一个查询将返回之后或当时的所有结果。

布尔字段

布尔字段在文档中是一种标记，例子中的硬件规格，文档含有该字段，我们可以选择做如下内容：

si.query("Samsung", inStock=True) # instock为真的所有Samsung

8.Sorting results（结果排序）

除非特别声明，否则solr利用相关度对返回结果排序，solr如何确定相关性是一个复杂的问题，并且取决于你的具体设置。然而，它有可能重写这个并且根据某一字段对结果进行排序该字段必须排序，所以你很可能会用一个数值或日期字段。

si.query("game").sort_by("price") #根据价格升序排序
si.query("game").sort_by("-price") # 根据价格降序排序

也可以根据多个参考值排序：

si.query("game").sort_by("-price").sort_by("score")

这个查询会首先根据价格降序排序，然后根据相关性得分排序。

9.Excluding results from queries（排除查询）

在上面的例子中，我们只考虑以积极的方式缩小我们的搜索要求。如果我们想排除一些标准的结果呢？再回到图书资料，我们通过下面代码可以把所有的亚力山大劳埃德的书都排除在外：

si.exclude(author_t="Lloyd Alexander")

exclude()方法与methodms（）方法在链中以同样的方式存在，所以你可以混合和匹配。

si.query(price__gt=7).exclude(author_t="Lloyd Alexander")
# 返回所有花费大于7美元的书，并排除作者是Lloyd Alexander的书

10.Optional terms and combining queries（可选条件和组合查询）

sunburnt的查询可以以各种各样的方式被链接在一起，包含查询和排除等。到目前为止，你只见过有强制条件的例子，无论是正面的（query（））或负面的（exclude()）。万一你想有选择的条件？

这个语法有点丑陋。让我们想象一下，我们想要在他们的标题有“游戏”或“黑色”这个词的所有书籍。我们需要做的就是构建两个查询对象，一个用于一个条件，或者是他们一起构成的。

si.query(si.Q("game") | si.Q("black"))

Q对象可以包含任意的查询，然后可以结合使用布尔逻辑（在这里，用|，OR运算符）。结果可以通过正常的Si（）调用执行。
Q对象可以使用任何一个布尔运算符，所以与，或，非都可以，并且可以嵌套彼此。你可能不在乎这个除非你正在构建查询的方式，但它可能以这种方式来表达任意复杂的查询。
一个适度复杂的查询可以写：

si.query(si.Q(si.Q("game") & ~si.Q(author_t="orson")) | si.Q(si.Q("black" & ~si.Q(author_t="lloyd")))

这将返回所有符合标准的结果：

• 要么（书的标题中含有”game”,但是作者不是orson）
• 要么（书的标题中含有”black”,但是作者不是lloyd）

11.Wildcard searching(通配符搜索)

有时你想搜索一个单词的部分匹配。这就要取决于你的Solr模式如何匹配了，它有可能会为你自动完成。例如，在这个例子的schema中，如果你搜索“parse”，然后含有“parsing”的文件也将返回来，因为Solr会减去搜索词和文档中的公共部分，这就是“par”。
然而，有时你需要做的部分匹配，solr也不知道。你可以以正常的方式使用星号和问号,除了在IE中你不可以使用通配符-IE在字符开始没有通配符匹配。

再次使用书籍的例子：

si.query(name="thr*")

上面代码会返回所有有一个单词以“thr”开头的书籍，所以它会返回“A Game of Thrones” 和 “The Book of Three”。

si.query(name="b*k")

将会返回”The Black Company”, “The Book of Three” and “The Black Cauldron”。

一个通配符搜索结果是高度依赖于你的Solr的配置，特别是取决于文本分析执行。你可能会发现你需要小写搜索即使原始文件混合大小写，因为Solr索引之前它已经变成小写了。（我们在这里做了这个）。
如果，出于某种原因，你要搜索的是一串星号标记或一个问题，然后你需要告诉Solr的特殊情况：

si.query(id=RawString(“055323933?*”))

这将搜索一个ID包含字符串的文件，包括问题和星号标记。（因为没有一个在我们的索引中，这将返回没有结果。）

12.Filter queries and caching（过滤查询和缓存）

Solr实现了几个内部缓存层，并在一定程度上你可以控制什么时间、如何使用他们。（这是从HTTP缓存层分开）。

通常，你发现你可以分区查询；一部分是运行很多次而不改变，或者非常有限的变化，另一个部分变化更大。（见更多的指导。http://wiki.apache.org/solr/filterqueryguidance）

你可以通过使用FilterCache让solr缓存索引中不经常变化的部分。例如，在图书的情况下，您可以提供标准功能，以各种价格范围的过滤结果：不到7.50美元，或大于7.50美元。您的搜索的这部分将在几乎所有的查询中运行相同的，而查询的主要文本部分变化很多。

如果你分开这两部分的查询，你可以把价格查询标记为可缓存的，通过查询过滤器代替一个普通的查询。

如果你从用户的搜索输入，你会写：

si.query(name=user_input).filter(price__lt=7.5)
si.query(name=user_input).filter(price__gte=7.5)

在数据类型和查询类型方面，filter()方法和query()方法有相同的功能。然而，这也告诉Solr分离出部分的查询和缓存结果。在这种情况下，它将预先计算价格部分查询缓存的结果，以便用户驱动的不同查询。Solr只有在充满独特的部分查询，姓名查询和价格过滤器可以做到更加迅速。

你可以过滤任何查询，通过filter()代替query（）。如果你是一个排除过滤，那么filter_exclude()与exclude()具有相同的功能。

si.query(title="black").filter_exclude(author_t="lloyd")
#如果你大量的用户讨厌作者lloyd，它可能是有用的

如果它有用，只要你喜欢，你可以混合和匹配filter（）和filter()命令。将所得的过滤查询和缓存合并在一起。

si.query(...).filter(...).exclude(...).filter_exclude(...)

是Si的布尔组合Q的对象可以使用命令filter()或filter_exclude()。

13.Query boosting（设置权重查询）

solr根据不同的字段权重为最终结果提供了一种机制（详情参见：http://wiki.apache.org/solr/SolrRelevancyCookbook#Boosting_Ranking_Terms）你在做一个可选的搜索并且你想指定一些更加重要的字段时，这是有用的。

例如，想象你正在寻找有“black的书籍，或有一个名为“lloyd”的作者。让我们这样说，虽然无论是做什么，你关心作者比标题更多。你就可以用sunburnt提高Q对象得到你你想要的。

si.query(si.Q("black") | si.Q(author_t="lloyd")**3)

相对black而言，以上代码把作者字段的重要程度提高了三倍。

通常情况下，你想找到title里面含有black,并且作者与lloyd有关的所有书。这与上一个查询是不同的，上面的查询会返回作者是lloyd但是title里面不含有black的书。在Solr中实现这些是可能的，但有点不优美；sunburnt提供了这种模式的快捷方式。

si.query("black").boost_relevancy(3, author_t="lloyd")

这是具有连贯性的，boost_relevancy可以是查询对象的任意集合。

14.Faceting(层面搜索)

背景资料，请看：http://wiki.apache.org/solr/SimpleFacetParameters.

sunburnt允许你利用facet_by()方法对任何查询做层面搜索，facet_by()方法需要至少一个字段用来层面搜索。

facet_query = si.query("game").facet_by("sequence_i").paginate(rows=0)

以上代码将根据sequence_i的值搜索标题为game的结果，仅仅在层面搜索上，他将返回0条结果。

>>> print facet_query.execute().facet_counts.facet_fields

{'sequence_i': [('1', 2), ('2', 0), ('3', 0)]}

facet_ counts即结果中文档的数目，在此，假定我们只对facet_ fields对象感兴趣，结果将包含在一个字典中，key是层面搜索请求的字段(我们仅仅在层面搜索上利用了一个字段)，字典的value是一个二元组列表，映射层面域的值（在这种情况下，sequence_ i的value是1，2，3）为每个结果的数量。

你可以这样理解上面的结果：在所有的title里面含有black的书籍中，有2个sequence_ i=1,0个sequence_ i=2,0个sequence_ i=3的。

你也可以在一次搜索中用更多的字段：

si.query(...).facet_by(fields=["field1", "field2, ...])

这样的话facet_fields 字典会有不止一个key,每个字段就会产生一个key.
Solr支持多个参数的操作，所有的基本选择是基于sunburnt的：fields, prefix, sort, limit, offset, mincount, missing, method, enum.cache.minDf，这些都可以作为关键字参数被facet()调用的，当然，除了最后一个，因为它包含时期。要把关键字参数传递给它们，你可以使用**语法：

facet(**{"enum.cache.minDf":25})

你也可以在结果中使用一个或者多个facet_query()方法。例如：

>>> fquery = si.query("game").facet_query(price__lt=7).facet_query(price__gte=7)
>>> print fquery.execute().facet_counts.facet_queries

[('price:[7.0 TO *]', 1), ('price:{* TO 7.0}', 1)]

这将根据你指定的两个查询对结果进行层面搜索，所以你可以看到结果中有多少的价格低于或者高于7美元。

结果以facet_queryies()对象返回，但是与之前的形式是一样的。层面搜索其实就是将结果分类处理，分别统计出数量。上面结果的意思就是结果中价格高于7美元和低于7美元的都是1个。

注 -其他类型的层面搜索

目前，根据日期和范围的层面搜索暂时不支持（但是可以利facet_query()解决。

15.Highlighting（高亮）

背景详情见：http://wiki.apache.org/solr/HighlightingParameters.

除了正常的搜索结果，你可以让Solr返回的文件的某些字段，相关搜索方面将结果设置没高亮。你在这可以调用highlight()方法。默认情况下，该值将突出显示默认搜索字段中的值。在我们的书籍例如，默认的搜索字段是一个生成的字段，没有返回的结果，所以我们需要明确指定哪一个字段，我们希望看到高亮：

>>> highlight_query = si.query("game").highlight("name")
>>> print highlight_query.execute().highlighting

{'0553573403': {'name': ['A <em>Game</em> of Thrones']},
'0812550706': {'name': ["Ender's <em>Game</em>"]}}

高亮的结果突出在solrresponse对象中。结果是字典的嵌套。顶层的key是每个返回文件的ID（或uniquekey）。对于每一个文档，你都会有一个字典映射字段名来突出显示文本的片段。在这种情况下，我们只要求在名称字段上进行高亮显示。每个字段都可以返回多个片段，但在这种情况下，我们只得到一个片段。是通过HTML来突出显示文本的，并且碎片会合适地直接舍弃搜索模板。
查询中，
如果你使用的是默认的结果格式（即，当你调用execute()时，你没有指定一个构造函数选项），在一个结果中，高亮的部分可以被传递出来。例如，在以上的中，你可以利用results[‘solr_highlights’][‘name’]只查看高亮部分信息，对于在模板中单独展示高亮部分，这是特别的方便的。比如子啊Django模板中：

{% for snippet in book.solr_highlights.name %}
<p>... {{ snippet|safe }} ...</p>
{% endfor %}

再次，Solr对于高亮命令支持大量的选项，这些都是通过sunburnt。支持选项的完整列表：fields, snippets, fragsize, mergeContinuous, requireFieldMatch, maxAnalyzedChars,
alternateField, maxAlternateFieldLength, formatter, simple.pre.simple.post,
fragmenter, usePhrasehighlighter, hilightMultiTerm, regex.slop, regex.pattern,
regex.maxAnalyzedChars

16.More Like This（模糊搜索）

背景详情见：http://wiki.apache.org/solr/MoreLikeThis

在一系列的搜索结果中，solr能够找出那些与搜索结果相似的。

注-查询处理程序

sunburnt通过StandardQueryHandler只支持more like this，不能通过单独的MoreLikeThisHandler。也就是说，它只支持对已在其索引的文档进行这样的搜索。

模糊搜索由mlt()完成可选项。它需要知道哪些字段决定相似；如果你不做任何选择，那么就是默认的字段（默认字段由solrcofig.xml指定）。

>>> mlt_query = si.query(id="0553573403").mlt("name", mintd=1, mindf=1)
>>> mlt_results = mlt_query.execute().more_like_these
>>> print mlt_results

{'0553573403': <sunburnt.schema.SolrResult object at 0x4b10510>}

>>> print mlt_results['0553573403'].docs

[{'author_t': u'Orson Scott Card',
  'cat': (u'book',),
  'genre_s': u'scifi',
  'id': u'0812550706',
  'inStock': True,
  'name': u"Ender's Game",
  'price': 6.9900000000000002,
  'sequence_i': 1,
  'series_t': u'Ender'}]

在这里，我们用mlt()选项来改变默认的行为（因为我们的语料库是如此之小，以至于与标准的查询相比，solr也不会找到任何类似的文件。

solrresponse对象有一个more_like_these属性。这是一个solrresult对象字典，对于每一个结果的一个主要查询词典。在这里，查询只产生一个结果（因为我们在搜查的uniquekey。检查solrresult对象，我们发现，它只包含一个文件。）

我们可以看上面的结果，mlt()参数要求下，只有一个文档相似搜索结果。
在这种情况下，只有一个文件是由原始查询中返回，在这种情况下，有一个快捷方式的属性：可以用more_like_this替代more_like_these 。

>>> print mlt_query.execute().more_like_this.docs

[{'author_t': u'Orson Scott Card',
 ...

避免做额外的字典查找。
mlt()也作为一个选项列表（详见Solr文档）；

fields:count，mintf，mindf，minwl，MAWL，maxqt，maxntp，boost

17.Spatial fields(空间域)

从solr3.1版，空间域类型是支持的。这意味着你可以在一个文档中有（经度，纬度）对的字段。（事实上，你可以有一个任意数量的领域的代表点的尺寸。）

虽然sunburnt在存储和检索等领域是正确处理的，但是目前不支持精确匹配查询（包括空间查询）。

sunburnt的希望空间领域字段可提供两个可迭代对象的长度，并永远把他们做为二元组。

18.Binary fields(二进制字段)

从solr3.1版开始，二进制数据是支持的。在solr里面这些存储为Base64编码的点，但sunburnt的用户不用关心这个。sunburnt会自动转码，你的结果将包含一个适当的二进制字符串。（对二进制字段进行查询是不支持的，而且没有太多的意义）。

19.UUID fields（UUID字段）

从solr1.4版，UUIDs字段是支持的。检索结果时，Solr会自动将任何UUID字段传递 Python给UUID对象