# 在请求结果是表格结果返回的时候，我们往往可以通过 help 来帮助我们进行查询
GET /_cat/count?help
GET /_cat/master?help
GET /_cat/nodes?help
GET _cat/shards?help
GET /_cat/allocation?help

# 集群的健康状态
GET _cluster/health
# 集群状态
GET _cluster/state   // 查看集群的状态
GET _cluster/stats?human&pretty     // 查看es对集群情况做的统计信息
GET _cluster/settings?include_default=true // 查看集群的配置信息
# 节点信息请求格式查询
GET /_nodes/$[<node_id> / <metric> / {node_id/metric}]
# 主节点查询 API
GET _cat/master?v
# 集群节点查询 API
GET _cat/node
# 查询存在那几个索引
GET /_cat/indices
# 列出所有的节点信息
GET _nodes/$[_all、_local、_master、IP或者主机名字、节点ID或者名称、*、master: true/false、data:true/false、ingest:true/false、coordinating_only:true/false]
	_all: 列出所有的节点信息
	_local：列出所有的本地节点
	_master：列出主节点
	_IP或者主机的名字：列出指定的IP或者主机名字的节点
	节点 ID 或者名称：列出指定 ID 或者名称的节点
	*：IP、主机名字、节点 ID、名称都可以包括通配符
	master:true/false：列出主节点 / 不列出主节点
	data:true/false：列出数据节点 / 不列出数据节点
	ingest:true/false：列出索引预处理节点 / 不列出索引预处理节点
	coordinating_only:true/false：列出协调节点 / 不列出协调节点
	sample: GET _nodes/master:true,data:true,ingest:true,coordinating:true/process
# 分片情况查询 API
GET _cat/shards      // 所有分片信息
GET _cat/shards/${index}?v       // 某个索引的分片信息
GET ${index}/_settings    // 使用 json 结果查看某个索引的信息
GET _cat/indices/${index}?v    //  使用表格形式查看某个索引的状态
GET _cluster/state/metadata    // 集群状态 API，可以查看到所有索引的状态信息

GET /_cluster/state?filter_path=metadata.indices.${index}
GET /_cluster/state?filter_path=routing_table.indices.${index}

POST /_cluster/reroute
{
	"commands": [
        {
            "move": {
                "index": "${indexName}", "shard": ${shardNum},
                "from_node": "${removeFromNodeN}", "to_node": "${removeToNodeM}"
            }
        },
        {
            "allocate_replica": {
                "index": "${indexName}", "shard": ${shardNum},
	   			"node": "${nodeN}"
            }
        }
    ]
}

node.roles: [ master, data ] //设置节点为 master 候选节点和数据节点

// 设置 node1 为 hot 节点
node.attr.box_type: hot
// 设置 node2 为 warm 节点
node.attr.box_type: warm
// 设置 node3 为 cold 节点
node.attr.box_type: cold

// 如果是docker-compose启动的集群，可以通过以下配置
environment:
	- node.name=my_node1
	- node.attr.box_type=hot
environment:
	- node.name=my_node2
	- node.attr.box_type=warm
environment:
	- node.name=my_node3
	- node.attr.box_type=cold

PUT books
{
  "mappings": {
    "properties": {
      "book_id": {
        "type": "keyword"
      },
      "name": {
        "type": "text"
      }
    }
  },
  "settings": {
    "number_of_shards": 2,  # 定义了 2 个分片
    "number_of_replicas": 2  # 定义了每个分片 2 个副分片
  }
}

PUT booksv2
{
  "mappings": {
    "properties": {
      "book_id": {
        "type": "keyword"
      },
      "name": {
        "type": "text",
        "analyzer": "standard"
      },
      "name_completion": {
        "type": "completion"
      },
      "author": {
        "type": "keyword"
      },
      "price": {
        "type": "double"
      },
      "date": {
        "type": "date"
      },
      "seq_num": {
        "type": "integer"
      }
    }
  },
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  }
}
# 添加数据
POST booksv2/_doc/3
{
  "book_id": "ab114516",
  "name": "manba out",
  "name_completion": "manba out",
  "author": "kobe",
  "price": 114.51,
  "date": "2020-01-01",
  "seq_num": 3
}

POST /${index}/_open   // 开启索引  &  关闭索引 (关闭索引后不能做读写操作，也不占用内存)
POST /${index}/_close  
HEAD ${index}          // 检查索引是否存在，存在则 返回200 OK，不存在则返回 not found

