ElasticSearch~http操作
Linux

索引操作

创建索引

PUT /index_name

{
    "acknowledged": true,         // 响应结果
    "shards_acknowledged": true,   // 分片结果
    "index": "index_name"           // 索引名称
}

  • 注意：创建索引库的分片数默认 1 片，在 7.0.0 之前的 Elasticsearch 版本中，默认 5 片

  • 如果重复添加索引，会返回错误信息

    {
    "error": {
        "root_cause": [
            {
                "type": "resource_already_exists_exception",
                "reason": "index [index_name/RGwDu1G-Q72xELbHlBspLQ] already exists",
                "index_uuid": "RGwDu1G-Q72xELbHlBspLQ",
                "index": "index_name"
            }
        ],
        "type": "resource_already_exists_exception",
        "reason": "index [index_name/RGwDu1G-Q72xELbHlBspLQ] already exists",
        "index_uuid": "RGwDu1G-Q72xELbHlBspLQ",
        "index": "index_name"
    },
    "status": 400
}

查看所有索引

GET /_cat/indices 

{
    "0": {
        "health": "yellow",                 // 当前服务器健康状态：green(集群完整) yellow(单点正常、集群不完整) red(单点不正常)
        "status": "open",                   // 索引打开、关闭状态
        "index": "lawyer_infos",                // 索引名
        "uuid": "05YOLo3sQTqT_eKN_4uYJw",       // 索引统一编号 
        "pri": "1",                         // 主分片数量
        "rep": "1",                         // 副本数量
        "docs.count": "151011",                 // 可用文档数量
        "docs.deleted": "0",                    // 文档删除状态（逻辑删除）
        "store.size": "15.9mb",                 // 主分片和副分片整体占空间大小
        "pri.store.size": "15.9mb"                  // 主分片占空间大小
    },
    ... ...
}

查看单个索引

GET /index_name

{
    "index_name": {                   // 索引名
        "aliases": {},                // 别名
        "mappings": {},               // 映射
        "settings": {             // 设置
            "index": {                // 索引设置
                "routing": {          // 
                    "allocation": {
                        "include": {
                            "_tier_preference": "data_content"
                        }
                    }
                },
                "number_of_shards": "1",            // 主分片数量
                "provided_name": "index_name",
                "creation_date": "1678154179067",
                "number_of_replicas": "1",          // 副分片数量
                "uuid": "RGwDu1G-Q72xELbHlBspLQ",
                "version": {
                    "created": "7110199"
                }
            }
        }
    }
}

删除索引

DELETE /index_name

{
    "acknowledged": true
}

索引不存在

{
    "error": {
        "root_cause": [
            {
                "type": "index_not_found_exception",
                "reason": "no such index [index_name]",
                "resource.type": "index_or_alias",
                "resource.id": "index_name",
                "index_uuid": "_na_",
                "index": "index_name"
            }
        ],
        "type": "index_not_found_exception",
        "reason": "no such index [index_name]",
        "resource.type": "index_or_alias",
        "resource.id": "index_name",
        "index_uuid": "_na_",
        "index": "index_name"
    },
    "status": 404
}

文档操作

创建文档

POST /index_name/_doc

  • 请求的方式必须为 POST，不能是 PUT

  • _type 是早期版本的设计缺陷。

    • 在5.x以前的版本里边,一个所以下面是支持多个type的。

    • 6版本以后改为只支持一个type, type可以自定义。

    • 7以后所有的typr就默认为 _doc.

    • 8版本后移除type

请求

{
    "title":"zbuzhi",
    "age":28
}

响应

{
    "_index": "index_name",             // 索引
    "_type": "_doc",                    // 类型-文档
    "_id": "hsPsuYYBMW1qOO0fU7eE",      // 唯一标识，类比为 MySQL 中的主键，随机生成
    "_version": 1,                            // 版本
    "result": "created",                        // 这里的 create 表示创建成功
    "_shards": {
        "total": 2,                   // 分片 - 总数
        "successful": 1,          // 分片 - 成功
        "failed": 0                   // 分片 - 失败
    },
    "_seq_no": 0,
    "_primary_term": 1
}

创建文档 - 指定唯一标识

POST /index_name/_doc/1

  • 注意：如果增加数据时明确数据主键，那么请求方式也可以为 PUT
  • 如果已存在该ID，此操作就变成更新操作

请求

{
    "title":"zbuzhi",
    "age":28
}

响应

