ShardingSphere-Proxy5.5.2 DistSQL

发表于 分类于 ， ， 置顶 精品
阅读次数： 本文字数： 3.9k 阅读时长 ≈ 14 分钟

摘要

DistSQL

  • DistSQL（Distributed SQL）是 Apache ShardingSphere 特有的操作语言。 它与标准 SQL 的使用方式完全一致，用于提供增量功能的 SQL 级别操作能力。

  • 灵活的规则配置和资源管控能力是 Apache ShardingSphere 的特点之一。

  • 在使用 4.x 及其之前版本时，开发者虽然可以像使用原生数据库一样操作数据，但却需要通过本地文件或注册中心配置资源和规则。然而，操作习惯变更，对于运维工程师并不友好。

  • 从 5.x 版本开始，DistSQL（Distributed SQL）让用户可以像操作数据库一样操作 Apache ShardingSphere，使其从面向开发人员的框架和中间件转变为面向运维人员的数据库产品。

  • DistSQL 细分为 RDL、RQL、RAL 和 RUL 四种类型。

    • RDL: Resource & Rule Definition Language，负责资源和规则的创建、修改和删除。
    • RQL: Resource & Rule Query Language，负责资源和规则的查询和展现。
    • RAL: Resource & Rule Administration Language，负责强制路由、熔断、配置导入导出、数据迁移控制等管理功能。
    • RUL: Resource & Rule Utility Language，负责 SQL 解析、SQL 格式化、执行计划预览等功能。

示例准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 配置为基于 zookeeper 集群模式，为了演示 DistSQL 语法，这里需要将配置持久化，使用 JDBC 的单机模式也可以
mode:
  type: Cluster                 # 运行模式，默认是单机模式 Standalone
  repository:
    type: ZooKeeper             # 注册中心类型
    props:
      namespace: governance_ds  # ZooKeeper 上的根路径（逻辑命名空间），ShardingSphere 会把所有元数据（schema 的 data_sources、rules、版本信息、运行时实例节点等）放在该 namespace 下
      server-lists: localhost:2181 # ZooKeeper 集群地址列表，以逗号分隔的 host:port 列表
      retryIntervalMilliseconds: 500 # 与注册中心交互失败后的重试间隔（毫秒）。网络不稳定或短暂故障时用于重试回退。
      timeToLiveSeconds: 60     # 表示“临时/短期数据”的生存时间（秒），用于控制某些临时节点/实例信息的存活策略
      maxRetries: 3             # 最大重试次数（超过则认为操作失败）。
      operationTimeoutMilliseconds: 500  # 单次 ZooKeeper 操作（读写）的超时时间（毫秒）。

# 配置用户和权限，因为 DistSQL 暂不支持 用户和权限管理，所以这里需要先配置用户和权限
authority:
  users:
    - user: root@127.0.0.1
      password: root
      admin: true
    - user: sharding@%
      password: sharding
  privilege:
    type: DATABASE_PERMITTED
    props:
      user-database-mappings: root@127.0.0.1=*,sharding@%=sharding_db

  • 启动 ShardingSphere-Proxy 服务，并登录

1
2
3
4
5
6
7
8
9
10
11
12
13
# 启动 ShardingSphere-Proxy
./shardingsphere-proxy-bin/bin/start.sh
# 使用管理员登录
mysql -h127.0.0.1 -uroot -proot -P3307

# 查看当前用户权限
mysql> SHOW AUTHORITY RULE;
+----------------------------+--------------------+----------------------------------------------------------------------+
| users                      | provider           | props                                                                |
+----------------------------+--------------------+----------------------------------------------------------------------+
| root@127.0.0.1; sharding@% | DATABASE_PERMITTED | {"user-database-mappings":"root@127.0.0.1=*,sharding@%=sharding_db"} |
+----------------------------+--------------------+----------------------------------------------------------------------+
1 row in set (0.49 sec)

全局配置，即global.yaml中的配置

  • 全局配置对所有逻辑数据库有效

属性配置

  • 配置文件中的配置

1
2
props:
  sql-show: true # 控制台打印改写后的 SQL，便于排错，默认为 false

DistSQL 语法