PUT ${indexName}
{
    "settings": {
        "number_of_shards": n,      // 主分片数 【可选】
        "number_of_replicas": m,    // 副分片数 【可选】    总数量 = 主分片 * 副分片
        "routing": "${route_value}",    // 修改路由值 (一般不用该参数配置)
        "index.lifecycle.name": "${udf_ilm_policy}",   // 设置ILM索引生命周期【可选】
        "index.lifecycle.rollover_alias": "${udf_auto_handle_alias}" // 设置生命周期完毕更新别名(热冷数据处理)【可选】
        ······
        "analysis": {
            "analyzer": {   // [内置分词器使用]
                "${built-in_analyzer}": { // 如果使用内置或者插件的 analyzer
        			// 设置分词器类型 (默认情况下会使用standard)
                    "type": "$[standard / simple / whitespace / stop / keyword / pattern / language /"
                              "fingerprint / custom(自组合) / snowball / icu_analyzer / phonetic]", 
        			// 设置分词器的类型
                    "tokenizer": "$[standard / whitesapce / letter / lowercase / word_delimiter / pattern / uax_url_email / path_hierarchy / keyword / char_group / ik_smart / ik_max_word······]", 
        			// 设置字符过滤器 (在执行分词之前处理【可选】)
                    "char_filter": [$["html_strip" / "mapping" / "pattern_replcas" / "icu_normalizer"]], 
				   // 设置过滤器 (用于处理tokenizer的分词结果【可选】)
                    "filter": [$["lowercase" / "uppercase" / "stop" / "trim" / "stemmer" / "synonym" / "ascii_folding" / "snowball" / "length" / "truncate" / "pattern_replace", "pinyin" ······]] 
                }
            }
        }
    },
    "mapping": {
        // 配置索引是否全局允许动态添加字段 【可选】
        "dynamic": $[true / false / runtime / strict],
        // 动态模板配置 (使字段可自动扩展、按照规则映射【可选】)
        "dynamic_templates": [  
            {
                {
                    "${template_name}": {            // 设置模板的名字
                        "match_mapping_type": "string",    // 匹配字段的类型
                        "${match}": "pattern",        // 字段名称的匹配和不匹配模式
                        "${unmatch}": "pattern",   
                        "${match_pattern}": "regex",   // 匹配原则，一般是 regex
                        "${path_match}": "patch_pattern", // 字段路径的匹配和不匹配配置
                        "${path_ummatch}": "patch_pattern",
                        "mapping": {                 // 应用匹配字段的映射设置
                            "type": "keyword",
                            ······
                        }
                    }
                },
                ······
            }
        ],
        // 配置索引内部字段
        "properties": {
            // 普通数据类型
            "${field}": {
                "type": "$[keyword / text / integer / date ······]",
                ······ // 如果是 date ，可添加 format等类型规范 【可选】
                        // 如果是 keyword，可添加ignore_above  【可选】
                // 设置字段是否被索引 【可选】
                "index": $[true / false],
                // 配置该字段是否可以动态扩展 【可选】
                "dynamic": $[true / false],
                // 设置字段的分词器 (默认standard)  【可选】
                "analyzer": "$[analyzer-type / udf_analyzer]",
                // 设置字段被搜索时的分词器 (不设置默认跟 analyzer 一样)  【可选】
                "search-analyzer": "$[analyzer-type / udf_analyzer]"
                // 设置特定值替换null的存储 (不影响实际值，只影响索引，类似于mapping)  【可选】
                "null_value": "${NULL}",
                // 设置copy_to 实际效果等同于 在n个字段中任一字段存在该都匹配  【可选】
                "copy_to": "${other_field}",
                // 设置 doc_values 是否生成，es针对keyword等会生成doc_values协助进行聚合、排序等操作
                //      但会消耗大量存储空间, 需要注意关闭后无法再次打开 (text默认不开启)
			   //      一般来说，只有像 UUID 这种类型是百分百不需要 doc_values 
                "doc_values": $[true / false]
                // 父子字段嵌套 模板
                "$[fields / properties]": {
                    "${field}": {
                        "type": "$[keyword / text / integer / date ······]",
                        /* field common struct (same for root field) */
                        ······ // 如果是 date ，可添加 format等类型规范 【可选】
                                // 如果是 keyword，可添加ignore_above  【可选】
                    },
                    ······
                }
            },
            // 对象嵌套对象
            "${field}": {
                "type": "nested",
                "properties": {
                    "${son_field}": { "type": "${son_field_type}", ······ },
                    ······
                }
            }
            ······
        }
    },
    // 设置当前索引的别名【可选】
    "aliases": { 
        "${udf_index_aliases}": {
            // 设置别名的过滤器 【可选】
            "filter": { "$[term / range]": {"${field}": "${value}" }},
            // 是否写入到索引 【可选】
            "is_write_index": $[true / false],
            // 设置别名的路由 使用该参数配置值后，会同时指定索引 和 搜索的路由，如果数据量太大将会导致数据极度集中  【可选】
            "routing": "${udf_routing_value}",
            // 设置搜索的路由，使用该参数进行配置之后，会导致搜索请求指定到某个节点   (必须使用别名搜索)
            "search_routing": "${udf_routing_value-for search}"
            // 设置索引的路由，使用该参数会导致    (必须使用别名PUT / POST)
            "index_routing": "${udf_routing_value-for store}"
        }
    }
}

# 先创建索引本身
PUT /${indexName}
# 补充 mapping 和 properties
PUT /${indexName}/_mapping
{
  "properties": {
    "${fieldName}": {
      "type": "#{fieldType}"
    },
    ······
  }
}
// 但是需要注意的是，es不能对已经存在字段使用mapping来做修改，可以创建新字段

