elasticsearch查询语句

2022-10-17 19:31:04

1，安装es

安装java环境

# java --version
java version "1.8.0_65" Java(TM) SE Runtime Environment (build 1.8.0_65-b17) Java HotSpot(TM) 64-Bit Server VM (build 25.65-b01, mixed mode)

安装es 官网：https://www.elastic.co/guide/en/elasticsearch/reference/current/rpm.html

 # rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

[elasticsearch-6.x]

name=Elasticsearch repository for 6.x packages

baseurl=https://artifacts.elastic.co/packages/6.x/yum

gpgcheck=1

gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch

enabled=1

autorefresh=1

type=rpm-md

# sudo yum install elasticsearch

2，es配置文件

elasticsearch.yml 配置Elasticsearch

# cat /etc/elasticsearch/elasticsearch.yml  |grep -v ^#

cluster.name: escluster  #集群名称

node.name: ${HOSTNAME}     #节点名称

path.data: /data/es-data/   #数据存储路径

path.logs: /var/log/elasticsearch   #日志文件路径

network.host: _eth0_    # 节点要绑定的地址 

http.port: 9200     # 接受http请求的端口

transport.tcp.port: 9300  # 集群节点之间通信的端口

transport.tcp.compress: true

discovery.zen.ping.unicast.hosts: ["127.0.0.1:9300"]  #要加入集群的节点，如果没指定端口默认为transport.tcp.port

discovery.zen.minimum_master_nodes: 1 #默认1,必须要合理设置。避免网络故障时脑裂将集群拆分成独立集群(master_eligible_nodes/2)+1.假如有3个节点符合则设置为2.

bootstrap.memory_lock: true  # 锁定进程的内存空间，防止es内存被交换出去。

xpack.security.enabled: false

xpack.monitoring.enabled: true

除此之外还有一些重要的配置。es调优的时候经常用到。

文件描述符

.zip .tar包安装的。

# ulimit -n 65536 或者

# vim /etc/security/limits.conf

elasticsearch  -  nofile  65536

rpm包的已经将文件描述符最大数量默认为65536无需更改。

　　可以通过 GET _nodes/stats/process?filter_path=**.max_file_descriptors 来检查。

禁用交换分区

# sudo swapoff -a
# /etc/sysctl.conf 添加vm.swappiness=1
# 在elasticsearch.yml配置 bootstrap.memory_lock: true 锁定进程地址空间，防止es内存被交换出去。

　　可以用curl -X GET "localhost:9200/_nodes?filter_path=**.mlockall" 来查看。如果"mlockall": false说明请求失败。日志里面还会有警告信息：memory locking requested for elasticsearch process but memory is not locked。可能是因为运行es的用户没有锁定内存的权限。

　　　解决方法：

如果es是用tar或者zip包安装的

#ulimit -l unlimited，或者

# /etc/security/limits.conf添加

 elasticsearch - nofile 65536

rpm包安装的

在/usr/lib/systemd/system/elasticsearch.service文件中，或者添加一个/etc/systemd/system/elasticsearch.service.d/override.conf文件

[Service]

LimitMEMLOCK=infinity

# sudo systemctl daemon-reload

虚拟内存

# sysctl -w vm.max_map_count = 262144

或者是

# vim /etc/sysctl.conf

   vm.max_map_count=262144

# sysctl vm.max_map_count

# rpm包已经自动配置，无需配置。

jvm.options 配置es的jvm

-Xms256m

-Xmx256m

3，架构

filebeat--> kafka --> logstash --> elasticsearch --> kibana

filebeat收集日志传给kafka-->logstash input作为消费者消费kafka的数据 -->logstash output将input的内容传给es --> kibana上添加新索引

4，Restful API

Elasticsearch支持使用RESTful API，可以使用RESTful API来进行增加文档，删除文档等操作，也可以用于查询。

可以直接使用 kibana的 DevTools来发送restful请求，进行增删改查操作。

es 查询语句

URI Search

参数有q, analyzer,_source,sort,from,size等

GET my_index/doc/_search?q=quick

GET my_index*/_search?q=title:quick

GET _search?q=user:ketty

GET _all/_search?q=user:ketty

Request body search

query

GET test_index/_search

{

  "query": {

    "term": {

      "age": {

        "value": "22"

      }}}}

from/size

GET test_index/_search

{

  "from": 0,    #第一个结果的偏移量，第0页  from默认为0

  "size": 1,     # 最大命中个数 ， 1条数据   size 默认为10

  "query": {

    "term": {

      "name": {

        "value": "ketty"

      }}}}

