elasticsearch查询

最新推荐文章于 2024-07-24 11:10:05 发布
最新推荐文章于 2024-07-24 11:10:05 发布
阅读量338 收藏
点赞数
分类专栏： elasticserach 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010519674/article/details/108554296
版权

文章目录

前言

包含内容

  • 索引创建
  • mapping 添加修改
  • 集群健康度
 GET  /_cluster/health?pretty
 
{
  "cluster_name" : "test-es-cluster",
  "status" : "green",  #green 健康   yellow 亚健康  red 病了
  "timed_out" : false,
  "number_of_nodes" : 3,  # 节点数
  "number_of_data_nodes" : 3,  # 数据节点
  "active_primary_shards" : 264,
  "active_shards" : 525,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 0,
  "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" : 100.0
}
  • 查看所有索引状态
 GET /_cat/indices

yellow open test_index_1 MzjlWDJMR3ytnwERULaWsA 5 1 0 0  1kb  1kb
green  open test_index   UNQgrksETpi7rPjGKv-WDA 3 0 0 0 624b 624b
  • 创建索引
  PUT /test_index
  
  {
  	"settings":{
          "index":{
              "number_of_shards": 5, 
              "number_of_replicas": 1
          }
      }
  }

numner_of_shards: 分片数量，默认时1
number_of_replicas: 副本数量一般与节点数保持一致，默认时1

  • 查看创建索引
  GET /test_index
  • 创建索引并添加mapping
  PUT /test_m1
  
  {
      "settings": {
          "index": {
              "number_of_shards": 3,
              "number_of_replicas": 0
          }
      },
      "mappings": {
          "properties": {
              "username": {
                  "type": "text",
                  "index": true
              },
              "password": {
                  "type": "keyword",
                  "index": false
              }
          }
      }
  }

index:false 不进行索引

  • 创建mapping，不指定index
  PUT /test_m2
  
  {
      "mappings": {
          "properties": {
              "username": {
              	"type": "text",
                  "index": true
              },
              "password": {
                  "type": "keyword",
                  "index": false
              }
          }
      }
  }

新增mappings 时不指定索引分片副本，默认是1副本1分片

  • 给新建索引添加mapping
  PUT /test_m3
  
  {
      "mappings":{
          "properties":{
              "username":{
                  "type":"text",
                  "index":true
              },
              "keyword":{
                  "type":"keyword",
                  "index":false
              }
          }
      }
  }

  #另一种方式
 
  PUT /test_m3/_mapping
  
  {
        "properties":{
            "username":{
                "type":"text",
                "index":true
            },
            "keyword":{
                "type":"keyword",
                "index":false
            }
        }
    }

小结

mappings 一旦创建成功后，不能修改，只剩查询、删除

添加文档

  • 新增文档数据
POST /test_m1/_doc/1

{
    "id":1,
    "username":"貂蝉",
    “password":"123456",
    "age":18,
    "gender":"女",
    "desc":"四大美女之一",
    "date_time":"2010-02-23"
}
  • 更新，部分更新
  POST /test_m1/_doc/1
  
  {
      "doc":{
          "desc": "三国美女"
      }
  }
  • 整体更新
  POST /test_m1/_doc/1/_update
  
  {
      "id":1,
      "username":"貂蝉1111",
      “password":"123456",
      "age":18,
      "gender":"女",
      "desc":"四大美女之一",
      "date_time":"2010-02-23"
  }
  • 删除
  DELETE  /test_m1/_doc/1
  • 查询，根据id查询
  GET /test_m1/_doc/1
  • 查询全部
  GET /test_m1/_doc/_search

分词

  • text

username 类型是text,默认分词器使用空格隔开

  GET /test_m1/_analyze
  
  {
      "field": "username",
   	"text": "this is a good idea"
  }
  • kerword

password 类型是keyword，作为一个整体不会进行切分

  GET /test_m1/_analyze
  
  {
      "field": "password",
   	"text": "this is a good idea"
  }
  • 测试任意分词
  GET  /test_m1/_analyze
  
  {
      "analyzer": "standard",
      "text": "THIS is a Good Ideas"
  }