PUT /${index}
{
	"mappings": {
        ${"dynamic": "$[true / false / null / strict]",}   // 允许新增字段，有动态模板，大概率是false
		"dynamic_templates": [
			{
                "${template_name}": {            // 设置模板的名字
                    "match_mapping_type": "string",    // 匹配字段的类型
                    "${match}": "pattern",        // 字段名称的匹配和不匹配模式
                    "${unmatch}": "pattern",   
                    "${match_pattern}": "regex",   // 匹配原则，一般是 regex
                    "${path_match}": "patch_pattern", // 字段路径的匹配和不匹配配置
                    "${path_ummatch}": "patch_pattern",
                    "mapping": {                 // 应用匹配字段的映射设置
                "type": "keyword",
                ······
                    }
                }
			}
            ······
		],
        "properties": {
            // 显式定义的字段
            "${fieldName}" : {
                "type": "${fieldType}",
                "ignore_malformed": "$[true / false]"
            }
        }
	}
}

PUT "${indexName}"
{
  "mappings": {
    "dynamic_templates": [
      {
        "ids_as_keywords": {
          "match_mapping_type": "string",
          "match": "*_id",
          "mapping": {
            "type": "keyword"
          }
        }
      }
    ]
  }
}

# 删除一个索引
DELETE ${index}

PUT shards_index
{
  "mappings": {
    "properties": {
      "id": {
        "type": "integer"
      }
    }
  },
  "settings": {
    "number_of_shards": 12,   // 这里将该索引的主分片数量设置为了12个
    "number_of_replicas": 2
  }
}

POST ${index}/_settings
{
	"index.routing.allocation.require._name": "${nodeName}",  // 将索引重新分配节点
	"index.number_of_replicas": 0,    // 保证只有单个服务有该索引数据
	"index.blocks.write": true        // 设置索引是否处于只读状态
}

POST ${index}/_shrink/${new_index_name}
{
	"settings": {
        "index.number_of_replicas": n,    // 设置索引的副本数量
        "index.number_of_shards": m,     // 设置索引的分片数量
        "index.routing.allocation.require._name": null,  // 系统随机分配分片
        "index.blocks.write": null       // 设置索引是否处于只读状态
    }
}

// 构建别名模板
POST /_aliases
{
	"action": [
{ "add": { "index": "${indexName}", "alias": "${aliasName}" } }
	]
}
// 删除别名模板
POST /_aliases 
{
    "action": [
        { "remove": { "index": "${indexName}", "alias": "${aliasName}" } }
    ]
}
// 别名重命名操作
POST /_aliases
{
    "action": [
        { "remove": { "index": "${indexName}", "alias": "${aliasName}" } },
        { "add": { "index": "${indexName}", "alias": "${aliasName}" } }
    ]
}
// 单个别名关联多个索引
POST /_aliases
{
    "actions": [
        { "add": { "indices": ["${indexName1}", "${indexName2}"], "alias": "aliasName1"}}
    ]
}

POST ${alias_name}/_doc
{
	"${field}": "${field_value}"
}

GET ${alias_name}/_search
{
  "query": {
    "match_all": {}
  }
}

GET ${alias_name}/_search
{
  "query": {
    "range": {
      "@timestamp": {
        "gte": "2023-01-01",
        "lte": "2023-12-31"
      }
    }
  }
}

GET ${alias_name}/_search
{
  "query": {
    "match": {
      "log_msg": "error"
    }
  }
}

GET book*/_search
{
  "query": {
    "match_all": {}
  }
}

PUT /_index_template/${index_template_name}
{
    "index_patterns": ["${regex}"],    // 使用正则表达式来控制什么情况的索引构建会使用该模板
    ${"priority": n,}            // 该模板的优先级
    "template": {            // 索引模板的主体
        "settings": {
            ${"order": n,}    // 
            ${"number_of_shards": m,}         // 使用该模板的默认分片数量
            ${"number_of_replicas": j, }     // 使用该模板的默认副本数量
		   "analysis": {
               /* 这个部分其实完全等同于上文索引模板 */
               "analyzer": {
                   "${udf_analyzer}": {
                       "type": "custom",
                       "tokenizer": "$[standard ······]",
                       "filter": $["lowercase ······"]
                   }
               }
           }
		   /* 日志类型参数设置 */
		   // ${ "index.refresh_interval": "ns" }   // 设置刷新间隔 n 秒
		   /* 时间序列数据索引 (类似于传感器 / 股票等时间变动数据会变动的数据) */
		   // ${ "index.lifecycle.name": "timeseries_policy", }  // 指明当前索引使用的 ILM Policy  (一旦配置的 ilm.policy 就一定要 routng 和 rollover_alias 不然会有不可预测的结果)
		   // ${ "index.lifecycle.rollover_alias": "", }   //
	       // ${ "index.routing.allocation.include.box_type": "hot", }   // 指明新建的索引都分配在hot节点上
		   /* 存储指标数据 (用于记录系统监控信息) */
		   // ${ "index.mapping.total_fields.limit": 2000, }     // 索引内部可以定义的字段最大数量
		   // ${ "index.refresh_interval": "30s" }  // 索引中嵌套字段的最大数量
        },
        "mappings": {
            "properties": {
                /* 这个部分其实完全等同于上文索引模板 */
            	"${field}": {
                    "type": "${fieldType}"
                },
                "${@timestamp}": {    // 如果是timestamp，一般会使用 @timestamp 代替 timestamp 
                    				// [@符号排名靠前、@timestamp可以避免与es自带的冲突]
                    "type": "date",
                    "format": "${strict_date_optional_time||epoch_millis}"   // 设置时间戳格式
                }
                ······
            },
            ${"date_detection": $[true / false],}   // 是否默认自动检测为 date 类型数据，并自动转换
            ${"numeric_detection": $[true / false],} // 是否自动检测为 number 类型，并自动转换
        },
	   "aliases": {
           "logs_current": {}   // 设置当前索引的别名
       },
	   // 使用压缩模板设置压缩效果
	   ${"composed_of": ["udf_compression_template"]}
    }
}

