es查询练习

GET _search
{
  "query": {
    "match_all": {}
  }
}

# 创建索引
PUT person
PUT zqk
# 查询索引
GET person
GET zqk 
# 删除索引
DELETe person
DELETE zqk

# 查询映射
GET person/_mapping
GET zqk/_mapping


# 添加映射
PUT person/_mapping
{
  "properties":{
    "name":{
      "type":"keyword"
    },
    "age":{
      "type":"integer"
    }
  }
}
PUT zqk/_mapping
{
  "properties":{
    "name" :{
      "type" : "keyword"
    },
    "age": {
      "type" : "integer"
    }
  }
}


# 创建索引并添加映射
PUT person
{
  "mappings": {
    "properties": {
      "name":{
        "type": "keyword"
      },
      "age":{
        "type":"integer"
      }
    }
    
  }
}
PUT zqk
{
  "mappings": {
    "properties" :{
      "name" : {
        "type" : "keyword"
      },
      "age" : {
        "type" : "integer"
      }
    }
  }
}


# 索引库中添加字段
PUT person/_mapping
{
  "properties":{
    "address":{
      "type":"text"
    }
  }
}
PUT zqk/_mapping
{
  "properties" :{
    "address" : {
      "type" : "text"
    }
  }
}

# 查询索引
GET person
GET zqk



# 添加文档，指定id
POST person/_doc/3
{
  "name":"張三",
  "age":30,
  "address":"华为5G手机"
}
POST zqk/_doc/3
{
  "name":"张三",
  "age" : 30,
  "address" : "华为5G手机"
}
# 查询文档
GET person/_doc/1
GET zqk/_doc/3

# 添加文档,不指定id
POST person/_doc/
{
  "name":"李四",
  "age":20,
  "address":"深圳南山區"
}
POST zqk/_doc/
{
  "name":"天津李四",
  "age" : 38,
  "address": "天津滨海"
}
# 查询文档
GET person/_doc/PC6eIpvAQ_yQua9UW9tlZQ
GET zqk/_doc/iXQYo30BxeVvR4r0hPeu

# 添加文档,不指定id
POST person/_doc/
{
  "name":"李四",
  "age":20,
  "address":"深圳南山区"
}
POST zqk/_doc
{
  "name" : "沈阳仙洋",
  "age" : 30,
  "address": "沈阳市皇姑区"
}
# 查询文档
GET person/_doc/7fWDhnsB3zC415WCdfEQ
GET zqk/_doc/inQao30BxeVvR4r0rvcX

# 查询所有文档
GET person/_search
GET zqk/_search

# 删除文档
DELETE person/_doc/1
DELETE zqk/_doc/iXQYo30BxeVvR4r0hPeu



# 修改文档 根据id，id存在就是修改，id不存在就是添加
PUT person/_doc/1
{
  "name":"乾坤傢",
  "age":20,
  "address":"深圳福田保税区"
}
GET zqk/_search
PUT zqk/_doc/1
{
  "name" : "zqk:嗷嗷强",
  "age" : 23,
  "address" : "沈阳市于洪区"
}


# match 先会对查询的字符串进行分词，在查询，求交集
GET person/_search
{
  "query": {
    "match": {
      "address": "华为手机"
    }
  }
}
GET zqk/_search
{
  "query" : {
    "match": {
      "address": "华为手机"
    }
  }
}

#词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索
#查询文档-term查询
# 查询所有数据
GET person/_search
GET zqk/_search

# 查询 深开头的数据
GET person/_search
{
  "query": {
    "term": {
      "address": {
        "value": "深"
      }
    }
  }
}
GET zqk/_search
{
  "query" : {
    "term": {
      "address": {
        "value": "沈"
      }
    }
  }
}
POST zqk/_doc/2
{
  "name" :"zqk2",
  "age" : 24,
  "address" : "五里河"
}

#查询名字等于张三的用户
GET person/_search?q=name:張三
GET zqk/_search?q=name:张三


#4.2.13 DSL 查询
#url地址请求体，多添加几条数据，方便做查询


PUT qiankunjia/_doc/1001
{
  "id":"1001",
  "name":"张三",
  "age":20,
  "sex":"男"
}



PUT qiankunjia/_doc/1002
{
  "id":"1002",
  "name":"李四",
  "age":25,
  "sex":"女"
}

PUT qiankunjia/_doc/1003
{
	"id":"1003",
	"name":"王五",
	"age":30,
	"sex":"女"
}

PUT qiankunjia/_doc/1004
{
  "id":"1004",
	"name":"赵六",
	"age":30,
	"sex":"男"
}

# 查询
GET qiankunjia/_search
GET qiankunjia/_search

