安装、运行ES

1. 通过官网下载：https://www.elastic.co/downloads/elasticsearch
2. 启动ESbin/elasticsearch
3. 运行curl http://localhost:9200/
4. 运行多实例

bin/elasticsearch -E node.name=node1 -E cluster.name=geektime -E path.data=node1_data -d
bin/elasticsearch -E node.name=node2 -E cluster.name=geektime -E path.data=node2_data -d
bin/elasticsearch -E node.name=node3 -E cluster.name=geektime -E path.data=node3_data -d
#删除进程
ps | grep elasticsearch
kill pid

ES目录讲解

├── bin      脚本文件
├── config   集群配置文件
├── data     数据文件
├── jdk.app  Java运行环境
├── lib      Java类库
├── logs     日志文件
├── modules  包含ES所有模块
└── plugins  包含所有已安装插件

安装与查看elasticsearch插件

#查看插件列表
bin/elasticsearch-plugin list
#运行
bin/elasticsearch-plugin install analysic-icu

安装Kibana

1. 通过官网下载：https://www.elastic.co/downloads/kibana
2. 编辑config/kibana.yml，设置elaticsearch.url指向Elasticsearch实例
3. 启动bin/kibanan
4. 访问http://localhost:5601/
5. 根据引导安装Sample data，然后就可以进入Dev Tools进行操作elasticsearch的API操作了。以下是关于Kibana的一些快捷操作：

cmd + / (查看API帮助文件)
cmd + option + l （展开代码）
cmd + option + 0 （收缩代码）
cmd + option + shift + 0

安装与查看Kibana插件

#查看kibana插件
bin/kibana-plugin list
#安装kibana插件
bin/kibana-plugin install plugin_location
#删除kibana插件
bin/kibana remove plugin_name
#一些已知的插件列表
https://www.elastic.co/guide/cn/kibana/current/known-plugins.html

通过Docker运行ELK

1. 安装 Docker https://www.docker.com/products/docker-desktop
2. 安装 docker-compose https://docs.docker.com/compose/install/
   docker-compose的相关命令

#运行
docker-compose up
#停止容器
docker-compose down
#停止容器并且移除数据
docker-compose down -v
#一些docker 命令
docker ps
docker stop Name/ContainerId
docker start Name/ContainerId

#删除单个容器
$docker rm Name/ID
-f, –force=false; -l, –link=false Remove the specified link and not the underlying container; -v, –volumes=false Remove the volumes associated to the container

#删除所有容器
$docker rm `docker ps -a -q`  
停止、启动、杀死、重启一个容器
$docker stop Name/ID  
$docker start Name/ID  
$docker kill Name/ID  
$docker restart name/ID

docker-compose.yml示例，同时运行cerebro 、kibana、elasticsearch

version: '2.2'
services:
  cerebro:
    image: lmenezes/cerebro:0.8.3
    container_name: cerebro
    ports:
      - "9000:9000"
    command:
      - -Dhosts.0.host=http://elasticsearch:9200
    networks:
      - es72net
  kibana:
    image: docker.elastic.co/kibana/kibana:7.2.0
    container_name: kibana72
    environment:
      #- I18N_LOCALE=zh-CN
      - XPACK_GRAPH_ENABLED=true
      - TIMELION_ENABLED=true
      - XPACK_MONITORING_COLLECTION_ENABLED="true"
    ports:
      - "5601:5601"
    networks:
      - es72net
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.2.0
    container_name: es72_01
    environment:
      - cluster.name=geektime
      - node.name=es72_01
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
      - discovery.seed_hosts=es72_01,es72_02
      - network.publish_host=elasticsearch
      - cluster.initial_master_nodes=es72_01,es72_02
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es72data1:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
    networks:
      - es72net
  elasticsearch2:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.2.0
    container_name: es72_02
    environment:
      - cluster.name=geektime
      - node.name=es72_02
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
      - discovery.seed_hosts=es72_01,es72_02
      - network.publish_host=elasticsearch
      - cluster.initial_master_nodes=es72_01,es72_02
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es72data2:/usr/share/elasticsearch/data
    networks:
      - es72net