// 定义一个策略
PUT _ilm/policy/${policyName}
{
	"policy": {
		"phases": {
			"hot": {
				"min_age": "0s",        // 多久之后进入到该阶段
				"actions": {
					${built-in action}: { /* built-in action struct */ }
				},
				"set_priority": {
                	 "priority": n     // 设置 hot 阶段的索引的优先级   
                 }
			},
			"warm": { /* same as hot */ },
			"cold": { /* same as hot */ },
			"delete": { /* same as hot */ }
		}
	}
}

// 查看 Policy 的信息
GET _ilm/policy/${index}
// 删除 policy 的信息
DELETE _ilm/policy/${index}

// 声明一个 hot阶段 大小超过5GB、年龄超过30天 就会创建新索引、且设置 Warm 阶段会将索引副本数量设置为 1
PUT _ilm/policy/my_index
{
	"policy": {
		"phases": {
			"hot": {
				"actions": {
					"rollover": {
						"max_size": "5GB",
						"max_age": "30d"
					}
				}
			}，
			"warm": {
				"action": {
					"migrate": {},
					"allocate": {
						"number_of_replicas": 1
					}
				}
			}
		}
	}
}

// 将 ilm 绑定到 某个索引上，方式1 & 方式2
PUT ${index}
{
    "${mappings}": { /* mappings struct */ },
    "settings": {
        "index.lifecycle.name": "${udf_ilm}"
    }
}
PUT ${index}/_settings
{
    "settings": {
        "index.lifecycle.name": "${udf_ilm}"
    }
}

PUT _template/${template_name}
{
	/* template struct */
	"settings": {
		"index": {
			"lifecycle": {
                "name": "${udf_ilm_policy}",
                "rollover_alias": "${create index alias}"
			}
		},
        /* other settings struct */
	}
}

# 如果数据量不大，那么可以通过以下模板来实现修改   
POST _reindex
{
	"source": { "index": "${source_indexName}" },
	"dest": { "index": "${dest_indexName}" }
}
# 如果有着大量的数据的话，es的请求大概率就会出现超时的问题，因此，我们可以将其设置为后台处理 ·?wait_for_completion=false·
POST _reindex?wait_for_completion=false
{
	"source": { "index": "${source_indexName}" },
	"dest": { "index": "${dest_indexName}" }
}
# 在成功调用之后，最终的执行效果，可以通过
GET /_task/taskSeq 获得

POST _reindex
{
  "source": { "index": "oldindex" },   // 原索引
  "dest": { "index": "reindex" },     // 目标索引
  "script": {
    "source": """   
      ctx._source.${destFieldName1} = ctx._source.remove("${sourceField1}");   // 转换规则
      ctx._source.${destFieldName2} = ctx._source.remove("${sourceField2}");
      ctx._source.${destFieldName3} = ctx._source.remove("${sourceField3}");
      ctx._source.remove("date")   // 去掉不需要的字段 (如果原先有这里不做处理)
    """
  }
}

# such as
POST books/_doc/1   # 从左到右分别是 index: books type: _doc id: 1
{
  "book_id": "1",              # 字段book_id为1
  "name": "elasticsearch 从入门到放弃学习"   # 字段name为 ······
}

POST books/_search       # 从左到右动作是 index: books type：_search 表明此次是查询操作
{
  "query": {             # 表明是查询
    "match_phrase": {    # 标识精准匹配一个词语或者是一个字段的值 
                         # 与之对应的是 match_phrase_prefix (一般用于字符串) 这里最好是用 term
      "book_id": 1
    }
  }
}

{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.6931471,
    "hits" : [
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.6931471,
        "_source" : {
          "book_id" : "1",
          "name" : "elasticsearch 从入门到放弃学习"
        }
      }
    ]
  }
}

PUT ${indexName}
{
    "settings": {
        ······
        "analysis": { // analyzer、[tokenizer、char_filter、filter 服务于analyzer]
        	"analyzer": {
                "${udf_custom_analyzer}": { // 如果要完全自定义 analyzer
                    "type": "custom",
                    "tokenizer": "${udf_tokenizer} / ······ / 其他内置的tokenizer",
                    "char_filter": ["[${udf_char_filter}", ······ / "其他内置的字符过滤器]"],
                    "filter": [$["${udf_filter}", ······ / "其他内置的过滤器"]],
                    "tokenizer": {
                        "${udf_tokenizer}": {
                            "type": "$[pattern / simple_pattern / classic / ngram / path_hierarchy / edge_ngram / char_group / keyword / whitespace ······]",
                            // if type is pattern / simple_pattern
                            // "pattern": "${regex}"
                            // if type is char_group (自定义在字符切割)
                            // "tokenize_on_chars": [${char}, ······]
                            ······
                        }
                    },
                    "char_filter": { // 自定义字符过滤器
                        "${udf_char_filter}": {
                            "type": "$[html_strip / mapping / pattern_replcas / icu_normalizer]",
                            // if type is html_strip
                            // "escaped_tags": ["${html tag such as span}"] 
                            // if type is mapping
                            // "mappings": [ "${char} => ${char}", ······] 
                            // if type is pattern_replcas
                            // "pattern": "${regex}",  
                            // "replacement": "${replace_str}"
                            // if type is icu_normalizer (语汇单元过滤器)
                            // "name": "$[nfc / nfkc ······]",
                            // "mode": "decompose"
                            ······
                        }
                    },
                    "filter": { // 自定义过滤器
                        "${udf_filter}": {
                            "type": "same for built-in filter type",
                            ${udf_filter_body} // 无法提供确定模板，太多了
                        	······
                        }
                    }
                }
            }
        },
        ······
    }
}

