Sugo PlyQL

plyql是类似SQL的语言，可以解析成sugo-plywood的表达并执行。

plyql目前支持SELECT，DESCRIBE，和SHOW TABLES查询。

启用服务方式

终端命令模式
HTTP REST API模式
JDBC驱动模式

示例

以下使用实例以终端命令模式为例子，其他模式的SQL调用一样

对于这些示例，我们查询一个Druid代理节点IP为192.168.60.100，端口为8082

我们将地址（192.168.60.100:8082）传递给--host（-h）选项。

将所有的SQL比如SHOW TABLES，DESCRIBE TABLE_NAME，SELECT COUNT(*) FROM TABLE_NAME传递给--query（-q）选项。

注：暂不支持多表JOIN查询，只支持单表查询，具体可参考下面示例

查询数据源
- 查询数据源列定义结构
SQL查询调用

终端命令模式

查询所有数据源列表

查询当前节点所有数据源列表的例子：

plyql -h 192.168.60.100:8082 -q 'SHOW TABLES'

┌────────────────────────────────────┐
│ Tables_in_database                 │
├────────────────────────────────────┤
│ COLUMNS                            │
│ SCHEMATA                           │
│ TABLES                             │
│ sugo_test1                         │
│ sugo_test2                         │
│ sugo                               │
└────────────────────────────────────┘

查看数据源列定义结构

plyql -h 192.168.60.100:8082 -q 'DESCRIBE sugo'

返回数据源的列定义：

┌──────────────┬────────┬──────┬─────┬─────────┬───────┐
│ Field        │ Type   │ Null │ Key │ Default │ Extra │
├──────────────┼────────┼──────┼─────┼─────────┼───────┤
│ HEAD_ARGS    │ STRING │ YES  │     │ NULL    │       │
│ HEAD_IP      │ STRING │ YES  │     │ NULL    │       │
│ __time       │ TIME   │ YES  │     │ NULL    │       │
│ app_id       │ STRING │ YES  │     │ NULL    │       │
│ duration     │ NUMBER │ YES  │     │ NULL    │       │
│ is_active    │ STRING │ YES  │     │ NULL    │       │
│ is_installed │ STRING │ YES  │     │ NULL    │       │
│ client_time  │ TIME   │ YES  │     │ NULL    │       │
└──────────────┴────────┴──────┴─────┴─────────┴───────┘

普通查询

这里是一个简单的查询，获取所以的原始明细数据限定2条。

plyql -h 192.168.60.100:8082 -q 'SELECT * FROM sugo limit 2'

┌────────────┬───────────────┬──────────────────────┬─────────────────────┬──────────┬───────────┬──────────────┬──────────────────────┐
│ HEAD_ARGS  │ HEAD_IP       │ __time               │ app_id              │ duration │ is_active │ is_installed │ client_time          │
├────────────┼───────────────┼──────────────────────┼─────────────────────┼──────────┼───────────┼──────────────┼──────────────────────┤
│ topic=sugo │ 192.168.0.210 │ 2016-09-19T06:36:43Z │ 6284164581582112235 │ 7682     │ 1         │ 1            │ 2016-12-24T16:00:00Z │
│ topic=sugo │ 192.168.0.210 │ 2016-09-19T06:36:43Z │ 6284164581582112235 │ 7682     │ 1         │ 1            │ 2016-12-24T16:00:00Z │
└────────────┴───────────────┴──────────────────────┴─────────────────────┴──────────┴───────────┴──────────────┴──────────────────────┘

条件过滤查询

查询某个时间段范围的数据

注意这里的时间ISO格式

plyql -h 192.168.60.100:8082 -q '
SELECT page as pg, 
is_active as flag 
FROM sugo
WHERE is_active='1' AND __time > "2016-01-24T16:00:00Z" AND __time < "2016-09-24T16:00:00Z"
LIMIT 4
'

结果集:

┌─────────────────────┬─────┐
│ pg                  │flag │
├─────────────────────┼─────┤
│ Jeremy Corbyn       │ 1   │
│ Jeremy 111111       │ 1   │
│ Jeremy 222222       │ 1   │
│ Jeremy 333333       │ 1   │
└─────────────────────┴─────┘

