首页 > 其他分享 >ElasticSearch之聚合操作

ElasticSearch之聚合操作

时间：2024-05-28 17:59:42浏览次数：17  
标签：salary 聚合 field job ElasticSearch aggs 操作 size

官网：Aggregations | Elasticsearch Guide [8.13] | Elastic

Elasticsearch除搜索以外，提供了针对ES 数据进行统计分析的功能。聚合(aggregations)可以让我们极其方便的实现对数据的统计、分析、运算。

基本语法

聚合查询的语法结构与其他查询相似，通常包含以下部分：

  • 查询条件：指定需要聚合的文档，可以使用标准的 Elasticsearch 查询语法，如 term、match、range 等等。
  • 聚合函数：指定要执行的聚合操作，如 sum、avg、min、max、terms、date_histogram 等等。每个聚合命令都会生成一个聚合结果。
  • 聚合嵌套：聚合命令可以嵌套，以便更细粒度地分析数据。
GET <index_name>/_search
{
  "aggs": {
    "<aggs_name>": { // 聚合名称需要自己定义
      "<agg_type>": {
        "field": "<field_name>"
      }
    }
  }
}
  • aggs_name：聚合函数的名称
  • agg_type：聚合种类，比如是桶聚合（terms）或者是指标聚合（avg、sum、min、max等）
  • field_name：字段名称或者叫域名。

聚合的分类

  • Bucket Aggregation（桶聚合）： 满足特定条件的文档的集合放置到一个桶里，每一个桶关联一个key，类比Mysql中的group by操作。
SELECT size COUNT(*) FROM products GROUP BY size
#bucket聚合的DSL类比实现：
{
 "aggs": {
    "by_size": {
      "terms": {
        "field": "size"
      }
  }
}
  • Metric Aggregation（指标聚合）：数学运算，可以对文档字段进行统计分析，类比Mysql中的 min(), max(), sum() 操作。
SELECT MIN(price), MAX(price) FROM products
#Metric聚合的DSL类比实现：
{
    "aggs":{
        "avg_price":{
            "avg":{
                "field":"price"
            }
        }
    }
}
  • Pipeline Aggregation（管道聚合）：对其他的聚合结果进行二次聚合

Metric Aggregation

  • 单值分析︰只输出一个分析结果
    • min, max, avg, sum
    • Cardinality（类似distinct Count)
  • 多值分析:输出多个分析结果
    • stats（统计）, extended stats
    • percentile （百分位）, percentile rank
    • top hits(排在前面的示例)

示例数据：

DELETE /member
#创建索引库
PUT /member
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer"
      },
      "gender":{
        "type": "keyword"
      },
      "job":{
         "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 50
            }
          }
      },
      "name":{
        "type": "keyword"
      },
      "salary":{
        "type": "integer"
      }
    }
  }
}

