es的语法操作命令

灰太狼 2024-03-25 11:20 57阅读 0赞

### 查询 ###

#查询所有索引和详情信息
    #此方法查询的显示更加详细的索引信息显示
    GET /_cat/indices?v
    GET /_cat/indices
    
    #查询某个索引
    GET person
    
    #查询全部索引的状态数据
    GET /_cat/indices?v
    
    #查询
    GET http://ip:端口/索引名称  # 查询单个索引信息
    GET http://ip:端口/索引名称1,索引名称2...  # 查询多个索引信息
    GET http://ip:端口/_all  # 查询所有索引信息
    
    #查询索引user映射
    GET user/_mapping
    
    #查询user索引文档，指定id
    GET /user/_doc/1
    
    #查询user索引所有文档
    GET /user/_search

### 添加 ###

#添加
    PUT http://ip:端口/索引名称
    
    #添加索引
    PUT user
    
    #创建索引并添加映射（推荐）
    PUT /person1
    {
        
      "mappings": {
        
        "properties": {
        
          "name": {
        
            "type": "text"
          },
          "age": {
        
            "type": "integer"
          }
        }
      }
    }
    
    #添加字段（属性）
    PUT /person1/_mapping
    {
        
      "properties": {
        
        "name": {
        
          "type": "text"
        },
        "age": {
        
          "type": "integer"
        },
        "createTime": {
        
            "type": "date",
            "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
          }
      }
    }
    ##如果需要用时间范围查询，必须要设置"type": "date"和"format"
    #请注意，在设置日期映射时，建议使用Elasticsearch支持的日期格式，并根据需要选择正确的日期格式。此外，如果您已经创建了索引并且需要更新日期映射，可以使用Update Mapping API来更新。
    
    #添加文档，指定id
    POST /person/_doc/1
    {
        
      "name":"张三",
      "age":18,
      "address":"北京"
    }
    
    #添加文档，不指定id
    POST /person1/_doc/
    {
        
      "name":"张三",
      "age":18,
      "address":"北京"
    }
    
    #字段"tel"不可以进行查询，不然会报错只因创建映射时"tel"的"index"为false
    {
        
        "user": {
        
            "mappings": {
        
                "properties": {
        
                    "name": {
        
                        "type": "text"
                    },
                    "sex": {
        
                        "type": "keyword"
                    },
                    "tel": {
        
                        "type": "keyword",
                        "index": false
                    }
                }
            }
        }
    }
    
    
    
    #实现模糊检索，类似于SQL中的like条件，这个需求我们使用wildcard类型字段来实现. 
    对同一个字段即可实现模糊检索，也能实现分词检索（我们原来使用text类型字段+ik分词器实现），这两种检索应用于同一字段
    定义字段 name：【使用示例，就是在已经固定的mapping映射上加属性，因为已经添加的属性不能修改，只能添加】
    "name": {
        
    	"type": "text",
    	"fields": {
        
      		"wildcard": {
        
      		"type": "wildcard"
      		},
      		"ik": {
        
      		"type": "text",
      		"analyzer": "ik_max_word"
      		}
    	}
    }
    #然后进行检索如下，可以同时对 name.wildcard 和 name.ik 字段进行检索
    {
        
    	"query": {
        
    		"multi_match": {
        
    		"query": "查询关键词",
    		"fields": ["name.wildcard", "name.ik"]
    		}
    	}
    }

### 修改 ###

#局部更新
    POST /user/_update/4
    {
        
      "doc": {
        
        "email":"88886"
      }
    }
    
    #全量更新，存在就更新，不存在就创建
    POST /user/_doc/4
    {
        
       "name" : "王九",
       "sex" : "男性",
       "tel" : "99"
    }

### 删除 ###

