Doris--基础--3.5--SQL--建表

Doris–基础–3.5–SQL–建表


1、查看帮助

1.1、命令

HELP CREATE TABLE;

1.2、内容

MySQL [(none)]> help create table
Name: 'CREATE TABLE'
Description:

该语句用于创建 table。
语法:

```
CREATE [EXTERNAL] TABLE [IF NOT EXISTS] [database.]table_name
(column_definition1[, column_definition2, ...]
[, index_definition1[, index_definition2, ...]])
[ENGINE = [olap|mysql|broker|hive|iceberg]]
[key_desc]
[COMMENT "table comment"];
[partition_desc]
[distribution_desc]
[rollup_index]
[PROPERTIES ("key"="value", ...)]
[BROKER PROPERTIES ("key"="value", ...)]
```

1. column_definition
语法:
`col_name col_type [agg_type] [NULL | NOT NULL] [DEFAULT "default_value"]`

说明:
col_name:列名称
col_type:列类型

```
	BOOLEAN(1字节)
		范围:{0,1}
	TINYINT(1字节)
		范围:-2^7 + 1 ~ 2^7 - 1
	SMALLINT(2字节)
		范围:-2^15 + 1 ~ 2^15 - 1
	INT(4字节)
		范围:-2^31 + 1 ~ 2^31 - 1
	BIGINT(8字节)
		范围:-2^63 + 1 ~ 2^63 - 1
	LARGEINT(16字节)
		范围:-2^127 + 1 ~ 2^127 - 1
	FLOAT(4字节)
		支持科学计数法
	DOUBLE(8字节)
		支持科学计数法
	DECIMAL[(precision, scale)] (16字节)
		保证精度的小数类型。默认是 DECIMAL(10, 0)
		precision: 1 ~ 27
		scale: 0 ~ 9
		其中整数部分为 1 ~ 18
		不支持科学计数法
	DATE(3字节)
		范围:0000-01-01 ~ 9999-12-31
	DATETIME(8字节)
		范围:0000-01-01 00:00:00 ~ 9999-12-31 23:59:59
	CHAR[(length)]
		定长字符串。长度范围:1 ~ 255。默认为1
	VARCHAR[(length)]
		变长字符串。长度范围:1 ~ 65533
	HLL (1~16385个字节)
		hll列类型,不需要指定长度和默认值、长度根据数据的聚合
		程度系统内控制,并且HLL列只能通过配套的hll_union_agg、Hll_cardinality、hll_hash进行查询或使用
	BITMAP
		bitmap列类型,不需要指定长度和默认值。表示整型的集合,元素最大支持到2^64 - 1
```

agg_type:聚合类型,如果不指定,则该列为 key 列。否则,该列为 value 列

   * SUM、MAX、MIN、REPLACE
   * HLL_UNION(仅用于HLL列,为HLL独有的聚合方式)、
   * BITMAP_UNION(仅用于 BITMAP 列,为 BITMAP 独有的聚合方式)、
   * REPLACE_IF_NOT_NULL:这个聚合类型的含义是当且仅当新导入数据是非NULL值时会发生替换行为,如果新导入的数据是NULL,那么Doris仍然会保留原值。注意:如果用在建表时REPLACE_IF_NOT_NULL列指定了NOT NULL,那么Doris仍然会将其转化NULL,不会向用户报错。用户可以借助这个类型完成部分列导入的功能。**这里要注意的是字段默认值要给NULL,而不能是空字符串,如果是空字符串,会给你替换成空字符串**。
   * 该类型只对聚合模型(key_desc的type为AGGREGATE KEY)有用,其它模型不需要指这个。

是否允许为NULL: 默认允许为 NULL。NULL 值在导入数据中用 \N 来表示

注意:
	BITMAP_UNION聚合类型列在导入时的原始数据类型必须是TINYINT,SMALLINT,INT,BIGINT。

2. index_definition
语法:
	`INDEX index_name (col_name[, col_name, ...]) [USING BITMAP] COMMENT 'xxxxxx'`
说明:
	index_name:索引名称
	col_name:列名
注意:
	当前仅支持BITMAP索引, BITMAP索引仅支持应用于单列

3. ENGINE 类型
默认为 olap。可选 mysql, broker, hive, iceberg
1) 如果是 mysql,则需要在 properties 提供以下信息:

```
PROPERTIES (
	"host" = "mysql_server_host",
	"port" = "mysql_server_port",
	"user" = "your_user_name",
	"password" = "your_password",
	"database" = "database_name",
	"table" = "table_name"
	)
```

注意:
	"table" 条目中的 "table_name" 是 mysql 中的真实表名。
	而 CREATE TABLE 语句中的 table_name 是该 mysql 表在 Doris 中的名字,可以不同。

在 Doris 创建 mysql 表的目的是可以通过 Doris 访问 mysql 数据库。
	而 Doris 本身并不维护、存储任何 mysql 数据。
2) 如果是 broker,表示表的访问需要通过指定的broker, 需要在 properties 提供以下信息:
	```
	PROPERTIES (
	"broker_name" = "broker_name",
	"path" = "file_path1[,file_path2]",
	"column_separator" = "value_separator"
	"line_delimiter" = "value_delimiter"
	)
	```
	另外还需要提供Broker需要的Property信息,通过BROKER PROPERTIES来传递,例如HDFS需要传入
	```
	BROKER PROPERTIES(
		"username" = "name",
		"password" = "password"
	)
	```
	这个根据不同的Broker类型,需要传入的内容也不相同