volumes:
  es72data1:
    driver: local
  es72data2:
    driver: local

networks:
  es72net:
    driver: bridge

cerebro是一款ElasticSearch监控工具，可以更加直观，界面如下：

image.png

在docker-compose.yml目录下运行docker-compose up即可拉起容器

#访问kibana
http://localhost:5601/
#访问cerebro
http://localhost:9000/

实战经验

1. 启动docker后，访问cerebro http://elasticsearch:9200 报错Unexpected response status: [503]，

# 诊断查看集群的正常状态，是否为 Green
http://localhost:9200/_cat/health?v

2. elasticsearch显示:{"type":"master_not_discovered_exception","reason":null}，把network.publish_host再作

- discovery.seed_hosts=es72_01
#把network.publish_host去掉
- network.publish_host=elasticsearch
- cluster.initial_master_nodes=es72_01

3. 打开Kibana显示Kibana server is not ready yet，kibana驱动也需要一些时间，在这期间访问kibana就有可能看到seever is not ready的信息

安装logstash

1. 下载并解压：https://www.elastic.co/cn/downloads/logstash
2. 准备logstash.conf配置文件
3. 运行bin/logstash f logstash.conf
4. 练习数据准备下载最 MovieLens 最小测试数据集：https://grouplens.org/datasets/movielens/

logstash.conf示例