#删除索引
    DELETE /索引名称
    #例如删除索引dev
    DELETE /dev
    
    #删除指定id文档
    DELETE /person/_doc/1
    
    #删除某个文档中的属性
    POST user/_doc/1/_update
    {
        
        "script" : "ctx._source.remove('new_field')"
    }
    
    # 按照查询条件进行删除
    POST user/_delete_by_query
    {
        
      "query":{
        
        "match_phrase":{
        
          "catagoryId": "1643191714195750913"
        }
      }
    }

### 高级ur路径查询 ###

#查询name端包含王或者九的
    GET /user/_search?q=name:王九
    
    #URL带参数形式查询，这很容易让不善者心怀恶意，或者参数值出现中文会出现乱码情况。为了避免这些情况，我们可用使用带JSON请求体请求进行查询

### 高级查询term ###

#term是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词拆解
    GET user/_search
    {
        
      "query": {
        
        "term": {
        
          "FIELD": {
        
            "value": "VALUE"
          }
        }
      }
    }
    
    
    #terms里的[ ] 多个是或者的关系，只要满足其中一个词就可以
    GET user/_search
    {
        
      "query": {
        
        "terms": {
        
          "FIELD": [
            "VALUE1",
            "VALUE2"
          ]
        }
      }
    }
    
    #terms里的[ ] 多个是或者的关系，只要满足其中一个词就可以。想要通知满足两个词的话，就得使用bool的must来做
    GET user/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
        "term": {
        
              "FIELD": {
        
                "value": "VALUE"
              }
            }},
            {
        
              "term": {
        
                "FIELD": {
        
                  "value": "VALUE"
                }
              }
            }
          ]
        }
      }
    }

### 高级查询match ###

#查找所有文档内容
    GET user/_search
    {
        
    	"query":{
        
    		"match_all":{
        }
    	}
    }
    
    
    # 查询全部文档指定字段
    GET user/_search
    {
        
    	"query":{
        
    		"match_all":{
        }
    	},
    	"_source":["FIELD"]
    }
    
    
    
    
    
    #match进行搜索的时候，会先进行分词拆分，拆完后，再来匹配
    GET user/_search
    {
        
      "query": {
        
        "match": {
        
          "FIELD": "TEXT"
        }
      }
    }
    
    #match_phrase 称为短语搜索，要求所有的分词必须同时出现在文档中，同时位置必须紧邻一致
    GET user/_search
    {
        
    "query": {
        
      "match_phrase": {
        
        "FIELD": "PHRASE"
      }
    }
    
    
    # 上面的 MatchQuery 有一个短板，假如用户输入了某关键字，我们在查找的时候并不知道他输入的是 name 还是 description，这时我们用什么都不合适，而 MultiQuery 的出现解决了这个问题，他可以通过 fields 属性来设置多个域联合查找
    GET user/_search
    {
        
        "query": {
        
            "multi_match": {
        
                "query": "Spring开发",
                "minimum_should_match": "70%",
                "fields": ["name", "description"]
            }
        }
    }
    }
    
    
    # 在多域联合查询的时候，可以通过 boost 来设置某个域在计算得分时候的比重，比重越高的域当他符合条件时计算的得分越高，相应的该记录也更靠前。通过在 fields 中给相应的字段用 ^权重倍数来实现
    GET user/_search
    {
        
        "query": {
        
            "multi_match": {
        
                "query": "Spring开发",
                "minimum_should_match": "70%",
                "fields": ["name^10", "description"]
            }
        }
    }
    }

### 多条件查询，must相当于数据库的&&，should相当于数据库的|| ###

#must相当于数据库的&&
    GET user/_search
    {
        
    	"query":{
        
    		"bool":{
        
    			"must":[{
        
    				"match":{
        
    					"name":"小王"
    				}
    			},{
        
    				"match":{
        
    					"age":18
    				}
    			}]
    		}
    	}
    }
    
    
    #should相当于数据库的||
    GET user/_search
    {
        
    	"query":{
        
    		"bool":{
        
    			"should":[{
        
    				"match":{
        
    					"name":"小王"
    				}
    			},{
        
    				"match":{
        
    					"age":18
    				}
    			}]
    		}
    	}
    }

