内容有缩减，原文请点击这里
创建数据库
CREATE DATABASE [IF NOT EXISTS] db_name
创建表
CREATE TABLE可以有几种形式。
创建一张表，最好指定引擎结构
-
CREATE [
TEMPORARY]
TABLE [
IF
NOT
EXISTS] [db.]
name [
ON CLUSTER cluster]
-
(
-
name1 [type1] [
DEFAULT|
MATERIALIZED|
ALIAS expr1],
-
name2 [type2] [
DEFAULT|
MATERIALIZED|
ALIAS expr2],
-
...
-
)
ENGINE =
engine
创建一张像另一张表结构的表
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] [db.]name AS [db2.]name2 [ENGINE = engine]
创建一张自定义引擎，数据及结构来源于另一张表的表
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] [db.]name ENGINE = engine AS SELECT ...
默认值
列描述可以指定一个默认值的表达式，其中有以下几个方法：默认的expr、物化expr、别名expr。示例:URLDomain字符串默认域（URL）。如果没有定义默认值的表达式，那么默认值将被设置为0，用于数字、字符串的空字符串、数组的空数组，以及用于日期的00-00 00 00 00 00 0000-0000。不支持null。
临时表
在所有情况下，如果指定临时表，就会创建临时表。临时表有以下特点：
- 临时表在会话结束时消失，包括连接丢失。
- 一个临时表是用内存引擎创建的。其他表引擎不受支持。
- DB不能为临时表指定。它是在数据库之外创建的。
- 如果临时表与另一个表的名称相同，并且查询指定表名而不指定DB，则使用临时表。
- 对于分布式查询处理，查询中使用的临时表被传递给远程服务器。
在大多数情况下，临时表不是手动创建的，而是在使用外部数据进行查询时，或者在分布式（全局）中使用。
创建视图
CREATE [MATERIALIZED] VIEW [IF NOT EXISTS] [db.]name [TO[db.]name] [ENGINE = engine] [POPULATE] AS SELECT ...
有两种类型的视图：正常的和物化的。
在创建物化视图时，必须指定引擎—用于存储数据的表引擎。
物化视图的工作原理如下：当将数据插入SELECT中指定的表时，插入数据的一部分被这个SELECT查询转换，结果被插入到视图中。
普通视图不存储任何数据，只是执行从另一个表读取的数据。换句话说，正常的视图只不过是一个保存的查询。从视图读取时，这个保存的查询被用作FROM子句中的子查询。
举例，假设你已经创建了一个视图
CREATE VIEW view AS SELECT ...
而且写了一个查询
SELECT a, b, c FROM view
这个查询等价于这个子查询
SELECT a, b, c FROM (SELECT ...)
物化视图是这样安排的：在将数据插入到SELECT中指定的表时，插入数据的一部分被这个SELECT查询转换，结果被插入到视图中。如果您指定填充，则在创建时将现有的表数据插入视图中，就像创建一个CREATE TABLE。作为选择……否则，查询只包含创建视图后插入到表中的数据。我们不建议使用填充，因为在视图创建期间插入到表中的数据不会被插入到其中。
ATTACH
这个查询与CREATE完全相同，但是不是“创建”这个词，它使用“附加”这个词。
该查询不会在磁盘上创建数据，但是假设数据已经在适当的位置，并且只向服务器添加关于表的信息。执行附加查询后，服务器将知道表的存在。如果表以前是分离的，也就是说它的结构是已知的，那么您可以使用速记而不用定义结构。
ATTACH TABLE [IF NOT EXISTS] [db.]name
DETACH
从服务器删除关于“name”表的信息。服务器停止知道表的存在。
DETACH TABLE [IF EXISTS] [db.]name
DROP
DROP数据库
DROP DATABASE [IF EXISTS] db [ON CLUSTER cluster]
DROP TABLE
DROP [TEMPORARY] TABLE [IF EXISTS] [db.]name [ON CLUSTER cluster]
RENAME
重命名一个或多个表。
RENAME TABLE [db11.]name11 TO [db12.]name12, [db21.]name21 TO [db22.]name22, ... [ON CLUSTER cluster]
所有表都在全局锁定下重命名。重命名表是一项轻操作。如果您在之后指定了另一个数据库，那么该表将被移动到这个数据库。但是，带有数据库的目录必须位于相同的文件系统中（否则，将返回错误）
ALTER
ALTER查询只支持MergeTree表，以及mergeand分布式。该查询有几个变体。
ALTER TABLE [db].name [ON CLUSTER cluster] ADD|DROP|MODIFY COLUMN ...
增加列（排在某个列之后）
ADD COLUMN name [type] [default_expr] [AFTER name_after]
删除列
DROP COLUMN name
改变列类型
MODIFY COLUMN name [type] [default_expr]
不支持在主键或采样键中删除列（在引擎表达式中是列）。更改主键中包含的列的类型只有在此更改不会导致数据被修改时才可能（例如，允许将值添加到枚举中，或者将DateTime的类型更改为UInt32）。
有几个处理阶段：
- 用修改过的数据准备临时的（新的）文件
- 重命名旧文件
- 将临时（新）文件重命名为旧的名称
- 删除旧的文件
分区操作
它只适用于MergeTree的表：
DETACH PARTITION—— 将一个分区移动到“分离”目录并忘记它DROP PARTITION—— 删除一个分区ATTACH PART|PARTITION —— 将一个新的部分或分区从分离的目录添加到表FREEZE PARTITION——创建一个分区的备份FETCH PARTITION——
每一种类型的查询都被单独地覆盖。
表中的一个分区是单个日历月的数据。这是由表引擎参数中指定的日期键的值决定的。每个月的数据都是单独存储的，以简化对这些数据的操作。表中的“部分”是来自单个分区的数据的一部分，按主键排序。你可以使用这个系统。用于查看表部分和分区的部件表
例如：只算活跃的部分，不活跃的部分是在合并到更大的部分后剩余的部分——这些部分在合并后大约10分钟被删除。
SELECT * FROM system.parts WHERE active
另一种查看一组部件和分区的方法是使用表数据进入目录。数据目录:/var/lib/clickhouse/data/database/table/,/var/lib/clickhouse/ ClickHouse的路径数据,数据库的数据库名称,表的表名。
在这里，2014031720140323220和20140320140323440是数据部分的目录。让我们来分解第一部分的名
- 20140317是数据块中数据的最小日期
- 20140323是数据块中数据的最大日期
- 2是数据块的最小值
- 2是数据块的最大值
- 0是块级别（合并树的深度是由它形成的）
每个部分都与一个单独的分区有关，并且只包含一个月的数据。201403是分区的名称。一个分区是一个月的一组部件。
在操作服务器上，您不能手动更改文件系统上的部分或它们的数据，因为服务器不知道它。对于非复制表，当服务器停止时，您可以这样做，但我们不建议这样做。对于复制的表，在任何情况下都不能更改部分。
分离的目录包含服务器不使用的部分——使用ALTER从表中分离
将名为“name”的分区的所有数据移动到“分离”目录，然后忘记它们。分区名称以YYYYMM格式指定。它可以用单引号或没有引号表示
ALTER TABLE [db.]table DETACH PARTITION 'name'
与分离操作相同。从表中删除数据。数据部分将被标记为不活动，在大约10分钟内将被完全删除。该查询将被复制——数据将在所有副本上被删除。
ALTER TABLE [db.]table ATTACH PARTITION|PART 'name'
从“分离”目录中添加数据到表中。
ALTER TABLE [db.]table ATTACH PARTITION|PART 'name'
创建一个或多个分区的本地备份。名称可以是分区的全名（例如，201403），或者它的前缀（例如，2014）：然后将为所有相应的分区创建备份。
ALTER TABLE [db.]table FREEZE PARTITION 'name'
备份和复制
这个查询只适用于可复制的表
ALTER TABLE [db.]table FETCH PARTITION 'name' FROM 'path-in-zookeeper'
尽管查询被称为ALTER TABLE，但它不会改变表结构，也不会立即更改表中可用的数据。它从碎片中下载指定的分区，它在FROM子句中指定了路径，然后将其放入指定表的分离目录中。
SHOW DATABASES
展示所有数据库
SHOW DATABASES [INTO OUTFILE filename] [FORMAT format]
SHOW TABLES
展示数据库里所有表格
SHOW [TEMPORARY] TABLES [FROM db] [LIKE 'pattern'] [INTO OUTFILE filename] [FORMAT format]
SHOW PROCESSLIST
输出正在处理的查询列表
SHOW PROCESSLIST [INTO OUTFILE filename] [FORMAT format]
SHOW CREATE TABLE
显示创建表的SQL
DESC|DESCRIBE TABLE [db.]table [INTO OUTFILE filename] [FORMAT format]
DESCRIBE TABLE
每个字段的名称及类型
DESC|DESCRIBE TABLE [db.]table [INTO OUTFILE filename] [FORMAT format]
EXISTS
存在一个utf-8的列，返回1，否则0
EXISTS [TEMPORARY] TABLE [db.]name [INTO OUTFILE filename] [FORMAT format]
USE
使用某一个数据库
USE db
SET
SET param = value
允许您设置param值，如果指定了全局，则为会话或服务器（全局）设置设置。在创建全局设置时，设置并不适用于已经运行的会话，包括当前会话。它只会用于新会话。当服务器重新启动时，使用SET的全局设置就会丢失。要在服务器重新启动后进行设置
OPTIMIZE
OPTIMIZE TABLE [db.]name [PARTITION partition] [FINAL]
仅支持MergeTree引擎， 用于回收闲置的数据库空间，当表上的数据行被删除时，所占据的磁盘空间并没有立即被回收，使用了OPTIMIZE TABLE命令后这些空间将被回收，并且对磁盘上的数据行进行重排
INSERT
不严格插入数据，没有出现的列自动填充为默认值
INSERT INTO [db.]table [(c1, c2, c3)] VALUES (v11, v12, v13), (v21, v22, v23), ...
严格插入数据，每一列都必须出现在上面
INSERT INTO [db.]table [(c1, c2, c3)] FORMAT Values (v11, v12, v13), (v21, v22, v23), ...
插入select 得到的数据
INSERT INTO [db.]table [(c1, c2, c3)] SELECT ...
Performance considerations
按主键对输入数据进行排序，并按月将它们划分为分区。如果您在混合月份插入数据，那么它会显著降低INSERT查询的性能。为了避免这种情况:：
- 在相当大的批量中添加数据，比如一次100,000行。
- 在将数据上传至ClickHouse之前，先将数据分组。
性能不会降低：
- 数据是实时添加的
- 上传的数据通常是按时间排序的
SELECT
-
SELECT [
DISTINCT] expr_list
-
[
FROM [db.]
table | (subquery) | table_function] [
FINAL]
-
[
SAMPLE sample_coeff]
-
[
ARRAY
JOIN ...]
-
[
GLOBAL]
ANY|ALL
INNER|
LEFT
JOIN (subquery)|
table
USING columns_list
-
[PREWHERE expr]
-
[
WHERE expr]
-
[
GROUP
BY expr_list] [
WITH TOTALS]
-
[
HAVING expr]
-
[
ORDER
BY expr_list]
-
[
LIMIT [n, ]m]
-
[
UNION ALL ...]
-
[
INTO
OUTFILE filename]
-
[
FORMAT
format]
-
[
LIMIT n
BY
columns]
子句几乎与查询执行传输器的顺序相同。
在使用FINAL时，查询处理得比较慢。在大多数情况下，您应该避免使用FINAL。
SAMPLE
仅支持MergeTree引擎，且必须在创建时指定抽样表达式
-
SELECT
-
Title,
-
count() *
10
AS PageViews
-
FROM hits_distributed
-
SAMPLE
0.1
-
WHERE
-
CounterID =
34
-
AND toDate(EventDate) >= toDate(
'2013-01-29')
-
AND toDate(EventDate) <= toDate(
'2013-02-04')
-
AND
NOT DontCountHits
-
AND
NOT
Refresh
-
AND Title !=
''
-
GROUP
BY Title
-
ORDER
BY PageViews
DESC
LIMIT
1000
SAMPLE k 当k在0~1之间时，如上例k=0.1，即在10%上的数据执行
SAMPLE k 当k为正整数时，如上例k=1000，运行该查询最多为1000行
上例是在10%的数据里执行的，所以count()要手动*10，当使用类似10000000的样例时，没有任何关于哪个相对百分比的数据被处理的信息，或者聚合函数应该乘以什么，因此这种写作方法并不总是适用于这种情况。
ARRAY JOIN
查询只能指定单个数组连接子句
ARRAY本质上和INNER JOIN 一样，举例：
-
:)
CREATE
TABLE arrays_test (s
String, arr
Array(UInt8))
ENGINE =
Memory
-
-
CREATE
TABLE arrays_test
-
(
-
s
String,
-
arr
Array(UInt8)
-
)
ENGINE =
Memory
-
-
Ok.
-
-
0
rows
in set. Elapsed:
0.001 sec.
-
-
:)
INSERT
INTO arrays_test
VALUES (
'Hello', [
1,
2]), (
'World', [
3,
4,
5]), (
'Goodbye', [])
-
-
INSERT
INTO arrays_test
VALUES
-
-
Ok.
-
-
3
rows
in set. Elapsed:
0.001 sec.
-
-
:)
SELECT *
FROM arrays_test
-
-
SELECT *
-
FROM arrays_test
-
-
┌─s───────┬─arr─────┐
-
│ Hello │ [
1,
2] │
-
│ World │ [
3,
4,
5] │
-
│ Goodbye │ [] │
-
└─────────┴─────────┘
-
-
3
rows
in set. Elapsed:
0.001 sec.
-
-
:)
SELECT s, arr
FROM arrays_test
ARRAY
JOIN arr
-
-
SELECT s, arr
-
FROM arrays_test
-
ARRAY
JOIN arr
-
-
┌─s─────┬─arr─┐
-
│ Hello │
1 │
-
│ Hello │
2 │
-
│ World │
3 │
-
│ World │
4 │
-
│ World │
5 │
-
└───────┴─────┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
可以在数组连接子句中指定一个别名。在这种情况下，可以通过这个别名访问数组项
-
:)
SELECT s, arr, a
FROM arrays_test
ARRAY
JOIN arr
AS a
-
-
SELECT s, arr, a
-
FROM arrays_test
-
ARRAY
JOIN arr
AS a
-
-
┌─s─────┬─arr─────┬─a─┐
-
│ Hello │ [
1,
2] │
1 │
-
│ Hello │ [
1,
2] │
2 │
-
│ World │ [
3,
4,
5] │
3 │
-
│ World │ [
3,
4,
5] │
4 │
-
│ World │ [
3,
4,
5] │
5 │
-
└───────┴─────────┴───┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
相同大小的多个数组可以在数组连接子句中进行逗号分隔。在这种情况下，连接是同时执行的
-
:)
SELECT s, arr, a,
num, mapped
FROM arrays_test
ARRAY
JOIN arr
AS a, arrayEnumerate(arr)
AS
num, arrayMap(x -> x +
1, arr)
AS mapped
-
-
SELECT s, arr, a,
num, mapped
-
FROM arrays_test
-
ARRAY
JOIN arr
AS a, arrayEnumerate(arr)
AS
num, arrayMap(lambda(tuple(x), plus(x,
1)), arr)
AS mapped
-
-
┌─s─────┬─arr─────┬─a─┬─
num─┬─mapped─┐
-
│ Hello │ [
1,
2] │
1 │
1 │
2 │
-
│ Hello │ [
1,
2] │
2 │
2 │
3 │
-
│ World │ [
3,
4,
5] │
3 │
1 │
4 │
-
│ World │ [
3,
4,
5] │
4 │
2 │
5 │
-
│ World │ [
3,
4,
5] │
5 │
3 │
6 │
-
└───────┴─────────┴───┴─────┴────────┘
-
-
5
rows
in set. Elapsed:
0.002 sec.
-
-
:)
SELECT s, arr, a,
num, arrayEnumerate(arr)
FROM arrays_test
ARRAY
JOIN arr
AS a, arrayEnumerate(arr)
AS
num
-
-
SELECT s, arr, a,
num, arrayEnumerate(arr)
-
FROM arrays_test
-
ARRAY
JOIN arr
AS a, arrayEnumerate(arr)
AS
num
-
-
┌─s─────┬─arr─────┬─a─┬─
num─┬─arrayEnumerate(arr)─┐
-
│ Hello │ [
1,
2] │
1 │
1 │ [
1,
2] │
-
│ Hello │ [
1,
2] │
2 │
2 │ [
1,
2] │
-
│ World │ [
3,
4,
5] │
3 │
1 │ [
1,
2,
3] │
-
│ World │ [
3,
4,
5] │
4 │
2 │ [
1,
2,
3] │
-
│ World │ [
3,
4,
5] │
5 │
3 │ [
1,
2,
3] │
-
└───────┴─────────┴───┴─────┴─────────────────────┘
-
-
5
rows
in set. Elapsed:
0.002 sec.
数组连接也可以使用嵌套的数据结构
-
:)
CREATE
TABLE nested_test (s
String, nest
Nested(x UInt8, y UInt32))
ENGINE =
Memory
-
-
CREATE
TABLE nested_test
-
(
-
s
String,
-
nest
Nested(
-
x UInt8,
-
y UInt32)
-
)
ENGINE =
Memory
-
-
Ok.
-
-
0
rows
in set. Elapsed:
0.006 sec.
-
-
:)
INSERT
INTO nested_test
VALUES (
'Hello', [
1,
2], [
10,
20]), (
'World', [
3,
4,
5], [
30,
40,
50]), (
'Goodbye', [], [])
-
-
INSERT
INTO nested_test
VALUES
-
-
Ok.
-
-
3
rows
in set. Elapsed:
0.001 sec.
-
-
:)
SELECT *
FROM nested_test
-
-
SELECT *
-
FROM nested_test
-
-
┌─s───────┬─nest.x──┬─nest.y─────┐
-
│ Hello │ [
1,
2] │ [
10,
20] │
-
│ World │ [
3,
4,
5] │ [
30,
40,
50] │
-
│ Goodbye │ [] │ [] │
-
└─────────┴─────────┴────────────┘
-
-
3
rows
in set. Elapsed:
0.001 sec.
-
-
:)
SELECT s, nest.x, nest.y
FROM nested_test
ARRAY
JOIN nest
-
-
SELECT s,
`nest.x`,
`nest.y`
-
FROM nested_test
-
ARRAY
JOIN nest
-
-
┌─s─────┬─nest.x─┬─nest.y─┐
-
│ Hello │
1 │
10 │
-
│ Hello │
2 │
20 │
-
│ World │
3 │
30 │
-
│ World │
4 │
40 │
-
│ World │
5 │
50 │
-
└───────┴────────┴────────┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
当在数组连接中指定嵌套数据结构的名称时，其含义与数组连接的含义相同，它包含了所有数组元素。
如下SQL与上面结果相同：
-
:)
SELECT s, nest.x, nest.y
FROM nested_test
ARRAY
JOIN nest.x, nest.y
-
-
SELECT s,
`nest.x`,
`nest.y`
-
FROM nested_test
-
ARRAY
JOIN
`nest.x`,
`nest.y`
-
-
┌─s─────┬─nest.x─┬─nest.y─┐
-
│ Hello │
1 │
10 │
-
│ Hello │
2 │
20 │
-
│ World │
3 │
30 │
-
│ World │
4 │
40 │
-
│ World │
5 │
50 │
-
└───────┴────────┴────────┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
其他示例：
-
:)
SELECT s, nest.x, nest.y
FROM nested_test
ARRAY
JOIN nest.x
-
-
SELECT s,
`nest.x`,
`nest.y`
-
FROM nested_test
-
ARRAY
JOIN
`nest.x`
-
-
┌─s─────┬─nest.x─┬─nest.y─────┐
-
│ Hello │
1 │ [
10,
20] │
-
│ Hello │
2 │ [
10,
20] │
-
│ World │
3 │ [
30,
40,
50] │
-
│ World │
4 │ [
30,
40,
50] │
-
│ World │
5 │ [
30,
40,
50] │
-
└───────┴────────┴────────────┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
别名依旧可以用于ARRAY：
-
:)
SELECT s, n.x, n.y, nest.x, nest.y
FROM nested_test
ARRAY
JOIN nest
AS n
-
-
SELECT s,
`n.x`,
`n.y`,
`nest.x`,
`nest.y`
-
FROM nested_test
-
ARRAY
JOIN nest
AS n
-
-
┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┐
-
│ Hello │
1 │
10 │ [
1,
2] │ [
10,
20] │
-
│ Hello │
2 │
20 │ [
1,
2] │ [
10,
20] │
-
│ World │
3 │
30 │ [
3,
4,
5] │ [
30,
40,
50] │
-
│ World │
4 │
40 │ [
3,
4,
5] │ [
30,
40,
50] │
-
│ World │
5 │
50 │ [
3,
4,
5] │ [
30,
40,
50] │
-
└───────┴─────┴─────┴─────────┴────────────┘
-
-
5
rows
in set. Elapsed:
0.001 sec.
使用arrayEnumerate函数：
-
:)
SELECT s, n.x, n.y, nest.x, nest.y,
num
FROM nested_test
ARRAY
JOIN nest
AS n, arrayEnumerate(nest.x)
AS
num
-
-
SELECT s,
`n.x`,
`n.y`,
`nest.x`,
`nest.y`,
num
-
FROM nested_test
-
ARRAY
JOIN nest
AS n, arrayEnumerate(
`nest.x`)
AS
num
-
-
┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┬─
num─┐
-
│ Hello │
1 │
10 │ [
1,
2] │ [
10,
20] │
1 │
-
│ Hello │
2 │
20 │ [
1,
2] │ [
10,
20] │
2 │
-
│ World │
3 │
30 │ [
3,
4,
5] │ [
30,
40,
50] │
1 │
-
│ World │
4 │
40 │ [
3,
4,
5] │ [
30,
40,
50] │
2 │
-
│ World │
5 │
50 │ [
3,
4,
5] │ [
30,
40,
50] │
3 │
-
└───────┴─────┴─────┴─────────┴────────────┴─────┘
-
-
5
rows
in set. Elapsed:
0.002 sec.
JOIN
该连接与上面描述的array join 没有关联
[GLOBAL] ANY|ALL INNER|LEFT [OUTER] JOIN (subquery)|table USING columns_list
有几种类型的连接：
INNER or LEFT：同mysql
ANY or ALL：如果指定了ANY，那么只有第一个找到的行被连接，如果指定了ALL，那么所有符合的行都被连接
GLOBAL ... JOIN：全局查询，首先，请求者服务器运行一个子查询来计算正确的表。这个临时表被传递给每个远程服务器，并使用传输的临时数据在它们上运行查询，请谨慎使用GLOBAL ... JOIN
-
SELECT
-
CounterID,
-
hits,
-
visits
-
FROM
-
(
-
SELECT
-
CounterID,
-
count()
AS hits
-
FROM test.hits
-
GROUP
BY CounterID
-
)
ANY
LEFT
JOIN
-
(
-
SELECT
-
CounterID,
-
sum(
Sign)
AS visits
-
FROM test.visits
-
GROUP
BY CounterID
-
)
USING CounterID
-
ORDER
BY hits
DESC
-
LIMIT
10
-
┌─CounterID─┬───hits─┬─visits─┐ │ 1143050 │ 523264 │ 13665 │ │ 731962 │ 475698 │ 102716 │ │ 722545 │ 337212 │ 108187 │ │ 722889 │ 252197 │ 10547 │ │ 2237260 │ 196036 │ 9522 │ │ 23057320 │ 147211 │ 7689 │ │ 722818 │ 90109 │ 17847 │ │ 48221 │ 85379 │ 4652 │ │ 19762435 │ 77807 │ 7026 │ │ 722884 │ 77492 │ 11056 │ └───────────┴────────┴────────┘子查询不允许您设置名称或使用它们来引用特定子查询中的列。在使用中指定的列必须在子查询中具有相同的名称，而其他列必须以不同的方式命名。您可以使用别名来更改子查询中的列的名称
右表（子查询结果）驻留在RAM中。如果没有足够的内存，就不能运行一个连接。
只有一个连接可以在查询中指定（在一个级别上）。要运行多个连接，您可以将它们放入子查询中
在各种类型的连接中，最有效的是任何左连接，然后是任何内部连接。最低效的是所有的左连接和所有内部连接。
如果需要连接维度表（这些表中包含维度属性的相对较小的表，例如用于广告活动的名称），那么连接可能不太方便，因为使用了大量的语法，而且每个查询都需要重新访问正确的表。对于这种情况，有一个“外部字典”特性，您应该使用它而不是连接
WHERE
如果有WHERE子句，它必须包含带有UInt8类型的表达式PREWHERE
首先，只需要执行预读操作的列。然后读取其他列来运行查询，但是只有那些块才是真值，仅支持引擎为 MergeTree的表
GROUP BY
-
SELECT
-
count(),
-
median(FetchTiming >
60 ?
60 : FetchTiming),
-
count() -
sum(
Refresh)
-
FROM hits
与MySQL不同（并且符合标准SQL），您不能获得某些不在键或聚合函数中的列的值（除非是常量表达式）。为了解决这个问题，您可以使用“any”聚合函数（获得第一个碰见的值）或“最小/最大值”。
-
SELECT
-
domainWithoutWWW(
URL)
AS
domain,
-
count(),
-
any(Title)
AS title
-- getting the first occurred page header for each domain.
-
FROM hits
-
GROUP
BY
domain
WITH TOTALS modifier
GROUP BY in external memory
您可以将临时数据转储到磁盘，以限制组内的内存使用。通过设置，maxbytes先于外部组通过临时数据对文件系统来确定倾倒组的阈值RAM消耗量。如果设置为0（缺省值），则禁用它。LIMIT N BY
-
SELECT
-
domainWithoutWWW(
URL)
AS
domain,
-
domainWithoutWWW(REFERRER_URL)
AS referrer,
-
device_type,
-
count() cnt
-
FROM hits
-
GROUP
BY
domain, referrer, device_type
-
ORDER
BY cnt
DESC
-
LIMIT
5
BY
domain, device_type
-
LIMIT
100
HAVING
类似where字句，如果没有使用聚合，则不能使用它
ORDER BY
默认为ASC升序，外部排序比RAM排序有效
DISTINCT
Distinct与Group by 不同之处：
- distinct可以和group by 合用
- 当Limit被定义并且没有Order by时，在读取了所需数目的不同行之后，查询立即停止运行。
- 数据块是在处理它们的过程中产生的，而不需要等待整个查询完成运行。
在至少有一个数组存在的情况下，distinct是不被支持的
LIMIT
如果没有一个ORDER BY子句显式地对结果进行排序，那么结果可能是任意的和不确定的UNION ALL
你可以使用UNION ALL来合并任意数量的查询
-
SELECT CounterID,
1
AS
table, toInt64(
count())
AS c
-
FROM test.hits
-
GROUP
BY CounterID
-
-
UNION ALL
-
-
SELECT CounterID,
2
AS
table,
sum(
Sign)
AS c
-
FROM test.visits
-
GROUP
BY CounterID
-
HAVING c >
0
可能列名有所不同，但最终列名取自第一个查询
INTO OUTFILE
添加到OUTFILE filename子句（其中文件名是一个字符串文字）将查询输出重定向到指定的文件。与MySQL相反，文件是在客户端创建的。如果具有相同文件名的文件已经存在，那么查询将失败。这个功能在命令行客户端和clicklocal本地（通过HTTP接口发送的查询将失败）
默认的输出格式是TAB分离的
FORMAT
指定格式“格式”以获取任何指定格式的数据。您可以将其用于方便，或用于创建转储。要了解更多信息，请参阅“格式”一节。如果省略了格式子句，则使用默认的格式，这取决于用于访问DB的设置和接口。对于HTTP接口和批处理模式下的命令行客户端，默认的格式是制表符。对于交互式模式下的命令行客户端，缺省格式是PrettyCompact（它有吸引和紧凑的表）
IN
操作符的左边要么是一个列，要么是一个元祖
-
SELECT UserID
IN (
123,
456)
FROM ...
-
SELECT (CounterID, UserID)
IN ((
34,
123), (
101500,
456))
FROM ...
子查询可以为过滤元组指定多个列
SELECT (CounterID, UserID) IN (SELECT CounterID, UserID FROM ...) FROM ...
左右两边列应该具有相同的类型
查询操作符和子查询可以发生在查询的任何部分，包括聚合函数和lambda函数
SELECT EventDate, avg(UserID IN ( SELECT UserID FROM test.hits WHERE EventDate = toDate('2014-03-17') )) AS ratio FROM test.hits GROUP BY EventDate ORDER BY EventDate Asc
Distributed subqueries
分布式子查询
in/join 与GLOBAL in /GLOBAL join 的区别：
当使用in的时候，查询被发送到远程服务器，并且每个服务器都在IN或JOIN子句中运行子查询
如
SELECT uniq(UserID) FROM distributed_table
将会被发送到所有远程服务器
SELECT uniq(UserID) FROM local_table
两个受众交集的计算：
SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM local_table WHERE CounterID = 34)
这个查询将发送到所有服务器
SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM local_table WHERE CounterID = 34)
换句话说， In子句中的数据集将在每个服务器上独立地收集，只收集本地储存的数据。
如果您已经准备好了这种情况，并且在集群服务器上分布数据，那么单个UserID的数据完全驻留在一台服务器上，那么这将是正确和最优的。在这种情况下，所有必需的数据将在每个服务器上本地可用。否则，结果将是不准确的。我们将该查询的变体称为“localin”
当数据在集群服务器上随机分布时，为了纠正查询的工作方式，您可以在子查询中指定分布表。这个查询看起来是这样的：
SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM distributed_table WHERE CounterID = 34)
这个查询将被发送到所有远程服务器
SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM distributed_table WHERE CounterID = 34)
子查询将开始在每个远程服务器上运行。由于子查询使用分布式表，所以每个远程服务器上的子查询将会对每个远程服务器都感到不满，如果您有一个100个服务器集群，执行整个查询将需要10000个基本请求，这通常被认为是不可接受的。
SELECT UserID FROM local_table WHERE CounterID = 34
在这种情况下，您应该始终使用GLOBAL in 而不是In。让我们看看它是如何在查询中工作的
SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID GLOBAL IN (SELECT UserID FROM distributed_table WHERE CounterID = 34)
服务器将运行子查询
SELECT UserID FROM distributed_table WHERE CounterID = 34
结果将被放在RAM中的临时表中。然后请求将被发送到每个远程服务器
SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID GLOBAL IN _data1
记住以下几点：
- 在创建临时表时，数据不是惟一的。为了减少通过网络传输的数据量，在子查询中指定不同的数据。在 in 的情况下不用
- 临时表将被发送到所有远程服务器。传输不考虑网络拓扑。例如，如果10个远程服务器驻留在与请求者服务器相对较远的数据中心中，那么数据将通过通道发送10次到远程数据中心。在使用global in时尽量避免大数据集
- 在将数据传输到远程服务器时，对网络带宽的限制是不可配置的。你可能会让网络超负荷
- 尝试跨服务器分发数据，这样您就不需要经常使用global in。
- 如果您需要经常使用global in，那么就计划一下ClickHouse集群的位置，这样单个副本就可以驻留在一个数据中心中，并且在它们之间建立一个快速网络，这样一个查询就可以在一个数据中心内进行处理了
Extreme values
极值 除了结果之外，您还可以获得结果列的最小值和最大值。要做到这一点，将extremes设置为1。对于数值类型、日期和日期，计算最小值和最大值。对于其他栏目，输出的是默认值Notes
笔记，说明
group by 和order by 不支持位置参数，比如group by 1,2不是按第一列第二列聚集，而会被解释为常量分组，即所有行聚合为1
你可以在查询的任何部分加上一个*而不是表达式，但只有少部分*是合理的：
- 创建表转储时
- 对于仅包含几个列的表，如系统表
- 为了获取关于表中有哪些列。在这种情况下，设置limit 1，最好使用DESC查询。
- 当在少量的列上使用强过滤时 prewhere
- 在子查询中（因为外部查询不需要的列被排除在子查询之外）。
KILL QUERY
-
KILL
QUERY
-
WHERE <
where expression
to
SELECT
FROM system.processes
query>
-
[
SYNC|ASYNC|
TEST]
-
[
FORMAT
format]
尝试终止当前正在运行的查询。从系统中选择terminate查询
例如：
-
-- Terminates all queries with the specified query_id.
-
KILL
QUERY
WHERE query_id=
'2-857d-4a57-9ee0-327da5d60a90'
-
-
-- Synchronously terminates all queries run by `username`.
-
KILL
QUERY
WHERE
user=
'username'
SYNC
2296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
