# es

**Repository Path**: NOW_GO/es

## Basic Information

- **Project Name**: es
- **Description**: esDemo
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-05-20
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#分词
~~~~

POST _analyze
{
 "analyzer":"ik_max_word",
 "text":"中国，你好！华为加油"
}
~~~~
# 操作es 的Restful 语法
~~~~

GET 请求：
   http://ip:port/index:查询信息
   http://ip:port/index/type/doc_id:查询指定的文档信息       
POST 请求：
    http://ip:port/index/type/_search:查询文档，可以在请求体中添加json代表查询条件
    http://ip:port/index/type/doc_id/_update 修改文档，在请求体中指定json代表修改的具体信息
PUT 请求：
    http://ip:port/index:创建一个索引，需要在请求体中指定索引的信息
    http://ip:port/index/type/_mappings:代表创建索引时，指定索引文档存储的属性的信息
 DELETE 请求
    http://ip:port/index/type/doc_id
    
    
    
~~~~
#索引
~~~~
PUT /book
{
  "settings": {
    "number_of_replicas": 1,
    "number_of_shards": 5
  },
  "mappings": {
    "novel":{
       "properties":{
         "name":{
            "type":"text",
            "analyzer":"ik_max_word",
            "index":true,
            "store":false
         },
         "author":{
           "type":"keyword"
         },
         "count":{
           "type":"long" 
         },
         "onSale":{
           "type":"date",
           "format":"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
         },
         "descr":{
            "type":"text",
            "analyzer":"ik_max_word"
         }
       }
    }
  }
}
~~~~
#添加文档
~~~~
添加文档自动生成id
POST /book/novel
{
  "name":"西游记",
  "author":"施耐庵",
  "count":100000,
  "onSale":"1985-02-01",
  "descr":"四大名著之一"
}
添加文档手动生成id
PUT /book/novel/1
{
  "name":"红楼梦",
  "author":"曹雪芹",
  "count":989898989,
  "onSale":"1905-04-02",
  "descr":"名著"
}
~~~~
#修改文档
~~~~
1、覆盖式修改

PUT /book/novel/1
{
  "name":"红楼梦",
  "author":"曹雪芹",
  "count":1000000,
  "onSale":"1905-04-02",
  "descr":"名著"
}
2、doc 形式修改

POST /book/novel/1/_update
{
  "doc": {
    "count":132456
  }
} 

~~~~  
#   term 和terms
  都不会 将指定的查询关键字进行分词，直接去分词库中匹配  ，在找到相应的文档
   term:where province =北京
   terms:where province=北京 or province=上海 （province in (北京,上海)）
   
   term
~~~~
	/**
	 * POST /book/novel/_search
	 * {
	 *   "from": 0,
	 *   "size": 20,
	 *   "query": {
	 *     "term": {
	 *       "province": {
	 *         "value": "北京"
	 *       }
	 *     }
	 *   }
	 * }
	 * @throws IOException
	 */
      @Test
	void contextLoadsA()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		  SearchRequest request = new SearchRequest("book");
		  request.types("novel");
		  SearchSourceBuilder builder = new SearchSourceBuilder();
		  builder.from(0);
		  builder.size(5);
		  builder.query(QueryBuilders.termQuery("province","北京"));
		  request.source(builder);
		  SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		  for (SearchHit hit : response.getHits().getHits()) {
			  Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			  System.out.println(sourceAsMap);
		  }
	  }


~~~~
#terms
~~~~
POST /book/novel/_search
{
  "query": {
    "terms": {
      "province": [
        "北京",
        "山西",
        "武汉"
      ]
    }
  }
}

	void termsQuery()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		  SearchRequest request = new SearchRequest("book");
		  request.types("novel");
		  SearchSourceBuilder builder = new SearchSourceBuilder();
		  builder.from(0);
		  builder.size(5);
		  builder.query(QueryBuilders.termsQuery("province","北京","山西","武汉"));
		  request.source(builder);
		  SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		  for (SearchHit hit : response.getHits().getHits()) {
			  Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			  System.out.println(sourceAsMap);
		  }
	  }

~~~~
#bool match  查询   
（查询smsContent field 字段包含中国和健康（and）））
 ~~~~
POST /book/novel/_search
{
  "query": {
    "match": {
      "smsContent": {
        "query": "中国 健康",
        "operator": "and | or "
      }
    }
  }
}

	void boolTermSearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		  SearchRequest request = new SearchRequest("book");
		  request.types("novel");
		  SearchSourceBuilder builder = new SearchSourceBuilder();
		  builder.from(0);
		  builder.size(5);
		  builder.query(QueryBuilders.matchQuery("province","中国 健康").operator(Operator.OR));
		  request.source(builder);
		  SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		  for (SearchHit hit : response.getHits().getHits()) {
			  Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			  System.out.println(sourceAsMap);
		  }
	  }
~~~~
# multi_match 查询  (多个field 匹配)
~~~~

        POST /book/novel/_search
        {
          "query": {
            "multi_match": {
              "query": "西",
              "fields": ["name","author"]
            }
          }
        }

	void multiMatchSearch()throws IOException {
		  RestHighLevelClient client = ESCl1ient.getClient();
		  SearchRequest request = new SearchRequest("book");
		  request.types("novel");
		  SearchSourceBuilder builder = new SearchSourceBuilder();
		  builder.from(0);
		  builder.size(5);
		  builder.query(QueryBuilders.multiMatchQuery("西","name","author"));
		  request.source(builder);
		  SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		  for (SearchHit hit : response.getHits().getHits()) {
			  Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			  System.out.println(sourceAsMap);
		  }
	  }

