StarRocks常用命令

1、StarRocks 集群管理&配置命令

2、StarRocks 常用操作命令

3、StarRocks 数据导入和导出

1、StarRocks 集群管理&配置命令

查询 FE 节点信息
SHOW frontends;
SHOW PROC '/frontends';
mysql -h192.168.1.250 -P9030 -uroot -p -e "SHOW PROC '/dbs';"

查询 BE 节点信息
SHOW backends;
SHOW PROC '/backends';

注意：FE 转发给 BE 时取的地址是 SHOW BACKENDS 中的 IP，客户端访问时，StarRocks 客户端需要能访问该地址；

查询 Broker 节点信息
SHOW broker;
SHOW PROC '/brokers';
注意：两种查询方后者 brokers 多一个"s"

-- StarRocks BE 节点管理

-- 添加 BE 节点（到 StarRocks 集群）
-- 注意：host 需要与 priority_networks 相匹配，port 需要与 be.conf 文件中的设置的 heartbeat_service_port 相同，默认为 9050。
ALTER SYSTEM ADD BACKEND "host:port";
ALTER SYSTEM ADD BACKEND "192.168.1.250:9050";

-- 删除 BE 节点（从 StarRocks 集群）
ALTER SYSTEM decommission BACKEND "host:port";

-- 查看 StarRockets FE 配置项
ADMIN SHOW FRONTEND CONFIG;
ADMIN SHOW FRONTEND CONFIG LIKE '%limit%';
ADMIN SHOW FRONTEND CONFIG LIKE '%bucket%';

-- 修改/配置 FE 动态参数
-- 动态设置的配置项，在 FE 重启之后会恢复成 fe.conf 文件中的配置或者默认值。如果需要让配置长期生效，建议设置完之后同时修改 fe.conf 文件，防止重启后修改失效。
ADMIN SET FRONTEND CONFIG ("key" = "value");

-- 修改/配置 FE 静态参数
-- FE 静态参数不支持在线修改，您需要在 fe.conf 中修改并重启 FE 以使修改生效。
-- FE 静态参数参考：https://docs.mirrorship.cn/zh/docs/3.1/administration/management/FE_configuration/

-- 查看 BE 配置项
curl http://<BE_IP>:<BE_HTTP_PORT>/varz
curl http://192.168.1.250:8040/varz

-- 修改/配置 BE 动态参数
curl -XPOST http://be_host:http_port/api/update_config?configuration_item=value

-- 修改/配置 BE 静态参数
-- BE 静态参数不支持在线修改，您需要在 be.conf 中修改并重启 BE 服务。

2、StarRocks 常用操作命令

SQL命令官方资料参考：https://docs.mirrorship.cn/zh/docs/2.5/sql-reference/sql-statements/all-commands/

StarRocks的表类型和表操作

StarRocks的表类型：主键表、明细表、聚合表、更新表。

主键表：
官网介绍参考：https://docs.starrocks.io/zh/docs/table_design/table_types/primary_key_table/
主键表使用 StarRocks 全新设计开发的存储引擎。其主要优势在于支撑实时数据更新的同时，也能保证高效的复杂即席查询性能。在实时分析业务中采用主键表，用最新的数据实时分析出结果来指导决策，使得数据分析不再受限于 T+1 数据延迟。

主键表的使用场景：
场景1：实时对接事务型数据至 StarRocks的场景。
场景2：利用部分列更新轻松实现多流 JOIN。例如画像场景，采用大宽表方式来提升多维分析的性能，同时简化数据分析师的使用模型。而这种场景中的上游数据，往往可能来自于多个不同业务（比如来自购物消费业务、快递业务、银行业务等）或系统（比如计算用户不同标签属性的机器学习系统），主键表的部分列更新功能就很好地满足这种需求，不同业务直接各自按需更新与业务相关的列即可，并且继续享受主键表的实时同步增删改数据及高效的查询性能。

注意：
自 3.0 版本起，主键表解耦了排序键与主键，支持单独指定排序键，提供更灵活的建表能力。
自 3.1 版本起，存算分离模式支持创建主键表。
自 3.1.4 版本起，支持持久化主键索引至本地磁盘。
自 3.3.2 版本起，支持持久化主键索引至对象存储。
在建表语句中，主键列必须定义在其他列之前。
主键必须包含分区列和分桶列。
主键列支持以下数据类型：数值（包括整型和布尔）、日期和字符串。
默认设置下，单条主键值编码后的最大长度为 128 字节。
建表后不支持修改主键。
主键列的值不能更新，避免破坏数据一致性。

主键表的底层工作原理：
更新表和聚合表整体上采用了 Merge-On-Read 的策略。虽然写入时处理简单高效，但是读取时需要在线 Merge 多个版本的数据文件。并且由于 Merge 算子的存在，谓词和索引无法下推至底层数据，会严重影响查询性能。
然而为了兼顾实时更新和查询性能，主键表的元数据组织、读取、写入方式完全不同。主键表采用了 Delete+Insert 策略，借助主键索引配合 DelVector 的方式实现，保证在查询时只需要读取具有相同主键值的数据中的最新数据。如此可以避免 Merge 多个版本的数据文件，并且谓词和索引可以下推到底层数据，所以可以极大提升查询性能。

-- 创建表-主键表
-- PRIMARY KEY 定义主键
-- 主键表仅支持分桶策略为哈希分桶，因此您还需要通过 DISTRIBUTED BY HASH () 定义哈希分桶键
CREATE TABLE orders1 (
order_id bigint NOT NULL,
dt date NOT NULL,
user_id INT NOT NULL,
good_id INT NOT NULL,
cnt int NOT NULL,
revenue int NOT NULL
)
PRIMARY KEY (order_id)
DISTRIBUTED BY HASH (order_id)
;

eg:
DROP TABLE IF EXISTS test03_pk;
CREATE TABLE IF NOT EXISTS default_catalog.testdb.test03_pk (
id INT,
info STRING,
cnt INT,
uptime DATETIME
)
PRIMARY KEY (id)
DISTRIBUTED BY HASH (id)
;

-- 指定 column_name 部分更新（partialUpdate，StarRocks V3.3.1开始支持 INSERT INTO 指定列时部分更新、低版本不支持仍然为整行更新Full Upset）
INSERT INTO default_catalog.testdb.test03_pk (id,info,cnt,uptime) VALUES (1,'aaa',100,'2024-11-10 08:30:21.111222'),(2,'bbb',102,'2024-11-11 08:35:58.333444');
INSERT INTO default_catalog.testdb.test03_pk (id,info,cnt,uptime) VALUES (3, 'uuu', 103, '2024-11-11 08:35:58.333444');
INSERT INTO default_catalog.testdb.test03_pk (id,info) VALUES (3, 'xxx');

-- 不指定 column_name 整行更新(Full Upset)
INSERT INTO default_catalog.testdb.test03_pk VALUES (3, 'uuu', 103, '2024-11-11 08:35:58.333444');
INSERT INTO default_catalog.testdb.test03_pk VALUES (3, 'uuu', NULL, NULL);

指定 lable:
INSERT INTO default_catalog.testdb.test03_pk WITH LABEL test03_pk_005 (id,info,cnt,uptime) VALUES (1,'aaa',100,'2024-11-10 08:30:21.111222'),(2,'bbb',102,'2024-11-11 08:35:58.333444');
SHOW LOAD WHERE label="test03_pk_005";

SELECT * FROM default_catalog.testdb.test03_pk;

UPDATE default_catalog.testdb.test03_pk SET info = 'sss' WHERE id=3;

DELETE FROM default_catalog.testdb.test03_pk WHERE id=3;

-- 创建表-主键表分区表
-- 如果是主键表分区表要求主键必须包括分区列和分桶列
-- PRIMARY KEY 指定主键。建表后不支持修改主键，主键列的值不能更新、避免破坏数据一致性
-- PARTITION BY 指定分区列，date_trunc天为粒度（按天分区）
-- DISTRIBUTED BY HASH 定义哈希分桶键
-- ORDER BY 指定排序键（加速查询）。建表后支持通过 ALTER TABLE ... ORDER BY ... 修改排序键，但不支持删除排序键，不支持修改排序列的数据类型
-- PROPERTIES 属性，如果建表不指定，SHOW CREATE TABLE example_table\G 查看默认PROPERTIES为：
PROPERTIES (
"replication_num" = "3",
"in_memory" = "false",
"enable_persistent_index" = "false",
"replicated_storage" = "true",
"compression" = "LZ4"
)

CREATE TABLE orders2 (
order_id bigint NOT NULL,
dt date NOT NULL,
merchant_id int NOT NULL,
user_id int NOT NULL,
good_id int NOT NULL,
good_name string NOT NULL,
price int NOT NULL,
cnt int NOT NULL,
revenue int NOT NULL,
state tinyint NOT NULL
)
PRIMARY KEY (order_id,dt,merchant_id)
PARTITION BY date_trunc('day', dt)
DISTRIBUTED BY HASH (merchant_id)
ORDER BY (dt,merchant_id)
PROPERTIES (
"enable_persistent_index" = "true"
);

明细表：
明细表是默认创建的表类型。如果在建表时未指定任何 key，默认创建的是明细表。
建表时支持定义排序键。如果查询的过滤条件包含排序键，则 StarRocks 能够快速地过滤数据，提高查询效率。
明细表适用于日志数据分析等场景，支持追加新数据，不支持修改历史数据。

明细表的使用场景：
分析原始数据，例如原始日志、原始操作记录等。
查询方式灵活，不需要局限于预聚合的分析方式。
导入日志数据或者时序数据，主要特点是旧数据不会更新，只会追加新的数据。

-- 创建明细表
-- 排序键：
-- 自 v3.3.0 起，明细表支持使用 ORDER BY 指定排序键，可以是任意列的排列组合。
-- 如果同时使用 ORDER BY 和 DUPLICATE KEY，则 DUPLICATE KEY 无效。
-- 如果未使用 ORDER BY 和 DUPLICATE KEY，则默认选择表的前三列作为排序键。