PUT /member/_bulk
{ "index" : {  "_id" : "1" } }
{ "name" : "Emma","age":32,"job":"Product Manager","gender":"female","salary":35000 }
{ "index" : {  "_id" : "2" } }
{ "name" : "Underwood","age":41,"job":"Dev Manager","gender":"male","salary": 50000}
{ "index" : {  "_id" : "3" } }
{ "name" : "Tran","age":25,"job":"Web Designer","gender":"male","salary":18000 }
{ "index" : {  "_id" : "4" } }
{ "name" : "Rivera","age":26,"job":"Web Designer","gender":"female","salary": 22000}
{ "index" : {  "_id" : "5" } }
{ "name" : "Rose","age":25,"job":"QA","gender":"female","salary":18000 }
{ "index" : {  "_id" : "6" } }
{ "name" : "Lucy","age":31,"job":"QA","gender":"female","salary": 25000}
{ "index" : {  "_id" : "7" } }
{ "name" : "Byrd","age":27,"job":"QA","gender":"male","salary":20000 }
{ "index" : {  "_id" : "8" } }
{ "name" : "Foster","age":27,"job":"Java Programmer","gender":"male","salary": 20000}
{ "index" : {  "_id" : "9" } }
{ "name" : "Gregory","age":32,"job":"Java Programmer","gender":"male","salary":22000 }
{ "index" : {  "_id" : "10" } }
{ "name" : "Bryant","age":20,"job":"Java Programmer","gender":"male","salary": 9000}
{ "index" : {  "_id" : "11" } }
{ "name" : "Jenny","age":36,"job":"Java Programmer","gender":"female","salary":38000 }
{ "index" : {  "_id" : "12" } }
{ "name" : "Mcdonald","age":31,"job":"Java Programmer","gender":"male","salary": 32000}
{ "index" : {  "_id" : "13" } }
{ "name" : "Jonthna","age":30,"job":"Java Programmer","gender":"female","salary":30000 }
{ "index" : {  "_id" : "14" } }
{ "name" : "Marshall","age":32,"job":"Javascript Programmer","gender":"male","salary": 25000}
{ "index" : {  "_id" : "15" } }
{ "name" : "King","age":33,"job":"Java Programmer","gender":"male","salary":28000 }
{ "index" : {  "_id" : "16" } }
{ "name" : "Mccarthy","age":21,"job":"Javascript Programmer","gender":"male","salary": 16000}
{ "index" : {  "_id" : "17" } }
{ "name" : "Goodwin","age":25,"job":"Javascript Programmer","gender":"male","salary": 16000}
{ "index" : {  "_id" : "18" } }
{ "name" : "Catherine","age":29,"job":"Javascript Programmer","gender":"female","salary": 20000}
{ "index" : {  "_id" : "19" } }
{ "name" : "Boone","age":30,"job":"DBA","gender":"male","salary": 30000}
{ "index" : {  "_id" : "20" } }
{ "name" : "Kathy","age":29,"job":"DBA","gender":"female","salary": 20000}

查询最低最高和平均工资：

POST /member/_search
{
  "size": 0,  
  "aggs": {
    "max_salary": {
      "max": {
        "field": "salary"
      }
    },
    "min_salary": {
      "min": {
        "field": "salary"
      }
    },
    "avg_salary": {
      "avg": {
        "field": "salary"
      }
    }
  }
}

对salary进行统计：

POST /member/_search
{
  "size": 0,
  "aggs": {
    "stats_salary": {
      "stats": {
        "field":"salary"
      }
    }
  }
}

cardinate对搜索结果去重：

POST /member/_search
{
  "size": 0,
  "aggs": {
    "cardinate": {
      "cardinality": {
        "field": "job.keyword"
      }
    }
  }
}

Bucket Aggregation

按照一定的规则，将文档分配到不同的桶中，从而达到分类的目的。ES提供的一些常见的 Bucket Aggregation。

  • Terms，需要字段支持filedata
    • keyword 默认支持fielddata
    • text需要在Mapping 中开启fielddata，会按照分词后的结果进行分桶
  • 数字类型
    • Range / Data Range
    • Histogram（直方图） / Date Histogram
  • 支持嵌套: 也就在桶里再做分桶

桶聚合可以用于各种场景，例如：

  • 对数据进行分组统计，比如按照地区、年龄段、性别等字段进行分组统计。
  • 对时间序列数据进行时间段分析，比如按照每小时、每天、每月、每季度、每年等时间段进行分析。
  • 对各种标签信息分类，并统计其数量。

获取job的分类信息

GET /member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword"
      }
    }
  }
}

聚合可配置属性有：

  • field：指定聚合字段
  • size：指定聚合结果数量
  • order：指定聚合结果排序方式

默认情况下，Bucket聚合会统计Bucket内的文档数量，记为_count，并且按照_count降序排序。我们可以指定order属性，自定义聚合的排序方式：

GET /member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword",
         "size": 10,
        "order": {
          "_count": "asc" 
        }
      }
    }
  }
}

限定聚合范围

GET /member/_search
{
  "query": {
    "range": {
      "salary": {
        "gte": 20000 
      }
    }
  }, 
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword",
         "size": 10,
        "order": {
          "_count": "asc" 
        }
      }
    }
  }
}

注意：对 Text 字段进行 terms 聚合查询，会失败抛出异常

解决：对 Text 字段打开 fielddata，支持terms aggregation