LOOKUP_IN条件过滤查询

将LOOKUP作为过滤条件查询

plyql -h 192.168.60.100:8082 -q '
SELECT page as pg, 
is_active as flag
FROM sugo
WHERE UserID LOOKUP_IN("lookup_id") AND SID LOOKUP_IN "looup_id2" -- 或者可以去掉括号 UserID LOOKUP_IN "lookup_id"
LIMIT 4
'

结果集:

┌─────────────────────┬─────┐
│ pg                  │flag │
├─────────────────────┼─────┤
│ Jeremy Corbyn       │ 1   │
│ Jeremy 111111       │ 1   │
│ Jeremy 222222       │ 1   │
│ Jeremy 333333       │ 1   │
└─────────────────────┴─────┘

分组查询

plyql -h 192.168.60.100:8082 -q '
SELECT page as pg, 
COUNT() as cnt 
FROM sugo_test 
WHERE "2015-09-12T00:00:00" <= __time AND __time < "2015-09-13T00:00:00"
GROUP BY page
ORDER BY cnt DESC 
LIMIT 5;
'

结果集:

┌─────────────────────┬─────┐
│ pg                  │ cnt │
├─────────────────────┼─────┤
│ Jeremy Corbyn       │ 2   │
│ Jeremy 111111       │ 2   │
│ Jeremy 222222       │ 2   │
│ Jeremy 333333       │ 2   │
└─────────────────────┴─────┘

分组查询

plyql -h 192.168.60.100:8082 -q '
SELECT province as pg,
age,
date_format(__time,"%Y-%m-%d") time
COUNT() as cnt
FROM sugo_test
WHERE "2015-09-12T00:00:00" <= __time AND __time < "2015-09-13T00:00:00"
GROUP BY GROUPING SETS (1, (2, 3))
ORDER BY cnt DESC
LIMIT 5;
'

结果集:

┌─────┬──────────┬──────┬────────────┬───────┐
│ GID │ province │ age  │ time       │ total │
├─────┼──────────┼──────┼────────────┼───────┤
│ 0   │ 上海市    │ NULL │ 2017-05-13 │ 25768 │
│ 0   │ 云南省    │ NULL │ 2017-05-13 │ 25595 │
│ 0   │ 内蒙古    │ NULL │ 2017-05-13 │ 25756 │
│ 0   │ 北京市    │ NULL │ 2017-05-13 │ 25490 │
│ 1   │ NULL     │ 11   │ 2017-05-13 │ 43524 │
│ 1   │ NULL     │ 12   │ 2017-05-13 │ 43428 │
│ 1   │ NULL     │ 13   │ 2017-05-13 │ 43726 │
│ 1   │ NULL     │ 14   │ 2017-05-13 │ 43606 │
│ 1   │ NULL     │ 15   │ 2017-05-13 │ 43376 │
│ 1   │ NULL     │ 16   │ 2017-05-13 │ 43599 │
│ 1   │ NULL     │ 29   │ 2017-05-19 │ 49927 │
└─────┴──────────┴──────┴────────────┴───────┘

时间分组

通过TIME_BUCKET函数可以对时间分解

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT SUM(added) as total 
FROM sugo_test 
GROUP BY TIME_BUCKET(__time, PT6H, "Asia/Shanghai");
'

┌─────────────────────────────────────────────┬───────┐
│ split0                                      │ total │
├─────────────────────────────────────────────┼───────┤
│ [2017-02-06T22:00:00Z,2017-02-07T04:00:00Z] │ 8337  │
│ [2017-02-07T04:00:00Z,2017-02-07T10:00:00Z] │ 21600 │
│ [2017-02-07T10:00:00Z,2017-02-07T16:00:00Z] │ 21600 │
│ [2017-02-07T16:00:00Z,2017-02-07T22:00:00Z] │ 21600 │
│ [2017-02-07T22:00:00Z,2017-02-08T04:00:00Z] │ 21600 │
│ [2017-02-08T04:00:00Z,2017-02-08T10:00:00Z] │ 21600 │
│ [2017-02-08T10:00:00Z,2017-02-08T16:00:00Z] │ 21600 │
│ [2017-02-08T16:00:00Z,2017-02-08T22:00:00Z] │ 21600 │
│ [2017-02-08T22:00:00Z,2017-02-09T04:00:00Z] │ 21600 │
└─────────────────────────────────────────────┴───────┘