sort

GET test_index/_search

{

  "query": {         #先过滤出含有ketty的name字段

    "term": {

      "name": {

        "value": "ketty"

      }

    }

  },

  "sort": [        #后对这些字段排序

    {

      "age": {

        "order": "desc"         #desc 倒序 asc 顺序

      }}}}

source filtering

默认会返回_source 所有字段的内容。

# "_source": false   关闭

# "_source": "fieldname"

# "_source": "obj.*"  可接受通配符

GET test_index/_search

{

  "_source": {

    "excludes": "content",

    "includes": "name"

  },

  "query": {

    "term": {

      "content": {

        "value": "hello"

      }}}}

query DSL

query and filter context

查询上下文：文档匹不匹配这个查询，相关度高吗。是在query进行查询是的执行环境

过滤器上下文：文档匹不匹配。不考虑相关性算分，和返回的排序问题。使用filter参数时

GET /_search

{

  "query": {           #查询上下文

    "bool": {

      "must": [      #两个match在查询上下文中

        { "match": { "title":   "Search"        }},

        { "match": { "content": "Elasticsearch" }}

      ],

      "filter": [       # 过滤器上下文

        { "term":  { "status": "published" }},

        { "range": { "publish_date": { "gte": "2015-01-01" }}}

      ]   # term，range在过滤器上下文中，会过滤掉不匹配的，但不会影响算分

    }

  }

}

match_all query

GET test_index/_search

{

  "query": {

    "match_all": {}

  }

}

full-context queries
- match query

GET test_index/_search

{

  "query": {

    "match": {

      "content": {

        "query": "hello ketty",

        "operator": "and"     # 默认是or） 匹配出content字段中同时含有hello和ketty单词的文档

      }}}}

#模糊查询 fuzziness

GET test_index/_search

{

  "query": {

    "match": {

      "content": {

        "query": "test tontent",

        "fuzziness": 1      # "fuzziness":"auto" 自动根据字段值长度编辑距离

      }}}}

match_phrase　匹配短语

GET test_index/_search

{

  "query": {

    "match_phrase": {

      "content": {

        "query": "test content"   # 如果使用match，会匹配带有test，content，test content的文档

      }}}}

  # "slop":"2"  "content test" 这个顺序 也可以匹配
  # "analyzer": "my_analyzer" 可以指定分词器

- match_phrase_prefix 匹配短语前缀
1. ```
PUT test_index/doc/6

　{  "name":"fox",

     "message":"quick brown fox." }

GET test_index/doc/_search

{

  "query": {

    "match_phrase_prefix": {

      "message": {

        "query": "quick brown f",

        "max_expansions": ""  # max_expansions 控制将要扩展的后缀数量

      }

    }}}
```
- multi_match 　多字段　　　　
1. ```
GET test_index/_search

{

  "query": {

    "multi_match": {

      "query": "hello",

      "fields": ["message","conte*"]    #可以使用通配符

    }

  }

}
```
- query_string
- #### deafult_field 指定字段，如果不指定默认字段会查询索引中的所有字段
  
  GET test_index/_search
  
  {
  
  "profile":true, #查看执行过程
  "query": {
  "query_string": {
  "default_field": "message",
  "query": "fox AND (white OR brown)" #匹配到 "slow white fox" 和 "quick brown fox"
  }}}
```
### fields 多字段查询 
GET test_index/_search

{

  "query": {

    "query_string": {

      "fields": ["message","content"],

      "query": "brown AND fox"

    }}}
等同于 -->
```
  {
  "query": {
  "query_string": {
  "query": "(message:brown OR content:brown) AND (message:fox OR content:fox)"
  }}}
  
  #返回结果
```
  "_source": {"message": "quick brown fox."  }}]
```
```
也可以在字段名中使用通配符，例如：
```
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "fields": ["messa*"], #使用通配符匹配字段名
  "query": "brown AND fox"
  }}}} 等同于----》
  
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "query": "messag\\*:(brown AND fox)" #将字段名写在query string里面。转义*
  }}}
  
  # 由于\是json字符串中的特殊字符，因此需要用\进行转义，因此上面的两个反斜杠。
  
  # 返回结果：