#下载与ES相同版本号的logstash（7.1.0），并解压到相应目录
#修改movielens目录下的logstash.conf文件
#path修改为,你实际的movies.csv路径
input {
  file {
    path => "YOUR_FULL_PATH_OF_movies.csv"
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}

filter {
  csv {
    separator => ","
    columns => ["id","content","genre"]
  }

  mutate {
    split => { "genre" => "|" }
    remove_field => ["path", "host","@timestamp","message"]
  }

  mutate {

    split => ["content", "("]
    add_field => { "title" => "%{[content][0]}"}
    add_field => { "year" => "%{[content][1]}"}
  }

  mutate {
    convert => {
      "year" => "integer"
    }
    strip => ["title"]
    remove_field => ["path", "host","@timestamp","message","content"]
  }

}
output {
   elasticsearch {
     hosts => "http://localhost:9200"
     index => "movies"
     document_id => "%{id}"
   }
  stdout {}
}

启动 logstash

#启动Elasticsearch实例，然后启动 logstash，并制定配置文件导入数据
bin/logstash -f /YOUR_PATH_of_logstash.conf

ES入门-基本概念

文档

索引和文档更偏向开发人员视角，更偏向逻辑概念
节点和分片更偏向运维人员视角，更偏向物件概念。

1. ES是面向文档的，文档是可搜索的最小单元，类似于关系型数据库中的一条纪录
2. 文档被会序列化为JSON格式保存在ES中，JSON对象由字段组成，每个字段都有对应的类型（字符串/布尔/数值/日期等），ES会根据字段的类型自动推算，支持数组，也支持嵌套。
3. 每个文档都有一个UniqueID，可自指定也可自动生成。

文档的元数据

元数据就是用来标注文档相关信息的，常用字段如下：

#_all 已废除，整合所有字段
#_version 版本信息
{
       #_index 文档所属索引名
        "_index" : "kibana_sample_data_ecommerce",
       #_type 文档所属类型名，ES7 后一个文档只能创建一个_Type
        "_type" : "_doc",
       #_id 文档唯一ID
        "_id" : "uRX-xnABf4mTj_4ZsM3e",
       #_score 相关性打分 
        "_score" : 1.0,
        #_source 文档的原始JSON
        "_source" : {
          "category" : [
            "Men's Clothing"
          ],
        }
},

索引

Index-索引是文档的容器，是一类文档的结合

• index 体现了逻辑空间的概念：每个索引都有自己的Mapping定义，其包含字段名和类型
• Shard 体现了物理空间的概念：索引中的数据都分散在Shard上
• Mapping 定义文档字段的类型
• Setting 定义不同数据分布
  索引管理：在Kibana->管理->索引管理中， 可查看到索引的状态、分片、存储大小等基础信息，以及可以进行设置Mapping、Setting等操作。

“索引”有时候不太容易理解，它即能任作动词，又能作名词。比如：
索引（动词）文档到ES的索引（名词）中，如下图

理解“索引”的语意.png

REST API

为方便各个语言的整合，ES设计了一套REST API

RestAPI.png

例如：Index 相关 API

#查看索引相关信息
GET kibana_sample_data_ecommerce

#查看索引的文档总数
GET kibana_sample_data_ecommerce/_count

#查看前10条文档，了解文档格式
POST kibana_sample_data_ecommerce/_search
{ }

#_cat indices API
#查看indices
GET /_cat/indices/kibana*?v&s=index

#查看状态为绿的索引
GET /_cat/indices?v&health=green

#按照文档个数排序
GET /_cat/indices?v&s=docs.count:desc

#查看具体的字段
GET /_cat/indices/kibana*?pri&v&h=health,index,pri,rep,docs.count,mt

#How much memory is used per index?
GET /_cat/indices?v&h=i,tm&s=tm:desc

ES与关系型数据库的类比

为帮助理解，我们可以拿ES跟关系型数据库进行类比。

Elasticsearch的分布式架构

ES中一个分布式系统，所以高可用、可扩展。它能帮ES实现存储的水平扩容，并提高了可用性。
在ES中，不同的集群通过不同的名字来区分，默认名为elasticsearch，可通过配置文件修改，或在命令中-E cluster.name=xxx进行设定，一个集群可以有1个或多个节点。

节点

节点是ES的一个实例，本质是一个JAVA进程。一台机可运行多个ES进程，但生产环境建议一台机运行一个。
每个节点都有自己的名字，通过配置文件修改，或在命令中-E node.name=xxx进行设定
每个节点启动后，都有自己的UID，保存在data目录。

Master-eligible nodes和Master node

每个节点启动后，就是一个Master-eligible节点，可以通过配置文件禁止，设置node.master:false即可。Master-eligible 节点可以参加选主流程，成为Master。
当第一个节点启动时，它会将自己选举为主Master。
每个节点上都保存了集群信息，但只有Master节点能修改集群的状态，如果任意节点都能修改的话会导致数据的不一致性。

• 集群状态（Cluster State）维护了一个集群中，必要的信息
  • 所有节点信息
  • 所有索引和其相关的Mapping和Setting
  • 分片的路由信息

Data Node & Coordinating Node

• Data Node ，即可以保存数据的节点，负责保存分片数据，在数据扩展上起到关键作用。
• Coordinating Node ，负责接受Client的请求并分发到合适的节点，最终把结果汇集到一起。每个节点默认都起到Coordinating Node职责。

其它节点类型

• Hot & Warm Node：不同硬件配置的节点
• Machine Learning Node：负责跑机器学习的Job
• Tribe Node：将被淘汰，5.3开始用Cross Cluster Search

配置节点类型

• 开发环境中一个节点可承担多种角色
• 生产环境中应设置单一的角色节点

分片

主分片

用以解决数据水平扩展的问题，通过主分片，可以把将数据分布到集群内所有的节点上，一个分版即是一个Lucene实例，主分片是在索引创建时指定，后续不允许修改，除非Reindex

副本

用以解决数据高可用的问题，是主分片的copy
副本的分片数可以动态调整，增加副本数可以提高服务的可用性（读取的吞吐）

分片的设定

对于生产环境的分片设定，需要提前做好容量规划，设置过小导致后续无法增加节点实现水平扩展，设置过大影响相关性打分和资源浪费。7.0开始默认主分片为1

集群API Demo

通过API查看集群信息

GET _cluster/health
{
  #集群名称
  "cluster_name" : "geektime",
  #集群状态
  "status" : "green",
  "timed_out" : false,
  #节点数
  "number_of_nodes" : 2,
  #数据节点数
  "number_of_data_nodes" : 2,
  #主分片数
  "active_primary_shards" : 6,
  "active_shards" : 12,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 0,
  "delayed_unassigned_shards" : 0,
  "number_of_pending_tasks" : 0,
  "number_of_in_flight_fetch" : 0,
  "task_max_waiting_in_queue_millis" : 0,
  "active_shards_percent_as_number" : 100.0
}
get _cat/nodes?v
GET /_nodes/es7_01,es7_02
GET /_cat/nodes?v
GET /_cat/nodes?v&h=id,ip,port,v,m


GET _cluster/health
GET _cluster/health?level=shards
GET /_cluster/health/kibana_sample_data_ecommerce,kibana_sample_data_flights
GET /_cluster/health/kibana_sample_data_flights?level=shards

#### cluster state
The cluster state API allows access to metadata representing the state of the whole cluster. This includes information such as
GET /_cluster/state

#cluster get settings
GET /_cluster/settings
GET /_cluster/settings?include_defaults=true

GET _cat/shards
GET _cat/shards?h=index,shard,prirep,state,unassigned.reason

通过Cerebro工具可以非常清晰地查看到ES集群的状态

Cerebro工具

文档的CURD

Create 一个文档

支持自动生成ID和指定ID两种方式
POST my_index/_doc，不指定ID，自动生成
PUT my_index/_create/id，若ID已存在则会失败
PUT myindex/_doc/1?op_type=create

############Create Document############
#create document. 自动生成 _id
POST users/_doc
{
    "user" : "Mike",
    "post_date" : "2019-04-15T14:12:12",
    "message" : "trying out Kibana"
}

#create document. 指定Id为1。如果id已经存在，报错
PUT users/_doc/1?op_type=create
{
    "user" : "Jack",
    "post_date" : "2019-05-15T14:12:12",
    "message" : "trying out Elasticsearch"
}

#返回结果
{
  "_index" : "users",
  "_type" : "_doc",
  "_id" : "WoI30XABzd6sVkG_V0ZG",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "failed" : 0
  },
  "_seq_no" : 1,
  "_primary_term" : 1
}
#PUT方式， 如果ID已存在，返回结果
{
  "error": {
    "root_cause": [
      {
        "type": "version_conflict_engine_exception",
        "reason": "[1]: version conflict, document already exists (current version [1])",
        "index_uuid": "zjmA5Jo0TIaafbUhJJEEiA",
        "shard": "0",
        "index": "users"
      }
    ],
    "type": "version_conflict_engine_exception",
    "reason": "[1]: version conflict, document already exists (current version [1])",
    "index_uuid": "zjmA5Jo0TIaafbUhJJEEiA",
    "shard": "0",
    "index": "users"
  },
  "status": 409
}