1
2
# 这里要注意，属性名需要使用下划线格式
SET DIST VARIABLE sql_show = true;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
mysql> SHOW DIST VARIABLES;
+-----------------------------------------+-----------------+
| variable_name                           | variable_value  |
+-----------------------------------------+-----------------+
| agent_plugins_enabled                   | true            |
| cached_connections                      | 0               |
| cdc_server_port                         | 33071           |
| check_table_metadata_enabled            | false           |
| kernel_executor_size                    | 0               |
| load_table_metadata_batch_size          | 1000            |
| max_connections_size_per_query          | 1               |
| proxy_backend_query_fetch_size          | -1              |
| proxy_default_port                      | 3307            |
| proxy_frontend_database_protocol_type   |                 |
| proxy_frontend_executor_size            | 0               |
| proxy_frontend_flush_threshold          | 128             |
| proxy_frontend_max_connections          | 0               |
| proxy_frontend_ssl_cipher               |                 |
| proxy_frontend_ssl_enabled              | false           |
| proxy_frontend_ssl_version              | TLSv1.2,TLSv1.3 |
| proxy_meta_data_collector_enabled       | false           |
| proxy_netty_backlog                     | 1024            |
| sql_show                                | true            |
| sql_simple                              | false           |
| system_log_level                        | INFO            |
| system_schema_metadata_assembly_enabled | true            |
+-----------------------------------------+-----------------+

分布式事务配置

  • 配置文件中的配置

1
2
3
transaction:
  defaultType: XA
  providerType: Atomikos

DistSQL 语法

1
SHOW TRANSACTION RULE;
1
2
3
ALTER TRANSACTION RULE(
  DEFAULT="XA", TYPE(NAME="Atomikos")
);

规则配置，即database-xxx.yaml中的配置

  • 以下 DistSQL 仅可以在逻辑库中执行，所以需要先创建一个逻辑数据库

1
2
3
4
5
mysql> CREATE DATABASE sharding_db;
Query OK, 0 rows affected (0.03 sec)

mysql> use sharding_db;
Database changed

数据源配置

  • 在 DistSQL中，官方将数据源叫做存储单元(STORAGE UNIT)

  • 配置文件中的配置

1
2
3
4
5
6
7
8
9
10
dataSources:
  ds_0: # 逻辑数据源名称
    url: jdbc:mysql://127.0.0.1:3306/shardingdb0?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8  # 注意这里属性为 url
    username: root
    password: newpwd

  ds_1:
    url: jdbc:mysql://127.0.0.1:3306/shardingdb1?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
    username: root
    password: newpwd

DistSQL 语法

1
2
3
4
5
6
7
8
9
10
11
REGISTER STORAGE UNIT ds_0 (
    URL="jdbc:mysql://127.0.0.1:3306/shardingdb0?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8",
    USER="root",
    PASSWORD="newpwd"
);

REGISTER STORAGE UNIT ds_1 (
    URL="jdbc:mysql://127.0.0.1:3306/shardingdb1?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8",
    USER="root",
    PASSWORD="newpwd"
);
1
SHOW STORAGE UNITS FROM sharding_db \G;
1
2
3
4
5
6
ALTER STORAGE UNIT ds_1 (
    URL="jdbc:mysql://127.0.0.1:3306/shardingdb1?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8",
    USER="root",
    PASSWORD="newpwd",
    PROPERTIES("maximumPoolSize"=10,"idleTimeout"=30000)
);
1
2
# 无法移除已经被规则使用的存储单元
UNREGISTER STORAGE UNIT ds_0;

单表配置

  • 配置文件中的配置

1
2
3
4
5
rules:
  - !SINGLE # 单表规则配置，单表规则优先级高于分库分表规则
    tables:
      # MySQL 风格
      - ds_0.t_address # 加载指定单表

DistSQL 语法

1
LOAD SINGLE TABLE ds_0.t_address;
1
SHOW SINGLE TABLES;
1
LOAD SINGLE TABLE ds_0.t_address;

广播表配置

  • 广播表，即所有数据源都包含的表，比如字典表

1
2
3
4
rules:
  - !BROADCAST  # 广播表配置，即所有的库中都包含指定的表，写入数据时同时写入多个库，查询时随机读一个
    tables:
      - dict    # 广播表名称，⼴播表不能配置分表逻辑，只往多个库的同⼀个表中插⼊数据。

DistSQL 语法

1
CREATE BROADCAST TABLE RULE dict;

分库分表配置

