You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by wu...@apache.org on 2022/08/02 10:06:04 UTC
[shardingsphere] branch master updated: feat(blog): add new blogs (#19791)
This is an automated email from the ASF dual-hosted git repository.
wuweijie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new e327fae6bde feat(blog): add new blogs (#19791)
e327fae6bde is described below
commit e327fae6bdef975903a3186c105805c1392749f1
Author: Yumeiya <10...@users.noreply.github.com>
AuthorDate: Tue Aug 2 18:05:58 2022 +0800
feat(blog): add new blogs (#19791)
* add blogs
* add weight
* change weight
* modify code format
* Add syntax to code blocks
Co-authored-by: 吴伟杰 <wu...@apache.org>
---
...d_by_ICDE_A_Top-Level_Database_Conference.en.md | 59 ++++
..._2022_Understanding_Apache_ShardingSphere.en.md | 247 +++++++++++++
...cal_Guide_to_Apache_ShardingSphere's_HINT.en.md | 392 +++++++++++++++++++++
..._Apache_ShardingSphere_5.1.1_Is_Available.en.md | 131 +++++++
...e_Performance_Record_with_10_Million_tpmC.en.md | 94 +++++
...oduction_Scenarios_Your_Quick_Start_Guide.en.md | 388 ++++++++++++++++++++
..._System_with_100s_of_Millions_of_Records.en.md" | 115 ++++++
...ed_by_ICDE_A_Top-Level_Database_Conference1.png | Bin 0 -> 105432 bytes
...ed_by_ICDE_A_Top-Level_Database_Conference2.png | Bin 0 -> 127900 bytes
...ed_by_ICDE_A_Top-Level_Database_Conference3.png | Bin 0 -> 81153 bytes
...E_2022_Understanding_Apache_ShardingSphere1.png | Bin 0 -> 513954 bytes
..._2022_Understanding_Apache_ShardingSphere10.png | Bin 0 -> 95825 bytes
..._2022_Understanding_Apache_ShardingSphere11.png | Bin 0 -> 33153 bytes
..._2022_Understanding_Apache_ShardingSphere12.png | Bin 0 -> 7687 bytes
..._2022_Understanding_Apache_ShardingSphere13.png | Bin 0 -> 9880 bytes
..._2022_Understanding_Apache_ShardingSphere14.png | Bin 0 -> 54779 bytes
..._2022_Understanding_Apache_ShardingSphere15.png | Bin 0 -> 81352 bytes
..._2022_Understanding_Apache_ShardingSphere16.png | Bin 0 -> 74067 bytes
..._2022_Understanding_Apache_ShardingSphere17.png | Bin 0 -> 57956 bytes
..._2022_Understanding_Apache_ShardingSphere18.png | Bin 0 -> 71415 bytes
..._2022_Understanding_Apache_ShardingSphere19.png | Bin 0 -> 65361 bytes
...E_2022_Understanding_Apache_ShardingSphere2.png | Bin 0 -> 311745 bytes
..._2022_Understanding_Apache_ShardingSphere20.png | Bin 0 -> 47792 bytes
..._2022_Understanding_Apache_ShardingSphere21.png | Bin 0 -> 74392 bytes
..._2022_Understanding_Apache_ShardingSphere22.png | Bin 0 -> 61582 bytes
...E_2022_Understanding_Apache_ShardingSphere3.png | Bin 0 -> 74370 bytes
...E_2022_Understanding_Apache_ShardingSphere4.png | Bin 0 -> 100774 bytes
...E_2022_Understanding_Apache_ShardingSphere5.png | Bin 0 -> 64847 bytes
...E_2022_Understanding_Apache_ShardingSphere6.png | Bin 0 -> 53387 bytes
...E_2022_Understanding_Apache_ShardingSphere7.png | Bin 0 -> 20362 bytes
...E_2022_Understanding_Apache_ShardingSphere8.png | Bin 0 -> 15714 bytes
...E_2022_Understanding_Apache_ShardingSphere9.png | Bin 0 -> 36324 bytes
...ical_Guide_to_Apache_ShardingSphere's_HINT1.png | Bin 0 -> 230381 bytes
...ical_Guide_to_Apache_ShardingSphere's_HINT2.jpg | Bin 0 -> 130607 bytes
..._Apache_ShardingSphere_5.1.1_Is_Available1.jpeg | Bin 0 -> 94338 bytes
..._Apache_ShardingSphere_5.1.1_Is_Available2.jpeg | Bin 0 -> 177997 bytes
...8_Apache_ShardingSphere_5.1.1_Is_Available3.png | Bin 0 -> 673376 bytes
...se_Performance_Record_with_10_Million_tpmC1.png | Bin 0 -> 33328 bytes
...se_Performance_Record_with_10_Million_tpmC2.png | Bin 0 -> 131067 bytes
...se_Performance_Record_with_10_Million_tpmC3.png | Bin 0 -> 61465 bytes
...roduction_Scenarios_Your_Quick_Start_Guide1.png | Bin 0 -> 36221 bytes
...roduction_Scenarios_Your_Quick_Start_Guide2.jpg | Bin 0 -> 23254 bytes
...roduction_Scenarios_Your_Quick_Start_Guide3.jpg | Bin 0 -> 25321 bytes
...roduction_Scenarios_Your_Quick_Start_Guide4.png | Bin 0 -> 7117 bytes
...roduction_Scenarios_Your_Quick_Start_Guide5.jpg | Bin 0 -> 36943 bytes
...roduction_Scenarios_Your_Quick_Start_Guide6.jpg | Bin 0 -> 21202 bytes
...n_System_with_100s_of_Millions_of_Records1.png" | Bin 0 -> 56426 bytes
...n_System_with_100s_of_Millions_of_Records2.png" | Bin 0 -> 178336 bytes
...n_System_with_100s_of_Millions_of_Records3.png" | Bin 0 -> 121743 bytes
...n_System_with_100s_of_Millions_of_Records4.png" | Bin 0 -> 78800 bytes
...n_System_with_100s_of_Millions_of_Records5.png" | Bin 0 -> 403492 bytes
...n_System_with_100s_of_Millions_of_Records6.png" | Bin 0 -> 74418 bytes
...n_System_with_100s_of_Millions_of_Records7.png" | Bin 0 -> 355844 bytes
...n_System_with_100s_of_Millions_of_Records8.png" | Bin 0 -> 131075 bytes
54 files changed, 1426 insertions(+)
diff --git a/docs/blog/content/material/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference.en.md b/docs/blog/content/material/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference.en.md
new file mode 100644
index 00000000000..f1554b1e1e5
--- /dev/null
+++ b/docs/blog/content/material/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference.en.md
@@ -0,0 +1,59 @@
++++
+title = "1st Academic Paper by Apache ShardingSphere Accepted by ICDE, A Top-Level Database Conference"
+weight = 47
+chapter = true
++++
+
+
+
+## ICDE Accepted Apache ShardingSphere’s First Academic Paper
+
+Recently, “Apache ShardingSphere: A Holistic and Pluggable Platform for Data Sharding”, co-authored by the Apache ShardingSphere community, SphereEx Lab and the Department of Computer Science of Chongqing University, has been accepted by [The International Conference on Data Engineering (ICDE)](https://icde2022.ieeecomputer.my/), one of the top international conferences on data engineering and databases. This conference paper is the first one focusing on data sharding in the database industry.
+
+ICDE is a top-level academic conference on databases and data mining, as well as the flagship conference of the [Institute of Electrical and Electronics Engineers (IEEE)](https://www.ieee.org/), the world’s largest technical professional organization for the advancement of technology. ICDE, ACM SIGMOD Conference and International Conference on Very Large Data Bases are known as the top three data management and database conferences in the world.
+
+This paper’s publication represents the culmination of 5-year of R&D and implementation testing for Apache ShardingSphere guided by its Database Plus development concept. The acceptance of this paper stands as a testament of the acknowledgment of Database Plus, Apache ShardingSphere’s enhanced computing engine and plugin-oriented architecture by the academic community.
+
+Thanks to the acceptance of this paper, our community is proud to announce that our efforts have led to innovative breakthroughs in core database technologies.
+
+In this paper, the co-authors propose that: considering that today relational databases that are not scalable and efficient enough to solve high concurrency problems still dominate online transaction processing and that NewSQL databases could lead to additional training costs, the database middleware Apache ShardingSphere becomes a very friendly and efficient way to connect and manage multiple databases.
+
+## Apache ShardingSphere: A Scientific Development Path
+
+> Why Did We Choose to Improve the Database Ecosystem Rather Than Creating a New Database?
+
+The aim of Apache ShardingSphere is to better utilize the computing and storage capabilities of relational databases in distributed scenarios, rather than implementing a new type of relational database.
+
+So far, as relational databases are still the best choice for complete transactions, they are often used to handle online transaction processing. However, the relational database is designed for a single machine. In other words, at the initial stage developers did not take big data into account. In short, relational databases are less scalable to efficiently solve high concurrency problems.
+
+In this context, NewSQL came into being. However, New means this type of database is developed from scratch. Although it is suitable for current application scenarios, it has not been tested in enough real production environments, and for enterprise maintainers, it has a steep learning curve.
+
+Apache ShardingSphere just released its official version 5.1.0. With this update, Apache ShardingSphere has also shifted its positioning to Database Plus with the desire to build the standard and ecosystem above different databases. Apart from enhanced capabilities, the Database Plus architecture also opens up a highly scalable database ecosystem for developers and users.
+
+> Apache ShardingSphere’s Multiple Features
+
+- Pluggable
+Apache ShardingSphere adopts a “microkernel + three-layer plugin oriented” model — making the kernel, functional components and the whole ecosystem pluggable and scalable. Developers can leverage our plugins to configure all or some of ShardingSphere’s features according to their needs. Under the Apache ShardingSphere architecture, all features can be assembled into the ShardingSphere system just like building blocks. You can either use them separately or combine them together as needed.
+
+However, in developers’ standard-oriented SPI programming, the kernel is not affected by the incremental functions, therefore multiple functional modules of ShardingSphere can be flexibly combined in real application scenarios, leaving discretion for our users.
+
+Addtionally, Apache ShardingSphere is designed on the basis of SPI (Service Provider Interface, a service discovery mechanism provided by Java JDK) among other design patterns. Therefore, various types of databases, functions, and sharding algorithms can be easily added, removed or combined as needed.
+
+Among them, as the primary development direction of ShardingSphere, data sharding has always been one of the most important features for us. For many users, data sharding was one of the reasons why they chose ShardingSphere. Generally speaking, performing data sharding on relational databases and removing the limitation of the storage capacity of a standalone machine by means of horizontal data sharding is an ideal solution for enterprises.
+
+- High Performance
+The paper mentioned that Chongqing University and SphereEx conducted multiple rounds of tests under Sysbench and TPCC testing scenarios, verifying that, using the same configuration, the performance of Apache ShardingSphere is superior to most sharding systems and new database architectures. Detailed records are shown in the following graphs:
+
+
+
+
+
+## NConclusion
+
+Apache ShardingSphere has been adopted and tested by hundreds of enterprises, from the Internet, gaming, banking, insurance & securities, manufacturing, telecommunications, new retail sectors to the public sector, etc., and has been tested in multiple production scenarios.
+
+With its first paper being included in ICDE, Apache ShardingSphere’s concept has now been recognized by the academic community. The paper will provide new solutions for the development of the database industry and the improvement of data processing efficiency.
+
+It also lays a solid theoretical foundation for the application of distributed capabilities in relational databases, the popularization of plugin architecture and the creation of an ecosystem layer above the fragmented database’s basic services.
+
+We hope this paper and Apache ShardingSphere’s exploration can inspire developers and scholars inthe database field to build databases into a data service platform that is closer to enterprise business scenarios.
\ No newline at end of file
diff --git a/docs/blog/content/material/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere.en.md b/docs/blog/content/material/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere.en.md
new file mode 100644
index 00000000000..e3ce7252577
--- /dev/null
+++ b/docs/blog/content/material/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere.en.md
@@ -0,0 +1,247 @@
++++
+title = "A Holistic Pluggable Platform for Data Sharding — ICDE 2022 & Understanding Apache ShardingSphere"
+weight = 48
+chapter = true
++++
+
+I bet you have at least once experienced accessibility issues on your preferred online shopping website. Yo may have not even thought much about it, or you may have attirbuted it to a slow internet connction, but the truth is that the increasing concurrent access that databases cannot deal with is one of the reasons.
+
+Then it begs the question: how can we effectively solve the current database challenges? Data sharding could be a solution.
+
+This article will introduce a paper titled “Apache ShardingSphere: A Holistic and Pluggable Platform for Data Sharding” which is co-authored by Chongqing University and SphereEx Lab and published by [International Conference on Data Engineering (ICDE)](https://icde2022.ieeecomputer.my/) 2022, one of the top-level database conferences in the world.
+
+
+## Background
+Data expansion and growing needs for data mean that databases are not only supposed to be able to manage large amounts of data, but to also support highly concurrent access.
+
+Therefore, it’s necessary to design a database that can meet these two requirements since it can enhance user experience and solve website accessibility problems.
+
+For now, relational databases are still the best choice for online transaction processing (OLTP). However, a relational database is designed for a single machine, which means its scalability could be poor when faced with large amountsof data, thus failing to resolve the problem of high concurrency cannot be quite resolved.
+
+Although NoSQL databases such as HBase can support high concurrent requests, they are not suitable for OLTP and they may even cause data inconsistency. That’s why NewSQL has drawn a lot of attention, although we should note that “New” means that the database is developed from zero. Though suitable for current application scenarios, this type of database are still relatively untested, and NewSQL users and maintainers still need to fully learn the new technologies.
+
+If you were to ask if it is feasible to insert a data sharding middleware between database and applications to connect and manage multiple existing databases, the answer is a resounding “yes”.
+
+As shown in Figure 1 below, the sharding middleware distributes user queries to multiple databases in different machines, executes the queries separately, merges the multiple results, and returns them to the application, which effectively removes the limitations of a single machine.
+
+For developers, the sharding middleware is transparent and easy to use — therefore making it very developer-friendly and efficient.
+
+
+
+Designing a good data sharding middleware can be rather challenging.
+
+**First**, the underlying databases used in different scenarios vary. These databases use different database protocols and SQL statements, making it difficult to support multiple databases under a unified framework. Additionally, there are many types of SQL statements (from simple queries to aggregations to Multi-Table JOINs, etc.), and route and merge strategies for different SQL statements also are also different.
+
+**Second**, it is difficult to coordinate transactions across multiple databases, and sometimes a single transaction type may not support all scenarios.
+
+**Third**, data sharding middleware could be inefficient since it takes some time to forward requests and merge results.
+
+**Fourth**, database administrators (DBA) have to configure sharding rules one by one, which is time-consuming.
+
+Apache ShardingSphere, as Apache’s first Top-Level open source database sharding project, can tackle all the above-mentioned challenges. The main goal of ShardingSphere is to reduce the impact of data sharding and allow coders to use data sharding databases as if they were using just one database. It provide the following features:
+
+**1.Versatile.** ShardingSphere supports a variety of mainstream relational databases (in fact, it supports any database that meets the SQL-92 standard). A complete SQL engine is designed and implemented in ShardingSphere, so any type of SQL can be routed accurately. Additionally, it provides three types of distributed transactions and a variety of features. As far as I know, ShardingSphere is the first system that includes data sharding, strongly consistent transactions, and flexible tr [...]
+
+**2.Efficient.**
+ In addition to the proxy mode, ShardingSphere also provides JDBC access, which can greatly improve efficiency in most scenarios. Besides, ShardingSphere creates two execution modes and an intelligent strategy for choosing the appropriate execution mode and result merging strategy, which can help manage resources while ensuring efficiency.
+
+**3.Pluggable and scalable.**
+ ShardingSphere is designed on the basis of SPIs (Service Provider Interface, a service discovery mechanism provided by Java JDK) among other design patterns. Therefore, multiple types of databases, functions, and sharding algorithms can be easily added. Furthermore, all existing functions can be removed or combined as needed.
+
+**4.User-friendly.**
+ShardingSphere supports almost all SQL statements while hiding the details of distributed transactions. Therefore, with the help of ShardingSphere, application developers can use distributed transactions and sharded database clusters in the same way as standalone databases. ShardingSphere also provides DistSQL and AutoTable strategies to help DBAs handily configure sharding strategies.
+Currently, more than 170 companies are using ShardingSphere. This article is based on ShardingSphere 5.0.0 released on November 10, 2021.
+
+## System Architecture and Data Flow
+As shown in Figure 2, ShardingSphere can be divided into five modules:
+
+1. **dData source:** It enables storage by integrating various databases and currently supports data sources such as MySQL, PostgreSQL, SQL Server, Oracle, MariaDB and openGuass.
+2. **Function:** It provides many out-of-the-box features that can be freely added, combined, or deleted as needed.
+3. **Governor** is mainly used for configuration management and health monitoring.
+4. **SQL engine.** With the complete data sharding SQL engine, all functions are pluggable, and any function can be implemented through a SQL statement.
+5. **Adaptors:** They target different scenarios.
+
+
+
+Figure 3 shows data flows of ShardingSphere. There are two types: the first one can enhance and extend JDBC, enabling ShardingSphere-JDBC to run in the same thread with a JAVA application.
+
+In terms of ShardingSphere-Proxy, the process between data source and application support applications written in any programming language. In addition, you can directly connect to ShardingSphere-Proxy through any terminal compatible with MySQL or PostgreSQL protocol (such as MySQL Command-Line client, MySQL Workbench, etc.), which is very friendly to DBAs. The governor, as a separate process, can monitor data sources and maintain the configurations of ShardingSphere-JDBC and ShardingSph [...]
+
+
+
+Next, let’s take a close look at the feature module, governor, SQL engine and adaptor.
+
+## Features
+### Data Sharding
+Data sharding is one of ShardingSphere’s most significant features. It can shard data and store it based on certain rules in multiple tables and data sources(data source here refers to the schema, the same below). ShardingSphere involves table sharding and data source sharding, and each sharding supports both vertical and horizontal shardings.
+
+Figure 4 shows the four types of sharding. Figure 4(a) shows the original database with its internal table structures and data. Figure 4(c) shows the vertical table sharding, horizontal table sharding, vertical data source sharding, and horizontal data source sharding. Figure 4(b) shows the table structure after sharding.
+
+Vertical sharding alters the table structure, and therefore the structure has to be frequently adjusted in actual application scenarios and can’t fully meet the fast-changing needs of the internet business. However, horizontal sharding can break the limits of a single machine’s storage capacity and support more flexible extensions.
+
+
+
+
+Combining Figure 1 and Figure 4, let’s explain some data sharding concepts: the `uid` in Figure 1 is used to determine the database sharding field, known as the sharding key. `uid%2` in Figure 1 is used to distribute data to different tables, which is the sharding algorithm. ShardingSphere has over ten built-in sharding algorithms, and also allows clients to customize algorithms through interfaces.
+
+ShardingSphere provides different types of tables for different data sharding demands. For example in Figure 4, `t_user` is a schema, while `t_user_h0` and `t_user_h1` are physical tables. The actual tables stored in the database are the physical tables, but the tables seen by application developers are un-sharded schemas. Data sharing operation is transparent to application developers.
+
+In Figure 4, if `t_user` and `t_order` share the same sharding algorithm, data source and sharding key, they are binding tables with each other, which is very helpful in related queries. In addition, we use data nodes to map schema to physical tables. It is the smallest unit of sharding, consisting of a data source name and an actual table name, such as `DSO.t_user_h1`.
+
+### Distributed Transaction
+ShardingSphere provides three types of distributed transactions for different application scenarios.
+
+**XA Transactions.** Native XA transactions include three roles: Application Program(AP), Resource Manager(RM), and Transaction Manager(TM). Developers will have to pay a high learning cost if they want to use XA transactions. ShardingSphere plays the role of AP and TM, so developers can use XA transactions just like standalone transactions.
+
+As shown in Figure 5, when an application sends a “commit” request to ShardingSphere, ShardingSphere logs it and starts the 2PC (two-phase commit) process — phase one: ShardingSphere will send prepare commands one by one to collect votes from all data sources.
+
+If a data source determines that it can commit its own transaction, it sends an “ok” to ShardingSphere; otherwise, it sends a “no” and rolls back what it has done.
+
+If all the data source feedback is OK, ShardingSphere will send a commit command to all data sources. If there is any No data source feedback, it will send a rollback command to roll back. The data source operates according to the commands.
+
+
+XA transactions ensure the ACID features (Atomicity, Consistency, Isolation, Durability) of the data, but they are not suitable for long-time transactions as they lock resources. ShardingSphere provides Local Transactions and BASE Transactions to solve this problem.
+
+**Local Transactions.** As in Figure 6, when ShardingSphere receives a `COMMIT` or `ROLLBACK` command from a user application, it transmits the command directly to all data sources. Even if some data sources fail to commit, ShardingSphere will ignore it, because there is no preparation phase for Local Transactions, which can increase efficiency.
+
+
+**BASE Transactions.** A BASE transaction allows data inconsistency for a short period of time. A BASE transaction has to meet three requirements: basically available, soft state and eventually consistent. Generally, BASE transactions can improve systems’ performance, because they do not require strong consistency and can reduce the contention for shared resources.
+
+
+
+SharingSphere integrates SEATA, as it provides an automatic transaction mode(AT) to automatically generate compensation operations. As shown in the grey box of Figure 7, SEATA has three roles: 1) The Transaction Coordinator(TC) maintains the state of global and branch transactions and drives global commits or rollbacks; 2)The Transaction Manager(TM) defines the scope of global transactions; 3)Resource Manager(RM) manages resources and drive branch transactions to commit or rollback.
+
+The user application only needs to interact with ShardingSphere with a standard database connection. The BASE transaction in ShardingSphere is a 2PC process where ShardingSphere plays the role of TM and RM in SEATA. the BASE transaction process is shown in Figure 8.
+
+
+In addition to data sharding and distributed transactions, ShardingSphere also provides many other helpful features, which include but are not limited to: read/write splitting, encryption, shadowing (i.e. creating a shadow database and routing the corresponding test SQL to it), scale-out, etc. All these features are transparent to application developers, as ShardingSphere can intelligently identify the necessary information from standard SQL statements. And we can add, remove or merge ot [...]
+
+## Governor
+### Configuration Management
+Configuration information is stored in Apache ZooKeeper, a mature and powerful distributed orchestration system that provides efficient memory management and distributed locking services. Developers are now used to operating data via SQL. Therefore, we initiated a new DistSQL (distributed SQL), which allows users to configure ShardingSphere in the same way as they use a database.
+
+DistSQL is divided into Resource & Rule Definition Language (RDL), Resource & Rule Query Language (RQL), and Resource & Rule Administrate Language (RAL):
+
+(1) RDL: To add, modify or delete resources and rules. For example:
+
+
+We proposed the AutoTable concept. We don’t need to set the sharding rules manually, but just tell ShardingSphere the data source for sharding and how many shards there should be. ShardingSphere will take care of the sharding details.
+
+(2) RQL: To query and display existing resources and rules. For example:
+
+
+(3) RAL: Responsible for additional administrator functions, such as switching transaction types and extensions. For example:
+
+
+It can be seen that DistSQL is very similar to SQL and is developer-friendly. More information can be found in our user manual.
+
+### Health Monitoring
+To ensure high availability, we can create multiple ShardingSphere-Proxy instances and use a load-balancer to ensure load balancing. The governor will initiate a thread to regularly check the status of each ShardingSphere-Proxy instance and the underlying database, and if changes are found, the governor will automatically change the configuration to ensure system’s proper function.
+
+## SQL Engine
+ShardingSphere designs and implements a complete SQL engine for data sharding and other features, which enables users to execute any Apache ShardingSphere function with a single SQL statement.
+
+First, a SQL statement is parsed into an abstract syntax tree by SQL Parser. Then SQL Router matches the logical SQL statement with the data node according to the parsing result.
+
+As mentioned above, what developers view are logical tables, rather than actual tables, so how can coders perform SQL operations in the actual data source? The answer is by utilizing SQL Rewriter that rewrites the SQL statement.
+
+There are two types: one is correctness-oriented rewrites that include the processes such as rewriting the logical identifiers to actual ones (e.g. rewrite `t_user` to `t_user_h0`), deriving columns needed for subsequent merges, modifying pagination from different data sources, splitting `Insert` statements with batches to ensure the correctness of SQL statement execution and avoids data duplication while the other one is referred as optimization-oriented rewrites that only rewrite the i [...]
+
+SQL Executor sends the rewritten SQL statement to the underlying data source and performs related operations. The details are explained below.
+
+Next, multiple results of different data sources obtained from SQL Executor are merged and returned to the client application.
+
+### SQL Executor
+This process also focuses on achieving a balance between data source connections, memory consumption, and maximum concurrency besides simply forwarding SQL statements to the underlying data sources.
+
+SQL Executor has two connection modes to automatically balance resource controlling and execution efficiency. In Memory Strictly Mode, memory usage is limited to ensure the number of connections for an operation. For this mode, we prefer to maintain an independent connection for each data node, execute SQL concurrently, load the results through data cursors and merge streams to avoid out of memory or frequent garbage collection. In Connection Strictly mode, connection consumption is stri [...]
+
+It is difficult for users to choose a suitable connection method and even within the same application, different queries may fit different modes. To make it convenient, we have designed an automatic execution engine which has two phases as shown in Figure 9 below:
+
+
+
+**Phase 1: Preparation**
+
+First, group the route and rewrite results according to data source.
+
+Then based on the condition of data source connections, we can choose a suitable connection mode. If the number of SQL statements routed to the data source is greater than the maximum connections used by the data source for querying, Connection Strictly Mode is chosen, otherwise, Memory Strictly Mode.
+
+Next, we get the required connections and create the execution unit. To avoid deadlocks, we need to add locks to the data source to automatically acquire all the connections needed for the query.
+
+**Phase 2: Execution**
+
+At this stage, the grouped execute units are sent together to the corresponding underlying data source. Data sources then execute SQL concurrently and send `Event` messages for distributed transactions or monitoring.
+
+### Result Merger
+Result Merger can merge multiple result sets from different data sources into one and returns the results to the user application.
+
+The above-mentioned merge methods stream merge and memory coalescing are designed for different statements.
+
+Stream is perfect for iterative statements and we only need to merge the results one by one according to the database cursor.
+
+In terms of `ORDER BY` statements, since the result set returned by each data source is ordered, we use stream merge and multiway merge algorithm to combine these result sets into one. If the statement contains both `GROUP BY` and `ORDER BY`, and their attributes are the same, Stream Merge is favorable, because the grouped data records are all located at the first position marked by the cursor. As shown in Figure 10, we scan the pointed data records (marked in orange) from left to right [...]
+
+
+
+In addition, we can use Stream and Memory Coalescing together for aggregate statements and paging.
+
+## Adapters and Application
+There are two types of ShardingSphere adapters, namely ShardingSphere-JDBC and ShardingSphere-Proxy.
+
+The former is an enhanced JDBC driver that integrates the entire SQL engine and other functions provided by ShardingSphere, making it applicable anywhere JDBC is used.
+
+The latter is a proxy server that forwards requests from the application to the data source. It provides a connection pool so different applications and different queries can share the same connection. ShardingSphere-Proxy can disguise itself as a MySQL or PostgreSQL database, making it transparent to application developers. In addition, it supports all programming languages.
+
+## Experiments
+**Datasets:**
+
+1) Sysbench: a well-known database benchmarking tool that provides a table that allows users to adjust data volume
+
+2) TPC-C, short for Transaction Processing Performance Council Benchmark C, is a benchmark used to compare the performance of online transaction processing (OLTP) systems. It simulates several transaction types frequently used by stores. The ten tables are organized by warehouse ( about 600,000 entries per warehouse).
+
+Comparative method: MySQL v5.7.26 (MS); PostgreSQL v10.17 (PG); Vitess v12.0.0; Citus v9.0.0; TiDB v5.2.0; CockroachDB v21.1.11 (CRDB); Aurora MySQL v2.07.2; Aurora PostgreSQL v4.2.
+
+We used a cluster with 12 virtual servers in HUAWEI Cloud, each of which was equipped with CentOS 7.1 64-bit, 32-VCORE CPU, 64 GB memory, and 1TB disk.
+
+**Comparative Experiment.** Results from Sysbench runs are compared. As shown in the table below, the ShardingSphere-based system always performed the best in all scenarios.
+
+
+In terms of TPC-C, we provided five scenarios, and the proportion of each is fixed. In the article we only state the overall performance. As shown in Figure 11, SSJ works best.
+
+
+
+Scalability Testing. Next, we only compare with TiDB, because it has the best performance compared to other systems. As shown in Figure 12, SSJ-based systems always perform best.
+
+
+
+In the test with different concurrency numbers, as shown in Figure 13, we find SSJ-based systems perform best in terms of TPS.
+
+
+
+When it comes to comparison with different data servers, as shown in Figure 14, TPS increases slightly at first, and then remains stable when the number of data servers exceeds 3. There may be two reasons: first, we only use one proxy server, which may become a bottleneck, and second, with the increasing number of data servers, networking may become another bottleneck.
+
+
+
+We also verified the validity of the binding table. In the figure below, Common shows the performance of table querying without binding. It can be clearly seen that its performance is far less efficient than the binding table.
+
+
+
+We also tested the effect of the maximum connections MaxCon on efficiency. The result is shown in Figure 16.
+
+
+## Conclusion
+With Extensive experiments completed by using two well-known benchmarking tools, we verify that under such settings, ShardingSphere outperforms other sharding systems and databases with new architectures in most cases.
+
+As more and more companies are adopting ShardingSphere, we will continue to follow the development guidance concept Database Plus and provide more products to build an plugin-oriented ecosystem with enhanced functions.
+
+## Author
+Zheng LI, Chongqing University Spatio-Temporal Lab (CUST)
+
+## Apache ShardingSphere Project Links:
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
\ No newline at end of file
diff --git a/docs/blog/content/material/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT.en.md b/docs/blog/content/material/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT.en.md
new file mode 100644
index 00000000000..1832b9c3b70
--- /dev/null
+++ b/docs/blog/content/material/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT.en.md
@@ -0,0 +1,392 @@
++++
+title = "A Practical Guide to Apache ShardingSphere’s HINT"
+weight = 49
+chapter = true
++++
+
+## Background
+[Apache ShardingSphere](https://shardingsphere.apache.org/) has gradually introduced various features based on practical user requirements, such as data sharding and read/write splitting.
+
+The data sharding feature contains many practical sharding strategies such as Standard Sharding Strategy and Complex Sharding Strategy, and users can easily configure the corresponding sharding algorithms.
+
+When it comes to Read/Write Splitting, Apache ShardingSphere provides users with two types called Static and Dynamic, and abundant load balancing algorithms.
+
+Sharding and Read/Write Splitting functions of ShardingSphere are already very useful, but scenarios are ever-changing.
+
+Take a multi-tenant case as an example: a user expects to shard data according to the tenant to which the login account belongs, but the tenant information does not exist in every business SQL. In this case, the algorithm for extracting sharding fields from SQL is not feasible.
+
+Additionally, in most read/write splitting scenarios, users want to route queries to the secondary database for execution, but in some scenarios with a requirement for real-time operations, users want to route SQL to the primary database for execution. Currently, read/write splitting cannot meet business requirements.
+
+Considering the above-mentioned pain points, Apache ShardingSphere created the `Hint` function to allow users to utilize different logic rather than SQL to implement forced routing or sharding.
+
+Currently, ShardingSphere provides users with two `Hint` methods. One is a manual programming method with Java API and uses `HintManager` for forced routing and sharding. This method is very friendly to applications programmed with JDBC because developers don’t need to write too much code and can easily implement SQL-independent sharding or forced routing functions.
+
+Based on distributed SQL ([DistSQL](https://opensource.com/article/21/9/distsql), ShardingSphere designed `SQL HINT` and `DistSQL HINT` to provide users with sharding and forced routing functions that can be implemented without coding. The method is more friendly to database administrators (DBAs).
+
+Next, let’s take a close look at the two methods.
+
+## Manual Programming Based on HintManager
+
+ShardingSphere can implement the functions of forced route and sharding via the `HintManager` objects. With `HintManager`, users can complete data sharding without SQL. It also allows users to shard data or force routing more flexibly, greatly expanding user scenarios.
+
+At the moment, with the help of `HintManager`, users can utilize ShardingSphere’s built-in or custom `Hint` algorithms to implement the sharding function, and can set specified data source or force primary database to do read/write splitting to implement the forced routing function.
+
+I’d like to explain its basic implementation principle first to help you gain a better understanding of `HintManager`.
+
+- **The Implementation of HintManager**
+The code snippet below can help you quickly understand the principle of `HintManager`.
+
+```java
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class HintManager implements AutoCloseable {
+
+ private static final ThreadLocal<HintManager> HINT_MANAGER_HOLDER = new ThreadLocal<>();
+}
+```
+
+As shown above, ShardingSphere implements the function of `HintManager` with `ThreadLocal`: as long as they are in the same thread, user’s sharding settings are preserved. Therefore, the user only needs to call relevant `HintManager` functions before executing SQL statements, and then ShardingSphere can obtain the sharding or mandatory routing conditions set by the user in the current thread so as to perform sharding or routing operations.
+
+Next, let’s learn how to use it.
+
+- **How to Use HitManager**
+
+1. Use `HINT` for Sharding
+To use the `Hint Sharding Algorithm`, users are required to implement the interface `org.apache.shardingsphere.sharding.api.sharding.hint.HintShardingAlgorithm`. When Apache ShardingSphere performs routing, it will obtain shard values from `HintManager` for routing operations.
+
+> **The configuration is as follows:**
+
+```yaml
+rules:
+- !SHARDING
+ tables:
+ t_order:
+ actualDataNodes: demo_ds_${0..1}.t_order_${0..1}
+ databaseStrategy:
+ hint:
+ algorithmClassName: xxx.xxx.xxx.HintXXXAlgorithm
+ tableStrategy:
+ hint:
+ algorithmClassName: xxx.xxx.xxx.HintXXXAlgorithm
+ defaultTableStrategy:
+ none:
+ defaultKeyGenerateStrategy:
+ type: SNOWFLAKE
+ column: order_id
+
+props:
+ sql-show: true
+```
+
+> **Get the HintManager instance:**
+
+```java
+HintManager hintManager = HintManager.getInstance();
+```
+
+> **Add shard key:**
+
+- Use `hintManager.addDatabaseShardingValue` to add data source shard key
+- `hintManager.addTableShardingValue` is used to add table shard key
+
+Note: In the case of database sharding without table sharding, when using HINT to force routing to a database shard, you can use `hintManager.setDatabaseShardingValue` to add `Shard`.
+
+> **Delete shard key:**
+
+`Shard Key` is stored in `ThreadLocal` so you need to call `hintManager.close()` at the end of the operation to clear the content in `ThreadLocal`
+
+> **The complete code snippet example is as follows:**
+
+```java
+String sql = "SELECT * FROM t_order";
+try (HintManager hintManager = HintManager.getInstance();
+ Connection conn = dataSource.getConnection();
+ PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+ hintManager.addDatabaseShardingValue("t_order", 1);
+ hintManager.addTableShardingValue("t_order", 2);
+ try (ResultSet rs = preparedStatement.executeQuery()) {
+ while (rs.next()) {
+ // ...
+ }
+ }
+}
+
+String sql = "SELECT * FROM t_order";
+try (HintManager hintManager = HintManager.getInstance();
+ Connection conn = dataSource.getConnection();
+ PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+ hintManager.setDatabaseShardingValue(3);
+ try (ResultSet rs = preparedStatement.executeQuery()) {
+ while (rs.next()) {
+ // ...
+ }
+ }
+}
+```
+
+2. Use `HINT` to `Force Primary Database Route`
+
+> Obtain HintManager
+
+It is the same as HINT-based Data Sharding described above.
+
+> Set Primary Database Route
+
+Use hintManager.setWriteRouteOnly to complete setting.
+
+> Clear Shard Key Value
+
+It is the same as HINT-based Data Sharding described above.
+
+> The complete code snippet example is as follows:
+
+```java
+String sql = "SELECT * FROM t_order";
+try (HintManager hintManager = HintManager.getInstance();
+ Connection conn = dataSource.getConnection();
+ PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+ hintManager.setWriteRouteOnly();
+ try (ResultSet rs = preparedStatement.executeQuery()) {
+ while (rs.next()) {
+ // ...
+ }
+ }
+}
+```
+
+3. Use `HINT` to Implement Route to Specified Database
+
+> Obtain HintManager
+
+It is the same as HINT-based Data Sharding described above.
+
+> Set Route to Specified Database
+
+Use `hintManager.setWriteRouteOnly` to set database name.
+
+> The complete code snippet example is as follows:
+
+```java
+String sql = "SELECT * FROM t_order";
+try (HintManager hintManager = HintManager.getInstance();
+ Connection conn = dataSource.getConnection();
+ PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+ hintManager.setDataSourceName("ds_0");
+ try (ResultSet rs = preparedStatement.executeQuery()) {
+ while (rs.next()) {
+ // ...
+ }
+ }
+}
+```
+
+> Delete Forced Route Value
+
+It is the same as HINT-based Data Sharding described above.
+
+After understanding the manual programming method based on `HintManager`, let’s take a look at another HINT solution provided by ShardingSphere based on distributed SQL.
+
+## DistSQL Based HINT
+DistSQL HINT provided by Apache ShardingSphere is composed of two functions: one is called `SQL HINT` that is based on SQL annotations, and the other is the function that acts on `HintManager` through DistSQL implementation.
+
+## SQL HINT
+
+`SQL HINT` is a HINT method to implement forced routing by adding annotations to SQL statements, reducing the cost of code modification for users. This means that it is not subjected to the limitations of Java API, and is available in both ShardingSphere-JDBC and ShardingSphere-Proxy.
+
+Take the following SQL statement as an example. Even if the user configures the relevant sharding algorithm for t_order, the SQL statement will be directly executed on the database ds_0 and the execution result will be returned.
+```sql
+/* ShardingSphere hint: dataSourceName=ds_0 */
+SELECT * FROM t_order;
+```
+
+By means of annotations, we can easily send the SQL statement directly to the specified database for execution with no need for considering other sharding logic.
+
+Taking the multi-tenant scenario as an example. Users do not need to configure complex database sharding logic or modify business logic any more, but only need to add the specified database to the annotation.
+
+Next, I’d like to explain the implementation principle of `SQL HINT`.
+
+- **The Implementation of SQL HINT**
+
+If you’ve heard of Apache ShardingSphere before, you must be familiar with its SQL Parser engine. The first step to implementing SQL HINT is to extract SQL annotations.
+
+With Access Channel in ANTLR4, SQL annotation can be sent to a specific hidden channel separately. ShardingSphere also uses this function to extract annotations in the hidden channel while generating the parsing result.
+
+The specific implementation is shown in the following code snippet:
+
+- Feed SQL comments into the hidden channel:
+```
+lexer grammar Comments;
+
+import Symbol;
+
+BLOCK_COMMENT: '/*' .*? '*/' -> channel(HIDDEN);
+INLINE_COMMENT: (('-- ' | '#') ~[\r\n]* ('\r'? '\n' | EOF) | '--' ('\r'? '\n' | EOF)) -> channel(HIDDEN);
+```
+
+- Access the syntax tree and add the extraction of the annotation
+
+```java
+public <T> T visit(final ParseContext parseContext) {
+ ParseTreeVisitor<T> visitor = SQLVisitorFactory.newInstance(databaseType, visitorType, SQLVisitorRule.valueOf(parseContext.getParseTree().getClass()), props);
+ T result = parseContext.getParseTree().accept(visitor);
+ appendSQLComments(parseContext, result);
+ return result;
+}
+
+private <T> void appendSQLComments(final ParseContext parseContext, final T visitResult) {
+ if (!parseContext.getHiddenTokens().isEmpty() && visitResult instanceof AbstractSQLStatement) {
+ Collection<CommentSegment> commentSegments = parseContext.getHiddenTokens().stream().map(each -> new CommentSegment(each.getText(), each.getStartIndex(), each.getStopIndex()))
+ .collect(Collectors.toList());
+ ((AbstractSQLStatement) visitResult).getCommentSegments().addAll(commentSegments);
+ }
+}
+```
+
+After extracting the SQL annotation information, we need to perform related mandatory routing based on the information. For routing, it is normal to use Apache ShardingSphere’s Router engine.
+
+We have made some modifications for HINT on the Router engine.
+
+```java
+public RouteContext route(final LogicSQL logicSQL, final ShardingSphereMetaData metaData) {
+ RouteContext result = new RouteContext();
+ Optional<String> dataSourceName = findDataSourceByHint(logicSQL.getSqlStatementContext(), metaData.getResource().getDataSources());
+ if (dataSourceName.isPresent()) {
+ result.getRouteUnits().add(new RouteUnit(new RouteMapper(dataSourceName.get(), dataSourceName.get()), Collections.emptyList()));
+ return result;
+ }
+ for (Entry<ShardingSphereRule, SQLRouter> entry : routers.entrySet()) {
+ if (result.getRouteUnits().isEmpty()) {
+ result = entry.getValue().createRouteContext(logicSQL, metaData, entry.getKey(), props);
+ } else {
+ entry.getValue().decorateRouteContext(result, logicSQL, metaData, entry.getKey(), props);
+ }
+ }
+ if (result.getRouteUnits().isEmpty() && 1 == metaData.getResource().getDataSources().size()) {
+ String singleDataSourceName = metaData.getResource().getDataSources().keySet().iterator().next();
+ result.getRouteUnits().add(new RouteUnit(new RouteMapper(singleDataSourceName, singleDataSourceName), Collections.emptyList()));
+ }
+ return result;
+}
+```
+
+
+ShardingSphere first finds SQL annotations that meet the definition, and after verification, it will directly return the routing result specified by the user, thus implementing the forced routing function.
+
+Next, I’d like to showcase how to use `SQL HINT`.
+
+- **How to Use SQL HINT**
+`SQL HINT` is easy to use with ShardingSphere-JDBC and ShardingSphere-Proxy.
+
+Step 1: Turn on the annotation parser and set `sqlCommentParseEnabled` to true.
+
+Step 2: Add SQL comments. Currently `SQL HINT` supports specifying data source routing and primary database routing.
+
+- Data source-specified Routing: currently only supports routing to one data source. The comment format only supports `/* */` for the time being and starts with `ShardingSphere hint`: with the attribute name `dataSourceName`.
+
+```sql
+/* ShardingSphere hint: dataSourceName=ds_0 */
+SELECT * FROM t_order;
+```
+
+- Primary Database Routing: The comment format only supports /* */ for the time being. The content needs to start `ShardingSphere hint`: and the attribute name is `writeRouteOnly`.
+
+```sql
+/* ShardingSphere hint: writeRouteOnly=true */
+SELECT * FROM t_order;
+```
+
+## DistSQL HINT
+DistSQL also provides HINT functions, enabling users to implement sharding and forced routing through ShardingSphere-Proxy.
+
+- **The Implementation Principle of DistSQL HINT**
+
+Let’s take a look at the implementation principle of DistSQL Hint first.
+
+The implementation principle of DistSQL HINT is very simple: it is the HINT function implemented by operating `HintManager`.
+
+Taking the read/write splitting HINT as an example. When a user executes the following SQL with ShardingSphere-Proxy, ShardingSphere actually performs the operations (as shown below) to the SQL statement:
+
+- Forced Primary Database Read-write
+
+```
+set readwrite_splitting hint source = write
+```
+
+```java
+@RequiredArgsConstructor
+public final class SetReadwriteSplittingHintExecutor extends AbstractHintUpdateExecutor<SetReadwriteSplittingHintStatement> {
+
+ private final SetReadwriteSplittingHintStatement sqlStatement;
+
+ @Override
+ public ResponseHeader execute() {
+ HintSourceType sourceType = HintSourceType.typeOf(sqlStatement.getSource());
+ switch (sourceType) {
+ case AUTO:
+ HintManagerHolder.get().setReadwriteSplittingAuto();
+ break;
+ case WRITE:
+ HintManagerHolder.get().setWriteRouteOnly();
+ break;
+ default:
+ break;
+ }
+ return new UpdateResponseHeader(new EmptyStatement());
+ }
+}
+```
+
+```java
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class HintManagerHolder {
+
+ private static final ThreadLocal<HintManager> HINT_MANAGER_HOLDER = new ThreadLocal<>();
+
+ /**
+ * Get an instance for {@code HintManager} from {@code ThreadLocal},if not exist,then create new one.
+ *
+ * @return hint manager
+ */
+ public static HintManager get() {
+ if (HINT_MANAGER_HOLDER.get() == null) {
+ HINT_MANAGER_HOLDER.set(HintManager.getInstance());
+ }
+ return HINT_MANAGER_HOLDER.get();
+ }
+
+ /**
+ * remove {@code HintManager} from {@code ThreadLocal}.
+ */
+ public static void remove() {
+ HINT_MANAGER_HOLDER.remove();
+ }
+}
+```
+
+After the user executes the SQL statement, the DistSQL parser engine will first identify that the SQL statement is with read/write splitting Hint, and will extract the fields that the user wants to automatically route or force to the write database.
+
+After that, it will use `SetReadwriteSplittingHintExecutor` to execute the SQL statement, so as to set the correct operation in HintManager, implementing the function of forced primary database routing.
+
+- **How to Use DistSQL HINT**
+-
+Below are the relevant statements of DistSQL HINT.
+
+
+This blog introduced the two methods and basic principles of HINT in detail. Once you develop a basic understanding of HINT, you’ll be able to better select the most appropriate method.
+
+## Apache ShardingSphere Project Links:
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
+
+## Author
+**Chuxin CHEN**
+
+SphereEx Middleware Engineer & Apache ShardingSphere Committer
+
+Currently, Chen mainly develops the kernel module of Apache ShardingSphere.
+
+
\ No newline at end of file
diff --git a/docs/blog/content/material/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available.en.md b/docs/blog/content/material/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available.en.md
new file mode 100644
index 00000000000..aa8e31b6afe
--- /dev/null
+++ b/docs/blog/content/material/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available.en.md
@@ -0,0 +1,131 @@
++++
+title = "Apache ShardingSphere 5.1.1 Is Available"
+weight = 50
+chapter = true
++++
+
+
+> In less than two months since the release of Apache ShardingSphere 5.1.0, our community has merged 698 PRs from teams or individuals around the world to bring you the new 5.1.1 release. This release has a number of optimizations in terms of features, performance, testing, documentation, examples and more.
+
+> The performance aspect deserves special mention, as we adopt the industry-standard TPC-C test model to run Apache ShardingSphere 5.1.1 and the openGauss 3.0 database on 16 physical servers, achieving over 10 million tpmC, the best performance in the industry at the same scale!
+
+> This article is an overview of the ShardingSphere 5.1.1 update.
+
+Apache ShardingSphere 5.1.1 update optimizes the functionality and performance of 5.1.0, and fixes some issues. The following will give you a general overview of some of the updates.
+
+## Kernel
+The kernel is ShardingSphere’s foundation, and it remains our goal to build a fully functional and stable kernel with high performance. In 5.1.1, ShardingSphere optimizes a lot of logic at the kernel level, fixing the problems found in different scenarios in the previous version, including data sharding, read/write splitting, data encryption, and improved the performance of each scenario to varying degrees.
+
+In terms of database dialects, the kernel improves the support for [MySQL](https://www.mysql.com/) tablespaces and improves SQL support for [Oracle](https://www.oracle.com/database/), [SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-downloads), [PostgreSQL](https://www.postgresql.org/), [openGauss](https://opengauss.org/en/), and other databases. Additionally, the initial support for PostgreSQL / openGauss schema, a three-tier structure, has been implemented in the Shar [...]
+
+## Interface
+This update fixes a potential performance risk for ShardingSphere-JDBC, optimizes the non-essential interaction logic between internal ShardingSphere-JDBC and the database connection pool, and reduces the performance overhead of ShardingSphere-JDBC.
+
+In terms of ShardingSphere-Proxy, support for MySQL / PostgreSQL data types has been improved. The occasional `ResultSet` closed error for ShardingSphere-Proxy MySQL has been fixed, and ShardingSphere-Proxy MySQL also has initial support for executing multiple statements at the protocol level to improve the performance of batch operations.
+
+In terms of client support, ShardingSphere-Proxy PostgreSQL improves the support for PostgreSQL JDBC Driver 42.3.x, and ShardingSphere-Proxy openGauss improves the support for openGauss JDBC Driver 3.0.
+
+## Elastic Scale-out
+In this update, in addition to fixing the problem that migration tasks cannot be restarted by DistSQL after reporting errors, the elastic scaling has been improved and new features of stop source writing, resume source writing, and partial tables scaling have been implemented. For cases that do not meet the migration conditions, elastic scale-out can fail quickly and find out the problem in time to avoid extra time costs for users.
+
+
+## DistSQL
+DistSQL has been optimized in terms of user experience, adding more calibration and reducing the possibility of user configuration errors in using DistSQL. We also fixed an issue where some user input conflicted with DistSQL keywords.
+
+## Distributed Governance
+In terms of read/write splitting and database discovery, in addition to the original MGR, MySQL adds a new database discovery method by querying primary-secondary delay, which can automatically switch read/write splitting data sources by getting the secondary delay, reducing the threshold for users to use dynamic read/write splitting.
+
+In cluster mode, the metadata storage structure has been optimized and reconstructed, and the problems caused by ZooKeeper session timeout and case mismatch on table names have been fixed.
+
+## Distributed Transactions
+In terms of transactions, ShardingSphere-JDBC adds support for Savepoint, and ShardingSphere-Proxy adds support for Savepoint in XA scenarios, in addition to the original support for `Savepoint` for `LOCAL` transactions.
+
+When Narayana is used as an XA implementation, ShardingSphere supports the configuration of Narayana to make the use of XA more conveniently.
+
+With PostgreSQL / openGauss, when an exception occurs in a transaction, ShardingSphere can properly abort the transaction and automatically roll back.
+
+The above is an introduction to some of the updates to Apache ShardingSphere 5.1.1, please refer to the update log for details. The ShardingSphere community will be releasing detailed explanations of some of these features, so stay tuned.
+
+ShardingSphere 5.1.1 has no changes at the API level but has made many improvements in functionality and performance — you’re welcome to try it out.
+
+## Update Log
+
+### New Features
+
+- Kernel: PostgreSQL supports `alter materialized` view
+- Kernel: PostgreSQL supports `declare `syntax
+- Kernel: PostgreSQL supports `discard` syntax
+- Kernel: PostgreSQL supports `$$` mark
+- Kernel: Support MySQL to create Tablespace Statements
+- Elastic Scale-out: Implement stop source writing and resume source writing
+- Elastic Scale-out: Support partial tables scaling
+- DistSQL: New syntax `SHOW UNUSED RESOURCES`
+- Distributed Governance: New persistent XA recovery Id in governance center
+- Distributed Governance: Database discovery adds a new feature of delaying master-slave delay
+- Distributed Transaction: ShardingSphere-Proxy supports savepoint
+- Distributed Transaction: PostgreSQL & openGauss transaction exceptions, automatic rollback
+- Distributed Transaction: Narayana XA transaction ease
+- Distributed Transaction: ShardingSphere-JDBC supports savepoint
+
+### Optimizations
+
+- Kernel: Refactor kernel functional code to improve performance
+- Interface: Reduce ShardingSphere-Proxy Docker image size
+- Interface: ShardingSphere-Proxy supports setting character encoding with syntaxes such as `set names`
+- Interface: ShardingSphere-Proxy MySQL Supports Bulk Statements
+- Interface: ShardingSphere-Proxy supports the openGauss JDBC Driver 3.0 client
+- Elastic Scale-out: Only one Proxy node in a ShardingSphere-Proxy cluster needs to do completion detection
+- Elastic Scale-out: Optimize the field types in the input and output configurations, changing them from int to Integer to make it easier to configure as null via DistSQL
+- Elastic Scale-out: Optimize MySQL calibration and SQL
+- Elastic Scale-out: Optimize progress deletion and progress checking
+- Elastic Scale-out: Optimize the problem that FinishedCheckJob cannot do a completion check under the error state
+- Elastic Scale-out: If there are tables that are not eligible for migration, report an error as soon as possible
+- Elastic Scale-out: Reuse ClusterPersistRepository when PipelineAPIFactory creates GovernanceRepositoryAPI
+- Elastic Scale-out: Upgrade jobId generation algorithm; jobId supports idempotency
+- DistSQL: `CREATE/ALTER ENCRYPT RULE` syntax supports configuring data types and lengths
+- DistSQL; Unify the display of `SHOW ALL VARIABLES` and `SHOW VARIABLE `syntax
+- DistSQL: `DROP BINDING TABLE RULES `syntax eliminates the effect of binding order on deletion results
+- DistSQL: `SHOW INSTANCE LIST` syntax adds the display of `mode_type` fields
+- DistSQL: `ENABLE/DISABLE INSTANCE `syntax adds calibration of patterns
+- DistSQL: Add calibration to see if a rule is in use when deleting a read/write splitting rule
+- DistSQL: Add calibration for resource renaming when creating read/write splitting rules
+- DistSQL: `SHOW READWRITE_SPLITTING READ RESOURCES` adds display of the delay time
+- DistSQL: `DROP RULE` syntax supports pre-judgement of `IF EXISTS`
+- DistSQL: Optimize `ADD/ALTER RESOURCE `connection failure messages
+- Distributed Governance: DistSQL Add schema version number to support bulk execution of DistSQL
+- Distributed Governance: Optimize persistent metadata in clustered mode
+- Distributed Governance: Database discovery creates `JOB` to add schemaName marker
+
+## Refactoring
+
+- Kernel: Refactor encryption and decryption test cases
+- Kernel: Refactor the metadata model to fit the PostgreSQL database and schema model
+- Elastic Scale-out: Pipeline module removes HikariCP dependencies
+- Distributed Governance: Reconfigure the storage node structure of the governance centre
+- Distributed Governance: Refactor the metadata structure of the governance centre
+- Distributed Governance: Adjust database discovery MGR module to MySQL module
+
+## Problem Fixes
+
+- Kernel: Fix the exception where a constant could not get a variable
+- Kernel: Fix `InsertValueContext.getValue` conversion exceptions
+- Kernel: Fix distinct aggregate function column exception
+
+
+
+
+## Apache ShardingSphere Open Source Project Links:
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+[ShardingSphere Slack](https://github.com/apache/shardingsphere/blob/master/RELEASE-NOTES.md)
+[ShardingSphere Medium ](https://medium.com/@shardingsphere)
+[ShardingSphere Release Note](https://github.com/apache/shardingsphere/blob/master/RELEASE-NOTES.md)
+
+## Author
+**Weijie WU**
+
+> SphereEx Infrastructure R&D Engineer, Apache ShardingSphere PMC
+> He focuses on the R&D of Apache ShardingSphere interface and ShardingSphere subproject ElasticJob.
+
diff --git a/docs/blog/content/material/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC.en.md b/docs/blog/content/material/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC.en.md
new file mode 100644
index 00000000000..bdb2d9c6c25
--- /dev/null
+++ b/docs/blog/content/material/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC.en.md
@@ -0,0 +1,94 @@
++++
+title = "Apache ShardingSphere & openGauss: Breaking the Distributed Database Performance Record with 10 Million tpmC"
+weight = 51
+chapter = true
++++
+
+Our open source community has cooperated Huawei’s openGauss to build a distributed solution with [Apache ShardingSphere](https://shardingsphere.apache.org/) and [openGauss](https://opengauss.org/en/).
+
+We tested performance together with openGauss on 16 servers for more than one hour. The results were great: our joint solution broke the performance bottleneck of a single machine with a benchmark result of 10 million transactions per minute (tpmC) on average.
+
+
+## Breaking the 10 Million tpmC Barrier
+In this test, the openGauss community ran this TPC-C testing on [BenchmarkSQL](https://www.postgresql.org/message-id/CAGBW59f9q2Y4v-B3D8gje3xUsWz2Z-WaK9wYx4%3DhCY1zN%3D7%2BBQ%40mail.gmail.com) 5.0, which is an open source implementation of the popular TPC/C OLTP database benchmark.
+
+In terms of stand-alone performance, openGauss with ShardingSphere broke the limit of multi-core CPU: two-way 128-Core Huawei Kunpeng reached 1.5 million tpmC, and the memory-optimized table (MOT) engine reached 3.5 million tpmC.
+
+These are great results, but we’re not done. We’ll never stop pushing the boundaries for better database performance — especially in today’s Big Data scenarios and their thirst for top notch database performance.
+
+
+
+In this case, the openGauss team used 7 machines to run BenchmarkSQL adapted to [ShardingSphere-JDBC](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-jdbc), connected 8 openGauss databases, and deployed [ShardingSphere-Proxy](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-jdbc) for data initialization, consistency verification, and other maintenance operations.
+
+Thanks to its database sharding capability, ShardingSphere enabled a total of 8,000 bins of data (over 800 GB) to be distributed across 8 openGauss nodes. Following over 1 hour of test, not only sharding was perfect but the average results also reached over 10 million tpmC, which is the best industry performance at this scale.
+
+
+## ShardingSphere & openGauss: Building an Ecosystem Cooperation
+
+The Apache ShardingSphere community has been working closely with the openGauss community since 2021.
+
+Faced with the diversification of business scenarios and data volume expansion, the traditional solution that centrally stores data to a single node has since become unable to meet needs in terms of performance, availability, and affordable operation cost.
+
+Database sharding can solve problems of performance, availability, as well as single-point backup and recovery of stand-alone databases — but it also makes distributed architecture more complex.
+
+As the proponent of the Database Plus concept, Apache ShardingSphere aims to build a criterion and ecosystem above heterogeneous databases and enhance the ecosystem with sharding, elastic scaling, encryption features & more. Placed above databases, ShardingSphere focuses on the collaborative way of databases to make reasonable and full use of database compute and storage capabilities.
+
+Currently Apache ShardingSphere has a microkernel plus plugin-oriented architecture model, and on this basis, it continues to improve the capabilities of its kernel and functions to provide increasingly flexible solutions.
+
+Thanks to the design concept of its pluggable architecture, ShardingSphere can support openGauss without additional changes and only needs to increase implementations of the corresponding openGauss database based on the SPI extension points provided by each ShardingSphere module .
+
+Our two communities have collaborated to create a distributed database solution suitable for highly-concurrent Online Transaction Processing (OLTP) scenarios by combining the powerful standalone performance of openGauss with the distributed capabilities provided by the Apache ShardingSphere ecosystem.
+
+
+## Building an openGauss-based Distributed Database Solution with ShardingSphere
+Apache ShardingSphere includes many features such as database sharding, read/write splitting, data encryption, and shadow database. The features can be used independently or in combination.
+
+
+
+Currently, ShardingSphere provides users with two access methods, namely ShardingSphere-JDBC and ShardingSphere-Proxy.
+
+ShardingSphere-JDBC can easily and transparently perform operations such as sharding and read/write splitting on databases while meeting high concurrency and low latency needs.
+
+ShardingSphere-Proxy is deployed to add some database capabilities and operations at the proxy level, enabling users to operate ShardingSphere as if it was a native database for a better user experience.
+
+ShardingSphere-JDBC and ShardingSphere-Proxy can be deployed together. We recommend using this mixed deployment in order to make the system user-friendly and perform better.
+
+
+
+
+From the perspective of the openGauss system, Apache ShardingSphere can shard the database horizontally to greatly enhance compute and storage capabilities, as well as database performance.
+
+This means it can effectively solve problems caused by increasing data volume in a single table and can be combined with business data flows to flexibly and smoothly scale out data nodes, intelligently split reads and writes, and implement automatic load balancing of distributed databases.
+
+
+## Conclusion
+Apache ShardingSphere and openGauss can seek potential cooperation opportunities.
+
+Considering the increasingly diversified applicaiton scenarios and increasing data volume, the requirements for database performance are at an all time high and will only continue to increase in the future.
+
+The success of our two communities cooperation is just the beginning of ourtwo communities building a collaborative database ecosystem.
+
+💡 About openGauss
+
+openGauss is an open source relational database management system. It has enterprise-grade features such as multi-core high performance, full-link security, and intelligent operation.
+
+It integrates Huawei’s years of kernel development experience in the database field and makes adaptations and optimizations on architecture, transaction, storage engine, optimizer, and ARM architecture.
+
+💡 About TPC-C
+
+Transaction Processing Performance Council Benchmark C or TPC-C is a benchmark used to compare the performance of online transaction processing (OLTP) systems. It was released by Transaction Processing Performance Council (TPC) in 1992. The latest update is TPC-C v5.11 published in 2010.
+
+TPC-C involves a mix of five concurrent transactions of different types and complexity either executed online or queued for deferred execution. The database is comprised of nine types of tables with a wide range of record and population sizes.
+
+TPC-C is measured in transactions per minute (tpmC). While the benchmark portrays the activity of a wholesale supplier, TPC-C is not limited to the activity of any particular business segment, but, rather represents any industry that must manage, sell, or distribute a product or service.
+
+
+Apache ShardingSphere Project Links:
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
\ No newline at end of file
diff --git a/docs/blog/content/material/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide.en.md b/docs/blog/content/material/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide.en.md
new file mode 100644
index 00000000000..0a31220a20e
--- /dev/null
+++ b/docs/blog/content/material/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide.en.md
@@ -0,0 +1,388 @@
++++
+title = "How to Use ShardingSphere-Proxy in Real Production Scenarios—Your Quick Start Guide"
+weight = 52
+chapter = true
++++
+
+This post analyzes ops & maintenance solutions with experiences taken from real production scenarios for data sharding and other functions provided by ShardingSphere-Proxy Version 5.1.0.
+
+> Unless otherwise specified, in the following examples, when we say “database” we refer to [MySQL](https://www.mysql.com/).
+
+## What does ShardingSphere-Proxy do?
+ShardingSphere-Proxy allows users to use Apache ShardingSphere just as if it were a native database.
+
+To gain a better understanding of what’s ShardingSphere-proxy, let’s take a look at its definition provided, by [Apache ShardingSphere’s official website](https://shardingsphere.apache.org/):
+
+> ShardingSphere-Proxy is a transparent database proxy that provide a database server containing database binary protocols designed to support heterogeneous languages.
+> Currently, it supports MySQL and [PostgreSQL](https://www.postgresql.org/) (and PostgreSQL-based databases, such as [openGauss](https://shardingsphere.medium.com/apache-shardingsphere-opengauss-breaking-the-distributed-database-performance-record-with-10-b8ced05daa37)) and any related terminals (such as MySQL Command Client, https://blog.devart.com/mysql-command-line-client.html Workbench, etc.) that are compatible with MySQL or PostgreSQL protocols to operate data. It’s a DBA-friendly tool.
+
+
+It’s worth noting that ShardingSphere-Proxy is a service process. In terms of client-side program connections, it is similar to a MySQL database.
+
+## Why you need ShardingSphere-Proxy
+ShardingSphere-Proxy is a good choice when:
+
+- sharding rules or other rules are used; because data will be distributed across multiple database instances, inevitably making management inconvenient.
+- non-Java developers need to leverage ShardingSphere capabilities.
+
+## 1. Application scenarios
+There are many scenarios where ShardingSphere-JDBC is used for data sharding. If you have a user table and need to perform horizontal scaling with Hash for the User ID property, the way the client connects to the database is like this:
+
+
+
+Below are three real production scenarios:
+
+1. A testing engineer wants to see the information of user ID 123456 in databases & tables, and you need to tell the engineer which subtable the user is in.
+2. You need to find out the total user growth in 2022 and overall user information for drafting a yearly report.
+3. Your company is going to hold its 8th-anniversary event and you are required to provide a list of active users who have been registered for over 8 years.
+Since the data is distributed across database shards and table shards, it is not easy to complete the above-mentioned tasks. If you develop code every time to satisfy these temporary requirements, it’ll be inefficient to say the least. ShardingSphere-Proxy is perfect for these scenarios.
+
+ShardingSphere-Proxy hides the actual backend databases, so the user operates the client side the same way as a database.
+
+For example, `t_user` is split into several real tables at the database level, that is from `t_user_0` to `t_user_9` . While operating ShardingSphere-Proxy on the client side, the user only needs to know one logical table `t_user`,and routing to the real tables is executed inside ShardingSphere-Proxy.
+
+**1. Logical table:** The logical name of the horizontally-scaled databases/tables with the same structure. A logical table is the logical identifier of tables in SQL. For example, user data is sharded into 10 tables according to the significant digits of the primary key, that is, `t_user_0` to `t_user_9` , and their common logical table is named `t_user`.
+
+**2. Actual table:** The physical table actually exists in databases after scale-out, that is, the above-mentioned `t_user_0` to `t_user_9` .
+
+
+
+## 2. The differences between ShardingSphere-JDBC and ShardingSphere-Proxy
+After reading the above description, you probably feel that ShardingSphere-Proxy and ShardingSphere-JDBC are so similar. So what are the differences between the two?
+
+
+
+Check out more on the differences between the two below:
+
+1. ShardingSphere-JDBC is a `.jar` package. Its bottom layer completes SQL parsing, routing, rewriting, execution, and other processes by rewriting JDBC components. You should add the configuration files to implement the corresponding functions in the project, making it intrusive to applications.
+
+2. ShardingSphere-Proxy is a process service. In most cases, it is positioned as a productivity tool to assist operations. It disguises itself as a database, making itself non-intrusive to applications. The SQL execution logic in ShardingSphere-Proxy is the same as in ShardingSphere-JDBC because they share the same kernel.
+
+**Since ShardingSphere-Proxy is non-intrusive to applications, and it shares the same kernel with ShardingSphere-JDBC — so why do we still need ShardingSphere-JDBC?**
+
+1. When an application directly operates databases through ShardingSphere-JDBC, there is only one network I/O. However, when the application connects to ShardingSphere-Proxy, one network I/O, and then ShardingSphere-Proxy operates databases, and another network I/O occurs, in total two network I/O requests.
+
+2. There is one more layer of application called link, which is more likely to cause a data traffic bottleneck and potential risks to the application. In general, it’s suggested that an application should be used together with ShardingSphere-JDBC.
+
+Of course, ShardingSphere-JDBC and ShardingSphere-Proxy can be deployed simultaneously with a hybrid architecture. ShardingSphere-JDBC is suitable for high-performance lightweight Online Transaction Processing (OLTP) applications developed in Java, while ShardingSphere-Proxy is perfect for Online Analytical Processing (OLAP) applications and scenarios for managing and operating sharding databases.
+
+
+
+
+## Quick Start Guide
+There are three setup methods to install ShardingSphere-Proxy: binary package, Docker, and Helm. Stand-alone deployment and clustered deployment are also provided. Here, we take the standalone binary package as an example:
+
+1. Get the ShardingSphere-Proxy binary installation package [at this link](https://shardingsphere.apache.org/document/current/en/downloads/);
+
+2. Decompress it and then modify `conf/server.yaml` and files starting with the `config-` prefix to configure sharding, read/write splitting and other functions;
+
+3. If you use Linux as operating system, please run `bin/start.sh.` For Windows operating systems, please run `bin/start.bat` to bootup ShardingSphere-Proxy.
+
+The file directory looks like this:
+
+```
+├── LICENSE
+├── NOTICE
+├── README.txt
+├── bin #Start/stop script
+├── conf #service configuration, data sharding, read/write splitting, data encryption, and other function configuration files
+├── lib # Jar package
+└── licenses
+```
+**1. Copy MySQL Java connector to the ext-lib package**
+Download the `driver mysql-connector-java-5.1.47.jar` ([Click the link to download](https://repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.47/mysql-connector-java-5.1.47.jar)) or `mysql-connector-java-8.0.11.jar` (https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.11/mysql-connector-java-8.0.11.jar) into the `ext-lib` package. Note：there is no `ext-lib` package in the initial directory, so you need to create one yourself.
+
+**2. Modify the `conf/server.yaml` configuration file**
+For `server.yaml` the default operation mode is `Cluster Mode`. Below is how to configure the standalone operation mode.
+
+```yaml
+mode:
+ type: Standalone #Standalone mode
+ repository:
+ type: File
+ props:
+ path: /Users/xxx/software/apache-shardingsphere-5.1.0-shardingsphere-proxy/file #persistent file paths such as metadata configuration
+ overwrite: false #Overwrite the existing metadata？
+
+rules: #Verification Info
+ - !AUTHORITY
+ users: #Init user
+ - root@%:root
+ - sharding@:sharding
+ provider:
+ type: ALL_PRIVILEGES_PERMITTED
+ - !TRANSACTION
+ defaultType: XA
+ providerType: Atomikos
+ - !SQL_PARSER
+ sqlCommentParseEnabled: true
+ sqlStatementCache:
+ initialCapacity: 2000
+ maximumSize: 65535
+ concurrencyLevel: 4
+ parseTreeCache:
+ initialCapacity: 128
+ maximumSize: 1024
+ concurrencyLevel: 4
+
+props: #public configuration
+ max-connections-size-per-query: 1
+ kernel-executor-size: 16 # Infinite by default.
+ proxy-frontend-flush-threshold: 128 # The default value is 128.
+ proxy-opentracing-enabled: false
+ proxy-hint-enabled: false
+ sql-show: false
+ check-table-metadata-enabled: false
+ show-process-list-enabled: false
+ # Proxy backend query fetch size. A larger value may increase the memory usage of ShardingSphere Proxy.
+ # The default value is -1, which means set the minimum value for different JDBC drivers.
+ proxy-backend-query-fetch-size: -1
+ check-duplicate-table-enabled: false
+ proxy-frontend-executor-size: 0 # Proxy frontend executor size. The default value is 0, which means let Netty decide.
+ # Available options of proxy backend executor suitable: OLAP(default), OLTP. The OLTP option may reduce time cost of writing packets to client, but it may increase the latency of SQL execution
+ # and block other clients if client connections are more than `proxy-frontend-executor-size`, especially executing slow SQL.
+ proxy-backend-executor-suitable: OLAP
+ proxy-frontend-max-connections: 0 # Less than or equal to 0 means no limitation.
+ sql-federation-enabled: false
+ # Available proxy backend driver type: JDBC (default), ExperimentalVertx
+ proxy-backend-driver-type: JDBC
+
+```
+
+> Note: if you start a standalone ShardingSphere-Proxy and later need to change Proxy configurations, you need to set `mode.overwrite` to `true`. By doing so, ShardingSphere-Proxy will reload the metadata after startup.
+
+**3. Start ShardingSphere-Proxy**
+Execute the bootup command: `sh bin/start.sh`. The default port `is 3307`, and the port can be replaced by adding parameters to the start script command: `sh bin/start.sh 3308` .
+
+To check whether ShardingSphere-Proxy started successfully, execute the check log command: `tail -100f logs/stdout.log` .
+
+The following information placed on the last line means that the startup is successful:
+
+```
+[INFO ] xxx-xx-xx xx:xx:xx.xxx [main] o.a.s.p.frontend.ShardingSphereProxy - ShardingSphere-Proxy Standalone mode started successfully
+```
+
+## Scenarios and applications
+Based on actual prouction scenarios, we’d like to show you how you can utilize ShardingSphere-Proxy to meet your expectations.
+
+
+
+**1. Initialize the database & table**
+
+```sql
+# CREATE DATABASE
+CREATE DATABASE user_sharding_0;
+
+CREATE DATABASE user_sharding_1;
+
+# CREATE TABLE
+use user_sharding_0;
+
+CREATE TABLE `t_user_0` (
+ `id` bigint (20) NOT NULL,
+ `user_id` bigint (20) NOT NULL,
+ `create_date` datetime DEFAULT NULL,
+ PRIMARY KEY (`id`)) ENGINE = InnoDB DEFAULT CHARSET = latin1;
+
+CREATE TABLE `t_user_1` (
+ `id` bigint (20) NOT NULL,
+ `user_id` bigint (20) NOT NULL,
+ `create_date` datetime DEFAULT NULL,
+ PRIMARY KEY (`id`)) ENGINE = InnoDB DEFAULT CHARSET = latin1;
+
+
+use user_sharding_1;
+
+CREATE TABLE `t_user_0` (
+ `id` bigint (20) NOT NULL,
+ `user_id` bigint (20) NOT NULL,
+ `create_date` datetime DEFAULT NULL,
+ PRIMARY KEY (`id`)) ENGINE = InnoDB DEFAULT CHARSET = latin1;
+
+
+CREATE TABLE `t_user_1` (
+ `id` bigint (20) NOT NULL,
+ `user_id` bigint (20) NOT NULL,
+ `create_date` datetime DEFAULT NULL,
+ PRIMARY KEY (`id`)) ENGINE = InnoDB DEFAULT CHARSET = latin1;
+```
+**2. Initialize sharding configuration in Proxy**
+
+```yaml
+schemaName: sharding_db
+
+dataSources:
+ ds_0:
+ url: jdbc:mysql://127.0.0.1:3306/user_sharding_0?serverTimezone=UTC&useSSL=false
+ username: root
+ password: root
+ connectionTimeoutMilliseconds: 30000
+ idleTimeoutMilliseconds: 60000
+ maxLifetimeMilliseconds: 1800000
+ maxPoolSize: 50
+ minPoolSize: 1
+ ds_1:
+ url: jdbc:mysql://127.0.0.1:3306/user_sharding_1?serverTimezone=UTC&useSSL=false
+ username: root
+ password: root
+ connectionTimeoutMilliseconds: 30000
+ idleTimeoutMilliseconds: 60000
+ maxLifetimeMilliseconds: 1800000
+ maxPoolSize: 50
+ minPoolSize: 1
+
+rules:
+- !SHARDING
+ tables:
+ t_user:
+ actualDataNodes: ds_${0..1}.t_user_${0..1}
+ tableStrategy:
+ standard:
+ shardingColumn: user_id
+ shardingAlgorithmName: t_user_inline
+ keyGenerateStrategy:
+ column: user_id
+ keyGeneratorName: snowflake
+ bindingTables:
+ - t_user
+ defaultDatabaseStrategy:
+ standard:
+ shardingColumn: user_id
+ shardingAlgorithmName: database_inline
+ defaultTableStrategy:
+ none:
+
+ shardingAlgorithms:
+ database_inline:
+ type: INLINE
+ props:
+ algorithm-expression: ds_${user_id % 2}
+ t_user_inline:
+ type: INLINE
+ props:
+ algorithm-expression: t_user_${user_id % 2}
+
+ keyGenerators:
+ snowflake:
+ type: SNOWFLAKE
+```
+**3. Test sharding configuration**
+
+Use the MySQL terminal command to connect to the ShardingSphere-Proxy server.
+
+If you deploy databases in Docker containers, you need to add `-h` native `ip`. Because accessing 127.0.0.1 in the container is blocked.
+
+```
+#replace {xx} with actual parameter
+mysql -h {ip} -u {username} -p{password} -P 3307
+#example command
+mysql -h 127.0.0.1 -u root -proot -P 3307
+```
+
+> ShardingSphere-Proxy supports [Navicat MySQL](https://www.navicat.com/en/products/navicat-for-mysql), [DataGrip](https://www.jetbrains.com/datagrip/), [WorkBench](https://www.mysql.com/products/workbench/), [TablePlus](https://tableplus.com/), and other database management connectors.
+
+After confirming the connection is successful, query the databases and make sure they are consistent with those in the configuration file.
+
+```
+mysql> show databases;
++-------------+
+| schema_name |
++-------------+
+| sharding_db |
++-------------+
+1 row in set (0.02 sec)
+```
+
+Execute the new `t_user` statement, insert 6 pieces of user data (3 pieces for 2021, and 3 pieces for 2022).
+
+```
+mysql> use sharding_db;
+mysql> INSERT INTO t_user (id, user_id, create_date) values(1, 1, '2021-01-01 00:00:00'), (2, 2, '2021-01-01 00:00:00'), (3, 3, '2021-01-01 00:00:00'), (4, 4, '2022-01-01 00:00:00'), (5, 5, '2022-02-01 00:00:00'), (6, 6, '2022-03-01 00:00:00');
+Query OK, 6 rows affected (0.16 sec)
+
+mysql> select * from t_user;
++----+---------+---------------------+
+| id | user_id | create_date |
++----+---------+---------------------+
+| 2 | 2 | 2021-01-01 00:00:00 |
+| 4 | 4 | 2022-01-01 00:00:00 |
+| 6 | 6 | 2022-03-01 00:00:00 |
+| 1 | 1 | 2021-01-01 00:00:00 |
+| 3 | 3 | 2021-01-01 00:00:00 |
+| 5 | 5 | 2022-02-01 00:00:00 |
++----+---------+---------------------+
+```
+
+At this time, the data is in the `user_sharding_0` and
+`user_sharding_1` databases respectively.
+
+## Scenario 1: How to locate data information?
+
+Since ShardingSphere-Proxy has logically aggregated the tables, you can query them directly.
+
+```
+mysql> select * from t_user where user_id = 1;
++----+---------+---------------------+
+| id | user_id | create_date |
++----+---------+---------------------+
+| 1 | 1 | 2021-01-01 00:00:00 |
++----+---------+---------------------+
+1 row in set (0.01 sec)
+```
+
+## Scenario 2: How to check user growth in 2022 and user information?
+
+```
+mysql> select count(*) from t_user where create_date > '2022-00-00 00:00:00';
++----------+
+| count(*) |
++----------+
+| 3 |
++----------+
+1 row in set (0.10 sec)
+
+mysql> select * from t_user where create_date > '2022-00-00 00:00:00';
++----+---------+---------------------+
+| id | user_id | create_date |
++----+---------+---------------------+
+| 4 | 4 | 2022-01-01 00:00:00 |
+| 6 | 6 | 2022-01-01 00:00:00 |
+| 5 | 5 | 2022-01-01 00:00:00 |
++----+---------+---------------------+
+3 rows in set (0.02 sec)
+```
+
+## Scenario 3: How to get a list of active users who have been registered for over 8 years?
+
+Refer to the above code and you will know how to cope with it.
+
+## Conclusion
+This post summarizes the basic concepts of ShardingSphere-Proxy based on the actual data sharding production scenarios, and demonstrates how ShardingSphere-Proxy faces these scenarios.
+
+After reading this article, you should be able to:
+
+Understand why ShardingSphere-Proxy is an excellent product to assist developers in DevOps.
+Know the differences between ShardingSphere-JDBC and ShardingSphere-Proxy, their advantages and disadvantages, and how they are implemented.
+Since you now have a better understanding of ShardingSphere-Proxy, we believe, it will be easier for you to study its source code. To know more about ShardingSphere, please visit [Apache ShardingSphere's official website](https://shardingsphere.apache.org/) or our community’s previous blogs such as Create a Distributed Database Solution Based on PostgreSQL/openGauss.
+
+**Apache ShardingSphere Project Links:**
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
+
+## References
+[1]Apache ShardingSphere Download Page:
+https://shardingsphere.apache.org/document/current/en/downloads/
+
+[2] mysql-connector-java-5.1.47.jar: https://repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.47/mysql-connector-java-5.1.47.jar
+
+[3] mysql-connector-java-8.0.11.jar: https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.11/mysql-connector-java-8.0.11.jar
+
+[4] Apache ShardingSphere official website: https://shardingsphere.apache.org/
+
+[5] Build a Distributed Database Solution based on PostgreSQL/openGauss: https://shardingsphere.apache.org/blog/en/material/jan_28_blog_pg_create_a_distributed_database_solution_based_on_postgresql__opengauss/
+
diff --git "a/docs/blog/content/material/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records.en.md" "b/docs/blog/content/material/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records.en.md"
new file mode 100644
index 00000000000..bb3e85d5bd9
--- /dev/null
+++ "b/docs/blog/content/material/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records.en.md"
@@ -0,0 +1,115 @@
++++
+title = "Apache ShardingSphere Enterprise Applications: Zhuanzhuan’s Transaction System with 100s of Millions of Records"
+weight = 53
+chapter = true
++++
+
+## Background and Challenges
+[Zhuanzhuan](https://www.zhuanzhuan.com/index.html) is an internet platform that allows it users to sell their second-hand stuff — sort of an eBay of the East. Its business had been booming, and with it the ordering system started to face increasing performances challenges. The order database is the cornerstone of the system, and its performance should not be underestimated.
+
+**Challenges:**
+
+- During promotions and special discount periods the burden on databases is heaby with tens of thousands of single database queries per second (qps) taking up huge database resources, and causing a significant reduction in write performance.
+- Increased data pressure, with a single database containing several large tables with hundreds of millions of data, which challenges the capacity limit of the server.
+- Overwhelming data volume, and data backup and recovery take a long time, posing high risks of data loss in extreme cases.
+
+## Why ShardingSphere?
+In the beginning, ZhuanZhuan’s team took adjustment measures to ease the database pressure. Exmaples include:
+
+**- Optimized major transactions, reduced transactions, and even eliminated transactions**
+
+
+
+We adjusted the original transaction order by putting table generation, the core step at the end, and keeping the transaction only in the order primary database. When the operation of the main table was abnormal, dirty reads were allowed on other order-related tables.
+
+**- Order data cache**
+
+
+
+Data consistency was the trickiest part of the cache. As order data involved account settlements and commission, non-real-time and inconsistent data would cause serious accidents.
+
+Strictly keeping cache data consistency would complex coding and reduce system concurrency. Therefore, we made some compromises on cache plans:
+
+1. Allowing direct query when cache failed.
+2. Adding version serial number, and querying the latest version’s data to ensure real-time data.
+3. Complex queries were conducted by [Elasticsearch (ES)](https://www.elastic.co/) and primary and secondary separation, and for some large tables, we adopted hot and cold data separation.
+
+
+
+Through these optimizations, database pressure was eased. However, it still seemed overwhelming under high concurrency scenarios, such as discount season.
+
+To fundamentally solve the performance problem of order database, ZhuanZhuan decided to adopt data sharding (database and table splitting) on the `order` database so that we wouldn’t have to worry about order capacity in the future 3–5 years.
+
+Zhuangzhuang chose [ShardingSphere](https://shardingsphere.apache.org/) after comparing the efficiency, stability, learning cost and etc. of different data sharding components.
+
+Advantages of ShardingSphere:
+
+- It provides standardized data sharding, distributed transactions and database governance, and it’s applicable in a variety of situations such as Java isomorphism, heterogeneous language and cloud native.
+- It has flexible sharding strategies, supporting multiple sharding methods.
+- It’s easy to integrate with other components and has a low level of transaction intrusions.
+- It has extensive documentation and an active community.
+
+ShardingSphere initiated the Database Plus concept and adopts a plugin oriented architecture where all modules are independent of each other, allowing each to be used individually or flexibly combined.
+
+It consists of three products, namely [JDBC](https://shardingsphere.apache.org/), [Proxy](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-proxy) and [Sidecar ](https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-sidecartodo)(Planning), which supports both independent and hybrid deployment.
+
+Below is a feature comparison of the three products:
+
+
+
+By comparison, and considering the high order concurrency, we chose ShardingSphere-JDBC as our data sharding middleware.
+
+ShardingSphere-JDBC is a lightweight Java framework, proving extra service at the JDBC layer. It directly connects to the database by the client-side, provides services by Jar package, and requires no extra deployment and reliance. It can be seen as an enhanced JDBC driver, fully compatible with JDBC and other Object-Relational Mapping(ORM) frameworks.
+
+
+
+## Key Points in Project Implementation
+
+**- Sharding Key**
+The current order ID is generated by `timestamp+user identification code+machine code+incremental sequence`. The user identification code is taken from bits 9 to 16 of the buyer ID, a true random number when the user ID is generated, and is thus suitable as a sharding key.
+
+Choosing user identification code as the sharding key has some advantages:
+
+- The data can be distributed as evenly as possible to each database and table.
+- Specific sharding locations can be quickly located either by order ID or user ID.
+- Data of the same buyer can be distributed to the same databases and tables, facilitating the integrated query of the buyer information.
+
+
+The sharding strategy: we adopt 16 databases and 16 tables. User identification codes are used to split databases, and higher 4 bits are used to split tables.
+
+**- Data Migration between Old and New Databases**
+The migration must be online, and downtime migration cannot be accepted, as there will be new data writes during the migration process.
+
+The data should be intact, and the migration process should be insensible to the client-side. After the migration, data in the new database should be consistent with the ones in the old databases.
+
+The migration should allow rollback, so that when a problem occurs during the migration process, it should be able to roll back to the source database without impacting system availability.
+
+Data migration steps are as follows: dual writes-> migrate historical data-> verify-> old database offline.
+
+## Effects and Benefits
+
+- It solves the problem of single database capacity limit.
+- The data volume of a single database and table is greatly reduced after sharding. The data volume of a single table is reduced from nearly a hundred million level to several millions level, which greatly improves the overall performance.
+- It reduces the risk of data losses due to oversized single databases and tables in extreme cases and eases the pressure of operation and maintenance.
+The following is a comparison of the number of interface calls of the order placement service and the time consumed by the interface during two promotion and discount periods:
+
+**Promotion before adopting ShardingSphere**
+
+
+
+**Promotion after adopting ShardingSphere**
+
+
+
+## Summary
+ShardingSphere simplifies the development of data sharding with its well-designed architecture, highly flexible, pluggable and scalable capabilities, allowing R&D teams to focus only on the business itself, thus enabling flexible scaling of the data architecture.
+
+**Apache ShardingSphere Project Links:**
+
+[ShardingSphere Github](https://github.com/apache/shardingsphere/issues?page=1&q=is%3Aopen+is%3Aissue+label%3A%22project%3A+OpenForce+2022%22)
+
+[ShardingSphere Twitter](https://twitter.com/ShardingSphere)
+
+[ShardingSphere Slack](https://join.slack.com/t/apacheshardingsphere/shared_invite/zt-sbdde7ie-SjDqo9~I4rYcR18bq0SYTg)
+
+[Contributor Guide](https://shardingsphere.apache.org/community/cn/contribute/)
\ No newline at end of file
diff --git a/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference1.png b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference1.png
new file mode 100644
index 00000000000..7bf917eb5d4
Binary files /dev/null and b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference1.png differ
diff --git a/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference2.png b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference2.png
new file mode 100644
index 00000000000..0f88241a600
Binary files /dev/null and b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference2.png differ
diff --git a/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference3.png b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference3.png
new file mode 100644
index 00000000000..9670477b3a1
Binary files /dev/null and b/docs/blog/static/img/2022_04_01_1st_Academic_Paper_by_Apache_ShardingSphere_Accepted_by_ICDE_A_Top-Level_Database_Conference3.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere1.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere1.png
new file mode 100644
index 00000000000..1da38443902
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere1.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere10.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere10.png
new file mode 100644
index 00000000000..432fa982b60
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere10.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere11.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere11.png
new file mode 100644
index 00000000000..ef7646cd3ec
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere11.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere12.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere12.png
new file mode 100644
index 00000000000..7aa389b893b
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere12.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere13.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere13.png
new file mode 100644
index 00000000000..329bdfc5165
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere13.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere14.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere14.png
new file mode 100644
index 00000000000..6c4df959e76
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere14.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere15.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere15.png
new file mode 100644
index 00000000000..f87ed78e516
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere15.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere16.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere16.png
new file mode 100644
index 00000000000..47a8a1133c7
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere16.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere17.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere17.png
new file mode 100644
index 00000000000..e92c7201e4d
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere17.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere18.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere18.png
new file mode 100644
index 00000000000..a9f93bbce2e
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere18.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere19.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere19.png
new file mode 100644
index 00000000000..c4dfb9b9741
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere19.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere2.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere2.png
new file mode 100644
index 00000000000..c202e3e63b7
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere2.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere20.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere20.png
new file mode 100644
index 00000000000..b05d797fd64
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere20.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere21.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere21.png
new file mode 100644
index 00000000000..38ec7675ff9
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere21.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere22.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere22.png
new file mode 100644
index 00000000000..a5c6e3df72a
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere22.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere3.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere3.png
new file mode 100644
index 00000000000..4d0d911fd0d
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere3.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere4.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere4.png
new file mode 100644
index 00000000000..9152ec22b19
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere4.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere5.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere5.png
new file mode 100644
index 00000000000..dd9cacbfca5
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere5.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere6.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere6.png
new file mode 100644
index 00000000000..8ebf65f9474
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere6.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere7.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere7.png
new file mode 100644
index 00000000000..0c94191bed6
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere7.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere8.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere8.png
new file mode 100644
index 00000000000..0d6142f724a
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere8.png differ
diff --git a/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere9.png b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere9.png
new file mode 100644
index 00000000000..bd83d47cbee
Binary files /dev/null and b/docs/blog/static/img/2022_04_06_A_Holistic_Pluggable_Platform_for_Data_Sharding_ICDE_2022_Understanding_Apache_ShardingSphere9.png differ
diff --git a/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT1.png b/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT1.png
new file mode 100644
index 00000000000..f0f1ccdea18
Binary files /dev/null and b/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT1.png differ
diff --git a/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT2.jpg b/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT2.jpg
new file mode 100644
index 00000000000..50bf85426ef
Binary files /dev/null and b/docs/blog/static/img/2022_04_13_A_Practical_Guide_to_Apache_ShardingSphere's_HINT2.jpg differ
diff --git a/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available1.jpeg b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available1.jpeg
new file mode 100644
index 00000000000..49e225dac7d
Binary files /dev/null and b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available1.jpeg differ
diff --git a/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available2.jpeg b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available2.jpeg
new file mode 100644
index 00000000000..8d387f99c5b
Binary files /dev/null and b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available2.jpeg differ
diff --git a/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available3.png b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available3.png
new file mode 100644
index 00000000000..e6918e1038c
Binary files /dev/null and b/docs/blog/static/img/2022_04_18_Apache_ShardingSphere_5.1.1_Is_Available3.png differ
diff --git a/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC1.png b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC1.png
new file mode 100644
index 00000000000..6513d276935
Binary files /dev/null and b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC1.png differ
diff --git a/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC2.png b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC2.png
new file mode 100644
index 00000000000..9c49bf38f78
Binary files /dev/null and b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC2.png differ
diff --git a/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC3.png b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC3.png
new file mode 100644
index 00000000000..97e6f98f24b
Binary files /dev/null and b/docs/blog/static/img/2022_04_21_Apache_ShardingSphere_openGauss_Breaking_the Distributed_Database_Performance_Record_with_10_Million_tpmC3.png differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide1.png b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide1.png
new file mode 100644
index 00000000000..0e77d0f4aaf
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide1.png differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide2.jpg b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide2.jpg
new file mode 100644
index 00000000000..a4e83b57752
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide2.jpg differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide3.jpg b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide3.jpg
new file mode 100644
index 00000000000..608f5b3191c
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide3.jpg differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide4.png b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide4.png
new file mode 100644
index 00000000000..f295c6afe32
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide4.png differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide5.jpg b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide5.jpg
new file mode 100644
index 00000000000..589d2090b30
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide5.jpg differ
diff --git a/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide6.jpg b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide6.jpg
new file mode 100644
index 00000000000..41c7710dc07
Binary files /dev/null and b/docs/blog/static/img/2022_04_26_How_to_Use_ShardingSphere-Proxy_in_Real_Production_Scenarios_Your_Quick_Start_Guide6.jpg differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records1.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records1.png"
new file mode 100644
index 00000000000..ec8b40ba580
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records1.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records2.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records2.png"
new file mode 100644
index 00000000000..fbc234bdf36
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records2.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records3.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records3.png"
new file mode 100644
index 00000000000..ba077694bb1
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records3.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records4.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records4.png"
new file mode 100644
index 00000000000..b979417d75a
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records4.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records5.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records5.png"
new file mode 100644
index 00000000000..1a582c445d3
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records5.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records6.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records6.png"
new file mode 100644
index 00000000000..2c5850e62a6
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records6.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records7.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records7.png"
new file mode 100644
index 00000000000..9374436b9bc
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records7.png" differ
diff --git "a/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records8.png" "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records8.png"
new file mode 100644
index 00000000000..4ccf82d486d
Binary files /dev/null and "b/docs/blog/static/img/2022_04_29_Apache_ShardingSphere_Enterprise_Applications_Zhuanzhuan\342\200\231s_Transaction_System_with_100s_of_Millions_of_Records8.png" differ