### 如果我们既要对一些字段进行分词查询，同时要对另一些字段进行精确查询，就需要使用布尔查询来实现了。布尔查询对应于Lucene的BooleanQuery查询，实现将多个查询组合起来，有三个可选的参数：must：文档必须匹配must所包括的查询条件，相当于 “AND”should：文档应该匹配should所包括的查询条件其中的一个或多个，相当于 "OR"must\_not：文档不能匹配must\_not所包括的该查询条件，相当于“NOT” ###

GET user/_search
    {
        
        "query": {
        
            "bool": {
         // 布尔查询
                "must": [ // 查询条件 must 表示数组中的查询方式所规定的条件都必须满足
                    {
        
                        "multi_match": {
        
                            "query": "王小妹",
                            "minimum_should_match": "50%",
                            "fields": [
                                "name^10",
                                "title"
                            ]
                        }
                    },
                    {
        
                        "term": {
        
                            "address": "广州"
                        }
                    }
                ]
            }
        }
    }

### 分页查询 ###

GET user/_search
    {
        
    	"query":{
        
    		"match_all":{
        }
    	},
    	"from":0,
    	"size":2
    }

### 查询排序，支持对 keyword、date、float 等类型添加排序，text类型的字段不允许排序，text因为会分词，所以排序不了 ###

{
        
    	"query":{
        
    		"match_all":{
        }
    	},
    	"sort": [
        {
        
          "age": {
        
            "order": "desc"
          }
        }
      ]
    }

### 范围查询 ###

GET user/_search
    {
        
    	"query":{
        
    		"bool":{
        
    			"should":[{
        
    				"match":{
        
    					"name":"小王"
    				}
    			},{
        
    				"match":{
        
    					"age":18
    				}
    			}],
    			"filter": [
    			  {
        "range": {
        
    			    "age": {
        
    			      "gte": 10,
    			      "lte": 20
    			    }
    			  }}
    			]
    		}
    	}
    }

### 全文检索 ###

{
        
    	"query":{
        
    		"match":{
        
    			"name" : "王妹"
    		}
    	}
    }

### 高亮查询，高亮展示的数据，本身就是文档中的一个field，单独将field以highlight的形式返回给你。 ###

ES提供了一个highlight属性，和query同级别的

GET user/_search
    {
        
      "query": {
        
        "match_phrase": {
        
          "name": "张三"
        }
      },
      "highlight": {
        
        "fields": {
        
          "name": {
        }
        },
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fragment_size": 10
      }
        }
    }
    
    
    #全文高亮检索
    GET person1/_search
    {
        
      "query": {
        
        "multi_match": {
        
          "query": "广州",
          "fields": []
        }
      },
      "highlight": {
        
        "fields": {
        
          "*": {
        }
        }
      }
    }

> fragment\_size ：指定高亮数据展示多少个字符回来；  
> pre\_tag：指定前缀标签，如 < font color=“red”>  
> post\_tags：指定后缀标签，如 < /font>  
> field：指定那个字段为高亮字段

### 定义过滤器查询，是在原本查询结果的基础上对数据进行筛选，因此省略了重新计算的分的步骤，效率更高。并且方便缓存。推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用，过滤器在布尔查询中使用，过滤查询和检索查询能做一样的效果。区别在于过滤查询不评分，结果能缓存，检索查询要评分，结果不缓存。 一般是不会直接使用过滤查询，都是在检索了一定数据的基础上再使用，下边是在搜索结果的基础上进行过滤 ###

GET user/_search
    {
        
        "query": {
        
            "bool": {
        
                "must": [
                    {
        
                        "multi_match": {
        
                            "query": "王小妹",
                            "minimum_should_match": "50%",
                            "fields": [
                                "name^10",
                                "title"
                            ]
                        }
                    }
                ],
                "filter": [
                    {
        
                        // 过滤条件：studymodel 必须是 201001
                        "match": {
        "address": "广州"}
                    },
                    {
        
                        // 过滤条件：年龄 >=10 <=100
                        "range": {
        "age": {
        "gte": 10,"lte": 100}}
                    }
                ]
            }
        }
    }

