ES-基本概念

• 词项： 所有文档中出现的不重复个体
• 分片： 底层工作单元，保存全部数据中的一部分，能搜索任意一个节点上的资源（文档会被存储和索引到分片内）。分为主分片和副本分片，索引内的任意一个文档都归属于主分片，副本分片是主分片的拷贝，提供读服务，副本分片和主分片不会被分到同一个节点
• Document： 根对象，能被indexed的基本信息单元，用JSON表示，ID唯一,不可修改，只能替换

• 文档元数据

  1. _Index 索引。相似document的集合，标明文档存放的位置
  2. _type 数据子分区。同一索引下的数据逻辑分区,一个索引可以有多个类型
  3. _id 与 _index,_type一起唯一确定一个文档
  4. _version 保证相互冲突的变更不会导致数据丢失。ES使用乐观并发控制，默认不阻塞并发请求，如果请求版本号不对，返回错误状态码
• Shards： 索引被切分存储的片段
• Replication： 索引shards的拷贝
• _score：正浮点数，表示相关性，评分越高，相关性越高
• 倒排索引：文档中所有不重复词的列表构成，其中每个词有一个包含它的文档列表，只能搜索到索引中存在的词条

ES-命令行使用

集群操作

查询集群的名字

⇒  curl -XGET 'http://localhost:9200'

查询集群的健康状况

⇒  curl -XGET 'http://localhost:9200/_cluster/health?format=yaml'

status字段说明：

1. green 一切正常
2. yellow replicas没有分配[可能是只有单个节点]，集群正常
3. red 某些数据取不到

format=yaml指定使用yaml格式输出，方便查看

索引操作

获取集群的所有索引

⇒  curl -XGET 'http://localhost:9200/_cat/indices'

索引的字段

⇒  curl -XGET 'http://localhost:9200/mytest/_mapping?format=yaml'

结果

mytest:
 mappings:
   external:
  properties:
    addre:
      type: "string"
    name:
      type: "string"

它类似于数据库的schema，描述文档可能具有的字段或属性、每个字段的数据类型。

字段对于非string类型，一般只需要设置type。string域两重要属性 index analyzer

index

1. analyzed 全文索引这个域。首先分析字符串，然后索引

    2. not_analyzed 精确索引 ，不分析            

    3. no 此域不会被搜索

analyzer

将文本分成四核倒排索引的独立词条，后将词条统一化提高可搜索性

动态映射： 文档中出现之前从未遇到过的字段，动态确定数据类型，并自动把新的字段添加到类型映射

新建索引

⇒  curl -XPUT 'localhost:9200/mytest'

删除索引

⇒  curl -XDELETE 'localhost:9200/mytest?format=yaml'

数据查询

插入单条数据

⇒  curl -XPUT 'localhost:9200/mytest/external/1?format=yaml' -d '
quote> { "name":"paxi"}'

查询单条数据

⇒  curl -XGET 'localhost:9200/mytest/external/1?format=yaml'

删除单条数据

curl -XDELETE 'localhost:9200/mytest/external/3?format=yaml'

存储的文本分析

curl -XGET 'localhost:9200/_analyze?format=yaml' -d '
{"papa xixi write"}'

结果为

tokens:
- token: "papa"
  start_offset: 3
  end_offset: 7
  type: "<ALPHANUM>"
  position: 1
- token: "xixi"
  start_offset: 8
  end_offset: 12
  type: "<ALPHANUM>"
  position: 2
- token: "write"
  start_offset: 13
  end_offset: 18
  type: "<ALPHANUM>"
  position: 3

token 表示实际存储的词条，position表示词条在原始文本中的位置。

可以看出完整的文本会被切割存储成不同的词条

不返回元数据

curl -XGET 'localhost:9200/mytest/_search?filter_path=hits.hits._source&format=yaml' -d '
{ "query":{"match":{"name":"papa xixi write"}}}'

低版本无法生效

只返回部分字段

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"match":{"name":"papa xixi write"}},"_source":["name"]}'

低版本无效，可以用通配符

match查询

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"match":{"name":"papa xixi write"}}}'

查询匹配的结果如下