注意:
	"path" 中如果有多个文件,用逗号[,]分割。如果文件名中包含逗号,那么使用 %2c 来替代。如果文件名中包含 %,使用 %25 代替
	现在文件内容格式支持CSV,支持GZ,BZ2,LZ4,LZO(LZOP) 压缩格式。

3) 如果是 hive,则需要在 properties 提供以下信息:
```
PROPERTIES (
	"database" = "hive_db_name",
	"table" = "hive_table_name",
	"hive.metastore.uris" = "thrift://127.0.0.1:9083"
)

```
其中 database 是 hive 表对应的库名字,table 是 hive 表的名字,hive.metastore.uris 是 hive metastore 服务地址。

4)如果是 iceberg,则需要在 properties 中提供以下信息:
```
	PROPERTIES (
		"iceberg.database" = "iceberg_db_name",
		"iceberg.table" = "iceberg_table_name",
		"iceberg.hive.metastore.uris" = "thrift://127.0.0.1:9083",
		"iceberg.catalog.type" = "HIVE_CATALOG"
		)

```
其中 database 是 Iceberg 对应的库名;  
table 是 Iceberg 中对应的表名;
hive.metastore.uris 是 hive metastore 服务地址;  
catalog.type 默认为 HIVE_CATALOG。当前仅支持 HIVE_CATALOG,后续会支持更多 Iceberg catalog 类型。


4. key_desc
语法:
	`key_type(k1[,k2 ...])`
说明:
	数据按照指定的key列进行排序,且根据不同的key_type具有不同特性。
	key_type支持以下类型:
			AGGREGATE KEY:key列相同的记录,value列按照指定的聚合类型进行聚合,
						 适合报表、多维分析等业务场景。
			UNIQUE KEY:key列相同的记录,value列按导入顺序进行覆盖,
						 适合按key列进行增删改查的点查询业务。
			DUPLICATE KEY:key列相同的记录,同时存在于Doris中,
						 适合存储明细数据或者数据无聚合特性的业务场景。
	默认为DUPLICATE KEY,key列为列定义中前36个字节, 如果前36个字节的列数小于3,将使用前三列。
注意:
	除AGGREGATE KEY外,其他key_type在建表时,value列不需要指定聚合类型。

5. partition_desc
目前支持 RANGE 和 LIST 两种分区方式。
5.1 RANGE 分区
	RANGE partition描述有两种使用方式
	1) LESS THAN
		语法:

		```
			PARTITION BY RANGE (k1, k2, ...)
			(
			PARTITION partition_name1 VALUES LESS THAN MAXVALUE|("value1", "value2", ...),
			PARTITION partition_name2 VALUES LESS THAN MAXVALUE|("value1", "value2", ...)
			...
			)
		```
		
		说明:
			使用指定的 key 列和指定的数值范围进行分区。
			1) 分区名称仅支持字母开头,字母、数字和下划线组成
			2) 目前仅支持以下类型的列作为 Range 分区列
				TINYINT, SMALLINT, INT, BIGINT, LARGEINT, DATE, DATETIME
			3) 分区为左闭右开区间,首个分区的左边界为做最小值
			4) NULL 值只会存放在包含最小值的分区中。当包含最小值的分区被删除后,NULL 值将无法导入。
			5) 可以指定一列或多列作为分区列。如果分区值缺省,则会默认填充最小值。
		
		注意:
			1) 分区一般用于时间维度的数据管理
			2) 有数据回溯需求的,可以考虑首个分区为空分区,以便后续增加分区
	
	2)Fixed Range
		语法:
		```
			PARTITION BY RANGE (k1, k2, k3, ...)
			(
			PARTITION partition_name1 VALUES [("k1-lower1", "k2-lower1", "k3-lower1",...), ("k1-upper1", "k2-upper1", "k3-upper1", ...)),
			PARTITION partition_name2 VALUES [("k1-lower1-2", "k2-lower1-2", ...), ("k1-upper1-2", MAXVALUE, ))
			"k3-upper1-2", ...
			)
		```
		说明:
			1)Fixed Range比LESS THAN相对灵活些,左右区间完全由用户自己确定
			2)其他与LESS THAN保持同步

5.2 LIST 分区
	LIST partition分为单列分区和多列分区
	1) 单列分区
		语法:

		```
			PARTITION BY LIST(k1)
			(
			PARTITION partition_name1 VALUES IN ("value1", "value2", ...),
			PARTITION partition_name2 VALUES IN ("value1", "value2", ...)
			...
			)
		```
	
		说明:
			使用指定的 key 列和制定的枚举值进行分区。
			1) 分区名称仅支持字母开头,字母、数字和下划线组成
			2) 目前仅支持以下类型的列作为 List 分区列
				BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, DATE, DATETIME, CHAR, VARCHAR
			3) 分区为枚举值集合,各个分区之间分区值不能重复
			4) 不可导入 NULL 值
			5) 分区值不能缺省,必须指定至少一个
	
	2) 多列分区
		语法:
	
		```
			PARTITION BY LIST(k1, k2)
			(
			PARTITION partition_name1 VALUES IN (("value1", "value2"), ("value1", "value2"), ...),
			PARTITION partition_name2 VALUES IN (("value1", "value2"), ("value1", "value2"), ...)
			...
			)
		```
	
		说明:
			1) 多列分区的分区是元组枚举值的集合
			2) 每个元组值的个数必须与分区列个数相等
			3) 其他与单列分区保持同步