CREATE TABLE detail (
event_time DATETIME NOT NULL COMMENT "datetime of event",
event_type INT NOT NULL COMMENT "type of event",
user_id INT COMMENT "id of user",
device_code INT COMMENT "device code",
channel INT COMMENT "")
ORDER BY (event_time, event_type);

eg:
DROP TABLE IF EXISTS test02;
CREATE TABLE IF NOT EXISTS test02 (
id INT,
info STRING,
cnt INT,
uptime DATETIME
);

-- 指定排序键
CREATE TABLE IF NOT EXISTS test02_b (
id INT,
info STRING,
cnt INT,
uptime DATETIME
)
ORDER BY(id)
;

SHOW CREATE TABLE test02;
SHOW PARTITIONS FROM test02;
SHOW CREATE TABLE test02_b;
SHOW PARTITIONS FROM test02_b;

INSERT INTO default_catalog.testdb.test02 WITH LABEL test02_001 (id,info,cnt,uptime) VALUES (1,'aaa',100,'2024-11-10 08:30:21.111222'),(2,'bbb',102,'2024-11-11 08:35:58.333444');
INSERT OVERWRITE default_catalog.testdb.test02 (id,info,cnt,uptime) VALUES (1,'aaa',100,'2024-11-10 08:30:21.111222'),(2,'bbb',102,'2024-11-11 08:35:58.333444');
select * from default_catalog.testdb.test02;

聚合表：
建表时可以定义聚合键并且为 value 列指定聚合函数。当多条数据具有相同的聚合键时，value 列会进行聚合。并且支持单独定义排序键，如果查询的过滤条件包含排序键，则 StarRocks 能够快速地过滤数据，提高查询效率。
在分析统计和汇总数据时，聚合表能够减少查询时所需要处理的数据，提升查询效率。

使用场景：适用于分析统计和汇总数据。

-- 创建聚合表
-- 建表时必须使用 DISTRIBUTED BY HASH 子句指定分桶键。
-- 自 2.5.7 版本起，StarRocks 支持在建表和新增分区时自动设置分桶数量 (BUCKETS)，您无需手动设置分桶数量。
-- 在建表语句中，聚合键必须定义在其他列之前。
-- 聚合键可以通过 AGGREGATE KEY 显式定义。并且 AGGREGATE KEY 必须包含除 value 列之外的所有列，则建表会失败。如果不通过 AGGREGATE KEY 显示定义聚合键，则默认除 value 列之外的列均为聚合键。
-- 聚合键具有唯一性约束。
-- value 列：通过在列名后指定聚合函数，定义该列为 value 列。一般为需要汇总统计的数据。
-- 聚合函数：value 列使用的聚合函数。聚合表支持的聚合函数例如：SUM、MAX、MIN、REPLACE等（详情参考：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/table_bucket_part_index/CREATE_TABLE/）
-- 排序键：自 v3.3.0 起，聚合表解耦了排序键和聚合键。聚合表支持使用 ORDER BY 指定排序键和使用 AGGREGATE KEY 指定聚合键。排序键和聚合键中的列需要保持一致，但是列的顺序不需要保持一致。
-- 查询时，排序键在多版聚合之前就能进行过滤，而 value 列的过滤在多版本聚合之后。因此建议将频繁使用的过滤字段作为排序键，在聚合前就能过滤数据，从而提升查询性能。
-- 建表时，仅支持为 key 列创建 Bitmap 索引、Bloom filter 索引。

CREATE TABLE aggregate_tbl (
site_id LARGEINT NOT NULL COMMENT "id of site",
date DATE NOT NULL COMMENT "time of event",
city_code VARCHAR(20) COMMENT "city_code of user",
pv BIGINT SUM DEFAULT "0" COMMENT "total page views"
)
AGGREGATE KEY(site_id, date, city_code)
DISTRIBUTED BY HASH(site_id);

eg：
DROP TABLE IF EXISTS default_catalog.testdb.test06_aggregate;
CREATE TABLE IF NOT EXISTS default_catalog.testdb.test06_aggregate (
id INT NOT NULL COMMENT "id of city, citiy code",
event VARCHAR(255) COMMENT "event name or desc",
uptime DATETIME NOT NULL COMMENT "time of event",
totalnum BIGINT SUM DEFAULT "0" COMMENT "total num"
)
AGGREGATE KEY(id,event,uptime)
DISTRIBUTED BY HASH(id);
-- DISTRIBUTED BY HASH(id) BUCKETS 4;

-- 注意：
-- 1)建表时必须使用 DISTRIBUTED BY HASH 子句指定分桶键。
-- 2)自 2.5.7 版本起，StarRocks 支持在建表和新增分区时自动设置分桶数量 (BUCKETS)，您无需手动设置分桶数量。
-- 3)在建表语句中，聚合键必须定义在其他列之前。
-- 4)聚合键可以通过 AGGREGATE KEY 显式定义。并且 AGGREGATE KEY 必须包含除 value 列之外的所有列，则建表会失败。
-- 5)如果不通过 AGGREGATE KEY 显示定义聚合键，则默认除 value 列之外的列均为聚合键。
-- 6)聚合键具有唯一性约束。
-- 7)通过在列名后指定聚合函数，定义该列为 value 列。一般为需要汇总统计的数据。
-- 8)聚合函数支持：SUM、MAX、MIN、REPLACE，以及其他特殊场景的聚合函数：HLL_UNION、BITMAP_UNION、REPLACE_IF_NOT_NULL。
-- 9)自 v3.3.0 起，聚合表解耦了排序键和聚合键。聚合表支持使用 ORDER BY 指定排序键和使用 AGGREGATE KEY 指定聚合键。排序键和聚合键中的列需要保持一致，但是列的顺序不需要保持一致。
-- 10)查询时，排序键在多版聚合之前就能进行过滤，而 value 列的过滤在多版本聚合之后。因此建议将频繁使用的过滤字段作为排序键，在聚合前就能过滤数据，从而提升查询性能。

SELECT * FROM default_catalog.testdb.test06_aggregate;

INSERT INTO default_catalog.testdb.test06_aggregate (id,event,uptime,totalnum) values (330100,'traffic-hangzhou','2025-01-01 09:30:00', 50000);
INSERT INTO default_catalog.testdb.test06_aggregate (id,event,uptime,totalnum) values (330100,'traffic-hangzhou','2025-01-01 09:30:00', 10000);

INSERT INTO default_catalog.testdb.test06_aggregate (id,event,uptime,totalnum) values (430100,'traffic-changsha','2025-01-01 09:30:00', 30000);
INSERT INTO default_catalog.testdb.test06_aggregate (id,event,uptime,totalnum) values (430100,'traffic-changsha','2025-01-01 09:30:00', 40000);

DELETE FROM default_catalog.testdb.test06_aggregate WHERE id=330100;

TRUNCATE TABLE default_catalog.testdb.test06_aggregate;

-- 注意：
聚合表不支持 UPDATE，例如：
UPDATE default_catalog.testdb.test06_aggregate SET totalnum = 10000 WHERE id=330100;
聚合表不支持无 WHERE 条件的 DELETE，例如：
DELETE FROM default_catalog.testdb.test06_aggregate;

更新表：

建表时需要定义唯一键。当多条数据具有相同的唯一键时，value 列会进行 REPLACE，查询时返回唯一键相同的一组数据中的最新数据。
并且支持单独定义排序键，如果查询的过滤条件包含排序键，则 StarRocks 能够快速地过滤数据，提高查询效率。
更新表能够支撑实时和频繁更新的场景，不过目前已经逐渐被主键表代替。

适用场景：实时和频繁更新的业务场景，例如分析电商订单。在电商场景中，订单的状态经常会发生变化，每天的订单更新量可突破上亿。

-- 创建更新表
-- 建表时必须使用 DISTRIBUTED BY HASH 子句指定分桶键。
-- 自 2.5.7 版本起，StarRocks 支持在建表和新增分区时自动设置分桶数量 (BUCKETS)，您无需手动设置分桶数量。
-- 在建表语句中，唯一键必须定义在其他列之前。
-- 唯一键需要通过 UNIQUE KEY 显式定义。
-- 唯一键必须满足唯一性约束。
-- 排序键：自 v3.3.0 起，更新表解耦了排序键和聚合键。更新表支持使用 ORDER BY 指定排序键和使用 UNIQUE KEY 指定唯一键。排序键和唯一键中的列需要保持一致，但是列的顺序不需要保持一致。
-- 建表时，仅支持为 key 列创建 Bitmap 索引、Bloom filter 索引。
-- 导入数据时，仅支持全部更新，即导入任务需要指明所有列，例如示例中的 create_time、order_id、order_state 和 total_price 四个列。
-- 在设计导入频率时，建议以满足业务对实时性的要求为准。查询更新表的数据时，需要聚合多版本的数据，当版本过多时会导致查询性能降低。所以导入数据至更新表时，应该适当降低导入频率，从而提升查询性能。如果业务对实时性的要求是分钟级别，那么每分钟导入一次更新数据即可，不需要秒级导入。

CREATE TABLE orders (
create_time DATE NOT NULL COMMENT "create time of an order",
order_id BIGINT NOT NULL COMMENT "id of an order",
order_state INT COMMENT "state of an order",
total_price BIGINT COMMENT "price of an order"
)
UNIQUE KEY(create_time, order_id)
DISTRIBUTED BY HASH(order_id);

索引：
https://docs.starrocks.io/zh/docs/category/indexes/

前缀索引和排序键：
https://docs.starrocks.io/zh/docs/table_design/indexes/Prefix_index_sort_key/