#① 根据年龄查询
POST qiankunjia/_doc/_search
{
  "query":{
    "match":{
      "age":20
    }
  }
}
GET qiankunjia/_doc/_search
{
  "query" : {
    "match" : {
      "age" : 20
    }
  }
}

# ② 查询年龄大于20岁的女性用户
# 请求URL地址：
GET qiankunjia/_search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "age": {
            "gt": 20
          }
        }
      },
      "must":{
        "match":{
          "sex":"女"
        }
      }
    }
  }
}


# ③ 全文搜索
# 请求URL地址

GET qiankunjia/_search
{
  "query": {
    "match": {
      "name": "张三 李四"
    }
  }
}
GET qiankunjia/_search
{
  "query": {
    "match": {
      "name": "张三，李四"
    }
  }
}

# 高亮查询
GET qiankunjia/_search
{
  "query": {
    "match": {
      "name": "张三 李四"
    }
  },
  "highlight": {
    "fields": {
      "name": {}
    }
  }
}
GET qiankunjia/_search
{
  "query" : {
    "match": {
      "name": "张三，李四"
    }
  },
  "highlight": {
    "fields": {
      "name" : {}
    }
  }
}

# 聚合查询
GET qiankunjia/_search
{
  "aggs": {
    "all_interests": {
      "terms": {
        "field": "age"
      }
    }
  }
}
GET qiankunjia/_search
{
  "aggs" :{
    "all_interests" : {
      "terms": {
        "field": "age",
        "size": 10
      }
    }
  }
}

# 4.2.16 指定响应字段
# 在响应的数据中，如果我们不需要全部的字段，可以指定
# 些需要的字段进行返回
GET qiankunjia/_doc/1001?_source=id,name
GET qiankunjia/_doc/1001?_source=id,name

# 4.2.17 判断文档是否存在
# 如果我们只需要判断文档是否存在，而不是查询文档内容，那么可以这样：
HEAD qiankunjia/_doc/1001
# 200证明有
HEAD  shangguigu/_doc/1001
# 404证明没有


# 4.2.18.1 批量查询
POST qiankunjia/_doc/_mget
{
  "ids" : ["1001","1003"]
}
GET qiankunjia/_doc/_mget
{
  "ids" : ["1001","1003"]
}
#如果，某一条数据不存在，不影响整体响应，需要通过found的值进行判断是否查询到数据。
POST qiankunjia/_doc/_mget
{
  "ids" : ["1001","1006"]
}


# 4.2.18.2 _bulk操作
# 在Elasticsearch中，支持批量的插入、修改、删除操作，都是通过_bulk的api完成的。
# 请求格式如下：（请求格式不同寻常）

# 批量插入数据：
POST _bulk
{"create":{"_index":"qkjia","_id":2001}}
{"id":2001,"name":"name1","age":20,"sex":"男"}
{"create":{"_index":"qkjia","_id":2002}}
{"id":2002,"name":"name2","age":20,"sex":"男"}
{"create":{"_index":"qkjia","_id":2003}}
{"id":2003,"name":"name3","age":20,"sex":"男"}


# 批量删除
POST _bulk
{"delete":{"_index":"qkjia","_id":2001}}
{"delete":{"_index":"qkjia","_id":2002}}
{"delete":{"_index":"qkjia","_id":2003}}


# 4.2.19 分页
# 和SQL使用 LIMIT
# 关键字返回只有一页的结果一样，Elasticsearch接受
# from和 size 参数：

# 如果你想每页显示5个结果，页码从1到3，那请求如下：
GET /_search?size=5
GET /_search?size=5&from=5
GET /_search?size=5&from=10



GET qiankunjia/_search?size=1&from=2
GET zqk/_search?size=1&from=2

# 批量创建


POST zhaoqiankun/_bulk
{"index":{"_index":"zhaoqiankun"}}
{"name":"张三","age":20,"mail":"111@qq.com","hobby":"羽毛球、乒乓球、足球"}
{"index":{"_index":"zhaoqiankun"}}
{"name":"张三","age":21,"mail":"222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"}
{"index":{"_index":"zhaoqiankun"}}
{"name":"张三","age":23,"mail":"333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"}
{"index":{"_index":"zhaoqiankun"}}
{"name":"张三","age":24,"mail":"444@qq.com","hobby":"听音乐、看电影"}

GET zhaoqiankun/_search

# 测试搜索 
POST zhaoqiankun/_search
{
  "query": {
    "match": {
      "hobby": "音乐，足球"
    }
  }
}

#terms查询
#terms 跟 term 有点类似，但 terms #允许指定多个匹配条件。 #如果某个字段指定了多个值，那么文档需要一
#起去做匹配：
GET zhaoqiankun/_search
{
  "query": {
    "terms": {
      "age": [
        "20",
        "21"
      ]
    }
  }
}

