ElasticStack（一）ElasticSearch入门

bin/elasticsearch -d 
bin/elasticsearch -Ehttp.port=8200 -Epath.data=node2 -d
bin/elasticsearch -Ehttp.port=7200 -Epath.data=node3 -d

# 创建ID为1的Document
PUT /test_index/doc/1
{
 "username":"alfred",
 "age":"24"
}
#
# 不指定ID创建Document(ID会自动生成)
POST /test_index/doc
{
 "username":"buzhiding",
 "age":"1"
}

# 查看名为test_index的索引中id为1的文档
GET /test_index/doc/1
#
# 查询所有文档：
# 查询名为test_index的索引中所有文档,用到endpoint：_search，默认返回符合的前10条
# term和match的区别：term完全匹配，不进行分词器分析；match模糊匹配，进行分词器分析，包含即返回
GET /test_index/doc/_search
{
 "query":{
  "term":{
   "_id":"1"
  }
 }
}

# 批量创建文档，用到endpoint：_bulk
# index和create的区别，如果文档存在时，使用create会报错，而index会覆盖
POST _bulk
{"index":{"_index":"test_index","_type":"doc","_id":"3"}}
{"username":"alfred","age":"20"}
{"delete":{"_index":"test_index","_type":"doc","_id":"1"}}
{"update":{"_id":"2","_index":"test_index","_type":"doc"}}
{"doc":{"age":"30"}}
#
# 批量查询文档，使用endpoint:_mget
GET _mget
{
 "doc":[
  {
   "_index":"test_index",
   "_type":"doc",
   "_id":"1"
  },
  {
   "_index":"test_index",
   "_type":"doc",
   "_id":"2"
  }
 ]
}

# 根据搜索内容删除文档,使用endpoint:_delete_by_query
POST /test_index/doc/_delete_by_query
{
 "query":{
  "match":{
   "username":"buzhiding"
  }
 }
}
# 
# 删除整个test_index的索引中的文档,依然使用endpoint:_delete_by_query
POST /test_index/doc/_delete_by_query
{
 "query":{
  "match_all":{}
 }
}

# 指定分词器进行分词测试
POST _analyze
{
 "analyzer":"standard",
 "text":"hello world!"
}
# 
# 直接指定索引中字段：使用username字段的分词方式对text进行分词。
POST test_index/_analyze
{
 "field":"username",
 "text":"hello world!"
}
# 
# 自定义分词器，自定义Tokenizer、filter、等进行分词：
POST _analyze
{
 "tokenizer":"standard",
 "filter":["lowercase"],
 "text":"Hello World!"
}

# 创建名为my_index的索引，并自定义mapping
# 使用dynamic参数控制字段的新增
PUT my_index
{
 "mappings":{        # 关键字
  "doc":{            # 类型名
   "dynamic":false,  # 设置为false，索引不允许新增字段
   "properties":{    # 字段名称及类型定义
    "title":{
     "type":"text"   # 字段类型
    },
    "name":{
     "type":"keyword"
    },
    "age":{
     "type":"integer"
    } 
   }
  }
 }
}

# copy_to的使用
PUT my_index
{
 "mappings":{
  "doc":{
   "properties":{
    "first_name":{
     "type":"text",
     "copy_to":"full_name"
    },
    "last_name":{
     "type":"text",
     "copy_to":"full_name"
    },
    "full_name":{
     "type":"text"
    }
   }
  }
 }
}
# 
# 向索引写入数据
PUT my_index/doc/1
{
 "first_name":"John",
 "last_name":"Smith"
}
# 
# 查询索引my_index中full_name同时包含John 和 Smith的数据
GET my_index/_search
{
 "query":{
  "match":{
   "full_name":{
    "query":"John Smith",
    "operator":"and"
   }
  }
 }
}

# index参数的使用
PUT my_index
{
 "mappings":{
  "doc":{
   "properties":{
    "cookie":{
     "type":"text",
     "index":false    # 设置为false，该字段不能被搜索
    }
   }
  }
 }
}

# 向使用了index参数的字段写入信息
PUT my_index/doc/1
{
 "cookie":"name=alfred"
}

# index_options参数的使用
PUT my_index
{
 "mappings":{
  "doc":{
   "properties":{
    "cookie":{
     "type":"text",
     "index_options":"offsets"  # 记录文档ID、词频TF、分词位置和偏移
    }
   }
  }
 }
}

# 使用null_value修改ES遇到null值时的默认返回值
PUT my_index
{
 "mappings":{
  "doc":{
   "properties":{
    "cookie":{
     "type":"keyword",
     "null_value":"NULL"    # 当遇到空值null的时候，返回一个字符串形式的NULL
    }
   }
  }
 }
}

