ElasticSearch

添加1条数据

  1. PUT /customer/_doc/1
  2. {
  3. "name": "John Doe"
  4. }
  1. POST /customer/_doc/2
  2. {
  3. "name": "John Doe"
  4. }

结果:

  1. {
  2. "_index" : "customer", //索引名
  3. "_type" : "_doc", //类型
  4. "_id" : "1", //id
  5. "_version" : 1, //版本 没修改一次就会+1
  6. "result" : "created", //创建
  7. "_shards" : { //分片
  8. "total" : 2, //总共两个分片
  9. "successful" : 2, //成功2
  10. "failed" : 0 //失败0
  11. },
  12. "_seq_no" : 26,
  13. "_primary_term" : 4
  14. }

PUT 和 POST 的区别:

1.PUT 命令后边必须加id,不加就会报错。如果已经存在该id就是修改(”result” : “update”),没有就是创建(”result” : “created”)—— 幂等

2.POST 命令后边可以加id,也可以不加。如果已经存在该id就是修改(”result” : “update”),没有就是创建(”result” : “created”),不加id就产生随机值

查询一条数据

  1. GET /customer/_doc/1

结果:

  1. {
  2. "_index" : "customer", //索引
  3. "_type" : "_doc", //类型
  4. "_id" : "1", //id
  5. "_version" : 1, //版本
  6. "_seq_no" : 26,
  7. "_primary_term" : 4,
  8. "found" : true,
  9. "_source" : {
  10. "name": "John Doe" //数据
  11. }
  12. }

查询全部并排序(默认只显示10条数据)

  1. GET /bank/_search
  2. {
  3. "query": { "match_all": {} },
  4. "sort": [
  5. { "account_number": "asc" }
  6. ]
  7. }

结果:

  1. {
  2. "took" : 23, //花费时间
  3. "timed_out" : false, //是否超时
  4. "_shards" : {
  5. "total" : 1,
  6. "successful" : 1,
  7. "skipped" : 0,
  8. "failed" : 0
  9. },
  10. "hits" : { //命中
  11. "total" : {
  12. "value" : 1000, //1000
  13. "relation" : "eq"
  14. },
  15. "max_score" : null, //最大得分
  16. "hits" : [
  17. {
  18. "_index" : "bank",
  19. "_type" : "customer",
  20. "_id" : "0",
  21. "_score" : null,
  22. "_source" : { //具体数据
  23. "account_number" : 0,
  24. "balance" : 16623,
  25. "firstname" : "Bradshaw",
  26. "lastname" : "Mckenzie",
  27. "age" : 29,
  28. "gender" : "F",
  29. "address" : "244 Columbus Place",
  30. "employer" : "Euron",
  31. "email" : "bradshawmckenzie@euron.com",
  32. "city" : "Hobucken",
  33. "state" : "CO"
  34. },
  35. "sort" : [ //排序号
  36. 0
  37. ]
  38. },
  39. ......
  40. ......
  41. {
  42. "_index" : "bank",
  43. "_type" : "customer",
  44. "_id" : "9",
  45. "_score" : null,
  46. "_source" : {
  47. "account_number" : 9,
  48. "balance" : 24776,
  49. "firstname" : "Opal",
  50. "lastname" : "Meadows",
  51. "age" : 39,
  52. "gender" : "M",
  53. "address" : "963 Neptune Avenue",
  54. "employer" : "Cedward",
  55. "email" : "opalmeadows@cedward.com",
  56. "city" : "Olney",
  57. "state" : "OH"
  58. },
  59. "sort" : [
  60. 9
  61. ]
  62. }
  63. ]
  64. }
  65. }

指定查询范围

  1. GET /bank/_search
  2. {
  3. "query": {
  4. "match_all": {}
  5. },
  6. "sort": [
  7. { "account_number": "asc" }
  8. ],
  9. "from": 10, //从第10条数据开始查询
  10. "size": 10 //一共查询10条数据
  11. }

指定查询条件

  1. //查询 address mill lane的数据 共有19条数据
  2. GET /bank/_search
  3. {
  4. "query": {
  5. "match": {
  6. "address": "mill lane"
  7. }
  8. }
  9. }
  1. //查询 address mill lane的数据 共有1条数据
  2. GET /bank/_search
  3. {
  4. "query": {
  5. "match_phrase": {
  6. "address": "mill lane"
  7. }
  8. }
  9. }

match 中的查询条件会被分词

match_phrase 中查询的条件不会被分词(当成一个整体作为查询条件)

组合多个查询条件

  1. GET /bank/_search
  2. {
  3. "query": {
  4. "bool": {
  5. "must": [
  6. {"match": {
  7. "age": "40" //必须匹配 age 40
  8. }}
  9. ],
  10. "must_not": [
  11. {"match": {
  12. "state": "ID" //必须不匹配 state ID
  13. }}
  14. ]
  15. }
  16. }
  17. }

聚合查询(根据state分组并求人数)

  1. GET /bank/_search
  2. {
  3. "size": 0, //响应仅包含聚合结果
  4. "aggs": {
  5. "group_by_state": { //聚合名 唯一即可
  6. "terms": { //汇总(类似于mysql中的分组后count
  7. "field": "state.keyword" //分组字段
  8. }
  9. }
  10. }
  11. }

嵌套分组(根据state分组并求人数并求平均工资)

  1. GET /bank/_search
  2. {
  3. "aggs": {
  4. "state_count": {
  5. "terms": {
  6. "field": "state.keyword"
  7. },
  8. "aggs": {
  9. "balance_avg": {
  10. "avg": {
  11. "field": "balance"
  12. }
  13. }
  14. }
  15. }
  16. }
  17. }