# range查询
# range 过滤允许我们按照指定范围查找一批数据：
# gt :: 大于
# gte :: 大于等于
# lt :: 小于
# lte :: 小于等于
# 示例
POST zhaoqiankun/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 10,
        "lte": 20
      }
    }
  }
}

# exists 查询
# exists 查询可以用于查找文档中是否包含指定字段或没有某个字段，类似于SQL语句中的 IS_NULL 条件
# 'exists': 必须包含
POST zhaoqiankun/_search
{
  "query": {
    "exists": {
      "field": "age"
    }
  }
}

# 例如对 “我是程序员” # 进行分词#标准分词器分词效果测试：
POST _analyze
{
  "text": "我是程序员"
}
# Standard 标准分词，按单词切分，并且会转化成小写
POST _analyze
{
  "analyzer" : "standard",
  "text": ["A man becomes learned by asking questions ."]
}

#  IK分词器测试
# 1）最小切分：在浏览器地址栏输入地址
POST _analyze
{
  "analyzer": "ik_smart",
  "text": ["我是程序员"]
}
# 2）最细切分：在浏览器地址栏输入地址
POST _analyze
{
  "analyzer": "ik_max_word",
  "text": ["我是程序员"]
}

# 5.4 修改索引映射mapping
# 5.4.1 重建索引
# 创建索引
PUT person
# 删除原有blog1索引
DELETe person
# 创建索引，添加映射，指定使用ik分词器
PUT person
{
  "mappings": {
    "properties": {
      "name":{
        "type":"keyword"
      },
      "address":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}
PUT person
{
  "mappings": {
    "properties": {
      "name" : {
        "type": "keyword"
      },
      "address" : {
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}
# 查询索引
GET person

# 创建文档
PUT person/_doc/1
{
  "name" : "张三",
  "age" : 30,
  "address" : "华为5G手机"
}

# 添加文档
POST person/_doc/2
{
  "name":"李四",
  "age":20,
  "address":"深圳南山区"
}

# 添加文档
PUT person/_doc/3
{
  "name":"张三",
  "age":29,
  "address": "深圳南山"
}

# 查询所有数据
GET person/_search


# 5.4.3 再次测试term测试
# 使用term查询 深圳开头的数据
GET person/_search
{
  "query": {
    "term": {
      "address": {
        "value": "深圳"
      }
    }
  }
}




# 查询代码创建的 索引
GET abc

# 查询代码创建的 索引和映射
GET aaa

# 查询代码创建的 索引 删除后
GET abc

# 查询代码创建的 文档
GET aaa/_doc/2

# 查询代码创建的 修改后文档
GET aaa/_doc/2

# 查询代码创建的 删除后文档
GET aaa/_doc/1


GET person/_search

# 批量操作
# 1 删除1号记录
# 2 添加8号记录
# 3 修改2号记录 名称为二号

POST _bulk
{"delete":{"_index":"person","_id":"1"}}
{"create":{"_index":"person","_id":"8"}}
{"name":"8号","age":80,"address":"北京"}
{"update":{"_index":"person","_id":"2"}}
{"doc":{"name":"2号"}}



# 将数据库中Goods表的数据导入到ElasticSearch中
# ① 将数据库中Goods表的数据导入到ElasticSearch中
# ② 创建索引
PUT goods
{
	"mappings": {
		"properties": {
			"title": {
				"type": "text",
				"analyzer": "ik_smart"
			},
			"price": { 
				"type": "double"
			},
			"createTime": {
				"type": "date"
			},
			"categoryName": {	
				"type": "keyword"
			},
			"brandName": {	
				"type": "keyword"
			},
	
			"spec": {		
				"type": "object"
			},
			"saleNum": {	
				"type": "integer"
			},
			
			"stock": {	
				"type": "integer"
			}
		}
	}
}

# 查询索引
GET goods

# 添加文档数据
POST goods/_doc/1
{
  "title":"小米手机",
  "price":1000,
  "createTime":"2019-12-01",
  "categoryName":"手机",
  "brandName":"小米",
  "saleNum":3000,
  "stock":10000,
  "spec":{
    "网络制式":"移动4G",
    "屏幕尺寸":"4.5"
  }
}

# 查询文档数据
GET goods/_search

# 查询是否导入
GET goods/_search

#  查询 matchAll查询：查询所有文档
GET goods/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 100
}

# term查询：不会对查询条件进行分词。
GET goods

# term 查询
GET goods/_search
{
  "query": {
    "term": {
      "categoryName": {
        "value": "手机"
      }
    }
  }
}


# matchQuery:词条分词查询
# match查询：
# • 会对查询条件进行分词。
# • 然后将分词后的查询条件和词条进行等值匹配
# • 默认取并集（OR）

# match 查询 "title": "手机"
GET goods/_search
{
  "query": {
    "match": {
      "title": "华为"
      
    }
  }
}
# match 查询  "operator": "or"
GET goods/_search
{
  "query": {
    "match": {
      "title": {
        "query": "华为手机",
        "operator": "and"
      }
    }
  }
}


# 模糊查询-脚本
# wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
# prefix查询：前缀查询


# wildcard 查询。查询条件分词，模糊查询 华为，华，*华*
GET goods/_search
{
  "query": {
    "wildcard": {
      "title": {
        "value": "华*" 
      }
    }
  }
}

# 前缀查询
GET goods/_search
{
  "query": {
    "prefix": {
      "brandName": {
        "value": "三"
      }
    }
  }
}

# range 范围查询：查找指定字段在指定范围内包含值
# 范围查询 gte 大于等于 lte小于等于
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 2000,
        "lte": 3000
      }
    }
  }
}

