Elasticsearch学习笔记

es增删改查

创建index

PUT /index_name   				//index的名字
{
  "mappings": {
    "my_type": {				//type_name
      "dynamic" : "strict",    //规定如果添加新的field会报错
      "properties": {
        "title" : {
          "type": "text", 		
          "index": true
        },
        "address" : {
          "type": "object",		//object类型
          "dynamic" : true     //规定如果添加新的field会进行dynamic mapping
        }
      }
    }
  }
}
1.定制dynamic策略
true：遇到陌生字段，就进行dynamic mapping
false：遇到陌生字段，就忽略
strict：遇到陌生字段，就报错

手动创建mapping

    PUT /index_name
    {
      "settings":{
        "number_of_shards":3,          //分片的数量
        "number_of_replicas":1         //副本数量
      },
      "mappings":{
        "type_name":{                  //类型的名字
          "dynamic" : "strict",        //（注释1） 规定如果添加新的field会报错(true,flase，strict)
          "properties":{  
            "name":{              
              "type":"text",           //类型为text(keyword ,text)  text分词
              "analyzer":"standard"    //（注释2）使用分词器 
            },
            "updata_time":{
              "type":"date",          //日期类型
              "index":"false"         //是否创建倒排索引  默认情况下会为每个字段建立倒排
              "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"   //时间的格式
            }
          }
        }
      }
    }

1 定制dynamic策略
true：遇到陌生字段，就进行dynamic mapping
false：遇到陌生字段，就忽略
strict：遇到陌生字段，就报错
########################################
2 ik 分词器
ik_max_word //细粒度的拆分，尽可能多的拆分出词语
ik_smart //粗力度但拆分，不会重复

添加数据

//如果给定ID 可以使用put 
//如果没有给定ID 只能使用post系统自动生成一个ID
PUT /index_name/type_name/id
{
 "name":"xioaming"
}

查询

直接在url中添加查询条件
（简单查询）

 GET GET /index_name/type_nameme/_search?q=xiaohei:hello Elasticsearch

 结果

 {
        "took": 1,                //时间毫秒
        "timed_out": false,       //是否超时
        "_shards": {               //分片
          "total": 3,             //向三个分片发送请求
          "successful": 3,        //三个成功
          "skipped": 0,  
          "failed": 0
        },
        "hits": {
          "total": 2,             //一共查询出来几个文档
          "max_score": 0.5753642, // 匹配度分数  匹配度最大的 
          "hits": [
            {
              "_index": "yyz001",
              "_type": "yyztype",
              "_id": "9t7Al2sBgnM7_3hnd7qZ",
              "_score": 0.5753642,
              "_source": {        //每个字段对应的值
                "xiaohei": "hello Elasticsearch",
                "time": "2019-6-25"
              }
            },
            {
              "_index": "yyz001",
              "_type": "yyztype",
              "_id": "9d64l2sBgnM7_3hnzbou",
              "_score": 0.2876821,
              "_source": {
                "dabai": "hello Elasticsearch"
              }
            }
          ]
        }
 }

term查询

term 会去倒排索引中去找 ， 不会分词 ，倒排索引中没有就是没有， 适合没有分词类型的进行查询

GET /index_name/type_name/_search
{
  "query":{
    "term":{
      "name":"hello Elasticsearch"
    }
  }
}

terms查询

terms  查询多个
  GET /index_name/type_name/_search
  {
    "from":0, //将查询结果从第0个文档开始
    "size":2, //显示到第2个， 只显示两个
    "version":true,//显示版本号 如果更改过数据
    "query":{
      "terms":{
        "xiaohei":["hello Elasticsearch","hello zhongguo"]//查询多个
      }
    }
  }

match查询

match  会进行分词， 
  GET /index_name/type_name/_search
  {
    "query":{
      "match":{
        "xiaohei":"hello Elasticsearch" //先分词然后再去查找(分为hello和Elasticsearch)
      }
    }
  }

multi_match查询

multi_match   可以指定多个字段  
  GET /index_name/type_name/_search
  {
    "query":{
      "multi_match":{
        "query":"hello"
        "fields":["name","age"]      //只要是在name和age中有hello的都会被查到
      },
    "_source":{
      "includes":["name","age"],              //显示哪些字段
      "excludes":["address","birthday"]       //不显示哪些字段
    }
    }
  }

match_phrase