GET _analyze
{
	"analyzer": "${build-in analyzer}",
    "text": "${udf_string}"
}

// 如果需要使用在某个index声明的时候写的自定义分词器
GET ${index}/_analyze
{
    "analyzer": "${udf_analyzer}",
    "text": "${udf_string}"
}
// 如果想要对自己还没实际构建的索引进行测试   (只支持内置的)
GET _analyze
{
    "tokenizer": "${built-in analyzer}",
    "filter": [$["lowercase"······]],
    "text": "${udf_text}"
}

// 对象嵌套对象
"${field}": {
    "type": "nested",
    "properties": {
        "${son_field}": { "type": "${son_field_type}", ······ },
        ······
    }
}
# mapping properties 嵌套声明格式
{
    "field0": { "type": "text" },
    "field1": {
 		"type": "nested",      // 必须是nested
 		"properties": {
 			"son_field1": {
                "type": "text"
            },
            ······
		}
	}
}
# 插入文档格式
PUT / POST ${index}/_doc/${id} 
{
	"field0": "${field0Value}",
    "field1": [
		{ "son_field1": "${son_fieldValue1}" },    // 本质上是类似的，
		{ "son_field2": "${son_fieldValue2}"},
        ······
    ]
}
# 以数组的形式插入到文档到索引之中
PUT / POST ${index}/_doc/${id}
{
    ""
}
# final store
{
    "field0": "field value",
    "field1.son_field1": "son_field1 value",
    "field1.son_field2": "son_field2 value",
    ······
}

GET / POST ${index}/_search
{
	"query": {
		"bool": {
            "must":  
                { "term": { "${field.son_field1}": "${son_field1_value}" } },
                { "term": { "${field.son_field2}": "${son_field2_value}" } }
            ]
        }
	}
}

// 基本的父子类型的定义
"mappings": {
	"properties": {
        "${field0}": { "type": "$[keyword / integer ······]" },
        "${field1}": { "type": "$[keyword / integer ······]" },
        "${field2}":{
            "type": "join",
            "relations": {
                "${parent_field [跟field0 / field1无关系]}": "${child_field [跟field0 / field1无关系]}"
            }
		}
        ······
    },
    ······
}

// 示例 (构建内包含 join 类型的字段)
"mappings": {
    "properties": {
        "${field0}": {"type": "text"},
        "${field1}": {"type": "text"},
        "${field2}": {
            "type": "join",
            "relations": {
                "${parent}": "${child}"
            }
        }
    }
}
// 索引父文档内容 (插入新父文档)
// 实际上是将当前索引的整个文档都当做父文档进行记录 (包含：field0、field1 ······)
PUT / POST ${index}/_doc/${parent_id}
{
    "${field0}": "${field0_value}",
    "${field1}": "${field1_value}",
    "${field2}": {
        "name": "${parent}",
    }
}
// 索引子文档内容 (插入新子文档)  [插入子文档数据时，必须跟父文档的id是一致的，否则可能找不到子文档]
// 实际上是将当前索引的整个文档都当做子文档进行记录 (包含：field0、field1 ······)
PUT / POST ${index}/_doc/${id}?routing=${parent_id}
{
    "${field0}": "${field0_value}",
    "${field1}": "${field1_value}",
    "${field2}": {
        "name": "${child}",
        "parent": "${parent_id}"
    }
}

// 通过 GET 方式获取parent_id的内容
GET ${index}/_doc/${parent_id}
// sample：GET join_index/_doc/1

// 通过 POST 方式获取 parent 的内容
POST join_index/_search
{
  "query": {
    "term": {
      "_id": {
        "value": 1
      }
    }
  }
}

// 可以查出使用目标作为父文档的子文档
POST ${index}/_search
{
  "query": {
    "has_parent": {
      "parent_type": "${parent}",   // 声明 relations 中 parent 的名字
      "query": {            // 需要注意的是，这里的query的参数和内容都是针对 parent 文档的
        "term": {
          "${parent field}": "${parent field value}"       // 针对parent的查询条件
        }
      }
    }
  }
}

GET / POST ${index}/_doc/${id}?routing=${parent_id}
// sample：GET join_index/_doc/2?routing=1

// 通过 POST 方式获取 child 的内容  (通过parent的值)
POST ${index}/_search
{
    "query": {
        "parent_id": {     // 这里的parent_id指代的是parent的id是搜索项，固定的
            "type": "child",
            "id": ${parent_id}      // 这里的parent_id是参数
        }
    }
}