建表时指定一个或多个列构成排序键 (Sort Key)。表中的数据行会根据排序键进行排序以后再落入磁盘存储。
并且数据写入的过程中会自动生成前缀索引。数据按照指定的排序键排序后，每写入 1024 行数据构成一个逻辑数据块（Data Block），在前缀索引表中存储一个索引项，内容为该逻辑数据块中第一行数据的排序列组成的前缀。
通过这样两层的排序结构，查询时就可以使用二分查找快速跳过不符合条件的数据。

自 3.0 版本起，主键表支持使用 ORDER BY 定义排序键，自 3.3 版本起，明细表、聚合表和更新表支持使用 ORDER BY 定义排序键。
主键表中数据先按照主键 PRIMARY KEY 进行 REPLACE 后，再按照排序键 ORDER BY 排序。

前缀字段的数量不超过 3 个，前缀索引项的最大长度为 36 字节。
由于前缀索引项的最大长度为 36 字节，超过部分会被截断，因此该表的前缀索引项为 uid (4 字节) + name (只取前 32 字节)，前缀字段为 uid 和 name。
前缀字段中 CHAR、VARCHAR、STRING 类型的列只能出现一次，并且处在末尾位置。

Bitmap 索引：
https://docs.starrocks.io/zh/docs/table_design/indexes/Bitmap_index/

Bloom filter 索引：
https://docs.starrocks.io/zh/docs/table_design/indexes/Bloomfilter_index/

[Preview] N-Gram bloom filter 索引：
https://docs.starrocks.io/zh/docs/table_design/indexes/Ngram_Bloom_Filter_Index/

[Preview] 全文倒排索引：
https://docs.starrocks.io/zh/docs/table_design/indexes/inverted_index/

-- 查询StarRocks数据库版本号
SELECT current_version() as version;
+---------------+
| version |
+---------------+
| 3.3.2-857dd73 |
+---------------+
1 row in set (0.01 sec)

数据目录（catalog）

查询数据目录列表（catalog）

查看当前集群中的所有 Catalog，包括 Internal Catalog 和 External Catalog
注意：一个 StarRocks 集群中只有一个默认的 internal catalog，名为 default_catalog，不支持删除；default_catalog 也是 StarRocks 集群中唯一的 internal catalog

SHOW CATALOGS;
SHOW PROC '/catalog';

Catalog：Catalog 名称。
Type：Catalog 类型。如果是 default_catalog，则返回 Internal。如果是 external catalog，则返回 external catalog 的类型，例如 Hive, Hudi, Iceberg。
Comment：Catalog 的备注。
1）在创建 external catalog 时不支持为 external catalog 添加备注，所以如果是 external catalog，则返回的 Comment 为 NULL。
2）如果是 default_catalog，则默认返回的 Comment 为 An internal catalog contains this cluster's self-managed tables.。default_catalog 是 StarRocks 集群中唯一的 internal catalog，不允许删除。

注意：
1）只有拥有 External Catalog USAGE 权限的用户才能查看到该 Catalog。如果没有该权限，仅返回 default_catalog。您可以使用 GRANT 命令进行授权操作。
2）外部数据目录不同的类型支持规格不同。
3）StarRocks 的 JDBC 外部数据目录目前不支持 CREATE TABLE、DROP TABLE、INSERT INTO、TRUNCATE TABLE 操作，主要是支持查询；
4）Hive 外部数据目录支持 CREATE TABLE 操作、但也有些操作不支持。
5）外部数据目录的支持规格和限制，更多详情可查阅官方资料。

创建外部数据目录

详细说明参考官网资料：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/Catalog/CREATE_EXTERNAL_CATALOG/
该语句用于创建 External Catalog。创建后，无需数据导入或创建外部表即可查询外部数据：

CREATE EXTERNAL CATALOG [IF NOT EXISTS] <catalog_name>
[COMMENT <comment>]
PROPERTIES ("key"="value", ...)

参数说明：
catalog_name：必须由字母 (a-z 或 A-Z)、数字 (0-9) 或下划线 (_) 组成，且只能以字母开头。总长度不能超过 1023 个字符。Catalog 名称大小写敏感。
PROPERTIES：External catalog 的属性，不同的 external catalog 需要设置不同属性。详细配置信息，请参见 Hive catalog、Iceberg catalog、Hudi catalog、Delta Lake catalog 和 JDBC Catalog。

-- 创建外部数据目录示例0（JDBC Catalog）

-- 创建外部数据目录-创建 jdbc catalog（mysql）
-- driver_url 支持 http[s]、file（file:///<path>/to/the/driver）

DROP CATALOG jdbc01_mysql_catalog
CREATE EXTERNAL CATALOG jdbc01_mysql_catalog
PROPERTIES
(
"type"="jdbc",
"user"="test",
"password"="1q2w3e",
"jdbc_uri"="jdbc:mysql://192.168.1.250:33061",
"driver_url"="https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.28/mysql-connector-java-8.0.28.jar",
"driver_class"="com.mysql.cj.jdbc.Driver"
);

如果指定本地的jdbc驱动文件："driver_url"="file:///home/jdbc_drivers/mysql/mysql-connector-java-8.0.28.jar"

SHOW CATALOGS;
SHOW CREATE CATALOG jdbc01_mysql_catalog;
SHOW DATABASES FROM jdbc01_mysql_catalog;
SHOW TABLES FROM jdbc01_mysql_catalog.testdb;
SELECT * FROM jdbc01_mysql_catalog.testdb.test01;
SHOW CREATE TABLE jdbc01_mysql_catalog.testdb.test01;

-- 创建外部数据目录-创建 jdbc catalog（postgresql）
-- driver_url 支持 http[s]、file（file:///<path>/to/the/driver）

DROP CATALOG jdbc02_pg_catalog;
CREATE EXTERNAL CATALOG jdbc02_pg_catalog
PROPERTIES
(
"type"="jdbc",
"user"="test",
"password"="1q2w3e",
"jdbc_uri"="jdbc:postgresql://192.168.1.231:5432/testdb",
"driver_url"="https://repo1.maven.org/maven2/org/postgresql/postgresql/42.3.3/postgresql-42.3.3.jar",
"driver_class"="org.postgresql.Driver"
);

如果指定本地的jdbc驱动文件："driver_url"="file:///home/jdbc_drivers/postgresql/postgresql-42.3.3.jar",

注意：
pg 类型的 jdbc catalog 的 jdbc_uri 参数必须指定到 database 级别，否则无法访问，会报错：ERROR 1064 (HY000): Driver org.postgresql.Driver claims to not accept jdbcUrl, jdbc:postgresql://x.x.x.x:5432

SHOW CATALOGS;
SHOW CREATE CATALOG jdbc02_pg_catalog;
SELECT * FROM jdbc02_pg_catalog.public.test01;

-- 创建外部数据目录-创建 jdbc catalog（oracle）
-- driver_url 支持 http[s]、file（file:///<path>/to/the/driver）

DROP CATALOG jdbc03_oracle_catalog;
CREATE EXTERNAL CATALOG jdbc03_oracle_catalog
PROPERTIES
(
"type"="jdbc",
"user"="TEST",
"password"="1q2w3e",
"jdbc_uri"="jdbc:oracle:thin:@192.168.1.140:1521:ORCL",
"driver_url"="https://repo1.maven.org/maven2/com/oracle/database/jdbc/ojdbc10/19.18.0.0/ojdbc10-19.18.0.0.jar",
"driver_class"="oracle.jdbc.driver.OracleDriver"
);

SHOW CATALOGS;
SHOW CREATE CATALOG jdbc02_pg_catalog;
SELECT * FROM jdbc03_oracle_catalog.TEST.TEST01;

JDBC catalog 无论是 mysql、pg、oracle，访问查询数据的格式为 catalog.<db|schema|user>.table。

-- 创建外部数据目录示例（Hive Catalog）

eg：
创建名为 hive_metastore_catalog 的 Hive catalog。其对应的 Hive 集群使用 Hive metastore 作为元数据服务：
CREATE EXTERNAL CATALOG hive_metastore_catalog
PROPERTIES(
"type"="hive",
"hive.metastore.uris"="thrift://xx.xx.xx.xx:9083"
);

eg:
创建名为 hive_glue_catalog 的 Hive catalog。其对应的 Hive 集群使用 AWS Glue 作为元数据服务：
CREATE EXTERNAL CATALOG hive_glue_catalog
PROPERTIES(
"type"="hive",
"hive.metastore.type"="glue",
"aws.hive.metastore.glue.aws-access-key"="xxxxxx",
"aws.hive.metastore.glue.aws-secret-key"="xxxxxxxxxxxx",
"aws.hive.metastore.glue.endpoint"="https://glue.x-x-x.amazonaws.com"
);

-- 创建外部数据目录示例（Iceberg Catalog）

eg:
创建名为 iceberg_metastore_catalog 的 Iceberg catalog。其对应的 Iceberg 集群使用 Hive metastore 作为元数据服务：
CREATE EXTERNAL CATALOG iceberg_metastore_catalog
PROPERTIES(
"type"="iceberg",
"iceberg.catalog.type"="hive",
"iceberg.catalog.hive.metastore.uris"="thrift://xx.xx.xx.xx:9083"
);

eg:
创建名为 iceberg_glue_catalog 的 Iceberg catalog。其对应的 Iceberg 集群使用 AWS Glue 作为元数据服务：
CREATE EXTERNAL CATALOG iceberg_glue_catalog
PROPERTIES(
"type"="iceberg",
"iceberg.catalog.type"="glue",
"aws.hive.metastore.glue.aws-access-key"="xxxxx",
"aws.hive.metastore.glue.aws-secret-key"="xxx",
"aws.hive.metastore.glue.endpoint"="https://glue.x-x-x.amazonaws.com"
);

-- 创建外部数据目录示例（hudi Catalog）