使用standard 对text 进行分词

es 内置了很多分词器，如下

standard: 默认分词，单词会被拆分，大写转小写
simple：按照字母分词，大写转小写
whitespace：按照空格分词，大写转小写
stop: 去掉停用词,大写转小写
keyword：不分词，当成一个整体

中文分词

GET  /test_m1/_analyze

{
    "analyzer": ”ik_max_word“,
    "text": "燃烧我的卡路里"
}

查询

  • QueryString
  GET http://192.168.75.206:9200/test_index/_search?q=desc:爱学习&q=gender:男

DSL

  • 判断是否存在，并展示存在该字段的数据
  GET http://192.168.75.206:9200/test_index/_search
  
  {
      "query":{
          "existis":{
              "fiels":"username"
          }
      }
  }

单个字段查询

  • match 必须匹配
GET /test_m1/_analyze

{
    "query": {
        "match": {
            "nickname": {
                "query": "tom"，
                "analyzer": "standrad"
            }
        }
    }
}

match 先对要查询的词进行分词进行全文检索，再查询出符合分词的结果匹配具体的某一个字段，可以先对查询的词分词看线，分此后结果。

analyzer 指定查询时使用的分词器，必须与存储时使用的分词器一致，存储时分词器，可通过查看mapping 查看

  • match or/and
  GET /test_index/_search
  # and 必须满足所有条件
  {
      “query”:{
          "match":{
              "desc":"学习 java",
              "operator": "and"
          }
      }
  }
  
  # or 必须满足一个条件即可
  {
      “query”:{
          "match":{
              "desc":"学习 java",
              "operator": "or"
          }
      }
  }
  • match - minimum_should_match
  GET /test_index/_search
  
  {
      "query":{
          "match":{
              "desc":{
                  "query":"我在学习elasticsearch日志分析",
                  "minimum_should_match":"80%"
              }
          }
      }
  }

minimum_should_match最小精度匹配，一句话分词后匹配的词的个数. 分词后的词语个数X百分比，得出的数值，就是匹配的精度。举个栗子：一句话分词后又10个词组，如果百分比为50%， 10*50%=5,至少有5个词组匹配就能检索出。

minimum_should_match可选值，数字或者百分比

  • multi_match

    在多个字段中匹配，类似于 or

  GET /test_index/_search
  
  {
      "query":{
          "multi_match":{
              "query":"骑着毛驴去旅行",
              "fields":["username","desc"]
          }
      }
  }
  # 查询的词先进行分词
  GET /_analyzer
  
  {
      "text": "骑着毛驴去旅行",
      "analyzer": "ik_max_word"
  }

multi_match 查询username、desc两个字段，满足骑着毛驴去旅行分词后词语，多个条件是or连接

  • 指定字段和分页
  GET /test_index/_search
  
  {
      "query":{
      	"match_all": {}
      },
      "_source":["username","nickname","city"],
      "from":0,
      "size":3
  }

match_all:查询所有，_source: 显示那些字段

  • term 精确匹配
  GET /test_index/_search
  
  {
      "query":{
          "term":{
              "username":"骑着毛驴去旅行"
           }
      }
  }

term 查询按查询词 骑着毛驴去旅行当作一个整体去查询，如果搜索的词username mapping 类型为非keyword 查询不到。

原因很简单，存储时username 按照默认分词存储，会把骑着毛驴去旅行进行分词，查询时(trem)又是按照一个整体去查, 肯定检索不到。

解决：1. 查询时按照username.keyword去查 2. 设置username 类型为keyword

  • terms 匹配多个词
  GET /test_index/_search
  
  {
      "query":{
          "terms":{
              "username":["骑着毛驴去旅行","他大舅他二舅都是他舅"]
          }
      },
      "_source":["username", "age", "city"],
      "from":0,
      "size":5
  }
  • match_phare短语查询
  GET /test_index/_search
  
  {
      "query":{
          "match_phare":{
              "desc":{
                  "query":"学习 es"，
                  ”slop": 2
              }
          }
      }
  }