注意分组列如果没有选择但仍有返回, 列如TIME_BUCKET(__time, PT1H, 'Asia/Shanghai') as 'split'

是查询列中的一个。

时间分割也支持，这里是一个例子：

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT TIME_PART(__time, HOUR_OF_DAY, "Asia/Shanghai") as HourOfDay, 
SUM(added) as TotalAdded 
FROM wikipedia 
GROUP BY 1 
ORDER BY TotalAdded DESC LIMIT 3;
'

注意，这个 GROUP BY 指的是选择中的第一列。

这将返回：

┌────────────┬───────────┐
│ TotalAdded │ HourOfDay │
├────────────┼───────────┤
│ 8077302    │ 10        │
│ 5998730    │ 17        │
│ 5210222    │ 18        │
└────────────┴───────────┘

它也是可能做到多维度分组查询的

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT TIME_BUCKET(__time, PT1H, "Asia/Shanghai") as Hour, 
page as PageName, 
SUM(added) as TotalAdded 
FROM wikipedia 
GROUP BY 1, 2 
ORDER BY TotalAdded DESC 
LIMIT 3;
'

[
  {
    "TotalAdded": 242211,
    "PageName": "Wikipedia‐ノート:即時削除の方針/過去ログ16",
    "Hour": {
      "start": "2015-09-12T15:00:00.000Z",
      "end": "2015-09-12T16:00:00.000Z",
      "type": "TIME_RANGE"
    }
  },
  {
    "TotalAdded": 232941,
    "PageName": "Користувач:SuomynonA666/Заготовка",
    "Hour": {
      "start": "2015-09-12T14:00:00.000Z",
      "end": "2015-09-12T15:00:00.000Z",
      "type": "TIME_RANGE"
    }
  },
  {
    "TotalAdded": 214017,
    "PageName": "User talk:Estela.rs",
    "Hour": {
      "start": "2015-09-12T12:00:00.000Z",
      "end": "2015-09-12T13:00:00.000Z",
      "type": "TIME_RANGE"
    }
  }
]

聚合查询

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT province as pro,
SUM(added) as sumAdded,
MAX(__time) as maxTime,
AVG(added) as avgAdded
FROM sugo_test
LIMIT 5;
'

┌──────────┬───────────────┬──────────┐
│ sumAdded │ maxTime       │ avgAdded │
├──────────┼───────────────┼──────────┤
│ 2160     │ 1487812861000 │ 1920     │
└──────────┴───────────────┴──────────┘

聚合函数带where查询

plyql -h 192.168.60.100:8082 -i P1Y -q '
  SELECT COUNT(*) total ,
  COUNT(* where event_action in ("启动" , "唤醒")) filterTotal
  FROM sugo_test
'

┌──────────┬───────────────┐
│ total    │ filterTotal   │
├──────────┼───────────────┤
│ 21605    │ 3223          │
└──────────┴───────────────┘

plyql -h 192.168.60.100:8082 -i P1Y -q '
  SELECT TIME_BUCKET(__time, P1D, "Asia/Shanghai") time,
  COUNT(*) total ,
  COUNT(* where event_action in ("启动" , "唤醒")) filterTotal
  FROM sugo_test
  GROUP BY 1
'

┌────────────────────┬────────┬─────────────┐
│ time               │ total  │ filterTotal │
├────────────────────┼────────┼─────────────┤
│ 2016-07-24 16:00:00│ 234334 │ 1920        │
└────────────────────┴────────┴─────────────┘

函数查询

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT
SUBSTR(Province, 1, 1) subPro, 
CONCAT(Province, "_SUFF")
FROM sugo_test
LIMIT 5;
'

