数据类型

  1. Text: 被 Analyzer 索引的字符串类型
  2. KeyWord: 不能被 Analyzer、只能被精确匹配的字符串类型
  3. Date: 日期类型，配合 format
  4. 数字类型: long integer short doubel .etc
  5. boolean: true false
  6. Array: 数组
  7. Object: json 嵌套
  8. IP类型
  9. Geo_point: 地理位置

语法

添加

控制分片

  1. // 控制分片
  2. put /employee
  3. {
  4.   "settings": {
  5.     "number_of_shards": 1,
  6.     "number_of_replicas": 0
  7.   }
  8. }
  • es 集群状态主要看 从分片能不能存在在 n-1 个节点上

暂时存储

  1. GET /_all
  4. delete /employee
  6. # 控制分片
  7. put /employee
  8. {
  9.   "settings": {
  10.     "number_of_shards": 1,
  11.     "number_of_replicas": 0
  12.   }
  13. }
  15. # 非结构化方式新建索引
  16. # _doc 为 type，但是仅仅作为占位符
  18. PUT /employee/_doc/1
  19. {
  20.   "name": "akarin2",
  21.   "age": 20
  22. }
  24. GET /employee/_doc/1
  26. # 会直接覆盖上面得内容，即默认需要全量更新
  27. PUT /employee/_doc/1
  28. {
  29.   "name": "akarin2"
  30. }
  32. # 获取索引记录
  33. GET /employee/_doc/1
  35. # 指定某一字段更新
  36. POST /employee/_update/1
  37. {
  38.   "doc":{
  39.     "name": "fuck"
  40.   }
  41. }
  43. # 强制指定创建，如果存在，则失败
  44. POST /employee/_create/1
  45. {
  46.   "name": "lee",
  47.   "age": 30
  48. }
  51. # 删除某个文档
  52. DELETE /employee/_doc/1
  54. # 查询全部文档
  55. GET /employee/_search
  57. #/
  58. DELETE /employee
  60. # 使用结构化的方式创建 索引
  61. # 设置 mapping 的结构
  62. PUT /employee
  63. {
  64.   "settings": {
  65.     "number_of_shards": 1,
  66.     "number_of_replicas" : 0
  67.   },
  68.   "mappings":{
  69.     "properties": {
  70.       "name": {
  71.         "type": "text"
  72.       },
  73.       "age":{
  74.         "type": "integer"
  75.       }
  76.     }
  77.   }
  78. }
  80. # 此时进行put 操作
  81. PUT /employee/_doc/1
  82. {
  83.   "name": "baba"
  84. }
  85. # 虽然显示缺少了 age ，但是 /employee 的 mapping 还是保持原结构
  86. # 但是如果 put 了新的不冲突字段，mapping 还是会跟着改
  87. GET /employee/_doc/1
  90. PUT /employee/_doc/1
  91. {
  92.   "name": "demo 1",
  93.   "age": 123
  94. }
  95. PUT /employee/_doc/2
  96. {
  97.   "name": "demo 2",
  98.   "age": 1234
  99. }
  102. # 不带条件查询所有记录
  103. GET /employee/_search
  104. {
  105.   "query": {
  106.     "match_all": {}
  107.   }
  108. }
  110. # 分页查询
  111. # from 从第几个索引开始（索引从0开始）
  112. # size 要几条记录
  113. GET /employee/_search 
  114. {
  115.   "query": {
  116.     "match_all": {}
  117.   },
  118.   "from": 0,
  119.   "size": 1
  120. }
  122. # 条件查询
  123. # 带关键字查询, 只能单一字段
  124. GET /employee/_search
  125. {
  126.   "query": {
  127.     "match": {
  128.       "name": "demo"
  129.     }
  130.   }
  131. }
  133. # 带排序的查询
  134. # 此时返回 _score 为 null，评分标准是 sort字段
  135. GET /employee/_search 
  136. {
  137.   "query": {
  138.      "match": {
  139.        "name": "demo"
  140.       }
  141.     },
  142.     "sort":{
  143.       "age":{
  144.         "order": "asc"
  145.       }
  146.     }
  147.   }
  148. }
  150. # filter
  151. # 作用在 bool 下
  152. # filter 类似 relation db 中的 where
  153. # 打分均为0.0
  154. # term 和 match 区别是后者带有分词 analize, term 是纯粹的 equals
  155. GET /employee/_search
  156. {
  157.   "query": {
  158.     "bool":{
  159.       "filter" :{
  160.         "term": {
  161.           "name": "demo"
  162.         }
  163.       }
  164.     }
  165.   }
  166. }
  168. # 带聚合的查询
  169. # 对某个字段进行聚合
  170. # 返回的聚合字段中，key 就是对应 field 的值
  171. GET /employee/_search 
  172. {
  173.   "query": {
  174.     "match": {
  175.       "name": "demo"
  176.     }
  177.   },
  178.   "aggs":{
  179.     "随便起个名称":{
  180.       "terms": {
  181.         "field": "age"
  182.       }
  183.     }
  184.   }
  185. }
  186. #
  187. # 分词
  188. #
  189. PUT /movie/_doc/1 
  190. {
  191.   "name": "eating a apple"
  192. }
  193. # 查看分词状态
  194. # 根据对应 field 的 analyzer 对 text 进行分词
  195. # 默认是标准字符处理，以空格和标点符号分割内容
  196. GET /movie/_analyze
  197. {
  198.   "field": "name",
  199.   "text": ["eating a applet"]
  200. }
  203. DELETE /movie
  204. # 修改为 engalish 分词
  205. # 在结构化索引的时候，不要带_doc和id
  206. PUT /movie
  207. {
  208.   "mappings":{
  209.     "properties":{
  210.       "name":{
  211.         "type": "text",
  212.         "analyzer": "english"
  213.       }
  214.     }
  215.   }
  216. }
  218. # 查看新的分词状态
  219. GET /movie/_analyze
  220. {
  221.   "field": "name",
  222.   "text": ["Eatting this apple"]
  223. }
  225. # 添加一条街ilu
  226. POST /movie/_doc/1
  227. {
  228.   "name": "Eatting a apple"
  229. }
  231. GET /movie/_doc/1
  233. GET /movie/_search
  234. {
  235.   "query": {
  236.     "match": {
  237.       "name": "Eatting a apple"
  238.     }
  239.   }
  240. }
  242. GET /movie/_search
  243. {
  244.   "query": {
  245.     "bool": {
  246.       "filter": {
  247.         "term" : {
  248.           "name": "Eatting a apple"
  249.         }
  250.       }
  251.     }
  252.   }
  253. }
  255. #/
  256. # tomdb
  257. #/
  259. DELETE /movie
  261. # 时间format可以对应多种，前面语法要求带个8
  262. # object 中 character 和 name 的分词用 standard 精确查询
  263. PUT /movie 
  264. {
  265.   "settings": {
  266.     "number_of_shards": 1,
  267.     "number_of_replicas": 0
  268.   },
  269.   "mappings": {
  270.     "properties": {
  271.       "title": {
  272.         "type": "text",
  273.         "analyzer": "english"
  274.       },
  275.       "tagline": {
  276.         "type": "text",
  277.         "analyzer": "english"
  278.       },
  279.       "release_date": {
  280.         "type": "date",
  281.         "format": "8yyyy/MM/dd||yyyy/M/dd||yyyy/MM/d||yyyy/M/d"
  282.       },
  283.       "popularity": {
  284.         "type": "double"
  285.       },
  286.       "overview": {
  287.         "type": "text",
  288.         "analyzer": "english"
  289.       },
  290.       "cast": {
  291.         "type": "object",
  292.         "properties": {
  293.           "character": {"type": "text", "analyzer": "standard"},
  294.           "name": {"type": "text", "analyzer": "standard"}
  295.         }
  296.       }
  297.     }
  298.   }
  299. }
  300. # match: 对搜索词进行分词分析，再去索引查询
  301. GET /movie/_search
  302. {
  303.   "query": {
  304.     "match": {
  305.       "title": "steve"
  306.     }
  307.   }
  308. }
  310. # term: 不进行分词分析，直接去索引查询，精确匹配
  311. GET /movie/_search
  312. {
  313.   "query": {
  314.     "term": {
  315.       "title": "steve"
  316.     }
  317.   }
  318. }
  320. # or
  321. # 默认是将分词后的token进行or匹配，只要有一个 token 命中索引即返回数据
  322. GET /movie/_search
  323. {
  324.   "query": {
  325.     "match": {
  326.       "title": "basketball and aliens"
  327.     }
  328.   }
  329. }
  331. # and
  332. # 可以修改为分词后的 token 全部命中才可以返回数据
  333. GET /movie/_search
  334. {
  335.   "query": {
  336.     "match": {
  337.       "title": {
  338.         "query": "basketball and aliens",
  339.         "operator": "and"
  340.       }
  341.     }
  342.   }
  343. }
  345. # 最小词匹配项
  346. # 分词后的 token 要命中指定个数
  347. GET /movie/_search
  348. {
  349.     "query": {
  350.     "match": {
  351.       "title": {
  352.         "query": "basketball and aliens",
  353.         "operator": "or",
  354.         "minimum_should_match": 1
  355.       }
  356.     }
  357.   }
  358. }
  360. # 短语查询
  361. # 不走索引?
  362. GET /movie/_search
  363. {
  364.   "query": {
  365.     "match_phrase": {
  366.       "title": "steve"
  367.     }
  368.   }
  369. }
  371. # 多字段查询
  372. GET /movie/_search
  373. {
  374.   "query": {
  375.     "multi_match": {
  376.       "query": "basketball and aliens",
  377.       "fields": ["title", "overview"]
  378.     }
  379.   }
  380. }
  382. # 查看打分过程
  383. GET /movie/_search
  384. {
  385.   "explain": true, 
  386.   "query": {
  387.     "match": {
  388.       "title": "steve"
  389.     }
  390.   }
  391. }
  393. # 多字段查询打分
  394. # 通过结果来看，会对不同 field 进行打分，然后取最大的一个
  395. GET /movie/_search
  396. {
  397.   "explain": true, 
  398.   "query": {
  399.     "multi_match": {
  400.       "query": "basketball and aliens",
  401.       "fields": ["title", "overview"]
  402.     }
  403.   }
  404. }
  406. # 优化多字段查询优化1
  407. # 对重要字段进行 放大系数的乘积
  408. GET /movie/_search
  409. {
  410.   "explain": true, 
  411.   "query": {
  412.     "multi_match": {
  413.       "query": "basketball and aliens",
  414.       "fields": ["title^10", "overview"]
  415.     }
  416.   }
  417. }
  419. # 优化多字段查询优化2
  420. # unknown
  421. GET /movie/_search
  422. {
  423.   "explain": true, 
  424.   "query": {
  425.     "multi_match": {
  426.       "query": "basketball and aliens",
  427.       "fields": ["title^10", "overview"],
  428.       "tie_breaker": 0.3
  429.     }
  430.   }
  431. }
  433. # 多字段查询 从 max of 改为 sum of
  434. # bool 查询，根据条件，会先过滤不匹配的 document，再进行打分，最后 sum of
  435. #   must: 必须都为 true
  436. #   must not: 必须都是 false
  437. #   shold: 其中有个 true 即可
  438. GET /movie/_search
  439. {
  440.   "explain": true,
  441.   "query": {
  442.     "bool": {
  443.       "should": [
  444.         {"match": {"title": "basketball and aliens"}},
  445.         {"match": {"overview": "basketball and aliens"}}
  446.       ]
  447.     }
  448.   }
  449. }
  451. # 多字段查询
  452. # multi_query 会根据不同的 type 进行打分匹配
  453. # 默认是 best_fields ，最匹配模式
  454. GET /movie/_search
  455. {
  456.   "query": {
  457.     "multi_match": {
  458.       "query": "basketball and aliens",
  459.       "fields": ["title", "overview"],
  460.       "type": "best_fields"
  461.     }
  462.   }
  463. }
  464. # best_fields 等同于 dis_max + queries 模式
  465. GET /movie/_search
  466. {
  467.   "explain": true,
  468.   "query": {
  469.     "dis_max": {
  470.       "queries": [
  471.         {"match": {"title": "basketball and aliens"}},
  472.         {"match": {"overview": "basketball and aliens"}}
  473.       ]
  474.     }
  475.   }
  476. }
  478. # best_fields 模式，最模式打分，不管 fields 有没有对应分词，只管各个 fiedls 打分最大值
  479. # "explanation" : "((overview:basketbal overview:alien) | (title:basketbal title:alien))"
  480. GET /movie/_validate/query?explain
  481. {
  482.   "query": {
  483.     "multi_match": {
  484.       "query": "basketball and aliens",
  485.       "fields": ["title", "overview"],
  486.       "type": "best_fields"
  487.     }
  488.   }
  489. }
  490. # most_fields 模式，考虑所有文本的， 类似 bool + should
  491. #  "explanation" : "((overview:basketbal overview:alien) | (title:basketbal title:alien))~1.0"
  492. GET /movie/_validate/query?explain
  493. {
  494.   "query": {
  495.     "multi_match": {
  496.       "query": "basketball and aliens",
  497.       "fields": ["title", "overview"],
  498.       "type": "most_fields"
  499.     }
  500.   }
  501. }
  502. # cross_fields 分词导向模式，以分词为单位计算栏位的总分
  503. # 先算分词在各个field 中的分数，取最大值，然后再和其他分词结果相加
  504. #  "explanation" : "blended(terms:[overview:basketbal, title:basketbal]) blended(terms:[overview:alien, title:alien])"
  505. GET /movie/_validate/query?explain
  506. {
  507.   "query": {
  508.     "multi_match": {
  509.       "query": "basketball and aliens",
  510.       "fields": ["title", "overview"],
  511.       "type": "cross_fields"
  512.     }
  513.   }
  514. }
  516. ##########################
  517. # 过滤和排序
  518. ##########################
  520. # AND OR 快速使用
  521. # 不用使用 bool + must 之类的
  522. GET /movie/_search
  523. {
  524.   "explain": true, 
  525.   "query": {
  526.     "query_string": {
  527.       "fields": ["title", "overview"], 
  528.       "query": "steve AND jobs"
  529.     }
  530.   }
  531. }
  533. # filter，score为0
  534. # 单条件过滤
  535. GET /movie/_search
  536. {
  537.   "query": {
  538.     "bool": {
  539.       "filter": {
  540.         "term": {"title": "steve"}
  541.       }
  542.     }
  543.   }
  544. }
  546. # filter 多条件过滤 + 排序
  547. # score 为 null
  548. GET /movie/_search
  549. {
  550.   "query": {
  551.     "bool": {
  552.       "filter": [
  553.         {"term": {"title": "steve"}},
  554.         {"term": {"cast.name": "gaspard"}},
  555.         {"range": {"release_date": {"lte": "2015/01/01"}}},
  556.         {"range": {"popularity": {"gte": "25"}}}
  557.         ]
  558.     }
  559.   },
  560.   "sort": [
  561.     {
  562.       "popularity": {
  563.         "order": "desc"
  564.       }
  565.     }
  566.   ]
  567. }
  569. # 带match打分的 filter
  570. GET /movie/_search
  571. {
  572.   "query": {
  573.     "bool": {
  574.       "should": [
  575.         {"match": {"title": "steve"}}
  576.       ], 
  578.       "filter": [
  579.         {"term": {"title": "steve"}},
  580.         {"term": {"cast.name": "gaspard"}},
  581.         {"range": {"release_date": {"lte": "2015/01/01"}}},
  582.         {"range": {"popularity": {"gte": "25"}}}
  583.         ]
  584.     }
  585.   }
  586. }
  588. # function score   自定义打分
  589. GET /movie/_search
  590. {
  591.   "query": {
  592.     "function_score": {
  593.       // 原始查询得到 oldValue
  594.       "query": {
  595.         "multi_match": {
  596.           "query": "steve job",
  597.           "fields": ["title", "overview"],
  598.           "operator": "or",
  599.           "type": "most_fields"
  600.         }
  601.       },
  602.       "functions": [
  603.         {
  604.           "field_value_factor": {
  605.             "field": "popularity",  // 对应要处理的字段
  606.             "modifier": "log2p",  // 字段值+2后，计算对数
  607.             "factor": 1.2   // 字段预处理 * 10
  608.           }
  609.         }
  610.       ],
  611.       "score_mode": "sum",  // 不同的 field value 之间的得分处理模式，默认 multiply 相乘
  612.       "boost_mode": "sum" // 和 oldValue 之间的得分处理模式，默认 multiply 相乘
  613.     }
  614.   }
  615. }

ik 分词器

  1. # 测试 ik
  2. # 宁缺勿滥
  3. GET _analyze?pretty
  4. {
  5.   "analyzer": "ik_smart",
  6.   "text": "中华人民共和国国歌"
  7. }
  9. # 最大努力
  10. GET _analyze?pretty
  11. {
  12.   "analyzer": "ik_max_word",
  13.   "text": "中华人民共和国国歌"
  14. }
  16. # 普通分词
  17. GET _analyze?pretty
  18. {
  19.   "analyzer": "standard",
  20.   "text": "中华人民共和国国歌"
  21. }
  23. # analyzer 指定搞得是构建索引的时候的分词
  24. # search_analyzer 指定的是搜索关键字时的分词
  25. # 最佳实践
  26. #   索引阶段用 max_word 
  27. #   查询阶段用 smart word

实践

  1. 定义字段逻辑
  2. 定义字段类型
  3. 定义字段 analyzer