# ES的自动类型识别
PUT my_index/doc/1
{
 "username":"alfred",    # username字段自动识别为text类型
 "age":20                # age字段自动识别为long类型
}

# 验证ES的字段类型自动识别
PUT my_index/doc/1
{
 "username":"alfred",    # 字符串类型text
 "age":20,               # 整数long
 "bitrh":"1998-10-10",   # 默认识别日期date
 "married":false,        # 布尔类型boolean
 "year":"18"             # 默认不识别数字text
 "tags":["boy","fashion"],# 数组中第一个不为null的元素为字符串类型，所以为text
 "money":100.1           # 浮点类型float
}
#  再对my_index进行mapping查询，就会获得每个字段的类型：

# 1. 使用dynamic_date_formats自定义日期格式
PUT my_index
{
 "mappings":{
  "doc":{
   "dynamic_date_formats":["MM/dd/yyyy"]
  }
 }
}
# 写入符合自定义格式的日期数据，可识别为date类型
PUT my_index/doc/1
{
 "create_time":"01/01/2019"    # create_time字段识别为date类型
}
# 
#  2. 使用date_detection可以关闭自动识别日期格式：
PUT my_index
{
 "mappings":{
  "doc":{
   "date_detection":false 
  }
 }
}
# 
PUT my_index/doc/1
{
 "create_time":"01/01/2019"    # create_time字段是text类型
}
# 
# ES中可配置数字是否识别，默认关闭：
PUT my_index
{
 "mappings":{
  "doc":{
   "numeric_detection":true    # 开启数字自动识别
  }
 }
}
# 写入数字数据，ES可以自动识别其类型
PUT mu_index/doc/1
{
 "year":"18",    # year字段自动识别为long类型
 "money":"100.1"    # money字段自动识别为float类型
}

# ES根据自动识别的数据类型、字段名等动态设定字符类型
PUT test_index
{
 "mappings":{
  "doc":{
   "dynamic_template":[
    {
     "strings":{
      # 匹配到所有的字符串类型，全部设为keyword类型
      "match_mapping_type":"string",
      "mapping":{
       "type":"keyword"
      }
     }
    }
   ]
  }
 }
}

# 如：Request Body Search方式进行查询
GET /my_index/_search
{
 "query":{
  "match":{
   "username":"alfred"
  }
 }
}

GET my_index/_search?q=alfred
{
 "profile":true #使用profile参数，可以明确地看到ES如何执行的查询条件
}

# a.查询字段username中包含alfred的文档
GET my_index/_search?q=username:alfred
#
# b.查询字段username中包含alfred或way的文档
GET my_index/_search?q=username:alfred way
#
# c.查询字段username为"alfred way"的文档
GET my_index/_search?q=username:"alfred way"
#
# d.分组后，查询字段username中包含alfred，包含way的文档
GET my_index/_search?q=username:(alfred way)
# 这个和b的结果一样，但是区别在于使用分组之后，不进行泛查询。

# 查询索引my_index中username包含alfred但是不包含way的文档
GET my_index/_search?q=username:(alfred NOT way)
#
# 查询索引my_index中一定包含lee，一定不含alfred，可能有way的文档
GET my_index/_search?q=username:(way +lee -alfred)
# 或写成
GET my_index/_search?q=username:((lee && !alfred) || (way && lee && !alfred))
#
# 注意：url中，+(加号)会被解析成空格，所以要用 %2B ：
# 查询索引my_index中一定包含lee，一定不包含alfred，可能包含way的文档
GET my_index/_search?q=username:(way %2Blee -alfred)

# a.查询索引my_index中username字段包含alfred_或_年龄大于20的文档
GET my_index/_search?q=username:alfred age>20
#  
# b.查询索引my_index中username字段包含alfred_且_年龄大于20的文档
GET my_index/_search?q=username:alfred AND age>20
# 
# 查询索引my_index中birth字段在1985和1990之间的文档
GET my_index/_search?q=birth:(>1985 AND < 1990)

# 模糊匹配。匹配与alfred差一个字符的词，比如：alfreds、alfret等
GET my_index/_search?q=username:alfred~1
#
# 近似度查询，查询字段username和"alfred way"差n个单词的文档
GET my_index/_search?q=username:"alfred way" ~5

GET my_index/_search
{
  "query":{  
   "match":{                 # 关键词
    "username":"alfred way"  # 字段名和查询语句
   }
  }
}

# 使用operator参数控制单词间关系
GET my_index/_search
{
 "query":{
  "match":{
   "username":"alfred way",
   "operator":"and"    # and，同时包含alfred和way
  }
 }
}

# 使用minimum_should_match参数控制需匹配的单词数
GET my_index/_search
{
 "query":{
  "match":{
   "username":"alfred way",
   "minimum_should_match":"2"
  }
 }
}