┌────────┬─────────────┐
│ subPro │ pro         │
├────────┼─────────────┤
│ 宁     │ 辽宁省_SUFF │
│ 西     │ 广西省_SUFF │
│ 西     │ 陕西省_SUFF │
│ 建     │ 福建省_SUFF │
│ 苏     │ 江苏省_SUFF │
└────────┴─────────────┘

QUANTILE函数

支持对直方图的分位数。

假设您想要使用直方图计算 0.95 分位数的三角洲筛选的城市是旧金山。

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT 
QUANTILE(delta_hist WHERE cityName = "San Francisco", 0.95) as P95 
FROM wikipedia;
'

CASE WHEN 查询

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT
CASE Province WHEN "广东省" THEN "广东省" ELSE "其他省份" END AS caseProvince,
COUNT(*) AS "Count"
FROM sugo_test
WHERE Nation = "中国"
GROUP BY 1
ORDER BY Count DESC 
LIMIT 3;
'

或者

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT
CASE WHEN Province="广东省" THEN "广东省" ELSE "其他省份" END AS caseProvince, 
COUNT(*) AS "Count"
FROM sugo_test
WHERE Nation = "中国" 
GROUP BY 1 
ORDER BY Count DESC 
LIMIT 3;
'

┌──────────────┬───────────┐
│ caseProvince │ Count     │
├──────────────┼───────────┤
│ 其他省份      │ 216958713 │
│ 广东省        │ 6781726   │
└──────────────┴───────────┘

having查询

这里的HAVING条件跟传统的SQL有点区别，就是只能指定SELET里聚合过的或者数值列类型的

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT province as pro, 
COUNT() as cnt 
FROM sugo_test
GROUP BY province 
HAVING cnt > 1
ORDER BY cnt DESC 
LIMIT 5;
'

┌────────┬───────┐
│ pro    │ cnt   │
├────────┼───────┤
│ 局域网  │ 49311 │
│ 广东   │ 30407 │
│ 广西   │ 9213  │
│ 福建   │ 3134  │
│ 香港   │ 956   │
└────────┴───────┘

高级查询

这里是一个高级的示例，获取前 5 页编辑时间。

PlyQL 的一个显著特征是它对待（aka 表）的数据集作为可以嵌套在另一个表的只是另一种数据类型。

这使我们能够嵌套查询数据像这样︰

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT page as Page, 
COUNT() as cnt, 
(
  SELECT 
  SUM(added) as TotalAdded 
  GROUP BY TIME_BUCKET(__time, PT1H, "Asia/Shanghai") 
  LIMIT 3 -- only get the first 3 hours to keep this example output small
) as "ByTime" 
FROM wikipedia 
GROUP BY page 
ORDER BY cnt DESC 
LIMIT 5;
'

[
  {
    "cnt": 314,
    "Page": "Jeremy Corbyn",
    "ByTime": [
      {
        "TotalAdded": 1075,
        "split0": {
          "start": "2015-09-12T01:00:00.000Z",
          "end": "2015-09-12T02:00:00.000Z",
          "type": "TIME_RANGE"
        }
      },
      {
        "TotalAdded": 0,
        "split0": {
          "start": "2015-09-12T07:00:00.000Z",
          "end": "2015-09-12T08:00:00.000Z",
          "type": "TIME_RANGE"
        }
      },
      {
        "TotalAdded": 10553,
        "split0": {
          "start": "2015-09-12T08:00:00.000Z",
          "end": "2015-09-12T09:00:00.000Z",
          "type": "TIME_RANGE"
        }
      }
    ]
  },
  {
    "cnt": 255,
    "Page": "User:Cyde/List of candidates for speedy deletion/Subpage",
    "ByTime": [
      {
        "TotalAdded": 73,
        "split0": {
          "start": "2015-09-12T00:00:00.000Z",
          "end": "2015-09-12T01:00:00.000Z",
          "type": "TIME_RANGE"
        }
      },
      {
        "TotalAdded": 3363,
        "split0": {
          "start": "2015-09-12T01:00:00.000Z",
          "end": "2015-09-12T02:00:00.000Z",
          "type": "TIME_RANGE"
        }
      },
      {
        "TotalAdded": 336,
        "split0": {
          "start": "2015-09-12T02:00:00.000Z",
          "end": "2015-09-12T03:00:00.000Z",
          "type": "TIME_RANGE"
        }
      }
    ]
  },
  "... results omitted ..."
]

