关于java:Apache-Druid数据查询套件详解计数排名和分位数计算送JSONoverHTTP和SQL两种查询详解

数据查问

明天这篇文章是之前两篇文章的续篇，所以，大家如果间接上来干，干不懂的话，就须要先去理解下之前的两篇文章，尽管跟上两篇文章关联性不是很强，但还是有肯定关系。

提醒到此结束！

欲看此文，必看如下两篇文章：

1. 【超具体】Apache Durid 从入门到装置具体教程
2. Apache Druid 数据摄取 — 本地数据和 kafka 流式数据

Druid 反对 JSON-over-HTTP 和 SQL 两种查问形式。除了规范的 SQL 操作外，Druid 还反对大量的唯一性操作，利用 Druid 提供的算法套件能够疾速的进行计数，排名和分位数计算。

5.1 筹备工作

5.1.1 导入大量数据

筹备大量数据提供查问, 咱们插入 1 万条随机打车数据

http://localhost:8010/taxi/batchTask/100000

5.2.2 查看数据摄取过程

咱们发现数据摄取过程正在运行，能够期待数据摄取工作完结

5.3 原生查问

Druid 最开始的时候是不反对 SQL 查问的，原生查问是通过查问 Broker 提供的 http server 来实现的

5.3.1 查问语法

curl -L -H'Content-Type:application/json' -XPOST --data-binary  @<query_json_file> <queryable_host>:<port>/druid/v2/?pretty

5.3.2 查问案例

5.3.2.1 编辑查问 JSON

# 创立查问目录
mkdir query
# 编辑查问的 JSON
vi query/filter1.json

json 内容如下

{
    "queryType":"timeseries",
    "dataSource":"message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{"type":"selector","dimension":"status","value":1},
    "intervals":["2021-06-07/2022-06-07"]
}

5.3.2.2 参数解释

• queryType：查问类型，timeseries 代表工夫序列查问
• dataSource：数据源，指定须要查问的数据源是什么
• granularity：分组粒度，指定须要进行分组的粒度是什么样的
• aggregations：聚合查问：外面咱们聚合了 count，对数据进行统计
• filter：数据过滤，须要查问那些数据
• intervals：查问工夫的范畴，留神工夫范畴是前闭后开的，前面的日期是查问不到的

5.3.2.3 执行查问命令

在命名行中执行上面的命令会将查问 json 发送到对应的 broker 中进行查问 --data-binary 指定的查问 json 的门路

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter1.json http://192.168.64.177:8082/druid/v2/?pretty

咱们查问了每个月发动打车的人数有多少

5.4 查问类型

druid 查问采纳的是 HTTP RESTFUL 形式，REST 接口负责接管客户端的查问申请，客户端只须要将查问条件封装成 JSON 格局，通过 HTTP 形式将 JSON 查问条件发送到 broker 节点，查问胜利会返回 JSON 格局的后果数据。理解一下 druid 提供的查问类型

5.4.1 工夫序列查问

timeseries 工夫序列查问对于指定时间段依照查问规定返回聚合后的后果集，查问规定中能够设置查问粒度，后果排序形式以及过滤条件，过滤条件能够应用嵌套过滤，并且反对后聚合。

5.4.1.1 查问属性

工夫序列查问次要包含 7 个次要局部

5.4.1.2 案例

{
    "queryType":"topN",
    "dataSource":"taxi_message",
    "dimension":"local",
    "threshold":2,
    "metric":"age",
    "granularity":"month",
    "aggregations":[
     {
        "type":"longMin",
        "name":"age",
        "fieldName":"age"
     }
     ],
    "filter":{"type":"selector","dimension":"sex","value":"女"},
    "intervals":["2021-06-07/2022-06-07"]
}

5.4.2 TopN 查问

topn 查问是通过给定的规定和显示维度返回一个后果集，topn 查问能够看做是给定排序规定，返回繁多维度的 group by 查问，然而 topn 查问比 group by 性能更快。metric 这个属性是 topn 专属的依照该指标排序。

5.4.2.1 查问属性

topn 的查问属性如下

5.4.2.2 案例

查问每个季度年龄最小的女性的前两个的城市

vi query/topN.json

{
    "queryType":"topN",
    "dataSource":"message",
    "dimension":"local",
    "threshold":2,
    "metric":"age",
    "granularity":"quarter",
    "aggregations":[
     {
            "type":"longMin",
            "name":"age",
             "fieldName":"age"
     }
      ],
    "filter":{"type":"selector","dimension":"sex","value":"女"},
    "intervals":["2021-06-07/2022-06-07"]
}