hits:
  - _index: "mytest"
    _type: "external"
    _id: "11"
    _score: 0.6532502
    _source:
      name: "papa xixi write"
  - _index: "mytest"
    _type: "external"
    _id: "4"
    _score: 0.22545706
    _source:
      name: "papa xixi"
  - _index: "mytest"
    _type: "external"
    _id: "2"
    _score: 0.12845722
    _source:
      name: "papa"
  - _index: "mytest"
    _type: "external"
    _id: "10"
    _score: 0.021688733
    _source:
      name: "xixi"

从查询结果,它获取到了所有包含 papa 、 xixi和write 的词，相当于将原来的词拆开，然后两个单词做了 OR 操作，如果要全部匹配，可以使用AND操作

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"match":{"name":{"query":"papa xixi write","operator":"and"}}}}'
---
  hits:
  total: 1
  max_score: 0.6532502
  hits:
  - _index: "mytest"
    _type: "external"
    _id: "11"
    _score: 0.6532502
    _source:
      name: "papa xixi write"

如果只是想提高精度

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"match":{"name":{"query":"papa xixi write","minimum_should_match":"75%"}}}}'
---
hits:
  total: 2
  max_score: 0.6532502
  hits:
  - _index: "mytest"
    _type: "external"
    _id: "11"
    _score: 0.6532502
    _source:
      name: "papa xixi write"
  - _index: "mytest"
    _type: "external"
    _id: "4"
    _score: 0.22545706
    _source:
      name: "papa xixi"

term查询

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"term":{"name":"papa xixi write"}}}'

它的结果是什么也没有查到

total: 0
  max_score: null
  hits: []

换用查询语句

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"term":{"name":"papa"}}}'

结果为

hits:
  - _index: "mytest"
    _type: "external"
    _id: "2"
    _score: 1.0
    _source:
      name: "papa"
  - _index: "mytest"
    _type: "external"
    _id: "4"
    _score: 0.37158427
    _source:
      name: "papa xixi"
  - _index: "mytest"
    _type: "external"
    _id: "11"
    _score: 0.2972674
    _source:
      name: "papa xixi write"

match 和 term的区别

match 如果在全文字段上查询，会使用正确的分析器分析查询字符串；如果精确值字段使用，会精确匹配。 term精确匹配，只要包含了对应的文本就可以，不对文本分析(not_analyzed文本会精确匹配,terms 多个值只要有一个匹配就匹配);

从"papa xixi write"的存储文本分析来看，它本身会被切割成不同的词条，所以用 term查询"papa xixi write"，无法获取到结果，但是match确能够匹配

filter使用

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"filtered":{"filter":{"range":{"name":{"gt":"w"}}}}}}'

或者

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"constant_score":{"filter":{"range":{"name":{"gt":"w"}}}}}}'

验证语法是否正确

⇒  curl -XGET 'localhost:9200/_validate/query?explain&format=yaml' -d '{ "query":{{"filter":{"range":{"name":{"gt":"w"}}}}}'
---
valid: false
//原因省略

bool使用

使用term查询

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ "query":{"term":{"addre":"beijing"}}}'

结果为

hits:
  - _index: "mytest"
    _type: "external"
    _id: "5"
    _score: 0.30685282
    _source:
      addre: "beijing"
  - _index: "mytest"
    _type: "external"
    _id: "6"
    _score: 0.30685282
    _source:
      addre: "beijing"
      name: "px"

转换为bool查询，结果一样

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ query:{bool:{must:{match:{addre:"beijing"}}}}}'

如果只想要最后一条

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ query:{bool:{must:{match:{addre:"beijing"}},must:{match:{name:"px"}}}}}'

想要第一条

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ query:{bool:{must:{match:{addre:"beijing"}},must_not:{match:{name:"px"}}}}}'

都想要

curl -XGET 'localhost:9200/mytest/_search?format=yaml' -d '
{ query:{bool:{must:{match:{addre:"beijing"}},should:{match:{name:"px"}}}}}'

must的意思是当前值必须是有的，must_not必须没有，should表示数据可以有也可以没有

ES-java查询

AggregationBuilders.terms:一段时间内，某个字段取值的数量排名前几的聚合

/ **     @param startTime 开始的时间
     * @param endTime 结束的时间
     * @param termAggName term过滤
     * @param fieldName 要做count的字段
     * @param top 返回的数量
     */