POST ${index}/_search
{
  "query": {
    "has_child": {
      "type": "${child}",             // 声明 relations 中的 child 的名字
      "query": {              // 需要注意的是，这里的query的参数和内容都是针对 child 文档的
        "term": {
          "field": {
            "value": "child_field_value"       // 针对parent的查询条件
          }
        }
      }
    }
  }
}

PUT ${index}
{
  "mappings": {
    "properties": {
      "${textFieldName}": {
        "type": "text",
        "fielddata": true
      }
    }
  }
}

PUT books
{
	"mappings": {
        "properties": {
            "book_id" : {
       			"type": "keyword"
            },
            "name": {
        		"type": "text"
            }
        }
	},
	"settings": {
        "number_of_shards": 2, # 定义了 2 个分片
        "number_of_replicas": 2 # 定义了每个分片 2 个副分片
	}
}

POST /books/_search
{
  "size": 0,  
  "aggs": {
    "max_book_title": {
      "terms": {
        "field": "book_title.keyword",  
        "size": 1,  
        "order": {
          "_key": "desc"
        }
      }
    }
  }
}

POST books/_doc/3
{
  "book_id": "3",
  "name": "elasticsearch?还是得学"
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "3",
  "_version" : 1,
  "result" : "created",
  "_shards" : {        // shards 的意思是描述在此次的操作过程之中涉及的分片及其情况
    "total" : 3,          // 该索引总共有多少个分片，其中第一个是主分片，其他的都是副分片
    "successful" : 3,     // 成功执行了多少个分片的操作
    "failed" : 0         // 失败了多少个分片
  },
  "_seq_no" : 2,         // 本质上等同于改了多少次
  "_primary_term" : 2    // 本质上是描述es服务器重启或者重新选举的master 加起来的次数
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "3",
  "_version" : 3,
  "result" : "updated",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 4,
  "_primary_term" : 2
}

PUT books/_create/4
{
  "book_id": "4",
  "name": "好好好"
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "4",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 3
}

PUT books/_doc/5
{
  "book_id": "5",
  "name": "不是，哥们"
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "5",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 5,
  "_primary_term" : 3
}

GET books/_doc/id

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "4",
  "_version" : 2,
  "_seq_no" : 1,
  "_primary_term" : 3,
  "found" : true,
  "_source" : {
    "book_id" : "4",
    "name" : "不是，哥们"
  }
}

GET ${index}/_search
{
  "size": 100,
  /* 排序 ， 这里的elementProperties 可以是 _id、也可以是_source内部的列
  "sort": [
  	{ "${elementProperties}": "asc/desc" },
    { "${elementProperties}": "asc/desc" },
  ]
  */
  /* 查询某些列   这里的includes当然只能是 _source结果内部的列
  "_source": {
    "includes": ["${fieldName1}", "${fieldName2}"]
  },
  */
  "query": {
    "match_all": {}
  }
}

# 如果使用GET   (无序)
GET /books/_search
{
  "size": 100,
  "query": {
    "match_all": {}
  }
}
# 如果使用POST   (无序)
POST /books/_search
{
  "size": 100,
  "query": {
    "match_all": {}
  }
}
# 如果需要指定某一部分字段返回
GET /your_index/_search
{
  "size": 100,
  "_source": true,   // 默认情况下ES查询就是 _source = true
    	    // 如果是false，则无法看到我们实际存储的数据
  "query": {
    "match_all": {}
  }
}

# 如果需要排序 假设是 id 升序排序
GET /your_index/_search
{
  "size": 100,
  "sort": [
    { "_id": "asc / desc" }   
  ],
  "query": {
    "match_all": {}
  }
}

# 如果只要特定字段的信息  当然需要注意的是，这里的_source: ["$filedName"] 其实是简化过的
#      最标准的写法可以参考更下面一个
GET books/_search
{
  "size": 100,
  "_source": ["name"],
  "query": {
    "match_all": {}
  }
}

GET books/_search
{
  "size": 100,
  "_source": {
    "includes": ["${fieldName1}", "${fieldName2}"]
  },
  "query": {
    "match_all": {}
  }
}

# 1. 在 docs 的 body 之中指定 index
# GET /_mget { "docs": ["_index": ${indexName}, "_id": ${id} ] 
GET /_mget
{
	"docs": [
{ "_index": "books", "_id": "1" },
{ "_index": "books", "_id": "2" }
	]
}

# 2. 当然也可以 前缀 上直接指定 index 不在 docs 的 body 之中再指定
GET /${indexName}/_doc/_mget
GET /books/_mget
{
   	"ids": ["1", "2"]
}

# 这两个方式的结果是一样的
{
  "docs" : [
    {
      "_index" : "books",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "book_id" : "1",
        "name" : "elasticsearch 从入门到放弃学习"
      }
    },
    {
      "_index" : "books",
	 ··· ···
      "_source" : {
        "book_id" : "2",
        "name" : "elasticsearch 学牛魔，开摆"
      }
    }
  ]
}

POST books/_doc/4
{
  "book_id": "4",
  "name": "好好好"
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "4",
  "_version" : 3,
  "result" : "updated",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 2,
  "_primary_term" : 4
}

