Tindex的原生查询接口是HTTP REST风格查询方式，还有其它客户库查询方式比如：sugo-plyql
使用HTTP REST风格查询（Broker, Historical, 或者 Realtime）节点数据。
查询参数为JSON格式，每个节点类型都会暴露相同的REST查询接口。
对于正常的Tindex操作，应该向Broker节点发出查询。
查询请求示例如下：
curl -X POST '<queryable_host>:<port>/druid/v2/?pretty' -H 'Content-Type:application/json' -d @<query_json_file>queryable_host: Broker节点ip:8082 (http://192.168.0.200:8082)
query_json_file: 查询参数详见Tindex-Query-Json部分
- Tindex-Query-Json 属性详情如下：
数据源相当于数据库中的表。
JSON示例如下：
{
"type":"table",
"name":<string_value>
}
最常用的数据源，<string_value>为源数据源的名称，类似关系数据库中的表名。
JSON示例如下：
{
"type": "union",
"dataSources": [<string_value1>,<string_value2>,... ]
}
该数据源连接两个或多个表数据，<string_value1> <string_value2> 为表数据源的名称。Union DataSource应该有相同的schema。Union Queries应该发送到代理/路由器节点，并不受历史节点直接支持。
JSON示例如下：
{
"type":"query",
"query":{<query>}
}
可以进行查询的嵌套。
Dimension ,即维度。
Dimension类别详情如下：
Default Dimension 返回维度值，并可选择对维度进行重命名。JSON示例如下：
{
"type":"default",
"dimension":"<dimension>",
"outputName":"<output_name>"
}
Extraction Dimension 返回使用给定提取函数转换的维度值。JSON示例如下：
{
"type":"extraction",
"dimension":"<dimension>",
"outputName":"<output_name>",
"extraction":{
<extraction_function>
},
"dimExtractionFn":{
<extraction_function>
}
}
Regex Dimension返回给定正则表达式的第一个匹配组。如果没有匹配，则返回维度值。JSON示例如下：
{
"type":"regex",
"delegate":{
<dimensionSpec>
},
"pattern":"pattern_string"
}
例如，使用"expr" : "(\\w\\w\\w).*"将改变'Monday'，'Tuesday'，'Wednesday'成'Mon'，'Tue'，'Wed'。
ListFiltered Dimension仅适用于多值维度。JSON示例如下：
{
"type":"listFiltered",
"delegate":{
<dimensionSpec>
},
"values":[
"<value_string>","<value_string>",...
],
"isWhitelist":true
}
如果您在druid中有一行具有值为[“v1”，“v2”，“v3”]的多值维度，并且通过该维度使用查询过滤器为值“v1” 发送groupBy / topN查询分组。在响应中，您将获得包含“v1”，“v2”和“v3”的3行。对于某些用例，此行为可能不直观。
Lookup Dimension允许在执行提取时使用的一组键和值。JSON示例如下：
{
"type":"lookup",
"dimension":"<dimensionName>",
"outputName":"<dimensionOutputName>",
"lookup":{
"type":"map",
"map":{
"key1":"value1",
"key2":"value2"
},
"isOneToOne":false
},
"retainMissingValue":false,
"replaceMissingValueWith":"<missing_value>",
"name":"<name_string>",
"optimize":true
}
在查询时可以指定属性retainMissingValue为false，并通过设置replaceMissingValueWith提示如何处理缺失值。
retainMissingValue如果在查找中找不到，设置为true将使用维度的原始值。
默认是replaceMissingValueWith = null，retainMissingValue = false并且导致丢失的值被视为丢失值。
NumericGroup Dimension可以对维度进行指定间隔的数字分组。JSON示例如下：
{
"type": "numericGroup",
"dimension": "<dimensionName>",
"outputName": "<dimensionOutputName>",
"min": 1492153157000,
"max": 1501229310000,
"interval": 86400000,
"granularity": {
"period": "P1D",
"type": "period"
}
}
min和max为数字的边界，interval 为每个分组的间隔，这里period为P1D,即为以一天为周期进行聚合。
CustomGroup Dimension可以对维度进行自定义分组。JSON示例如下：
{
"type": "customGroup",
"dimension": "event_time",
"outputName": "test_time",
"groups": [
{
"name": "2017-06-01~2017-06-02",
"lower": 1496246400000,
"upper": 1496332800000
},
{
"name": "2017-06-03~2017-06-04",
"lower": 1499011200000,
"upper": 1499097600000
}
],
"outOfBound": true
}
groups为分组列表，可以存放多个分组。其中，name为分组的名字，lower和upper为边界。outOfBound超出边界的是否存放到另外一个分组里。
NumericGroupBy Dimension可以对维度进行间隔为1分组。JSON示例如下：
{
"type": "NumericGroupBy",
"dimension": "event_time",
"outputName": "test_time",
"maxCardinality":1000,
"granularity": {
"period": "P1D",
"type": "period"
}
}
maxCardinality为维度基数, 这里period为P1D,即为以一天为周期进行聚合。
在查询中指定时间区间。Interval中的时间是ISO-8601格式。对于中国用户，所在时区为东8区，因此需要在时间中加入“+08:00”。 如"2015-12-31T16:00:00+08:00 / 2017-04-14T15:59:59+08:00"。
JSON示例如下：
{
"type":"intervals",
"intervals":[<interval>,<interval>,...]
}
Segments Interval可以定义多个段，JSON示例如下：
{
"type":"segments",
"segments":[
{
"itvl":{<interval>},
"ver":"version",
"part":100
},
{
"itvl":{<interval>},
"ver":"version",
"part":200
}
]
}
Filter,即过滤器，在查询语句中是一个JSON对象，用来对维度进行筛选，表示维度满足Filter的行是我们需要的数据。它基本上等同于SQL中的WHERE子句。
Filter类别详情如下：
Seletor Filter是最简单的过滤器，它将与具体值匹配，功能类似于SQL中的where key=value，支持提取功能。Seletor Filter的JSON示例如下：
"filter":{
"type":"selector",
"dimension":<dimension_string>,
"value":<value_string>,
"extractionFn":{<extractionFn>}
}
上面的参数设置这相当于 WHERE <dimension_string> = <value_string>。
使用示例如下：
"filter": {
"type": "selector",
"dimension": "province",
"value": "广东省"
}
相当于 WHERE province = ＂广东省＂。
Regex Filter允许用户用正则表达式来筛选维度，任何标准的Java正则表达式Druid都支持，支持使用提取功能。Regex Filter的JSON示例如下：
"filter":{
"type":"regex",
"dimension":<dimension_string>,
"pattern":<pattern_string>,
"extractionFn":{<extractionFn>}
}
pattern：给定的模式，可以是任何标准的Java正则表达式。
使用示例如下:
"filter": {
"type": "regex",
"dimension": "UserID",
"pattern": "^c.*"
}
以上实例将匹配任何以"c"开头的"userId"。
Logical Expression Filer包含and、or、not三种过滤器，与SQL中的and、or、not相似。每一种过滤器都支持嵌套，可以构建丰富的逻辑表达式。
And Filter的JSON示例如下：
"filter"：{
"type":"and",
"fields":[<filter>, <filter>, ...]
}
<filter>可以是任何一种过滤器。
使用示例如下：
"filter": {
"type": "and",
"fields": [
{
"type": "selector",
"dimension": "age",
"value": 20
},
{
"type": "selector",
"dimension": "province",
"value": "广东省"
}
]
}
相当于：WHERE age=20 AND province="广东省"
Or Filter的JSON示例如下：
"filter"：{
"type":"or",
"fields":[
"fields":[<filter>, <filter>, ...]
}
<filter>可以是任何一种过滤器。
使用示例如下：
"filter": {
"type": "or",
"fields": [
{
"type": "selector",
"dimension": "age",
"value": 20
},
{
"type": "selector",
"dimension": "province",
"value": "广东省"
}
]
}
相当于：WHERE age=20 OR province="广东省"
Not Filter的JSON示例如下：
"filter"：{
"type":"not",
"field":<filter>
}
<filter>可以是任何一种过滤器。
使用示例如下：
"filter": {
"type": "not",
"field": {
"type": "selector",
"dimension": "age",
"value": 20
}
}
相当于选出age不等于20的记录。
Search Filter通过字符串匹配过滤维度，支持多种匹配方式。Search Filter的JSON示例如下：
"filter"：{
"type":"search",
"dimension":<dimension_string>,
"query":{
"type":"contains",
"value":<value_string>,
"caseSensitive":<false | true>
},
"extractionFn":{<extractionFn>}
}
使用实例如下：
"filter":{
"type":"search",
"dimension":"province",
"query":{
"type":"contains",
"value":"东",
"caseSensitive":true
}
}
若省份名字包含"东"字,则匹配。
Search Query定义了如下几种字符串匹配方式。
1. contains
如果指定的维度的值包含给定的字符串，则匹配。JSON示例如下：
"query":{
"type":"contains",
"value":<value_string>,
"caseSensitive":<false | true>
}
caseSensitive：是否大小写敏感
2.insensitive_contains
如果指定的维度的值包含给定的字符串，则匹配，不区分大小写。相当于contains中的caseSensitive设置为false。insensitive_contains的JSON示例如下：
"query":{
"type":"insensitive_contains",
"value":<value_string>
}
3. fragment
如果指定的维度的值的任意部分包含给定的字符串，则匹配。fragment的JSON示例如下：
"query":{
"type":"fragment",
"values":[<value_string>,<value_string>,...],
"caseSensitive":<false | true>
}
4. regex
如果指定的维度的值与正则表达式匹配，则匹配。regex的JSON示例如下：
"query":{
"type":"regex",
"pattern":<pattern_string>
}
In Filter类似于SQL中的in。只支持字符串类型的维度。In Filter的JSON示例如下：
"filter":{
"type":"in",
"dimension":<dimension_string>,
"values":[<value_string>,<value_string>,...],
"extractionFn":{
{extractionFn}
}
}
- values: in的范围。
使用实例如下：
"filter": {
"type": "in",
"dimension": "province",
"values": [
"广东省",
"广西省"
]
}
相当于： WHERE province IN ("广东省","广西省")
Bound Filter 其实就是比较过滤器，包含“大于”、“小于”和“等于”三种算子。Bound Filter 默认是字符串比较，并基于字典序。如果要使用数字比较，则需要在查询中设定alphaNumeric的值为true。Bound Filter默认的大小比较为“>=”或“<=”。Bound Filter具体的JSON表达式示例如下：
"filter":{
"type":"bound",
"dimension":<dimension_string>,
"lower":"0",
"upper":"100",
"lowerStrict":<false | true>,
"upperStrict":<false | true>,
"alphaNumeric":<false | true>,
"extractionFn":{<extractionFn>}
}
lowerStrict：是否包含下界upperStrict：是否包含上界alphaNumeric：是否进行数值比较
使用示例如下：
"filter": {
"type": "bound",
"dimension": "age",
"alphaNumeric": true,
"upper": 20,
"upperStrict": true
}
相当于：WHERE age<20 。
如果上述Filter不能满足要求，Druid还可以通过自己写JavaScript Filter来过滤维度，但是只能支持一个入参，就是Filter里指定的维度的值，返回true或false。JavaScript Filter的JSON表达式实例如下：
"filter":{
"type":"javascript",
"dimension":<dimension_string>,
"function":<function_string>,
"extractionFn":{<extractionFn>}
}
dimension: 函数的参数（只能有一个）
使用示例如下：
{
"type":"javascript",
"dimension":"name",
"function":"function(x) { return(x >= 'bar' && x <= 'foo') }"
}
上面的例子可匹配任何name在'bar'和'foo'之间的维度值。
Spatial Filter，即为空间过滤器，JSON表达式示例如下：
"filter":{
"type":"spatial",
"dimension":<dimension_string>,
"bound":<bound>
}
spatial.bound.type，即边界类型，目前支持两种：rectangular，radius
1. Rectangular
Rectangular,即为矩形，JSON示例如下：
"bound":{
"type":"rectangular",
"minCoords":[4.5,5.3],
"maxCoords":[2.3,5.6],
"limit":50
}
- minCoords: 最小坐标轴列表 [x,y,z,...]
- maxCoords: 最大坐标轴列表 [x,y,z,...]
2. Radius
Radius,即为半径，JSON示例如下：
"bound":{
"type":"radius",
"coords":[4.5,5.3],
"radius":[2.3,5.6],
"limit":50
}
coords: 原点坐标 [x,y,z,...]radius: 浮点表示的半径值 [x,y,z,...]
All Filter匹配所有维度值，JSON示例如下：
{
"type":"all"
}
Lookup Filter用于检查该维度的值是否存在于指定的用户分群中。JSON示例如下：
{
"type":"lookup",
"dimension":<dimension_string>,
"lookup":<lookup_string>
}
dimension: 维度名，一般是用户id或设备id。lookup: 用户分群id
使用示例如下：
{
"type":"lookup",
"dimension":"userId",
"lookup":"usergroup-gdsfrex1"
}
Lucene Filter支持lucene格式的查询语法，用于过滤不满足条件的数据。JSON示例如下：
{
"type":"lucene",
"query":<query_string>
}
query: 满足lucene格式的查询字符串。
1.使用示例如下：
{
"type":"lucene",
"query":"userId:10001"
}
查询userId=10001的记录，相当于WHERE userId='10001'。
2.使用lucene查询实现过滤维度值不为null的记录，示例如下：
{
"type": "not",
"field": {
"type": "lucene",
"query": "(*:* NOT address:*)"
}
}
查询address不为null的记录，相当于where address is not null。
用于过滤null，。JSON示例如下：
"filter": {
"type": "not",
"field": {
"type": "lucene",
"query": "(*:* NOT Province:*)"
}
}
用于过滤null和空字符串，。JSON示例如下：
"filter": {
"type": "and",
"fields": [
{
"type": "lucene",
"query": "(*:* NOT Province:*)"
},
{
"type": "selector",
"dimension": "Province",
"value": ""
}
]
}
Extraction,即提取过滤器，使用一些特定的提取函数匹配维度。
Extraction类别详情如下：
Regex Extraction返回给定正则表达式的第一个匹配组。如果没有匹配，则返回维度值。JSON示例如下：
"extractionFn":{
"type":"regex",
"expr":<expr_string>,
"replaceMissingValue":<false | true>,
"replaceMissingValueWith":<replace_string>
}
如果正则表达式匹配，返回维度值不变，否则返回null。JSON示例如下：
"extractionFn":{
"type":"partial",
"expr":<expr_string>
}
如果给定SearchQuerySpec匹配，返回维度值不变，否则返回null。JSON示例如下：
"extractionFn":{
"type":"searchQuery",
"query":{
"type":"contains",
"value":<value_string>,
"caseSensitive":<false | true>
}
}
Javascript Extraction返回由给定的JavaScript函数转换的维度值。JSON示例如下：
"extractionFn":{
"type":"javascript",
"query":{
"type":"contains",
"function":<function_string>,
"injective":<false | true>
}
}
TimeFormat Extraction以特定格式，时区或语言环境来提取时间戳。JSON示例如下：
"extractionFn":{
"type":"timeFormat",
"query":{
"type":"contains",
"format":<pattern_string>,
"timeZone":{<dateTimeZone>},
"locale":<locale_string>
}
}
timeZone:时区locale:地点
example
"filter": {
"type": "selector",
"dimension": "__time",
"value": "Friday",
"extractionFn": {
"type": "timeFormat",
"format": "EEEE",
"timeZone": "America/New_York",
"locale": "en"
}
}
JSON示例如下：
"extractionFn":{
"type":"identity"
}
JSON示例如下：
"extractionFn":{
"type":"lookup",
"lookup": {
"lookup":<lookup>,
"retainMissingValue":<false | true>
"replaceMissingValueWith":<replaceMissingValueWith_string>,
"injective":<false | true>,
"optimize":<false | true>
},
"retainMissingValue":<false | true>,
"replaceMissingValueWith":<replace_string>,
"injective":<false | true>,
"optimize":<false | true>
}
使用示例如下:
"filter": {
"type": "selector",
"dimension": "product",
"value": "bar_1",
"extractionFn": {
"type": "lookup",
"lookup": {
"type": "map",
"map": {
"product_1": "bar_1",
"product_5": "bar_1",
"product_3": "bar_1"
}
}
}
}
JSON示例如下：
"extractionFn":{
"type":"registeredLookup",
"lookup":<lookup_string>,
"retainMissingValue":<false | true>,
"replaceMissingValueWith":<replace_string>,
"injective":<false | true>,
"optimize":<false | true>,
}
SubString Extraction返回从提供的索引开始至所需长度的子字符串。JSON示例如下：
"extractionFn":{
"type":"substring",
"index":10,
"length":20
}
Cascade Extraction按指定的顺序将指定的提取函数转换为维度值。JSON示例如下：
"extractionFn":{
"type":"cascade",
"extractionFns":[{<extraction>},{<extraction>}]
}
StringFormat Extraction返回根据给定的格式字符串格式化的维度值。JSON示例如下：
"extractionFn":{
"type":"stringFormat",
"format":<format_string>,
"nullHandling":{<nullHandling>}
}
Upper Extraction返回大写的维度值。JSON示例如下：
"extractionFn":{
"type":"upper",
"locale":<locale_string>
}
Lower Extraction返回小写的维度值。JSON示例如下：
"extractionFn":{
"type":"lower",
"locale":<locale_string>
}
Aggregation类别详情如下：
用于计算Druid的数据行数，相当于count()。Count Aggregation的JSON示例如下：
"aggregations": [
{
"type":"lucene_count",
"name":<name_string>
}
]
使用示例如下:
"aggregations": [
{
"type": "lucene_count",
"name": "__VALUE__"
}
]
在查询时，Cardinality Aggregation使用HyperLogLog算法计算给定维度集合的基数，相当于distinct()。Cardinality Aggregation 的JSON示例如下：
"aggregations": [
{
"type":"lucene_cardinality",
"name":<name_string>,
"fieldNames":[<fieldName_string>,<fieldName_string>,...],
"byRow":<false | true>
}
]
当设置byRow为false（默认值）时，它计算由所有给定维度的所有维度值的并集组成的集合的基数。
在查询时，HyperUnique Aggregation 使用HyperLogLog算法计算给定维度集合的基数。JSON示例如下：
"aggregations":[
{
"type":"lucene_hyperUnique",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
使用示例如下:
"aggregations":[
{
"type":"lucene_hyperUnique",
"name":"ageCount",
"fieldName":"age"
}
]
查询结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"user": 20.098296726168925
}
}
]
结果的最大值，该值类型为 double ，维度的类型支持 int,long,float,相当于max(<fieldName_string>)。JSON示例如下：
"aggregations":[
{
"type":"lucene_doubleMax",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 结果输出的名称fieldName- 维度的名称
使用示例如下:
"aggregations": [
{
"type":"lucene_doubleMax",
"name":"max",
"fieldName":"age"
}
]
返回结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"max": 29
}
}
]
结果的最小值，该值类型为double，输入的值类型为int,long,float,相当于min(<fieldName_string>)。JSON示例如下：
"aggregations": [
{
"type":"lucene_doubleMin",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 结果输出的名称fieldName- 求最小值的列的名称
将查询到的值的和计算为double类型的数，输入的值类型为int,long,float,相当于sum(<fieldName_string>)。JSON示例如下：
"aggregations": [
{
"type":"lucene_doubleSum",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 求和值的输出名称fieldName- 维度的名称
结果的最大值，该值类型为64位有符号整数，输入的值类型为int,long，相当于max(<fieldName_string>)。JSON示例如下：
"aggregations": [
{
"type":"lucene_longMax",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 结果输出的名称fieldName- 维度的名称
结果的最小值，该值类型为64位有符号整数，输入的值类型为int,long，相当于min(<fieldName_string>)。JSON示例如下：
"aggregations": [
{
"type":"lucene_longMin",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 结果输出的名称fieldName- 维度的名称
结果的的和，该值类型为64位有符号整数，输入的值类型为int,long，相当于sum(<fieldName_string>) 。JSON示例如下：
"aggregations": [
{
"type":"lucene_longSum",
"name":<name_string>,
"fieldName":<fieldName_string>
}
]
name- 结果输出的名称fieldName- 维度的名称
如果上述聚合器无法满足需求，Druid还提供了JavaScript Aggregation。用户可以自己写JavaScript function，其中指定的列即为function的入参。JavaScript Aggregation 的JSON示例如下：
"aggregations": [
{
"type":"lucene_javascript",
"name":<name_string>,
"fieldNames":[<fieldName_string>,<fieldName_string>],
"fnAggregate":<fnAggregate_string>,
"fnReset":<fnReset_string>,
"fnCombine":<fnCombine_string>
}
]
name:这组JavaScript函数的名称fieldNames:参数的名字
使用示例如下:
"aggregations": [
{
"type": "lucene_javascript",
"name": "sum(log(x)*y) + 10",
"fieldNames": ["x", "y"],
"fnAggregate" : "function(current, a, b) { return current + (Math.log(a) * b); }",
"fnCombine" : "function(partialA, partialB) { return partialA + partialB; }",
"fnReset" : "function() { return 10; }"
}
]
结果的最小值，该值类型为date, 输入的值的类型必须是date。DateMin Aggregation的JSON示例如下：
"aggregations": [
{
"type":"lucene_dateMin",
"name":"<name_string>",
"fieldName":"<fieldName_string>"
}
]
使用示例如下:
"aggregations": [
{
"type":"lucene_dateMin",
"name":"minDate",
"fieldName":"birthday"
}
]
查询结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"minDate": "1988-05-17T07:36:52.046Z"
}
}
]
结果的最小值，该值类型为date,输入的值的类型必须是date。DateMax Aggregation 的JSON示例如下：
"aggregations": [
{
"type":"lucene_dateMax",
"name":"<name_string>",
"fieldName":"<fieldName_string>"
}
]
Filtered Aggregation可以在aggregation中指定Filter规则。只对满足规则的维度进行聚合，以提升聚合效率。JSON示例如下：
"aggregations": [
{
"type":"lucene_filtered",
"aggregator":<aggregator>,
"filter":"<filter>
}
]
使用示例如下:
"aggregations":[
{
"type":"lucene_filtered",
"aggregator": {
"type": "lucene_count",
"name": "__VALUE__"
},
"filter": {
"type": "bound",
"dimension": "age",
"alphaNumeric": true,
"upper": 20,
"upperStrict": true
}
}
]
该聚合只对age<20的记录实行。
查询结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"__VALUE__": 50094
}
}
]
ThetaSketch Aggregation的JSON示例如下：
"aggregations": [
{
"type":"lucene_thetaSketch",
"name":"<name_string>",
"fieldName":"<fieldName_string>"
"size":10,
"shouldFinalize":true,
"isInputThetaSketch":true,
"errorBoundsStdDev":5,
"trunc":true
}
]
PostAggregation可以对Aggregation的结果进行二次加工并输出。最终的输出既包含Aggregation的结果，也包含PostAggregation的结果。使用PostAggregation必须包含Aggregation。
PostAggregation类别详情如下：
Arithmetic PostAggregation支持对Aggregation的结果和其他Arithmetic PostAggregation的结果进行“ + ”，“ - ”，“ * ”，“ / ”和“ quotient ”计算，quotient划分的行为像常规小数点的划分。
"postAggregations":{
"type":"arithmetic",
"name":<name_string>,
"fn":<fnName_string>,
"fields":[<postAggregator>,<postAggregator>...],
"ordering":<ordering_string>
}
- 对于“/”，如果分母为0，则返回0。
“quotient”不判断分母是否为0。- 当
Arithmetic PostAggregation的结果参与排序时，默认使用float类型。用户可以手动通过Ordering字段指定排序方式。
使用示例如下:
"postAggregations":[
{
"type":"arithmetic",
"name":"age",
"fn":"-",
"fields":[
{
"type":"hyperUniqueCardinality",
"fieldName":"max(age)"
},
{
"type":"hyperUniqueCardinality",
"fieldName":"min(age)"
}
],
"ordering":<ordering_string>
}
]
以上示例可以计算最大年龄和最小年龄之间的年龄差。
FieldAccess PostAggregation返回指定的Aggregation的值，在PostAggregation中大部分情况下使用fieldAccess来访问Aggregation。在fieldName中指定Aggregation里定义的name，如果对HyperUnique的结果进行访问，则需要使用hyperUniqueCardinality。FieldAccess PostAggregation的JSON示例如下：
"postAggregations":[
{
"type":"fieldAccess",
"name":<output_name>,
"fieldName":<aggregator_name>
}
]
使用示例如下:
"postAggregations":[
{
"type":"fieldAccess",
"name":"field",
"fieldName":"__VALUE__"
}
]
结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"field": 100000,
"__VALUE__": 100000
}
}
]
Constant PostAggregation会多返回一个常数，比如100。可以将Aggregation返回的结果转换为百分比。JSON示例如下：
"postAggregations":[
{
"type":"constant",
"name":<output_name>,
"value":<numerical_value>
}
]
使用示例如下:
"postAggregations":[
{
"type":"constant",
"name":"num",
"value":10
}
]
结果如下:
[
{
"timestamp": "2017-01-01T00:00:00.000Z",
"result": {
"num": 10,
"__VALUE__": 100000
}
}
]
HyperUniqueCardinality PostAggregation得到HyperUnique Aggregation的结果，使之参与到PostAggregation的计算中。JSON示例如下：
"postAggregations":[
{
"type":"lucene_hyperUniqueCardinality",
"name":<output name>,
"fieldName":<the name field value of the hyperUnique aggregator>
}
]
Druid DataSketch是基于Yahoo开源的Sketch包实现的数据近似计算功能。
SketchEstimate PostAggregation用于计算Sketch的估计值，JSON示例如下：
"postAggregations":[
{
"type":"lucene_sketchEstimate",
"name":"<name_string>",
"field":{<postAggregator>}
}
]
SketchSetOper PostAggregation用于Sketch的集合运算，JSON示例如下：
"postAggregations":[
{
"type":"lucene_sketchSetOper",
"name":"<name_string>",
"func":"<func_string>",
"size":20,
"fields":[<postAggregator>,<postAggregator>,...]
}
]
Javascript PostAggregation将提供的JavaScript函数应用于给定字段，JSON示例如下：
"postAggregations":[
{
"type":"javascript",
"name":"<output_name>",
"fieldNames":["<aggregator_name>","<aggregator_name>",...],
"function":"<javascript function>"
}
]
使用示例如下:
"postAggregations":[
{
"type": "javascript",
"name": "absPercent",
"fieldNames": ["delta", "total"],
"function": "function(delta, total) { return 100 * Math.abs(delta) / total; }"
}
]
Max PostAggregation用于计算最大值，JSON示例如下：
"postAggregations":[
{
"type":"max",
"name":"<output_name>",
"fieldName":"<post_aggregator>"
}
]
Min PostAggregation用于计算最小值，JSON示例如下：
"postAggregations":[
{
"type":"min",
"name":"<output_name>",
"fieldName":"<post_aggregator>"
}
]
类似于SQL中的having操作，对GroupBy的结果进行筛选。
having类别详情如下：
和，JSON示例如下：
{
"type":"and",
"havingSpecs":[<havingSpec>,<havingSpec>,..]
}
或，JSON示例如下：
{
"type":"or",
"havingSpecs":[<havingSpec>,<havingSpec>,..]
}
非，JSON示例如下：
{
"type":"not",
"havingSpecs":{<havingSpec>}
}
等于，JSON示例如下：
{
"type":"equalTo",
"aggregation":"aggName",
"value":10
}
大于，JSON示例如下：
{
"type":"greaterThan",
"aggregation":"aggName",
"value":10
}
小于，JSON示例如下：
{
"type":"lessThan",
"aggregation":"aggName",
"value":10
}
DimSelector将匹配尺寸值等于指定值的行，JSON示例如下：
{
"type":"dimSelector",
"dimension":"dimName",
"value":<value_string>,
"extractionFn":{<extractionFn>}
}
总是，即不进行筛选，全部返回，JSON示例如下：
{
"type":"always",
}