类型 字符串
ELasticsearch 5.x 之后的字段类型不再支持 string，由 text 或 keyword 取代
text类型
1 2 3 4 5 { "title" : { "type" : "text" } }
keyword类型
1 2 3 4 5 { "companyName" : { "type" : "text" } }
数值型
类型
区域
整型
byte、short、integer、long
浮点型
float、half_float、scaled_float、double
类型
取值范围
long
-263至263-1
integer
-231至231-1
short
-32768 至 32768
byte
-128 至 127
double
64位双精度IEEE 754浮点类型
float
32位单精度IEEE 754浮点类型
half_float
16位半精度IEEE 754浮点类型
scaled_float
缩放类型的的浮点数（比如价格只需要精确到分，price为57.34的字段缩放因子为100，存起来就是5734）
对于float、half_float和 scaled_float, -0.0 和 +0.0 是不同的值，使用 term 查询查找 -0.0 不会匹配 +0.0，同样range查询中上边界是 -0.0 不会匹配 +0.0，下边界是 +0.0 不会匹配 -0.0 。
在满足需求的情况下，尽可能选择范围小的数据类型。比如，某个字段的取值最大值不会超过100，那么选择byte类型即可。迄今为止吉尼斯记录的人类的年龄的最大值为134岁，对于年龄字段，short 足矣。字段的长度越短，索引和搜索的效率越高。
优先考虑使用带缩放因子的浮点类型。1 2 3 4 5 6 7 8 9 10 11 12 { "number_of_bytes" : { "type" : "integer" } , "time_in_seconds" : { "type" : "float" } , "price" : { "type" : "scaled_float" , "scaling_factor" : 100 } }
日期类型 date
日期格式的字符串：e.g. 2015-01-01 or 2015/01/01 12:10:30.
long 类型的毫秒数( milliseconds-since-the-epoch)
integer 的秒数(seconds-since-the-epoch)1 2 3 4 5 { "create_date" : { "type" : "date" } }
范围型
类型
范围
integer_range
-231至231-1
float_range
32-bit IEEE 754
long_range
-263至263-1
double_range
64-bit IEEE 754
date_range
64位整数，毫秒计时
1 2 3 4 5 6 7 8 9 { "age_limit" : { "type" : "integer_range" } , "time_frame" : { "type" : "date_range" , "format" : "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis" } }
布尔 boolean true、false
1 2 3 4 5 { "is_stop" : { "type" : "boolean" } }
二进制 binary 会把值当做经过 base64 编码的字符串，默认不存储，且不可搜索
1 2 3 4 5 { "img_head" : { "type" : "binary" } }
复杂数据类型 对象 object 对象，一个对象中可以嵌套对象。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 { "age" : { "type" : "integer" } , "name" : { "properties" : { "first" : { "type" : "text" } , "last" : { "type" : "text" } } } }
数组 ELasticsearch没有专用的数组类型，默认情况下任何字段都可以包含一个或者多个值，但是一个数组中的值要是同一种类型。例如：
字符数组: ["one","two"]
整型数组：[1,3]
嵌套数组：[1,[2,3]] 等价于[1,2,3]
对象数组：[{"name":"Mary","age":12}, {"name":"John","age":10}]
注意事项：
动态添加数据时，数组的第一个值的类型决定整个数组的类型
混合数组类型是不支持的，比如：[1,"abc"]
数组可以包含null值，空数组[]会被当做missing field对待。
专用数据类型 IP ip类型的字段用于存储IPV4或者IPV6的地址
1 2 3 4 5 { "ip" : { "type" : "ip" } }
nested类型 nested嵌套类型是object中的一个特例，可以让array类型的Object独立索引和查询。
1 2 3 4 5 { "title" : { "type" : "nested" } }
token_count类型 token_count用于统计词频：
1 2 3 4 5 6 { "view_count" : { "type" : "token_count" , "analyzer" : "standard" } }
geo point 类型 地理位置信息类型用于存储地理位置信息的经纬度：
1 2 3 4 5 { "location" : { "type" : "geo_point" } }
GET _search - 搜索 查询表达式 QueryDSL 最简单的搜索命令，不指定索引和类型的空搜索，它将返回集群下所有索引的所有文档（默认显示10条）
1 2 3 4 5 6 7 8 9 10 GET /_search ---- 等价于 ---- GET /_search { "query": { "match_all": {} } }
搜索语法 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 # 查询语句结构 { QUERY_NAME: { ARGUMENT: VALUE, ARGUMENT: VALUE,... } } # 针对某个字段的查询 { QUERY_NAME: { FIELD_NAME: { ARGUMENT: VALUE, ARGUMENT: VALUE,... } } }
复合查询 再复杂的查询语句，也是由一个一个的查询条件叠加而成的，查询语句有两种形式：
叶子语句：单个条件组成的语句，如match语句，类似mysql的"id = 1"这种。
复合语句：有多个条件，需要合并在一起才能组成一个完整的语句，需要使用bool进行组合，里面的条件可以用must必须匹配、must not必须不匹配、should可以匹配修饰，也可以包含过滤器filter, 类似mysql的"(status = 1 && language != 'french' && (author = 'John' || author = 'Tom'))"这种
举个例子 :
1 2 3 4 5 6 7 8 { "bool": { "must": { "match": { "status": 1 }}, "must_not": { "match": { "language": "french" }}, "should": { "match": { "author": "John Tom" }}, "filter": { "range": { "length" : { "gt" : 30 }} } } }
复合语句可以嵌套，来实现更复杂的查询需求，在上面的例子上简单延伸一下：
1 2 3 4 5 6 7 8 9 10 11 12 "bool": { "must": { "match": { "status": 1 }}, "must_not": { "match": { "language": "french" }}, "should": [ {"match": { "author": "John Tom" }}, {"bool": { "must": { "match": { "name": "friend" }}, "must_not": { "match": { "content": "star" }} }} ], "filter": { "range": { "length" : { "gt" : 30 }} } }
相关性分数计算 每一个子查询都独自地计算文档的相关性得分。一旦他们的得分被计算出来，bool 查询就将这些得分进行合并并且返回一个代表整个布尔操作的得分，得分高的显示在前面，filter内的条件不参与分数计算
过滤器 filter
仅按照搜索条件把需要的数据筛选出来，不计算相关度分数。
匹配条件的数据，会根据搜索条件的相关度，计算每个document的分数，然后按照分数进行排序，这个才是全文搜索的情况。
filter只做过滤，不作排序，并且会缓存结果到内存中，性能非常高。query匹配条件，要做评分，没有缓存，性能要低一些。
filter 一个非常重要的作用就是减少不相关数据对 query 的影响，提升 query 的性能，二者常常搭配在一起使用。组合使用的时候，把期望符合条件的document 的搜索条件放在 query 里，把要滤掉的条件放在filter里
多个索引查询 1 GET index1,index2/_search
基础参数 不传递参数则返回所有数据
from - 查询起始位置 相当于 mysql 查询的 limit
size - 查询数量 相当于mysql 查询的 offset
1 2 3 4 5 6 # from,size从指定位置开始返回指定数量的记录 GET {index}/_search { "from": 5, "size": 5 }
sort 对结果进行排序 对查询结果按字段进行排序，desc 降序，asc 升序
1 2 3 4 5 6 7 8 9 10 GET {index}/_search { "sort": [ { "price": { "order": "desc" } } ] }
_source 返回字段 使用 _source 返回自定义的字段
1 2 3 4 GET {index}/_search { "_source": ["id", "title"] }
query 查询 match_all 查询 查询简单的匹配所有文档
1 2 3 4 5 6 GET /_search { "query": { "match_all": {} } }
match 匹配 match 匹配查询，直接匹配目标字符串，不做分词处理
1 2 3 4 5 6 7 8 GET {index}/_search { "query": { "match": { "author": "多厘" } } }
需要注意索引内是否分词, 如果索引内已经分词, 这里的match 遵循分词进行全文搜索
1 2 3 4 5 6 7 8 # 全文搜索例子 { "match": { "content": "寒食" }} # 精确搜索 { "match": { "likes": 15 }} { "match": { "date": "2019-12-05" }} { "match": { "isOwner": true }} { "match": { "keyword": "love you" }}
range 范围 查询指定区间内的数字或时间, query 和 filter 都支持, 一般是 filter 使用的多, 允许的操作符如下
gt 大于
gte 大于或等于
lt 小于
lte 小于或等于1 2 3 4 5 6 7 8 9 10 11 GET {index}/_search { "query": { "range": { "stock": { "gte": 1, "lte": 3 } } } }
term 查询 用于精确值匹配, 精确值可以是数字, 日期, boolean 或 keyword 类型的字符串
1 2 3 4 { "term": { "likes" : 15 }} { "term": { "date" : "2019-12-05"}} { "term": { "isOwner": true }} { "term": { "keyword": "love you" }}
建立索引时 mapping 设置为 not_analyzed 时，match 等同于 term，用得多的是 match 和 range
terms 多对象匹配, 对象之间是或关系 terms则是可以输入多个对象来匹配，对象之间是或关系
1 2 3 4 5 6 7 8 9 10 GET {index}/_search { "query":{ "terms":{ "author" :[ "李春梅", "柏桂兰" ] } } }
match_phrase(todo) 作为输入短语来进行匹配 1 2 3 4 5 6 7 8 GET {index}/_search { "query":{ "match_phrase":{ "title" :"梅" } } }
multi_match 从多个字段中去匹配查询目标 这里的匹配是精准匹配, 也就是 = 匹配
1 2 3 4 5 6 7 8 9 GET {index}/_search { "query":{ "multi_match":{ "query" :"多厘", "fields" : ["title", "description"] } } }
query_string 字串之间使用 AND 和 OR 连接 针对字符串的查询，字符串之间用AND和OR连接
1 2 3 4 5 6 7 8 9 10 GET {index}/_search { "query":{ "query_string": { "default_field": "FIELD", "query": "this AND that OR thus" "default_operator": "OR" } } }
simple_query_string 针对在多个字段中查找目标 这里是精准匹配, default_operator是在多个字段中采用什么样的查询操作
1 2 3 4 5 6 7 8 9 10 GET {index}/_search { "query":{ "simple_query_string": { "query": "多厘", "fields": ["title", "description"], "default_operator": "OR" } } }
wildcard 使用通配符来查询 这个通配符相当于 sql 查询中 like 的 %
1 2 3 4 5 6 7 8 9 10 GET {index}/_search { "query": { "wildcard": { "title": { "value": "*婷*" } } } }
constant_score 非相关性, 查询数据缓存 不进行相关性算分，并把查询的数据进行缓存，提升效率, 因为 must 等非 filter 查询会对文档进行分数的计算, 然后根据分数进行相关的排序, 所以这样的语句更简洁, 更清晰, 只是没有评分, 示例如下 :
1 2 3 4 5 6 7 8 9 10 11 12 13 GET {index}/_search { "query": { "constant_score": { "filter": { "match": { "title": "梅" } }, "boost": 1.0 } } }
注意 filter 内不支持 terms 语法
fuzzy(todo) 模糊查询, 按得分值降序
1 2 3 4 5 6 7 8 GET {index}/_search { "query": { "fuzzy": { "title": "梅" } } }
fuzzy&fuzziness 控制对模糊值的改变次数来匹配目标最终文档，fuzziness 的取值范围为0、1、2
1 2 3 4 5 6 7 8 9 GET {index}/_search { "query": { "fuzzy": { "value": "梅", "fuzziness": 1 } } }
组合查询 bool&must 多条件查询
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 GET {index}/_search { "query": { "bool": { "must": [ { "simple_query_string": { "query": "beautiful mind", "fields": ["title"] }}, { "range": { "year": { "gte": 1990, "lte": 1992 } } } ] } } }
bool&must&must not多条件查询
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 GET {index}/_search { "query": { "bool": { "must": [ { "simple_query_string": { "query": "beautiful mind", "fields": ["title"] }}, { "range": { "year": { "gte": 1990, "lte": 1992 } } } ] } } }
bool&filter筛选，和must差不多，支持多条件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 GET {index}/_search { "query": { "bool": { "filter": [ { "simple_query_string": { "query": "beautiful", "fields": ["title"] }}, { "range": { "year": { "gte": 1990, "lte": 1992 } } } ] } } }
bool&should多条件之间是或者的关系, should内是或的关系
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 GET {index}/_search { "query": { "bool": { "should": [ { "simple_query_string": { "query": "beautiful", "fields": ["title"] }}, { "range": { "year": { "gte": 1990, "lte": 1992 } } } ] } } }
agg 聚合查询 sum/avg/value_count/cardinality 查询
sum - 求和
avg - 平均数
value_count : 计数
cardinality : 非重复计数1 2 3 4 5 6 7 8 9 10 11 12 13 GET {index}/_search { "size": 0, # 只返回聚合结果，默认为20，返回20条原数据, 0 代表不返回条目数据 "aggs": { "FIELD_NAME": { # 求和后的字段名称 "sum": { "field": "price" } }, # 可以进行多个查询 .... } }
stats - 查看数据类型的数据最大最小平均值等描述性信息 返回上方所有的聚合结果，返回数据的描述性信息
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 GET {index}/_search { "aggs": { "{FIELD_NAME}": { # 自定义字段名称 "stats": { "field": "price" } } } } ------ { "aggregations" : { "{FIELD_NAME}" : { "count" : 25, "min" : 0.0, "max" : 8.72154882E8, "avg" : 6.267083224E7, "sum" : 1.566770806E9 } } }
terms 对 filed 中的每个类型进行分组并统计每个类型出现的次数，类似于 groupby 然后count 嵌套达到groupby两个或多个字段并count的效果
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 GET {index}/_search { "aggs": { "{FIELD_NAME}": { # 自定义字段名称 "terms": { "field": "author" } } } } -------- { "took" : 1, "timed_out" : false, "hits" : { "total" : { "value" : 2034, "relation" : "eq" }, "max_score" : null, "hits" : [ ] }, "aggregations" : { "authors" : { "doc_count_error_upper_bound" : 0, "sum_other_doc_count" : 2010, "buckets" : [ { "key" : "多厘", "doc_count" : 5 }, { "key" : "鞠正诚", "doc_count" : 3 }, ... { "key" : "屠晨", "doc_count" : 2 } ] } } }
(todo) terms&terms 嵌套达到 groupby 两个或多个字段并 count 的效果
未通过实验性数据达到学习的结果
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 GET {index}/_search { "size": 0, "aggs": { "NAME": { "terms": { "field": "title" }, "aggs": { "NAME": { "terms": { "field": "price" } } } } } }
terms & aggs & stats - groupby后返回每个bucket指定字段的统计信息 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 GET employee/_search { "size": 0, "aggs": { "NAME": { "terms": { "field": "job" }, "aggs": { "NAME": { "stats": { "field": "sal" } } } } } }
top_hits - 在top_hits指定 sort 参数达到返回按列排序的前几条数据 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 # top_hits & size & sort 返回按列排序后的前几条数据 GET employee/_search { "size": 0, "aggs": { "NAME": { "top_hits": { "size": 2, "sort": [ { "age": { "order": "desc" } } ] } } } }
range - 对数值进行分桶并计算每个bucket中的数量，指定 ranges 参数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 # range对数值进行分组并对每个区间进行计数 GET employee/_search { "size": 0, "aggs": { "NAME": { "range": { "field": "sal", "ranges": [ { "key": "0-10000", "to": 10001 }, { "key": "10000-20000", "from": 10001, "to": 20001 }, { "key": "20000-30000", "from": 20001, "to": 30001 } ] } } } }
histogram - 按同样的区间对字段进行分组统计数量，指定 interval 步长即可 histogram 是对数值进行分区间，sep为固定值，并对每个区间进行计数
1 2 3 4 5 6 7 8 9 10 11 12 GET employee/_search { "size": 0, "aggs": { "NAME": { "histogram": { "field": "sal", "interval": 10000 } } } }
min_bucket - 筛选平均工资最低的工种 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 GET employee/_search { "size": 0, "aggs": { "NAME1": { "terms": { "field": "job" }, "aggs": { "NAME2": { "avg": { "field": "sal" } } } }, "NAME": { "min_bucket": { "buckets_path": "NAME1>NAME2" # 这里为路径，按name指定 } } } }
range&avg - 先分组再计算组内平均值 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 GET employee/_search { "size": 0, "aggs": { "NAME": { "range": { "field": "sal", "ranges": [ { "key": "大于30", "from": 30 } ] }, "aggs": { "NAME": { "avg": { "field": "sal" } } } } } }
query&aggs - 先筛选再聚合 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 GET employee/_search { "query": { "match": { "job": "java" } }, "size": 0, "aggs": { "NAME": { "stats": { "field": "sal" } } } } #
针对两次聚合不同数据源的聚合，aggs下分name后filter接下来再聚合 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 GET employee/_search { "size": 0, "aggs": { "平均工资": { "avg": { "field": "sal" } }, "筛选大于30": { "filter": { "range": { "age": { "gte": 30 } } }, "aggs": { "大于30平均工资": { "avg": { "field": "sal" } } } } } }
Suggest - 建议高亮 suggest - 搜索建议，针对未添加到索引中的文本 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 GET movies/_search { "suggest": { "NAME": { "text": "beauti", "term": { "field": "title" } } } }
suggest 搜索建议，设置不管在不在索引中都提供搜索建议，设置suggest_mode为always 1 2 3 4 5 6 7 8 9 10 11 12 GET movies/_search { "suggest": { "NAME": { "text": "beauty", "term": { "field": "title", "suggest_mode":"always" # 默认为missing，设置为popular为常见的建议 } } } }
completion - 自动补全功能的实现（首先要将mapping需要补全的字段类型设置为completion，然后在传入数据） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 GET movies_completion/_search { "_source": [""], # 不显示其他字段内容，只显示匹配的title "suggest": { "NAME": { "prefix":"bea", # 前缀为bea字段为title的自动补全 "completion": { "field":"title"， "skip_duplicates":true， # 忽略重复值，返回唯一值 "size":10 # 默认显示5条 } } } }
highlight - 高亮查询出来匹配的文本 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 GET movies/_search { "query": { "multi_match": { "query": "romance", "fields": ["title", "genre"] } }, "highlight": { "fields": { "title": {}, "genre": { "pre_tags": "<span>", # 定义查询出来的标签，默认标签为em "post_tags": "</span>" } } } }
highlight&highlight_query - 实现对筛选后的结果再对其他字段再次筛选并进行高亮 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 GET movies/_search { "query": { "bool": { "must": [ {"match": { "year": 2012 }}, {"match": { "title": "romance" }} ] } }, "highlight": { "fields": { "title": {}, # 这是直接高亮上方筛选中title中包含romance "genre": { "pre_tags": "<span>", "post_tags": "</span>", "highlight_query": { # 对上层筛选出来的结果按children进行再次筛选并高亮 "match": { "genre": "children" } } } } } }
_cat GET _cat/indices - 查看所有索引及基础信息 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 GET _cat/indices ---- result ---- { //... "12": { "health": "green", "status": "open", "index": "duoli-misc-canal", "uuid": "Xt2lk0WnRN-SKWgQo2YuvQ", "pri": "5", "rep": "0", "docs.count": "21", "docs.deleted": "0", "store.size": "27.4kb", "pri.store.size": "27.4kb" }, //... }
GET _cat/nodes?v - 查看所有 node 1 2 3 GET _cat/nodes?v ip heap.percent ram.percent cpu load_1m load_5m load_15m node.role master name 172.20.0.1 25 57 0 0.00 0.05 0.24 cdfhilmrstw * node-1
GET _cat/shards - 查看索引存放的shards 1 2 3 4 5 6 GET _cat/shards duoli-misc-canal 2 p STARTED 5 5.6kb 172.20.0.1 node-1 duoli-misc-canal 4 p STARTED 5 5.7kb 172.20.0.1 node-1 duoli-misc-canal 1 p STARTED 1 4.6kb 172.20.0.1 node-1 duoli-misc-canal 3 p STARTED 2 4.9kb 172.20.0.1 node-1
GET _cat/master?v - 查看主服务器信息 {index} - 索引 PUT {index} - 设置索引信息 定义mapping，一般es会自动创建mapping，可以先上传测试数据，然后删除索引修改 mapping 再创建，最后再上传数据
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 PUT duoli-misc-canal { "mappings" : { "properties" : { "created_at" : { "type" : "date", "format" : "yyyy-MM-dd HH:mm:ss||epoch_millis" }, "id" : { "type" : "long" }, ... "title" : { "type" : "keyword" } } } }
index : 是否开启索引 index : false 禁止索引
1 2 3 4 "{FIELD_NAME}" : { "type" : "keyword", "index": false }
type: keyword null_value : 查询空值
1 2 3 4 "{FIELD_NAME}" : { "type" : "keyword", "null_value": "null" }
GET {index} - 查看索引相关的配置信息 1 2 3 4 5 6 7 8 9 10 11 12 13 GET duoli-misc-canal { "duoli-misc-canal" : { "aliases" : { }, "mappings" : { ... }, "settings" : { ... } } }
GET {index}/_mapping - 查看索引内的映射关系 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 GET /duoli-misc-canal/_mapping { "duoli-misc-canal" : { "mappings" : { "properties" : { "created_at" : { "type" : "date", "format" : "yyyy-MM-dd HH:mm:ss||epoch_millis" }, "id" : { "type" : "long" }, ... "title" : { "type" : "keyword" } } } } }
PUT {index}/_doc/{id} - 写入单条数据 一般情况下, 创建内容的时候便会自动创建 mapping
1 2 3 4 5 6 7 8 9 10 # 写入单条数据 PUT duoli-misc-canal/_doc/22 { "id": 2, "title": "不同注册市场本站质量.比较新闻必须为什.工作更新的话关于项目简介完全.", "price": 2, "stock": 33, "stock_at": "2022-10-10 23:18:28", "created_at": "2022-10-12 23:18:28" }
POST {index}/_analyze - 分析当前的分词 1 2 3 4 5 POST /index/_analyze { "text": "中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首", "tokenizer": "ik_smart" }
DELETE {index} - 删除索引 GET {index}/type/_validate/query?explain - 分析查询语句 复杂的语句可以先使用工具来分析下查询语句, 方便定位不合法的搜索以及原因 explain 参数可提供更详细的查询不合法的信息, 以便于错误的语法进行定位
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 GET /index/type/_validate/query?explain { "query": { "match": { "content": "寒食" } } } ---- result ---- { "_shards" : { "total" : 1, "successful" : 1, "failed" : 0 }, "valid" : true, # valid 代表语句通过验证 "explanations" : [ { "index" : "duoli-misc-canal", "valid" : true, "explanation" : """+content:寒食 #MatchNoDocsQuery("")""" } ] }
GET _sql 使用 sql 语句进行查询
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 使用sql语句进行查询 GET _sql { "query": """ SELECT sum(AvgTicketPrice) agg_sum FROM "kibana_sample_data_flights" where DestCountry = 'US' """ } # translate将SQL语句解析为es查询json GET _sql/translate { "query": """ SELECT sum(AvgTicketPrice) agg_sum FROM "kibana_sample_data_flights" where DestCountry = 'US' """ } # format参数可返回多种形式的结果（json、yaml、txt、csv等）默认json GET _sql?format=csv { "query": """ SELECT AvgTicketPrice,Cancelled,DestCountry FROM "kibana_sample_data_flights" where DestCountry = 'US' limit 10 """ }
_cluster - 集群 GET _cluster/health - 查看集群状态 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 GET _cluster/health { "cluster_name" : "elasticsearch", "status" : "yellow", "timed_out" : false, "number_of_nodes" : 1, "number_of_data_nodes" : 1, "active_primary_shards" : 29, "active_shards" : 29, "relocating_shards" : 0, "initializing_shards" : 0, "unassigned_shards" : 4, "delayed_unassigned_shards" : 0, "number_of_pending_tasks" : 0, "number_of_in_flight_fetch" : 0, "task_max_waiting_in_queue_millis" : 0, "active_shards_percent_as_number" : 87.87878787878788 }
GET _cluster/stats - 查看集群详细信息 GET _cluster/settings - 查看集群配置 参考链接
语雀镜像 : ES 语法 ,点此 提问