单分片键，Long 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
rules:
  - !SHARDING # 分片规则配置
    tables: # 手工分片规则配置
      course: # 逻辑表名称
        actualDataNodes: ds_${0..1}.course_${1..2} # 实际数据节点，建表时写成了 1和2，懒得改了，所以下面分表规则中对2取余后要+1
        databaseStrategy: # 分库策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: user_id # 分片列名称
            shardingAlgorithmName: course_db_inline # 分片算法名称
        tableStrategy: # 分表策略
          standard:
            shardingColumn: cid
            shardingAlgorithmName: course_inline
        keyGenerateStrategy: # 分布式序列策略
          column: cid # 自增列名称
          keyGeneratorName: snowflake # 分布式序列算法名称

    shardingAlgorithms: # 分片算法
      course_inline: # 定义名称，在上面引用
        type: INLINE # 基于行表达式的分片算法，这里使用 MOD 会报错
        props: # 属性
          algorithm-expression: course_${cid % 2 + 1} # 表达式，这是因为表名称为 course_1, course_2
          allow-range-query-with-inline-sharding: true # 允许范围查询
      course_db_inline:
        type: INLINE
        props:
          algorithm-expression: ds_${user_id % 2} # 表示 ds_0, ds_1

    keyGenerators: # 分布式主键生成器
      snowflake: # 定义名称，在上面引用
        type: SNOWFLAKE # 使用雪花算法，Long
DistSQL 语法
1
2
3
4
5
6
CREATE SHARDING TABLE RULE course (
  DATANODES("ds_${0..1}.course_${1..2}"),
  DATABASE_STRATEGY(TYPE="standard",SHARDING_COLUMN=user_id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="ds_${user_id % 2}")))),
  TABLE_STRATEGY(TYPE="standard",SHARDING_COLUMN=cid,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="course_${cid % 2 + 1}","allow-range-query-with-inline-sharding"=true )))),
  KEY_GENERATE_STRATEGY(COLUMN=cid,TYPE(NAME="snowflake"))
);

单分片键，String 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
rules:
  - !SHARDING # 分片规则配置
    tables: # 手工分片规则配置
      t_user:
        actualDataNodes: ds_${0..1}.t_user_${0..1} # 实际数据节点
        databaseStrategy: # 分库策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: id # 分片列名称
            shardingAlgorithmName: t_user_db_inline # 分片算法名称
        tableStrategy: # 分表策略
          standard:
            shardingColumn: id  # 分片列名称
            shardingAlgorithmName: t_user_inline # 分片算法名称
        keyGenerateStrategy: # 分布式序列策略
          column: id # 自增列名称，字符串类型
#           keyGeneratorName: uuid # 分布式序列算法名称
          keyGeneratorName: custom_snowflake_string # 分布式序列算法名称

    shardingAlgorithms: # 分片算法
      t_user_db_inline:
        type: INLINE
        props:
          algorithm-expression: ds_${Math.abs(id.hashCode()%2)} # 分库，ds_0, ds_1，id 为字符串，所以要转换为数字再进行运算
      t_user_inline:
        type: INLINE
        props:
          algorithm-expression: t_user_${Math.abs(id.hashCode()%4).intdiv(2)} # 分表，t_user_0, t_user_1

    keyGenerators: # 分布式序列算法
      uuid:    # 定义名称
        type: UUID # 字符串主键，String
      custom_snowflake_string:
        type: CUSTOM_SNOWFLAKE_STRING # 自定义雪花算法，String，spi
        props:
          workerId: 2
          datacenterId: 2
DistSQL 语法

  • 创建分片规则

1
2
3
4
5
6
CREATE SHARDING TABLE RULE t_user (
  DATANODES("ds_${0..1}.t_user_${0..1}"),
  DATABASE_STRATEGY(TYPE="standard",SHARDING_COLUMN=id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="ds_${Math.abs(id.hashCode()%2)}")))),
  TABLE_STRATEGY(TYPE="standard",SHARDING_COLUMN=id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="t_user_${Math.abs(id.hashCode()%4).intdiv(2)}")))),
  KEY_GENERATE_STRATEGY(COLUMN=id,TYPE(NAME="CUSTOM_SNOWFLAKE_STRING"))
);