# 使用explain参数，可以查看具体的相关性的得分是如何计算的
GET my_index/_search
{
 "explain":true,    # 设置为true
 "query":{
  "match":{
   "username":"alfred"
  }
 }
}

# 设定shards数量为1
PUT my_index
{
 "settings":{
  "number_of_shards":"1"
 }
}

GET my_index/_search
{
 "query":{
  "match_phrase":{    # 关键词
   "job":"java engineer"
  }
 }
}

GET my_index/_search
{
 "query":{
  "match_phrase":{
   "job":{
    "query":"java engineer",
    "slop":"1"    # 关键词，设定单词间隔
   }
  }
 }
}

GET my_index/_search
{
 "query":{
  "query_string":{
   "default_field":"username",
   "query":{alfred AND way"
  }
 }
}
#
#* 或 */
GET my_index/_search
{
 "query":{
  "query_string":{
   "fileds":["username","job"],
   "query":"alfred OR (java AND ruby)"
  }
 }
}

GET my_index/_search
{
 "query":{
  "simple_query_string":{
   "fields":[username],
   "query":"alfred +way"    #等价于 "query":"alfred AND way"
  }
 }
}

GET my_index/_search
{
 "query":{
  "term":{
   "username":"alfred"
  }
 }
}

GET my_index/_search
{
 "query":{
  "terms":{
   "username":["alfred","way"]
  }
 }
}

# range query对数值的查询
GET my_index/_search
{
 "query":{
  "range":{
   "age":{
    "gte":10,
    "lte":20
   }
  }
 }
}

# range query对日期的查询
GET my_index/_search
{
 "query":{
  "range":{
   "birth":{
    "lte":"1988-01-01" 
    # 或者使用"lte":"now-30y",这种Date Math类型
   }
  }
 }
}

# 假设当前时间为2019-01-02 12:00:00
now+1h   =>   2019-01-02 13:00:00
now-1h   =>   2019-01-02 11:00:00
now-1h/d =>   2019-01-02 00:00:00
2019-01-01||+1M/d  => 2019-02-01 00:00:00

# 使用constant_score query
GET my_index/_Search
{
 "query":{
  "constant_score":{    #关键词
   "match":{
    "username":"alfred"
   }
  }
 }
}

# 使用filter查询
GET my_index/_search
{
 "query":{
  "bool":{    # 关键词
   "filter":[
    "term":{
     "username":"alfred"
    }
   ]
  }
 }
}

# 使用must进行查询
GET my_index/_search
{
 "query":{
  "bool":{
   "must":[    
    {
     "match":{
      "username":"alfred"
     }
    },
    {
     "match":{
      "job":"specialist"
     }
    }
   ]
  }
 }
}

# 使用must_not进行查询
GET my_index/_search
{
 "query":{
  "bool":{
   "must":[
   {
    "match":{
     "job":"java"
    }
   }
   ],
   "must_not":[
   {
    "match":{
     "job":"ruby"
    }
   }
   ]
  }
 }
}

# bool查询中只有should的情况
GET my_index/_search
{
 "query":{
  "bool":{
   "should":[
    {
     "term":{"job":"java"}    # 条件1
    },
    {
     "term":{"job":"ruby"}    # 条件3
    }
    {
     "term":{"job":"specialist"}    # 条件3
    }
   ],
   "minimum_should_match":2    # 至少需要满足两个条件
  }
 }
}
# 
# bool查询中同时包含should和must
GET my_index/_search
{
 "query":{
  "bool":{
   "should":[    # 同时包含should
   {
    "term":{"job":"ruby"}
   }
   ],
   "must":[    # 同时包含must
   {
    "term":{"usernmae":"alfred"}
   }
   ]
  }
 }
}

# query和filter上下文
GET my_index/_search
{
 "query":{
  "bool":{
   "must":[    # query上下文
   {
    "term":{"title":"Search"}
   },
   {
    "term":{"content":"ElasticSearch"}
   }
   ],
   "filter":[    # filter上下文
   {
    "term":{"status":"published"}
   },
   {
    "range":{
     "publish_date":{
      "gte":"2015-01-01"
     }
    }
   }
   ]
  }
 }
}

# 使用_count获取符合条件的文档数
GET my_index/_count    # 关键词
{
 "query":{
  "match":{
   "username":"alfred"
  }
 }
}

# 不返回_source
GET my_index/_search
{
 "_source":false
}
# 返回_source部分字段
GET my_index/_search
{
 "_source":["username","age"]
}
# 通配符匹配返回_source部分字段
GET my_index/_search
{
 "_source":{
  "includes":"*I*",
  "encludes":"birth"
 }
}