PUT /member/_mapping
{
  "properties" : {
    "job":{
       "type":  "text",
       "fielddata": true
    }
  }
}

# 对 Text 字段进行分词，分词后的terms
POST /member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job"
      }
    }
  }
}

对job.keyword 和 job 进行 terms 聚合，分桶的总数并不一样

POST /member/_search
{
  "size": 0,
  "aggs": {
    "cardinate": {
      "cardinality": {
        "field": "job"
      }
    }
  }
}

Range & Histogram

  • 按照数字的范围，进行分桶
  • 在Range Aggregation中，可以自定义Key

Range 示例：按照工资的 Range 分桶

#Salary Range分桶，可以自己定义 key
POST member/_search
{
  "size": 0,
  "aggs": {
    "salary_range": {
      "range": {
        "field":"salary",
        "ranges":[
          {
            "to":10000
          },
          {
            "from":10000,
            "to":20000
          },
          {
            "key":">20000",
            "from":20000
          }
        ]
      }
    }
  }
}

Histogram示例：按照工资的间隔分桶

#工资0到5万，以 2000一个区间进行分桶
POST member/_search
{
  "size": 0,
  "aggs": {
    "salary_histrogram": {
      "histogram": {
        "field":"salary",
        "interval":2000,
        "extended_bounds":{
          "min":0,
          "max":50000
        }
      }
    }
  }
}

top_hits应用场景: 当获取分桶后，桶内最匹配的顶部文档列表

# 指定size，不同工种中，年纪最大的3个员工的具体信息
POST /member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword"
      },
      "aggs":{
        "old_member":{
          "top_hits":{
            "size":3,
            "sort":[
              {
                "age":{
                  "order":"desc"
                }
              }
            ]
          }
        }
      }
    }
  }
}

嵌套聚合示例

# 嵌套聚合1，按照工作类型分桶，并统计工资信息
POST member/_search
{
  "size": 0,
  "aggs": {
    "Job_salary_stats": {
      "terms": {
        "field": "job.keyword"
      },
      "aggs": {
        "salary": {
          "stats": {
            "field": "salary"
          }
        }
      }
    }
  }
}

# 多次嵌套。根据工作类型分桶，然后按照性别分桶，计算工资的统计信息
POST member/_search
{
  "size": 0,
  "aggs": {
    "Job_gender_stats": {
      "terms": {
        "field": "job.keyword"
      },
      "aggs": {
        "gender_stats": {
          "terms": {
            "field": "gender"
          },
          "aggs": {
            "salary_stats": {
              "stats": {
                "field": "salary"
              }
            }
          }
        }
      }
    }
  }
}

Pipeline Aggregation

支持对聚合分析的结果，再次进行聚合分析。

Pipeline 的分析结果会输出到原结果中，根据位置的不同，分为两类：

  • Sibling - 结果和现有分析结果同级
    • Max，min，Avg & Sum Bucket
    • Stats，Extended Status Bucket
    • Percentiles Bucket
  • Parent -结果内嵌到现有的聚合分析结果之中
    • Derivative(求导)
    • Cumultive Sum(累计求和)
    • Moving Function(移动平均值 )

min_bucket示例

在员工数最多的工种里，找出平均工资最低的工种

# 平均工资最低的工种
POST member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field": "job.keyword",
        "size": 10
      },
      "aggs": {
        "avg_salary": {
          "avg": {
            "field": "salary"
          }
        }
      }
    },
    "min_salary_by_job":{   
      "min_bucket": {    
        "buckets_path": "jobs>avg_salary"  
      }
    }
  }
}
  • min_salary_by_job结果和jobs的聚合同级
  • min_bucket求之前结果的最小值
  • 通过bucket_path关键字指定路径

Stats示例

# 平均工资的统计分析
POST member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field": "job.keyword",
        "size": 10
      },
      "aggs": {
        "avg_salary": {
          "avg": {
            "field": "salary"
          }
        }
      }
    },
    "stats_salary_by_job":{
      "stats_bucket": {
        "buckets_path": "jobs>avg_salary"
      }
    }
  }
}

percentiles示例