多分片键，Long 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
rules:
  - !SHARDING # 分片规则配置
    tables: # 手工分片规则配置
      t_order_complex: # 逻辑表名称
        actualDataNodes: ds_${0..1}.t_order_complex_${0..1} # 实际数据节点
        databaseStrategy: # 分库策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: user_id # 分片列名称
            shardingAlgorithmName: t_order_db_inline # 分片算法名称
        tableStrategy: # 分表策略
          complex: # 用于多分片键的复杂分片场景
            shardingColumns: user_id,order_id
            shardingAlgorithmName: t_order-complex-algorithm
        keyGenerateStrategy: # 分布式序列策略
          column: order_id # 自增列名称
          keyGeneratorName: snowflake # 分布式序列算法名称
      t_order_item_complex: # 逻辑表名称
        actualDataNodes: ds_${0..1}.t_order_item_complex_${0..1} # 实际数据节点
        databaseStrategy: # 分库策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: user_id # 分片列名称
            shardingAlgorithmName: t_order_db_inline # 分片算法名称
        tableStrategy: # 分表策略
          complex: # 用于多分片键的复杂分片场景
            shardingColumns: user_id,order_id  # 分片列名称,多个逗号分隔
#             shardingAlgorithmName: t_order_item-class-based-algorithm   # 基于自定义类的分片算法
            shardingAlgorithmName: t_order_item-class-based-algorithm_spi # 基于 SPI 的分片算法，效果同上，建议生产环境使用 SPI
        keyGenerateStrategy: # 分布式序列策略
          column: item_id # 自增列名称
          keyGeneratorName: snowflake # 分布式序列算法名称

    shardingAlgorithms: # 分片算法
      t_order_db_inline:
        type: INLINE
        props:
          algorithm-expression: ds_${user_id % 2}
      t_order-complex-algorithm:
        type: COMPLEX_INLINE # 基于行表达式的复合分片算法
        props:
          algorithm-expression: t_order_complex_${(user_id + order_id + 1) % 2}
      t_order_item-class-based-algorithm_spi: # SPI
        type: T_ORDER_ITEM_COMPLEX # 基于自定义类的分片算法

    keyGenerators: # 分布式主键生成器
      snowflake: # 定义名称，在上面引用
        type: SNOWFLAKE # 使用雪花算法，Long
DistSQL 语法

  • 创建分片规则

1
2
3
4
5
6
7
8
9
10
11
12
13
CREATE SHARDING TABLE RULE t_order_complex (
  DATANODES("ds_${0..1}.t_order_complex_${0..1}"),
  DATABASE_STRATEGY(TYPE="standard",SHARDING_COLUMN=user_id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="ds_${user_id % 2}")))),
  TABLE_STRATEGY(TYPE="complex",SHARDING_COLUMNS=user_id,order_id,SHARDING_ALGORITHM(TYPE(NAME="complex_inline",PROPERTIES("algorithm-expression"="t_order_complex_${(user_id + order_id + 1) % 2}")))),
  KEY_GENERATE_STRATEGY(COLUMN=order_id,TYPE(NAME="snowflake"))
);

CREATE SHARDING TABLE RULE t_order_item_complex (
  DATANODES("ds_${0..1}.t_order_item_complex_${0..1}"),
  DATABASE_STRATEGY(TYPE="standard",SHARDING_COLUMN=user_id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="ds_${user_id % 2}")))),
  TABLE_STRATEGY(TYPE="complex",SHARDING_COLUMNS=user_id,order_id,SHARDING_ALGORITHM(TYPE(NAME="T_ORDER_ITEM_COMPLEX"))),
  KEY_GENERATE_STRATEGY(COLUMN=item_id,TYPE(NAME="SNOWFLAKE"))
);

自动分片规则

  • 上面介绍的都是手工配置分片规则，用于配置较为复杂的分片规则，如果分片规则比价简单，可以使用自动分片规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