match_phare 先分词再查询，只要查询的目标文档中包含学习 es并且两个词之间的间隔为2即可命中查询

  • 主键查询
  GET/POST  /test_index/_search
  
  {
      "query":{
          "ids":{
              "values":["1","3"]
          }
      },
      "_source":["username", "gender", "city"]
  }

  • 权重boost

    权重越高，文档的相关性越大通过 ^ 设置权重

  GET  /test_index/_search
  
  {
      "query":{
          "multi_match":{
              "query":"骑着毛驴去旅行"
              "fields":["desc", "username^5"]
          }
      }
  }

多个字段查询

must 查询条件必须全部匹配，等同于 and
  • bool 同时查询多个字段
  GET /test_index/_search
  
  {
      "query":{
          "bool":{
              "must":[
                  {
                      "match":{
                          "desc":"学习"
                      }
                  },
                  {
                      "term":{
                          "age":18
                      }
                  }
              ]        
          }
      }
  }
  • should 查询条件满足1个以上，类似or
  GET /test_index/_search
  # 类似 select desc, age from person where desc like '%学习%' or age = 18
  
  {
      "query":{
          "bool":{
             "should":[
                  {
                      "match":{
                          "desc":"学习"
                      }
                  },
                 {
                     "term":{
                         "age": 18
                     }
                 }
              ]
          }
      }
  }

  1. must、should、must_not虽然在语法上可以并列写，但must和should组合，should就无效

  2. must和must_not组合时，must筛选后，会将符合must_not条件的剔除

嵌套查询

must于must_not同时使用时，如果要同时生效，可使用如下方法

  • must 与should 同时使用
  1. “minimum_should_match”:1 should条件就生效了，1 的意思是至少满足should中1个条件
  GET /test_index/_search
  
  {
      "query": {
          "bool":{
              "must":[
                  {
                      "match":{
                          "desc":"学习"
                      }
                  }
              ],
              "should":[
                  {
                      "match":{
                     		"nickname":"太阳"                        
                      }
  
                  },
                  {
                      "term":{
                          "gender":"男
                      }
                  }
              ],
              "minimum_should_match":1 
          }
      }
  }
  1. should嵌套 must
  • where (desc=‘学习’ and nicknanme=‘日出’) or (desc=‘学习’ and username=‘jacktian’)
  GET /test_index/_search
  
  {
      "query":{
          "bool":{
              "should":[
                  {
                      "bool":{
                          "must":[
                              {
                                  "match":{
                                       "desc":"学习"
                                  }
                                 
                              },
                              {
                                  "match":{
                                        "nickname":"日出"
                                  }
                              }
                          ]
                      }
                  },
                  {
                      "bool":{
                          "must":[
                              {
                                  "match":{
                                       "desc":"学习"
                                  }
                                 
                              },
                              {
                                  "term":{
                                      "username":"jacktian"
                                  } 
                              }
                          ]
                      }
                  }
              ]
          }
      }
  }

规则