所有查询示例

   SELECT
    a = b AS aISb1,
    a IS b AS aISb2,
    a <=> b AS aISb3,
    COUNT() Count1,
    COUNT(*) AS Count2,
    COUNT(1) AS Count3,
    COUNT(\`visitor\`) AS Count4,
    MATCH(\`visitor\`, "[0-9A-F]") AS 'Match',
    CUSTOM_TRANSFORM(\`visitor\`, "visitor_custom") AS 'CustomTransform',
    SUM(added) AS 'TotalAdded',
    DATE '2014-01-02' AS 'Date',
    SUM(\`wiki\`.\`added\`) / 4 AS TotalAddedOver4,
    NOT(true) AS 'False',
    -SUM(added) AS MinusAdded,
    ABS(MinusAdded) AS AbsAdded,
    ABSOLUTE(MinusAdded) AS AbsoluteAdded,
    POWER(MinusAdded, 0.5) AS SqRtAdded,
    POW(MinusAdded, 0.5) AS SqRtAdded2,
    SQRT(TotalAddedOver4) AS SquareRoot,
    EXP(0) AS One,
    +SUM(added) AS SimplyAdded,
    QUANTILE(added, 0.5) AS Median,
    QUANTILE(added, 0.5, "resolution=400") AS MedianTuned,
    COUNT_DISTINCT(visitor) AS 'Unique1',
    COUNT( DISTINCT visitor) AS 'Unique2',
    COUNT(DISTINCT(visitor)) AS 'Unique3',
    TIME_BUCKET(time, PT1H) AS 'TimeBucket',
    TIME_FLOOR(time, PT1H) AS 'TimeFloor',
    TIME_SHIFT(time, PT1H) AS 'TimeShift1',
    TIME_SHIFT(time, PT1H, 3) AS 'TimeShift3',
    TIME_RANGE(time, PT1H) AS 'TimeRange1',
    TIME_RANGE(time, PT1H, 3) AS 'TimeRange3',
    DATE_FORMAT(time, '%Y-%m-%d', 'Asia/Shanghai'),
    OVERLAP(x, y) AS 'Overlap',
    IF(x, "hello", \`world\`) AS 'If1',
    CASE moon WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'more' END AS 'Case1',
    CASE WHEN moon > 13 THEN 'T' ELSE 'F' END AS 'Case2',
    CASE WHEN moon = 13 THEN 'TheOne' END AS 'Case3',
    CUSTOM('blah') AS 'Custom1',
    CUSTOM_AGGREGATE('blah') AS 'Custom2'
    FROM \`wiki\`
    WHERE \`language\`="en"  AND UserID LOOKUP_IN('lookup_id');  -- This is just some comment

--interval 参数

Plyql有一个选项 --interval (-i) 自动过滤器加上interval间隔时间。

如果您不想键入时间筛选器，则这样设置非常有用。

plyql -h 192.168.60.100:8082 -i P1Y -q '
SELECT page as pg, 
COUNT() as cnt 
FROM wikipedia 
GROUP BY page 
ORDER BY cnt DESC 
LIMIT 5;
'

运算符

名称	描述
+	加法运算符
-	减号运算符 / 一元求反
*	乘法运算符
/	除法运算符
=, IS	等于运算符
!=, <>, IS NOT	不等于运算符
>=	大于或等于运算符
>	大于运算符
<=	小于或等于运算符
<	小于运算符
BETWEEN ... AND ...	检查一个值是否在值范围内
NOT BETWEEN ... AND ...	检查一个值是否不在值范围内
LIKE, CONTAINS	简单的模式(模糊)匹配
NOT LIKE, CONTAINS	否定的简单模式(模糊)匹配
REGEXP	模式匹配使用正则表达式
NOT REGEXP	正则表达式的否定
NOT, !	取否
AND	逻辑并
OR	逻辑或

函数

# TIME_BUCKET(operand, duration, timezone)

将时间在给定的timezone(时区)中按给定的duration(粒度)查询

示例: TIME_BUCKET(time, 'P1D', 'Asia/Shanghai')

这将把time变量装入日期块，其中按Asia/Shanghai时区的天粒度定义。

# TIME_PART(operand, part, timezone)

按指定的时区获取对应参数的时间参数值

例如: TIME_PART(time, 'DAY_OF_YEAR', 'Asia/Shanghai') 这将把'time`变量分成（整数）数字，表示一年中的哪一天。可能的部分值是:

SECOND_OF_MINUTE, SECOND_OF_HOUR, SECOND_OF_DAY, SECOND_OF_WEEK, SECOND_OF_MONTH, SECOND_OF_YEAR
MINUTE_OF_HOUR, MINUTE_OF_DAY, MINUTE_OF_WEEK, MINUTE_OF_MONTH, MINUTE_OF_YEAR
HOUR_OF_DAY, HOUR_OF_WEEK, HOUR_OF_MONTH, HOUR_OF_YEAR
DAY_OF_WEEK, DAY_OF_MONTH, DAY_OF_YEAR
WEEK_OF_MONTH, WEEK_OF_YEAR
MONTH_OF_YEAR
YEAR

# TIME_FLOOR(operand, duration, timezone)

在给定的timezone(时区)中将时间置于最近的duration(粒度)。示例: TIME_FLOOR(time, 'P1D', 'Asia/Shanghai')

这将把time变量置于一天的开始，其中天在Asia/Shanghai时区中定义。

# TIME_SHIFT(operand, duration, step, timezone)

在给定的timezone(时区)中，通过duration(粒度) * step向前移动时间。 step可能是负数。

示例: TIME_SHIFT(time, 'P1D', -2, 'Asia/Shanghai')

这将在两天后移动time变量，其中天在Asia/Shanghai时区中定义。

# TIME_RANGE(operand, duration, step, timezone)

在给定的timezone(时区)中创建一个范围形式time和一个duration *step远离time的点。 step可能是负数。

示例: TIME_RANGE(time, 'P1D', -2, 'Asia/Shanghai')

这将在两天后移动time变量，其中天在Asia/Shanghai时区中定义，并创建一个时间-2 * P1D - >时间范围。

# SUBSTR(str, pos, len)

从字符串str返回一个子串len个字符，从位置pos开始

# CONCAT(str1, str2, ...)

返回由连接参数产生的字符串。可以有一个或多个参数

# EXTRACT(str, regexp)

返回第一个匹配的组，结果窗体匹配 regexp 到 str

# LOOKUP(str, lookup-namespace)

返回键的值 str 内 查找-命名空间

# IFNULL(expr1, expr2)

返回 expr 如果不为空，否则返回 expr2

# FALLBACK(expr1, expr2)

这个等同于 IFNULL(expr1, expr2)

# OVERLAP(expr1, expr2)

检查 expr1 和 expr2 是否重叠

# CUSTOM_TRANSFORM(expr1, custom_name)

调用自定义转换函数处理数据

# CAST (expr1, op) 将expr1转换为其他类型, op包含：'CHAR'(string), 'SIGNED'(number); 例如将字符串转换为number类型： CAST(expr1, 'SIGNED') SELECT CAST(\commentLength` AS CHAR) as castedString, CAST(`commentLengthStr` AS SIGNED) as castedNumber FROM `wiki``

# DATE_FORMAT(expr, format, timezone)

时间格式化函数处理, 例如：DATE_FORMAT(time, '%Y-%m-%d', 'Asia/Shanghai') 目前支持格式：

format：

%Y-%m-%d %H:%i:%s
%Y-%m-%d %H:%i
%Y-%m-%d %H
%Y-%m-%d
%Y-%m
%Y

# 其他函数

YEAR, MONTH, WEEK_OF_YEAR DAY_OF_YEAR DAY_OF_MONTH DAY_OF_WEEK HOUR MINUTE SECOND DATE TIMESTAMP DATE_ADD DATE_SUB FROM_UNIXTIME UNIX_TIMESTAMP

数学函数

# ABS(expr)

返回expr的绝对值。

# POW(expr1, expr2)

返回 expr1 的幂 expr2。

# POWER(expr1, expr2)

这个等同于 POW(expr1, expr2)

# SQRT(expr)

返回expr的平方根

# EXP(expr)

返回 e（自然对数的基数）的值expr的幂。

聚合函数

# COUNT(expr?)

如果在没有表达式的情况下使用（或者作为COUNT(*)）返回行数的计数。当提供表达式时，返回expr不为null的行的计数。

# COUNT(DISTINCT expr), COUNT_DISTINCT(expr)

返回具有不同expr值的行数的计数。

# SUM(expr)

返回所有expr值的总和。

# MIN(expr)

返回所有expr值的最小值。

# MAX(expr)

返回所有expr值的最大值。

# AVG(expr)

返回所有expr值的平均值。

# QUANTILE(expr, quantile)

返回所有expr值的上层分位数。

# CUSTOM(custom_name)

返回名为custom_name的用户定义聚合。

# CUSTOM_AGGREGATE(custom_name)

调用自定义的聚合函数

HTTP REST API模式

启动HTTP REST APi

plyql -h 192.168.60.100  --json-server  8001

1. HTTP SQL接口请求

发送post请求到 http://192.168.60.100:8001/plyql

// post请求: application/json 参数
{
  "sql": "SHOW TABLES"
}

2. HTTP 原生Tindex-JSON接口请求

发送post请求到 http://192.168.60.100:8001/tindex

// post请求: application/json 参数
{
    "queryType": "lucene_timeseries",
    "dataSource": "events",
    "intervals": "1000/3000",
    "granularity": "all",
    "context": {
        "timeout": 60000,
        "groupByStrategy": "v2"
    },
    "aggregations": [
        {
            "name": "__VALUE__",
            "type": "lucene_count"
        }
    ]
}

3. HTTP 将SQL转换为Tindex原生queryJSON接口

发送post请求到 http://192.168.60.100:8001/get-query

  {
    sql: 'select * from events',
    // 可选参数
    scanQuery: false, // 是否scanQuery
    hasLimit: true,   // 是否包含limit
    timeout: 180000   // 设置timeout
  }

Sugo Plyql 使用文档

Sugo PlyQL

启用服务方式

示例

终端命令模式

查询所有数据源列表

查看数据源列定义结构

普通查询

条件过滤查询

LOOKUP_IN条件过滤查询

分组查询

分组查询

时间分组

聚合查询

聚合函数带where查询

函数查询

QUANTILE函数

CASE WHEN 查询

having查询

高级查询

所有查询示例

--interval 参数

运算符

函数

# 其他函数

数学函数

聚合函数

HTTP REST API模式

启动HTTP REST APi

1. HTTP SQL接口请求

2. HTTP 原生Tindex-JSON接口请求

3. HTTP 将SQL转换为Tindex原生queryJSON接口

更多Tindex查询类型请参考查询 Tindex-Query-Json

results matching ""

No results matching ""

Sugo PlyQL

启用服务方式

示例

终端命令模式

查询所有数据源列表

查看数据源列定义结构

普通查询

条件过滤查询

LOOKUP_IN条件过滤查询

分组查询

分组查询

时间分组

聚合查询

聚合函数带where查询

函数查询

QUANTILE函数

CASE WHEN 查询

having查询

高级查询

所有查询示例

--interval 参数

运算符

函数

# 其他函数

数学函数

聚合函数

HTTP REST API模式

启动HTTP REST APi

1. HTTP SQL接口请求

2. HTTP 原生Tindex-JSON接口请求

3. HTTP 将SQL转换为Tindex原生queryJSON接口

更多Tindex查询类型请参考 查询 Tindex-Query-Json

results matching ""

No results matching ""

更多Tindex查询类型请参考查询 Tindex-Query-Json