{
    "_index": "index_name",
    "_type": "_doc",
    "_id": "1",                 // 对应生成的ID，就是指定的ID
    "_version": 1,
    "result": "created",            // 如果已存在该ID，此操作就变成更新操作，对应的值为 “updated”
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 1,
    "_primary_term": 1
}

查看文档

按ID查

GET /index_name/_doc/1

{
    "_index": "index_name",     // 索引
    "_type": "_doc",            // 文档类型
    "_id": "1",
    "_version": 5,
    "_seq_no": 5,
    "_primary_term": 1,
    "found": true,                // 查询结果:true 表示查找到，false 表示未查找到
    "_source": {              // 文档源信息
        "title": "zbuzh1i",
        "age": 28
    }
}

查询所有

GET POST /index_name/_search

请求 (不传下面的请求参数结果也一样)

{
    "query": {                // 这里的 query 代表一个查询对象，里面可以有不同的查询属性
        "match_all": {}           // 查询类型，例如：match_all(代表查询所有)， match，term ， range 等等 # {查询条件}：查询条件会根据类型的不同，写法也有差异
    }
}

响应

{
    "took": 0,                // 查询花费的时间，单位毫秒
    "timed_out": false,           // 是否超时
    "_shards": {          // 分片信息
        "total": 1,               // 总数
        "successful": 1,      // 成功
        "skipped": 0,         // 忽略/跳过
        "failed": 0               // 失败
    },
    "hits": {                 // 搜索命中的结果
        "total": {                    // 搜索条件匹配的文档总数
            "value": 20,              // 总命中计数的值
            "relation": "eq"                // eq 表示计数准确， gte 表示计数不准确
        },
        "max_score": 1,               // 匹配度分值
        "hits": [                 // 命中结果的集合
            ... ...
        ]
    }
}

匹配查询

match 匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是 or 的关系

GET /index_name/_search

请求

{
    "query": {
        "match": {
            "title": "hello"
        }
    }
}

字段匹配查询

multi_match 与 match 类似，不同的是它可以在多个字段中查询

GET /index_name/_search

请求

{
    "query": {
        "multi_match": {
            "query": "zhangsan",
            "fields": ["name", "nickname"]
        }
    }
}

关键字精确查询

term 查询，精确的关键词匹配查询，不对查询条件进行分词。

GET /index_name/_search

请求

{
    "query": {
        "term": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}

多关键字精确查询

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。

GET /index_name/_search

请求

{
    "query": {
        "terms": {
            "name": ["zhangsan", "lisi"]
        }
    }
}

指定查询字段

对 _source 的结果进行过滤

GET /index_name/_search

请求

{
    "_source": ["name", "nickname"],
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}

过滤字段

includes: 来指定想要显示的字段

excludes: 来指定不想要显示的字段

{
    "_source": {
        "includes": ["name"]
    },
    "query":{
        "terms":{
            "nickname": ["zhangsan"]
        }
    }
}

组合查询

bool把各种其它查询通过must（必须 ）、must_not（必须不）、should（应该）的方式进行组合

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "name": "zhangsan"
                    }
                }
            ],
            "must_not": [
                {
                    "match": {
                        "age": 40
                    }
                }
            ],
            "should": [
                {
                    "match": {
                        "sex": "男"
                    }
                }
            ]
        }
    }
}

范围查询

gt >

gte >=

lt <

lte <=

{
    "query": {
        "range": {
            "age": {
                "gte": 30,
                "lte": 35
            }
        }
    }
}

模糊查询

返回包含与搜索字词相似的字词的文档

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

  • 更改字符（box → fox）
  • 删除字符（black → lack）
  • 插入字符（sic → sick）

  • 转置两个相邻字符（act → cat）

    为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。
    通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。

{
    "query": {
        "fuzzy": {
            "title": {
                "value": "zhangsan"
            }
        }
    }
}
{
    "query": {
        "fuzzy": {
            "title": {
                "value": "zhangsan",
                "fuzziness": 2
            }
        }
    }
}

单字段排序

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ]
}

多字段排序

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

高亮查询

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "highlight": {
        "pre_tags": "<font color='red'>",       // 前置标签
        "post_tags": "</font>",                // 后置标签
        "fields": {                           // 需要高亮的字段
            "name": {}                
        }
    }
}

分页查询

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ],
    "from": 0,                        // 当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size
    "size": 2                     // 每页显示多少条
}

聚合查询