bool 包好多个查询条件，
must、should、must_not：[] 形式，包含多个不同字段。类似于sql(username=‘张三’ and/or password=‘123456’
match、term、multi_match：具体某一个字段的查询条件类似于sql(username=‘张三’)

  1. must嵌套should
  • where desc=‘学习’ and (nicknanme=‘日出’ or username=‘jacktian’)
  GET /test_index/_search
  
  {
      "query":{
          "bool":{
              "must":[
                  {
                   	"match":{
                          "desc":"学习"
                      }   
                  },
                  {
                      "bool":{
                      	"should":[
                              {
                                  "match":{
                                      "nickname":"日出"
                                  }
                              },
                              {
                                  "term":{
                                      "username":"jacktian"
                                  }
                              }
                          ]
                  	}
                  }
              ]
          }
      }
  }
  • range
  GET /test_index/_search
  
  {
      "query":{
          "range":{
              "price":{
                  "gte": 1000,
                  "lte": 5000
              }
          }
      }
  }

查询价格再[1000, 5000]之间数据

批量操作

  • mapping
  PUT /bulk_index
  
  {
      "settings": {
          "index": {
              "number_of_shards": 3,
              "number_of_replicas": 0
          }
      },
      "mappings": {
          "properties": {
              "id": {
                  "type": "integer"
              },
              "name": {
                  "type": "keyword"
              },
              "nickname": {
                  "type": "text",
                  "analyzer": "ik_max_word"
              },
              "age": {
                  "type": "integer"
              },
              "gender": {
                  "type": "text"
              },
              "city": {
                  "type": "keyword"
              },
              "desc": {
                  "type": "text",
                  "analyzer": "ik_max_word"
              },
              "consume": {
                  "type": "long"
              }
          }
      }
  }
  
  POST /_bulk
  
  {"create":{"_index":"bulk_index","_type":"_doc","_id":1}}
  {"id":1,"name":"诸葛亮","nickname":"骑着毛驴去旅行","age":23,"gender":"男","city":"北京","desc":"我在学习elsticsearch，了解了很多新知识，进步很大","consume":2000.36}
  {"create":{"_index":"bulk_index","_type":"_doc","_id":2}}
  {"id":2,"name":"张飞","nickname":"一只小蜗牛","age":26,"gender":"男","city":"上海","desc":"一起来学习java，共同交流","consume":6239.12}
  {"create":{"_index":"bulk_index","_type":"_doc","_id":3}}
  {"id":3,"name":"貂蝉","nickname":"采蘑菇的小姑娘","age":18,"gender":"女","city":"郑州","desc":"喜欢舞蹈、唱歌，撸串，在学习吉他","consume":5000.75}
  {"create":{"_index":"bulk_index","_type":"_doc","_id":2}}
  {"id":4,"name":"武则天","nickname":"女王陛下","age":32,"gender":"女","city":"西安","desc":"我在学习mysql高级引用，认识了很多新同学，以后想成为一名老师","consume":8000.25}
  {"create":{"_index":"bulk_index","_type":"_doc","_id":5}}
  {"id":5,"name":"秦始皇","nickname":"飞上太空和太阳肩并肩","age":40,"gender":"男","city":"深圳","desc":"技术宅，喜欢编程，喜欢撸串、炸鸡、啤酒、可乐、矿泉水","consume":8000.25}
  • index
  POST /bulk_index/_doc/_bulk
  
  {"index":{"_id":1}}
  {"id":1,"name":"诸葛亮","nickname":"骑着毛驴去旅行","age":23,"gender":"男","city":"北京","desc":"我在学习elsticsearch，了解了很多新知识，进步很大","consume":2000.36}
  
  {"index":{"_id":2}}
  {"id":2,"name":"张飞","nickname":"一只小蜗牛","age":26,"gender":"男","city":"上海","desc":"一起来学习java，共同交流","consume":6239.12}
  {"index":{"_id":3}}
  {"id":3,"name":"貂蝉","nickname":"采蘑菇的小姑娘","age":18,"gender":"女","city":"郑州","desc":"喜欢舞蹈、唱歌，撸串，在学习吉他","consume":5000.75}
  • update
  POST /bulk_index/_doc/_bulk
  
  {"update":{"_id":1}}
  {"doc":{"name":"诸葛亮111"}}
  
  {"update":{"_id":2}}
  {"doc":{"desc":"java学完了，开始学习golang"}}
  • 删除
  POST /bulk_index/_doc/_bulk
  
  {"delete":{"_id":1}}
  {"delete":{"_id":2}}

模板

POST /_scripts/tpdesc

{
    "script": {
        "lang": "mustache",
        "source": {
            "query": {
                "match": {
                    "desc": {
                        "query": "{{desc_value}}",
                        "analyzer": "{{desc_analyzer}}"
                    }
                }
            }
        }
    }
}

# 查询
GET /test_index/_search/tpdesc

{
	"id":"tpdesc",
	"params":{
		"desc_value":"学习",
		"desc_analyzer":"ik_max_word"
	}
}
  • update_by_word
  {
      "query":{
          "match":{
              "nickanme":"骑着毛驴去旅行"
  
             
          }
      }
  }
  • 创建索引
PUT /update_index_test

{
    "settings": {
        "index": {
            "number_of_shards": 5,
            "number_of_replicas": 0
        }
    },
    "mappings": {
        "properties": {
            "username": {
                "type": "text",
                "analyzer": "ik_max_word"
            },
            "nickname": {
                "type": "text",
                "analyzer": "ik_max_word",
                "fields": {
                    "keyword": {
                        "type": "keyword"
                    }
                }
            }
        }
    }
}

# 写数据
POST /update_index_test/_doc/_bulk
{"index":{"_id":1}}
{"id":1,"username":"诸葛亮","nickname":"骑着毛驴去旅行"}
{"index":{"_id":2}}
{"id":2,"username":"张飞","nickname":"一只小蜗牛"}
{"index":{"_id":3}}
{"id":3,"username":"貂蝉","nickname":"采蘑菇的小姑娘"}

Ta来了Ta来了
关注
专栏目录
Elasticsearch in 查询 和not in 查询的实现方式
wei_bo_cai的博客
02-05 5475
in POST products/_search { "query": { "bool": { "filter": [ { "terms": { "product_id": ["1","2"] } } ] } } } 或是 POST products/_search { "query": { "bool": { "must": [
es查询字段更新记录_ElasticSearch查询 第二篇：文档更新
weixin_39661345的博客
12-19 1436
《ElasticSearch查询》目录导航：ElasticSearch是性能优化的分布式全文搜索引擎，存储数据的载体是文档(Document)，它的优势在于搜索速度快和支持聚合操作，在更新文档时，基本上能够达到实时搜索。ElasticSearch引擎总是按照文档标识来更新数据，并发控制是通过顺序的版本ID(version)实现的，控制写-写、写-读冲突，实现数据弱一致性。在ElasticSearc...
ElasticSearch.net In查询
星辉Johnson的博客
04-21 1606
public PUB_StockSearchResult SearchModelArr(PUB_StockSearch param)         {             PUB_StockSearchResult result = new PUB_StockSearchResult();             result.ResultList = new List();    
ElasticSearch(四)— 数据检索与查询
最新发布
敲代码的小小酥的博客
07-24 2037
所有的 REST 搜索请求使用_search 接口，既可以是 GET 请求，也可以是 POST请求，也可以通过在搜索 URL 中指定索引来限制范围。_search 接口有两种请求方法，一种是基于 URI 的请求方式，另一种是基于请求体的方式，无论哪种，他们执行的语法都是基于 DSL（ES 为我们定义的查询语言，基于 JSON 的查询语言），只是形式上不同。我们会基于请求体的方式来学习。分页参数，from代表从第几页开始，size代表了返回文档的数量。
Elasticsearch 最佳实践！
民工哥的博客
10-08 862
点击上方“民工哥技术之路”，选择“设为星标”回复“1024”获取独家整理的学习资料！之前在IDC机房环境部署了一套ELK日志集中分析系统, 这里简单总结下ELK中Elasticsearc...
es数据更新时间_Elasticsearch Lucene 数据写入原理 | ES 核心篇
weixin_39634900的博客
11-21 588
前言最近 TL 分享了下 《Elasticsearch基础整理》https://www.jianshu.com/p/e8226138485d ，蹭着这个机会。写个小文巩固下，本文主要讲 ES -> Lucene的底层结构，然后详细描述新数据写入 ES 和 Lucene 的流程和原理。这是基础理论知识，整理了一下，希望能对 Elasticsearch 感兴趣的同学有所帮助。一、Elastics...
elasticsearch in查询_Elasticsearch系列---近似匹配
weixin_39889597的博客
11-29 305
### 概要前面的match查询只能告诉我们，搜索的文档里有这些关键词，但无法告知词语之间的顺序，而不同的词语顺序表达的意思可能完全相反。我们想要的，是跟我们期望搜索的语义要相似，这就需要短语匹配和近似匹配来控制了。### 短语搜索短语搜索即把一小段话完完整整地进行搜索，必须保证被搜索的文档内有一模一样的才行，如下：```javaGET /music/children/_search{ "qu...
ES查询客户端，elasticsearch可视化工具 elasticsearch查询客户端
06-20
Elasticsearch查询客户端是用于与ES服务器通信的软件，它们提供了多种语言的API，允许开发者以编程方式执行索引、搜索、更新和删除等操作。常见的Elasticsearch客户端包括： - **Jest**：一个轻量级的Java REST...
ES查询客户端，elasticsearch可视化工具
06-24
elasticsearch的客户端比较出名的就是elasticsearch head 和Kibana了， 但是elasticsearch head已经停止更新，且样式老旧，功能不全； 而Kibana虽功能全面，但是启动麻烦，大部分功能用不上，很不灵活，所以采用vite...
JAVA使用ElasticSearch查询in和not in的实现方式
08-26
JAVA使用ElasticSearch查询in和not in的实现方式 Elasticsearch是一个基于Lucene的搜索服务器，提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。它是用Java开发的，并作为Apache许可条款下的开放...
对ElasticsearchPHP进行查询语句封装可实现链式调用方便es查询
08-07
在本项目中，“对Elasticsearch-PHP进行查询语句封装 可实现链式调用 方便 es查询”，主要涉及到的知识点有： 1. **Elasticsearch查询语句**：Elasticsearch支持丰富的查询语法，如match查询、term查询、range查询...
ElasticSearch 实现sqlIn查询
qq_38243173的博客
12-24 3518
比如查询 text in ('1','2','3'); 1.使用should BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery(); boolBuilder.should(QueryBuilders.matchPhraseQuery("param", "1")); boolBuilder.should(QueryBuilders.matchPhraseQuery("param", "2")); boolBuilder.should(Query
Elasticsearch入门教程(五)：Elasticsearch查询(一)
人不风流枉少年
02-01 4146
// 准备数据 PUT /shop/goods/1 { "name": "2017新款女装冬季外套ulzzang棉袄中长款棉衣韩版百搭棉服面包服", "desc": "", "price": 268, "quantit
【ES】Elasticsearch 常见的简单查询
一个写了10年bug的程序员日常笔记。
08-23 1732
Elasticsearch 常见的简单查询
elasticsearch in查询_使用Elasticsearch实现同段和同句搜索
weixin_39979167的博客
11-28 1017
同句搜索要求搜索多个关键词时，返回的文章不只要包含关键词，而且这些关键词必须在同一句中。同段搜素类似，只是范围为同一段落。SpanQuery同段、同句搜索，使用常用的 term、match 查询，没有找到办法可以实现。Elasticsearch 提供了 SpanQuery，官方文档中如下的介绍：Span queries are low-level positional queries w...
ElasticSearch查询语法
欢迎大家关注
05-05 5516
ElasticSearch查询语法
Elasticsearch文档读写模型实现原理
中间件兴趣圈
10-23 2150
   ES系列基于ElasticSearch6.4.x版本。 1、简介    ElasticSearch，每个索引被分成多个分片（默认每个索引5个主分片primary shard），每个分片又可以有多个副本。当一个文档被添加或删除时（主分片中新增或删除），其对应的复制分片之间必须保持同步。如果我们不这样做，主要对于同一个文档的检索请求，得到的结果将不一致。保持分片副本同步和服务读取的过程就是我们所...
ElasticSearch：查询操作合集
weixin_44384273的博客
04-18 2130
ElasticSearch：查询操作合集
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值