6. distribution_desc
	1) Hash 分桶
	语法:
		`DISTRIBUTED BY HASH (k1[,k2 ...]) [BUCKETS num]`
	说明:
		使用指定的 key 列进行哈希分桶。
	2) Random 分桶
	语法:
		`DISTRIBUTED BY RANDOM [BUCKETS num]`
	说明:
		使用随机数进行分桶。  
建议: 当没有合适的key做哈希分桶使得表的数据均匀分布的时候,建议使用RANDOM分桶方式。

7. PROPERTIES
1) 如果 ENGINE 类型为 olap
	   可以在 properties 设置该表数据的初始存储介质、存储到期时间和副本数。

```
   PROPERTIES (
	   "storage_medium" = "[SSD|HDD]",
	   ["storage_cooldown_time" = "yyyy-MM-dd HH:mm:ss"],
	   ["replication_num" = "3"]
	   ["replication_allocation" = "xxx"]
	   )
```

   storage_medium:        用于指定该分区的初始存储介质,可选择 SSD 或 HDD。默认初始存储介质可通过fe的配置文件 `fe.conf` 中指定 `default_storage_medium=xxx`,如果没有指定,则默认为 HDD。
						   注意:当FE配置项 `enable_strict_storage_medium_check` 为 `True` 时,若集群中没有设置对应的存储介质时,建表语句会报错 `Failed to find enough host in all backends with storage medium is SSD|HDD`. 
   storage_cooldown_time: 当设置存储介质为 SSD 时,指定该分区在 SSD 上的存储到期时间。
						   默认存放 30 天。
						   格式为:"yyyy-MM-dd HH:mm:ss"
   replication_num:        指定分区的副本数。默认为 3。
   replication_allocation:     按照资源标签来指定副本分布。

   当表为单分区表时,这些属性为表的属性。
	   当表为两级分区时,这些属性为附属于每一个分区。
	   如果希望不同分区有不同属性。可以通过 ADD PARTITION 或 MODIFY PARTITION 进行操作

2) 如果 Engine 类型为 olap, 可以指定某列使用 bloom filter 索引
	   bloom filter 索引仅适用于查询条件为 in 和 equal 的情况,该列的值越分散效果越好
	   目前只支持以下情况的列:除了 TINYINT FLOAT DOUBLE 类型以外的 key 列及聚合方法为 REPLACE 的 value 列

```
   PROPERTIES (
	   "bloom_filter_columns"="k1,k2,k3"
	   )
```

3) 如果希望使用 Colocate Join 特性,需要在 properties 中指定

```
   PROPERTIES (
	   "colocate_with"="table1"
	   )
```

4) 如果希望使用动态分区特性,需要在properties 中指定。注意:动态分区只支持 RANGE 分区

```
  PROPERTIES (
	  "dynamic_partition.enable" = "true|false",
	  "dynamic_partition.time_unit" = "HOUR|DAY|WEEK|MONTH",
	  "dynamic_partition.start" = "${integer_value}",
	  "dynamic_partition.end" = "${integer_value}",
	  "dynamic_partition.prefix" = "${string_value}",
	  "dynamic_partition.buckets" = "${integer_value}
```
dynamic_partition.enable: 用于指定表级别的动态分区功能是否开启。默认为 true。
dynamic_partition.time_unit: 用于指定动态添加分区的时间单位,可选择为HOUR(小时),DAY(天),WEEK(周),MONTH(月)。
							 注意:以小时为单位的分区列,数据类型不能为 DATE。
dynamic_partition.start: 用于指定向前删除多少个分区。值必须小于0。默认为 Integer.MIN_VALUE。
dynamic_partition.end: 用于指定提前创建的分区数量。值必须大于0。
dynamic_partition.prefix: 用于指定创建的分区名前缀,例如分区名前缀为p,则自动创建分区名为p20200108
dynamic_partition.buckets: 用于指定自动创建的分区分桶数量
dynamic_partition.create_history_partition: 用于创建历史分区功能是否开启。默认为 false。
dynamic_partition.history_partition_num: 当开启创建历史分区功能时,用于指定创建历史分区数量。
dynamic_partition.reserved_history_periods: 用于指定保留的历史分区的时间段。

5) 建表时可以批量创建多个 Rollup
语法:
```
	ROLLUP (rollup_name (column_name1, column_name2, ...)
		   [FROM from_index_name]
			[PROPERTIES ("key"="value", ...)],...)
```

6) 如果希望使用 内存表 特性,需要在 properties 中指定

```
	PROPERTIES (
	   "in_memory"="true"
	)   
```
当 in_memory 属性为 true 时,Doris会尽可能将该表的数据和索引Cache到BE 内存中

7) 创建UNIQUE_KEYS表时,可以指定一个sequence列,当KEY列相同时,将按照sequence列进行REPLACE(较大值替换较小值,否则无法替换)