rules:
  - !SHARDING # 分片规则配置
   # 绑定表：同分片键 join 时走同路由，多个逗号分隔，要求分片规则一致
    bindingTables:
      - t_order,t_order_item
    autoTables: # 自动分片规则配置
      t_order: # 逻辑表名称
        actualDataSources: ds_${0..1} # 数据源名称
        shardingStrategy: # 切分策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: user_id # 分片列名称
            shardingAlgorithmName: mod_2 # 自动分片算法名称
        keyGenerateStrategy: # 分布式序列策略
          column: order_id # 自增列名称
          keyGeneratorName: snowflake # 分布式序列算法名称
      t_order_item: # 逻辑表名称
        actualDataSources: ds_${0..1} # 数据源名称
        shardingStrategy: # 切分策略
          standard: # 用于单分片键的标准分片场景
            shardingColumn: user_id # 分片列名称
            shardingAlgorithmName: mod_2 # 自动分片算法名称
        keyGenerateStrategy: # 分布式序列策略
          column: item_id # 自增列名称
          keyGeneratorName: snowflake # 分布式序列算法名称

    shardingAlgorithms: # 分片算法
      mod_2:
        type: MOD # 基于 MOD 的分片算法
        props:
          sharding-count: 2 # 分片数量，即 对 2 进行取余

    keyGenerators: # 分布式主键生成器
      snowflake: # 定义名称，在上面引用
        type: SNOWFLAKE # 使用雪花算法，Long
DistSQL 语法

  • 创建分片规则

1
2
3
4
5
6
7
8
9
10
11
CREATE SHARDING TABLE RULE t_order (
  STORAGE_UNITS(ds_0,ds_1),
  SHARDING_COLUMN=user_id,TYPE(NAME="mod",PROPERTIES("sharding-count"="2")),
  KEY_GENERATE_STRATEGY(COLUMN=order_id,TYPE(NAME="snowflake"))
);

CREATE SHARDING TABLE RULE t_order_item (
  STORAGE_UNITS(ds_0,ds_1),
  SHARDING_COLUMN=user_id,TYPE(NAME="mod",PROPERTIES("sharding-count"="2")),
  KEY_GENERATE_STRATEGY(COLUMN=item_id,TYPE(NAME="snowflake"))
);

其它分片操作语句

1
2
3
4
5
6
# 查看当前逻辑库下的所有分片规则
SHOW SHARDING TABLE RULES \G;
# 查看指定逻辑库下的分片规则
SHOW SHARDING TABLE RULES FROM sharding_db; \G;
# 查看指定分片规则
SHOW SHARDING TABLE RULE t_user \G;

  • 修改分片规则，官网文档，与创建分片规则类似，将CREATE改为ALTER即可

1
2
3
4
5
6
ALTER SHARDING TABLE RULE t_order_item_complex (
  DATANODES("ds_${0..1}.t_order_item_complex_${0..1}"),
  DATABASE_STRATEGY(TYPE="standard",SHARDING_COLUMN=user_id,SHARDING_ALGORITHM(TYPE(NAME="inline",PROPERTIES("algorithm-expression"="ds_${user_id % 2}")))),
  TABLE_STRATEGY(TYPE="complex",SHARDING_COLUMNS=user_id,order_id,SHARDING_ALGORITHM(TYPE(NAME="T_ORDER_ITEM_COMPLEX"))),
  KEY_GENERATE_STRATEGY(COLUMN=item_id,TYPE(NAME="SNOWFLAKE"))
);
1
2
3
DROP SHARDING TABLE RULE t_order;
# 删除多个表
DROP SHARDING TABLE RULE t_order,t_order_item;

数据加密规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
rules:
  - !ENCRYPT    # 数据加密配置
    tables:
      t_user:  # 加密表名称
        columns:
          password: # 加密列名称
            cipher:
              name: password # 密文列名称
              encryptorName: aes_encryptor # 密文列加密算法名称
    # 加密算法配置: https://shardingsphere.apache.org/document/current/cn/user-manual/common-config/builtin-algorithm/encrypt/
    encryptors:
      aes_encryptor: # 加解密算法名称
        type: AES # 加解密算法类型
        props: # 加解密算法属性配置
          aes-key-value: 123456abc     # AES 使用的 KEY
          digest-algorithm-name: SHA-1 # AES KEY 的摘要算法
