ES7.x 聚合相关【聚合&索引迁移、重建、别名】

聚合

1. 聚合有以下四个种类
   1. Bucket Aggregation  一些列满足特定条件的文档的集合，给字段分桶，比如给性别分类，一个user文档属于哪个性别。

      GET movies/_search
      {
        "size": 0,
        "aggs": {
          "year": {
            "terms": {
              "field": "year"
            }
          }
        }
      }

      简单分桶，对年份进行分桶,aggs下的year为自定义名称，用来辨别响应集合，一下是响应

      {
        "took" : 2,
        "timed_out" : false,
        "_shards" : {
          "total" : 1,
          "successful" : 1,
          "skipped" : 0,
          "failed" : 0
        },
        "hits" : {
          "total" : {
            "value" : 10000,
            "relation" : "gte"
          },
          "max_score" : null,
          "hits" : [ ]
        },
        "aggregations" : {
          "year" : {
            "doc_count_error_upper_bound" : 0,
            "sum_other_doc_count" : 14954,
            "buckets" : [
              {
                "key" : 0,
                "doc_count" : 5169
              },
              {
                "key" : 2013,
                "doc_count" : 902
              },
              {
                "key" : 2009,
                "doc_count" : 885
              },
              {
                "key" : 2012,
                "doc_count" : 872
              },
              {
                "key" : 2011,
                "doc_count" : 850
              },
              {
                "key" : 2008,
                "doc_count" : 785
              },
              {
                "key" : 2010,
                "doc_count" : 766
              },
              {
                "key" : 2007,
                "doc_count" : 724
              },
              {
                "key" : 2014,
                "doc_count" : 701
              },
              {
                "key" : 2006,
                "doc_count" : 672
              }
            ]
          }
        }
      }
      

       

   2. Metric Aggregation  一些数学运算，可以对文档进行统计分析，可以在字段上也可以在脚本产生的结果之上进行计算。

      GET movies/_search
      {
        "size": 0,
        "aggs": {
          "year": {
            "terms": {
              "field": "year"
            },
            "aggs": {
              "sum_year": {
                "sum": {
                  "field": "year"
                }
              }
            }
          }
        }
      }

      首先对year进行分桶，然后对桶内的集合施加二次聚合，把桶内的年份加起来，其中，二次聚合的关键词aggs与分桶字段year同级，es会依次执行，以下是响应

      {
        "took" : 27,
        "timed_out" : false,
        "_shards" : {
          "total" : 1,
          "successful" : 1,
          "skipped" : 0,
          "failed" : 0
        },
        "hits" : {
          "total" : {
            "value" : 10000,
            "relation" : "gte"
          },
          "max_score" : null,
          "hits" : [ ]
        },
        "aggregations" : {
          "year" : {
            "doc_count_error_upper_bound" : 0,
            "sum_other_doc_count" : 14954,
            "buckets" : [
              {
                "key" : 0,
                "doc_count" : 5169,
                "sum_year" : {
                  "value" : 0.0
                }
              },
              {
                "key" : 2013,
                "doc_count" : 902,
                "sum_year" : {
                  "value" : 1815726.0
                }
              },
              {
                "key" : 2009,
                "doc_count" : 885,
                "sum_year" : {
                  "value" : 1777965.0
                }
              },
              {
                "key" : 2012,
                "doc_count" : 872,
                "sum_year" : {
                  "value" : 1754464.0
                }
              },
              {
                "key" : 2011,
                "doc_count" : 850,
                "sum_year" : {
                  "value" : 1709350.0
                }
              },
              {
                "key" : 2008,
                "doc_count" : 785,
                "sum_year" : {
                  "value" : 1576280.0
                }
              },
              {
                "key" : 2010,
                "doc_count" : 766,
                "sum_year" : {
                  "value" : 1539660.0
                }
              },
              {
                "key" : 2007,
                "doc_count" : 724,
                "sum_year" : {
                  "value" : 1453068.0
                }
              },
              {
                "key" : 2014,
                "doc_count" : 701,
                "sum_year" : {
                  "value" : 1411814.0
                }
              },
              {
                "key" : 2006,
                "doc_count" : 672,
                "sum_year" : {
                  "value" : 1348032.0
                }
              }
            ]
          }
        }
      }
      

      其中key是年份，doc_count即此年份在文档中出现的次数，而sum_year下即为当前年分桶下的年份和。

   3. Pipeline Aggregation  对其他的聚合结果进行二次聚合
   4. Matrix Aggregation 支持对多个字段的操作并提供一个结果矩阵
2. term查询与全文查询的区别
   1. term查询对输入不做分词，会将输入作为一个整体，在倒排索引中查找精准的词项，并使用相关算分工时为每个包含该词项的文档进行相关性打分
   2. match查询，回会输入做分词处理，并进行相关性打分。