```
	PROPERTIES (
		"function_column.sequence_type" = 'Date',
	);
```
sequence_type用来指定sequence列的类型,可以为整型和时间类型
Examples:

1. 创建一个 olap 表,使用 HASH 分桶,使用列存,相同key的记录进行聚合

```
CREATE TABLE example_db.table_hash
(
k1 BOOLEAN,
k2 TINYINT,
k3 DECIMAL(10, 2) DEFAULT "10.5",
v1 CHAR(10) REPLACE,
v2 INT SUM
)
ENGINE=olap
AGGREGATE KEY(k1, k2, k3)
COMMENT "my first doris table"
DISTRIBUTED BY HASH(k1) BUCKETS 32;
```

2. 创建一个 olap 表,使用 Hash 分桶,使用列存,相同key的记录进行覆盖,
设置初始存储介质和冷却时间

```
CREATE TABLE example_db.table_hash
(
k1 BIGINT,
k2 LARGEINT,
v1 VARCHAR(2048) REPLACE,
v2 SMALLINT SUM DEFAULT "10"
)
ENGINE=olap
AGGREGATE KEY(k1, k2)
DISTRIBUTED BY HASH (k1, k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD",
"storage_cooldown_time" = "2015-06-04 00:00:00"
);
```

3. 创建一个 olap 表,使用 Range 分区,使用Hash分桶,默认使用列存,
相同key的记录同时存在,设置初始存储介质和冷却时间

1)LESS THAN

```
CREATE TABLE example_db.table_range
(
k1 DATE,
k2 INT,
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
ENGINE=olap
DUPLICATE KEY(k1, k2, k3)
PARTITION BY RANGE (k1)
(
PARTITION p1 VALUES LESS THAN ("2014-01-01"),
PARTITION p2 VALUES LESS THAN ("2014-06-01"),
PARTITION p3 VALUES LESS THAN ("2014-12-01")
)
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD", "storage_cooldown_time" = "2015-06-04 00:00:00"
);
```

说明:
这个语句会将数据划分成如下3个分区:

```
( {    MIN     },   {"2014-01-01"} )
[ {"2014-01-01"},   {"2014-06-01"} )
[ {"2014-06-01"},   {"2014-12-01"} )
```

不在这些分区范围内的数据将视为非法数据被过滤

2) Fixed Range

```
CREATE TABLE table_range
(
k1 DATE,
k2 INT,
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
ENGINE=olap
DUPLICATE KEY(k1, k2, k3)
PARTITION BY RANGE (k1, k2, k3)
(
PARTITION p1 VALUES [("2014-01-01", "10", "200"), ("2014-01-01", "20", "300")),
PARTITION p2 VALUES [("2014-06-01", "100", "200"), ("2014-07-01", "100", "300"))
)
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD"
);
```

4. 创建一个 olap 表,使用 List 分区,使用Hash分桶,默认使用列存,
相同key的记录同时存在,设置初始存储介质和冷却时间

1)单列分区

```
CREATE TABLE example_db.table_list
(
k1 INT,
k2 VARCHAR(128),
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
ENGINE=olap
DUPLICATE KEY(k1, k2, k3)
PARTITION BY LIST (k1)
(
PARTITION p1 VALUES IN ("1", "2", "3"),
PARTITION p2 VALUES IN ("4", "5", "6"),
PARTITION p3 VALUES IN ("7", "8", "9")
)
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD", "storage_cooldown_time" = "2022-06-04 00:00:00"
);
```

说明:
这个语句会将数据划分成如下3个分区:

```
("1", "2", "3")
("4", "5", "6")
("7", "8", "9")
```

不在这些分区枚举值内的数据将视为非法数据被过滤

2) 多列分区

```
CREATE TABLE example_db.table_list
(
k1 INT,
k2 VARCHAR(128),
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
ENGINE=olap
DUPLICATE KEY(k1, k2, k3)
PARTITION BY LIST (k1, k2)
(
PARTITION p1 VALUES IN (("1","beijing"), ("1", "shanghai")),
PARTITION p2 VALUES IN (("2","beijing"), ("2", "shanghai")),
PARTITION p3 VALUES IN (("3","beijing"), ("3", "shanghai"))
)
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD", "storage_cooldown_time" = "2022-06-04 00:00:00"
);
```

说明:
这个语句会将数据划分成如下3个分区:

```
(("1","beijing"), ("1", "shanghai"))
(("2","beijing"), ("2", "shanghai"))
(("3","beijing"), ("3", "shanghai"))
```

不在这些分区枚举值内的数据将视为非法数据被过滤

5. 创建一个 mysql 表

5.1 直接通过外表信息创建mysql表
```
CREATE EXTERNAL TABLE example_db.table_mysql
(
k1 DATE,
k2 INT,
k3 SMALLINT,
k4 VARCHAR(2048),
k5 DATETIME
)
ENGINE=mysql
PROPERTIES
(
"host" = "127.0.0.1",
"port" = "8239",
"user" = "mysql_user",
"password" = "mysql_passwd",
"database" = "mysql_db_test",
"table" = "mysql_table_test"
)
```