5.4.2.3 执行查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/topN.json http://192.168.64.177:8082/druid/v2/?pretty

5.4.5 分组查问

在理论利用中常常须要进行分组查问，等同于 sql 语句中的 Group by 查问，如果对单个维度和指标进行分组聚合计算，举荐应用 topN 查问，可能取得更高的查问性能，分组查问适宜多维度，多指标聚合查问

5.4.5.1 查问属性

下表内容为一个 GroupBy 查问的次要局部：

5.4.5.2 案例

每一季度统计年龄在 21-31 的男女打车的数量

vi query/groupBy.json

{
    "queryType":"groupBy",
    "dataSource":"taxi_message",
    "granularity":"Quarter",
    "dimensions":["sex"],
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2022-06-07"]
}

5.4.5.3 执行查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/groupBy.json http://192.168.64.177:8082/druid/v2/?pretty

5.5 查问组件

在介绍具体的查问之前，咱们先来理解一下各种查问都会用到的根本组件，如 Filter,Aggregator,Post-Aggregator,Query,Interval 等，每种组件都蕴含很多的细节

5.5.1 Filter

Filter 就是过滤器，在查问语句中就是一个 JSON 对象，用来对维度进行筛选和过滤，示意维度满足 Filter 的行是咱们须要的数据，相似 sql 中的 where 字句。Filter 蕴含的类型如下：

5.5.1.1 抉择过滤器

Selector Filter 的性能相似于 SQL 中的where key=value, 它的 json 示例如下

"Filter":{"type":"selector","dimension":dimension_name,"value":target_value}

应用案例

vi query/filter1.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{"type":"selector","dimension":"status","value":1},
    "intervals":["2021-06-07/2022-06-07"]
}

5.5.1.2 正则过滤器

Regex Filter 容许用户应用正则表达式进行维度的过滤筛选，任何 java 反对的规范正则表达式 druid 都反对，它的 JSON 格局如下：

"filter":{"type":"regex","dimension":dimension_name,"pattern":regex}

应用案例，咱们搜寻姓名蕴含数字的的用户进行聚合统计

vi query/filter2.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{"type":"regex","dimension":"username","pattern":"[0-9]{1,}"},
    "intervals":["2021-06-07/2022-06-07"]
}

执行查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter2.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.1.3 逻辑过滤器

Logincal Expression Filter 蕴含 and,not,or 三种过滤器，每一种都反对嵌套，能够构建丰盛的逻辑表达式，与 sql 中的 and,not,or 相似，JSON 表达式如下：

"filter":{"type":"and","fields":[filter1,filter2]}
"filter":{"type":"or","fields":[filter1,filter2]}
"filter":{"type":"not","fields":[filter]}

应用案例，咱们查问每一个月，进行打车并且是女性的数量

vi query/filter3.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"and",
        "fields":[{"type":"selector","dimension":"status","value":1},
            {"type":"selector","dimension":"sex","value":"女"}
        ]
    },
    "intervals":["2021-06-07/2022-06-07"]
}

进行数据查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter3.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.1.4 蕴含过滤器

In Filter 相似于 SQL 中的 in，比方 where username in(‘zhangsan’,’lisi’,’zhaoliu’)，它的 JSON 格局如下：

{
    "type":"in",
    "dimension":"local",
    "values":['四川省','江西省','福建省']
}

应用案例，咱们查问每一个月，在四川省、江西省、福建省打车的人数

vi query/filter4.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"in",
        "dimension":"local",
        "values":["四川省","江西省","福建省"]
    },
    "intervals":["2021-06-07/2022-06-07"]
}

进行数据查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter4.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.1.5 区间过滤器

Bound Filter 是比拟过滤器，蕴含大于，等于，小于三种，它默认反对的就是字符串比拟，是基于字典程序，如果应用数字进行比拟，须要在查问中设定 alpaNumeric 的值为 true，须要留神的是 Bound Filter 默认的大小比拟为 >= 或者 <=，因而如果应用 < 或 >, 须要指定 lowerStrict 值为 true，或者 upperStrict 值为 true, 它的 JSON 格局如下: 21 <=age<=31

{
"type":"bound",
"dimension":"age",
"lower":"21",  #默认蕴含等于
"upper":"31",  #默认蕴含等于
"alphaNumeric":true #数字比拟时指定 alphaNumeric 为 true
}

应用案例，咱们查问每一个月，年龄在 21-31 之间打车人的数量

vi query/filter5.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"month",
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2022-06-07"]
}

进行数据查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter5.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.2 聚合粒度

聚合粒度通过 granularity 配置项指定聚合时间跨度，时间跨度范畴要大于等于创立索引时设置的索引粒度，druid 提供了三种类型的聚合粒度别离是：Simple,Duration,Period

