elasticsearch数据库查询语句积累

urisearch：uri传参查询

一、请求方式 ：

           get post均可

二、用法 

  @ip:@port/_search?q=@text      ---------不进行索引（index）查询，从所有内容中模糊查询@text   

  @ip:@port/@index/_search?q=@text      ---------在指定的索引(index)中进行查询@text

 

  @ip:@port/@index/@type/_search?q=@text      ---------在指定的索引(index)指定typ中进行查询@text 6.X版本后可以无视type

     

     

@ipes数据库的ip，若为集群任意一个节点便可
@portes数据库的端口号
@indexes的索引，可大致看为表名
@typees 类名，6.x后可以无视
_search查询固定关键字
q=uri查询中的关键字
@text

查询的内容，用两种用法

第一种：直接填写要查询的内容，如：test

第二种：在指定字段里查询指定内容，如：.

              a:test  解释：查询a字段中内容为test的

 

 

 

 

 

 

 

 

 

 

注：当uri查询和body查询同事存在时有限执行uri的查询

request body search：请求body传传参查询

一、关键字query，查询的逻辑主体

post /_search
{
    "query" : {
        "term" : { "user" : "kimchy" }
    }
}

查询字段user内容为kimchy的数据

用法在query查询快中添加查询子句即可

与uri查询类似 url也是由ip，port，index组成，其中index也可看为一个筛选条件，指定了本次查询的查询范围

 

 

查询分为两个部分查询和筛选，查询子句的行为取决于它在查询中还是在筛选中

查询中的子句会对查询的内容进行评分，通过评分来得出所查出的内容是否匹配查询子句

筛选中的子句会对查询结果进行筛选，得出所查结果是不是需要的结果（频繁使用的过滤器会被es缓存）

 

GET /_search
{
  "query": { 
    "bool": { 
      "must": [
        { "match": { "title":   "Search"        }},
        { "match": { "content": "Elasticsearch" }}
      ],
      "filter": [ 
        { "term":  { "status": "published" }},
        { "range": { "publish_date": { "gte": "2015-01-01" }}}
      ]
    }
  }
}

语句解释：查询字段title是Search并且content字段是Elasticearch的数据，再数据进行筛选 status字段必须为published，publish_date时间字段大于等于2015-01-01

bool对条件进行聚合：must答题相当于sql中where语句中的=，此外还有should和not must等

match和term都是查询用的关键词，其中term是完全匹配，不会对参数使用分词器进行拆分，而match会对参数进行分词处理

如      { "term":  { "a": "a b" }}  使用term只会查询a字段的分词中包含a b的内容

          { "match": { "a":   "a b"}}使用match会对参数进行分词处理结果会查出 a字段分词中有a的，b的以及a b 的内容

range用于时间查询的关键字

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

最简单的查询，查询并匹配所有的文档，并给他们添加_score为1.0

GET /_search
{
    "query": {
        "match_none": {}
    }
}

与match_all想反，查询所有但是不匹配任何文档

match查询：会对查询的参数进行分词之后查询

GET /_search
{
    "query": {
        "match" : {
            "message" : {
                "query" : "this is a test",
                "analyzer" : "my_analyzer"
            }
        }
    }
}
analyzer：可以指定那个分词器来对参数进行分词

高级参数：operator

GET /_search
{
    "query": {
        "match" : {
            "message" : {
                "query" : "this is a test",
                "operator" : "and"
            }
        }
    }
}

operator默认为or，他可以控制match查询中各个分词在查询中的判断关系比如：默认情况下例子中的参数会被分词为 this，is，a，test，数据中message字段的索引中只要包含着四个分词中任意一个可以被查出，若改为and，则message索引中需要包含这个四个分词才会被查出

{
    "query":{
        "match":{
            "name":{
                "query":"hello world",
                "minmum_should_match":"50%"
            }
        }
    }
}

minmum_should_match：最小匹配度，如上图50%即一般匹配度，name字段的索引包含hello或者world都可以被查出，若改为100%则该字段与operator的and效果相同

fuzziness：略
cutoff_frequency：略

Synonyms：略

match_phrase：分词后的查询必须即包含所有分词，分词必须相邻，且顺序需要正确，可以认为为输入参数的全匹配

match_phrase_prefix：



GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : {
                "query" : "quick brown f",
                "max_expansions" : 10
            }
        }
    }
}