5.2 通过External Catalog Resource创建mysql表
```
CREATE EXTERNAL RESOURCE "mysql_resource" 
PROPERTIES
(
 "type" = "odbc_catalog",
 "user" = "mysql_user",
 "password" = "mysql_passwd",
 "host" = "127.0.0.1",
  "port" = "8239"			
);
```
```
CREATE EXTERNAL TABLE example_db.table_mysql
(
k1 DATE,
k2 INT,
k3 SMALLINT,
k4 VARCHAR(2048),
k5 DATETIME
)
ENGINE=mysql
PROPERTIES
(
"odbc_catalog_resource" = "mysql_resource",
"database" = "mysql_db_test",
"table" = "mysql_table_test"
)
```

6. 创建一个数据文件存储在HDFS上的 broker 外部表, 数据使用 "|" 分割,"\n" 换行

```
CREATE EXTERNAL TABLE example_db.table_broker (
k1 DATE,
k2 INT,
k3 SMALLINT,
k4 VARCHAR(2048),
k5 DATETIME
)
ENGINE=broker
PROPERTIES (
"broker_name" = "hdfs",
"path" = "hdfs://hdfs_host:hdfs_port/data1,hdfs://hdfs_host:hdfs_port/data2,hdfs://hdfs_host:hdfs_port/data3%2c4",
"column_separator" = "|",
"line_delimiter" = "\n"
)
BROKER PROPERTIES (
"username" = "hdfs_user",
"password" = "hdfs_password"
)
```

7. 创建一张含有HLL列的表

```
CREATE TABLE example_db.example_table
(
k1 TINYINT,
k2 DECIMAL(10, 2) DEFAULT "10.5",
v1 HLL HLL_UNION,
v2 HLL HLL_UNION
)
ENGINE=olap
AGGREGATE KEY(k1, k2)
DISTRIBUTED BY HASH(k1) BUCKETS 32;
```

8. 创建一张含有BITMAP_UNION聚合类型的表(v1和v2列的原始数据类型必须是TINYINT,SMALLINT,INT)

```
CREATE TABLE example_db.example_table
(
k1 TINYINT,
k2 DECIMAL(10, 2) DEFAULT "10.5",
v1 BITMAP BITMAP_UNION,
v2 BITMAP BITMAP_UNION
)
ENGINE=olap
AGGREGATE KEY(k1, k2)
DISTRIBUTED BY HASH(k1) BUCKETS 32;
```

9. 创建两张支持Colocate Join的表t1 和t2

```
CREATE TABLE `t1` (
`id` int(11) COMMENT "",
`value` varchar(8) COMMENT ""
) ENGINE=OLAP
DUPLICATE KEY(`id`)
DISTRIBUTED BY HASH(`id`) BUCKETS 10
PROPERTIES (
"colocate_with" = "t1"
);

CREATE TABLE `t2` (
`id` int(11) COMMENT "",
`value` varchar(8) COMMENT ""
) ENGINE=OLAP
DUPLICATE KEY(`id`)
DISTRIBUTED BY HASH(`id`) BUCKETS 10
PROPERTIES (
"colocate_with" = "t1"
);
```

10. 创建一个数据文件存储在BOS上的 broker 外部表

```
CREATE EXTERNAL TABLE example_db.table_broker (
k1 DATE
)
ENGINE=broker
PROPERTIES (
"broker_name" = "bos",
"path" = "bos://my_bucket/input/file",
)
BROKER PROPERTIES (
  "bos_endpoint" = "http://bj.bcebos.com",
  "bos_accesskey" = "xxxxxxxxxxxxxxxxxxxxxxxxxx",
  "bos_secret_accesskey"="yyyyyyyyyyyyyyyyyyyy"
)
```

11. 创建一个带有bitmap 索引的表

```
CREATE TABLE example_db.table_hash
(
k1 TINYINT,
k2 DECIMAL(10, 2) DEFAULT "10.5",
v1 CHAR(10) REPLACE,
v2 INT SUM,
INDEX k1_idx (k1) USING BITMAP COMMENT 'xxxxxx'
)
ENGINE=olap
AGGREGATE KEY(k1, k2)
COMMENT "my first doris table"
DISTRIBUTED BY HASH(k1) BUCKETS 32;
```

12. 创建一个动态分区表(需要在FE配置中开启动态分区功能),该表每天提前创建3天的分区,并删除3天前的分区。例如今天为`2020-01-08`,则会创建分区名为`p20200108`, `p20200109`, `p20200110`, `p20200111`的分区. 分区范围分别为: 

```
[types: [DATE]; keys: [2020-01-08]; ‥types: [DATE]; keys: [2020-01-09]; )
[types: [DATE]; keys: [2020-01-09]; ‥types: [DATE]; keys: [2020-01-10]; )
[types: [DATE]; keys: [2020-01-10]; ‥types: [DATE]; keys: [2020-01-11]; )
[types: [DATE]; keys: [2020-01-11]; ‥types: [DATE]; keys: [2020-01-12]; )
```

```
CREATE TABLE example_db.dynamic_partition
(
k1 DATE,
k2 INT,
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
ENGINE=olap
DUPLICATE KEY(k1, k2, k3)
PARTITION BY RANGE (k1) ()
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"storage_medium" = "SSD",
"dynamic_partition.time_unit" = "DAY",
"dynamic_partition.start" = "-3",
"dynamic_partition.end" = "3",
"dynamic_partition.prefix" = "p",
"dynamic_partition.buckets" = "32"
 );
```

