python elastic,Python elasticsearch
弹性搜索模块弹性搜索低级客户端。提供从计算机编程语言到萨尔瓦多休息端点的直接映射。
连接集群节点指定连接es=Elasticsearch(
[172.16.153.129:9200],
# 认证信息
# http_auth=(elastic ， changeme )
)
动态连接es=Elasticsearch(
[esnode1:port ， esnode2:port]，
# 在做任何操作之前，先进行嗅探
嗅探启动=真
# 节点没有响应时，进行刷新，重新连接
嗅探连接失败=真
# 每60秒刷新一次
嗅探器超时=60
)
对不同的节点，赋予不同的参数es=Elasticsearch([
{host: localhost}，
{host: othernode ， port: 443， url_prefix: es ， use_ssl: True}，
])
假如使用了ssles=Elasticsearch(
[本地主机：443 ,其他主机：443],
#打开加密套接字协议层
use_ssl=True，
#确保我们验证了加密套接字协议层证书（默认关闭)
verify_certs=True，
#提供加利福尼亚证书的路径
ca_certs=/path/to/CA_certs ，
#PEM格式的加密套接字协议层客户端证书
client _ cert=/path/to/client cert。PEM ，
#PEM格式的加密套接字协议层客户端密钥
client _ key=/path/to/client key。 PEM
)
获取相关信息测试集群是否启动在[40]中：es.ping()
Out[40]:真
获取集群基本信息In [39]: es.info()
Out[39]:
{cluster_name: sharkyun ，
cluster _ uuid : rIt2U-un rug 0 hjbt 6 bxxqw ，
姓名:主人，
标语："你知道，为了搜索",
版本：{ build _ date : 2017-10-06t 20:33:39.012 z ，
build_hash: 1a2f265 ，
“build _ snapshot”:假，
lucene_version: 6.6.1 ，
数字: 5.6.3}}
获取集群的健康状态信息In [41]: es.cluster.health()
Out[41]:
{active_primary_shards: 6，
active_shards: 6，
“活动碎片百分比数量”:50.0
cluster_name: sharkyun ，
"延迟_未分配_碎片":0,
正在初始化_shards: 0，
数据节点数:1,
"飞行中取货数量":0,
节点数:1,
挂起任务数:0,
重定位_碎片:0,
状态：黄色，
task _ max _ waiting _ in _ queue _ millis :0，
timed_out: False，
未分配的碎片数:6}
获取当前连接的集群节点信息In [43]: es.cluster.client.info()
获取集群目前所有的索引在[55]中：打印。猫。索引())
黄色开放日志隐藏-2017。11 .04 zt2k 7k 0 yrzaiwmesz 9 H3 da 5 1 301000 0 162.3 MB 162.3 MB
黄色开放。基巴纳1 EPB 3 npfrimfjorwkhtxig 1 1 2 0 13.4 kb 13.4 kb
获取集群的更多信息es.cluster.stats()
利用实例的猫属性得到更简单易读的信息In [85]: es.cat.health()
out[85]: 1510431262 04:14:22 sharkyun yellow 1 1 6 6 0 0 6 0-50.0% \ n
In [86]: es.cat.master()
out[86]: vxgfbkaattgo 5a 1 qafdclw 172。16 .153 .129 172 .16 .153 .129主机\n
In [87]: es.cat.nodes()
出[87]: 172。16 .153 . 129 27 49 0 0.02 0.01 0.00 MDI *主\ n
在[88]:es。猫。索引()
Out[88]:黄开日志隐藏-2017。11 .04 ZT 2k 7k 0 yrzaiwmesz 9 H3 da 5 1 301000 0 162.3 MB 162.3 MB \ n允许打开。基巴纳1 EPB 3 npfrimfjorwkhtxig 1 1 2 0 13.4 kb 13.4 kb \ n
In [89]: es.cat.count()
out[89]: 1510431323 04:15:23 301002 \ n
In [90]: es.cat.plugins()
Out[90]:
In [91]: es.cat.templates()
out[91]: log stash log stash-* 0 50001 \ nfilebeat filebeat-* 0 \ n
任务es.tasks.get()
es.tasks.list()
查询发送查询请求es=Elasticsearch(
[172.16.153.129:9200]
)
response=es.search(
index=logstash-2017.11.14 ，#索引名
body={ #请求体
查询:{ #关键字，把查询语句给询问
bool: { #关键字，表示使用过滤器查询，没有匹配度
必须:[ #表示里面的条件必须匹配，多个匹配元素可以放在列表里
{
匹配:{ #关键字，表示需要匹配的元素
TransId : 06100021650016153 # TransId是字段名， 06100021650016153 是此字段需要匹配到的值
}
},
{
匹配:{
Ds: 2017-05-06
}
},
{
匹配:{
Gy: 2012020235
}
}, ],
must_not: { #关键字，表示查询的结果里必须不匹配里面的元素
匹配:{ #关键字
消息： M( #消息字段名，这个字段的值一般是查询到的结果内容体。这里的意思是，返回的结果里不能包含特殊字符m(
}
}
}
},
#下面是继续对返回的结果进行排序。
sort :[{ @ timestamp :{ order : desc } }]，
From: start，#返回匹配结果的数据，值是匹配数据的下标，从0开始。
Size: size #返回多少条数据？
}
)
返回的结果总数=res [hits] [total]
循环结果以获得所需的内容res_dict={}
对于搜索中的命中[hits][hits]:
log_time=%s%s %(点击[_source][Ds]，点击[_source][Us])
RES _ dict[log _ time]= % s % s % s % s %(点击[ _ source ][ beat ][ hostname ]，点击[_source][FileName]，点击[_source][FileNum]，点击[_source][Messager])
查询日志信息query_body={
bool: {
must _ not :{ match :{ message : M( } }，
必须:[
{ match :{ TransId : 06100021650016153 } }，
{ range :{ @ timestamp :{ GTE :u now-7d ， lte: now}}
]
}
}res=es.search(
index=logstash-2017.11.14 ，
body={
query: query_body，
sort :[{ @ timestamp :{ order : desc } }]})
}
)
高级elasticsearch_dsl模块官网
尝试单字段查询es=Elasticsearch(
[172.16.153.129:9200]
)
s=搜索(使用=es，
index=logstash-2017.11.14 )。过滤器(匹配，Gy=20160521491 )。查询( match ，TransId=06100021650016153 )。排除(匹配，消息=M()
response=s.execute()
使用
使用连接对象。
询问
收到查询体语句。
排除
收到的不匹配字段像must_not。
过滤器
接收到的是过滤语句。过滤条件是指返回结果中包含这些条件的信息统计结果s.count()的总数。
response=sexecute()
回应.点击.总数
Get res_dict={}
对于在s中命中：
log_time=%s%s %(命中。Ds，打。美国’)
RES _ dict[log _ time]= % s % s % s % s %(hit . beat[ hostname ]，hit。文件名，点击。FileNum，点击。信使)
连接有几种方法可以配置库的连接。
最简单也是最有用的选择是定义一个默认连接，每次调用API时都会用到它，而不需要显式传递其他连接。
除非您想从一个应用程序访问多个集群，否则强烈建议您使用这个create_connection方法创建一个默认连接，该连接将被所有操作自动使用。
显式传递连接。如果不想提供全局配置(即默认连接)，可以传入自己的连接(instance elasticsearch。Elasticsearch)作为参数，并使用以下命令接受它：
s=Search(使用=Elasticsearch(localhost ))
您甚至可以通过以下方式覆盖对象关联的任何连接。
s=s . using(elastic search( other host:9200 ))
链接默认连接
要定义供全局使用的默认连接，请使用connections模块和create_connection方法：
从elasticsearch_dsl.connections导入连接
client=connections . create _ connection(hosts=[ 172 . 16 . 153 . 129:9200 ]，
http_auth=(elastic ， changeme )，timeout=20)
您不必传递连接对象来进行搜索。s=search(index= log stash-2017 . 11 . 14 )。过滤器(匹配，gy= 20160521491 )。查询(匹配，transid= 0610021650016153 )
在多集群环境中连接多个集群
您可以使用以下配置方法同时定义到多个集群的多个连接：
从elasticsearch_dsl.connections导入连接
客户端=连接.配置(
默认值={hosts: localhost}，
dev={
hosts :[ es dev 1 . example . com:9200 ]，
sniff_on_start :真
}
)
上述情况适用于第一个连接。
如果您有要传递给弹性搜索的配置，请运行setup connection #。_ _ init _ _
#将配置信息直接传递给Elasticsearch
connections . create _ connection( QA ，hosts=[ eska 1 . example . com ]，sniff_on_start=True)
#如果您已经准备好了一个Elasticsearch实例
#附加已经准备好的连接对象
connections.add_connection(qa ，my_client)
使用连接对象的别名使用多个连接时，可以通过使用下面注册的字符串别名来引用它们：
s=搜索(使用=qa )
如果在这个别名下没有注册的连接，将抛出KeyError异常。错误：“没有与别名‘QA’的连接。”Searchdsl此搜索对象
此搜索对象代表整个搜索请求：
查询、过滤器、聚集、排序、分页、附加参数和相关联的客户端)API被设计为可链接的。除了聚合功能之外，这意味着搜索对象是不可变的(对对象的所有更改都将导致创建(复制)包含更改的副本)。这意味着您可以安全地将搜索对象传递给外部代码，而不用担心该对象会被修改。
实例化一个对象时，可以通过一个低级的elasticSearch客户端实例搜索：
从弹性搜索导入弹性搜索
从elasticsearch_dsl导入搜索
client=Elasticsearch()
S=Search(using=client)==所有方法都将返回一个对象的副本，该副本可以安全地传递给外部代码。==
API是可连接的，允许你在一个语句中调用多个方法：s=Search()。使用(客户端)。Query (match ，title= python )向Elasticsearch:s.execute()发送请求如果只想遍历搜索返回的匹配项，可以遍历这个搜索对象：for hit in s:
print(log_time=%s%s %(命中。Ds，打。美国))
Print (hit.beat [主机名]，hit。filename，hit.filenum，hit.messager) ds，US，beat，FileName等。都是映射的字段名，是elasticsearch模块的search方法得到的结果中命中[_source]的内容。
搜索结果将被缓存。后续调用execute或尝试遍历已执行的搜索对象将不会触发发送到Elasticsearch的额外请求。指定ignore_cache=True以在请求时调用execute。
这个搜索对象也可以转换成之前的查询DSL格式s.to_dict()来查询Elasticsearch_dsl的查询类，为所有Elasticsearch查询类型提供类。将所有参数作为关键参数传递。这些类接受任何关键字参数，然后dsl将传递给构造函数的所有参数序列化为结果字典中的顶级关键字(所以生成的json发送给elasticsearch)。这意味着在原始查询和它在DSL中的对等查询之间存在明确的一对一映射：
从elasticsearch_dsl.query导入多匹配，匹配
# { multi _ match :{ query : python django ， fields: [title ， body]}}
多匹配(query=python django ，fields=[title ， body])
# { 匹配:{ 标题:{ 查询: web框架，类型:短语 }}}
match(title={ query : web framework ， type: phrase})==在某些情况下，由于python对标识符的限制，该方法不支持字段中的特殊字符，例如：@timestamp。==
在这种情况下，您必须使用原始的字典形式：range(* * { @ timestamp :{ lt : now } })
功能强大的Q你可以使用Q快捷方式把带参数名的dict或者原始数据构建成相应类的Search的实例：From Elastic Search _ DSL Import Q。
Q(multi_match ，query=python django ，fields=[title ， body])
q({ multi _ match :{ query : python django ， fields: [title ， body]})
#这两种方法的最终转换结果是一致的。
Multi (fields=[title ， body]，query= Python Django )要向搜索对象添加查询，请使用以下代码。query()方法：q=q (multi _ match ，query= Python Django ，fields=[title ， body 。
S=s.query(q)当然Q接收的参数，以及查询方法都支持S=S. query (multi _ match ，query= Python Django ，fields=[title ， body])实现与Q的组合查询。
可以使用逻辑运算符组合对象：Q (match ，title= python) Q (match ，title= django )
# {bool: {should: [.]}}
#只匹配任何条件。
Q(match ，title=python) Q(match ，title=django )
# {bool: {must: [.]}}
#列表中的条件必须同时匹配
~Q(match ，title=python )
# {bool: {must_not: [.]}}
# query method，另一种不实现组合查询的方法，可以连续调用
In [193]: sa=Search().查询()。查询( match ，title=python ).查询(" match "，body="django ")
In [194]: sa.to_dict()
Out[194]:
{
查询:{
bool: {
必须:[
{ 匹配:{
标题： python}
},
{ 匹配:{
body: django}
}
]
}
}
}假如你希望对查询的条件进行精确的控制，请使用Q构造组合查询：q=Q(bool ，
must=[Q(match ，title=python)]，
should=[Q(.),问（.)],
最小值应该匹配=1
)
s=Search().查询(问)过滤器过滤请使用过滤器方法
s=搜索()
s=s.filter(terms ，tags=[search ， python])
# { query :{ bool :{ filter :[{ terms :{ tags :[ search ， python ]} } }在幕后，这将产生一个弯曲件查询并将指定的条款查询放入其过滤器分支，使其等价于：
s=搜索()
s=s.query(bool ，filter=[Q(terms ，tags=[search ， python])])
# { query :{ bool :{ filter :[{ terms :{ tags :[ search ， python ]} }==下面没搞懂==
如果您想使用后置过滤器元素进行分面导航，请使用该。后置过滤器()方法。
你也可以用排除()排除查询项目：
s=搜索()
s=s.exclude(terms ，tags=[search ， python])官网上说下面是简写，简直不敢相信
s=s.query(bool ，filter=[~Q(terms ，tags=[search ， python])])聚合定义一个聚合，请使用A
A(terms ，field=tags )
# {terms: {field: tags}}嵌套聚合，可以使用桶()，公制()和。管道()方法：a=A("术语",字段="类别")
# { terms :{ field : category } }
a.metric(clicks_per_category ， sum ，field=clicks)\。bucket(tags_per_category ， terms ，field=tags )
# {
# 术语:{ 字段:类别 },
# aggs: {
# 点击次数/类别:{ 总和:{ 字段:点击次数 }},
# tags _ per _ category :{ terms :{ field : tags } }
# }
# }要将聚合添加到搜索对象，请使用。抗气性坏疽血清充当顶级聚合的属性s=搜索()
a=A(“术语",字段="类别")
s.aggs.bucket(category_terms ，a)
# {
# aggs: {
# 类别术语:
# 条款:{
# 字段:类别
# }
# }
# }
# }或者下面这样的，有点儿变态
s=搜索()
s。aggs。bucket(每日文章，日期直方图，字段=发布日期，间隔=天)\。度量值(每天点击次数,总和，字段=点击次数)\。管道( moving_click_average ， moving_avg ，buckets _ path= clicks _ per _ day )\。bucket(tags_per_day ， terms ，field=tags )
s.to_dict()
# {
# aggs: {
# 每日文章数:{
# 日期直方图:{ 间隔:日,字段:发布日期 },
# aggs: {
# 每天点击次数:{ 总和:{ 字段:点击次数 } },
# 移动点击平均:{ 移动平均:{ 桶路径:每天点击次数 } }，
# tags _ per _ day :{ terms :{ field : tags } }
# }
# }
# }
# }您可以通过名称访问现有存储桶s=搜索()
s.aggs.bucket(per_category ， terms ，field=category )
s.aggs[per_category].度量值(点击次数/类别,总和，字段=点击次数)
s.aggs[per_category].bucket(tags_per_category ， terms ，field=tags)==当链接多个聚合时，什么。桶()和。公制()方法返回之间是有区别的==
==.桶()返回新定义的存储区，同时。公制()返回其父容器以允许进一步链接。==
==与搜索对象上的其他方法相反，定义聚合是在原地完成的（不返回副本)。==
排序要指定排序顺序，请使用。排序()方法：
s=Search().排序（
类别，
-标题，
{lines : {order : asc ， mode : avg}}
)==它接受可以是字符串或字典的位置参数。字符串值是一个字段名称，可以用-符号前缀来指定降序。==
恢复排序使用无参的排序()方法s=s.sort()分页要指定从/尺寸参数，请使用计算机编程语言切片美国联合通讯社(美联社)
s=s[10:20]
# { 从:10,大小:10}如果要访问与查询匹配的所有文档，可以使用扫描使用扫描/滚动弹性搜索应用程序接口的方法对于扫描()中的命中：
print(hit.title)==请注意，在这种情况下，结果将不会被排序。==
Highlight若要设置突出显示的通用属性，请使用以下highlight_options方法：s=s . highlight _ options(order= score )为每个字段启用突出显示。使用以下突出显示方法：s=s.highlight(title )
#或，包括参数：
s=s.highlight (title ，fragment _ size=50)返回的结果将在分配给一个对象(变量)时可用，meta.highlight.FIELD将包含一个结果列表：response=s.execute()
对于响应中的点击：
对于hit.meta.highlight.title中的片段：
打印(片段)建议建议==这部分没看懂，需要研究==
要在搜索对象上指定建议请求，请使用以下建议方法：
S=s.suggestion (my _ suggestion ， pyhton ，term={field: title})。第一个参数是建议名称(它将返回的名称)，第二个参数是您希望建议处理的实际文本。关键字参数将被添加到建议的json中，这意味着它应该是term、phrase之一。
如果您只想运行搜索的建议部分(通过_suggest端点)，您可以通过execute_suggest以下列方式执行：
s=s.suggest(my_suggestion ， pyhton ，term={field: title})
suggestions=s.execute_suggest()
print(suggestions . my _ suggestions)额外的属性和参数要设置搜索请求的额外属性，请使用。extra()方法。这可用于定义不能通过特定API方法限定主题的关键字explain或search _ after:s=s . extra(explain=true)。要设置查询参数，请使用以下命令。params()方法：s=s.params(search_type=count )。如果您需要限制elasticsearch返回的字段，请使用以下内容
s=s.source([title ， body])
#不返回任何字段，只返回元数据
s=s.source(假)
#显式包含/排除字段
s=s.source(包含=[title]，排除=[user。*])
#重置字段选择
S=s.source(None)序列化和反序列化搜索对象可以使用。to_dict()方法。
也可以使用。搜索类的from_dict()方法。
这将创建一个新的对象，并用字典中的数据填充它。
s=search . from _ dict({ query :{ match :{ title : python } })如果要修改现有的搜索对象并重写其属性，可以使用此实例的update_from_dict()方法，更改会实时生效：
In [2]: s=Search()
In [4]: s.to_dict()
out[4]:{ query :{ match _ all :{ } } }
in[5]:s . update _ from _ dict({ query :{ match :{ title : python } }， size: 42}
. )
Out[5]:
In [6]: s.to_dict()
out[6]:{ query :{ match :{ title : python } }， size: 42}返回结果可以通过调用。搜索对象的execute()方法，之后将返回一个响应对象。
您可以将这个返回的对象(结果)分配给一个对象。
响应对象允许您通过属性访问来访问响应对象字典中的任何键(即。).
它还提供了一些方便的助手：
response=s.execute()
print(response.success())
#成功了吗？
#真的
打印(response.took)
点击数
# 12
打印(响应.点击.总数)
print(response . suggestion . my _ suggestions)如果要检查response对象的内容，只需要使用它的to_dict方法访问原始数据并打印出来即可。
要访问搜索返回的匹配对象，请访问Hits属性或只遍历响应对象：
response=s.execute()
打印(总共找到%d个匹配项。% response.hits.total
对于h的回答：
Print(h.title，h.body)结果被包装在一个方便的类中，带有单独的命中，允许属性访问返回的字典中的键。结果的所有元数据都可以通过meta(没有下划线开头_)访问：
response=s.execute()
h=response.hits[0]
print(/%s/%s/%s以分数%f %(
H.meta.index，h.meta.doc _ type，h.meta.id，h.meta.score))响应=s.执行()
H=响应。点击[0]
Print (/%s/%s/%s)和score return% f%(。袁。索引，袁。文件类型，.袁。身份证，.袁。分数))
注意
==如果刚好文档中有一个字段叫meta，可以使用字典的键方法来访问它：点击[meta]。==
聚合聚合可通过聚集属性获得：
对于回应。聚合。每个标签。大量中的标记：
print(tag.key，tag.max_lines.value)多重搜索如果您需要同时执行多个搜索，则可以使用多重搜索类，这将使用该类的_msearch API:
从elasticsearch_dsl导入多重搜索，搜索
ms=MultiSearch(index=blogs )
ms=ms.add(Search().过滤器( term ，tags=python ))
ms=ms.add(Search().过滤器( term ，tags=elasticsearch ))
responses=ms.execute()
对于回复中的回复：
打印(查询% r . %响应。搜索。询问的结果)
对于响应中的点击：
打印（点击标题)持久化映射您可以使用深散射层库为应用程序定义映射和基本的持久层。映射定义遵循与查询深散射层类似的模式：
从elasticsearch_dsl导入关键字，映射，嵌套，文本
#说出你的类型
m=映射("我的类型")
#添加字段
m.field(标题,文本)
#您可以轻松使用多字段
m.field(category ， text ，fields={raw: Keyword()})
#您也可以手动创建字段
comment=Nested()
comment.field(author ，Text())
comment.field(created_at ，Date())
#并将其附加到映射中
m.field(注释，注释)
#您还可以为元字段定义映射
m.meta(_all ，enabled=False)
#将映射保存到索引"我的索引"中
m.save(my-index)==注意==
默认情况下，所有的字段（除了嵌套)都会有单个值。
您可以在创建/定义字段期间，通过向构造函数传入multi=True(m.field(tags ，Keyword(multi=True)))来始终覆盖此期望值。
那么，即使字段没有被设置，字段的值也将是一个空的列表，使您能够写入。
doc.tags.append(搜索)
特别是如果您使用动态映射，则可以根据弹性搜索中的现有类型更新映射，或直接从现有类型创建映射：#从我们的生产集群获取映射
m=Mapping.from_es(my-index ， my-type ，using=prod )
#根据质量保证集群中的数据进行更新
m.update_from_es(my-index ，using=qa )
#更新生产映射
# 在生产上更新映射
m.save(my-index ，using=prod )常用字段选项：多
如果设置真实的为该字段的值将被设置为[]第一次访问。
需要
指示字段是否需要文档的有效值。
分析要指定字段的分析者值，文本您可以使用分析仪的名称（作为字符串),并依靠定义的分析仪（如内置分析仪)或手动定义分析仪。
或者，您可以创建自己的分析器并让持久层处理其创建：
来自elasticsearch_dsl导入分析器，标记器
我的分析器=分析器(我的分析器),
tokenizer=tokenizer(trigram ， nGram ，min_gram=3，max_gram=3)，
过滤器=[小写]
)每个分析对象需要有一个名字（我的_分析仪和三线形在我们的例子)和断词，令牌过滤器和过滤器炭还需要指定类型(nGram在我们的例子)。
==在创建依赖于自定义分析器的映射时，索引必须不存在或被关闭。要创建多个文档类型定义的映射，您可以使用索引对象==
文档类型如果你想在你的文档中创建一个类似于模型的包装，请使用文档类型类：
从日期时间导入日期时间
从elasticsearch_dsl导入文档类型，日期，嵌套，布尔，\
分析器，InnerObjectWrapper，完成，关键字，文本
html _ strip=analyzer( html _ strip ，
标记器=标准，
过滤器=[标准,小写,停止,雪球],
char_filter=[html_strip]
)
类注释(InnerObjectWrapper):
定义年龄（自己):
返回日期时间。现在()-自我。创建于
类别发布（文档类型):
title=Text()
title_suggest=Completion()
created_at=Date()
发布=布尔值()
类别=文本（
分析器=html_strip，
fields={raw: Keyword()}
)
注释=嵌套（
doc_ properties={
作者:文本(fields={raw: Keyword()})，
内容:文本(分析器=雪球),
"创建时间":日期()
}
)
类别元：
索引=博客
定义添加注释(自己，作者，内容):
自我.评论.附加
{ 作者：作者，内容：内容})
def save(self，** kwargs):
self.created_at=datetime.now()
返回超级().保存(**夸拉)文档生命周期（记录生命周期)在首次使用邮政文档类型之前，您需要在弹性搜索中创建映射。为此，您可以使用索引对象或通过调用初始化类方法直接创建映射：
#在弹性搜索中创建映射
Post.init()要创建一个新邮政文档只需实例化这个类并传入你想要设置的任何字段，就可以使用标准属性设置来改变/添加更多的字段。请注意，您不限于显式定义的字段：
#实例化文档
first=Post(title=我的第一篇博客帖子，耶!,已发布=真)
#分配一些字段值，可以是值或值列表
first.category=[万物,虚无]
#每个文档在元中都有一个编号
first.meta.id=47
#将文档保存到集群中
first.save()所有的元数据字段(id，父，路由，索引等等)可以被访问（和设置)。
通过自指的属性或直接用下划线变体访问它们：
post=Post(meta={id: 42})
#打印42,与邮政相同. id
打印(post.meta.id)
#覆盖默认索引，与邮政相同。_索引
post.meta.index=我的博客来检索（检索，得到)现有文档使用得到类方法：#检索文档
first=Post.get(id=42)
#现在我们可以调用方法，更改字段，
first.add_comment(我,这很好!)
#并将更改再次保存到集群中
first.save()
#您还可以（也)只更新将调用更新应用程序接口的单个字段
#还有（并且)就地更新文档（首先)
first.update(published=True，published_by=me )如果在弹性搜索中没有找到该文档，则出现异常(弹性搜索.NotFoundError)将被引发。如果您希望返回没有，只需传入忽略=404来隐藏异常：p=Post.get(id=not-in-es ，ignore=404)
p是零当您想要同时检索多个文档时，id您可以使用以下文件列表方法：posts=Post.mget([42，47，256])mgetNotFoundError如果有任何文件没有找到，并且请求错误文件中有任何内容导致错误，将会默认提出。您可以通过设置参数来控制此行为：
引发错误
如果真（默认),那么任何错误都会引发异常。否则，包含错误的所有文档将被视为丢失。
错过
可以有三个可能的值：(无默认)养和跳过。如果文档丢失或出错，将被替换为没有，将引发异常或文档将完全跳过。所有有关的信息DocType，包括它的信息绘图都可以通过_doc_type类的属性来访问：
#弹性搜索中类型和索引的名称
贴吧.文档类型名称
贴吧. doc_type.index
#原始映射对象
# 原始映射对象
贴吧. doc_type.mapping
#父类型的可选名称（如果已定义)
# 父类型的可选名称（如果已定义)
贴吧. doc _ type.parentThe属性也是恢复精神方法的宿主，该方法将更新弹性搜索中文档类型上的映射。_文档_类型
e 属性也是可以通过 refresh 方法来更新elasticsearch的DocType上的映射。假如你使用的是动态映射，并希望类知道这些字段，（比如，你希望日期字段能被正确的序列化）你这样将会是很有用的：
Post._doc_type.refresh()To delete a document just call its delete method:first = Post.get(id=42)
first.delete()SearchTo search for this document type, use the search class method:
# by calling .search we get back a standard Search object
# 通过调用 .search()， 我们得到一个标准的搜索对象
s = Post.search()
# the search is already limited to the index and doc_type of our document
s = s.filter(term, published=True).query(match, title=first)
results = s.execute()
# when you execute the search the results are wrapped in your document class (Post)
for post in results:
print(post.meta.score, post.title)或者，您可以只取一个Search对象，并限制它返回我们的文档类型，用正确的类包装：s = Search()
s = s.doc_type(Post)您也可以将文档类与标准文档类型（只是字符串）结合起来，这将像以前一样处理。您也可以传入多个DocType 子类，响应中的每个文档将被包装在它的类中。If you want to run suggestions, just use the suggest method on the Search object:
s = Post.search()
s = s.suggest(title_suggestions, pyth, completion={field: title_suggest})
# you can even execute just the suggestions via the _suggest API
suggestions = s.execute_suggest()
for result in suggestions.title_suggestions:
print(Suggestions for %s: % result.text)
for option in result.options:
print( %s (%r) % (option.text, option.payload))class Meta 选项在Meta文档定义的类中，您可以为文档定义各种元数据：
doc_type
elasticsearch中的doc_type的名称。默认情况下，它将从类名（MyDocument - my_document）
index
文档的默认索引，默认情况下它是空的，并且每个操作（比如get或save需要一个明确的index参数）
using
默认使用的连接别名，默认为 default
mapping
Mapping类的可选实例，用作从文档类本身上的字段创建的映射的基础。
在任何属性Meta是的实例类MetaField将被用于控制元字段（的映射_all，_parent等等）。只需将参数（不带前导下划线）命名为要映射的字段并将任何参数传递给MetaField类：
class Post(DocType):
title = Text()
class Meta:
all = MetaField(enabled=False)
parent = MetaField(type=blog)
dynamic = MetaField(strict)索引(Index)Index是一个类，负责在elasticsearch映射和设置中保存与索引有关的所有元数据。
在定义 index 时最为有用，因为它允许同时轻松创建多个 index。在迁移中设置弹性搜索对象时，这非常有用：
from elasticsearch_dsl import Index, DocType, Text, analyzer
blogs = Index(blogs)
# define custom settings
blogs.settings(
number_of_shards=1,
number_of_replicas=0
)
# define aliases
blogs.aliases(
old_blogs={}
)
# register a doc_type with the index
blogs.doc_type(Post)
# can also be used as class decorator when defining the DocType
@blogs.doc_type
class Post(DocType):
title = Text()
# You can attach custom analyzers to the index
html_strip = analyzer(html_strip,
tokenizer="standard",
filter=["standard", "lowercase", "stop", "snowball"],
char_filter=["html_strip"]
)
blogs.analyzer(html_strip)
# delete the index, ignore if it doesnt exist
blogs.delete(ignore=404)
# create the index in elasticsearch
blogs.create()您还可以为您的索引设置模板，并使用该clone方法创建特定的副本：blogs = Index(blogs, using=production)
blogs.settings(number_of_shards=2)
blogs.doc_type(Post)
# create a copy of the index with different name
company_blogs = blogs.clone(company-blogs)
# create a different copy on different cluster
dev_blogs = blogs.clone(blogs, using=dev)
# and change its settings
dev_blogs.setting(number_of_shards=1)
©
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。