RangeQueryBuilder actionPeriod = QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second");
TermsBuilder termsBuilder = AggregationBuilders.terms(termAggName).field(fieldName).size(top).order(Terms.Order.count(false));
return client.prepareSearch(INDICE).setQuery(actionPeriod).addAggregation(termsBuilder).setSize(0).execute().actionGet();

order(Terms.Order.count(false))：表示降序

size(top):top表示只要排序的数量

prepareSearch(INDICE):INDICE表示索引的名字

setSize(0):表示只要聚合结果

如果需要去掉某些特殊字段取值
client为构建的ES客户端

BoolQueryBuilder actionPeriodMustNot = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second")).mustNot(QueryBuilders.termQuery(field, value));

如果是单个字段特定的多个值

//values是个List
BoolQueryBuilder actioPeriodMust = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second")).must(QueryBuilders.termsQuery(field, values));

使用结果

Terms clickCount= sr.getAggregations().get(termAggName);
for (Terms.Bucket term:clickCount.getBuckets()){
  int key = term.getKeyAsNumber().intValue(); //要排序字段的值
  long docCount = term.getDocCount(); //数量
}

date_histogram: 一段时间之内，时间字段按照时间间隔的聚合

BoolQueryBuilder actioPeriodMust = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second"));
DateHistogramBuilder actionInterval = AggregationBuilders.dateHistogram(dateNickName).field("myTimeField").timeZone("Asia/Shanghai");
if (timeInterval<MINUTE){
  actionTimeInterval.interval(DateHistogramInterval.seconds(timeInterval)).format("HH:mm:ss");
}else if (timeInterval<HOUR){
  actionTimeInterval.interval(DateHistogramInterval.minutes(timeInterval / MINUTE)).format("dd HH:mm");
}else if (timeInterval < DAY){
  actionTimeInterval.interval(DateHistogramInterval.hours(timeInterval / HOUR)).format("HH:mm");
}else if (timeInterval < THIRTY_DAY){
  actionTimeInterval.interval(DateHistogramInterval.days(timeInterval / DAY));
}else{
  actionTimeInterval.interval(DateHistogramInterval.MONTH);
}
actionInterval.format("yyyy-MM-dd HH:mm:ssZ");
return client.prepareSearch(INDICE).setQuery(actioPeriodMust).addAggregation(actionInterval).setSize(0).execute().actionGet();

es本身默认设置的时间戳是 UTC形式，在国内要设置TimeZone(“Asia/Shanghai”);

java的SimpleDateFormate会默认获取虚拟机所在时区的时间戳,所以存时间的时候，最好存与时区无关的时间，再做本地化显示

使用结果

Histogram histogram=sr.getAggregations().get(dateNickName);
for(Histogram.Bucket entry:histogram.getBuckets()){
  String key = entry.getKeyAsString();//时间间隔
  long count = entry.getDocCount();//数量
}

subAggregation:一段时间内，按照一定的时间间隔，每个间隔段内字段每个取值的数量聚合

相当于合并上述两个场景

BoolQueryBuilder query = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second"))
  .must(QueryBuilders.termsQuery("action", orderValue));
DateHistogramBuilder actionTimeInterval = AggregationBuilders.dateHistogram(dateNickName).field("myTimeField").timeZone("Asia/Shanghai");
actionTimeInterval.subAggregation(AggregationBuilders.terms(termNickName).field("action").size(size));
return client.prepareSearch(INDICE).setQuery(query).addAggregation(actionTimeInterval).setSize(0).execute().actionGet();

使用结果

Histogram hitogram = sr.getAggregations().get(dateAggName);
for (Histogram.Bucket date : hitogram.getBuckets()) {
  String intervalName = date.getKeyAsString();
  long timeIntervalCount = date.getDocCount();
  if (timeIntervalCount != 0) {
    Terms terms = date.getAggregations().get(termAggName);
    for (Terms.Bucket entry : terms.getBuckets()) {
      int key=    entry.getKeyAsNumber().intValue();
      long childCount = entry.getDocCount();
    }
  }
}

分页获取数据

BoolQueryBuilder actionPeriodMust = QueryBuilders.boolQuery().must(QueryBuilders.termQuery(key, value)).must(QueryBuilders.rangeQuery("myTimeField").gte(startTime).lte(endTime).format("epoch_second"));
return client.prepareSearch(INDICE).setQuery(actionPeriodMust).addSort(SortBuilders.fieldSort("myTimeField").order(SortOrder.ASC)).setFrom(from).setSize(size).execute().actionGet();