Percentile ranks aggregation | Elasticsearch Guide [7.17] | Elastic

# 平均工资的百分位数
POST member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field": "job.keyword",
        "size": 10
      },
      "aggs": {
        "avg_salary": {
          "avg": {
            "field": "salary"
          }
        }
      }
    },
    "percentiles_salary_by_job":{
      "percentiles_bucket": {
        "buckets_path": "jobs>avg_salary"
      }
    }
  }
}

Cumulative_sum示例

#Cumulative_sum   累计求和
POST member/_search
{
  "size": 0,
  "aggs": {
    "age": {
      "histogram": {
        "field": "age",
        "min_doc_count": 0,
        "interval": 1
      },
      "aggs": {
        "avg_salary": {
          "avg": {
            "field": "salary"
          }
        },
        "cumulative_salary":{
          "cumulative_sum": {
            "buckets_path": "avg_salary"
          }
        }
      }
    }
  }
}

聚合的作用范围

ES聚合分析的默认作用范围是query的查询结果集，同时ES还支持以下方式改变聚合的作用范围：

  • Filter
  • Post Filter
  • Global
POST member/_search
{
  "size": 0,
  "query": {
    "range": {
      "age": {
        "gte": 20
      }
    }
  },
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword"
        
      }
    }
  }
}

#Filter
POST member/_search
{
  "size": 0,
  "aggs": {
    "older_person": {
      "filter":{
        "range":{
          "age":{
            "from":35
          }
        }
      },
      "aggs":{
         "jobs":{
           "terms": {
        "field":"job.keyword"
      }
      }
    }},
    "all_jobs": {
      "terms": {
        "field":"job.keyword"
        
      }
    }
  }
}



#Post field. 一条语句，找出所有的job类型。还能找到聚合后符合条件的结果
POST member/_search
{
  "aggs": {
    "jobs": {
      "terms": {
        "field": "job.keyword"
      }
    }
  },
  "post_filter": {
    "match": {
      "job.keyword": "Dev Manager"
    }
  }
}


#global 
POST member/_search
{
  "size": 0,
  "query": {
    "range": {
      "age": {
        "gte": 40
      }
    }
  },
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword"
        
      }
    },
    
    "all":{
      "global":{},
      "aggs":{
        "salary_avg":{
          "avg":{
            "field":"salary"
          }
        }
      }
    }
  }
}

排序

指定order，按照count和key进行排序：

  • 默认情况，按照count降序排序

  • 指定size，就能返回相应的桶

#排序 order
#count and key
POST member/_search
{
  "size": 0,
  "query": {
    "range": {
      "age": {
        "gte": 20
      }
    }
  },
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword",
        "order":[
          {"_count":"asc"},
          {"_key":"desc"}
          ]
        
      }
    }
  }
}


#排序 order
#count and key
POST member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword",
        "order":[  {
            "avg_salary":"desc"
          }]
        
        
      },
    "aggs": {
      "avg_salary": {
        "avg": {
          "field":"salary"
        }
      }
    }
    }
  }
}


#排序 order
#count and key
POST member/_search
{
  "size": 0,
  "aggs": {
    "jobs": {
      "terms": {
        "field":"job.keyword",
        "order":[  {
            "stats_salary.min":"desc"
          }]
        
        
      },
    "aggs": {
      "stats_salary": {
        "stats": {
          "field":"salary"
        }
      }
    }
    }
  }
}

ES聚合分析不精准原因

ElasticSearch在对海量数据进行聚合分析的时候会损失搜索的精准度来满足实时性的需求。

不精准的原因： 数据分散到多个分片，聚合是每个分片的取 Top X，导致结果不精准。ES 可以不每个分片Top X，而是全量聚合，但势必这会有很大的性能问题。

提高聚合精度:

方案1：设置主分片为1

注意7.x版本已经默认为1。

适用场景：数据量小的小集群规模业务场景。

方案2：调大 shard_size 值