5.5.2.1 Simple 的聚合粒度

Simple 的聚合粒度通过 druid 提供的固定工夫粒度进行聚合，以字符串示意，定义查问规定的时候不须要显示设置 type 配置项，druid 提供的罕用 Simple 粒度：

all,none,minute,fifteen_minute,thirty_minute,hour,day,month,Quarter（季度）,year；

• all：会将起始和完结工夫内所有数据聚合到一起返回一个后果集，
• none：依照创立索引时的最小粒度做聚合计算，最小粒度是毫秒为单位，不举荐使用性能较差；
• minute：以分钟作为聚合的最小粒度；
• fifteen_minute：15 分钟聚合；
• thirty_minute：30 分钟聚合
• hour：一小时聚合
• day：天聚合
• month：月聚合
• Quarter：季度聚合
• year：年聚合

编写测试，咱们这里依照季度聚合，并且咱们过滤年龄是 21-31 的数据，并且依照地区以及性别进行分组

vi query/filter6.json

{
    "queryType":"groupBy",
    "dataSource":"taxi_message",
    "granularity":"Quarter",
    "dimensions":["local","sex"],
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2022-06-07"]
}

进行查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter6.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.2.2 Duration 聚合粒度

duration 聚合粒度提供了更加灵便的聚合粒度，不只局限于 Simple 聚合粒度提供的固定聚合粒度，而是以毫秒为单位自定义聚合粒度，比方两小时做一次聚合能够设置 duration 配置项为 7200000 毫秒，所以 Simple 聚合粒度不可能满足的聚合粒度能够抉择应用 Duration 聚合粒度。

留神：应用 Duration 聚合粒度须要设置配置项 type 值为 duration

编写测试，咱们依照

vi query/filter7.json

{
    "queryType":"groupBy",
    "dataSource":"taxi_message",
    "granularity":{
        "type":"duration",
        "duration":7200000
    },
    "dimensions":["local","sex"],
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2021-06-10"]
}

数据查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter7.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.2.3 Period 聚合粒度

Period 聚合粒度采纳了日期格局，罕用的几种时间跨度示意办法，一小时：PT1H, 一周：P1W，一天：P1D，一个月：P1M；应用 Period 聚合粒度须要设置配置项 type 值为 period,

编写测试，咱们依照一天进行聚合

vi query/filter8.json

{
    "queryType":"groupBy",
    "dataSource":"taxi_message",
    "granularity":{
        "type":"period",
        "period":"P1D"
    },
    "dimensions":["sex"],
    "aggregations":[
     {
            "type":"count",
            "name":"taxiNum"
     }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2021-06-10"]
}

数据查问

curl -L -H 'Content-Type:application/json' -XPOST --data-binary @query/filter8.json http://192.168.64.177:8082/druid/v2/?pretty

5.5.3 聚合器

Aggregator 是聚合器，聚合器能够在数据摄入阶段和查问阶段应用，在数据摄入阶段应用聚合器可能在数据被查问之前依照维度进行聚合计算，进步查问阶段聚合计算性能，在查问过程中，应用聚合器可能实现各种不同指标的组合计算。

5.5.3.1 公共属性

聚合器的公共属性介绍

• type：申明应用的聚合器类型；
• name：定义返回值的字段名称，相当于 sql 语法中的字段别名；
• fieldName：数据源中已定义的指标名称，该值不能够自定义，必须与数据源中的指标名统一；

5.5.3.2 计数聚合

计数聚合器，等同于 sql 语法中的 count 函数，用于计算 druid roll-up 合并之后的数据条数，并不是摄入的原始数据条数，在定义数据模式指标规定中必须增加一个 count 类型的计数指标 count;

比方想查问 Roll-up 后有多少条数据，查问的 JSON 格局如下

vi query/aggregator1.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"Quarter",
    "aggregations":[
         {
            "type":"count",
            "name":"count"
         }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2022-06-07"]
}

5.5.3.3 求合聚合

求和聚合器，等同于 sql 语法中的 sum 函数，用户指标求和计算，druid 提供两种类型的聚合器，别离是 long 类型和 double 类型的聚合器；

第一类就是 longSum Aggregator , 负责整数类型的计算，JSON 格局如下：

{“type”:”longSum”,”name”:out_name,”fieldName”:”metric_name”}

第二类是 doubleSum Aggregator, 负责浮点数计算，JSON 格局如下：

{“type”:”doubleSum”,”name”:out_name,”fieldName”:”metric_name”}

示例

vi query/aggregator2.json

{
    "queryType":"timeseries",
    "dataSource":"taxi_message",
    "granularity":"Quarter",
    "aggregations":[
         {
            "type":"longSum",
            "name":"ageSum",
            "fieldName":"age"
         }
    ],
    "filter":{
        "type":"bound",
        "dimension":"age",
        "lower":"21",
        "upper":"31", 
        "alphaNumeric":true 
    },
    "intervals":["2021-06-07/2022-06-07"]
}

5.6 Druid SQL

Druid SQL 是一个内置的 SQL 层，是 Druid 基于 JSON 的本地查询语言的替代品，它由基于 Apache Calcite 的解析器和布局器提供反对

​ Druid SQL 将 SQL 转换为查问 Broker(查问的第一个过程)上的原生 Druid 查问，而后作为原生 Druid 查问传递给数据过程。除了在 Broker 上 转换 SQL) 的（轻微）开销之外，与原生查问相比，没有额定的性能损失。