match_phrase   短语匹配  
  GET /index_name/type_name/_search
  {
    "_source":["name","ag*"],   //控制只显示哪些字段 ，可以使用通配符
    "query":{
      "match_phrase":{
      "xiaohei":"hello Elasticsearch"  // 必须完全一样才能查出来 ，必须完全一样才能查出来
      }
    },
  
  }

sort 排序

sort 排序
  GET /index_name/type_name/_search
  {
    "query":{
      "match_all":{}
    },
    "sort":[
    {
      "age":{
        "order":desc     //ace&desc 和sql是一样的
      }
    }
    ]
  }

match_phrase_prefix 查询

GET /index_name/type_name/_search
      {
        "query":{
          "match_phrase_prefix":{
          "xiaohei":"hello"  //  相当于sql 的 like 'hello%' 
          }
        },
      
      }

范围查询

范围查询 range
      GET /index_name/type_name/_search
      {
        "query":{
          "range":{               // 范围查询
          "birthday":{
            "from":"1900-10-10",
            "to":"2019-6-1",
            "include_lower":true, //包含上限（from）
            "include_upper":false //不包含下限（false）
          } 
          }
        },
      }

fuzzy模糊查询

    GET /index_name/type_name/_search
      {
        "query":{
          "fuzzy":{
            "name":"xomig" //可以查到xiaoming
          }
        }
      }

高亮显示

GET /index_name/type_name/_search
    {
      "query":{
        "match":{
          "name":"xiaoming"
        }
      }
      "highlight":{                //高亮显示
        "fields":{
          "name":{} 			//字段名字
        }
      }
    }

Bool查询

Bool查询现在包括四种子句，must，filter,should,must_not。
bool查询的使用
Bool查询对应 Lucene 中的BooleanQuery，它由一个或者多个子句组成，每个子句都有特定的类型。

---

must

返回的文档必须满足must子句的条件，并且参与计算分值
与 AND 等价。

---

filter

返回的文档必须满足filter子句的条件。但是不会像Must一样，参与计算分值

---

should
返回的文档可能满足should子句的条件。在一个Bool查询中，如果没有must或者filter，
有一个或者多个should子句，至少有一个语句要匹配，与 OR 等价。
minimum_should_match 参数定义了至少满足几个子句。

---

must_not

所有的语句都 不能匹配，与 NOT 等价。

---

{
    "bool" : {
        "must" : {      //返回的文档必须满足must子句的条件，参与计算分值
            "term" : { "user" : "kimchy" }
        },
        "filter": {     //返回的文档必须满足filter子句的条件。但是不会参与计算分值
            "term" : { "tag" : "tech" }
        },
        "must_not" : {    //返回的文档必须不满足must_not定义的条件。
            "range" : {
                "age" : { "from" : 10, "to" : 20 }
            }
        },
        "should" : [     
                 // 返回的文档可能满足should子句的条件。在一个Bool查询中，如果没有must或者filter，
                    有一个或者多个should子句，那么只要满足一个就可以返回。
                    minimum_should_match 参数定义了至少满足几个子句。
            {
                "term" : { "tag" : "wow" }
            },
            {
                "term" : { "tag" : "elasticsearch" }
            }
        ],
        //有一个或者多个should子句，那么只要满足一个就可以返回。
 		//minimum_should_match 参数定义了至少满足几个子句。
        "minimum_should_match" : 1,
        "boost" : 1.0
    }
}

function_score

function_score 查询详情可以查看官网
https://www.elastic.co/guide/cn/elasticsearch/guide/current/function-score-query.html

---

exists 查询和 missing 查询被用于查找那些指定字段中有值 (exists) 或无值 (missing) 的文档。
这与SQL中的 IS_NULL (missing) 和 NOT IS_NULL (exists) 在本质上具有共性

{
    "exists":   {
        "field":    "title"
    }
}

尽管没有 bool 查询使用这么频繁，constant_score 查询也是你工具箱里有用的查询工具。
它将一个不变的常量评分应用于所有匹配的文档。它被经常用于你只需要执行一个 filter 而没有其它查询
（例如，评分查询）的情况下。

可以使用它来取代只有 filter 语句的 bool 查询。在性能上是完全相同的，但对于提高查询简洁性和清晰度有很大帮助。

{
    "constant_score":   {
        "filter": {
            "term": { "category": "ebooks" } 
        }
    }
}

term 查询被放置在 constant_score 中，转成不评分的 filter。
这种方式可以用来取代只有 filter 语句的 bool 查询。