13. 创建一个带有rollup索引的表
```
CREATE TABLE example_db.rollup_index_table
(
	event_day DATE,
	siteid INT DEFAULT '10',
	citycode SMALLINT,
	username VARCHAR(32) DEFAULT '',
	pv BIGINT SUM DEFAULT '0'
)
AGGREGATE KEY(event_day, siteid, citycode, username)
DISTRIBUTED BY HASH(siteid) BUCKETS 10
rollup (
r1(event_day,siteid),
r2(event_day,citycode),
r3(event_day)
)
PROPERTIES("replication_num" = "3");
```
14. 创建一个内存表

```
CREATE TABLE example_db.table_hash
(
k1 TINYINT,
k2 DECIMAL(10, 2) DEFAULT "10.5",
v1 CHAR(10) REPLACE,
v2 INT SUM,
INDEX k1_idx (k1) USING BITMAP COMMENT 'xxxxxx'
)
ENGINE=olap
AGGREGATE KEY(k1, k2)
COMMENT "my first doris table"
DISTRIBUTED BY HASH(k1) BUCKETS 32
PROPERTIES ("in_memory"="true");
```

15. 创建一个hive外部表

```
CREATE TABLE example_db.table_hive
(
  k1 TINYINT,
  k2 VARCHAR(50),
  v INT
)
ENGINE=hive
PROPERTIES
(
  "database" = "hive_db_name",
  "table" = "hive_table_name",
  "hive.metastore.uris" = "thrift://127.0.0.1:9083"
);
```

16. 通过 replication_allocation 指定表的副本分布

```	
CREATE TABLE example_db.table_hash
(
k1 TINYINT,
k2 DECIMAL(10, 2) DEFAULT "10.5"
)
DISTRIBUTED BY HASH(k1) BUCKETS 32
PROPERTIES (
	"replication_allocation"="tag.location.group_a:1, tag.location.group_b:2"
);


CREATE TABLE example_db.dynamic_partition
(
k1 DATE,
k2 INT,
k3 SMALLINT,
v1 VARCHAR(2048),
v2 DATETIME DEFAULT "2014-02-04 15:36:00"
)
PARTITION BY RANGE (k1) ()
DISTRIBUTED BY HASH(k2) BUCKETS 32
PROPERTIES(
"dynamic_partition.time_unit" = "DAY",
"dynamic_partition.start" = "-3",
"dynamic_partition.end" = "3",
"dynamic_partition.prefix" = "p",
"dynamic_partition.buckets" = "32",
"dynamic_partition."replication_allocation" = "tag.location.group_a:3"
 );
```

17. 创建一个 Iceberg 外表

```
CREATE TABLE example_db.t_iceberg 
ENGINE=ICEBERG
PROPERTIES (
"iceberg.database" = "iceberg_db",
"iceberg.table" = "iceberg_table",
"iceberg.hive.metastore.uris"  =  "thrift://127.0.0.1:9083",
"iceberg.catalog.type"  =  "HIVE_CATALOG"
);

```

2、建表

2.1、语法

CREATE [EXTERNAL] TABLE [IF NOT EXISTS] [database.]table_name
(column_definition1[, column_definition2, ...]
[, index_definition1[, index_definition2, ...]])
[ENGINE = [olap|mysql|broker|hive|iceberg]]
[key_desc]
[COMMENT "table comment"];
[partition_desc]
[distribution_desc]
[rollup_index]
[PROPERTIES ("key"="value", ...)]
[BROKER PROPERTIES ("key"="value", ...)]

2.1.1、案例

CREATE TABLE IF NOT EXISTS test_db.table0
(
    `user_id` LARGEINT NOT NULL COMMENT "用户id",
    `date` DATE NOT NULL COMMENT "数据灌入日期时间",
    `timestamp` DATETIME NOT NULL COMMENT "数据灌入的时间戳",
    `city` VARCHAR(20) COMMENT "用户所在城市",
    `age` SMALLINT COMMENT "用户年龄",
    `sex` TINYINT COMMENT "用户性别",
    `last_visit_date` DATETIME REPLACE DEFAULT "1970-01-01 00:00:00" COMMENT "用户最后一次访问时间",
    `cost` BIGINT SUM DEFAULT "0" COMMENT "用户总消费",
    `max_dwell_time` INT MAX DEFAULT "0" COMMENT "用户最大停留时间",
    `min_dwell_time` INT MIN DEFAULT "99999" COMMENT "用户最小停留时间"
)
ENGINE=olap
AGGREGATE KEY(`user_id`, `date`, `timestamp`, `city`, `age`, `sex`)
PARTITION BY RANGE(`date`)
(
    PARTITION `p202001` VALUES LESS THAN ("2020-02-01"),
    PARTITION `p202002` VALUES LESS THAN ("2020-03-01"),
    PARTITION `p202003` VALUES LESS THAN ("2020-04-01")
)
DISTRIBUTED BY HASH(`user_id`) BUCKETS 16
PROPERTIES
(
    "replication_num" = "3" 
);