# 范围查询 gte 大于等于 lte小于等于
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 2000,
        "lte": 3000
      }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

# queryString查询-脚本
# queryString：
# • 会对查询条件进行分词。
# • 然后将分词后的查询条件和词条进行等值匹配
# • 默认取并集（OR）
# • 可以指定多个查询字段

# queryString
GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","categoryName","brandName"],
      "query": "华为"
    }
  }
}

# 布尔查询
# boolQuery：对多个查询条件连接。连接方式：
# • must（and）：条件必须成立
# • must_not（not）：条件必须不成立
# • should（or）：条件可以成立
# • filter：条件必须成立，性能比must高。不会计算得分
#  term ：不会对查询条件进行分词。
# match查询：
# • 会对查询条件进行分词。
# • 然后将分词后的查询条件和词条进行等值匹配
# • 默认取并集（OR）

GET goods/_search
{
  "query": {
    "match": {
      "title": "华为手机"
    }
  },
  "size": 500
}

# 计算得分
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        }
      ]
    }
  }
}

# 不计算得分
GET goods/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        }  
      ]
    }
  }
}


# 计算得分 品牌是三星，标题还得电视
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "三星"
            }
          }
        }
      ],
      "filter": {
        "term": {
          "title": "电视"
        }
      }
    }
  }
}


# 聚合查询
# • 指标聚合：相当于MySQL的聚合函数。max、min、avg、sum等
# • 桶聚合：相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。

# 查询最贵的华为手机，max_price命名随便取，取一个有意义的名字
GET goods/_search
{
  "query": {
    "match": {
      "title": "华为手机"
    }
  },
  "aggs": {
    "max_price":{
      "max": {
        "field": "price"
      }
    }
  }
}



# 桶聚合 分组
GET goods/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "aggs": {
    "goods_brands": {
      "terms": {
        "field": "brandName",
        "size": 100
      }
    }
  }
}


# 高亮查询
# 高亮三要素：
# • 高亮字段
# • 前缀
# • 后缀
GET goods/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "highlight": {
    "fields": {
      "title": {
        "pre_tags": "",
        "post_tags": ""
      }
    }
  }
}

# 重建索引
# 随着业务需求的变更，索引的结构可能发生改变。
# ElasticSearch的索引一旦创建，只允许添加字段，不允许改变字段。因为改变字段，需要重建倒排索引，影响内部缓
# 存结构，性能太低。
# 那么此时，就需要重建一个新的索引，并将原有索引的数据导入到新索引中。
# 原索引库 ：student_index_v1
# 新索引库 ：student_index_v2

# 新建student_index_v1索引，索引名称必须全部小写
PUT student_index_v1
{
  "mappings": {
    "properties": {
      "birthday" : {
        "type": "date"
      }
    }
  }
}
# 查询索引
GET student_index_v1
# 添加数据
PUT student_index_v1/_doc/1
{
  "birthday":"2020-11-11"
}
# 查询数据
GET student_index_v1/_search
# 随着业务的变更，换种数据类型进行添加数据，程序会直接报错
PUT student_index_v1/_doc/1
{
  "birthday":"2020年11月11号"
}

# 业务变更，需要改变birthday数据类型为text
# 1：创建新的索引 student_index_v2
# 2：将student_index_v1 数据拷贝到 student_index_v2

# 创建新的索引
PUT student_index_v2 
{
  "mappings": {
    "properties": {
      "birthday":{
        "type": "text"
      }
    }
  }
}


# 删除索引2
DELETE student_index_v2

# 2：将student_index_v1 数据拷贝到 student_index_v2
POST _reindex
{
  "source": {
    "index": "student_index_v1"
  },
  "dest": {
    "index": "student_index_v2"
  }
}


# 查询新索引库数据
GET student_index_v2/_search

# 在新的索引库里面添加数据
PUT student_index_v2/_doc/2
{
  "birthday":"2020年11月13号"
}
# 查询数据
GET student_index_v2/_search


#    使用 kibana 查询
    GET item
    
     GET item/_search