5.6.1 根本查问

5.6.1.1 查问数据总条数

能够在 druid 的控制台进行查问

select count(1) from "taxi_message"

5.6.1.2 查问以后打车人数

咱们能够统计进去以后的打车的人数

5.6.2 聚合性能

聚合函数能够呈现在任何查问的 SELECT 子句中。能够应用相似语法过滤任何聚合器 AGG(expr) FILTER(WHERE whereExpr)。过滤的聚合器仅聚合与其过滤器匹配的行。同一 SQL 查问中的两个聚合器可能具备不同的筛选器。

只有 COUNT 聚合能够承受 DISTINCT。

5.6.2.1 查问数据总条数

能够在 druid 的控制台进行查问

select count(1) from "taxi_message"

5.7 客户端 API

咱们在这里实现 SpringBoot+Mybatis 实现 SQL 查问 ApacheDruid 数据

5.7.1 引入 Pom 依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>


        <dependency>
            <groupId>org.apache.calcite.avatica</groupId>
            <artifactId>avatica</artifactId>
            <version>1.18.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.calcite.avatica</groupId>
            <artifactId>avatica-server</artifactId>
            <version>1.18.0</version>
        </dependency>
    </dependencies>

5.7.1.1 配置数据源连贯

在 application.yml 中配置数据库的连贯信息

• 连贯时需注意 Druid 时区和 JVM 时区，不设置时区时默认采纳 JVM 时区
• 文档参考地址：https://calcite.apache.org/av…

spring:
  datasource:
    # 连接池信息
    url: jdbc:avatica:remote:url=http://192.168.64.177:8082/druid/v2/sql/avatica/
    # 驱动信息
    driver-class-name: org.apache.calcite.avatica.remote.Driver

5.7.2 编写代码

5.7.2.1 编写实体类

public class TaxiMessage {

    private String __time;
    private Integer age;
    private Integer createDate;
    private String local;
    private String sex;
    private Integer status;
    private String statusText;
    private String username;
    //setter getter 疏忽

    @Override
    public String toString() {
        return "TaxiMessage{" +
                "__time='" + __time + '\'' +
                ", age=" + age +
                ", createDate=" + createDate +
                ", local='" + local + '\'' +
                ", sex='" + sex + '\'' +
                ", status=" + status +
                ", statusText='" + statusText + '\'' +
                ", username='" + username + '\'' +
                '}';
    }
}

5.7.2.2 编写 mapper

所有字段名、表名必须应用如下形式标识 \"表名 \"

@Mapper
public interface TaxiMessageMapper {@Select("SELECT * FROM \"taxi_message\"where username=#{username}")
    public TaxiMessage findByUserName(String username);
}

5.7.2.3 编写 Service

@Service
public class TaxiMessageService {
    @Autowired
    private TaxiMessageMapper taxiMessageMapper;

    public TaxiMessage findByUserName(String username) {return taxiMessageMapper.findByUserName(username);
    }
}

5.7.2.4 编写启动类

@SpringBootApplication
@MapperScan(basePackages = "com.heima.druid.mapper")
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class);
    }
}

5.7.2.5 编写测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class DruidTest {
    @Autowired
    private TaxiMessageService taxiMessageService;

    @Test
    public void test() {TaxiMessage taxiMessage = taxiMessageService.findByUserName("eFQfLXmXD4");
        System.out.println(taxiMessage);
        Assert.assertNotNull(taxiMessage);
    }
}

5.7.2.6 运行测试

本文由 传智教育博学谷 教研团队公布。

如果本文对您有帮忙，欢送 关注 和点赞 ；如果您有任何倡议也可 留言评论 或私信，您的反对是我保持创作的能源。

转载请注明出处！