GET一个文档

GET _index/_type/1

# Get Document by ID
GET users/_doc/1

#返回命中结果，_source包含了文档所有原始内容
{
  "_index" : "users",
  "_type" : "_doc",
  "_id" : "WoI30XABzd6sVkG_V0ZG",
  "_version" : 1,
  "_seq_no" : 1,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "user" : "Mike",
    "post_date" : "2019-04-15T14:12:12",
    "message" : "trying out Kibana"
  }
}
#返回未命结果，找不到文档，返回HTTP404
{
  "_index" : "users",
  "_type" : "_doc",
  "_id" : "1",
  "found" : false
}

index 文档

index和create不同的地方，若文档不存在，就索引新文档。否则现有文档会被删除，新的文档被索引，版本信息+1

###  Index
#Index 指定 ID  (先删除，在写入)
GET users/_doc/WoI30XABzd6sVkG_V0ZG

PUT users/_doc/WoI30XABzd6sVkG_V0ZG
{
    "user" : "Mike"

}

Update文档

Update不会删除原文档，而是实现真实数据的更新，Update用的是post请求方式，请求体中需包含doc

#GET users/_doc/1
#在原文档上增加post_date、message字段
POST users/_update/1/
{
    "doc":{
        "post_date" : "2019-05-15T14:12:12",
        "message" : "trying out Elasticsearch"
    }
}