{
    "aggs": {
        "max_age": {
            "max": {          // 最大值，最小值用min
                "field": "age"
            }
        }
    },
    "size": 0                 // 为了只输出聚合查询结果，不输出命中的数据，把size设为0
}
{
    "aggs": {
        "sum_age": {
            "sum": {          // 求和
                "field": "age"
            }
        }
    },
    "size": 0
}
{
    "aggs": {
        "avg_age": {
            "avg": {          // 平均值
                "field": "age"
            }
        }
    },
    "size": 0
}
{
    "aggs": {
        "distinct_age": {
            "cardinality": {      // 去重后再求总数
                "field": "age"
            }
        }
    },
    "size": 0
}
{
    "aggs": {
        "stats_age": {
            "stats": {            // State 聚合：对某个字段一次性返回 count，max，min，avg 和 sum 五个指标
                "field": "age"
            }
        }
    },
    "size": 0
}

桶聚合查询

{
    "aggs": {
        "age_groupby": {
            "terms": {                // terms 聚合，分组统计
                "field": "age"
            }
        }
    },
    "size": 0
}
{
    "aggs": {
        "age_groupby": {
            "terms": {
                "field": "age"
            },
            "aggs": {                 // terms 分组下再进行聚合
                "sum_age": {
                    "sum": {"field": "age"}
                }
            }
        }
    },
    "size": 0
}

修改文档

POST /index_name/_doc/1

请求

{
    "title":"zbuzhi",
    "age":29
}

响应

{
    "_index": "index_name",
    "_type": "_doc",
    "_id": "1",
    "_version": 6,
    "result": "updated",        // 这里的 updated 表示修改成功
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 6,
    "_primary_term": 1
}

修改字段

POST /index_name/_update/1

请求

{
    "doc": {
        "title":"hello zbuzhi~"
    }
}

响应

{
    "_index": "index_name",
    "_type": "_doc",
    "_id": "1",
    "_version": 7,
    "result": "updated",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 7,
    "_primary_term": 1
}

删除文档

DELETE /index_name/_doc/1

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）。

{
    "_index": "index_name",
    "_type": "_doc",
    "_id": "1",
    "_version": 8,                // 对数据的操作，都会更新版本
    "result": "deleted",            //  deleted 表示数据被标记为删除
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 8,
    "_primary_term": 1
}

删除不存在的数据，不会报错

{
    "_index": "index_name",
    "_type": "_doc",
    "_id": "1",
    "_version": 9,
    "result": "not_found",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 9,
    "_primary_term": 1
}

条件删除文档

POST /index_name/_delete_by_query

请求

{
    "query":{
        "match": {
            "age": 28
        }
    }
}

响应

{
    "took": 1243,             // 耗时 ms
    "timed_out": false,               // 是否超时
    "total": 10,                  // 总条数
    "deleted": 10,                    // 删除数量
    "batches": 1,
    "version_conflicts": 0,
    "noops": 0,
    "retries": {
        "bulk": 0,
        "search": 0
    },
    "throttled_millis": 0,
    "requests_per_second": -1,
    "throttled_until_millis": 0,
    "failures": []
}

映射操作

创建映射

PUT /index_name/_mapping

请求

{
    "properties": {
        "title": {
            "type": "text",
            "index": true
        },
        "age": {
            "type": "long",
            "index": false
        }
    }
}

响应

{
    "acknowledged": true
}

  • 字段名任意填写

  • type类型

    • String
      • text: 可分词
      • keyword: 不可分词，数据会作为完整字段进行匹配
    • Numerical 数值类型
      • 基本数据类型：long、integer、short、byte、double、float、half_float
      • 浮点数的高精度类型：scaled_float
    • Date 日期类型
    • Array 数组类型
    • Object 对象

  • index 是否索引，默认为 true

  • store 是否将数据进行独立存储，默认为 false

    原始的文本会存储在 _source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。

  • analyzer 分词器，比如中文分词器ik用到的ik_max_word

查看映射

GET /index_name/_mapping

{
    "index_name": {
        "mappings": {
            "properties": {
                "age": {
                    "type": "long",
                    "index": false
                },
                "title": {
                    "type": "text"
                }
            }
        }
    }
}

索引映射关联

创建索引时同时创建映射

PUT /index_name

请求

{
    "settings": {},
    "mappings": {
        "properties": {
            "title": {
                "type": "text",
                "index": true
            },
            "age": {
                "type": "long",
                "index": false
            }
        }
    }
}

响应

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "index_name"
}
elasticsearch
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
															
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																				
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