eg:
创建名为 hudi_metastore_catalog 的 Hudi catalog。其对应的 Hudi 集群使用 Hive metastore 作为元数据服务：

CREATE EXTERNAL CATALOG hudi_metastore_catalog
PROPERTIES(
"type"="hudi",
"hive.metastore.uris"="thrift://xx.xx.xx.xx:9083"
);

eg:
创建名为 hudi_glue_catalog 的 Hudi catalog。其对应的 Hudi 集群使用 AWS Glue 作为元数据服务：

CREATE EXTERNAL CATALOG hudi_glue_catalog
PROPERTIES(
"type"="hudi",
"hive.metastore.type"="glue",
"aws.hive.metastore.glue.aws-access-key"="xxxxxx",
"aws.hive.metastore.glue.aws-secret-key"="xxxxxxxxxxxx",
"aws.hive.metastore.glue.endpoint"="https://glue.x-x-x.amazonaws.com"
);

-- 创建外部数据目录示例（deltalake Catalog）

eg:
创建名为 delta_metastore_catalog 的 Delta Lake catalog。其对应的 Delta Lake 使用 Hive metastore 作为元数据服务：

CREATE EXTERNAL CATALOG delta_metastore_catalog
PROPERTIES(
"type"="deltalake",
"hive.metastore.uris"="thrift://xx.xx.xx.xx:9083"
);

eg:
创建名为 delta_glue_catalog 的 Delta Lake catalog。其对应的 Delta Lake 使用 AWS Glue 作为元数据服务：

CREATE EXTERNAL CATALOG delta_glue_catalog
PROPERTIES(
"type"="deltalake",
"hive.metastore.type"="glue",
"aws.hive.metastore.glue.aws-access-key"="xxxxxx",
"aws.hive.metastore.glue.aws-secret-key"="xxxxxxxxxxxx",
"aws.hive.metastore.glue.endpoint"="https://glue.x-x-x.amazonaws.com"
);

外部数据目录授权操作

External catalog 相关的GRANT语法：
GRANT 语法详细介绍参考：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/account-management/GRANT/
GRANT
{ USAGE | DROP | ALL [PRIVILEGES] }
ON { CATALOG <catalog_name> [, <catalog_name>,...] | ALL CATALOGS}
TO { ROLE | USER} {<role_name>|<user_identity>} [ WITH GRANT OPTION ]

查看某个 External Catalog 的创建语句
-- 查看某个 External Catalog 的创建语句（StarRocks 3.0及以上版本支持该命令）
-- 支持查看如下 External Catalog:
-- Hive Catalog, Iceberg Catalog, Hudi Catalog, Delta Lake Catalog,
-- JDBC catalog (自 3.0 版本起)， Unified Catalog (自 3.2 版本起)， MaxCompute Catalog (自 3.3 版本起)
SHOW CREATE CATALOG catalog_name;
SHOW CREATE CATALOG jdbc01_mysql_catalog;

mysql> SHOW CREATE CATALOG jdbc01_mysql_catalog;
+----------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Catalog | Create Catalog |
+----------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| jdbc01_mysql_catalog | CREATE EXTERNAL CATALOG `jdbc01_mysql_catalog`
PROPERTIES ("driver_class" = "com.mysql.cj.jdbc.Driver",
"checksum" = "95cde01c78e7b04e13305338d60e056a",
"driver_url" = "https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.28/mysql-connector-java-8.0.28.jar",
"type" = "jdbc",
"user" = "root",
"jdbc_uri" = "jdbc:mysql://192.168.1.250:33061"
) |
+----------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

当前支持查看如下 External Catalog:
Hive Catalog
Iceberg Catalog
Hudi Catalog
Delta Lake Catalog
JDBC catalog (自 3.0 版本起)
Unified Catalog (自 3.2 版本起)
MaxCompute Catalog (自 3.3 版本起)
其中认证相关的密钥信息会进行脱敏展示，无法查看。
该命令自 3.0 版本起支持。

切换数据目录
切换到指定的 Catalog。该命令自 3.0 版本起支持。catalog_name 支持 Internal Catalog 和 External Catalog
SET CATALOG <catalogName>;
SET CATALOG jdbc01_mysql_catalog;
SET CATALOG default_catalog;

-- 删除数据目录（catalog）
DROP CATALOG [IF EXISTS] catalog_name

注意：目前不支持删除 internal catalog。一个 StarRocks 集群中只有一个默认的 internal catalog，名为 default_catalog。

例如：
CREATE EXTERNAL CATALOG hive_metastore
PROPERTIES(
"type"="hive",
"hive.metastore.uris"="thrift://xx.xx.xx.xx:9083"
);

DROP CATALOG hive_metastore;

查询数据库列表（SHOW PROC 方式能查询到更多信息，包括 DbId, DbName, TableNum 等信息）
SHOW databases;
SHOW PROC '/dbs';

SHOW databases FROM <catalog_name>;
SHOW databases FROM default_catalog;
SHOW databases FROM jdbc01_mysql_catalog;

mysql> SHOW PROC '/dbs';
+-------+--------------------+----------+----------------+--------------------------+---------------------+
| DbId | DbName | TableNum | Quota | LastConsistencyCheckTime | ReplicaQuota |
+-------+--------------------+----------+----------------+--------------------------+---------------------+
| 1 | information_schema | 46 | 8388608.000 TB | NULL | 9223372036854775807 |
| 100 | sys | 6 | 8388608.000 TB | NULL | 9223372036854775807 |
| 10002 | _statistics_ | 7 | 8388608.000 TB | NULL | 9223372036854775807 |
| 10157 | testdb | 3 | 8388608.000 TB | NULL | 9223372036854775807 |
+-------+--------------------+----------+----------------+--------------------------+---------------------+

-- 切换当前数据库
USE catalog_name.db_name;
USE default_catalog.testdb;
USE jdbc01_mysql_catalog.testdb;

-- 查询所有表列表
SHOW TABLES;
SHOW TABLES FROM testdb;
SHOW TABLES FROM default_catalog.testdb;
SHOW TABLES FROM jdbc01_mysql_catalog.testdb;

元数据查询方式查询数据库的表列表：
SELECT `TABLE_NAME` FROM `information_schema`.`TABLES` WHERE `TABLE_CATALOG`='def' AND `TABLE_SCHEMA`='testdb';

注意：
1）内部数据目录即默认数据目录（default_catalog）在元数据表 `information_schema`.`TABLES` 中所存储的 TABLE_CATALOG 字段的值为 def 而不是 default_catalog。
2）普通 SQL 命令中需要使用 default_catalog，但如果直接查询元数据表，则需要使用 def（而不是 default_catalog）。
例如：
INSERT INTO default_catalog.testdb.test01(id,info,cnt,uptime) VALUES (1,'aaa',90,'2025-01-01 13:00:01');
SELECT * FROM default_catalog.testdb.test01;

不指定 catalog 则默认查询当前 catalog（set catalog 切换数据目录）

-- 查询指定数据库的所有表信息（看到的信息更多，包括 TableId、TableName、PartitionColumnName 等信息）
SHOW PROC '/dbs/<db_id>';
SHOW PROC '/dbs/10157';

-- 查看表结构：
DESC default_catalog.testdb.test01;