```
  "_source": {"message": "quick brown fox."  }}]

# query string syntax
```
  字段名 例如：
  status:active
  title:(quick OR brown)等同于 title:(quick brown) titile字段中含有quick或者brown
  author:"John Smith" author字段中包含John Smith短语的
  book.\*:(quick brown) 字段名为book.title，book.cotent之类的字段名包含quick或者brown
  _exists_:title title字段中有非null值
  
  通配符 ? *
  qu?ck bro* 能匹配quick或者bro*
  
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "query": "name:ket*" #匹配到ketty kety
  }}}
  
  正则表达式 可以通过包装在/中嵌入query string中
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "query": "name:/k.*y/" #可以匹配name中包含ketty,kety等文档
  }}}
  模糊查询 ~1 ~2 默认编辑距离为2
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "query": "mess\\*:(quikc~1)" #可以匹配quick
  }}}
  
  接近查询 指定短语中最大编辑距离 "fox quick"~5 可以匹配"quick brown fox"
  
  范围查询 [] 包含范围 {} 排他范围 [} {]
  
  date:[2018-01-01 TO 2018-07-03]
  count: [10 TO *] 大于等于10
  age:[1 TO 5} 大于等于1 小于5
  age: >10
  age: <=5
  GET test_index/_search
  {
  "query": {
  "query_string": {
  "query": "age:[18 TO 24}" #大于等于18 小于24
  }}}
  
  　Boosting ^ 使一个术语比另一个术语更相关默认值是1 quick^2 fox
  
  布尔运算符
  + 必须存在
  - 必须不存在
  && AND
  || OR
  ! NOT
  
  GET test_index/_search
  
  {
  "query": {
  "query_string": {
  "query": "name:(!ketty)"
  }}}
  
  分组 (quick OR brown) AND fox
  
  保留字符 某些特殊字符需要用反斜杠转义： + - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /
  
  <> 无法转义
  
  例如：要查询(1+1)=2 写成 \(1\+1\)\=2

lucene query syntax

lucene查询语法

*文本搜索 safari 表示搜索所有字段的safari

特定字段中搜索值 status:200

搜索多个值 status:[400 TO 499]

布尔 AND,OR,NOT。要查找4XX状态码并且扩展名php或html status:[400 TO 499] AND (extension:php OR extension:html)

Lucene 支持转义特殊字符 + - && || ! ( ) { } [ ] ^ " ~ * ? : \

这些需要在字符前使用\转义。 例如搜索(1+1):2 需要写成\(1\+1\)\:2

terms

     单个term： 搜索单个单词例如"test"或者"hello"

     短语查询：用双引号括起来一组单词 "hello world"

      多个术语可以和布尔运算符组合起来

fields   可以指定字段 也可以使用默认字段

      字段名:术语   例如 title:Do it right  在title中搜索Do,在默认字段中搜索it和right

通配符

    支持？和*通配符 (不能用在短语查询中)

    ? 单个字符    te?t  匹配 test text等

    * 多字符     test*  匹配 test，tests，tester等

      注意：不能用?或*作为搜索的第一个字符

模糊匹配 roam~1

range范围查询  []包含首尾  {}不包含首尾

    mod_date:[20170101 TO 20180606] 字段值在>=20170101 <=20180606的文档

    title:{Aida TO Carmen}  文件标题介于Aida Carmen之间但不包含Aida，Carmen

布尔运算符 AND OR NOT 必须大写否则查不出来哦

  AND &&可替代AND

  OR || 可以替代OR 要搜索包含 apache或者nginx的文档，可用查询 apache nginx 或者是 apache OR nginx

  + 必须包含该字段值 例如 +jakarta lucene 表示必须包含jakarta可能包含lucene的文档

  NOT - 可代替NOT 必须不包含

分组  用括号将子句分组为子查询。

     (jakarta OR apache) AND website  有website 可能有jakarta或apache

Field 分组  使用括号将多个字句分组到单个字段

     title:(+return +"pink panther")  搜索title字段包含单词return和短语"pink panther"的

转义  特殊字符需要转义

    + - && || ! ( ) { } [ ] ^ " ~ * ? : \

     搜索(1+1):2  应该使用 \(1\+1\)\:2

kuery

加引号是短语搜索。 message:"Quick brown fox"  将搜索短语 ，不加引号将字段先分词再查询，可以匹配到brown quick fox

多个搜索项必须由布尔运算符分割。布尔运算符不区分大小写  and or not

      response:200 extension:php 将写成  response:200 and extension:php

 默认情况下 and优先级高于or 可以用括号( )分组覆盖优先级

单个字段搜索多个值 response:(200 or 400)

范围。 变为：bytes>1000。在 lucene里面是 bytes:>100

      >,>=,<,<=