DistSQL 语法
1
2
3
4
CREATE ENCRYPT RULE t_user (
COLUMNS(
  (NAME=password,CIPHER=password,ENCRYPT_ALGORITHM(TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc', 'digest-algorithm-name'='SHA-1'))))
));

  • 修改加密规则

1
2
3
4
ALTER ENCRYPT RULE t_user (
COLUMNS(
  (NAME=password,CIPHER=password,ENCRYPT_ALGORITHM(TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc', 'digest-algorithm-name'='SHA-1'))))
));

  • 删除加密规则

1
DROP ENCRYPT RULE t_user;
1
2
3
4
5
6
# 查询当前逻辑库中所有加密规则
SHOW ENCRYPT RULES \G;
# 获取指定逻辑库中的加密规则
SHOW ENCRYPT RULES FROM sharding_db \G;
# 获取指定逻辑表中的加密规则
SHOW ENCRYPT RULE t_user \G;

数据脱敏规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
rules:
  - !MASK  # 数据脱敏配置
    tables:
      t_user:  # 脱敏表名称
        columns:  # 脱敏列配置
          password: # 脱敏列名称
            maskAlgorithm: md5_mask # 脱敏算法名称
          email:
            maskAlgorithm: mask_before_special_chars_mask
          telephone:
            maskAlgorithm: keep_first_n_last_m_mask
          name:
            maskAlgorithm: my_mask

    maskAlgorithms: # 脱敏算法配置
      md5_mask: # 自定义脱敏算法名称
        type: MD5  # 脱敏算法类型，md5加密后展示
      mask_before_special_chars_mask:
        type: MASK_BEFORE_SPECIAL_CHARS # 在特殊字符（比如邮箱里的 @）前面做脱敏，示例：myemail@example.com → *******@example.com
        props:
          special-chars: '@'  # 遇到 @ 之前的部分做脱敏
          replace-char: '*'   # 脱敏字符用 * 代替
      keep_first_n_last_m_mask:
        type: KEEP_FIRST_N_LAST_M # 保留前 n 位和后 m 位，其余用替换字符填充，示例：13812345678 → 138****5678
        props:
          first-n: 3     # 保留前 3 位
          last-m: 4      # 保留后 4 位
          replace-char: '*' # 脱敏字符用 * 代替
      my_mask:
        type: MY_CUSTOM_MASK  # 自定义脱敏算法名称
        props:
          replace-char: "#"
DistSQL 语法
1
2
3
4
5
6
7
8
9
CREATE MASK RULE t_user (
  COLUMNS(
    (NAME=password, TYPE(NAME='MD5')),
    (NAME=email, TYPE(NAME='MASK_BEFORE_SPECIAL_CHARS', PROPERTIES("special-chars"="@",  "replace-char"="*"))),
    (NAME=telephone, TYPE(NAME='KEEP_FIRST_N_LAST_M', PROPERTIES("first-n"=3, "last-m"=4, "replace-char"="*"))),
    (NAME=`name`, TYPE(NAME='MY_CUSTOM_MASK', PROPERTIES("replace-char"="#")))
  )
);
# 这里注意 name 是关键字，所以需要用 `` 包起来

  • 修改脱敏规则

1
2
3
4
5
6
7
8
ALTER MASK RULE t_user (
  COLUMNS(
    (NAME=password, TYPE(NAME='MD5')),
    (NAME=email, TYPE(NAME='MASK_BEFORE_SPECIAL_CHARS', PROPERTIES("special-chars"="@",  "replace-char"="*"))),
    (NAME=telephone, TYPE(NAME='KEEP_FIRST_N_LAST_M', PROPERTIES("first-n"=3, "last-m"=4, "replace-char"="*"))),
    (NAME=`name`, TYPE(NAME='MY_CUSTOM_MASK', PROPERTIES("replace-char"="#")))
  )
);

  • 删除脱敏规则

1
DROP MASK RULE t_user;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 查询当前逻辑库中所有脱敏规则
SHOW MASK RULES;
# 仅查询指定逻辑库中的脱敏规则
SHOW MASK RULES FROM sharding_db;
# 查询指定规则
mysql> SHOW MASK RULE t_user;
+--------+-----------+---------------------------+-------------------------------------------------+
| table  | column    | algorithm_type            | algorithm_props                                 |
+--------+-----------+---------------------------+-------------------------------------------------+
| t_user | password  | MD5                       |                                                 |
| t_user | email     | MASK_BEFORE_SPECIAL_CHARS | {"replace-char":"*","special-chars":"@"}        |
| t_user | telephone | KEEP_FIRST_N_LAST_M       | {"first-n":"3","last-m":"4","replace-char":"*"} |
| t_user | name      | MY_CUSTOM_MASK            | {"replace-char":"#"}                            |
+--------+-----------+---------------------------+-------------------------------------------------+