设置 shard_size 为比较大的值，官方推荐：size*1.5+10。shard_size 值越大，结果越趋近于精准聚合结果值。此外，还可以通过show_term_doc_count_error参数显示最差情况下的错误值，用于辅助确定 shard_size 大小。

  • size：是聚合结果的返回值，客户期望返回聚合排名前三，size值就是 3。
  • shard_size: 每个分片上聚合的数据条数。shard_size 原则上要大于等于 size

适用场景：数据量大、分片数多的集群业务场景。

在Terms Aggregation的返回中有两个特殊的数值：

  • doc_count_error_upper_bound : 被遗漏的term 分桶，包含的文档，有可能的最大值
  • sum_other_doc_count: 除了返回结果 bucket的terms以外，其他 terms 的文档总数（总数-返回的总数)

方案3：将size设置为全量值，来解决精度问题

将size设置为2的32次方减去1也就是分片支持的最大值，来解决精度问题。

原因：1.x版本，size等于 0 代表全部，高版本取消 0 值，所以设置了最大值（大于业务的全量值）。

全量带来的弊端就是：如果分片数据量极大，这样做会耗费巨大的CPU 资源来排序，而且可能会阻塞网络。

适用场景：对聚合精准度要求极高的业务场景，由于性能问题，不推荐使用。

方案4：使用Clickhouse/ Spark 进行精准聚合

适用场景：数据量非常大、聚合精度要求高、响应速度快的业务场景。

Elasticsearch 聚合性能优化

启用 eager global ordinals 提升高基数聚合性能

eager_global_ordinals | Elasticsearch Guide [7.17] | Elastic

本质：以空间换时间

        为了支持聚合和其他需要按文档查找字段值的操作，Elasticsearch 使用一种称为 doc values的数据结构。基于术语的字段类型（例如）使用序数keyword映射存储其 doc values 以获得更紧凑的表示。此映射的工作原理是根据每个术语的字典顺序为其分配一个增量整数或序数 。字段的 doc values 仅存储每个文档的序数而不是原始术语，并使用单独的查找结构在序数和术语之间进行转换。
        在聚合期间使用序数可以大大提高性能。例如，terms聚合仅依靠序数将文档收集到分片级别的存储桶中，然后在跨分片组合结果时将序数转换回其原始术语值。
        每个索引段都定义自己的序数映射，但聚合会收集整个分片的数据。因此，为了能够使用序数进行聚合等分片级操作，Elasticsearch 创建了一个统一的映射，称为 全局序数。全局序数映射建立在段序数之上，通过为每个段维护从全局序数到本地序数的映射来工作。

适用场景：高基数聚合 。高基数聚合场景中的高基数含义：一个字段包含很大比例的唯一值。

global ordinals 中文翻译成全局序号，是一种数据结构，应用场景如下：

  • 基于 keyword，ip 等字段的分桶聚合，包含：terms聚合、composite 聚合等。
  • 基于text 字段的分桶聚合（前提条件是：fielddata 开启）。
  • 基于父子文档 Join 类型的 has_child 查询和 父聚合。

global ordinals 使用一个数值代表字段中的字符串值，然后为每一个数值分配一个 bucket（分桶）。

global ordinals 的本质是：启用 eager_global_ordinals 时，会在刷新（refresh）分片时构建全局序号。这将构建全局序号的成本从搜索阶段转移到了数据索引化（写入）阶段。

创建索引的同时开启：eager_global_ordinals。

PUT my-index-000001/_mapping
{
  "properties": {
    "tags": {
      "type": "keyword",
      "eager_global_ordinals": true
    }
  }
}

注意：开启 eager_global_ordinals 会影响写入性能，因为每次刷新时都会创建新的全局序号。为了最大程度地减少由于频繁刷新建立全局序号而导致的额外开销，请调大刷新间隔 refresh_interval。