Delete文档

### Delete by Id
# 删除文档
DELETE users/_doc/1

### 清除测试数据
DELETE users
DELETE test

Bulk API

在ES中请求时，重新建立网络开销是非常损耗性能的，Bulk API的目的就是在一次API请求中对不同索引做多次操作。支持四种类型操作

• Index
• Create
• Update
• Delete
  备注：可以URI中指定Index，也可在请求体中进行
  操作单条失败，不影响其它操作
  返回结果，包括每一条操作执行结果。

### Bulk 操作
#执行两次，查看每次的结果

#执行第1次
POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test2", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

#执行第2次
POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test2", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

批量读取mget

#URI中指定index
GET /test/_mget
{
    "docs" : [
        {

            "_id" : "1"
        },
        {

            "_id" : "2"
        }
    ]
}
#返回结果
GET /_mget
{
    "docs" : [
        {
            "_index" : "test",
            "_id" : "1",
            "_source" : false
        },
        {
            "_index" : "test",
            "_id" : "2",
            "_source" : ["field3", "field4"]
        },
        {
            "_index" : "test",
            "_id" : "3",
            "_source" : {
                "include": ["user"],
                "exclude": ["user.location"]
            }
        }
    ]
}

批量查询 - msearch

### msearch 操作，包含了2个查询
POST kibana_sample_data_ecommerce/_msearch
{}
{"query" : {"match_all" : {}},"size":1}
{"index" : "kibana_sample_data_flights"}
{"query" : {"match_all" : {}},"size":2}

常见错误返回

Search API

• URI Search , 在URI中使用参数
  • 使用q指定查询字符串
  • query string syntax，KV键值对

#URI Query
#搜寻叫Eddie的客户
GET kibana_sample_data_ecommerce/_search?q=customer_first_name:Eddie
GET kibana*/_search?q=customer_first_name:Eddie
GET /_all/_search?q=customer_first_name:Eddie

• Request body Search，使用ES中基于JSON的更加完备的DSL（Query Domain Speific Language）
  • 支持POST和GET方式，POST 索引名/执行搜寻的操作

#REQUEST Body
POST kibana_sample_data_ecommerce/_search
{
    "profile": true,
    "query": {
        "match_all": {}
    }
}

# 搜寻返回的结果
`took`是返回的时间 
`total`是符合条件文档的总数
`hits`是结果集，默认前10个文档
`_index`是索引名
`_id`是文档ID
`_score`是相关度评分
`_source`是文档原始信息

{
  "took" : 67,
  "responses" : [
    {
      "took" : 57,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 4675,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
            "_index" : "kibana_sample_data_ecommerce",
            "_type" : "_doc",
            "_id" : "uRX-xnABf4mTj_4ZsM3e",
            "_score" : 1.0,
            "_source" : {
              "category" : [
                "Men's Clothing"
              ],
              "currency" : "EUR",
                "city_name" : "Cairo"
              }
            }
          }
        ]
      },
      "status" : 200
    }
  ]
}

指定查询的索引

URI Search

• 使用q指定查询字符串
• df是默认字段，不指定时会对所有字段进行查询
• Sort排序 / from 和 size 用于分页
• Profile 可查看查询是如何被执行的

Demo

#基本查询
GET /movies/_search?q=2012&df=title&sort=year:desc&from=0&size=10&timeout=1s

#带profile
GET /movies/_search?q=2012&df=title
{
    "profile":"true"
}

# 返回结果类型
"query" : [{
    "type" : "TermQuery",
    "description" : "title:2012",
}]

泛查询