存在的查询。response:* 表示存在字段

通配符。machine: win*  通配符   可以匹配win7 win10等

                   machine.os*: win*   。使用的是es里面的复合查询

          在kibana搜索条里面使用kuery   source : /ubox/logs/test*

          使用lucene    source : \/ubox\/logs\/test*

simple_query_string

　　　　　　与常规的query_string不同，simple_query_string永远不会抛异常，并丢弃查询的无效部分

simple_query_string支持的特殊字符有：+ | - " * (AND) ~N在单词后 ~N在短语后搜索这些特殊字符需转义

GET test_index/_search

{

  "query": {

    "simple_query_string": {

      "query": "(test content) | fox + white",  # 匹配到一条 "message": "slow white fox."

      "fields": ["content","mess*"],

      "default_operator": "AND"

    }}}

# +AND  |OR  -否定  *在末尾表示前缀查询

Term level queries

term

#区别于match。 term不会对查询语句做分词，而是将查询语句作为整个单词

GET test_index/_search

{

  "query": {

    "term": {

      "message": {

        "value": "test message" #无法匹配到"this is a test message"

      }}}}

GET test_index/_search

{

  "query": {

    "match": {

      "message": "test alkdfj"  #可以匹配"this is a test message"

    }}}

terms 查询多个单词

GET test_index/_search

{

  "query": {

    "terms": {

      "message": [

        "test",

        "message"

      ]}}}

range 范围查询　

GET test_index/_search

{

  "query": {

    "range": {

      "age": {

        "gte": 10,      # gte 大于等于 ，gt 大于

        "lte": 20        # lte 小于等于， lt 小于

      }}}}

#按时间的range

GET /_search

{

  "query": {

    "range": {

      "@timestamp": {

        "gte": "now-1h/d",  # -1h：减去1小时， /d：向下舍入到UTC 00:00

        "lte": "now"

      }}}}

exists　字段存在

GET test_index/_search

{

  "query": {

    "exists":{

      "field":"name"

    }}}

prefix 前缀查询

GET test_index/_search

{

  "query": {

    "prefix": {

      "name": {

        "value": "ket"

      }}}}

wildcard 通配符查询

GET test_index/_search

{

  "query": {

    "wildcard": {

      "name": {

        "value": "ke*y"

      }}}}

regexp 正则表达式查询

GET test_index/_search

{

  "query": {

    "regexp":{

      "name":"k.*y"

    }}}

fuzzy 模糊查询

GET test_index/_search

{

  "query": {

    "fuzzy": {

      "name":{

        "value": "ket",

        "fuzziness": 2       #fuzziness 最大编辑距离

      }}}}

type

GET _search

{

  "query": {

    "type":{

      "value":"my_type"

    }}}

ids

GET _search

{

  "query": {

    "ids": {

      "type": "my_type",

      "values": ["",""]

    }}}

compoud queries 复合查询

constant_score

GET _search

{

  "query": {

    "constant_score": {

      "filter": {      # filter语句在过滤器上下文中 得分被忽略

        "term": {

          "name": "ketty"

        }

      },

      "boost": 1.2  #设定boost的值

    }}}

bool

　　　　　　bool查询由一个或多个子句构建，每个子句都有一个类型. 类型有：must，must not，should，filter

GET nginx-access-log-2018.06.03/_search

{

  "query": {

    "bool": {

      "must": [

        {"match":{

          "source":"/ubox/logs/budd/access.log"

        }},

        {"range":{

          "@timestamp":{

            "gte":"2018-06-03T00:00:00.000",

            "lte":"2018-06-03T02:00:00.000"

          }

        }},

        {"regexp":{

          "url_path":"/sync/vmSkin.*"

        }}

        ]

     }}}

joining queries

nested 嵌套类型的查询

PUT test_index

{

  "mappings": {

    "doc": {

      "properties": {

        "man":{            #设置man字段为嵌套类型

          "type": "nested",

          "properties": {

            "age":{

              "type":"integer"

             },

            "name":{

              "type":"text"

            }}}}}}}}

PUT test_index/doc/1

{

  "man":[

    {

      "name":"alice white",

      "age":34

    },

    {

      "name":"peter brown",

      "age":26

    }

    ]

}

GET test_index/_search    #查询语句

{

  "query": {

    "nested": {          #关键字

      "path": "man",    #嵌套字段

      "query": {

        "match": {

          "man.name": "peter"    #子字段

        }

      }

    }

  }

}

has_child
has_parent

码农公寓

es 查询语句

相关文章