使用

Iterator<SearchHit> iterator = sr.getHits().iterator();
while (iterator.hasNext()) {
  SearchHit next = iterator.next();
  JSONObject jo = JSONObject.parseObject(next.getSourceAsString());
}

AggregationBuilders.cardinality:获取某个字段的唯一取值数量

BoolQueryBuilder query = QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("myTimeField").gte(startTimeInSec*1000).lte(endTimeInSec*1000).format("epoch_millis"));
CardinalityBuilder fieldCardinality = AggregationBuilders.cardinality(cardinalityAggName).field(field);//field 要获取的字段
return client.prepareSearch(INDICE).setQuery(query).addAggregation(fieldCardinality).execute().actionGet();

使用结果

Cardinality cardinality = sr.getAggregations().get(cardinalityAggName);
long value = cardinality.getValue();

bool查询

比如想要addr是beijing的,同时必须满足条件：name是 paxi,或者，phoneNumber是 1234567890

BoolQueryBuilder searchIdQuery = QueryBuilders.boolQuery();
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
while (kvs.hasNext()){
  Map.Entry<String, String> fieldValue = kvs.next();
  String field=fieldValue.getKey();
  String value=fieldValue.getValue();
  searchIdQuery.should(QueryBuilders.termQuery(field, value));
}
boolQueryBuilder.must(searchIdQuery);
boolQueryBuilder.must(QueryBuilders.termsQuery(key, values));
return client.prepareSearch(INDICE).setQuery(boolQueryBuilder).execute().actionGet();

LogStash

./bin/logstash -f conf/test.conf 启动方式

• [] 字段引用，将字段名放到里面即可。 例如： 获取精度 geoip[0]
• a => true 数据类型，前面代表数据的字段名，后面是值，当前为bool
• stdin 中 type用来标记事件类型，tags由具体插件添加、删除
• start_position： logstash读取文件的初始位置，默认使用结束位置

grok表达式语法

1. 完整语法： %{PATTERN_NAME:capture_name:data_type}
2. 写表达式如果没有完全匹配那么会匹配失败
3. 一样的字符串直接写对应字符即可，希望解析的用%{}包裹
4. (?<param1>w+) 表示匹配 单词 一次或多次并将结果存储在 param1里面
5. pattern_dir 指定grok表达式存储的位置，match直接引用
6. 正则写到想要匹配的位置即可

附录

grok 表达式验证地址 官方grok内置正则 正则语法

Kibana查询

kibana框中的查询可以使用LUCENE查询语法或者是ES的查询语句

Field

查询指定的字段否则使用默认字段

比如 index包含两个字段 title , text ；text是默认字段

title:”hello world” AND text:to 和 title:”hello world” AND to 等效

title: hello world 查询的则是 title为hello的字段 text为world的字段

wildcard

te?t 匹配 text test ;表示任意一个字符

test* 匹配 test tests tester;表示0到多个字符

？和 * 不能用在第一个位置

Fuzzy

roam~ 匹配 foam和roams 基于 Levenshtein Distance，波浪线添加在末尾。从1.9版本开始可以追加数字代表相似度，越接近1相似度越高，比如 roam~0.8,默认是0.5

Proximity

“jakarta apache”~10 匹配从jakarta到apache中间隔10个单词

Range

mode_date:[20020101 TO 20030101] 匹配时间在20020101到20030101之间，包括20020101和20030101

title:{Aida TO Carmen} 匹配Aida 到 Carmen之间，不包括Aida和Carmen

“[”表示包含 “{”表示不包含

AND（+） OR NOT（-）

关键字要大写

(jakarta OR apache) AND website 组合查询 包含 website 和 jakarta/apache

逃逸字符

\(1\+1\)\:2

使用ES查询语法

将ES命令中的 -d 后面的参数加入即可；比如curl查询为

curl -XGET 'localhost:9200/_search?format=yaml' -d '
{ "query":{"term":{"addre":"beijing"}}}'

命令行下输入为:{ "query":{"term":{"addre":"beijing"}}}

附录

Lucene 语法