Doris--基础--3.5--SQL--建表_第1张图片

2.1.2、Partition

2.1.3、Bucket

Doris--基础--3.5--SQL--建表_第2张图片

2.1.4、PROPERTIES

2.1.5、ENGINE

Doris--基础--3.5--SQL--建表_第3张图片

2.2、字段类型

2.2.1、普通

BOOLEAN(1字节)
	范围:{0,1}
TINYINT(1字节)
	范围:-2^7 + 1 ~ 2^7 - 1
SMALLINT(2字节)
	范围:-2^15 + 1 ~ 2^15 - 1
INT(4字节)
	范围:-2^31 + 1 ~ 2^31 - 1
BIGINT(8字节)
	范围:-2^63 + 1 ~ 2^63 - 1
LARGEINT(16字节)
	范围:-2^127 + 1 ~ 2^127 - 1
FLOAT(4字节)
	支持科学计数法
DOUBLE(8字节)
	支持科学计数法
DECIMAL[(precision, scale)] (16字节)
	保证精度的小数类型。默认是 DECIMAL(10, 0)
	precision: 1 ~ 27
	scale: 0 ~ 9
	其中整数部分为 1 ~ 18
	不支持科学计数法
DATE(3字节)
	范围:0000-01-01 ~ 9999-12-31
DATETIME(8字节)
	范围:0000-01-01 00:00:00 ~ 9999-12-31 23:59:59
CHAR[(length)]
	定长字符串。长度范围:1 ~ 255。默认为1
VARCHAR[(length)]
	变长字符串。长度范围:1 ~ 65533
HLL (1~16385个字节)
	hll列类型,不需要指定长度和默认值、长度根据数据的聚合
	程度系统内控制,并且HLL列只能通过配套的hll_union_agg、Hll_cardinality、hll_hash进行查询或使用
BITMAP
	bitmap列类型,不需要指定长度和默认值。表示整型的集合,元素最大支持到2^64 - 1

 

2.2.2、agg_type:聚合类型,如果不指定,则该列为 key 列。否则,该列为 value 列

  • SUM、MAX、MIN、REPLACE
  • HLL_UNION(仅用于HLL列,为HLL独有的聚合方式)、
  • BITMAP_UNION(仅用于 BITMAP 列,为 BITMAP 独有的聚合方式)、
  • REPLACE_IF_NOT_NULL:这个聚合类型的含义是当且仅当新导入数据是非NULL值时会发生替换行为,如果新导入的数据是NULL,那么Doris仍然会保留原值。注意:如果用在建表时REPLACE_IF_NOT_NULL列指定了NOT NULL,那么Doris仍然会将其转化NULL,不会向用户报错。用户可以借助这个类型完成部分列导入的功能。这里要注意的是字段默认值要给NULL,而不能是空字符串,如果是空字符串,会给你替换成空字符串
    • 该类型只对聚合模型(key_desc的type为AGGREGATE KEY)有用,其它模型不需要指这个。

3、关于 Partition 和 Bucket 的数量和数据量的建议

  1. 一个表的 Tablet 总数量等于 (Partition num * Bucket num)。
  2. 一个表的 Tablet 数量,在不考虑扩容的情况下,推荐略多于整个集群的磁盘数量。
  3. 单个 Tablet 的数据量理论上没有上下界,但建议在 1G - 10G 的范围内。
    1. 如果单个 Tablet 数据量过小,则数据的聚合效果不佳,且元数据管理压力大。
    2. 如果单个 Tablet 数据量过大,则不利于副本的迁移、补齐,且会增加 Schema Change 或者 Rollup 操作失败重试的代价(这些操作失败重试的粒度是 Tablet)。
  4. 当 Tablet 的 数据量原则 和 数量原则 冲突时,建议优先考虑数据量原则。
  5. 在建表时,每个分区的 Bucket 数量统一指定。但是在动态增加分区时(ADD PARTITION),可以单独指定新分区的 Bucket 数量。可以利用这个功能方便的应对数据缩小或膨胀。
  6. 一个 Partition 的 Bucket 数量一旦指定,不可更改。所以在确定 Bucket 数量时,需要预先考虑集群扩容的情况。比如当前只有 3 台 host,每台 host 有 1 块盘。如果 Bucket 的数量只设置为 3 或更小,那么后期即使再增加机器,也不能提高并发度。

3.1、案例

假设在有10台BE,每台BE一块磁盘的情况下。如果表总大小为以下几种

  1. 表总大小为 500MB:建议 4-8个分片
  2. 表总大小为 5GB:建议 8-16个分片。
  3. 表总大小为 50GB:建议 32个分片。
  4. 表总大小为500GB:建议 分区,每个分区大小在 50GB 左右,每个分区16-32个分片。
  5. 表总大小为 5TB:建议分区,每个分区大小在 50GB 左右,每个分区16-32个分片。

3.2、表的数据量计算

注:表的数据量可以通过 show data 命令查看,表的数据量=size/ReplicaCount

表的数据量=size/ReplicaCount
show data

Doris--基础--3.5--SQL--建表_第4张图片