3. 多值字段查询

   GET movies/_search
   {
     "query": {
       "constant_score": {
         "filter": {
           "term": {
             "genre.keyword": "Adventure"
           }
         }
       }
     }
   }

   使用字段.keywor的形式进行多值字段查询，以下是查询结果

   {
     "took" : 0,
     "timed_out" : false,
     "_shards" : {
       "total" : 1,
       "successful" : 1,
       "skipped" : 0,
       "failed" : 0
     },
     "hits" : {
       "total" : {
         "value" : 2329,
         "relation" : "eq"
       },
       "max_score" : 1.0,
       "hits" : [
         {
           "_index" : "movies",
           "_type" : "_doc",
           "_id" : "126",
           "_score" : 1.0,
           "_source" : {
             "year" : 1994,
             "genre" : [
               "Adventure",
               "Children",
               "Fantasy"
             ],
             "@version" : "1",
             "id" : "126",
             "title" : "NeverEnding Story III, The"
           }
         },
         {
           "_index" : "movies",
           "_type" : "_doc",
           "_id" : "2",
           "_score" : 1.0,
           "_source" : {
             "year" : 1995,
             "genre" : [
               "Adventure",
               "Children",
               "Fantasy"
             ],
             "@version" : "1",
             "id" : "2",
             "title" : "Jumanji"
           }
         }
       ]
     }
   }
   

   会筛选出genre中含有adventure的文档，如果使用genre进行查询会查不到数据，因为genre中的数据与genre是包含的关系，而不是相等的关系。

4. 相关性和相关性算分

   1. es5之前采用的是TF-IDF算法，而es5之后采用的是BM25算法

   2. 相关性酸粉，描述了一个文档和查询语句匹配的程度，es会对每个匹配查询条件的结果进行算分_score

   3. 词频TF：检索词出现的次数除以文档的总字数，简单的将搜索中的每一个词的TF相加,TF(分词1) + TF（分词2）

2019-10-23

昨天产品插入了个需求，还要昨天就上线，加上凌晨有活动开启，要观测情况，一直搞倒了凌晨两点，结果我8点又来公司上班了，哈哈哈哈哈

下面插入一个更，因为周五有波分享，所以我想先学习下简单的重建索引reindex

都知道elasticsearch索引一旦建立，就无法动态修改其字段的映射类型，有时候因为人为原因污染了索引的mapping,这个时候就只能通过重建索引来修改索引的mapping设置了。

如果想更改索引，一般有以下两种情况

1.给这个索引追加一个新的字段，同时给这个字段指定类型

   但是这种方式会造成数据冗余、数据不同步的情况发生。尽量不要用

2.使用es的reindex api 创建新的索引，然后使用reindex将原来的索引重建到新索引即可，不过这样是停机迁移

PUT user/_doc/1
{
  "name":"PHPer"
}

首先创建被迁移索引，es会创建默认的mapping

{
  "user" : {
    "mappings" : {
      "properties" : {
        "name" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

mapping如上,如果现在要做索引重建

PUT new_user

PUT new_user/_mapping
{
  "properties":{
    "name":{
      "type":"keyword"
    }
  }
}

需要创建新索引，然后设置新的mapping

POST _reindex
{
  "source": {
    "index": "user",
    "size": 1
  },
  "dest": {
    "index": "new_user"
  }
}

使用reindex进行数据迁移，source中指定size使用scroll模式进行数据迁移，默认size1000

{
  "took" : 14,
  "timed_out" : false,
  "total" : 2,
  "updated" : 2,
  "created" : 0,
  "deleted" : 0,
  "batches" : 2,
  "version_conflicts" : 0,
  "noops" : 0,
  "retries" : {
    "bulk" : 0,
    "search" : 0
  },
  "throttled_millis" : 0,
  "requests_per_second" : -1.0,
  "throttled_until_millis" : 0,
  "failures" : [ ]
}

迁移结果如上，如果执行一次迁移，应该是created中是2，由于我第二次操作，属于在新索引上执行修改操作，所以，updated是2

2019-10-26

• 别名 

POST _aliases
{
  "actions": [
    {
      "remove": {"index": "movies","alias": "myindex"}
    },
    {
      "add": {"index": "movies_new","alias": "myindex"}
    }
  ]
}

使用alias api进行别名处理，一个索引可以有多个别名，一个别名也可以只想多个索引,actions间的行为时原子性的。如果一个别名指向多个索引，那么当查看索引别名时会查所有指向别名的索引。

• 查看当前别名指向哪些索引

  GET _alias/myindex1

  结果

  {
    "movies_new" : {
      "aliases" : {
        "myindex1" : { }
      }
    },
    "movies" : {
      "aliases" : {
        "myindex1" : { }
      }
    }
  }
  

   

• 查看当前索引有哪些别名

  GET movies_new/_alias

  结果

  {
    "movies_new" : {
      "aliases" : {
        "myindex1" : { }
      }
    },
    "movies" : {
      "aliases" : {
        "myindex1" : { }
      }
    }
  }