-- 元数据表查询方式查询表结构：
SELECT `COLUMN_NAME`, `ORDINAL_POSITION`, `COLUMN_KEY`, `DATA_TYPE`, `COLUMN_SIZE`, `DECIMAL_DIGITS`
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_CATALOG` IS NULL AND `TABLE_SCHEMA`='testdb' AND `TABLE_NAME`='test01';

注意：元数据表 `information_schema`.`COLUMNS` 中的 TABLE_CATALOG 的默认数据目录记录的是空值、而不是 def、也不是 default_catalog。

创建表
注意：
1）StarRocks 的 JDBC 外部数据目录不支持 CREATE TABLE 操作。
2）StarRocks 的建表语法和MySQL的类似，但数据类型、PRIMARY KEY等语法上也有些差异。
3）StarRocks 建表时必须使用 DISTRIBUTED BY HASH 子句指定分桶键，分桶数 BUCKETS xx 高版本支持自动设置、可不指定。自 2.5.7 版本起，StarRocks 支持在建表和新增分区时自动设置分桶数量，您无需手动设置分桶数量。
4）分区：分区用于将数据划分成不同的区间。分区的主要作用是将一张表按照分区键拆分成不同的管理单元，针对每一个管理单元选择相应的存储策略，比如副本数、分桶数、冷热策略和存储介质等。
如果建表没有指定分区键信息的，则StarRocks默认按表名将整个表作为一个分区处理。
PARTITION BY
分区支持手动创建静态分区，也支持动态分区。
分区详细介绍参考官方：https://docs.mirrorship.cn/zh/docs/2.5/table_design/Data_distribution/#%E5%88%86%E5%8C%BA
5）分桶：分区的下一级是分桶，StarRocks 采? Hash 算法作为分桶算法。在同一分区内，分桶键哈希值相同的数据形成 Tablet，Tablet 以多副本冗余的形式存储，是数据均衡和恢复的最小单位。
Tablet 的副本由一个单独的本地存储引擎管理，数据导入和查询最终都下沉到所涉及的 Tablet 副本上。
分桶详细介绍参考官方：https://docs.mirrorship.cn/zh/docs/2.5/table_design/Data_distribution/#%E5%88%86%E5%8C%BA

-- 无主键表/明细表
DROP TABLE IF EXISTS testdb.test03;
CREATE TABLE testdb.test03 (
`id` bigint NOT NULL,
`info` string,
`cnt` bigint,
`uptime` datetime
);

INSERT INTO testdb.test03(id,info,cnt,uptime) VALUES (1, 'aaa', 80, '2025-01-01 13:00:01');
INSERT INTO testdb.test03(id,info,cnt,uptime) VALUES (1, 'aaa', 92, '2025-01-02 13:02:20');
INSERT INTO testdb.test03(id,info,cnt,uptime) VALUES (2, 'bbb', 95, '2025-01-03 20:05:30');
SELECT * FROM testdb.test03;

mysql> SELECT * FROM testdb.test03;
+------+------+------+---------------------+
| id | info | cnt | uptime |
+------+------+------+---------------------+
| 1 | aaa | 80 | 2025-01-01 13:00:01 |
| 1 | aaa | 92 | 2025-01-02 13:02:20 |
| 2 | bbb | 95 | 2025-01-03 20:05:30 |
+------+------+------+---------------------+
3 rows in set (0.01 sec)

-- 查询表的分区(PartitionId,PartitionName)和分桶(Buckets)等信息
SHOW PARTITIONS FROM testdb.test03;

mysql> SHOW PARTITIONS FROM testdb.test03\G;
*************************** 1. row ***************************
PartitionId: 11286
PartitionName: test03
VisibleVersion: 4
VisibleVersionTime: 2025-01-09 06:11:24
VisibleVersionHash: 0
State: NORMAL
PartitionKey:
Range:
DistributionKey: ALL KEY
Buckets: 1
ReplicationNum: 1
StorageMedium: HDD
CooldownTime: 9999-12-31 15:59:59
LastConsistencyCheckTime: NULL
DataSize: 2.8KB
IsInMemory: false
RowCount: 3
DataVersion: 4
VersionEpoch: 332537583781281792
VersionTxnType: TXN_NORMAL
1 row in set (0.00 sec)

-- 创建表-主键表
DROP TABLE IF EXISTS testdb.test04_pk;
CREATE TABLE testdb.test04_pk (
`id` bigint NOT NULL,
`info` varchar(255),
`cnt` bigint,
`uptime` datetime
) PRIMARY KEY(`id`);

或显式指定HASH分桶
DROP TABLE IF EXISTS testdb.test04_pk;
CREATE TABLE testdb.test04_pk (
`id` bigint NOT NULL,
`info` varchar(255),
`cnt` bigint,
`uptime` datetime
)
PRIMARY KEY(`id`)
DISTRIBUTED BY HASH (`id`)
;

-- 查询表的分区(PartitionId,PartitionName)和分桶(Buckets)等信息
SHOW PARTITIONS FROM testdb.test04_pk;

mysql> SHOW PARTITIONS FROM testdb.test04_pk\G;
*************************** 1. row ***************************
PartitionId: 11380
PartitionName: test04_pk
VisibleVersion: 1
VisibleVersionTime: 2025-01-09 09:18:03
VisibleVersionHash: 0
State: NORMAL
PartitionKey:
Range:
DistributionKey: id
Buckets: 16
ReplicationNum: 1
StorageMedium: HDD
CooldownTime: 9999-12-31 15:59:59
LastConsistencyCheckTime: NULL
DataSize: 0B
IsInMemory: false
RowCount: 0
DataVersion: 1
VersionEpoch: 332561087616516096
VersionTxnType: TXN_NORMAL
1 row in set (0.00 sec)

INSERT INTO testdb.test04_pk(id,info,cnt,uptime) VALUES (1, 'aaa', 80, '2025-01-01 13:00:01');
INSERT INTO testdb.test04_pk(id,info,cnt,uptime) VALUES (1, 'aaa', 92, '2025-01-02 13:02:20');
INSERT INTO testdb.test04_pk(id,info,cnt,uptime) VALUES (2, 'bbb', 95, '2025-01-03 20:05:30');
SELECT * FROM testdb.test04_pk;

mysql> SELECT * FROM testdb.test04_pk;
+------+------+------+---------------------+
| id | info | cnt | uptime |
+------+------+------+---------------------+
| 1 | aaa | 92 | 2025-01-02 13:02:20 |
| 2 | bbb | 95 | 2025-01-03 20:05:30 |
+------+------+------+---------------------+
2 rows in set (0.00 sec)

-- 创建表-主键表分区表（显式指定 PARTITION BY）
DROP TABLE IF EXISTS testdb.test05_pt;
CREATE TABLE testdb.test05_pt (
`id` bigint NOT NULL,
`uptime` datetime,
`cnt` bigint,
`info` string
)
PRIMARY KEY (id,uptime,cnt)
PARTITION BY date_trunc('day', uptime)
DISTRIBUTED BY HASH (cnt)
ORDER BY (id)
PROPERTIES (
"replication_num" = "1",
"enable_persistent_index" = "true"
);

注意：
1）主键必须包含分区列和分桶列。
2）主键、分区列、分桶列位置必须放在建表字段的最前面。
3）主键 PRIMARY KEY 指定的字段的顺序必须是：主键,分区列,分桶列的顺序。
4）主键 PRIMARY KEY 的语法位置和 MySQL 的有区别。
5）如果要显式指定分桶数，则分桶后面显式指定 BUCKET xxx，例如：DISTRIBUTED BY HASH (cnt) BUCKETS 4。
6）enable_persistent_index：持久化索引，可选，如果设置true，会在磁盘上维护一个索引结构，以加速数据查询，特别是数据量大的时候。重启时能提供更高效的数据查询。默认值为false。
注意：
a）如果开启持久化索引，主键模型大大降低了主键索引对内存的占用。因为导入时少部分主键索引存在内存中，大部分主键索引存在磁盘中。单条主键编码后的最大长度为 128 字节。
b）如果不开启持久化索引，主键模型适用于主键占用空间相对可控的场景，因为导入时将主键索引加载至内存中。单条主键编码后的最大长度和内存占用上限为 128 字节。
7）replication_num：数据的副本数，可选。如果不设置则为默认副本数为3。
StarRocks 中的副本数就是同一个数据分批 Tablet 保存的份数，在建表时通过 replication_num 参数指定，也可以后面修改。默认不指定时，StarRocks使用3副本建表，也即每个 Tablet 会在不同节点存储三份（StarRocks 的副本策略会将某个 Tablet 的副本存储在与其不同 IP 的节点）。
注意：
a）副本数必须 <= BE 节点数量。如果只有1个BE节点，则副本数默认为1、也只能设置为1。
b）如果 "replication_num" = "1" 即每个数据分片（Tablet）只有1副本，则不提供数据的副本冗余，无高可靠性。

INSERT INTO testdb.test05_pt(id,info,cnt,uptime) VALUES (1, 'aaa', 80, '2025-01-01 13:00:01');
INSERT INTO testdb.test05_pt(id,info,cnt,uptime) VALUES (1, 'aaa', 92, '2025-01-02 13:02:20');
INSERT INTO testdb.test05_pt(id,info,cnt,uptime) VALUES (2, 'bbb', 95, '2025-01-03 20:05:30');
INSERT INTO testdb.test05_pt(id,info,cnt,uptime) VALUES (2, 'bbb', 95, '2025-01-03 20:05:30');

mysql> SELECT * FROM testdb.test05_pt;
+------+---------------------+------+------+
| id | uptime | cnt | info |
+------+---------------------+------+------+
| 1 | 2025-01-02 13:02:20 | 92 | aaa |
| 1 | 2025-01-01 13:00:01 | 80 | aaa |
| 2 | 2025-01-03 20:05:30 | 95 | bbb |
+------+---------------------+------+------+
3 rows in set (0.01 sec)

-- 查询表的分区(PartitionId,PartitionName)和分桶(Buckets)等信息
SHOW PARTITIONS FROM testdb.test05_pt;

mysql> SHOW PARTITIONS FROM testdb.test05_pt\G;
*************************** 1. row ***************************
PartitionId: 11431
PartitionName: p20250101
VisibleVersion: 2
VisibleVersionTime: 2025-01-09 09:33:06
VisibleVersionHash: 0
State: NORMAL
PartitionKey: uptime
Range: [types: [DATETIME]; keys: [2025-01-01 00:00:00]; ..types: [DATETIME]; keys: [2025-01-02 00:00:00]; )
DistributionKey: cnt
Buckets: 2
ReplicationNum: 1
StorageMedium: HDD
CooldownTime: 9999-12-31 15:59:59
LastConsistencyCheckTime: NULL
DataSize: 955B
IsInMemory: false
RowCount: 1
DataVersion: 2
VersionEpoch: 332562981307023360
VersionTxnType: TXN_NORMAL
*************************** 2. row ***************************
PartitionId: 11439
PartitionName: p20250102
VisibleVersion: 2
VisibleVersionTime: 2025-01-09 09:33:10
VisibleVersionHash: 0
State: NORMAL
PartitionKey: uptime
Range: [types: [DATETIME]; keys: [2025-01-02 00:00:00]; ..types: [DATETIME]; keys: [2025-01-03 00:00:00]; )
DistributionKey: cnt
Buckets: 2
ReplicationNum: 1
StorageMedium: HDD
CooldownTime: 9999-12-31 15:59:59
LastConsistencyCheckTime: NULL
DataSize: 950B
IsInMemory: false
RowCount: 1
DataVersion: 2
VersionEpoch: 332562989028737024
VersionTxnType: TXN_NORMAL
*************************** 3. row ***************************
PartitionId: 11447
PartitionName: p20250103
VisibleVersion: 3
VisibleVersionTime: 2025-01-09 09:34:12
VisibleVersionHash: 0
State: NORMAL
PartitionKey: uptime
Range: [types: [DATETIME]; keys: [2025-01-03 00:00:00]; ..types: [DATETIME]; keys: [2025-01-04 00:00:00]; )
DistributionKey: cnt
Buckets: 2
ReplicationNum: 1
StorageMedium: HDD
CooldownTime: 9999-12-31 15:59:59
LastConsistencyCheckTime: NULL
DataSize: 949B
IsInMemory: false
RowCount: 1
DataVersion: 3
VersionEpoch: 332562995456507904
VersionTxnType: TXN_NORMAL
3 rows in set (0.00 sec)

-- 查某个表表的创建语句（DDL）
SHOW CREATE TABLE test01;
SHOW CREATE TABLE testdb.test01;
SHOW CREATE TABLE default_catalog.testdb.test01;

mysql> SHOW CREATE TABLE default_catalog.testdb.test01\G;
*************************** 1. row ***************************
Table: test01
Create Table: CREATE TABLE `test01` (
`id` int(11) NOT NULL COMMENT "",
`info` varchar(65533) NULL COMMENT "",
`cnt` int(11) NULL COMMENT "",
`uptime` datetime NULL COMMENT ""
) ENGINE=OLAP
PRIMARY KEY(`id`)
DISTRIBUTED BY HASH(`id`)
PROPERTIES (
"compression" = "LZ4",
"enable_persistent_index" = "true",
"fast_schema_evolution" = "true",
"replicated_storage" = "true",
"replication_num" = "1"
);

-- 查询表的分区(PartitionId,PartitionName)和分桶(Buckets)等信息
SHOW PARTITIONS FROM test01;
SHOW PARTITIONS FROM testdb.test01;
SHOW PARTITIONS FROM default_catalog.testdb.test01;

-- 查看表的子表（tablet）总数：tablet子表总数 = 分区数(partitions) * 分桶数(buckets) * 副本数(replication_num)。非分区表按分区数为1计算。
SHOW tablet FROM test01;
SHOW tablet FROM default_catalog.testdb.test01;

-- 查看自动分桶 & 默认分桶相关配置参数
-- enable_auto_tablet_distribution = true 表示开启自动分桶功能，建表时未指定分桶数量(例如：BUCKETS 8)时系统也会自动设置分区的分桶数
ADMIN SHOW FRONTEND CONFIG LIKE '%bucket%';

-- 新增分区时，可以手动指定分桶数量，手动修改设置动态分区的默认分桶数（注意：不支持修改已创建分区的分桶数量）：
-- 手动创建/新增分区时带上 BUCKETS num 显式的指定分桶数量
ALTER TABLE <table_name> ADD PARTITION <partition_name> [DISTRIBUTED BY HASH (k1[,k2 ...]) [BUCKETS num]];
-- 手动设置表的动态分区的默认分桶数量
ALTER TABLE <table_name> SET ("dynamic_partition.buckets"="xxx");

-- 查询表数据量大小（字节）
SELECT concat(round(sum(data_length/1024/1024),2),'MB') AS data_length_MB, concat(round(sum(index_length/1024/1024),2),'MB') AS index_length_MB FROM information_schema.tables WHERE `TABLE_CATALOG`='def' AND table_schema='testdb' AND table_name = 'performance_test02_dst';
SELECT concat(round(sum(data_length/1024/1024),2),'MB') AS data_length_MB, concat(round(sum(index_length/1024/1024),2),'MB') AS index_length_MB FROM information_schema.tables WHERE `TABLE_CATALOG`='def' AND table_schema='testdb' AND table_name = 'test02';

3、StarRocks 数据导入和导出

StarRocks 数据导入

支持多种导入方式：Insert、Stream Load、Broker Load、Pipe、Routine Load、Spark Load。

Insert：
完整的语法参考：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/loading_unloading/INSERT/

INSERT INTO VALUES：往内部表写入少量数据。
INSERT INTO SELECT：
1）INSERT INTO SELECT FROM <table_name> ：往目标表写入另外一张表（内部表或外部表）的查询结果。
2）INSERT INTO SELECT FROM FILES()：往目标表写入远端存储的数据文件的查询结果。该特性自 3.1 版本起支持 AWS S3 数据源，自 3.2 版本起支持 HDFS、Microsoft Azure Storage、Google GCS、及其他兼容 S3 协议的对象存储（如 MinIO）等数据源。

单次导入数据量限制：根据内存大小的不同而不同。

INSERT OVERWRITE 覆盖写（覆盖目的表的数据）。

Stream Load：
适用场景：从本地文件系统批量导入数据。
支持的文件格式： CSV、JSON。
单次导入数据量限制： 10 GB 以内。

Broker Load：
适用场景：从 HDFS 或 AWS S3、Microsoft Azure Storage、Google GCS、其他兼容 S3 协议的云存储（如MinIO）、Alibaba Cloud OSS、Tencent Cloud COS、Huawei Cloud OBS 等数据源批量导入数据。从本地文件系统或 NAS 批量导入数据。
支持的文件格式： CSV、Parquet、ORC、JSON（自 3.2.3 版本起支持）。
单次导入数据量限制：数十到数百 GB。

Pipe：
适用场景：从 HDFS 或 AWS S3 批量或实时导入数据（该特性自 3.2 版本起支持）。
支持的文件格式： Parquet、ORC。
单次导入数据量限制： 100 GB 到 TB 级别。

Routine Load：
适用场景：从 Kafka 实时导入数据。
支持的文件格式： CSV、JSON、Avro（自 3.0.1 版本起支持）。
单次导入数据量限制：微批导入 MB 到 GB 级别。

Spark Load：
适用场景：通过 Spark 集群从 HDFS 批量导入 Apache Hive? 表的数据。
支持的文件格式： CSV、Parquet（自 2.0 版本起支持）、ORC（自 2.0 版本起支持）。
单次导入数据量限制：数十 GB 到 TB 级别。

生态工具：
StarRocks Connector for Apache Kafka（简称 Kafka Connector）
StarRocks Connector for Apache Spark（简称 Spark Connector）
StarRocks Connector for Apache Flink（简称 Flink Connector）
以及其他工具（比如 SMT、DataX、CloudCanal、Kettle Connector）

API：
Stream Load transaction interface。Stream Load 事务接口。
适用场景：从 Apache Flink、Apache Kafka 等外部系统导入数据时，实现跨系统的两阶段（2PC）提交。该特性自 2.4 版本起支持。
支持的文件格式： CSV and JSON。
单次导入数据量限制： 10 GB 以内。

从本地文件系统导入方案：
https://docs.starrocks.io/zh/docs/loading/StreamLoad/
使用 Stream Load 进行batch同步导入。
使用 Broker Load 进行batch异步导入。

StarRocks 提供两种导入方式帮助您从本地文件系统导入数据：

使用 Stream Load 进行同步导入。
使用 Broker Load 进行异步导入。
两种导入方式各有优势：

Stream Load 支持 CSV 和 JSON 两种数据文件格式，适用于数据文件数量较少且单个文件的大小不超过 10 GB 的场景。
Broker Load 支持 Parquet、ORC、CSV、及 JSON 四种文件格式（JSON 文件格式自 3.2.3 版本起支持），适用于数据文件数量较多且单个文件的大小超过 10 GB 的场景、以及文件存储在 NAS 的场景。
对于 CSV 格式的数据，需要注意以下两点：

StarRocks 支持设置长度最大不超过 50 个字节的 UTF-8 编码字符串作为列分隔符，包括常见的逗号 (,)、Tab 和 Pipe (|)。
空值 (null) 用 \N 表示。比如，数据文件一共有三列，其中某行数据的第一列、第三列数据分别为 a 和 b，第二列没有数据，则第二列需要用 \N 来表示空值，写作 a,\N,b，而不是 a,,b。a,,b 表示第二列是一个空字符串。
Stream Load 和 Broker Load 均支持在导入过程中做数据转换、以及通过 UPSERT 和 DELETE 操作实现数据变更。请参见导入过程中实现数据转换和通过导入实现数据变更。

本地文件系统 Stream Load 导入

-- Stream Load 导入数据

Stream Load导入详细介绍可参考官方资料：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/loading_unloading/STREAM_LOAD/
Stream Load语法：
curl --location-trusted -u <username>:<password> -XPUT <url>
(
data_desc
)
[opt_properties]

curl StreamLoad 参数说明：
--location-trusted
此参数用于允许 curl 将认证凭据传输给任何重定向的 URL。
-u root
用于登录 StarRocks 的用户名。指定密码格式为 -u root:pwd，无密码格式为 -u root:

data_desc: 用于描述源数据文件，包括源数据文件的名称、格式、列分隔符、行分隔符、目标分区、以及与 StarRocks 表之间的列对应关系等。data_desc 中的参数可以分为三类：公共参数、CSV 适用的参数、以及 JSON 适用的参数。
opt_properties: 用于指定一些导入相关的可选参数。指定的参数设置作用于整个导入作业。
data_desc & opt_properties 详细介绍参考官网：https://docs.starrocks.io/zh/docs/sql-reference/sql-statements/loading_unloading/STREAM_LOAD/

-T filename
T 代表传输（Transfer），用于指定需要传输的文件名。
-H 设置 header 参数：
   label:crashdata-0
   与此 Stream Load 作业关联的标签。标签必须唯一，因此如果多次运行作业，您可以添加一个数字保持递增。
   where: <condition1>[, <condition2>, ...] 可选参数，用于指定过滤条件。如果指定该参数，StarRocks 会按照指定的过滤条件对转换后的数据进行过滤。只有符合 WHERE 子句中指定的过滤条件的数据才会导入。
   column_separator:,
   如果导入的文件使用单个 , 作为列分隔符，则设置如上所示。如果使用其他分隔符，则在此处设置该分隔符。常见分隔符包括 \t、, 和 |。
   skip_header:1
   某些 CSV 文件会在首行（Header）记录所有的列名，还有些会在第二行记录所有列的数据类型信息。如果 CSV 文件有一或两个 Header 行，需要将 skip_header 设置为 1 或 2。如果您使用的 CSV 没有 Header 行，请将其设置为 0。
   enclose:\"
   如果某些字段包含带有逗号的字符串，则需要用双引号括起该字段。本教程使用的示例数据集中，地理位置信息包含逗号，因此需将 enclose 设置为 \"，其中 \ 用于转义 "。
   max_filter_ratio:1
   导入数据中允许出现错误行的比例，范围 0~1，默认值为 0。理想情况下，应将其设置为 0，即当导入的数据中有任意一行出现错误时，导入作业会失败。本教程中需要将其设置为 1，即在调试过程中，允许所有数据行出现错误。
   timeout: 可选参数。用于导入作业的超时时间。取值范围：1 ~ 259200。单位：秒。默认值：600。除了 timeout 参数可以控制该导入作业的超时时间外，您还可以通过 FE 配置参数 stream_load_default_timeout_second 来统一控制 Stream Load 导入作业的超时时间。如果指定了timeout 参数，则该导入作业的超时时间以 timeout 参数为准；如果没有指定 timeout 参数，则该导入作业的超时时间以stream_load_default_timeout_second 为准。
   strict_mode:
   可选参数。用于指定是否开严格模式。取值范围：true 和 false。默认值：false。true 表示开启，false 表示关闭。
   关于该模式的介绍，参见严格模式（https://docs.starrocks.io/zh/docs/loading/load_concept/strict_mode/）
   如果开启严格模式，StarRocks 会把错误的数据行过滤掉，只导入正确的数据行，并返回错误数据详情。
   如果关闭严格模式，StarRocks 会把转换失败的错误字段转换成 NULL 值，并把这些包含 NULL 值的错误数据行跟正确的数据行一起导入。
   实际导入过程中，正确的数据行和错误的数据行都有可能存在 NULL 值。如果目标列不允许 NULL 值，则 StarRocks 会报错，并把这些包含 NULL 值的数据行过滤掉。
   对于 Stream Load、Broker Load、Routine Load 和 Spark Load，导入作业能够容忍的因数据质量不合格而过滤掉的错误数据行所占的最大比例，由作业的可选参数 max_filter_ratio 控制。INSERT 导入方式当前不支持 max_filter_ratio 参数。
   不同导入方式 strict_mode 默认值不同：
   使用 Stream Load、Broker Load、Routine Load 和 Spark Load 执行数据导入时，需要通过参数 strict_mode 来设置严格模式。参数取值范围：true 和 false。默认值：false。true 表示开启，false 表示关闭。
   使用 INSERT 执行数据导入时，需要通过会话变量 enable_insert_strict 来设置严格模式。变量取值范围：true 和 false。默认值：true。true 表示开启，false 表示关闭。
   columns:
   此参数用于将 CSV 文件中的列映射到 StarRocks 表中的列。当前教程中使用的 CSV 文件中有大量的列，而 StarRocks 表中的列经过裁剪，仅保留部分列。未包含在表中的列在导入过程中都将被跳过。
   注意：
   columns 参数支持数据转换逻辑，在 CSV 文件中经常会有不符合标准的日期和时间，导入时可以指定数据转换逻辑、将日期和时间数据转换为 DATETIME 类型的逻辑。
   例如：如果数据集中的日期是以 MM/DD/YYYY 为格式（CRASH_DATE 列）、时间以 HH:MI 为格式（CRASH_TIME）的2个单独的列：
   08/05/2014,9:10,BRONX,10469,40.8733019,-73.8536375,"(40.8733019, -73.8536375)",
   由于 StarRocks 中的 DATETIME 格式为 YYYY-MM-DD HH:MI:SS，因此需要转换数据集中的数据，将两列数据合并成一列、并以空格分隔。则此处 columns: 参数应为：
   -H "columns:tmp_CRASH_DATE, tmp_CRASH_TIME, CRASH_DATE=str_to_date(concat_ws(' ', tmp_CRASH_DATE, tmp_CRASH_TIME), '%m/%d/%Y %H:%i')
   说明：
   通过设置以上参数可实现以下目标：
   将 CSV 文件的第一列内容分配给 tmp_CRASH_DATE 列；
   将 CSV 文件的第二列内容分配给 tmp_CRASH_TIME 列；
   通过 concat_ws() 函数，使用空格将 tmp_CRASH_DATE 列和 tmp_CRASH_TIME 列连接在一起；
   通过 str_to_date() 函数使用连接后的字符串生成 DATETIME 数据；
   将生成的 DATETIME 数据存储在列 CRASH_DATE 中。
timezone: 可选参数。用于指定导入作业所使用的时区。默认为东八区 (Asia/Shanghai)。该参数的取值会影响所有导入涉及的、跟时区设置有关的函数所返回的结果。受时区影响的函数有 strftime、alignment_timestamp 和 from_unixtime 等，具体请参见设置时区。导入参数 timezone 设置的时区对应“设置时区”中所述的会话级时区。
load_mem_limit: 可选参数。导入作业的内存限制，最大不超过 BE（或 CN）的内存限制。单位：字节。默认内存限制为 2 GB。
partial_update: 可选参数。部分更新。是否使用部分列更新。取值包括 TRUE 和 FALSE。默认值：FALSE。
partial_update_mode: 部分更新模式。
   可选参数。指定部分更新的模式，取值包括 row 和 column：
   row：默认值，指定使用行模式执行部分更新，比较适用于较多列且小批量的实时更新场景。
   column：指定使用列模式执行部分更新，比较适用于少数列并且大量行的批处理更新场景。在该场景，开启列模式，更新速度更快。例如，在一个包含 100 列的表中，每次更新 10 列（占比 10%）并更新所有行，则开启列模式，更新性能将提高 10 倍。
merge_condition: 可选参数。
   用于指定作为更新生效条件的列名。这样只有当导入的数据中该列的值大于等于当前值的时候，更新才会生效。StarRocks v2.5 起支持条件更新。参见通过导入实现数据变更。
   详情参考：https://docs.starrocks.io/zh/docs/loading/Load_to_Primary_Key_tables/
   注意：指定的列必须为非主键列，且仅主键表支持条件更新。

   StarRocks 的主键表支持通过 Stream Load、Broker Load 或 Routine Load 导入作业，对 StarRocks 表进行数据变更，包括插入、更新和删除数据。不支持通过 Spark Load 导入作业或 INSERT 语句对 StarRocks 表进行数据变更。
   StarRocks 还支持部分更新 (Partial Update) 和条件更新 (Conditional Update)。
   StarRocks 的主键表目前支持 UPSERT 和 DELETE 操作，不支持区分 INSERT 和 UPDATE 操作。
   在创建导入作业时，StarRocks 支持在导入作业的创建语句或命令中添加 __op 字段，用于指定操作类型。
   不同的导入方式，定义 __op 字段的方法也不相同：
       如果使用 Stream Load 导入方式，需要通过 columns 参数来定义 __op 字段。
       如果使用 Broker Load 导入方式，需要通过 SET 子句来定义 __op 字段。
       如果使用 Routine Load 导入方式，需要通过 COLUMNS 参数来定义 __op 字段。
   根据要做的数据变更操作，您可以选择添加或者不添加 __op 字段。不添加 __op 字段的话，默认为 UPSERT 操作。
   主要涉及的数据变更操作场景如下：
       1）当数据文件只涉及 UPSERT 操作时，可以不添加 __op 字段。
       2）当数据文件只涉及 DELETE 操作时，必须添加 __op 字段，并且指定操作类型为 DELETE。
       3）当数据文件中同时包含 UPSERT 和 DELETE 操作时，必须添加 __op 字段，并且确保数据文件中包含一个代表操作类型的列，取值为 0 或 1。其中，取值为 0 时代表 UPSERT 操作，取值为 1 时代表 DELETE 操作。
   使用说明：
       1）必须确保待导入的数据文件中每一行的列数都相同。
       2）所更新的列必须包含主键列。

-XPUT: 指定 HTTP 请求方法。必选参数。Stream Load 当前只支持 PUT 方法。
url: 用于指定 StarRocks 表的 URL 地址。必选参数。格式为 http://<fe_host>:<fe_http_port>/api/<database_name>/<table_name>/_stream_load
您可以通过 SHOW frontends 命令查看 FE 节点的 IP 地址和 HTTP 端口号，例如：mysql -h192.168.1.250 -P9030 -uroot -p -e "SHOW frontends;"

mysql -h192.168.1.250 -P9030 -utest -Dtestdb -p -e "TRUNCATE TABLE test01;"
mysql -h192.168.1.250 -P9030 -utest -Dtestdb -p -e "SELECT * FROM test01;"

-- 从本地文件导入数据--UPSET（不指定__op、则默认UPSET）
-- StarRocks 的 Stream Load 导入方式需要使用 curl 命令，涉及许多参数
echo '1,"aaa",100,"2024-11-10 08:30:21.111222"
2,"bbb",102,"2024-11-11 08:35:58.333444"' > test01.csv

curl --location-trusted -u test:1q2w3e \
-T ./test01.csv \
-H "label:test01_001" \
-H "column_separator:," \
-H "skip_header:0" \
-H "enclose:\"" \
-H "max_filter_ratio:0" \
-H "columns:id,info,cnt,uptime" \
-XPUT http://localhost:8030/api/testdb/test01/_stream_load

-- 命令上指定用户密码方式： -u user:pwd
-- 命令上指定用户如果没有设置密码，则： -u user:
-- 命令上也可以不指定密码，等提示输入再输入密码，则：-u user
curl --location-trusted -u test \
-T ./test01.csv \
-H "label:test01_002" \
-H "column_separator:," \
-H "skip_header:0" \
-H "enclose:\"" \
-H "max_filter_ratio:0" \
-H "columns:id,info,cnt,uptime" \
-XPUT http://localhost:8030/api/testdb/test01/_stream_load

-- 导入时也可以不指定 columns（csv文件中的列数要一致）:
curl --location-trusted -u test:1q2w3e \
-T ./test01.csv \
-H "label:test01_003" \
-H "column_separator:," \
-H "skip_header:0" \
-H "enclose:\"" \
-H "max_filter_ratio:0" \
-XPUT http://localhost:8030/api/testdb/test01/_stream_load

-- 从本地文件导入数据--DELETE（必须指定__op，仅主键表支持DELETE操作，无主键表不支持。如果不指定__op则默认为UPSET）
curl --location-trusted -u test:1q2w3e \
-T ./test01.csv \
-H "label:test01_004" \
-H "column_separator:," \
-H "skip_header:0" \
-H "enclose:\"" \
-H "max_filter_ratio:0" \
-H "columns:__op='delete'" \
-XPUT http://localhost:8030/api/testdb/test01/_stream_load

注意：仅主键表支持DELETE操作，如果是非主键表，上述命令执行后的效果是追加写的效果，多次执行，每次都会追加csv文件中的数据到目的表。

-- 如果csv文件数据中同时存在 UPSET 和 DELETE 的数据行，则需要在 csv 文件中包含 __op 字段、填写对应值（0 代表 UPSET；1 代表 DELETE）
-- 准备数据文件 test01_b.csv，数据中的第一列为临时列、值为0代表UPSET、1代表DELETE
echo '0,1,"aaa",100,"2024-11-10 08:30:21.111222"
1,2,"bbb",102,"2024-11-11 08:35:58.333444"' > test01_b.csv

查看准备好的csv文件内容：
root@2ce391eef088:/data/deploy/starrocks# cat test01_b.csv
0,1,"aaa",100,"2024-11-10 08:30:21.111222"
1,2,"bbb",102,"2024-11-11 08:35:58.333444"

-- UPSET 和 DELETE 导入测试
-- 目的表 INSERT 插入数据
mysql -h192.168.1.250 -P9030 -utest -Dtestdb -p -e "INSERT OVERWRITE test01 (id,info,cnt,uptime) VALUES (1,'aaa',100,'2024-11-10 08:30:21.111222'),(2,'bbb',102,'2024-11-11 08:35:58.333444');"
-- 查询数据
mysql -h192.168.1.250 -P9030 -utest -Dtestdb -p -e "SELECT * FROM test01;"

root@2ce391eef088:/data/deploy/starrocks# mysql -h192.168.1.250 -P9030 -utest -Dtestdb -p -e "SELECT * FROM test01;"
Enter password:
+------+------+------+----------------------------+
| id | info | cnt | uptime |
+------+------+------+----------------------------+
| 2 | bbb | 102 | 2024-11-11 08:35:58.333444 |
| 1 | aaa | 100 | 2024-11-10 08:30:21.111222 |
+------+------+------+----------------------------+

-- 执行csv导入（含UPSET和DELETE）
-- -H "columns:xxx" 中指定 __op=opflag 操作列(临时列opflag)，后面指定csv数据文件中对应的数据列:opflag,id,info,cnt,uptime
curl --location-trusted -u test:1q2w3e \
-T ./test01_b.csv \
-H "label:test01_005" \
-H "column_separator:," \
-H "skip_header:0" \
-H "enclose:\"" \
-H "max_filter_ratio:0" \
-H "columns:__op=opflag,opflag,id,info,cnt,uptime" \
-XPUT http://localhost:8030/api/testdb/test01/_stream_load

-- 执行结果：
root@2ce391eef088:/data/deploy/starrocks# curl --location-trusted -u test:1q2w3e \
> -T ./test01_b.csv \
> -H "label:test01_013" \
> -H "column_separator:," \
> -H "skip_header:0" \
> -H "enclose:\"" \
> -H "max_filter_ratio:0" \
> -H "columns:__op=opflag,opflag,id,info,cnt,uptime" \
> -XPUT http://localhost:8030/api/testdb/test01/_stream_load
{
"TxnId": 149,
"Label": "test01_013",
"Status": "Success",
"Message": "OK",
"NumberTotalRows": 2,
"NumberLoadedRows": 2,
"NumberFilteredRows": 0,
"NumberUnselectedRows": 0,
"LoadBytes": 86,
"LoadTimeMs": 186,
"BeginTxnTimeMs": 0,
"StreamLoadPlanTimeMs": 2,
"ReadDataTimeMs": 0,
"WriteDataTimeMs": 58,
"CommitAndPublishTimeMs": 124

执行后的效果是更新目的表中id=1的行、删除id=2的行。

starrocks-connector-for-kettle 导入（Stream Load方式）：

地址&端口：必填。支持多地址输入，英文分号分隔，例如：192.168.100.101:8030;192.168.100.102:8030;192.168.100.103:8030;
数据库名：必填。
user：必填。
pwd：选填。无密码则不填。
使用的是 StreamLoad 方式，单次导入最大10G；
格式（foramt）：必填。StreamLoad格式，支持 CSV、JSON。

列分割符（Column Sepatator）：选填。不指定默认为\t；选择CSV格式时为必填参数；最大长度支持最大不超过 50 个字节的 UTF-8 编码字符串作为列分隔符；
Json Paths：用于指定待导入的字段的名称。仅在使用匹配模式导入 JSON 数据时需要指定该参数。
单次导入最大字节数：选填。默认94371840(90M)。数据攒批的大小，达到该阈值后将数据通过 Stream Load 批量写入 StarRocks。取值范围：[64MB, 10GB]。
刷新频率-Scanning Frequency：选填，默认50ms
导入作业最大容错率-Max Filter Ratio：用于指定导入作业的最大容错率，即导入作业能够容忍的因数据质量不合格而过滤掉的数据行所占的最大比例。取值范围：0~1。默认值：0。
StarRocks连接超时时间-Connect Timeout:
连接 Http-url 的超时时间。选填。取值范围：[100, 60000]。默认1000。
Stream Load载入数据超时时间-Stream Load Timeout：Stream Load 超时时间，单位为秒。选填。默认600秒。
Stream Load 属性-Stream Load Properties：可选。Stream Load 的参数，控制导入行为。
部分导入-Partial Update：StarRocks v2.2 起，主键模型表支持部分更新，可以选择只更新部分指定的列。若勾选实现部分导入需要在“部分导入行”中填写要导入的列名。
部分导入行-Partial Update Columns：需要部分更新的列名。需要填写所要写入的目标表中对应的列名。各列名之间要以英文逗号隔开,，例如：col1,col2,col3
是否支持更新和删除-Enable Upsert Delete：
StarRocks 目前支持 UPSERT 和 DELETE 操作，不支持一次作业区分UPSERT和DELETE，只能对一次导入单独实现UPSERT和DELETE。
UPSERT: 该操作用于插入或更新数据。如果数据已存在（基于主键/唯一键），它将更新该数据；如果数据不存在，它将插入新数据。
DELETE: 该操作用于删除符合条件的数据记录。需要指定删除的条件，满足该条件的所有记录都将被删除。
目前StarRocks Kettle Connector目前支持UPSERT和DELETE操作，仅支持在一个步骤中使用一种操，不支持一个步骤中同时实现UPSERT和DELETE。在Kettle上游传输过来的数据中没有区分对每条数据进行那种操作的标识，因此不能对一批数据进行分别使用UPSERT或DELETE。若想要进行区分处理，可以尝试使用Kettle步骤开启复制多线程将数据分开两条数据流分别对其进行数据过滤最后通过UPSERT或DELETE将数据导入。

Upsert or Delete：当勾选“是否支持更新和删除”时需要选择是执行UPSERT或DELETE操作。若未选择则不执行更新或删除操作。
表字段-Table field： StarRocks目标表中各列的名称。需要与流字段一一对应。
流字段-Stream field：上一步骤传输过来的数据列名称。从上一步骤传递的数据列名称和类型必须与StarRocks目标表的数据格式和大小完全匹配。

条件更新 (Conditional Update)：指定更新条件。

Kettle数据类型
String：存储字符串或文本信息。
Date：存储日期信息。日期被存储为从1970-01-01 00:00:00.000 GMT开始的毫秒数。因此，可以保存任何日期和时间，从公元前至公元后。日期类型的默认掩码为yyyy/MM/dd HH:mm:ss.SSS。
Boolean：存储逻辑值，即True/False。
Integer：存储整数值。所有整数都被当作长整型(Long)处理，范围在-9223372036854775808到9223372036854775807之间。
Number：用于存储浮点数。这是一种双精度浮点类型，具有至少15位的精度。
BigNumber：用于存储任意精度的数字，适合用于精确的科学计算。
Binary：用于存储二进制对象。
Timestamp：这是一个扩展数据库的日期类型，允许更好地在数据库中处理日期和时间的组合。
Internet Address：存储Internet地址，主要存储网站的IPV4或IPV6地址。

StarRocks数据类型以及与Kettle对应
Kettle   StarRocks
String   CHAR、STRING、VARCHAR、JSON
Date   DATE、DATETIME
Boolean   BOOLEAN
Integer   TINYINT 、SMALLINT 、INT 、BIGINT
Number   DOUBLE、FLOAT
BigNumber   LARGEINT、DECIMAL
Binary   暂不支持
Timestamp   DATETIME、DATE
Internet Address   STRING
serializable 暂不支持

您可以通过 SHOW frontends 命令查看 FE 节点的 IP 地址和 HTTP 端口号。

注意&限制：
必须确保待导入的数据文件中每一行的列数都相同。
所更新的列必须包含主键列。
Kettle中暂不支持处理HLL和Bitmap位图这两种高级数据结构。
kttle版本尽量使用最近版本，9.3.0.0-349开始更新为Java11.
JDBC地址只用于从fe节点中获取数据库表信息，只需添加一个地址即可。
Kettle在进行Check时StarRocks中的largeint会被获取成UNKNOW，boolean会被映射成tinyint，这两处错误可忽略。
只支持CSV和JSON两种数据格式：在使用Stream Load向StarRocks导入数据时只采用这两种数据格式。导入步骤的上游源数据则可是Kettle中的任意数据格式。

StarRocks 数据导出

JDBC SELECT 查询导出或利用第三方工具（例如：starrocks-connector-for-apache-flink)导出。