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。它是使用一个或多个布尔子句构建的，每个子句都具有类型的出现。

用于组合多个查询子句，作为默认查询 must，should，must_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选项控制是否对字段值建立索引。它接受true 或false，默认为true。未索引的字段不可查询
meta 附加到字段的元数据。该元数据对Elasticsearch不透明，仅对在相同索引上工作的多个应用程序共享有关字段（例如单位）的元信息有用