POST books/_update/5
{
	"doc": {
        "name": "诗人握持"
    }
}

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "5",
  "_version" : 2,
  "result" : "updated",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 6,
  "_primary_term" : 4
}

POST books/_update_by_query
{
	"query": {
"term": {
	"book_id" : {
"value": "5"
	}
}
	},
	"script": {
"source": "ctx._source.name='就这？'",
"lang": "painless"
	}
}

POST books/_update_by_query?wait_for_completion=false
{
  "query": {
      "match_phrase": {
        "name": "哥们就这?"
      }
    },
    "script": {
      "source": "ctx._source.name='诗人握持'",
      "lang": "painless"
    }
  }
}

{
  "task" : "wbS5y0jDSGq9LU0JIddDuw:311880"
}

GET /_tasks/wbS5y0jDSGq9LU0JIddDuw:308389

{
  "completed" : true,
  "task" : {
    "node" : "wbS5y0jDSGq9LU0JIddDuw",
    "id" : 311880,
    "type" : "transport",
    "action" : "indices:data/write/update/byquery",
    "status" : {
      "total" : 1,
      "updated" : 1,
      "created" : 0,
      "deleted" : 0,
      "batches" : 1,
      "version_conflicts" : 0,
      "noops" : 0,
      "retries" : {
        "bulk" : 0,
        "search" : 0
      },
      "throttled_millis" : 0,
      "requests_per_second" : -1.0,
      "throttled_until_millis" : 0
    },
    "description" : "update-by-query [books] updated with Script{type=inline, lang='painless', idOrCode='ctx._source.name='诗人握持'', options={}, params={}}",
    "start_time_in_millis" : 1726161017445,
    "running_time_in_nanos" : 182169113,
    "cancellable" : true,
    "headers" : { }
  },
  "response" : {
    "took" : 182,
    "timed_out" : false,
    "total" : 1,
    "updated" : 1,
    "created" : 0,
    "deleted" : 0,
    "batches" : 1,
    "version_conflicts" : 0,
    "noops" : 0,
    "retries" : {
      "bulk" : 0,
      "search" : 0
    },
    "throttled" : "0s",
    "throttled_millis" : 0,
    "requests_per_second" : -1.0,
    "throttled_until" : "0s",
    "throttled_until_millis" : 0,
    "failures" : [ ]
  }
}

DELETE books/_doc/5

{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "5",
  "_version" : 5,
  "result" : "deleted",
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "failed" : 0
  },
  "_seq_no" : 9,
  "_primary_term" : 5
}

POST books/_delete_for_query
{
	"query": {
        "term": {
            "book_id": "5"
        }
	}
}

{
  "took" : 566,
  "timed_out" : false,
  "total" : 1,
  "deleted" : 1,
  "batches" : 1,
  "version_conflicts" : 0,
  "noops" : 0,
  "retries" : {
    "bulk" : 0,
    "search" : 0
  },
  "throttled_millis" : 0,
  "requests_per_second" : -1.0,
  "throttled_until_millis" : 0,
  "failures" : [ ]
}

POST books/_delete_by_query?wait_for_completion=false
{
  "query": {
    "match_phrase": {
      "name": "诗人握持"
    }
  }
}

GET _tasks/wbS5y0jDSGq9LU0JIddDuw:15575

// 后续就可以查看执行的效果如何

POST _bulk
{ "index" : { "_index" : "books", "_id" : "1" } }
{ "book_id": "5", "name": "芜湖，起飞" }
{ "index": { "_index": "books", "_id": "6" } }
{ "book_id": "6", "name": "manba out!" }
{ "create": { "_index": "books", "_id": "8" } }
{ "book_id": "8", "name": "zzzzz"}

{
  "took" : 4,
  "errors" : false,
  "items" : [
    {
      "index" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "5",
        "_version" : 2,
        "result" : "created",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 26,
        "_primary_term" : 5,
        "status" : 201
      }
    },
    {
      "index" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "6",
        "_version" : 6,
        "result" : "created",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 27,
        "_primary_term" : 5,
        "status" : 201
      }
    },
    {
      "create" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "8",
        "_version" : 1,
        "result" : "created",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 3,
        "_primary_term" : 5,
        "status" : 201
      }
    }
  ]
}

POST _bulk
{ "index": { "_index": "books", "_id": "7" } }
{ "book_id": "7", "name": "不是，哥们，你认真的？"}
{ "delete": { "_index": "books", "_id": "5"} }
{ "update": { "_index": "books", "_id": "7"} }
{ "doc": {"book_id": "6", "name": "不是，哥们，你认真的？ 7 - 6"}}

{
  "took" : 23,
  "errors" : false,
  "items" : [
    {
      "index" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "7",
        "_version" : 1,
        "result" : "created",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 28,
        "_primary_term" : 5,
        "status" : 201
      }
    },
    {
      "delete" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "5",
        "_version" : 3,
        "result" : "deleted",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 29,
        "_primary_term" : 5,
        "status" : 200
      }
    },
    {
      "update" : {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "7",
        "_version" : 2,
        "result" : "updated",
        "_shards" : {
          "total" : 3,
          "successful" : 3,
          "failed" : 0
        },
        "_seq_no" : 30,
        "_primary_term" : 5,
        "status" : 200
      }
    }
  ]
}