4、Doris 的存储引擎规则

  1. 用户数据首先被划分成若干个分区(Partition),划分的规则通常是按照用户指定的分区列进行范围划分,比如按时间划分。
  2. 在每个分区内,数据被进一步的按照Hash的方式分桶,分桶的规则是要找用户指定的分桶列的值进行Hash后分桶。每个分桶就是一个数据分片(Tablet),也是数据划分的最小逻辑单元。
  3. Partition 可以视为是逻辑上最小的管理单元。数据的导入与删除,都可以或仅能针对一个 Partition 进行。
  4. Tablet直接的数据是没有交集的,独立存储的。Tablet也是数据移动、复制等操作的最小物理存储单元。

5、Doris的建表方式

  1. 单分区
  2. 复合分区

5.1、单分区

数据不进行分区,数据只做 HASH 分布,也就是分桶

5.1.1、案例

  1. 建立一个名字为 table1 的逻辑表。字段说明如下
    1. siteid:类型是INT(4字节), 默认值为10
    2. citycode:类型是SMALLINT(2字节)
    3. username:类型是VARCHAR, 最大长度为32, 默认值为空字符串
    4. pv:类型是BIGINT(8字节), 默认值是0; 这是一个指标列, Doris内部会对指标列做聚合操作, 这个列的聚合方法是求和(SUM)
  2. 分桶列为 siteid
  3. 桶数为 10。

5.1.1.1、建表语句

CREATE TABLE table1
(
    siteid INT DEFAULT '10',
    citycode SMALLINT,
    username VARCHAR(32) DEFAULT '',
    pv BIGINT SUM DEFAULT '0'
)
AGGREGATE KEY(siteid, citycode, username)
DISTRIBUTED BY HASH(siteid) BUCKETS 10
PROPERTIES("replication_num" = "1");

Doris--基础--3.5--SQL--建表_第5张图片

5.1.1.2、查看

desc table1

Doris--基础--3.5--SQL--建表_第6张图片

5.2、复合分区

Doris--基础--3.5--SQL--建表_第7张图片

  1. 第1级称为 Partition,即分区。用户可以指定某一维度列作为分区列(当前只支持整型和时间类型的列),并指定每个分区的取值范围。
  2. 第2级称为 Distribution,即分桶。用户可以指定一个或多个维度列以及桶数对数据进行 HASH 分布。

5.2.1、使用场景

  1. 有时间维度或类似带有有序值的维度
    1. 可以以这类维度列作为分区列。
    2. 分区粒度可以根据导入频次、分区数据量等进行评估。
  2. 历史数据删除需求
    1. 如有删除历史数据的需求(比如仅保留最近N 天的数据)。使用复合分区,可以通过删除历史分区来达到目的。也可以通过在指定分区内发送 DELETE 语句进行数据删除。
  3. 解决数据倾斜问题:
    1. 每个分区可以单独指定分桶数量。如按天分区,当每天的数据量差异很大时,可以通过指定分区的分桶数,合理划分不同分区的数据,分桶列建议选择区分度大的列。

5.2.2、案例

  1. 建立一个名字为 table2 的逻辑表。字段说明如下
    1. event_day:类型是DATE,无默认值
    2. siteid:类型是INT(4字节), 默认值为10
    3. citycode:类型是SMALLINT(2字节)
    4. username:类型是VARCHAR, 最大长度为32, 默认值为空字符串
    5. pv:类型是BIGINT(8字节), 默认值是0; 这是一个指标列, Doris 内部会对指标列做聚合操作, 这个列的聚合方法是求和(SUM)
    6. 我们使用 event_day 列作为分区列,建立3个分区: p202006, p202007, p202008
    p202006:范围为 [最小值, 2020-07-01)
    p202007:范围为 [2020-07-01, 2020-08-01)
    p202008:范围为 [2020-08-01, 2020-09-01)
    
  2. 每个分区使用 siteid 进行哈希分桶,桶数为10

5.2.2.1、建表语句

CREATE TABLE table2
(
    event_day DATE,
    siteid INT DEFAULT '10',
    citycode SMALLINT,
    username VARCHAR(32) DEFAULT '',
    pv BIGINT SUM DEFAULT '0'
)
AGGREGATE KEY(event_day, siteid, citycode, username)
PARTITION BY RANGE(event_day)
(
    PARTITION p202006 VALUES LESS THAN ('2020-07-01'),
    PARTITION p202007 VALUES LESS THAN ('2020-08-01'),
    PARTITION p202008 VALUES LESS THAN ('2020-09-01')
)
DISTRIBUTED BY HASH(siteid) BUCKETS 10
PROPERTIES("replication_num" = "1");


Doris--基础--3.5--SQL--建表_第8张图片

5.2.2.2、查看

desc table2

Doris--基础--3.5--SQL--建表_第9张图片

5.2.2.3、注意

上述表通过设置 replication_num 建的都是单副本的表,Doris建议用户采用默认的 3 副本设置,以保证高可用。
可以对复合分区表动态的增删分区。详见 HELP ALTER TABLE 中 Partition 相关部分。
数据导入可以导入指定的 Partition。详见 HELP LOAD。
可以动态修改表的 Schema。
可以对 Table 增加上卷表(Rollup)以提高查询性能,这部分可以参见高级使用指南关于 Rollup 的描述。
表的列的Null属性默认为true,会对查询性能有一定的影响。

你可能感兴趣的:(Doris,sql,数据库,java)