#泛查询，正对_all,所有字段
GET /movies/_search?q=2012
{
    "profile":"true"
}

#返回结果类型
"query" : [{
     "type" : "DisjunctionMaxQuery",
     "description" : "(title.keyword:2012 | id.keyword:2012 | year:[2012 TO 2012] | genre:2012 | @version:2012 | @version.keyword:2012 | id:2012 | genre.keyword:2012 | title:2012)"
}]

指定字段查询

#指定字段 ， 效果跟df查询方式一样
GET /movies/_search?q=title:2012&sort=year:desc&from=0&size=10&timeout=1s
{
    "profile":"true"
}

Term vs Phrase（或&且）

#分组，Bool查询，或关系， 等效于Beautiful OR Mind
GET /movies/_search?q=title:(Beautiful Mind)
{
    "profile":"true"
}
#返回结果类型
"query" : [{
    "type" : "PhraseQuery",
    "description" : """title:"beautiful mind"""",
}]

#使用引号，Phrase查询，且关系 。 等效于Beautiful AND Mind
GET /movies/_search?q=title:"Beautiful Mind"
{
    "profile":"true"
}
#返回结果类型
"query" : [{
    "type" : "BooleanQuery",
    "description" : "title:beautiful title:mind",
}]

布尔操作

语法：AND / OR / NOT / && / || / ! ，必需大写，例title:(matrix NOT reloaded)
分组： + 表示 must，- 表示 must_not ， 例title:(+matrix -reloaded)

#布尔操作符
# 查找美丽心灵
GET /movies/_search?q=title:(Beautiful AND Mind)
{
    "profile":"true"
}
#返回结果类型
"query" : [{
    "type" : "BooleanQuery",
    "description" : "+title:beautiful +title:mind"
}]

# 查找美丽心灵
GET /movies/_search?q=title:(Beautiful NOT Mind)
{
    "profile":"true"
}
#返回结果类型
"query" : [{
    "type" : "BooleanQuery",
    "description" : "title:beautiful -title:mind"
}]

# 查找美丽心灵
GET /movies/_search?q=title:(Beautiful %2BMind)
{
    "profile":"true"
}
#返回结果类型
"query" : [{
    "type" : "BooleanQuery",
    "description" : "title:beautiful +title:mind"
}]

范围查询

• [ ]闭区间，例 year:[* TO 2018]
• { } 开区间，例 year:{2019 TO 2018}
• 算术符号 year:>2018 、 year:(>2010 && <=2018)、year:(+>2010 _<=2018)

#范围查询 ,区间写法
GET /movies/_search?q=title:beautiful AND year:[2002 TO 2018]
{
    "profile":"true"
}

通配符查询

查询效率低、占用内存大、不建议使用
?代表一个字符，例title:mi?d，*代表0或多个字符，例title:be*
正则表达，例title:[bt]oy

//通配符查询
GET /movies/_search?q=title:b*
{
    "profile":"true"
}

模糊匹配&近似度匹配

//模糊匹配&近似度匹配
GET /movies/_search?q=title:beautifl~1
{
    "profile":"true"
}

GET /movies/_search?q=title:"Lord Rings"~2
{
    "profile":"true"
}

Request Body Search

一般高阶的查询，都建议通过 Request Body Search 的DSL语法进行操作

• 可from和size进行分页
• 可通过sort对结果进行排序
• 可通过对_source对结果进行过滤，则可仅返回指定的字段内容。例 "_source":["order_date"]

#可`from`和`size`进行分页
POST /kibana_sample_data_ecommerce/_search
{
  "from":10,
  "size":20,
  "query":{
    "match_all": {}
  }
}

#对日期排序 , 可通过`sort`对结果进行排序
POST kibana_sample_data_ecommerce/_search
{
  "sort":[{"order_date":"desc"}],
  "query":{
    "match_all": {}
  }
}