{
        "_shard" : "[books][0]",
        "_node" : "59sIGdp7SMGqCo3umOyr-w",
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "Il2O8ZEBjKOqwPdUM6Cf",
        "_score" : 1.9924302,
        "_source" : {
          "book_id" : "114.514",
          "name" : "elasticsearch tbest1"
        },
        "_explanation" : {
          "value" : 1.9924302,
          "description" : "max of:",
          "details" : [
            {
              "value" : 1.9924302,
              "description" : "weight(book_id:114.514 in 0) [PerFieldSimilarity], result of:",
              "details" : [
                {
                  "value" : 1.9924302,
                  "description" : "score(freq=1.0), computed as boost * idf * tf from:",
                  "details" : [
                    {
                      "value" : 2.2,
                      "description" : "boost",
                      "details" : [ ]
                    },
                    {
                      "value" : 1.9924302,
                      "description" : "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5)) from:",
                      "details" : [
                        {
                          "value" : 1,
                          "description" : "n, number of documents containing term",
                          "details" : [ ]
                        },
                        {
                          "value" : 10,
                          "description" : "N, total number of documents with field",
                          "details" : [ ]
                        }
                      ]
                    },
                    {
                      "value" : 0.45454544,
                      "description" : "tf, computed as freq / (freq + k1 * (1 - b + b * dl / avgdl)) from:",
                      "details" : [
                        {
                          "value" : 1.0,
                          "description" : "freq, occurrences of term within document",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.2,
                          "description" : "k1, term saturation parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 0.75,
                          "description" : "b, length normalization parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.0,
                          "description" : "dl, length of field",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.0,
                          "description" : "avgdl, average length of field",
                          "details" : [ ]
                        }
                      ]
                    }
                  ]
                }
              ]
            }
          ]
        }

Term Query API 返回在指定字段中准确包含了检索内容的文档，你可以使用此 API 去查询精确值的字段，如书本ID、价格等，但是我们必须要了解的是，如果我们将term查询使用在text类型上，就会出现报错。

POST ${index}/_search
{
  "query": {
    "term": {
      "book_id": {
        "value": "16"
      }
    }
  }
}

    "hits" : [
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "J12f8ZEBjKOqwPdUiKBD",
        "_score" : 1.4816045,
        "_source" : {
          "book_id" : "16",
          "name" : "elasticsearch tb 114.514 est"
        }
      }
    ]

POST ${index}/_search
{
	"query": {
        "terms": {
            "${field}": [
                "${searchValue1}",
                "${searchValue2}"
            ]
        }
	}
}
				``````

查询结果

```json
"hits" : [
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "J12f8ZEBjKOqwPdUiKBD",
        "_score" : 1.0,
        "_source" : {
          "book_id" : "16",
          "name" : "elasticsearch tb 114.514 est"
        }
      },
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "IF2O8ZEBjKOqwPdUEaDZ",
        "_score" : 1.0,
        "_source" : {
          "book_id" : "114.514",
          "name" : "elasticsearch ti 114.514 est"
        }
      }
    ]

POST ${index}/_search
{
  "query": {
    "range": {
      "${field}": {
        "gte": ${ >= n },   // gt: 大于某个值
        "lte": ${ <= n }    // lt：小于某个值
      }
    }
  }
}

POST ${index}/_search
{
  "query": {
    "exists": {
      "field": "${fieldName}"
    }
  }
}

POST ${index}/_search
{
  "query": {
    "prefix": {
      "name": {
        "value": "${fieldName}"
      }
    }
  }
}

POST ${index}/_search
{
  "query": {
    "wildcard": {
      "${filedName}": {
        "value": "*.51?"   # 可以配合 * 代表任意长度字符 ? 代表单个字符 
      }
    }
  }
}

POST books/_search
{
  "query": {
    "range": {
      "book_id": {
        "gte": 0,
        "lte": 10
      }
    }
  }
}

POST books/_search
{
  "query": {
    "constant_score": {
      "filter": {
        "range": {
          "book_id": {
            "gte": 0,
            "lte": 12
          }
        }
      }
      // , "boost": 1.2
    }
  }
}

POST ${index}/_search
{
  "query": {
    "constant_score": {
      "$[filter / query]": {
        "$[term / terms / range / exist / prefix / wildcard / match(一般不用)]": {
          ${operator struct}
        }
      },
      "boost": n
    }
  }
}

POST books/_search 
{
  "query": {
    "bool": {
      "should": [
        {
          "constant_score": {
            "filter": {
              "term": {
                "book_id": 14
              }
            },
            "boost": 1.2
          }
        },
        {
          "match": {
            "name": "哥们"
          }
        }
      ]
    }
  }
}

{
  "took" : 8,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 2.4299998,
    "hits" : [
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "7",
        "_score" : 2.4299998,
        "_source" : {
          "book_id" : "6",
          "name" : "不是，哥们，你认真的？ 7 - 6"
        }
      },
      {
        "_index" : "books",
        "_type" : "_doc",
        "_id" : "JV2f8ZEBjKOqwPdUW6Cb",
        "_score" : 1.2,
        "_source" : {
          "book_id" : "14",
          "name" : "elasticsearch teest1"
        }
      }
    ]
  }
}