### 分组查询 ###

GET user/_search
    {
        
      "aggs": {
        
        "gg_gl": {
        
          "terms": {
        
            "field": "age"
          }
        }
      },
      "size": 0
    }

### 高级映射嵌套\*\*【字段type设置为keyword就不会被分词】 ###

#嵌套节点下面新增字段
    PUT /user/_mapping
    
    {
        
        "properties": {
        
            "school": {
        
                "type": "keyword",
                "norms": false,
                "doc_values": false
            },
            "teacher": {
        
                "type": "nested",
                "properties": {
        
                    "rightStatus": {
        
                        "type": "keyword",
                        "norms": false,
                        "doc_values": false
                    },
                    "rightCurrTime": {
        
                        "type": "keyword",
                        "norms": false,
                        "doc_values": false
                    }
                }
            }
        }
    }

## \#关闭、打开索引（关闭索引是为了释放内存，将数据持久化到硬盘，不可读写已经关闭的索引） ##

POST http://ip:端口/索引名称/_close  
    
    POST http://ip:端口/索引名称/_open ```

### IK分词器有两种分词模式：ik\_max\_word和ik\_smart模式 ###

### linux系统安装分词器，首先docker安装es ###

### 进入到es ###

docker exec -it elasticsearch /bin/bash

### 执行安装ik分词器（注意安装的分词器需要与es版本一直，不一致更改一下ik分词器的版本号） ###

./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.0/elasticsearch-analysis-ik-7.12.0.zip

### 安装成功后，可以再宿主机es挂卷的plugin下看到ik文件，然后必定要重启es容器 ###

docker restart elasticsearch

### 在kibana上操作，查看分词器结果\*\*【注意如是是英文字母大写，使用默认分词器分词后都会变成小写】 ###

GET /_analyze
    {
        
      "analyzer": "ik_smart",
      "text": "东哥是前端大佬"
    }
    
    
    #结果
    {
        
      "tokens" : [
        {
        
          "token" : "东",
          "start_offset" : 0,
          "end_offset" : 1,
          "type" : "CN_CHAR",
          "position" : 0
        },
        {
        
          "token" : "哥",
          "start_offset" : 1,
          "end_offset" : 2,
          "type" : "CN_CHAR",
          "position" : 1
        },
        {
        
          "token" : "是",
          "start_offset" : 2,
          "end_offset" : 3,
          "type" : "CN_CHAR",
          "position" : 2
        },
        {
        
          "token" : "前端",
          "start_offset" : 3,
          "end_offset" : 5,
          "type" : "CN_WORD",
          "position" : 3
        },
        {
        
          "token" : "大佬",
          "start_offset" : 5,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 4
        }
      ]
    }

### ES数据类型 ###

聚合：相当于mysql 中的sum（求和）  
text：会分词，不支持聚合  
keyword：不会分词，将全部内容作为一个词条，支持聚合  
integer：数值类型  
boolean：布尔  
binary：二进制  
integer\_range, float\_range, long\_range, double\_range, date\_range ：范围类型  
date：日期  
\[ \] Nested: nested (for arrays of JSON objects 数组类型的JSON对象)：数组  
\{ \} Object: object(for single JSON objects 单个JSON对象)：对象

> GET：用来获取资源  
> POST：用来新建资源（也可以用于更新资源）  
> PUT：用来更新资源  
> DELETE：用来删除资源
> 
>  *  ES 5.x中一个index可以有多种type。
>  *  ES 6.x中一个index只能有一种type。
>  *  ES 7.x以后，将逐步移除type这个概念，现在的操作已经不再使用，默认\_doc  
>     \#查看索引下的字段映射，es版本为7的可使用一下命令，在mapping?后加上format=json&include\_type\_name=true  
>     GET /user/\_doc/\_mapping?format=json&include\_type\_name=true