• elasticsearch操作

    1.倒排索引的介绍

    1. 1 倒排索引：对文章进行分词，对每个词建立索引，
    2. 由于这样建，会出现索引爆炸，索引索引跟标题建关系，标题再跟文章建索引，如下：
    3. 分词---文章建立索引                             |
    4.  
    5. | 今天(索引)    | (文章1,<2，10>,2) (文章3,<8>,1)       |
    6. | 星期天（索引） | (文章2,<12,25,100>,3)                 |
    7. | 出去玩（索引） | (文章5,<11,24,89>,3)(文章1,<8，19>,2) |
    8.  
    9. 今天出现在哪个文章，出现的位置和出现的次数

    2.索引操作（数据库）

    2.1 创建索引

    1. PUT ymq
    2. {
    3.   "settings": {
    4.     "index":{
    5.       "number_of_shards":5,
    6.       "number_of_replicas":1
    7.     }
    8.   }
    9. }

    2.2 查看索引

    1. # 查看单个
    2. GET ymq/_settings
    3. # 查看所有
    4. GET _all/_settings
    5. # 查看特定
    6. GET ymq,ymq2/_settings
    7. # 查看所有
    8. GET _settings

    2.3 修改索引（一般不太用，只能用来修改副本数量）

    1. #修改索引副本数量为2  分片的数量一开始就要定好
    2. # 副本数量可以改（有可能会出错）
    3. PUT ymq/_settings
    4. {
    5.   "number_of_replicas": 2
    6. }
    7.  
    8. PUT  _all/_settings
    9. {
    10. "index": {
    11.   "blocks": {
    12.     "read_only_allow_delete": false
    13.     }
    14.   }
    15. }

    2.4 删除索引

    DELETE ymq

    3. 映射管理(类型)（表）

    3.1 介绍

    在Elasticsearch 6.0.0或更高版本中创建的索引只包含一个mapping type。

    在5.x中使用multiple mapping types创建的索引将继续像以前一样在Elasticsearch 6.x中运行。 Mapping types将在Elasticsearch 7.0.0中完全删除

    ##索引如果不创建，只有插入文档，会自动创建

    3.2 创建映射（类型，表）

    1. PUT books
    2. {
    3.   "mappings": {
    4.     "properties":{
    5.       "title":{
    6.         "type":"text"
    7.       },
    8.       "price":{
    9.         "type":"integer"
    10.       },
    11.       "addr":{
    12.         "type":"keyword"
    13.       },
    14.       "company":{
    15.         "properties":{
    16.           "name":{"type":"text"},
    17.           "company_addr":{"type":"text"},
    18.           "employee_count":{"type":"integer"}
    19.         }
    20.       },
    21.       "publish_date":{"type":"date","format":"yyy-MM-dd"}
    22.       
    23.     }
    24.     
    25.   }
    26. }

    3.3 查看映射

    1. GET books/_mapping
    2. GET _all/_mapping

    3.4 特殊说明索引映射都不存在，也可以插入文档

    1. PUT ymq2/_doc/1
    2. {
    3.   "title":"白雪公主和十个小矮人",
    4.   "price":"99",
    5.   "addr":"黑暗森里",
    6.   "publish_date":"2018-05-19",
    7.   "name":"ymq"
    8. }

    4. 文档基本增删查改（一行一行数据）

    4.1 插入文档

    1. PUT books/_doc/1
    2. {
    3.   "title":"大头儿子小偷爸爸",
    4.   "price":100,  
    5.   "addr":"北京天安门",
    6.   "company":{
    7.     "name":"我爱北京天安门",
    8.     "company_addr":"我的家在东北松花江傻姑娘",
    9.     "employee_count":10
    10.   },
    11.   "publish_date":"2019-08-19"
    12. }
    13.  
    14. PUT books/_doc/2
    15. {
    16.   "title":"白雪公主和十个小矮人",
    17.   "price":"99", 
    18.   "addr":"黑暗森里",
    19.   "publish_date":"2018-05-19"
    20. }
    21.  
    22. PUT books/_doc/3
    23. {
    24.   "title":"白雪公主和十个小矮人",
    25.   "price":"99", 
    26.   "addr":"黑暗森里",
    27.   "publish_date":"2018-05-19",
    28.    "name":"lqz"
    29. }
    30.

    4.2 查看文档

    1.  
    2. # 格式：索引名称/默认类型名称/id
    3. GET books/_doc/1

    4.3 修改文档两种方式

    4.3.1 第一种(不推荐，全部修改)

    1. PUT lqz/_doc/1
    2. {
    3.   "name":"顾老二",
    4.   "age":30,
    5.   "from": "gu",
    6.   "desc": "皮肤黑、武器长、性格直",
    7.   "tags": ["黑", "长", "直"]
    8. }

    4.3.2 局部修改

    1. POST lqz/_doc/1/_update
    2. {
    3.   "doc": {
    4.     "desc": "皮肤很safasdfsda黄，武器很长，性格很直",
    5.     "tags": ["很黄","很长", "很直"]
    6.   }
    7. }

    4.4 删除文档

    DELETE lqz/_doc/4

    5. 文档查询

    5.1 term与match的区别

    5.1.1 介绍

    term：是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词，所以我们的搜索词必须是文档分词集合中的一个

    match：查询会先对搜索词进行分词,分词完毕后再逐个对分词结果进行匹配，因此相比于term的精确搜索，match是分词匹配搜索

    5.1.2 创建索引+映射(无ik)+插入数据

    1. # 创建索引跟映射
    2. PUT lqz
    3. {
    4.   "settings": {
    5. 		"number_of_shards": 5,
    6. 		"number_of_replicas": 2
    7. 	},
    8.   "mappings": {
    9.     "properties":{
    10.       "title":{
    11.         "type":"text"
    12.       },
    13.       "desc":{
    14.         "type":"text"
    15.       },
    16.       "price":{
    17.         "type":"integer"
    18.       },
    19.       "addr":{
    20.         "type":"keyword"
    21.       },
    22.       "company":{
    23.         "properties":{
    24.           "name":{"type":"text"},
    25.           "company_addr":{"type":"text"},
    26.           "employee_count":{"type":"integer"}
    27.         }
    28.       },
    29.       "publish_date":{"type":"date","format":"yyy-MM-dd"}
    30.       
    31.     }
    32.     
    33.   }
    34. }
    35.  
    36. # 插入数据
    37.  
    38. PUT lqz/_doc/1
    39. {
    40.   "title":"so beautiful zero",
    41.   "price":100,  
    42.   "addr":"北京天安门",
    43.   "desc":"beautiful cat",
    44.   "company":{
    45.     "name":"我爱北京天安门",
    46.     "company_addr":"我的家在东北松花江傻姑娘",
    47.     "employee_count":10
    48.   },
    49.   "publish_date":"2019-08-19"
    50. }
    51.  
    52. PUT lqz/_doc/2
    53. {
    54.   "title":"so beautiful one",
    55.   "price":200,  
    56.   "addr":"北京天安门",
    57.   "desc":"beautiful dog",
    58.   "company":{
    59.     "name":"我爱北京天安门",
    60.     "company_addr":"我的家在东北松花江傻姑娘",
    61.     "employee_count":10
    62.   },
    63.   "publish_date":"2019-08-19"
    64. }
    65.  
    66.  
    67. PUT lqz/_doc/3
    68. {
    69.   "title":"so beautiful tow",
    70.   "price":698,  
    71.   "addr":"北京天安门",
    72.   "desc":"dog",
    73.   "company":{
    74.     "name":"我爱北京天安门",
    75.     "company_addr":"我的家在东北松花江傻姑娘",
    76.     "employee_count":10
    77.   },
    78.   "publish_date":"2019-08-19"
    79. }

    5.2 term

    5.2.1 term与terms

    term:不会分词，按照指定的词查询

    terms:可指定多个词查询

    1. # term查的不会分词
    2. GET lqz/_doc/_search
    3.         {
    4.       "query": {
    5.         "term": {
    6.           "desc": "beautiful"
    7.         }
    8.       }
    9.     }
    10. # terms由于部分词，想查多个，terms
    11. GET lqz/_doc/_search
    12.   {
    13.     "query": {
    14.       "terms": {
    15.         "title": ["beautiful", "so"]
    16.       }
    17.     }
    18.   }

    5.3 match

    5.3.1 match和match_all

    match:查询相当于模糊匹配,只包含其中一部分关键词就行 

    match_all:能够匹配索引中的所有文件。 

    match_phrase：短语匹配查询,要求必须全部精确匹配，且顺序必须与指定的短语相同

    1. # match查的短语会分词
    2. GET lqz/_doc/_search
    3.     {
    4.       "query": {
    5.         "match_all": {}
    6.       }
    7.     }
    8.   
    9. GET lqz/_doc/_search
    10.     {
    11.       "query": {
    12.         "match": {
    13.           "title": "beautiful tow"
    14.         }
    15.       }
    16.     }

    5.4 排序查询

    不是所有字段都支持排序，只有数字类型，字符串不支持

    1. # 排序查询
    2. # 1.普通查询
    3. GET lqz/_doc/_search
    4. {
    5.   "query": {
    6.     "match": {
    7.       "addr": "北京天安门"
    8.     }
    9.   }
    10. }
    11.  
    12. # 2.降序
    13. GET lqz/_doc/_search
    14. {
    15.   "query": {
    16.     "match": {
    17.       "addr": "北京天安门"
    18.     }
    19.   },
    20.   "sort": [
    21.     {
    22.       "price": {
    23.         "order": "desc"
    24.       }
    25.     }
    26.   ]
    27. }
    28.  
    29. #3.升序
    30. GET lqz/_doc/_search
    31. {
    32.   "query": {
    33.     "match": {
    34.       "addr": "北京天安门"
    35.     }
    36.   },
    37.   "sort": [
    38.     {
    39.       "price": {
    40.         "order": "asc"
    41.       }
    42.     }
    43.   ]
    44. }
    45.  
    46. # 4.match_all+升序
    47. GET lqz/_doc/_search
    48. {
    49.   "query": {
    50.     "match_all": {
    51.     }
    52.   },
    53.   "sort": [
    54.     {
    55.       "price": {
    56.         "order": "asc"
    57.       }
    58.     }
    59.   ]
    60. }

    5.5 分页查询

    所有的条件都是可插拔的，彼此之间用 , 分割

    1. # 分页
    2. #从第二条开始，取一条
    3.  
    4. GET lqz/_doc/_search
    5. {
    6.   "query": {
    7.     "match_all": {}
    8.   },
    9.   "sort": [
    10.     {
    11.       "price": {
    12.         "order": "desc"
    13.       }
    14.     }
    15.   ], 
    16.   "from": 2,
    17.   "size": 2
    18. }
    19.  
    20.  
    21.  
    22.  
    23. ###注意：对于`elasticsearch`来说，所有的条件都是可插拔的，彼此之间 , 分割
    24. GET lqz/_doc/_search
    25. {
    26.   "query": {
    27.     "match_all": {}
    28.   }, 
    29.   "from": 2,
    30.   "size": 2
    31. }

    5.6 布尔查询

    • must：与关系，相当于关系型数据库中的and。

    • should：或关系，相当于关系型数据库中的or。

    • must_not：非关系，相当于关系型数据库中的not。

    • filter：过滤条件。

    • range：条件筛选范围。

    • gt：大于，相当于关系型数据库中的>。

    • gte：大于等于，相当于关系型数据库中的>=。

    • lt：小于，相当于关系型数据库中的<。

    • lte：小于等于，相当于关系型数据库中的<=。

    1. ##布尔查询之should or条件
    2. GET lqz/_doc/_search
    3. {
    4.   "query": {
    5.     "bool": {
    6.       "should": [
    7.         {
    8.           "match": {
    9.             "addr": "北京天安门"
    10.           }
    11.         },
    12.         {
    13.           "match": {
    14.             "desc": "beautiful"
    15.           }
    16.         }
    17.       ]
    18.     }
    19.   }
    20. }
    21.  
    22.  
    23.  
    24.  
    25.  
    26. ### must_not条件   都不是
    27. GET lqz/_doc/_search
    28. {
    29.   "query": {
    30.     "bool": {
    31.       "must_not": [
    32.         {
    33.           "match": {
    34.             "addr": "北京天安门"
    35.           }
    36.         },
    37.         {
    38.           "match": {
    39.             "desc": "beautiful"
    40.           }
    41.         },
    42.         {
    43.           "match": {
    44.             "price": 698
    45.           }
    46.         }
    47.       ]
    48.     }
    49.   }
    50. }
    51.  
    52.  
    53.  
    54.  
    55. ###filter，大于小于的条件   gt lt  gte  lte
    56. GET lqz/_doc/_search
    57. {
    58.   "query": {
    59.     "bool": {
    60.       "must": [
    61.         {
    62.           "match": {
    63.             "addr": "北京天安门"
    64.           }
    65.         }
    66.       ],
    67.       "filter": {
    68.         "range": {
    69.           "price": {
    70.             "lt": 200
    71.           }
    72.         }
    73.       }
    74.     }
    75.   }
    76. }
    77.  
    78.  
    79. ### 范围查询
    80. GET lqz/_doc/_search
    81. {
    82.   "query": {
    83.     "bool": {
    84.       "must": [
    85.         {
    86.           "match": {
    87.             "addr": "北京天安门"
    88.           }
    89.         }
    90.       ],
    91.       "filter": {
    92.         "range": {
    93.           "price": {
    94.             "gte": 100,
    95.             "lte": 150
    96.           }
    97.         }
    98.       }
    99.     }
    100.   }
    101. }

    5.7 查询结果过滤

    1.  
    2. ###基本使用
    3. GET lqz/_doc/_search
    4. {
    5.   "query": {
    6.     "match_all": {
    7.       }
    8.   },
    9.   "_source":["name","age"]
    10. }
    11.  
    12.  
    13. ####_source和query是平级的
    14.  
    15. GET lqz/_doc/_search
    16. {
    17.   "query": {
    18.     "bool": {
    19.       "must":{
    20.         "match":{"from":"gu"}
    21.       },
    22.       
    23.       "filter": {
    24.         "range": {
    25.           "age": {
    26.             "lte": 25
    27.           }
    28.         }
    29.       }
    30.     }
    31.   },
    32.   "_source":["name","age"]
    33. }
    34.  
    35.  
    36.  
    37.  
    38.

    5.8 高亮查询(未能高亮)

    1. GET lqz/_doc/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "price": "698"
    6.     }
    7.   },
    8.   "highlight": {
    9.     "pre_tags": "",
    10.     "post_tags": "",
    11.     "fields": {
    12.     "from": {}
    13.     }
    14.   }
    15. }

    5.9 聚合函数

    1.  
    2. # sum ,avg, max ,min
    3.  
    4. # select max(age) as my_avg from 表 where from=gu;
    5. GET lqz/_doc/_search
    6. {
    7.   "query": {
    8.     "match": {
    9.       "from": "gu"
    10.     }
    11.   },
    12.   "aggs": {
    13.     "my_avg": {
    14.       "avg": {
    15.         "field": "age"
    16.       }
    17.     }
    18.   },
    19.   "_source": ["name", "age"]
    20. }
    21.  
    22. #最大年龄
    23. GET lqz/_doc/_search
    24. {
    25.   "query": {
    26.     "match": {
    27.       "from": "gu"
    28.     }
    29.   },
    30.   "aggs": {
    31.     "my_max": {
    32.       "max": {
    33.         "field": "age"
    34.       }
    35.     }
    36.   },
    37.   "_source": ["name", "age"]
    38. }
    39.  
    40. #最小年龄
    41. GET lqz/_doc/_search
    42. {
    43.   "query": {
    44.     "match": {
    45.       "from": "gu"
    46.     }
    47.   },
    48.   "aggs": {
    49.     "my_min": {
    50.       "min": {
    51.         "field": "age"
    52.       }
    53.     }
    54.   },
    55.   "_source": ["name", "age"]
    56. }
    57.  
    58. # 总年龄
    59. #最小年龄
    60. GET lqz/_doc/_search
    61. {
    62.   "query": {
    63.     "match": {
    64.       "from": "gu"
    65.     }
    66.   },
    67.   "aggs": {
    68.     "my_sum": {
    69.       "sum": {
    70.         "field": "age"
    71.       }
    72.     }
    73.   },
    74.   "_source": ["name", "age"]
    75. }
    76.  
    77.  
    78.  
    79. #分组
    80.  
    81.  
    82. # 现在我想要查询所有人的年龄段，并且按照`15~20，20~25,25~30`分组，并且算出每组的平均年龄。
    83. GET lqz/_doc/_search
    84. {
    85.   "size": 0, 
    86.   "query": {
    87.     "match_all": {}
    88.   },
    89.   "aggs": {
    90.     "age_group": {
    91.       "range": {
    92.         "field": "age",
    93.         "ranges": [
    94.           {
    95.             "from": 15,
    96.             "to": 20
    97.           },
    98.           {
    99.             "from": 20,
    100.             "to": 25
    101.           },
    102.           {
    103.             "from": 25,
    104.             "to": 30
    105.           }
    106.         ]
    107.       }
    108.     }
    109.   }
    110. }
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
第一章 教育基础（07 心理学基础知识）                            
    
详细讲解什么是单例模式                            
    
获取sku详细信息 API 返回值说明                            
    
《MySQL学习笔记》数据库增删查改（进阶）                            
    
1、Html编程基础                            
    
内蒙古自治区工程系列建设工程专业技术人才职称评审条件                            
    
JVM【八股文】                            
    
视频剪辑中花式抠图的代码实操与案例详述                            
    
C#中的 Attribute 与 Python/TypeScript 中的装饰器是同个东西吗                            
    
Python基础——异常处理                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/qq_52385631/article/details/126374769
                
    •