How To Build A Dynamic Distributed Database With DistSQL

In this article, I demonstrate a data sharding scenario in which DistSQL’s flexibility allows you to create a distributed database. At the same time, I show some syntax sugar to simplify operating procedures, allowing your potential users to choose their preferred syntax.

A series of DistSQL statements are run through practical cases to give you a complete set of practical DistSQL sharding management methods, which create and maintain distributed databases through dynamic management.

(Jiang Longtao, CC BY-SA 4.0)

What is sharding?

In database terminology, sharding is the process of partitioning a table into separate entities. While the table data is directly related, it often exists on different physical database nodes or, at the very least, within separate logical partitions.

Practical case example

To follow along with this example, you must have these components in place, either in your lab or in your mind as you read this article:

• Two sharding tables: t_order and t_order_item.
• For both tables, database shards are carried out with the user_id field, and table shards with the order_id field.
• The number of shards is two databases times three tables.

(Jiang Longtao, CC BY-SA 4.0)

Set up the environment

1. Prepare a database (MySQL, MariaDB, PostgreSQL, or openGauss) instance for access. Create two new databases: demo_ds_0 and demo_ds_1.

2. Deploy Apache ShardingSphere-Proxy 5.1.2 and Apache ZooKeeper. ZooKeeper acts as a governance center and stores ShardingSphere metadata information.

3. Configure server.yaml in the Proxy conf directory as follows:

4. Start ShardingSphere-Proxy and connect it to Proxy using a client, for example:

<span class="co4">$ </span>mysql <span class="re5">-h</span> 127.0.0.1 <span class="re5">-P</span> <span class="nu0">3307</span> <span class="re5">-u</span> root <span class="re5">-p</span>

5. Create a distributed database:

CREATE DATABASE sharding_db;USE sharding_db;

Add storage resources

Next, add storage resources corresponding to the database:

View the storage resources:

Adding the optional \G switch to the query statement makes the output format easy to read.

Create sharding rules

ShardingSphere’s sharding rules support regular sharding and automatic sharding. Both sharding methods have the same effect. The difference is that the configuration of automatic sharding is more concise, while regular sharding is more flexible and independent.

Refer to the following links for more details on automatic sharding:

• Intro to DistSQL-An Open Source and More Powerful SQL
• AutoTable: Your Butler-Like Sharding Configuration Tool

Next, it’s time to adopt regular sharding and use the INLINE expression algorithm to implement the sharding scenarios described in the requirements.

Primary key generator

The primary key generator creates a secure and unique primary key for a data table in a distributed scenario. For details, refer to the document Distributed Primary Key.

1. Create a primary key generator:

2. Query the primary key generator:

Sharding algorithm

1. Create a database sharding algorithm used by t_order and t_order_item in common:

2. Create different table shards algorithms for t_order and t_order_item:

3. Query the sharding algorithm:

Create a default sharding strategy

The sharding strategy consists of a sharding key and sharding algorithm, which in this case is databaseStrategy and tableStrategy. Because t_order and t_order_item have the same database sharding field and sharding algorithm, create a default strategy to be used by all shard tables with no sharding strategy configured.

1. Create a default database sharding strategy:

2. Query default strategy:

You have not configured the default table sharding strategy, so the default strategy of TABLE is NONE.

Set sharding rules

The primary key generator and sharding algorithm are both ready. Now you can create sharding rules. The method I demonstrate below is a little complicated and involves multiple steps. In the next section, I’ll show you how to create sharding rules in just one step, but for now, witness how it’s typically done.

First, define t_order:

Here is an explanation of the values found above:

• DATANODES specifies the data nodes of shard tables.
• TABLE_STRATEGY specifies the table strategy, among which SHARDING_ALGORITHM uses created sharding algorithm t_order_inline.
• KEY_GENERATE_STRATEGY specifies the primary key generation strategy of the table. Skip this configuration if primary key generation is not required.

Next, define t_order_item:

Query the sharding rules to verify what you’ve created:

This looks right so far. You have now configured the sharding rules for t_order and t_order_item.

You can skip the steps for creating the primary key generator, sharding algorithm, and default strategy, and complete the sharding rules in one step. Here’s how to make it easier.

Sharding rule syntax

For instance, if you want to add a shard table called t_order_detail, you can create sharding rules as follows:

This statement specifies a database sharding strategy, table strategy, and primary key generation strategy, but it doesn’t use existing algorithms. The DistSQL engine automatically uses the input expression to create an algorithm for the sharding rules of t_order_detail.

Now there’s a primary key generator:

Display the sharding algorithm:

And finally, the sharding rules:

In the CREATE SHARDING TABLE RULE statement, DATABASE_STRATEGY, TABLE_STRATEGY, and KEY_GENERATE_STRATEGY can reuse existing algorithms.

Alternatively, they can be defined quickly through syntax. The difference is that additional algorithm objects are created.

Configuration and verification

Once you have created the configuration verification rules, you can verify them in the following ways.

1. Check node distribution:

DistSQL provides SHOW SHARDING TABLE NODES for checking node distribution, and users can quickly learn the distribution of shard tables:

You can see that the node distribution of the shard table is consistent with what is described in the requirement.

SQL preview

Previewing SQL is also an easy way to verify configurations. Its syntax is PREVIEW SQL. First, make a query with no shard key, with all routes:

Now specify user_id in a query with a single database route:

Specify user_id and order_id with a single table route:

Single-table routes scan the fewest shard tables and offer the highest efficiency.

Query unused resources

During system maintenance, algorithms or storage resources that are no longer in use may need to be released, or resources that need to be released may have been referenced and cannot be deleted. DistSQL’s SHOW UNUSED RESOURCES command can solve these problems:

Query unused primary key generator

DistSQL can also display unused sharding key generators with the SHOW UNUSED SHARDING KEY GENERATORS:

Query unused sharding algorithm

DistSQL can reveal unused sharding algorithms with (you guessed it) the SHOW UNUSED SHARDING ALGORITHMS command:

Query rules that use the target storage resources

You can also see used resources within rules with SHOW RULES USED RESOURCE. All rules that use a resource can be queried, not limited to the sharding rule.

Query sharding rules that use the target primary key generator

You can find sharding rules using a key generator with SHOW SHARDING TABLE RULES USED KEY GENERATOR:

Query sharding rules that use the target algorithm

Show sharding rules using a target algorithm with SHOW SHARDING TABLE RULES USED ALGORITHM:

Make sharding better

DistSQL provides a flexible syntax to help simplify operations. In addition to the INLINE algorithm, DistSQL supports standard sharding, compound sharding, HINT sharding, and custom sharding algorithms.

If you have any questions or suggestions about Apache ShardingSphere, please feel free to post them on ShardingSphereGitHub.