~~~~
#根据id 查询
~~~~
      GET /book/novel/1
	  @Test
	void findById()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		  GetRequest getRequest = new GetRequest("book","novel","1");
		  GetResponse response = client.get(getRequest, RequestOptions.DEFAULT);
		  System.out.println(response.getSourceAsMap());

	  }

~~~~
#根据多个id 查询
~~~~
  # 多个id 查询
  POST /book/novel/_search
  {
    "query": {
      "ids": {
        "values": ["1","2"]
      }
    }
  }

~~~~
#prefix 
前缀查询,可以通过一个关键字去指定一个Field的前缀,从而查询到指定的文档
~~~~

POST /book/novel/_search
{
  "query": {
    "prefix": {
      "name":{
        "value": "西"
      }
    }
  }
}
	@Test
	void prefixSearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		SearchRequest request = new SearchRequest("book");
		request.types("novel");
		SearchSourceBuilder builder = new SearchSourceBuilder();
		builder.from(0);
		builder.size(5);
		builder.query(QueryBuilders.prefixQuery("name","西"));
		request.source(builder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		for (SearchHit hit : response.getHits().getHits()) {
			Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			System.out.println(sourceAsMap);
		}

	}
~~~~ 
 #fuzzy 模糊查询(允许有错别查询)
~~~~

POST /book/novel/_search
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "西游击",
        "prefix_length": 1
      }
    }
  }
}
	@Test
	void fuzzySearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		SearchRequest request = new SearchRequest("book");
		request.types("novel");
		SearchSourceBuilder builder = new SearchSourceBuilder();
		builder.from(0);
		builder.size(5);
		builder.query(QueryBuilders.fuzzyQuery("name","西").prefixLength(1));
		request.source(builder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		for (SearchHit hit : response.getHits().getHits()) {
			Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			System.out.println(sourceAsMap);
		}

	}


~~~~
#wildcard 通佩查询  
通配查询,和MySQL 中的like 是 一个套路,可以在查询时,在字符中指定通配符* 和占位符?
~~~~

POST /book/novel/_search
{
  "query": {
    "wildcard": {
      "name": {
        "value": "西**"
      }
    }
  }
}
	@Test
	void wildcardSearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		SearchRequest request = new SearchRequest("book");
		request.types("novel");
		SearchSourceBuilder builder = new SearchSourceBuilder();
		builder.from(0);
		builder.size(5);
		builder.query(QueryBuilders.wildcardQuery("name","西**"));
		request.source(builder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		for (SearchHit hit : response.getHits().getHits()) {
			Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			System.out.println(sourceAsMap);
		}

	}
 ~~~~
#range
~~~~
POST /book/novel/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 10,
        "lte": 20
      }
    }
  }
}

	@Test
	void rangSearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		SearchRequest request = new SearchRequest("book");
		request.types("novel");
		SearchSourceBuilder builder = new SearchSourceBuilder();
		builder.from(0);
		builder.size(5);
		builder.query(QueryBuilders.rangeQuery("age").gte(1).lte(10));
		request.source(builder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		for (SearchHit hit : response.getHits().getHits()) {
			Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			System.out.println(sourceAsMap);
		}

	}

~~~~
#regexp 查询
~~~~

    POST /book/novel/_search
    {
      "query": {
        "regexp": {
          "mobile": "180[0-9]{8}"
        }
      }
    }

     @Test
	void regexpSearch()throws IOException {
		  RestHighLevelClient client = ESClient.getClient();
		SearchRequest request = new SearchRequest("book");
		request.types("novel");
		SearchSourceBuilder builder = new SearchSourceBuilder();
		builder.from(0);
		builder.size(5);
		builder.query(QueryBuilders.regexpQuery("mobile","180[0-9]{8}"));
		request.source(builder);
		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
		for (SearchHit hit : response.getHits().getHits()) {
			Map<String, Object> sourceAsMap = hit.getSourceAsMap();
			System.out.println(sourceAsMap);
		}

	}
~~~~
# 分页的原理
~~~~
from+size 在ES查询数据库的方式：

 1、将用户指定的关键词进行分词
 2、去分词库中进行检索，得到多个俄文档id
 3、去各个分片中拉去指定的数据。耗时较长
 4、根据score 进行排序。耗时较长
 5、根据from的值，将查询到的数据舍弃一部分呢
 6、返回结果

 scroll+size 在ES查询数据的方式：

 1、将用户指定的关键词进行分词
 2、将分词去分词库中进行检索。得到多个文档id
 3、将文档id 存放在一个ES的上下文中。
 4、根据你指定的size的个数去es中检索指定个数据，拿完数据的文档id,会从上下文中移除
 5、如果需要下一页的数据，直接去es的上下文中,找后续内容
 6、循环第4、5
 scroll 查询方式不适合作事实查询
~~~~
# _delete_by_query
~~~~
POST /book/novel/_delete_by_query
{
  "query":{
    "range":{
      "fee":{
        "lt":4
      }
    }
  }
}
~~~~
# bool
~~~~
#查询省份为武汉或者北京
 #运营商不是联通
 # smsContent中包含中国和平安
 # bool 查询
 POST /sms-logs-index/sms-logs-type/_search
 {
   "query": {
     "bool": {
       "should": [
         {
           "term": {
             "province": {
               "value": "北京"
             }
           }
           
         },
         {
           "term": {
             "province": {
               "value": "武汉"
             }
           }
         }
       ]，
       , "must_not": [
         {
           "term": {
             "operatorId": {
               "value": "2"
             }
           }
         }
       ],
       "must": [
         {
           "match": {
             "smsContent": "中国"
           }
         },
         {
           "match": {
             "smsContent": "平安"
           }
         }
       ]
     }
   }
 }