PUT my-index-000001/_settings
{
  "index": {
    "refresh_interval": "30s"
  }

插入数据时对索引进行预排序

Index Sorting | Elasticsearch Guide [7.17] | Elastic

  • Index sorting （索引排序）可用于在插入时对索引进行预排序，而不是在查询时再对索引进行排序，这将提高范围查询（range query）和排序操作的性能。
  • 在 Elasticsearch 中创建新索引时，可以配置如何对每个分片内的段进行排序。
  • 这是 Elasticsearch 6.X 之后版本才有的特性。
PUT my-index-000001
{
  "settings": {
    "index": {
      "sort.field": [ "username", "date" ], 
      "sort.order": [ "asc", "desc" ]       
    }
  },
  "mappings": {
    "properties": {
      "username": {
        "type": "keyword",
        "doc_values": true
      },
      "date": {
        "type": "date"
      }
    }
  }
}

注意：预排序将增加 Elasticsearch 写入的成本。在某些用户特定场景下，开启索引预排序会导致大约 40%-50% 的写性能下降。也就是说，如果用户场景更关注写性能的业务，开启索引预排序不是一个很好的选择。

使用节点查询缓存

Node query cache settings | Elasticsearch Guide [7.17] | Elastic

节点查询缓存（Node query cache）可用于有效缓存过滤器（filter）操作的结果。如果多次执行同一 filter 操作，这将很有效，但是即便更改过滤器中的某一个值，也将意味着需要计算新的过滤器结果。

例如，由于 “now” 值一直在变化，因此无法缓存在过滤器上下文中使用 “now” 的查询。

那怎么使用缓存呢？通过在 now 字段上应用 datemath 格式将其四舍五入到最接近的分钟/小时等，可以使此类请求更具可缓存性，以便可以对筛选结果进行缓存。

PUT /my_index/_doc/1
{
  "create_time":"2022-05-11T16:30:55.328Z"
}

#下面的示例无法使用缓存
GET /my_index/_search
{
  "query":{
    "constant_score": {
      "filter": {
        "range": {
          "create_time": {
            "gte": "now-1h",
            "lte": "now"
          }
        }
      }
    }
  }
}

# 下面的示例就可以使用节点查询缓存。
GET /my_index/_search
{
  "query":{
    "constant_score": {
      "filter": {
        "range": {
          "create_time": {
            "gte": "now-1h/m",
            "lte": "now/m"
          }
        }
      }
    }
  }
}

上述示例中的“now-1h/m” 就是 datemath 的格式。

如果当前时间 now 是：16:31:29，那么range query 将匹配 my_date 介于：15:31:00 和 15:31:59 之间的时间数据。同理，聚合的前半部分 query 中如果有基于时间查询，或者后半部分 aggs 部分中有基于时间聚合的，建议都使用 datemath 方式做缓存处理以优化性能。

使用分片请求缓存

聚合语句中，设置：size：0，就会使用分片请求缓存缓存结果。size = 0 的含义是：只返回聚合结果，不返回查询结果。

GET /es_db/_search
{
  "size": 0,
  "aggs": {
    "remark_agg": {
      "terms": {
        "field": "remark.keyword"
      }
    }
  }
}

拆分聚合，使聚合-并行化

Multi search API | Elasticsearch Guide [7.17] | Elastic

Elasticsearch 查询条件中同时有多个条件聚合，默认情况下聚合不是并行运行的。当为每个聚合提供自己的查询并执行 msearch 时，性能会有显著提升。因此，在 CPU 资源不是瓶颈的前提下，如果想缩短响应时间，可以将多个聚合拆分为多个查询，借助：msearch 实现并行聚合。

GET my-index-000001/_msearch
{ }
{"query" : {"match" : { "message": "this is a test"}}}
{"index": "my-index-000002"}
{"query" : {"match_all" : {}}}

#常规的多条件聚合实现
GET /member/_search
{
  "size": 0,
  "aggs": {
    "job_agg": {
      "terms": {
        "field": "job.keyword"
      }
    },
    "max_salary":{
      "max": {
        "field": "salary"
      }
    }
  }
}
# msearch 拆分多个语句的聚合实现
GET _msearch
{"index":"member"}
{"size":0,"aggs":{"job_agg":{"terms":{"field": "job.keyword"}}}}
{"index":"member"}
{"size":0,"aggs":{"max_salary":{"max":{"field": "salary"}}}}

标签：salary,聚合,field,job,ElasticSearch,aggs,操作,size
From： https://blog.csdn.net/weixin_49862903/article/details/139248208

相关文章

  • 现代操作系统第三章读书笔记
    现代操作系统第三章读书笔记***3.3.1分页3.4页面置换算法3.5分页系统中的设计问题前面讨论了分页系统如何工作，介绍了基本的页面置换算法。当然，只了解基本机制是不够的。要设计一个系统，必须知道如何是这个系统工作的更好，需要从全局考虑一些问题。下面是一些能过使得整个系统......
  • 美业SaaS收银系统源码-已过期卡项需要延期怎么操作？美业系统实操
    美业SaaS系统连锁多门店美业收银系统源码多门店管理/会员管理/预约管理/排班管理/商品管理/ 促销活动PC管理后台、手机APP、iPadAPP、微信小程序1.询问会员手机号和需要延期的卡项2.PC运营后端-数据导入-修改已售卡项，搜索手机号3.把需要卡项选中，点击【批量修......
  • 为什么在相机进行投影变换前要进行齐次操作?
    https://blog.csdn.net/zhuiqiuzhuoyue583/article/details/95230246#:~:text=这就是引入齐次坐标的作用，把各种变换都统一了起来，即把缩放，旋转，平移等变换都统一起来，都表示成一连串的矩阵相乘的形式。保证了形式上的线性一致性。简短的解释：齐次坐标就是将一个原本是n维的向量......
  • 阿赵UE引擎C++编程学习笔记——文件夹操作和文件读写
      大家好，我是阿赵。  这次学习一下在UE里面使用C++的API操作文件读写和文件夹操作。一、UE引擎获取相关路径  获取到路径一般是相对路径，使用FPaths::ConvertRelativePathToFull转换后，可以获得完整的绝对路径。FStringcontentDir=FPaths::ProjectContentDir();......
  • 听说部门来了个00后自动化测试，一顿操作给我整麻了
    公司新来了个同事，听说大学是学的广告专业，因为喜欢IT行业就找了个培训班，后来在一家小公司实习半年，现在跳槽来我们公司。来了之后把现有项目的性能优化了一遍，服务器缩减一半，性能反而提升4倍！给公司省了不少成本。后来才知道，他在以前的公司，业务能力特别强，JVM调优经验丰富。在他......
  • 【SCAU操作系统】实验二页面置换算法的模拟实现及命中率对比python源代码及实验报告参
    一、课程设计目的通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理中的页面置换算法。二、课程设计内容模拟实现OPT（最佳置换）、FIFO和LRU算法，并计算缺页率。三、要求及提示1、首先用随机数生成函数......
  • TV RecyclerView 滑动后操作保持落焦在左侧第一个View
     在recyclerview中，想要无论滑动到哪，每次按遥控器落焦，需要落焦在左侧第一个item上面，如果不能触屏还好，触屏会导致焦点丢失根据系统的反馈，如果你滑动了列表，刚好列表的item卡在一半的位置，此时系统的落焦规则，不一定会到第一个之前试过一个效果一般的方案，就是通过 findFirstV......
  • pycharm操作push推送失败，提示用户认证失败解决方案
    方法一：首先切换输入法为windows自带，然后切换成英文，输入账户跟密码，尝试再次push，查看是否可以正常push方法二：打开项目文件夹在文件夹右击，点击“Gitbashhere” 打开Gitbash，输入push或pull命令，gitpushorigininsure_gly，切换输入法为windows自带，然后切换成英文，输入账户跟密......
  • Python学习笔记-文件操作与CSV格式
    文件打开和关闭程序中的数据都存储在内存中，当程序执行完毕后，内存中的数据将丢失。文件可以用来进行数据的长期保存。open函数打开一个要做读/写操作的文件，打开文件后会返回一个文件对象，利用该文件对象可完成数据的读写操作。其常用形式为：open(filename,mode='r')#file......
  • Linux与Windows：操作系统的选择与个人体验
            在我使用Linux和Windows这两种操作系统的过程中，我发现了一些让我感到顺理成章或者费解的地方。Linux和Windows各有其优势和劣势，每个人对它们的偏好也不尽相同。在这篇文章中，我将分享我的个人看法和体验，探讨这两种操作系统的特点和使用感受。        ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99