聚合分组并排序(按照平均薪资降序—order只能用在terms的聚合里)

  1. GET /bank/_search
  2. {
  3. "size": 0, //响应仅包含聚合结果
  4. "aggs": {
  5. "group_by_state": {
  6. "terms": {
  7. "field": "state.keyword",
  8. "order": {
  9. "average_balance": "desc"
  10. }
  11. },
  12. "aggs": {
  13. "average_balance": {
  14. "avg": {
  15. "field": "balance"
  16. }
  17. }
  18. }
  19. }
  20. }
  21. }

复合查询

复合查询包括:bool 查询 、boosting 查询、constant_score 查询、dis_max 查询、function_score 查询

1.bool 查询

与文档匹配的查询,该文档与其他查询的布尔组合匹配。布尔查询映射到Lucene BooleanQuery。它是使用一个或多个布尔子句构建的,每个子句都具有类型的出现。

用于组合多个查询子句,作为默认查询 mustshouldmust_not,或filter。

filter等同于must但是不提供相关性得分(must_not也不提供相关性得分)

  1. POST _search
  2. {
  3. "query": {
  4. "bool" : {
  5. "must" : {
  6. "term" : { "user.id" : "kimchy" }
  7. },
  8. "filter": {
  9. "term" : { "tags" : "production" }
  10. },
  11. "must_not" : {
  12. "range" : {
  13. "age" : { "gte" : 10, "lte" : 20 }
  14. }
  15. },
  16. "should" : [
  17. { "term" : { "tags" : "env1" } },
  18. { "term" : { "tags" : "deployed" } }
  19. ],
  20. "minimum_should_match" : 1,
  21. "boost" : 1.0
  22. }
  23. }
  24. }

2.boosting 查询

返回与positive查询匹配的文档,但减少与negative查询匹配的文档的分数。

  1. GET /_search
  2. {
  3. "query": {
  4. "boosting": {
  5. "positive": {
  6. "term": {
  7. "text": "apple"
  8. }
  9. },
  10. "negative": {
  11. "term": {
  12. "text": "pie tart fruit crumble tree"
  13. }
  14. },
  15. "negative_boost": 0.5
  16. }
  17. }
  18. }

3.constant_score 查询

一个查询,它包装另一个查询,但在过滤器上下文中执行它。所有匹配的文档都被赋予相同的“常量” _score

  1. GET /_search
  2. {
  3. "query": {
  4. "constant_score": {
  5. "filter": {
  6. "term": { "user.id": "kimchy" }
  7. },
  8. "boost": 1.2
  9. }
  10. }
  11. }

4.dis_max 查询

一个查询,它接受多个查询,并返回与任何查询子句匹配的任何文档。当bool查询合并所有匹配查询的分数时,dis_max查询将使用单个最佳匹配查询子句的分数。

  1. GET /_search
  2. {
  3. "query": {
  4. "dis_max": {
  5. "queries": [
  6. { "term": { "title": "Quick pets" } },
  7. { "term": { "body": "Quick pets" } }
  8. ],
  9. "tie_breaker": 0.7
  10. }
  11. }
  12. }

5.function_score 查询

使用功能修改主查询返回的分数,以考虑诸如流行度,新近度,距离或使用脚本实现的自定义算法等因素。

  1. GET /_search
  2. {
  3. "query": {
  4. "function_score": {
  5. "query": { "match_all": {} },
  6. "boost": "5",
  7. "functions": [
  8. {
  9. "filter": { "match": { "test": "bar" } },
  10. "random_score": {},
  11. "weight": 23
  12. },
  13. {
  14. "filter": { "match": { "test": "cat" } },
  15. "weight": 42
  16. }
  17. ],
  18. "max_boost": 42,
  19. "score_mode": "max",
  20. "boost_mode": "multiply",
  21. "min_score": 42
  22. }
  23. }
  24. }

sql查询

  1. POST /_sql?format=txt
  2. {
  3. "query": "SELECT * FROM library WHERE release_date < '2000-01-01'"
  4. }

结果:

  1. author | name | page_count | release_date
  2. ---------------+---------------+---------------+------------------------
  3. Dan Simmons |Hyperion |482 |1989-05-26T00:00:00.000Z
  4. Frank Herbert |Dune |604 |1965-06-01T00:00:00.000Z

元数据

元数据字段 注释
_index 文档所属的索引
_type 文档的映射类型
_id 文件编号
_source 表示文档正文的原始JSON
_size _source提供的字段大小(以字节为单位)
_field_names 文档中包含非空值的所有字段
_ignored 由于导致索引时间被忽略的文档中的所有字段
_routing 一个自定义的路由值,用于将文档路由到特定的分片
_meta 特定于应用程序的元数据

映射参数

参数 注释
analyzer 指定索引或搜索字段时用于文本分析的分词器
boost 自动增强各个字段(对相关性得分进行更多计数)默认是1.0
coerce 清除脏值以适合字段的数据类型
copy_to 允许您将多个字段的值复制到组字段中,然后可以将其作为单个字段进行查询
doc_values 设置字段是否可以排序或聚合
dynamic 通过索引包含新字段的文档,即可将字段动态添加到文档或文档中的内部对象
enabled 是否为字段建立索引
format 格式化
ignore_above 长于ignore_above设置的字符串将不会被索引或存储
index index选项控制是否对字段值建立索引。它接受truefalse,默认为true。未索引的字段不可查询
meta 附加到字段的元数据。该元数据对Elasticsearch不透明,仅对在相同索引上工作的多个应用程序共享有关字段(例如单位)的元信息有用