与match_phrase相似，可对参数最后一位进行向后匹配比如例子中的参数 ‘quick brown f’就可以查出‘quick brown for’等

max_expansions设置最大的匹配长度

multi_match与match相似，但是multi_match更适合于多字段查询

GET /_search
{
  "query": {
    "multi_match" : {
      "query":    "hello world", 
      "fields": [ "subject", "message" ] 
    }
  }
}

对subject和message进行查询查询的参数是hello world，相当于match 的

{
    "query": {
        "bool": {
            "should": [
                {"match": {
                        "subject": "hello world"
                        
                    }},
                    {"match": {
                        "message": "hello world"
                    }}
            ]
        }
    }
}

 

multi_match查询的类型:编辑
multi_match查询内部执行的方式取决于类型参数，可以设置为:

GET /_search
{
  "query": {
    "multi_match" : {
      "query":      "brown fox",
      "type":       "best_fields",
      "fields":     [ "subject", "message" ],
      "tie_breaker": 0.3
    }
  }
}

best_fields

multi默认使用此规则，对多个字段分别评分使用其中评分最高的最为本条数据的评分

most_fields

对每个字段进行评分，合并所有字段的评分作为本条数据的评分

cross_fields

讲参数分为多个分词，将所查询的字段的索引页看做是一个字段的索引

phrase

相当于对每个字段分别进行match_phrase查询

phrase_prefix

相当于对每个字段进行一次phrase_prefix查询

Query String Query:让你可以做用字符串来编写筛选逻辑

GET /_search
{
    "query": {
        "query_string" : {
            "default_field" : "content",
            "query" : "hello AND world"
        }
    }
}

语句解释：查询content字段的索引中同事包含hello和world的

query_string项目介绍

query：查询的参数可以使用空格分隔省略掉AND和OR 但是这样的话会默认使用默认连接OR

default_field：查询的字段

fields：查询多个字段时使用 用法：fields" : ["age", "name"]

default_operator：默认连接符 若在query里使用空格使用空格分隔没有连接关键词的会默认使用此项

analyzer：指定对参数进行分词时的分词器

Simple Query String Query：官方自称的比Query String Query更加方便的方法

与Query String Query项目逻辑语被替换

+替换AND

|替换OR

-替换

term：会在倒排索引中查找到确切的参数，与match不同term的参数不会被分词器拆分

POST _search
{
  "query": {
    "term" : { "user" : "hello world" } 
  }
}

解释：查询字段user，索引中有hello world 的数据

terms：term的附属匹配版

GET /_search
{
    "query": {
        "terms" : { "user" : ["kimchy", "elasticsearch"]}
    }
}

解释：查询字段user中内容有kimchy或者elasticsearch的数据

 

搞不明白：

index

The index to fetch the term values from.

type

The type to fetch the term values from.

id

The id of the document to fetch the term values from.

path

The field specified as path to fetch the actual values for the terms filter.

routing

A custom routing value to be used when retrieving the external terms doc.

Range Query：对进行范围查询

GET _search
{
    "query": {
        "range" : {
            "age" : {
                "gte" : 10,
                "lte" : 20,
                "boost" : 2.0
            }
        }
    }
}

解释：查询字段age在范围10到20直接的数据

gte

大于等于

gt

大于

lte

小于等于

lt

小于

boost

查询的分值

 

注：日期数学暂时省略

Exists Query：

exists 根据字段是不是存在进行查询，实际可以认为是根据相关子弹内容是不是存在，因为若查询的字段内容是null或者[]也不会查出

GET /_search
{
    "query": {
        "exists": {
            "field": "user"
        }
    }
}

查询包含字段user（包含user字段且user字段不是null或者[]）的数据

Prefix Query：前缀查询指定字段的前缀进行查询

GET /_search
{ "query": {
    "prefix" : { "user" : "ki" }
  }
}

解释：查询user字段前缀为ki的数据

GET /_search
{ "query": {
    "prefix" : { "user" :  { "value" : "ki", "boost" : 2.0 } }
  }
}

本查询同样可以设置分数

Wildcard Query：可以使用一个或者多个通配符进行查询

GET /_search
{
    "query": {
        "wildcard": {
            "user": {
                "value": "ki*y",
                "boost": 1.0,
                "rewrite": "constant_score"
            }
        }
    }
}