#source filtering
POST kibana_sample_data_ecommerce/_search
{
  "_source":["order_date"],
  "query":{
    "match_all": {}
  }
}
#返回结果
"_source" : {
    "order_date" : "2020-03-23T09:28:48+00:00"
 }

脚本字段

例子中，可通过painless脚本算出新的结果，把order_date跟_hello做了拼接作为new_field返回。

#脚本字段
GET kibana_sample_data_ecommerce/_search
{
  "script_fields": {
    "new_field": {
      "script": {
        "lang": "painless",
        "source": "doc['order_date'].value+'hello'"
      }
    }
  },
  "query": {
    "match_all": {}
  }
}
#返回结果
"fields" : {
    "new_field" : [
         "2020-03-23T09:28:48.000Zhello"
]}

查询表达式

类似于Term vs Phrase（或&且）

# last OR christmas
POST movies/_search
{
  "query": {
    "match": {
      "title": "last christmas"
    }
  }
}

# last AND christmas
POST movies/_search
{
  "query": {
    "match": {
      "title": {
        "query": "last christmas",
        "operator": "and"
      }
    }
  }
}

短语搜寻

即搜寻的单词是按顺序出现，slop即中间可有多少个其它字符

POST movies/_search
{
  "query": {
    "match_phrase": {
      "title":{
        "query": "one love",
        "slop": 1
      }
    }
  }

Query String & Simple Query String

类似URI Query

#添加测试数据

PUT /users/_doc/1
{
  "name":"Ruan Yiming",
  "about":"java, golang, node, swift, elasticsearch"
}

PUT /users/_doc/2
{
  "name":"Li Yiming",
  "about":"Hadoop"
}

#查询
POST users/_search
{
  "query": {
    "query_string": {
      "default_field": "name",
      "query": "Ruan AND Yiming"
    }
  }
}


POST users/_search
{
  "query": {
    "query_string": {
      "fields":["name","about"],
      "query": "(Ruan AND Yiming) OR (Java AND Elasticsearch)"
    }
  }
}

Simple Query String会忽略错误 的语法，不支持AND OR NOT，会当作字符串处理。Term这间默认的关系是OR， 可以指定Operator；支持部分逻辑+代替 AND，| 替代 OR，- 替代NOT。

#Simple Query 默认的operator是 Or
POST users/_search
{
  "query": {
    "simple_query_string": {
      "query": "Ruan AND Yiming",
      "fields": ["name"]
    }
  }
}


POST users/_search
{
  "query": {
    "simple_query_string": {
      "query": "Ruan Yiming",
      "fields": ["name"],
      "default_operator": "AND"
    }
  }
}

还可以分组可查询多个字段

POST users/_search
{
  "query": {
    "query_string": {
      "default_field": "name",
      "query": "Ruan AND Yiming"
    }
  }
}


POST users/_search
{
  "query": {
    "query_string": {
      "fields":["name","about"],
      "query": "(Ruan AND Yiming) OR (Java AND Elasticsearch)"
    }
  }
}

Simple query String，示例中已经发现不支持AND了，一些复杂的查询已经不支持了。

#Simple Query 默认的operator是 Or
POST users/_search
{
  "query": {
    "simple_query_string": {
      "query": "Ruan AND Yiming",
      "fields": ["name"]
    }
  }
}


POST users/_search
{
  "query": {
    "simple_query_string": {
      "query": "Ruan Yiming",
      "fields": ["name"],
      "default_operator": "AND"
    }
  }
}

GET /movies/_search
{
    "profile": true,
    "query":{
        "query_string":{
            "default_field": "title",
            "query": "Beafiful AND Mind"
        }
    }
}

# 多fields
GET /movies/_search
{
    "profile": true,
    "query":{
        "query_string":{
            "fields":[
                "title",
                "year"
            ],
            "query": "2012"
        }
    }
}

GET /movies/_search
{
    "profile":true,
    "query":{
        "simple_query_string":{
            "query":"Beautiful +mind",
            "fields":["title"]
        }
    }
}

未完，待续. . .