查询user字段以ki开头并且以y结尾的数据

通配符：

?   单个字符的通配符

*   零个到多个字符的通配符

rewrite：指定es数据库对你的低效查询语句进行重写的方式   暂时省略

Regexp Query：允许查询中使用正则表达式进行，规则参考正则表达式规则

GET /_search
{
    "query": {
        "regexp":{
            "name.first": "s.*y",
            "max_determinized_states":2000
        }
    }
}

解释：查询name下的first字段以s开头y结尾的数据

max_determinized_states:允许正则字段的长度默认为1000，可以通过这个字段设置正则字段的长度

Fuzzy Query：是一种非常模糊得查询方式

GET /_search
{
    "query": {
        "fuzzy" : {
            "user" : {
                "value": "ki",
                "boost": 1.0,
                "fuzziness": 2,
                "prefix_length": 0,
                "max_expansions": 100
            }
        }
    }
}

fuzziness：允许被模糊得字符数

prefix_length：不会被模糊的首字母数目

max_expansions：模糊查询讲扩展到的最大的词语数

Type Query：类型查询（6.*版本type已经只能设置一个了，顾本项基本可以看为别名查询了）

GET /_search
{
    "query": {
        "type" : {
            "value" : "_doc"
        }
    }
}

解释，查询类型是_doc的数据

Ids Query：根据数据的id进行查询，这个id并不是我们自己规定的id 而是es数据库中每条数据的_id字段

GET /_search
{
    "query": {
        "ids" : {
            "type" : "_doc",
            "values" : ["1", "4", "100"]
        }
    }
}

解释：查询id 是1或者id是4或者id是100的数据

Constant Score Query：评分性查询，可以让里面的过滤也参与到评分中（不确定）

GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}

创建一个筛选器筛选出user字段是kimchy的数据，并计入boost中设置的分数

Bool Query：一种聚合查询，一种与其他查询组成的组合查询

OccurDescription

must

查询子句中的条件比距出现在结果中，有点相当于sql中的=

filter

过滤器，忽略插叙中的到的分数，过滤的执行在查询之后

should

相当于sql中使用or连接但是又有区别

must_not

查询子句中不能出现在查询中 类似于sql中的！=

POST _search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "user" : "kimchy" }
      },
      "filter": {
        "term" : { "tag" : "tech" }
      },
      "must_not" : {
        "range" : {
          "age" : { "gte" : 10, "lte" : 20 }
        }
      },
      "should" : [
        { "term" : { "tag" : "wow" } },
        { "term" : { "tag" : "elasticsearch" } }
      ],
      "minimum_should_match" : 1,
      "boost" : 1.0
    }
  }
}

查询user字段是kimchy，并且age不在10到20之间，并且tag是tech的，并且tag是wow或者tag是elasticsearch的数据

minimum_should_match：should最小的匹配条数，默认是0，意味着若是不设置的话should字段形同虚设

filter若不指定分值的话不会影响数据的最后的评分

Dis Max Query啥玩意没搞明白

Function Score Query啥玩意没搞明白

Boosting Query降分查询，降低与not不同它只是降低了符合条件的数据的分数，并不会筛选掉数据

GET /_search
{
    "query": {
        "boosting" : {
            "positive" : {
                "term" : {
                    "field1" : "value1"
                }
            },
            "negative" : {
                 "term" : {
                     "field2" : "value2"
                }
            },
            "negative_boost" : 0.2
        }
    }
}

解释：解释不出来我也没搞懂这个怎么用

Nested Query嵌套查询，子属性查询

GET /my_index/_search
{
    "query": {
        "nested" : {
            "path" : "obj1",
            "query" : {
                "bool" : {
                    "must" : [
                        { "match" : {"obj1.name" : "blue"} },
                        { "range" : {"obj1.count" : {"gt" : 5}} }
                    ]
                }
            },
            "score_mode" : "avg"
        }
    }
}

查询obj1竖向下面name字段是blue且count大于5的的数据

score_mode子类查询对根父类评分的影响策略

avg (Default)

使用所有匹配子对象的平均分数

max

使用所有匹配子对象的最高分数

min

使用所有匹配子对象的最低分数

none

不适用子类的分数，父类复制分数为0

sum

所有匹配到的子类的分数相加

Has Child Query：略

Has Parent Query：略

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

二、关键字from、size，分页

.........................未完待续且未验证