You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/10/18 05:36:34 UTC

(shardingsphere) branch master updated: Support missing PostgreSQL syntax and parser metadata (#40155)

This is an automated email from the ASF dual-hosted git repository.

terrymanu 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 ea8fa381127 Support missing PostgreSQL syntax and parser metadata (#40155)
ea8fa381127 is described below

commit ea8fa38112739b6654f82ed180d9be84eb9de8d2
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Oct 18 13:36:26 2026 +0800

    Support missing PostgreSQL syntax and parser metadata (#40155)
    
    * Use configured GitHub refs when loading external SQL test cases
    
    * Support missing PostgreSQL syntax and parser metadata
    
    * Resolve SQL parser test fixture merge conflicts
    
    * Reject data-modifying CTEs during MCP SQL analysis
    
    * Fix PostgreSQL parser metadata and AST consumer handling
    
    * Preserve PostgreSQL JSON clauses and MCP expression safety
    
    * Fix PostgreSQL parser metadata and defer incomplete syntax
    
    * Fix PostgreSQL parser metadata and defer incomplete syntax
    
    * Fix PostgreSQL DELETE USING source parsing
    
    * Fix parser AST consumer regressions
    
    * Fix table extraction from PostgreSQL MERGE clauses
    
    * Fix PostgreSQL USING alias scope and defer identifier decoding
---
 .../EncryptAssignmentTokenGenerator.java           |   30 +
 .../insert/EncryptInsertValuesTokenGenerator.java  |    3 +-
 .../EncryptOpenQuerySupportedCheckerTest.java      |    2 +-
 .../EncryptAssignmentTokenGeneratorTest.java       |  160 +++
 .../condition/ExpressionConditionUtilsTest.java    |    6 +-
 .../InsertClauseShardingConditionEngineTest.java   |    4 +-
 ...ConditionValueBetweenOperatorGeneratorTest.java |    9 +-
 ...ConditionValueCompareOperatorGeneratorTest.java |    2 +-
 .../ConditionValueInOperatorGeneratorTest.java     |    2 +-
 .../engine/LimitPaginationContextEngine.java       |    7 +-
 .../dml/expression/ExpressionSegmentBinder.java    |   20 +
 .../PrepareStatementQuerySegmentBinder.java        |    1 +
 .../with/CommonTableExpressionSegmentBinder.java   |    6 +-
 .../statement/ddl/PrepareStatementBinder.java      |    1 +
 .../engine/GeneratedKeyContextEngineTest.java      |    2 +-
 .../engine/LimitPaginationContextEngineTest.java   |   32 +
 .../expression/ExpressionSegmentBinderTest.java    |   73 +-
 .../PrepareStatementQuerySegmentBinderTest.java    |   70 +
 .../CommonTableExpressionSegmentBinderTest.java    |  128 ++
 .../statement/ddl/PrepareStatementBinderTest.java  |   26 +
 .../statement/dml/DeleteStatementBinderTest.java   |    2 +-
 .../statement/dml/SelectStatementBinderTest.java   |    6 +-
 .../statement/dml/UpdateStatementBinderTest.java   |    2 +-
 .../ast/converter/segment/with/WithConverter.java  |    8 +-
 .../statement/type/SelectStatementConverter.java   |    1 +
 .../expression/ExpressionConverterTest.java        |    2 +-
 .../converter/segment/with/WithConverterTest.java  |  172 +++
 .../type/DeleteStatementConverterTest.java         |    3 +-
 .../type/SelectStatementConverterTest.java         |   35 +
 .../handler/execute/SQLStatementTreeWalker.java    |   10 +-
 .../handler/execute/MCPSQLExecutionFacadeTest.java |    2 +-
 .../handler/execute/MCPStatementAnalyzerTest.java  |    3 +
 .../core/database/visitor/SQLVisitorRule.java      |   26 +
 .../statement/ClickHouseStatementVisitor.java      |    4 +-
 .../type/ClickHouseDMLStatementVisitor.java        |    2 +-
 .../visitor/statement/DorisStatementVisitor.java   |   11 +-
 .../statement/FirebirdStatementVisitor.java        |    4 +-
 .../type/FirebirdDMLStatementVisitor.java          |    2 +-
 .../visitor/statement/HiveStatementVisitor.java    |    3 +-
 .../statement/type/HiveDMLStatementVisitor.java    |   11 +-
 .../visitor/statement/MySQLStatementVisitor.java   |    8 +-
 .../statement/type/MySQLDMLStatementVisitor.java   |    3 +-
 .../statement/OpenGaussStatementVisitor.java       |    9 +-
 .../visitor/statement/OracleStatementVisitor.java  |   12 +-
 .../statement/type/OracleDMLStatementVisitor.java  |   12 +-
 .../src/main/antlr4/imports/postgresql/BaseRule.g4 |  247 +++-
 .../main/antlr4/imports/postgresql/DALStatement.g4 |   17 +-
 .../main/antlr4/imports/postgresql/DCLStatement.g4 |    4 +-
 .../main/antlr4/imports/postgresql/DDLStatement.g4 |  192 ++-
 .../main/antlr4/imports/postgresql/DMLStatement.g4 |   55 +-
 .../src/main/antlr4/imports/postgresql/Literals.g4 |   45 +-
 .../antlr4/imports/postgresql/PostgreSQLKeyword.g4 |   54 +-
 .../antlr4/imports/postgresql/StoreProcedure.g4    |    2 +-
 .../src/main/antlr4/imports/postgresql/Symbol.g4   |    8 +
 .../parser/autogen/PostgreSQLStatementParser.g4    |   14 +
 .../statement/PostgreSQLStatementVisitor.java      |  762 +++++++++--
 .../type/PostgreSQLDALStatementVisitor.java        |   29 +-
 .../type/PostgreSQLDDLStatementVisitor.java        |  163 ++-
 .../type/PostgreSQLDMLStatementVisitor.java        |    5 +-
 .../visitor/statement/PrestoStatementVisitor.java  |    3 +-
 .../statement/type/PrestoDMLStatementVisitor.java  |    8 +-
 .../visitor/statement/SQL92StatementVisitor.java   |    4 +-
 .../statement/type/SQL92DMLStatementVisitor.java   |    2 +-
 .../statement/SQLServerStatementVisitor.java       |    9 +-
 .../statement/core/extractor/ColumnExtractor.java  |   10 +
 .../core/extractor/ExpressionExtractor.java        |   31 +
 .../core/extractor/SubqueryExtractor.java          |   16 +
 .../statement/core/extractor/TableExtractor.java   |  469 +++++--
 .../core/segment/dml/ReturningSegment.java         |    8 +
 .../dml/expr/complex/CommonExpressionSegment.java  |    5 +
 .../expr/complex/CommonTableExpressionSegment.java |   13 +
 .../segment/dml/pagination/limit/LimitSegment.java |   10 +
 .../dml/prepare/PrepareStatementQuerySegment.java  |   12 +
 .../segment/generic/table/JoinTableSegment.java    |   11 +
 .../core/statement/type/ddl/PrepareStatement.java  |   22 +-
 .../sql/parser/statement/core/util/SQLUtils.java   |    5 +-
 .../core/extractor/ColumnExtractorTest.java        |   40 +-
 .../core/extractor/ExpressionExtractorTest.java    |  104 +-
 .../core/extractor/SubqueryExtractorTest.java      |  122 ++
 .../core/extractor/TableExtractorTest.java         |  466 +++++++
 .../statement/type/ddl/PrepareStatementTest.java   |   43 +
 .../ddl/PostgreSQLAlterLargeObjectStatement.java}  |   20 +-
 .../PostgreSQLAlterOperatorClassStatement.java}    |   20 +-
 .../PostgreSQLAlterOperatorFamilyStatement.java}   |   20 +-
 .../ddl/PostgreSQLAlterUserMappingStatement.java}  |   20 +-
 .../PostgreSQLCreateOperatorClassStatement.java}   |   20 +-
 .../PostgreSQLCreateOperatorFamilyStatement.java}  |   20 +-
 .../ddl/PostgreSQLCreateTransformStatement.java}   |   20 +-
 .../ddl/PostgreSQLCreateUserMappingStatement.java} |   20 +-
 .../ddl/PostgreSQLDropUserMappingStatement.java}   |   20 +-
 .../PostgreSQLImportForeignSchemaStatement.java}   |   20 +-
 .../PostgreSQLAlterEventTriggerStatement.java}     |   20 +-
 .../PostgreSQLCreateStatisticsStatement.java}      |   20 +-
 .../PostgreSQLCreateSubscriptionStatement.java}    |   20 +-
 .../backend/connector/ProxySQLExecutorTest.java    |    6 +-
 .../segment/assignment/AssignmentValueAssert.java  |    8 +
 .../segment/expression/ExpressionAssert.java       |   12 +
 .../asserts/segment/limit/LimitClauseAssert.java   |   17 +-
 .../prepare/PrepareStatementQueryAssert.java       |   11 +
 .../segment/returning/ReturningClauseAssert.java   |   19 +
 .../asserts/segment/table/TableAssert.java         |   94 +-
 .../asserts/segment/with/WithClauseAssert.java     |   39 +
 .../dal/standard/type/ExplainStatementAssert.java  |   14 +-
 .../postgresql/PostgreSQLDDLStatementAssert.java   |  161 +++
 .../postgresql/PostgreSQLDMLStatementAssert.java   |   50 +
 .../dml/standard/type/SelectStatementAssert.java   |    1 +
 .../cases/parser/jaxb/RootSQLParserTestCases.java  |   52 +
 .../impl/assignment/ExpectedAssignmentValue.java   |    4 +
 .../segment/impl/expr/ExpectedTableFunction.java   |    9 +
 ...leFunction.java => ExpectedXmlTableColumn.java} |   19 +-
 .../expr/complex/ExpectedCommonExpression.java     |   11 +
 .../impl/insert/ExpectedReturningClause.java       |   19 +
 .../segment/impl/limit/ExpectedLimitClause.java    |    7 +
 .../impl/query/ExpectedPrepareStatementQuery.java  |    4 +
 .../jaxb/segment/impl/table/ExpectedJoinTable.java |    9 +
 .../with/ExpectedCommonTableExpressionClause.java  |   22 +
 .../dal/standard/ExplainStatementTestCase.java     |   10 +
 ...stgreSQLAlterLargeObjectStatementTestCase.java} |    6 +-
 ...greSQLAlterOperatorClassStatementTestCase.java} |    6 +-
 ...reSQLAlterOperatorFamilyStatementTestCase.java} |    6 +-
 ...stgreSQLAlterUserMappingStatementTestCase.java} |    6 +-
 ...reSQLCreateOperatorClassStatementTestCase.java} |    6 +-
 ...eSQLCreateOperatorFamilyStatementTestCase.java} |    6 +-
 ...ostgreSQLCreateTransformStatementTestCase.java} |    6 +-
 ...tgreSQLCreateUserMappingStatementTestCase.java} |    6 +-
 ...ostgreSQLDropUserMappingStatementTestCase.java} |    6 +-
 ...reSQLImportForeignSchemaStatementTestCase.java} |    6 +-
 ...tgreSQLAlterEventTriggerStatementTestCase.java} |    6 +-
 ...stgreSQLCreateStatisticsStatementTestCase.java} |    6 +-
 ...greSQLCreateSubscriptionStatementTestCase.java} |    6 +-
 .../ddl/standard/PreparedStatementTestCase.java    |    8 +
 .../dml/standard/DeleteStatementTestCase.java      |    4 +
 .../dml/standard/UpdateStatementTestCase.java      |    4 +
 .../resources/case/dal/postgresql-regression.xml   |   89 ++
 .../parser/src/main/resources/case/dcl/grant.xml   |   18 +-
 .../parser/src/main/resources/case/dcl/revoke.xml  |   14 +
 .../src/main/resources/case/ddl/create-trigger.xml |    3 +-
 .../resources/case/ddl/postgresql-regression.xml   |  443 ++++++
 .../parser/src/main/resources/case/dml/delete.xml  |   97 ++
 .../parser/src/main/resources/case/dml/insert.xml  |  139 ++
 .../parser/src/main/resources/case/dml/merge.xml   |   81 ++
 .../main/resources/case/dml/postgresql-root.xml    |  101 ++
 .../main/resources/case/dml/select-expression.xml  | 1447 +++++++++++++++++++-
 .../main/resources/case/dml/select-group-by.xml    |   24 +
 .../src/main/resources/case/dml/select-join.xml    |   37 +
 .../main/resources/case/dml/select-pagination.xml  |   99 ++
 .../resources/case/dml/select-special-function.xml | 1113 ++++++++++++++-
 .../src/main/resources/case/dml/select-with.xml    |  335 +++++
 .../parser/src/main/resources/case/dml/update.xml  |  226 ++-
 .../sql/supported/dal/postgresql-regression.xml    |   30 +
 .../resources/sql/supported/dcl/grant-user.xml     |    8 +-
 .../resources/sql/supported/dcl/revoke-user.xml    |    6 +
 .../resources/sql/supported/ddl/create-trigger.xml |    3 +-
 .../sql/supported/ddl/postgresql-regression.xml    |  120 ++
 .../main/resources/sql/supported/dml/delete.xml    |    4 +
 .../main/resources/sql/supported/dml/insert.xml    |    7 +
 .../src/main/resources/sql/supported/dml/merge.xml |    3 +
 .../sql/supported/dml/postgresql-root.xml          |   32 +
 .../sql/supported/dml/select-expression.xml        |   53 +
 .../sql/supported/dml/select-group-by.xml          |    3 +
 .../resources/sql/supported/dml/select-join.xml    |    3 +
 .../sql/supported/dml/select-pagination.xml        |    9 +
 .../sql/supported/dml/select-special-function.xml  |   58 +
 .../resources/sql/supported/dml/select-with.xml    |    7 +
 .../main/resources/sql/supported/dml/update.xml    |    8 +
 .../main/resources/sql/unsupported/unsupported.xml |   27 +
 .../postgresql/InternalPostgreSQLParserIT.java     |  589 ++++++++
 167 files changed, 9455 insertions(+), 680 deletions(-)

diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGenerator.java
index f27a7e81967..860a5a8e9cd 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGenerator.java
@@ -31,6 +31,8 @@ import org.apache.shardingsphere.encrypt.rule.column.EncryptColumn;
 import org.apache.shardingsphere.encrypt.rule.table.EncryptTable;
 import org.apache.shardingsphere.infra.annotation.HighFrequencyInvocation;
 import org.apache.shardingsphere.infra.binder.context.segment.table.TablesContext;
+import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
 import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
 import org.apache.shardingsphere.infra.rewrite.sql.token.common.pojo.SQLToken;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.TableSourceType;
@@ -38,6 +40,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignmen
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.SetAssignmentSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 
@@ -55,6 +58,8 @@ import java.util.Optional;
 @Slf4j
 public final class EncryptAssignmentTokenGenerator {
     
+    private static final String UNSUPPORTED_ASSIGNMENT_MESSAGE = "Encrypted assignments with multiple columns, nested fields or unsupported expressions";
+    
     private final EncryptRule rule;
     
     private final ShardingSphereDatabase database;
@@ -75,9 +80,15 @@ public final class EncryptAssignmentTokenGenerator {
         QuoteCharacter quoteCharacter = databaseTypeRegistry.getDialectDatabaseMetaData().getQuoteCharacter();
         for (ColumnAssignmentSegment each : setAssignmentSegment.getAssignments()) {
             ColumnSegment assignedColumn = getAssignedColumn(each);
+            if (each.getColumns().size() > 1 || null != assignedColumn.getNestedObjectAttributes() && !assignedColumn.getNestedObjectAttributes().isEmpty()) {
+                checkUnsupportedAssignment(each);
+                continue;
+            }
             findEncryptTable(assignedColumn).ifPresent(encryptTable -> {
                 String columnName = assignedColumn.getIdentifier().getValue();
                 if (encryptTable.isEncryptColumn(columnName)) {
+                    ExpressionSegment value = each.getValue();
+                    ShardingSpherePreconditions.checkState(null == value || !isUnsupportedExpression(value), () -> new UnsupportedSQLOperationException(UNSUPPORTED_ASSIGNMENT_MESSAGE));
                     result.addAll(generateAssignmentSQLTokens(schemaName, encryptTable.getTable(), encryptTable.getEncryptColumn(columnName), each, quoteCharacter));
                 }
             });
@@ -85,6 +96,25 @@ public final class EncryptAssignmentTokenGenerator {
         return result;
     }
     
+    private void checkUnsupportedAssignment(final ColumnAssignmentSegment assignment) {
+        for (ColumnSegment each : assignment.getColumns()) {
+            ShardingSpherePreconditions.checkState(!findEncryptTable(each).map(optional -> optional.isEncryptColumn(each.getIdentifier().getValue())).orElse(false),
+                    () -> new UnsupportedSQLOperationException(UNSUPPORTED_ASSIGNMENT_MESSAGE));
+        }
+    }
+    
+    private boolean isUnsupportedExpression(final ExpressionSegment expression) {
+        if (!(expression instanceof FunctionSegment)) {
+            return !(expression instanceof ParameterMarkerExpressionSegment) && !(expression instanceof LiteralExpressionSegment);
+        }
+        for (ExpressionSegment each : ((FunctionSegment) expression).getParameters()) {
+            if (!(each instanceof ColumnSegment) && isUnsupportedExpression(each)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
     private Collection<SQLToken> generateAssignmentSQLTokens(final String schemaName, final String tableName, final EncryptColumn encryptColumn,
                                                              final ColumnAssignmentSegment segment, final QuoteCharacter quoteCharacter) {
         ExpressionSegment value = segment.getValue();
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/insert/EncryptInsertValuesTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/insert/EncryptInsertValuesTokenGenerator.java
index c60a39c7c42..8f71ac2b6fc 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/insert/EncryptInsertValuesTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/insert/EncryptInsertValuesTokenGenerator.java
@@ -51,6 +51,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simp
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -240,7 +241,7 @@ public final class EncryptInsertValuesTokenGenerator implements OptionalSQLToken
     }
     
     private ExpressionSegment createDefaultExpression(final ExpressionSegment valueExpression) {
-        return new CommonExpressionSegment(valueExpression.getStartIndex(), valueExpression.getStopIndex(), DEFAULT_EXPRESSION);
+        return new CommonExpressionSegment(valueExpression.getStartIndex(), valueExpression.getStopIndex(), DEFAULT_EXPRESSION, Collections.emptyList());
     }
     
     private boolean isLiteralExpression(final ExpressionSegment valueExpression) {
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/sql/openquery/EncryptOpenQuerySupportedCheckerTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/sql/openquery/EncryptOpenQuerySupportedCheckerTest.java
index 9e75766d9af..a9497317623 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/sql/openquery/EncryptOpenQuerySupportedCheckerTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/sql/openquery/EncryptOpenQuerySupportedCheckerTest.java
@@ -549,7 +549,7 @@ class EncryptOpenQuerySupportedCheckerTest {
     
     private WithSegment createWithSegmentContainingOpenQuery() {
         SubquerySegment cteSubquery = mockSubqueryWithOpenQueryFrom();
-        CommonTableExpressionSegment cteSeg = new CommonTableExpressionSegment(0, 80, new AliasSegment(0, 3, new IdentifierValue("foo_cte")), cteSubquery);
+        CommonTableExpressionSegment cteSeg = new CommonTableExpressionSegment(0, 80, new AliasSegment(0, 3, new IdentifierValue("foo_cte")), cteSubquery, null);
         return new WithSegment(0, 80, Collections.singletonList(cteSeg));
     }
     
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGeneratorTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGeneratorTest.java
index c61e2ed5776..63350325573 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGeneratorTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/assignment/EncryptAssignmentTokenGeneratorTest.java
@@ -25,12 +25,18 @@ import org.apache.shardingsphere.encrypt.rule.EncryptRule;
 import org.apache.shardingsphere.encrypt.rule.column.EncryptColumn;
 import org.apache.shardingsphere.encrypt.rule.table.EncryptTable;
 import org.apache.shardingsphere.infra.binder.context.segment.table.TablesContext;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
 import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.TableSourceType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.ColumnAssignmentSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.SetAssignmentSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.bound.ColumnSegmentBoundInfo;
@@ -41,17 +47,26 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.MockedConstruction;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockConstruction;
@@ -145,4 +160,149 @@ class EncryptAssignmentTokenGeneratorTest {
         when(assignmentSegment.getValue()).thenReturn(mock(LiteralExpressionSegment.class));
         assertThat(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).size(), is(1));
     }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getEncryptedTupleArguments")
+    void assertGenerateSQLTokensWithEncryptedTuple(final String name, final Collection<String> columnNames, final String encryptedColumnName) {
+        EncryptRule rule = mock(EncryptRule.class);
+        EncryptTable encryptTable = mock(EncryptTable.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(encryptTable));
+        when(encryptTable.isEncryptColumn(anyString())).thenAnswer(invocation -> encryptedColumnName.equals(invocation.getArgument(0)));
+        when(assignmentSegment.getColumns()).thenReturn(columnNames.stream().map(this::createBoundColumn).collect(Collectors.toList()));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Encrypted assignments with multiple columns, nested fields or unsupported expressions."));
+    }
+    
+    private ColumnSegment createBoundColumn(final String columnName) {
+        ColumnSegment result = new ColumnSegment(0, 0, new IdentifierValue(columnName));
+        result.setColumnBoundInfo(new ColumnSegmentBoundInfo(new TableSegmentBoundInfo(new IdentifierValue("foo_db"), new IdentifierValue("foo_schema")),
+                new IdentifierValue("foo_table"), new IdentifierValue(columnName), TableSourceType.PHYSICAL_TABLE));
+        return result;
+    }
+    
+    private static Stream<Arguments> getEncryptedTupleArguments() {
+        return Stream.of(
+                Arguments.of("encrypted first target", Arrays.asList("foo_cipher", "foo_plain"), "foo_cipher"),
+                Arguments.of("encrypted second target", Arrays.asList("foo_plain", "foo_cipher"), "foo_cipher"),
+                Arguments.of("encrypted third target", Arrays.asList("foo_plain", "bar_plain", "foo_cipher"), "foo_cipher"));
+    }
+    
+    @Test
+    void assertGenerateSQLTokensWithPlainTuple() {
+        EncryptRule rule = mock(EncryptRule.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(mock(EncryptTable.class)));
+        when(assignmentSegment.getColumns()).thenReturn(Arrays.asList(createBoundColumn("foo_plain"), createBoundColumn("bar_plain")));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        assertTrue(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).isEmpty());
+    }
+    
+    @Test
+    void assertGenerateSQLTokensWithTupleWithoutEncryptTable() {
+        when(assignmentSegment.getColumns()).thenReturn(Arrays.asList(createBoundColumn("foo_plain"), createBoundColumn("bar_plain")));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(mock(EncryptRule.class), mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        assertTrue(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).isEmpty());
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getSupportedFunctionValues")
+    void assertGenerateSQLTokensWithEncryptedFunction(final String name, final FunctionSegment value) {
+        EncryptRule rule = mock(EncryptRule.class);
+        EncryptTable encryptTable = mock(EncryptTable.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(encryptTable));
+        when(encryptTable.isEncryptColumn("foo_cipher")).thenReturn(true);
+        when(assignmentSegment.getColumns()).thenReturn(Collections.singletonList(createBoundColumn("foo_cipher")));
+        when(assignmentSegment.getValue()).thenReturn(value);
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        assertTrue(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).isEmpty());
+    }
+    
+    private static Stream<Arguments> getSupportedFunctionValues() {
+        FunctionSegment ifnull = new FunctionSegment(0, 20, "IFNULL", "IFNULL(foo_cipher, ?)");
+        ifnull.getParameters().add(new ColumnSegment(7, 16, new IdentifierValue("foo_cipher")));
+        ifnull.getParameters().add(new ParameterMarkerExpressionSegment(19, 19, 0));
+        FunctionSegment coalesce = new FunctionSegment(0, 33, "COALESCE", "COALESCE(IFNULL(foo_cipher, ?), 0)");
+        coalesce.getParameters().add(ifnull);
+        coalesce.getParameters().add(new LiteralExpressionSegment(32, 32, 0));
+        return Stream.of(
+                Arguments.of("legacy function", ifnull),
+                Arguments.of("nested legacy function", coalesce),
+                Arguments.of("function without parameters", new FunctionSegment(0, 3, "PI", "PI()")));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getUnsupportedAssignmentValues")
+    void assertGenerateSQLTokensWithEncryptedUnsupportedValue(final String name, final ExpressionSegment value) {
+        EncryptRule rule = mock(EncryptRule.class);
+        EncryptTable encryptTable = mock(EncryptTable.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(encryptTable));
+        when(encryptTable.isEncryptColumn("foo_cipher")).thenReturn(true);
+        when(assignmentSegment.getColumns()).thenReturn(Collections.singletonList(createBoundColumn("foo_cipher")));
+        when(assignmentSegment.getValue()).thenReturn(value);
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Encrypted assignments with multiple columns, nested fields or unsupported expressions."));
+    }
+    
+    private static Stream<Arguments> getUnsupportedAssignmentValues() {
+        UnaryOperationExpression unary = new UnaryOperationExpression(0, 1, new ParameterMarkerExpressionSegment(1, 1, 0), "~", "~?");
+        FunctionSegment function = new FunctionSegment(0, 11, "coalesce", "coalesce(~?)");
+        function.getParameters().add(unary);
+        FunctionSegment nestedFunction = new FunctionSegment(0, 21, "coalesce", "coalesce(coalesce(~?))");
+        nestedFunction.getParameters().add(function);
+        FunctionSegment commonFunction = new FunctionSegment(0, 15, "coalesce", "coalesce((?)[1])");
+        commonFunction.getParameters().add(new CommonExpressionSegment(9, 14, "(?)[1]", Collections.singletonList(new ParameterMarkerExpressionSegment(10, 10, 0))));
+        return Stream.of(
+                Arguments.of("common children", new CommonExpressionSegment(0, 5, "(?)[1]", Collections.singletonList(new ParameterMarkerExpressionSegment(1, 1, 0)))),
+                Arguments.of("opaque common", new CommonExpressionSegment(0, 6, "DEFAULT", Collections.emptyList())),
+                Arguments.of("cast unary value", new TypeCastExpression(0, 14, "CAST(~? AS text)", unary, "text")),
+                Arguments.of("unary value", unary),
+                Arguments.of("function unary value", function),
+                Arguments.of("nested function unary value", nestedFunction),
+                Arguments.of("function common value", commonFunction));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getUnsupportedAssignmentValues")
+    void assertGenerateSQLTokensWithPlainUnsupportedValue(final String name, final ExpressionSegment value) {
+        EncryptRule rule = mock(EncryptRule.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(mock(EncryptTable.class)));
+        when(setAssignmentSegment.getAssignments()).thenReturn(Collections.singletonList(new ColumnAssignmentSegment(0, 0, Collections.singletonList(createBoundColumn("foo_plain")), value)));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        assertTrue(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).isEmpty());
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getFieldAssignmentArguments")
+    void assertGenerateSQLTokensWithEncryptedField(final String name, final Collection<String> fields, final ExpressionSegment value) {
+        EncryptRule rule = mock(EncryptRule.class);
+        EncryptTable encryptTable = mock(EncryptTable.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(encryptTable));
+        when(encryptTable.isEncryptColumn("foo_cipher")).thenReturn(true);
+        ColumnSegment column = createBoundColumn("foo_cipher");
+        column.setNestedObjectAttributes(fields.stream().map(IdentifierValue::new).collect(Collectors.toList()));
+        when(setAssignmentSegment.getAssignments()).thenReturn(Collections.singletonList(new ColumnAssignmentSegment(0, 0, Collections.singletonList(column), value)));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Encrypted assignments with multiple columns, nested fields or unsupported expressions."));
+    }
+    
+    private static Stream<Arguments> getFieldAssignmentArguments() {
+        return Stream.of(
+                Arguments.of("single field parameter", Collections.singletonList("foo_field"), new ParameterMarkerExpressionSegment(0, 0, 0)),
+                Arguments.of("field chain literal", Arrays.asList("foo_field", "bar_field"), new LiteralExpressionSegment(0, 0, "foo_value")),
+                Arguments.of("quoted field parameter", Collections.singletonList("\"foo.field\""), new ParameterMarkerExpressionSegment(0, 0, 0)));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getFieldAssignmentArguments")
+    void assertGenerateSQLTokensWithPlainField(final String name, final Collection<String> fields, final ExpressionSegment value) {
+        EncryptRule rule = mock(EncryptRule.class);
+        when(rule.findEncryptTable("foo_table")).thenReturn(Optional.of(mock(EncryptTable.class)));
+        ColumnSegment column = createBoundColumn("foo_plain");
+        column.setNestedObjectAttributes(fields.stream().map(IdentifierValue::new).collect(Collectors.toList()));
+        when(setAssignmentSegment.getAssignments()).thenReturn(Collections.singletonList(new ColumnAssignmentSegment(0, 0, Collections.singletonList(column), value)));
+        tokenGenerator = new EncryptAssignmentTokenGenerator(rule, mock(ShardingSphereDatabase.class), TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
+        assertTrue(tokenGenerator.generateSQLTokens(tablesContext, setAssignmentSegment).isEmpty());
+    }
 }
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/ExpressionConditionUtilsTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/ExpressionConditionUtilsTest.java
index 4d1feca6cd9..be598fc7d02 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/ExpressionConditionUtilsTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/ExpressionConditionUtilsTest.java
@@ -21,6 +21,8 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.comp
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.junit.jupiter.api.Test;
 
+import java.util.Collections;
+
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -29,7 +31,7 @@ class ExpressionConditionUtilsTest {
     @Test
     void assertIsNowExpression() {
         assertFalse(ExpressionConditionUtils.isNowExpression(new LiteralExpressionSegment(0, 0, new Object())));
-        assertFalse(ExpressionConditionUtils.isNowExpression(new CommonExpressionSegment(0, 0, "shardingsphere")));
-        assertTrue(ExpressionConditionUtils.isNowExpression(new CommonExpressionSegment(0, 0, "NOW()")));
+        assertFalse(ExpressionConditionUtils.isNowExpression(new CommonExpressionSegment(0, 0, "shardingsphere", Collections.emptyList())));
+        assertTrue(ExpressionConditionUtils.isNowExpression(new CommonExpressionSegment(0, 0, "NOW()", Collections.emptyList())));
     }
 }
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/engine/InsertClauseShardingConditionEngineTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/engine/InsertClauseShardingConditionEngineTest.java
index 9c5d5133e94..19525176b22 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/engine/InsertClauseShardingConditionEngineTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/engine/InsertClauseShardingConditionEngineTest.java
@@ -117,11 +117,11 @@ class InsertClauseShardingConditionEngineTest {
     }
     
     private InsertValueContext createInsertValueContextAsCommonExpressionSegmentEmptyText() {
-        return new InsertValueContext(Collections.singleton(new CommonExpressionSegment(0, 10, "null")), Collections.emptyList(), 0);
+        return new InsertValueContext(Collections.singleton(new CommonExpressionSegment(0, 10, "null", Collections.emptyList())), Collections.emptyList(), 0);
     }
     
     private InsertValueContext createInsertValueContextAsCommonExpressionSegmentWithNow() {
-        return new InsertValueContext(Collections.singleton(new CommonExpressionSegment(0, 10, "now()")), Collections.emptyList(), 0);
+        return new InsertValueContext(Collections.singleton(new CommonExpressionSegment(0, 10, "now()", Collections.emptyList())), Collections.emptyList(), 0);
     }
     
     @Test
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueBetweenOperatorGeneratorTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueBetweenOperatorGeneratorTest.java
index f4cb507f07b..3a78bb7b802 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueBetweenOperatorGeneratorTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueBetweenOperatorGeneratorTest.java
@@ -39,6 +39,7 @@ import java.sql.Timestamp;
 import java.time.LocalDateTime;
 import java.util.Arrays;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.Date;
 import java.util.LinkedList;
 import java.util.Optional;
@@ -100,7 +101,7 @@ class ConditionValueBetweenOperatorGeneratorTest {
     void assertGenerateErrorConditionValue() {
         int between = 1;
         ExpressionSegment betweenSegment = new LiteralExpressionSegment(0, 0, between);
-        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()");
+        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()", Collections.emptyList());
         BetweenExpression value = new BetweenExpression(0, 0, null, betweenSegment, andSegment, false);
         assertThrows(ClassCastException.class, () -> generator.generate(value, column, new LinkedList<>(), timestampServiceRule));
     }
@@ -110,7 +111,7 @@ class ConditionValueBetweenOperatorGeneratorTest {
     void assertGenerateOneNowConditionValue() {
         Timestamp timestamp = Timestamp.valueOf(LocalDateTime.now());
         ExpressionSegment betweenSegment = new LiteralExpressionSegment(0, 0, timestamp);
-        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()");
+        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()", Collections.emptyList());
         BetweenExpression value = new BetweenExpression(0, 0, null, betweenSegment, andSegment, false);
         Optional<ShardingConditionValue> shardingConditionValue = generator.generate(value, column, new LinkedList<>(), timestampServiceRule);
         assertTrue(shardingConditionValue.isPresent());
@@ -126,8 +127,8 @@ class ConditionValueBetweenOperatorGeneratorTest {
     void assertGenerateNowConditionValue() {
         Calendar calendar = Calendar.getInstance();
         calendar.add(Calendar.DATE, 1);
-        ExpressionSegment betweenSegment = new CommonExpressionSegment(0, 0, "now()");
-        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()");
+        ExpressionSegment betweenSegment = new CommonExpressionSegment(0, 0, "now()", Collections.emptyList());
+        ExpressionSegment andSegment = new CommonExpressionSegment(0, 0, "now()", Collections.emptyList());
         BetweenExpression value = new BetweenExpression(0, 0, null, betweenSegment, andSegment, false);
         Optional<ShardingConditionValue> shardingConditionValue = generator.generate(value, column, new LinkedList<>(), timestampServiceRule);
         assertTrue(shardingConditionValue.isPresent());
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueCompareOperatorGeneratorTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueCompareOperatorGeneratorTest.java
index 4610f9d9e9f..bfb3edd9be6 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueCompareOperatorGeneratorTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueCompareOperatorGeneratorTest.java
@@ -199,7 +199,7 @@ class ConditionValueCompareOperatorGeneratorTest {
     
     @Test
     void assertGenerateConditionValueWithoutNowExpression() {
-        BinaryOperationExpression rightValue = new BinaryOperationExpression(0, 0, mock(ColumnSegment.class), new CommonExpressionSegment(0, 0, "value"), "=", null);
+        BinaryOperationExpression rightValue = new BinaryOperationExpression(0, 0, mock(ColumnSegment.class), new CommonExpressionSegment(0, 0, "value", Collections.emptyList()), "=", null);
         assertFalse(generator.generate(rightValue, column, new LinkedList<>(), mock(TimestampServiceRule.class)).isPresent());
     }
     
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueInOperatorGeneratorTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueInOperatorGeneratorTest.java
index fc75158bbd1..91c391240f2 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueInOperatorGeneratorTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/condition/generator/impl/ConditionValueInOperatorGeneratorTest.java
@@ -57,7 +57,7 @@ class ConditionValueInOperatorGeneratorTest {
     @Test
     void assertNowExpression() {
         ListExpression listExpression = new ListExpression(0, 0);
-        listExpression.getItems().add(new CommonExpressionSegment(0, 0, "now()"));
+        listExpression.getItems().add(new CommonExpressionSegment(0, 0, "now()", Collections.emptyList()));
         InExpression inExpression = new InExpression(0, 0, null, listExpression, false);
         Optional<ShardingConditionValue> shardingConditionValue = generator.generate(inExpression, column, new LinkedList<>(), timestampServiceRule);
         assertTrue(shardingConditionValue.isPresent());
diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngine.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngine.java
index a4116a23549..50576cb08d1 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngine.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngine.java
@@ -18,6 +18,9 @@
 package org.apache.shardingsphere.infra.binder.context.segment.select.pagination.engine;
 
 import org.apache.shardingsphere.infra.binder.context.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.PaginationValueSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.LimitSegment;
 
 import java.util.List;
@@ -35,6 +38,8 @@ public final class LimitPaginationContextEngine {
      * @return pagination context
      */
     public PaginationContext createPaginationContext(final LimitSegment limitSegment, final List<Object> params) {
-        return new PaginationContext(limitSegment.getOffset().orElse(null), limitSegment.getRowCount().orElse(null), params);
+        PaginationValueSegment offset = limitSegment.getOffset().orElse(null);
+        ShardingSpherePreconditions.checkState(!limitSegment.isImplicitRowCount(), () -> new UnsupportedSQLOperationException("Implicit FETCH row count"));
+        return new PaginationContext(offset, limitSegment.getRowCount().orElse(null), params);
     }
 }
diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinder.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinder.java
index f35ad59e4f1..ba5291d76a8 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinder.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinder.java
@@ -56,6 +56,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotE
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationDistinctProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationProjectionSegment;
@@ -63,6 +64,9 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.join.Oute
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlElementFunctionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlSerializeFunctionSegment;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
  * Expression segment binder.
  */
@@ -145,6 +149,9 @@ public final class ExpressionSegmentBinder {
         if (segment instanceof CollateExpression) {
             return CollateExpressionBinder.bind((CollateExpression) segment, parentSegmentType, binderContext, tableBinderContexts, outerTableBinderContexts);
         }
+        if (segment instanceof CommonExpressionSegment) {
+            return bindCommonExpression((CommonExpressionSegment) segment, parentSegmentType, binderContext, tableBinderContexts, outerTableBinderContexts);
+        }
         // TODO support more ExpressionSegment bound
         return segment;
     }
@@ -158,4 +165,17 @@ public final class ExpressionSegmentBinder {
         }
         return result;
     }
+    
+    private static CommonExpressionSegment bindCommonExpression(final CommonExpressionSegment segment, final SegmentType parentSegmentType, final SQLStatementBinderContext binderContext,
+                                                                final Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts,
+                                                                final Multimap<CaseInsensitiveString, TableSegmentBinderContext> outerTableBinderContexts) {
+        if (segment.getChildren().isEmpty()) {
+            return segment;
+        }
+        Collection<ExpressionSegment> children = new ArrayList<>(segment.getChildren().size());
+        for (ExpressionSegment each : segment.getChildren()) {
+            children.add(bind(each, parentSegmentType, binderContext, tableBinderContexts, outerTableBinderContexts));
+        }
+        return new CommonExpressionSegment(segment.getStartIndex(), segment.getStopIndex(), segment.getText(), children);
+    }
 }
diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinder.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinder.java
index 73c3d92d9e9..8ea0beb0146 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinder.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinder.java
@@ -45,6 +45,7 @@ public final class PrepareStatementQuerySegmentBinder {
         segment.getInsert().ifPresent(optional -> result.setInsert(new InsertStatementBinder().bind(optional, binderContext)));
         segment.getUpdate().ifPresent(optional -> result.setUpdate(new UpdateStatementBinder().bind(optional, binderContext)));
         segment.getDelete().ifPresent(optional -> result.setDelete(new DeleteStatementBinder().bind(optional, binderContext)));
+        result.setMerge(segment.getMerge().orElse(null));
         return result;
     }
 }
diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinder.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinder.java
index 841060696d5..e82e96e7255 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinder.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinder.java
@@ -31,6 +31,7 @@ import org.apache.shardingsphere.infra.binder.engine.segment.util.SubqueryTableB
 import org.apache.shardingsphere.infra.binder.engine.statement.SQLStatementBinderContext;
 import org.apache.shardingsphere.infra.binder.engine.statement.dml.SelectStatementBinder;
 import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
 import org.apache.shardingsphere.infra.exception.kernel.syntax.DifferenceInColumnCountOfSelectListAndColumnNameListException;
 import org.apache.shardingsphere.infra.exception.kernel.syntax.DuplicateCommonTableExpressionAliasException;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.TableSourceType;
@@ -67,6 +68,7 @@ public final class CommonTableExpressionSegmentBinder {
      */
     public static CommonTableExpressionSegment bind(final CommonTableExpressionSegment segment, final SQLStatementBinderContext binderContext,
                                                     final Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts, final boolean recursive) {
+        ShardingSpherePreconditions.checkState(null == segment.getDataModification(), () -> new UnsupportedSQLOperationException("Data-modifying common table expressions"));
         if (segment.getAliasName().isPresent()) {
             ShardingSpherePreconditions.checkState(!binderContext.getCommonTableExpressionsSegmentsUniqueAliases().contains(segment.getAliasName().get()),
                     () -> new DuplicateCommonTableExpressionAliasException(segment.getAliasName().get()));
@@ -82,8 +84,8 @@ public final class CommonTableExpressionSegmentBinder {
         segment.getAliasSegment().ifPresent(subqueryTableSegment::setAlias);
         SubqueryTableSegment boundSubquerySegment =
                 SubqueryTableSegmentBinder.bind(subqueryTableSegment, binderContext, LinkedHashMultimap.create(), tableBinderContexts, true);
-        CommonTableExpressionSegment result = new CommonTableExpressionSegment(
-                segment.getStartIndex(), segment.getStopIndex(), boundSubquerySegment.getAliasSegment().orElse(null), boundSubquerySegment.getSubquery());
+        CommonTableExpressionSegment result = new CommonTableExpressionSegment(segment.getStartIndex(), segment.getStopIndex(), boundSubquerySegment.getAliasSegment().orElse(null),
+                boundSubquerySegment.getSubquery(), null);
         Multimap<CaseInsensitiveString, TableSegmentBinderContext> currentTableBinderContexts =
                 createCurrentTableBinderContexts(segment.getColumns(), binderContext, boundSubquerySegment.getSubquery());
         segment.getColumns().forEach(each -> result.getColumns().add(ColumnSegmentBinder.bind(each,
diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinder.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinder.java
index adce6f6e1da..3b880142ac6 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinder.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinder.java
@@ -52,6 +52,7 @@ public final class PrepareStatementBinder implements SQLStatementBinder<PrepareS
                 .insert(boundInsert)
                 .update(boundUpdate)
                 .delete(boundDelete)
+                .merge(sqlStatement.getMerge().orElse(null))
                 .build();
         SQLStatementCopyUtils.copyAttributes(sqlStatement, result);
         return result;
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/insert/keygen/engine/GeneratedKeyContextEngineTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/insert/keygen/engine/GeneratedKeyContextEngineTest.java
index 15c91ae47bf..4b4a4a6eff9 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/insert/keygen/engine/GeneratedKeyContextEngineTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/insert/keygen/engine/GeneratedKeyContextEngineTest.java
@@ -95,7 +95,7 @@ class GeneratedKeyContextEngineTest {
                 .values(Arrays.asList(new InsertValuesSegment(0, 0, Collections.singletonList(new ParameterMarkerExpressionSegment(1, 2, 0))),
                         new InsertValuesSegment(0, 0, Collections.singletonList(new LiteralExpressionSegment(1, 2, 100))),
                         new InsertValuesSegment(0, 0, Collections.singletonList(new LiteralExpressionSegment(1, 2, "value"))),
-                        new InsertValuesSegment(0, 0, Collections.singletonList(new CommonExpressionSegment(1, 2, "ignored value")))))
+                        new InsertValuesSegment(0, 0, Collections.singletonList(new CommonExpressionSegment(1, 2, "ignored value", Collections.emptyList())))))
                 .build();
         List<InsertValueContext> insertValueContexts = insertStatement.getValues().stream()
                 .map(each -> new InsertValueContext(each.getValues(), Collections.emptyList(), 0)).collect(Collectors.toList());
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngineTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngineTest.java
index 532857e028f..e0d8c82c266 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngineTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/segment/select/pagination/engine/LimitPaginationContextEngineTest.java
@@ -18,6 +18,7 @@
 package org.apache.shardingsphere.infra.binder.context.segment.select.pagination.engine;
 
 import org.apache.shardingsphere.infra.binder.context.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.LimitSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.ParameterMarkerLimitValueSegment;
@@ -26,7 +27,11 @@ import org.junit.jupiter.api.Test;
 import java.util.Arrays;
 import java.util.Collections;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class LimitPaginationContextEngineTest {
@@ -52,4 +57,31 @@ class LimitPaginationContextEngineTest {
         PaginationContext paginationContext = paginationContextEngine.createPaginationContext(limitSegment, Arrays.asList(15L, 20L));
         assertTrue(paginationContext.isHasPagination());
     }
+    
+    @Test
+    void assertCreatePaginationContextWithImplicitRowCountWithoutOffset() {
+        LimitSegment limitSegment = new LimitSegment(0, 10, null, null);
+        limitSegment.setImplicitRowCount(true);
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class,
+                () -> paginationContextEngine.createPaginationContext(limitSegment, Collections.emptyList()));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Implicit FETCH row count."));
+    }
+    
+    @Test
+    void assertCreatePaginationContextWithImplicitRowCountAndOffset() {
+        NumberLiteralLimitValueSegment offset = new NumberLiteralLimitValueSegment(0, 10, 2L);
+        LimitSegment limitSegment = new LimitSegment(0, 20, offset, null);
+        limitSegment.setImplicitRowCount(true);
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class,
+                () -> paginationContextEngine.createPaginationContext(limitSegment, Collections.emptyList()));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Implicit FETCH row count."));
+    }
+    
+    @Test
+    void assertCreatePaginationContextWithOffsetOnly() {
+        NumberLiteralLimitValueSegment offset = new NumberLiteralLimitValueSegment(0, 10, 2L);
+        PaginationContext actual = paginationContextEngine.createPaginationContext(new LimitSegment(0, 20, offset, null), Collections.emptyList());
+        assertThat(actual.getOffsetSegment().orElseThrow(AssertionError::new), sameInstance(offset));
+        assertFalse(actual.getRowCountSegment().isPresent());
+    }
 }
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinderTest.java
index fc48be25604..d947a1695a1 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinderTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/expression/ExpressionSegmentBinderTest.java
@@ -21,31 +21,45 @@ import com.cedarsoftware.util.CaseInsensitiveMap.CaseInsensitiveString;
 import com.google.common.collect.LinkedHashMultimap;
 import com.google.common.collect.Multimap;
 import org.apache.shardingsphere.infra.binder.engine.segment.SegmentType;
+import org.apache.shardingsphere.infra.binder.engine.segment.dml.expression.type.ColumnSegmentBinder;
 import org.apache.shardingsphere.infra.binder.engine.segment.dml.expression.type.ExistsSubqueryExpressionBinder;
 import org.apache.shardingsphere.infra.binder.engine.segment.dml.expression.type.SubquerySegmentBinder;
 import org.apache.shardingsphere.infra.binder.engine.segment.dml.from.context.TableSegmentBinderContext;
 import org.apache.shardingsphere.infra.binder.engine.statement.SQLStatementBinderContext;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExistsSubqueryExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
 import org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicReference;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.hasItem;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @ExtendWith(AutoMockExtension.class)
-@StaticMockSettings({ExistsSubqueryExpressionBinder.class, SubquerySegmentBinder.class})
+@StaticMockSettings({ExistsSubqueryExpressionBinder.class, SubquerySegmentBinder.class, ColumnSegmentBinder.class})
 class ExpressionSegmentBinderTest {
     
     @Test
@@ -97,4 +111,61 @@ class ExpressionSegmentBinderTest {
         assertThat(mergedContexts.get().get(CaseInsensitiveString.of("t")), hasItem(currentTableBinderContext));
         assertThat(mergedContexts.get().get(CaseInsensitiveString.of("u")), contains(retainedOuterTableBinderContext));
     }
+    
+    @Test
+    void assertBindCommonExpression() {
+        ColumnSegment column = new ColumnSegment(0, 9, new IdentifierValue("foo_column"));
+        ColumnSegment boundColumn = new ColumnSegment(0, 9, new IdentifierValue("foo_column"));
+        SubquerySegment subquery = new SubquerySegment(13, 22, mock(SelectStatement.class), "(SELECT 1)");
+        SubquerySegment boundSubquery = new SubquerySegment(13, 22, mock(SelectStatement.class), "(SELECT 1)");
+        SubqueryExpressionSegment subqueryExpression = new SubqueryExpressionSegment(subquery);
+        ParameterMarkerExpressionSegment parameterMarker = new ParameterMarkerExpressionSegment(26, 26, 0);
+        CommonExpressionSegment segment = new CommonExpressionSegment(0, 26, "foo_column + (SELECT 1) + ?", Arrays.asList(column, subqueryExpression, parameterMarker));
+        SQLStatementBinderContext binderContext = mock(SQLStatementBinderContext.class);
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts = LinkedHashMultimap.create();
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> outerTableBinderContexts = LinkedHashMultimap.create();
+        when(ColumnSegmentBinder.bind(same(column), eq(SegmentType.PREDICATE), same(binderContext), same(tableBinderContexts), same(outerTableBinderContexts))).thenReturn(boundColumn);
+        when(SubquerySegmentBinder.bind(same(subquery), same(binderContext), any())).thenReturn(boundSubquery);
+        CommonExpressionSegment actual = (CommonExpressionSegment) ExpressionSegmentBinder.bind(segment, SegmentType.PREDICATE, binderContext, tableBinderContexts, outerTableBinderContexts);
+        assertThat(actual, not(sameInstance(segment)));
+        assertThat(actual.getStartIndex(), is(segment.getStartIndex()));
+        assertThat(actual.getStopIndex(), is(segment.getStopIndex()));
+        assertThat(actual.getText(), is(segment.getText()));
+        Iterator<ExpressionSegment> actualChildren = actual.getChildren().iterator();
+        assertThat(actualChildren.next(), sameInstance(boundColumn));
+        assertThat(((SubqueryExpressionSegment) actualChildren.next()).getSubquery(), sameInstance(boundSubquery));
+        assertThat(actualChildren.next(), sameInstance(parameterMarker));
+        assertFalse(actualChildren.hasNext());
+        assertThat(segment.getChildren(), contains(column, subqueryExpression, parameterMarker));
+        assertThat(subqueryExpression.getSubquery(), sameInstance(subquery));
+    }
+    
+    @Test
+    void assertBindNestedCommonExpression() {
+        ColumnSegment column = new ColumnSegment(1, 10, new IdentifierValue("foo_column"));
+        ColumnSegment boundColumn = new ColumnSegment(1, 10, new IdentifierValue("foo_column"));
+        CommonExpressionSegment nestedSegment = new CommonExpressionSegment(1, 10, "foo_column", Collections.singleton(column));
+        CommonExpressionSegment segment = new CommonExpressionSegment(0, 11, "(foo_column)", Collections.singleton(nestedSegment));
+        SQLStatementBinderContext binderContext = mock(SQLStatementBinderContext.class);
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts = LinkedHashMultimap.create();
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> outerTableBinderContexts = LinkedHashMultimap.create();
+        when(ColumnSegmentBinder.bind(same(column), eq(SegmentType.PROJECTION), same(binderContext), same(tableBinderContexts), same(outerTableBinderContexts))).thenReturn(boundColumn);
+        CommonExpressionSegment actual = (CommonExpressionSegment) ExpressionSegmentBinder.bind(segment, SegmentType.PROJECTION, binderContext, tableBinderContexts, outerTableBinderContexts);
+        CommonExpressionSegment actualNestedSegment = (CommonExpressionSegment) actual.getChildren().iterator().next();
+        assertThat(actual, not(sameInstance(segment)));
+        assertThat(actualNestedSegment, not(sameInstance(nestedSegment)));
+        assertThat(actualNestedSegment.getStartIndex(), is(nestedSegment.getStartIndex()));
+        assertThat(actualNestedSegment.getStopIndex(), is(nestedSegment.getStopIndex()));
+        assertThat(actualNestedSegment.getText(), is(nestedSegment.getText()));
+        assertThat(actualNestedSegment.getChildren(), contains(boundColumn));
+        assertThat(segment.getChildren(), contains(nestedSegment));
+        assertThat(nestedSegment.getChildren(), contains(column));
+    }
+    
+    @Test
+    void assertBindEmptyCommonExpression() {
+        CommonExpressionSegment segment = new CommonExpressionSegment(0, 9, "foo_clause", Collections.emptyList());
+        assertThat(ExpressionSegmentBinder.bind(segment, SegmentType.PROJECTION, mock(SQLStatementBinderContext.class), LinkedHashMultimap.create(), LinkedHashMultimap.create()),
+                sameInstance(segment));
+    }
 }
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinderTest.java
new file mode 100644
index 00000000000..145c13c1239
--- /dev/null
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/prepare/PrepareStatementQuerySegmentBinderTest.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.binder.engine.segment.dml.prepare;
+
+import org.apache.shardingsphere.infra.binder.engine.statement.SQLStatementBinderContext;
+import org.apache.shardingsphere.infra.binder.engine.statement.dml.SelectStatementBinder;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.prepare.PrepareStatementQuerySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedConstruction;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockConstruction;
+import static org.mockito.Mockito.when;
+
+class PrepareStatementQuerySegmentBinderTest {
+    
+    @Test
+    void assertBindWithMerge() {
+        MergeStatement mergeStatement = mock(MergeStatement.class);
+        PrepareStatementQuerySegment segment = new PrepareStatementQuerySegment(6, 118);
+        segment.setMerge(mergeStatement);
+        PrepareStatementQuerySegment actual = PrepareStatementQuerySegmentBinder.bind(segment, mock(SQLStatementBinderContext.class));
+        assertThat(actual.getStartIndex(), is(6));
+        assertThat(actual.getStopIndex(), is(118));
+        assertThat(actual.getMerge().orElse(null), sameInstance(mergeStatement));
+        assertFalse(actual.getSelect().isPresent());
+        assertFalse(actual.getInsert().isPresent());
+        assertFalse(actual.getUpdate().isPresent());
+        assertFalse(actual.getDelete().isPresent());
+    }
+    
+    @Test
+    void assertBindWithSelect() {
+        SelectStatement selectStatement = mock(SelectStatement.class);
+        PrepareStatementQuerySegment segment = new PrepareStatementQuerySegment(6, 13);
+        segment.setSelect(selectStatement);
+        SQLStatementBinderContext binderContext = mock(SQLStatementBinderContext.class);
+        SelectStatement boundSelect = mock(SelectStatement.class);
+        try (
+                MockedConstruction<SelectStatementBinder> ignored = mockConstruction(SelectStatementBinder.class,
+                        (mock, context) -> when(mock.bind(selectStatement, binderContext)).thenReturn(boundSelect))) {
+            PrepareStatementQuerySegment actual = PrepareStatementQuerySegmentBinder.bind(segment, binderContext);
+            assertThat(actual.getStartIndex(), is(6));
+            assertThat(actual.getStopIndex(), is(13));
+            assertThat(actual.getSelect().orElse(null), sameInstance(boundSelect));
+            assertFalse(actual.getMerge().isPresent());
+        }
+    }
+}
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinderTest.java
new file mode 100644
index 00000000000..6ff835b28e7
--- /dev/null
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/segment/dml/with/CommonTableExpressionSegmentBinderTest.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.binder.engine.segment.dml.with;
+
+import com.cedarsoftware.util.CaseInsensitiveMap.CaseInsensitiveString;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.binder.engine.segment.dml.from.context.TableSegmentBinderContext;
+import org.apache.shardingsphere.infra.binder.engine.segment.dml.from.type.SubqueryTableSegmentBinder;
+import org.apache.shardingsphere.infra.binder.engine.segment.util.SubqueryTableBindUtils;
+import org.apache.shardingsphere.infra.binder.engine.statement.SQLStatementBinderContext;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
+import org.apache.shardingsphere.infra.hint.HintValueContext;
+import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
+import org.apache.shardingsphere.sql.parser.statement.core.enums.TableSourceType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SubqueryTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings({SubqueryTableSegmentBinder.class, SubqueryTableBindUtils.class})
+class CommonTableExpressionSegmentBinderTest {
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getDataModificationArguments")
+    void assertBindDataModification(final String name, final DMLStatement body, final boolean recursive) {
+        CommonTableExpressionSegment segment = new CommonTableExpressionSegment(0, 50, new AliasSegment(5, 11, new IdentifierValue("foo_cte")), null, body);
+        SQLStatementBinderContext binderContext = new SQLStatementBinderContext(mock(ShardingSphereMetaData.class), "foo_db", new HintValueContext(), body);
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts = LinkedHashMultimap.create();
+        UnsupportedSQLOperationException actual = assertThrows(UnsupportedSQLOperationException.class,
+                () -> CommonTableExpressionSegmentBinder.bind(segment, binderContext, tableBinderContexts, recursive));
+        assertThat(actual.getMessage(), is("Unsupported SQL operation: Data-modifying common table expressions."));
+        assertTrue(binderContext.getCommonTableExpressionsSegmentsUniqueAliases().isEmpty());
+        assertTrue(binderContext.getExternalTableBinderContexts().isEmpty());
+        assertTrue(tableBinderContexts.isEmpty());
+    }
+    
+    private static Stream<Arguments> getDataModificationArguments() {
+        return Stream.of(
+                Arguments.of("INSERT", InsertStatement.builder().build(), false),
+                Arguments.of("UPDATE", UpdateStatement.builder().build(), true),
+                Arguments.of("DELETE", DeleteStatement.builder().build(), false),
+                Arguments.of("MERGE", MergeStatement.builder().build(), true));
+    }
+    
+    @Test
+    void assertBindSelect() {
+        ProjectionSegment projection = new ColumnProjectionSegment(new ColumnSegment(27, 36, new IdentifierValue("foo_column")));
+        ProjectionsSegment projections = new ProjectionsSegment(20, 36);
+        projections.getProjections().add(projection);
+        DatabaseType databaseType = mock(DatabaseType.class);
+        SelectStatement select = SelectStatement.builder().databaseType(databaseType).projections(projections).build();
+        AliasSegment alias = new AliasSegment(5, 11, new IdentifierValue("foo_cte"));
+        SelectStatement boundSelect = SelectStatement.builder().databaseType(databaseType).projections(projections).build();
+        SubquerySegment boundSubquery = new SubquerySegment(20, 36, boundSelect, "SELECT foo_column");
+        SubqueryTableSegment boundTable = new SubqueryTableSegment(0, 50, boundSubquery);
+        boundTable.setAlias(alias);
+        SQLStatementBinderContext binderContext = new SQLStatementBinderContext(mock(ShardingSphereMetaData.class), "foo_db", new HintValueContext(), select);
+        Multimap<CaseInsensitiveString, TableSegmentBinderContext> tableBinderContexts = LinkedHashMultimap.create();
+        when(SubqueryTableSegmentBinder.bind(any(), eq(binderContext), any(), eq(tableBinderContexts), eq(true))).thenReturn(boundTable);
+        when(SubqueryTableBindUtils.createSubqueryProjections(projections.getProjections(), new IdentifierValue(""), databaseType, TableSourceType.TEMPORARY_TABLE))
+                .thenReturn(Collections.singleton(projection));
+        CommonTableExpressionSegment segment = new CommonTableExpressionSegment(0, 50, alias, new SubquerySegment(20, 36, select, "SELECT foo_column"), null);
+        CommonTableExpressionSegment actual = CommonTableExpressionSegmentBinder.bind(segment, binderContext, tableBinderContexts, false);
+        assertThat(actual.getStartIndex(), is(0));
+        assertThat(actual.getStopIndex(), is(50));
+        assertThat(actual.getAliasSegment().orElse(null), sameInstance(alias));
+        assertThat(actual.getSubquery(), sameInstance(boundSubquery));
+        assertNull(actual.getDataModification());
+        assertThat(binderContext.getCommonTableExpressionsSegmentsUniqueAliases(), contains("foo_cte"));
+        Collection<TableSegmentBinderContext> actualContexts = binderContext.getExternalTableBinderContexts().get(CaseInsensitiveString.of("foo_cte"));
+        assertThat(actualContexts.size(), is(1));
+        TableSegmentBinderContext actualTableBinderContext = actualContexts.iterator().next();
+        assertThat(actualTableBinderContext.getTableSourceType(), is(TableSourceType.TEMPORARY_TABLE));
+        assertThat(actualTableBinderContext.getProjectionSegments(), contains(projection));
+    }
+}
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinderTest.java
index 1c756a33598..4e4eb3796e9 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinderTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/ddl/PrepareStatementBinderTest.java
@@ -25,11 +25,15 @@ import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
 import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
 import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionWithParamsSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ShorthandProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.PrepareStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.junit.jupiter.api.Test;
@@ -41,6 +45,7 @@ import java.util.Collections;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.eq;
@@ -85,6 +90,7 @@ class PrepareStatementBinderTest {
         assertFalse(actual.getInsert().isPresent());
         assertFalse(actual.getUpdate().isPresent());
         assertFalse(actual.getDelete().isPresent());
+        assertFalse(actual.getMerge().isPresent());
     }
     
     @Test
@@ -99,6 +105,26 @@ class PrepareStatementBinderTest {
         assertFalse(actual.getInsert().isPresent());
         assertFalse(actual.getUpdate().isPresent());
         assertFalse(actual.getDelete().isPresent());
+        assertFalse(actual.getMerge().isPresent());
+    }
+    
+    @Test
+    void assertBindWithMerge() {
+        SimpleTableSegment target = new SimpleTableSegment(new TableNameSegment(10, 19, new IdentifierValue("foo_target")));
+        SimpleTableSegment source = new SimpleTableSegment(new TableNameSegment(26, 35, new IdentifierValue("bar_source")));
+        ExpressionWithParamsSegment condition = new ExpressionWithParamsSegment(40, 43, new LiteralExpressionSegment(40, 43, true));
+        MergeStatement mergeStatement = MergeStatement.builder().databaseType(databaseType).target(target).source(source).expression(condition).build();
+        PrepareStatement prepareStatement = PrepareStatement.builder().databaseType(databaseType).merge(mergeStatement).build();
+        SQLStatementBinderContext binderContext = new SQLStatementBinderContext(metaData, "foo_db_1", new HintValueContext(), prepareStatement);
+        PrepareStatement actual = new PrepareStatementBinder().bind(prepareStatement, binderContext);
+        assertThat(actual.getDatabaseType(), is(databaseType));
+        assertThat(actual.getMerge().orElse(null), sameInstance(mergeStatement));
+        assertThat(actual.getAttributes().findAttribute(TableSQLStatementAttribute.class).get().getTables(),
+                is(prepareStatement.getAttributes().findAttribute(TableSQLStatementAttribute.class).get().getTables()));
+        assertFalse(actual.getSelect().isPresent());
+        assertFalse(actual.getInsert().isPresent());
+        assertFalse(actual.getUpdate().isPresent());
+        assertFalse(actual.getDelete().isPresent());
     }
     
     private SelectStatement createSelectStatement() {
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/DeleteStatementBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/DeleteStatementBinderTest.java
index 82293542d0f..f8d8a34042b 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/DeleteStatementBinderTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/DeleteStatementBinderTest.java
@@ -111,7 +111,7 @@ class DeleteStatementBinderTest {
     private WithSegment createWithSegment() {
         return new WithSegment(0, 0, new LinkedList<>(Collections.singletonList(
                 new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("combined_users")),
-                        new SubquerySegment(0, 0, createWithSelectStatement(), "")))),
+                        new SubquerySegment(0, 0, createWithSelectStatement(), ""), null))),
                 false);
     }
     
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/SelectStatementBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/SelectStatementBinderTest.java
index a5521e5f34a..fcdc716e627 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/SelectStatementBinderTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/SelectStatementBinderTest.java
@@ -279,8 +279,8 @@ class SelectStatementBinderTest {
         withProjections.getProjections().add(new ColumnProjectionSegment(new ColumnSegment(0, 0, new IdentifierValue("email"))));
         SelectStatement withSelectStatement = SelectStatement.builder().databaseType(databaseType).projections(withProjections)
                 .from(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_user")))).build();
-        CommonTableExpressionSegment commonTableExpressionSegment = new CommonTableExpressionSegment(
-                0, 0, new AliasSegment(0, 0, new IdentifierValue("t_user")), new SubquerySegment(0, 0, withSelectStatement, ""));
+        CommonTableExpressionSegment commonTableExpressionSegment = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("t_user")),
+                new SubquerySegment(0, 0, withSelectStatement, ""), null);
         WithSegment withSegment = new WithSegment(0, 0, new LinkedList<>(Collections.singleton(commonTableExpressionSegment)), false);
         ProjectionsSegment projections = new ProjectionsSegment(0, 0);
         projections.getProjections().add(new ShorthandProjectionSegment(0, 0));
@@ -528,7 +528,7 @@ class SelectStatementBinderTest {
     }
     
     private CommonTableExpressionSegment createCommonTableExpression(final String alias, final SelectStatement selectStatement) {
-        return new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue(alias)), new SubquerySegment(0, 0, selectStatement, ""));
+        return new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue(alias)), new SubquerySegment(0, 0, selectStatement, ""), null);
     }
     
     private ProjectionsSegment createOrderProjections() {
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/UpdateStatementBinderTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/UpdateStatementBinderTest.java
index b1259c2d54b..fa94668f570 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/UpdateStatementBinderTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/engine/statement/dml/UpdateStatementBinderTest.java
@@ -185,7 +185,7 @@ class UpdateStatementBinderTest {
     private WithSegment createWithSegment() {
         return new WithSegment(0, 0, new LinkedList<>(Collections.singletonList(
                 new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("combined_users")),
-                        new SubquerySegment(0, 0, createWithSelectStatement(), "")))),
+                        new SubquerySegment(0, 0, createWithSelectStatement(), ""), null))),
                 false);
     }
     
diff --git a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverter.java b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverter.java
index 2571543dcd4..2501a7ffd48 100644
--- a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverter.java
+++ b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverter.java
@@ -20,11 +20,14 @@ package org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.segme
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlWith;
 import org.apache.calcite.sql.SqlWithItem;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
@@ -55,9 +58,12 @@ public final class WithConverter {
     private static SqlNodeList convertWithItem(final Collection<CommonTableExpressionSegment> commonTableExpressionSegments) {
         SqlNodeList result = new SqlNodeList(SqlParserPos.ZERO);
         for (CommonTableExpressionSegment each : commonTableExpressionSegments) {
+            ShardingSpherePreconditions.checkState(null == each.getDataModification(), () -> new UnsupportedSQLOperationException("Data-modifying common table expressions in SQL Federation"));
+            ShardingSpherePreconditions.checkState(each.getSearchColumns().isEmpty() && each.getCycleColumns().isEmpty(),
+                    () -> new UnsupportedSQLOperationException("SEARCH or CYCLE clauses in SQL Federation"));
             SqlIdentifier name = new SqlIdentifier(each.getAliasName().orElse(""), SqlParserPos.ZERO);
             SqlNodeList columns = each.getColumns().isEmpty() ? null : convertColumns(each.getColumns());
-            result.add(new SqlWithItem(SqlParserPos.ZERO, name, columns, new SelectStatementConverter().convert(each.getSubquery().getSelect())));
+            result.add(new SqlWithItem(SqlParserPos.ZERO, name, columns, new SelectStatementConverter().convert(each.getSubquery().getSelect()), SqlLiteral.createBoolean(false, SqlParserPos.ZERO)));
         }
         return result;
     }
diff --git a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverter.java b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverter.java
index a39d10a4b49..a460910b8b0 100644
--- a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverter.java
+++ b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverter.java
@@ -63,6 +63,7 @@ public final class SelectStatementConverter implements SQLStatementConverter<Sel
         SqlNodeList orderBy = selectStatement.getOrderBy().flatMap(OrderByConverter::convert).orElse(SqlNodeList.EMPTY);
         Optional<LimitSegment> limit = selectStatement.getLimit();
         if (limit.isPresent()) {
+            ShardingSpherePreconditions.checkState(!limit.get().isImplicitRowCount(), () -> new UnsupportedSQLOperationException("Implicit FETCH row count in SQL Federation"));
             SqlNode offset = limit.get().getOffset().flatMap(PaginationValueSQLConverter::convert).orElse(null);
             SqlNode rowCount = limit.get().getRowCount().flatMap(PaginationValueSQLConverter::convert).orElse(null);
             return new SqlOrderBy(SqlParserPos.ZERO, sqlCombine, orderBy, offset, rowCount);
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/ExpressionConverterTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/ExpressionConverterTest.java
index d272fd6fe0f..4a325db99b8 100644
--- a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/ExpressionConverterTest.java
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/ExpressionConverterTest.java
@@ -219,7 +219,7 @@ class ExpressionConverterTest {
     
     @Test
     void assertConvertThrowsUnsupportedForCommonExpression() {
-        CommonExpressionSegment expressionSegment = new CommonExpressionSegment(0, 0, "text");
+        CommonExpressionSegment expressionSegment = new CommonExpressionSegment(0, 0, "text", Collections.emptyList());
         UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> ExpressionConverter.convert(expressionSegment));
         assertThat(actualException.getMessage(), is("Unsupported SQL operation: unsupported CommonExpressionSegment."));
     }
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverterTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverterTest.java
new file mode 100644
index 00000000000..4e8859db8f5
--- /dev/null
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/with/WithConverterTest.java
@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.segment.with;
+
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlWith;
+import org.apache.calcite.sql.SqlWithItem;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
+import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.segment.expression.impl.ColumnConverter;
+import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.statement.type.SelectStatementConverter;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.MockedConstruction;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockConstruction;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ColumnConverter.class)
+class WithConverterTest {
+    
+    @Test
+    void assertConvertWithoutCommonTableExpressions() {
+        SqlNode expectedBody = mock(SqlNode.class);
+        SqlWith actual = (SqlWith) WithConverter.convert(new WithSegment(0, 30, Collections.emptyList()), expectedBody).orElseThrow(AssertionError::new);
+        assertTrue(actual.withList.isEmpty());
+        assertThat(actual.body, sameInstance(expectedBody));
+    }
+    
+    @Test
+    void assertConvertWithSelect() {
+        SelectStatement selectStatement = mock(SelectStatement.class);
+        CommonTableExpressionSegment commonTableExpression = createSelectCommonTableExpression(selectStatement);
+        SqlNode expectedQuery = mock(SqlNode.class);
+        SqlNode expectedBody = mock(SqlNode.class);
+        try (
+                MockedConstruction<SelectStatementConverter> ignored = mockConstruction(SelectStatementConverter.class,
+                        (mock, context) -> when(mock.convert(selectStatement)).thenReturn(expectedQuery))) {
+            SqlWith actual = (SqlWith) WithConverter.convert(new WithSegment(0, 30, Collections.singletonList(commonTableExpression)), expectedBody).orElseThrow(AssertionError::new);
+            assertThat(actual.withList.size(), is(1));
+            SqlWithItem actualItem = (SqlWithItem) actual.withList.get(0);
+            assertThat(actualItem.name.getSimple(), is("foo_cte"));
+            assertNull(actualItem.columnList);
+            assertThat(actualItem.query, sameInstance(expectedQuery));
+            assertFalse(actualItem.recursive.booleanValue());
+            assertThat(actual.body, sameInstance(expectedBody));
+        }
+    }
+    
+    private CommonTableExpressionSegment createSelectCommonTableExpression(final SelectStatement selectStatement) {
+        return new CommonTableExpressionSegment(0, 20, new AliasSegment(0, 6, new IdentifierValue("foo_cte")), new SubquerySegment(8, 20, selectStatement, ""), null);
+    }
+    
+    @Test
+    void assertConvertWithColumns() {
+        SelectStatement selectStatement = mock(SelectStatement.class);
+        CommonTableExpressionSegment commonTableExpression = createSelectCommonTableExpression(selectStatement);
+        ColumnSegment column = new ColumnSegment(0, 0, new IdentifierValue("foo_column"));
+        commonTableExpression.getColumns().add(column);
+        SqlIdentifier expectedColumn = new SqlIdentifier("foo_column", SqlParserPos.ZERO);
+        when(ColumnConverter.convert(column)).thenReturn(expectedColumn);
+        SqlNode expectedQuery = mock(SqlNode.class);
+        try (
+                MockedConstruction<SelectStatementConverter> ignored = mockConstruction(SelectStatementConverter.class,
+                        (mock, context) -> when(mock.convert(selectStatement)).thenReturn(expectedQuery))) {
+            SqlWith actual = (SqlWith) WithConverter.convert(new WithSegment(0, 30, Collections.singletonList(commonTableExpression)), mock(SqlNode.class)).orElseThrow(AssertionError::new);
+            SqlWithItem actualItem = (SqlWithItem) actual.withList.get(0);
+            assertThat(actualItem.columnList.size(), is(1));
+            assertThat(actualItem.columnList.get(0), sameInstance(expectedColumn));
+            assertThat(actualItem.query, sameInstance(expectedQuery));
+        }
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getSearchOrCycleArguments")
+    void assertConvertWithSearchOrCycle(final String name, final boolean search, final boolean cycle) {
+        CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(0, 40, new AliasSegment(0, 6, new IdentifierValue("foo_cte")),
+                new SubquerySegment(8, 20, mock(SelectStatement.class), ""), null);
+        ColumnSegment column = new ColumnSegment(12, 21, new IdentifierValue("foo_column"));
+        if (search) {
+            commonTableExpression.getSearchColumns().add(column);
+        }
+        if (cycle) {
+            commonTableExpression.getCycleColumns().add(column);
+        }
+        commonTableExpression.getColumns().add(new ColumnSegment(30, 39, new IdentifierValue("foo_generated")));
+        WithSegment withSegment = new WithSegment(0, 40, Collections.singletonList(commonTableExpression));
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> WithConverter.convert(withSegment, mock(SqlNode.class)));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: SEARCH or CYCLE clauses in SQL Federation."));
+    }
+    
+    private static Stream<Arguments> getSearchOrCycleArguments() {
+        return Stream.of(Arguments.of("SEARCH", true, false), Arguments.of("CYCLE", false, true), Arguments.of("SEARCH and CYCLE", true, true));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getDataModificationArguments")
+    void assertConvertWithDataModification(final String name, final DMLStatement dataModification) {
+        CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(0, 20, new AliasSegment(0, 6, new IdentifierValue("foo_cte")), null, dataModification);
+        WithSegment withSegment = new WithSegment(0, 30, Collections.singletonList(commonTableExpression));
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> WithConverter.convert(withSegment, mock(SqlNode.class)));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Data-modifying common table expressions in SQL Federation."));
+    }
+    
+    private static Stream<Arguments> getDataModificationArguments() {
+        return Stream.of(
+                Arguments.of("INSERT", InsertStatement.builder().build()),
+                Arguments.of("UPDATE", UpdateStatement.builder().build()),
+                Arguments.of("DELETE", DeleteStatement.builder().build()),
+                Arguments.of("MERGE", MergeStatement.builder().build()));
+    }
+    
+    @Test
+    void assertConvertWithDataModificationAfterSelect() {
+        SelectStatement selectStatement = mock(SelectStatement.class);
+        CommonTableExpressionSegment select = createSelectCommonTableExpression(selectStatement);
+        CommonTableExpressionSegment dataModification = new CommonTableExpressionSegment(21, 40, new AliasSegment(21, 27, new IdentifierValue("bar_cte")), null, UpdateStatement.builder().build());
+        WithSegment withSegment = new WithSegment(0, 50, Arrays.asList(select, dataModification));
+        try (
+                MockedConstruction<SelectStatementConverter> ignored = mockConstruction(SelectStatementConverter.class,
+                        (mock, context) -> when(mock.convert(selectStatement)).thenReturn(mock(SqlNode.class)))) {
+            UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> WithConverter.convert(withSegment, mock(SqlNode.class)));
+            assertThat(actualException.getMessage(), is("Unsupported SQL operation: Data-modifying common table expressions in SQL Federation."));
+        }
+    }
+}
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/DeleteStatementConverterTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/DeleteStatementConverterTest.java
index 6f08a963d9d..cba92f47669 100644
--- a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/DeleteStatementConverterTest.java
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/DeleteStatementConverterTest.java
@@ -206,8 +206,7 @@ class DeleteStatementConverterTest {
         ProjectionsSegment projectionsSegment = new ProjectionsSegment(0, 0);
         projectionsSegment.getProjections().add(new ColumnProjectionSegment(new ColumnSegment(0, 0, new IdentifierValue("col"))));
         SelectStatement selectStatement = SelectStatement.builder().databaseType(databaseType).projections(projectionsSegment).build();
-        CommonTableExpressionSegment cte = new CommonTableExpressionSegment(
-                0, 0, new AliasSegment(0, 0, new IdentifierValue("cte")), new SubquerySegment(0, 0, selectStatement, "subquery"));
+        CommonTableExpressionSegment cte = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("cte")), new SubquerySegment(0, 0, selectStatement, "subquery"), null);
         return new WithSegment(0, 0, Collections.singleton(cte), false);
     }
     
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
index d0ad3269b78..6fc48dd98fc 100644
--- a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
@@ -114,6 +114,41 @@ class SelectStatementConverterTest {
         assertThat(new SelectStatementConverter().convert(selectStatement), isA(SqlSelect.class));
     }
     
+    @Test
+    void assertConvertImplicitRowCountWithoutOffset() {
+        LimitSegment limit = new LimitSegment(0, 10, null, null);
+        limit.setImplicitRowCount(true);
+        SelectStatement selectStatement = SelectStatement.builder().databaseType(databaseType).projections(createProjectionsSegment()).limit(limit).build();
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> new SelectStatementConverter().convert(selectStatement));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Implicit FETCH row count in SQL Federation."));
+    }
+    
+    @Test
+    void assertConvertImplicitRowCountAndOffset() {
+        LimitSegment limit = new LimitSegment(0, 20, new NumberLiteralLimitValueSegment(0, 10, 2L), null);
+        limit.setImplicitRowCount(true);
+        SelectStatement selectStatement = SelectStatement.builder().databaseType(databaseType).projections(createProjectionsSegment()).limit(limit).build();
+        UnsupportedSQLOperationException actualException = assertThrows(UnsupportedSQLOperationException.class, () -> new SelectStatementConverter().convert(selectStatement));
+        assertThat(actualException.getMessage(), is("Unsupported SQL operation: Implicit FETCH row count in SQL Federation."));
+    }
+    
+    @Test
+    void assertConvertOffsetWithoutRowCount() {
+        LimitSegment limit = new LimitSegment(0, 20, new NumberLiteralLimitValueSegment(0, 10, 2L), null);
+        SelectStatement selectStatement = SelectStatement.builder().databaseType(databaseType).projections(createProjectionsSegment()).limit(limit).build();
+        SqlOrderBy actual = (SqlOrderBy) new SelectStatementConverter().convert(selectStatement);
+        assertThat(actual.offset.toString(), is("2"));
+        assertNull(actual.fetch);
+    }
+    
+    @Test
+    void assertConvertUnlimitedRowCount() {
+        SelectStatement selectStatement = SelectStatement.builder().databaseType(databaseType).projections(createProjectionsSegment()).limit(new LimitSegment(0, 10, null, null)).build();
+        SqlOrderBy actual = (SqlOrderBy) new SelectStatementConverter().convert(selectStatement);
+        assertNull(actual.offset);
+        assertNull(actual.fetch);
+    }
+    
     private SelectStatement createBaseSelect(final boolean withWithSegment, final boolean distinct) {
         return createBaseSelect(databaseType, withWithSegment, distinct, null, null, null, null);
     }
diff --git a/mcp/core/src/main/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/SQLStatementTreeWalker.java b/mcp/core/src/main/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/SQLStatementTreeWalker.java
index a6f77d2ca0d..9bbd71c03ff 100644
--- a/mcp/core/src/main/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/SQLStatementTreeWalker.java
+++ b/mcp/core/src/main/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/SQLStatementTreeWalker.java
@@ -18,6 +18,8 @@
 package org.apache.shardingsphere.mcp.core.tool.handler.execute;
 
 import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
+import org.apache.shardingsphere.mcp.core.protocol.exception.MCPUnsupportedSQLStatementException;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.ColumnAssignmentSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.CombineSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.datetime.DatetimeExpression;
@@ -38,6 +40,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowE
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ValuesExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationProjectionSegment;
@@ -232,7 +235,10 @@ final class SQLStatementTreeWalker {
     }
     
     private void walkWith(final WithSegment with) {
-        with.getCommonTableExpressions().forEach(each -> walk(each.getSubquery().getSelect()));
+        with.getCommonTableExpressions().forEach(each -> {
+            ShardingSpherePreconditions.checkState(null == each.getDataModification(), MCPUnsupportedSQLStatementException::new);
+            walk(each.getSubquery().getSelect());
+        });
     }
     
     private void walkCombine(final CombineSegment combine) {
@@ -335,6 +341,8 @@ final class SQLStatementTreeWalker {
         expressionConsumer.accept(expression);
         if (expression instanceof FunctionSegment) {
             walkFunction((FunctionSegment) expression);
+        } else if (expression instanceof CommonExpressionSegment) {
+            ((CommonExpressionSegment) expression).getChildren().forEach(this::walkExpression);
         } else if (expression instanceof AggregationProjectionSegment) {
             AggregationProjectionSegment aggregation = (AggregationProjectionSegment) expression;
             aggregation.getParameters().forEach(this::walkExpression);
diff --git a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeTest.java b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeTest.java
index 89959bcf41b..b56a102e8ec 100644
--- a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeTest.java
+++ b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeTest.java
@@ -379,7 +379,7 @@ class MCPSQLExecutionFacadeTest {
         WindowItemSegment item = new WindowItemSegment(0, 0);
         item.setPartitionListSegments(List.of(createCurrentFunction("foo_partition")));
         item.setOrderBySegment(expressionOrder(createCurrentFunction("foo_order")));
-        item.setFrameClause(new CommonExpressionSegment(0, 0, "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW"));
+        item.setFrameClause(new CommonExpressionSegment(0, 0, "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW", List.of()));
         AggregationProjectionSegment aggregation = new AggregationProjectionSegment(0, 0, AggregationType.SUM, "SUM(logic_db.foo_value())");
         aggregation.getParameters().add(createCurrentFunction("foo_value"));
         aggregation.setWindow(item);
diff --git a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPStatementAnalyzerTest.java b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPStatementAnalyzerTest.java
index 1721c4a4d2c..4c51451c4ed 100644
--- a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPStatementAnalyzerTest.java
+++ b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPStatementAnalyzerTest.java
@@ -252,6 +252,7 @@ class MCPStatementAnalyzerTest {
                         "SELECT 1 # @order_status := 1", "", ""),
                 Arguments.of("postgresql adjacent dash comment", "PostgreSQL", "SELECT 1--@order_status:=1", SupportedMCPStatement.QUERY, "SELECT",
                         "SELECT 1--@order_status:=1", "", ""),
+                Arguments.of("postgresql array subscript", "PostgreSQL", "SELECT (ARRAY[1, 2])[1]", SupportedMCPStatement.QUERY, "SELECT", "SELECT (ARRAY[1, 2])[1]", "", ""),
                 Arguments.of("postgresql dollar quoted literal", "PostgreSQL", "SELECT $$/*!80018 ANALYZE */; @order_status:=1$$", SupportedMCPStatement.QUERY, "SELECT",
                         "SELECT $$/*!80018 ANALYZE */; @order_status:=1$$", "", ""),
                 Arguments.of("opengauss tagged dollar quoted literal", "openGauss", "SELECT $tag$a;b$tag$", SupportedMCPStatement.QUERY, "SELECT",
@@ -366,6 +367,8 @@ class MCPStatementAnalyzerTest {
                         MCPBannedSQLStatementException.class, "Statement is banned by the MCP contract."),
                 Arguments.of("banned configuration mutation", "PostgreSQL", "SELECT set_config('search_path', 'public', false)", MCPBannedSQLStatementException.class,
                         "Statement is banned by the MCP contract."),
+                Arguments.of("banned configuration mutation in array subscript", "PostgreSQL", "SELECT (set_config('application_name', '{foo}', false)::text[])[1]",
+                        MCPBannedSQLStatementException.class, "Statement is banned by the MCP contract."),
                 Arguments.of("banned replication slot advance", "PostgreSQL", "SELECT pg_replication_slot_advance('order_slot', '0/1')",
                         MCPBannedSQLStatementException.class, "Statement is banned by the MCP contract."),
                 Arguments.of("banned wal switch", "PostgreSQL", "SELECT pg_switch_wal()", MCPBannedSQLStatementException.class,
diff --git a/parser/sql/engine/core/src/main/java/org/apache/shardingsphere/sql/parser/engine/core/database/visitor/SQLVisitorRule.java b/parser/sql/engine/core/src/main/java/org/apache/shardingsphere/sql/parser/engine/core/database/visitor/SQLVisitorRule.java
index a62af299e1f..a3b8d5c8cde 100644
--- a/parser/sql/engine/core/src/main/java/org/apache/shardingsphere/sql/parser/engine/core/database/visitor/SQLVisitorRule.java
+++ b/parser/sql/engine/core/src/main/java/org/apache/shardingsphere/sql/parser/engine/core/database/visitor/SQLVisitorRule.java
@@ -103,6 +103,22 @@ public enum SQLVisitorRule {
     
     CREATE_PROCEDURE("CreateProcedure", SQLStatementType.DDL),
     
+    CREATE_STATISTICS("CreateStatistics", SQLStatementType.DDL),
+    
+    CREATE_SUBSCRIPTION("CreateSubscription", SQLStatementType.DDL),
+    
+    CREATE_OPERATOR_CLASS("CreateOperatorClass", SQLStatementType.DDL),
+    
+    ALTER_OPERATOR_CLASS("AlterOperatorClass", SQLStatementType.DDL),
+    
+    CREATE_OPERATOR_FAMILY("CreateOperatorFamily", SQLStatementType.DDL),
+    
+    ALTER_OPERATOR_FAMILY("AlterOperatorFamily", SQLStatementType.DDL),
+    
+    ALTER_EVENT_TRIGGER("AlterEventTrigger", SQLStatementType.DDL),
+    
+    IMPORT_FOREIGN_SCHEMA("ImportForeignSchema", SQLStatementType.DDL),
+    
     CREATE_PACKAGE("CreatePackage", SQLStatementType.DDL),
     
     CREATE_PUBLICATION("CreatePublication", SQLStatementType.DDL),
@@ -183,6 +199,16 @@ public enum SQLVisitorRule {
     
     CREATE_SERVER("CreateServer", SQLStatementType.DDL),
     
+    CREATE_USER_MAPPING("CreateUserMapping", SQLStatementType.DDL),
+    
+    ALTER_USER_MAPPING("AlterUserMapping", SQLStatementType.DDL),
+    
+    DROP_USER_MAPPING("DropUserMapping", SQLStatementType.DDL),
+    
+    CREATE_TRANSFORM("CreateTransform", SQLStatementType.DDL),
+    
+    ALTER_LARGE_OBJECT("AlterLargeObject", SQLStatementType.DDL),
+    
     CREATE_SYNONYM("CreateSynonym", SQLStatementType.DDL),
     
     DROP_SYNONYM("DropSynonym", SQLStatementType.DDL),
diff --git a/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/ClickHouseStatementVisitor.java b/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/ClickHouseStatementVisitor.java
index 14eb4cbc6f5..e70da7ae9d0 100644
--- a/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/ClickHouseStatementVisitor.java
+++ b/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/ClickHouseStatementVisitor.java
@@ -348,7 +348,7 @@ public abstract class ClickHouseStatementVisitor extends ClickHouseStatementBase
             return new SubqueryExpressionSegment((SubquerySegment) astNode);
         }
         if (astNode instanceof OtherLiteralValue) {
-            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), ((OtherLiteralValue) astNode).getValue());
+            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), ((OtherLiteralValue) astNode).getValue(), Collections.emptyList());
         }
         return astNode;
     }
@@ -378,7 +378,7 @@ public abstract class ClickHouseStatementVisitor extends ClickHouseStatementBase
         if (null != ctx.columnName()) {
             return visit(ctx.columnName());
         }
-        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText());
+        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/type/ClickHouseDMLStatementVisitor.java b/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/type/ClickHouseDMLStatementVisitor.java
index fae71689bf5..ffe87279c07 100644
--- a/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/type/ClickHouseDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/clickhouse/src/main/java/org/apache/shardingsphere/sql/parser/engine/clickhouse/visitor/statement/type/ClickHouseDMLStatementVisitor.java
@@ -159,7 +159,7 @@ public final class ClickHouseDMLStatementVisitor extends ClickHouseStatementVisi
     @Override
     public ASTNode visitAssignmentValue(final ClickHouseStatementParser.AssignmentValueContext ctx) {
         ExprContext expr = ctx.expr();
-        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText()) : visit(expr);
+        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList()) : visit(expr);
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/doris/src/main/java/org/apache/shardingsphere/sql/parser/engine/doris/visitor/statement/DorisStatementVisitor.java b/parser/sql/engine/dialect/doris/src/main/java/org/apache/shardingsphere/sql/parser/engine/doris/visitor/statement/DorisStatementVisitor.java
index 2021107edfe..6cfcc6f83e2 100644
--- a/parser/sql/engine/dialect/doris/src/main/java/org/apache/shardingsphere/sql/parser/engine/doris/visitor/statement/DorisStatementVisitor.java
+++ b/parser/sql/engine/dialect/doris/src/main/java/org/apache/shardingsphere/sql/parser/engine/doris/visitor/statement/DorisStatementVisitor.java
@@ -890,7 +890,7 @@ public abstract class DorisStatementVisitor extends DorisStatementBaseVisitor<AS
     @Override
     public ASTNode visitCteClause(final CteClauseContext ctx) {
         CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (AliasSegment) visit(ctx.alias()),
-                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())));
+                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())), null);
         if (null != ctx.columnNames()) {
             CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(ctx.columnNames());
             result.getColumns().addAll(columns.getValue());
@@ -1123,7 +1123,8 @@ public abstract class DorisStatementVisitor extends DorisStatementBaseVisitor<AS
             result.setOrderBySegment((OrderBySegment) visit(ctx.orderByClause()));
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), getOriginalText(ctx.frameClause())));
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), getOriginalText(ctx.frameClause()),
+                    Collections.emptyList()));
         }
         return result;
     }
@@ -1443,7 +1444,7 @@ public abstract class DorisStatementVisitor extends DorisStatementBaseVisitor<AS
             visit(each);
         }
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
@@ -1782,12 +1783,12 @@ public abstract class DorisStatementVisitor extends DorisStatementBaseVisitor<AS
         if (null != expr) {
             ASTNode result = visit(expr);
             if (result instanceof ColumnSegment) {
-                return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+                return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
             } else {
                 return result;
             }
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/FirebirdStatementVisitor.java b/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/FirebirdStatementVisitor.java
index 17cd8598154..e952f1cc003 100644
--- a/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/FirebirdStatementVisitor.java
+++ b/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/FirebirdStatementVisitor.java
@@ -456,7 +456,7 @@ public abstract class FirebirdStatementVisitor extends FirebirdStatementBaseVisi
         if (null != ctx.variable()) {
             return visit(ctx.variable());
         }
-        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText());
+        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText(), Collections.emptyList());
     }
     
     @Override
@@ -702,7 +702,7 @@ public abstract class FirebirdStatementVisitor extends FirebirdStatementBaseVisi
     @Override
     public ASTNode visitCteClause(final CteClauseContext ctx) {
         CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (AliasSegment) visit(ctx.alias()),
-                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())));
+                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())), null);
         if (null != ctx.columnNames()) {
             CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(ctx.columnNames());
             result.getColumns().addAll(columns.getValue());
diff --git a/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/type/FirebirdDMLStatementVisitor.java b/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/type/FirebirdDMLStatementVisitor.java
index a93cbdb790b..7c66c049d50 100644
--- a/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/type/FirebirdDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/firebird/src/main/java/org/apache/shardingsphere/sql/parser/engine/firebird/visitor/statement/type/FirebirdDMLStatementVisitor.java
@@ -229,7 +229,7 @@ public final class FirebirdDMLStatementVisitor extends FirebirdStatementVisitor
         if (null != expr) {
             return visit(expr);
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/HiveStatementVisitor.java b/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/HiveStatementVisitor.java
index 4869085adbc..74ae60d4851 100644
--- a/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/HiveStatementVisitor.java
+++ b/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/HiveStatementVisitor.java
@@ -92,6 +92,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.value.literal.impl.St
 import org.apache.shardingsphere.sql.parser.statement.core.value.parametermarker.ParameterMarkerValue;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedList;
 
 /**
@@ -552,7 +553,7 @@ public abstract class HiveStatementVisitor extends HiveStatementBaseVisitor<ASTN
             visit(each);
         }
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/type/HiveDMLStatementVisitor.java b/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/type/HiveDMLStatementVisitor.java
index c066c435e29..58e512349f3 100644
--- a/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/type/HiveDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/hive/src/main/java/org/apache/shardingsphere/sql/parser/engine/hive/visitor/statement/type/HiveDMLStatementVisitor.java
@@ -332,7 +332,7 @@ public final class HiveDMLStatementVisitor extends HiveStatementVisitor implemen
     @Override
     public ASTNode visitCteClause(final CteClauseContext ctx) {
         CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), createAliasSegment(ctx.identifier()),
-                new SubquerySegment(ctx.subquery().start.getStartIndex(), ctx.subquery().stop.getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())));
+                new SubquerySegment(ctx.subquery().start.getStartIndex(), ctx.subquery().stop.getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())), null);
         if (null != ctx.columnNames()) {
             result.getColumns().addAll(((CollectionValue<ColumnSegment>) visit(ctx.columnNames())).getValue());
         }
@@ -493,7 +493,7 @@ public final class HiveDMLStatementVisitor extends HiveStatementVisitor implemen
         }
         if (null != ctx.windowSpecification().frameClause()) {
             result.setFrameClause(new CommonExpressionSegment(ctx.windowSpecification().frameClause().start.getStartIndex(), ctx.windowSpecification().frameClause().stop.getStopIndex(),
-                    ctx.windowSpecification().frameClause().getText()));
+                    ctx.windowSpecification().frameClause().getText(), Collections.emptyList()));
         }
         return result;
     }
@@ -508,7 +508,8 @@ public final class HiveDMLStatementVisitor extends HiveStatementVisitor implemen
             result.setOrderBySegment((OrderBySegment) visit(ctx.orderByClause()));
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().getStart().getStartIndex(), ctx.frameClause().getStop().getStopIndex(), ctx.frameClause().getText()));
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().getStart().getStartIndex(), ctx.frameClause().getStop().getStopIndex(), ctx.frameClause().getText(),
+                    Collections.emptyList()));
         }
         if (null != ctx.identifier()) {
             result.setWindowName(new IdentifierValue(ctx.identifier().getText()));
@@ -944,7 +945,7 @@ public final class HiveDMLStatementVisitor extends HiveStatementVisitor implemen
     public ASTNode visitMatchExpression(final MatchExpressionContext ctx) {
         visit(ctx.expr());
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
@@ -1372,7 +1373,7 @@ public final class HiveDMLStatementVisitor extends HiveStatementVisitor implemen
         if (null != expr) {
             return visit(expr);
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/MySQLStatementVisitor.java b/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/MySQLStatementVisitor.java
index a13c8fbc38d..a5c052b4052 100644
--- a/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/MySQLStatementVisitor.java
+++ b/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/MySQLStatementVisitor.java
@@ -876,7 +876,7 @@ public abstract class MySQLStatementVisitor extends MySQLStatementBaseVisitor<AS
     @Override
     public ASTNode visitCteClause(final CteClauseContext ctx) {
         CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (AliasSegment) visit(ctx.alias()),
-                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())));
+                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery())), null);
         if (null != ctx.columnNames()) {
             CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(ctx.columnNames());
             result.getColumns().addAll(columns.getValue());
@@ -1168,7 +1168,7 @@ public abstract class MySQLStatementVisitor extends MySQLStatementBaseVisitor<AS
             result.setOrderBySegment((OrderBySegment) visit(ctx.orderByClause()));
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText()));
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText(), Collections.emptyList()));
         }
         if (null != ctx.identifier()) {
             result.setWindowName(new IdentifierValue(ctx.identifier().getText()));
@@ -1563,7 +1563,7 @@ public abstract class MySQLStatementVisitor extends MySQLStatementBaseVisitor<AS
             visit(each);
         }
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
@@ -1963,7 +1963,7 @@ public abstract class MySQLStatementVisitor extends MySQLStatementBaseVisitor<AS
         if (null != expr) {
             return visit(expr);
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/type/MySQLDMLStatementVisitor.java b/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/type/MySQLDMLStatementVisitor.java
index bd4778c6d1e..53e31de6510 100644
--- a/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/type/MySQLDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/mysql/src/main/java/org/apache/shardingsphere/sql/parser/engine/mysql/visitor/statement/type/MySQLDMLStatementVisitor.java
@@ -62,6 +62,7 @@ import org.apache.shardingsphere.sql.parser.statement.mysql.dml.MySQLLoadDataSta
 import org.apache.shardingsphere.sql.parser.statement.mysql.dml.MySQLLoadXMLStatement;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -178,7 +179,7 @@ public final class MySQLDMLStatementVisitor extends MySQLStatementVisitor implem
             result.setOrderBySegment((OrderBySegment) visit(ctx.orderByClause()));
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText()));
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText(), Collections.emptyList()));
         }
         if (null != ctx.identifier()) {
             result.setWindowName(new IdentifierValue(ctx.identifier().getText()));
diff --git a/parser/sql/engine/dialect/opengauss/src/main/java/org/apache/shardingsphere/sql/parser/engine/opengauss/visitor/statement/OpenGaussStatementVisitor.java b/parser/sql/engine/dialect/opengauss/src/main/java/org/apache/shardingsphere/sql/parser/engine/opengauss/visitor/statement/OpenGaussStatementVisitor.java
index c55674c3445..7e336fd182d 100644
--- a/parser/sql/engine/dialect/opengauss/src/main/java/org/apache/shardingsphere/sql/parser/engine/opengauss/visitor/statement/OpenGaussStatementVisitor.java
+++ b/parser/sql/engine/dialect/opengauss/src/main/java/org/apache/shardingsphere/sql/parser/engine/opengauss/visitor/statement/OpenGaussStatementVisitor.java
@@ -330,7 +330,7 @@ public abstract class OpenGaussStatementVisitor extends OpenGaussStatementParser
         }
         super.visitAExpr(ctx);
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     private Optional<String> findBinaryOperator(final AExprContext ctx) {
@@ -432,7 +432,7 @@ public abstract class OpenGaussStatementVisitor extends OpenGaussStatementParser
         }
         super.visitCExpr(ctx);
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), text, Collections.emptyList());
     }
     
     private ExpressionSegment createSubqueryExpressionSegment(final CExprContext ctx) {
@@ -1034,7 +1034,8 @@ public abstract class OpenGaussStatementVisitor extends OpenGaussStatementParser
     public ASTNode visitCommonTableExpr(final CommonTableExprContext ctx) {
         CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (AliasSegment) visit(ctx.alias()),
                 new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.preparableStmt().select()),
-                        getOriginalText(ctx.preparableStmt().select())));
+                        getOriginalText(ctx.preparableStmt().select())),
+                null);
         if (null != ctx.optNameList().nameList()) {
             result.getColumns().addAll(generateUsingColumn(ctx.optNameList().nameList()));
         }
@@ -1179,7 +1180,7 @@ public abstract class OpenGaussStatementVisitor extends OpenGaussStatementParser
             result.setOrderBySegment(orderBySegment);
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText()));
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText(), Collections.emptyList()));
         }
     }
     
diff --git a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
index dbebd5bbe6d..a5337048377 100644
--- a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
+++ b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
@@ -732,10 +732,10 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
             return createBinaryOperationExpressionFromLike(ctx);
         }
         if (null != ctx.PRIOR()) {
-            return null == ctx.predicate() ? new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx)) : visit(ctx.predicate());
+            return null == ctx.predicate() ? new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), Collections.emptyList()) : visit(ctx.predicate());
         }
         if (null == ctx.bitExpr(0)) {
-            return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
+            return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), Collections.emptyList());
         }
         return visit(ctx.bitExpr(0));
     }
@@ -829,7 +829,7 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
             return new SubqueryExpressionSegment((SubquerySegment) astNode);
         }
         if (astNode instanceof OtherLiteralValue) {
-            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText());
+            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText(), Collections.emptyList());
         }
         return astNode;
     }
@@ -881,7 +881,7 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
     @Override
     public ASTNode visitPseudorecord(final PseudorecordContext ctx) {
         if (null == ctx.NEW() && null == ctx.OLD()) {
-            return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx));
+            return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx), Collections.emptyList());
         }
         ColumnSegment result = new ColumnSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
         int ownerStartIndex = null == ctx.NEW() ? ctx.OLD().getSymbol().getStartIndex() : ctx.NEW().getSymbol().getStartIndex();
@@ -926,7 +926,7 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
         for (SimpleExprContext each : ctx.simpleExpr()) {
             visit(each);
         }
-        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText());
+        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText(), Collections.emptyList());
     }
     
     @Override
@@ -1147,7 +1147,7 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
     
     @Override
     public ASTNode visitWindowingClause(final WindowingClauseContext ctx) {
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx));
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDMLStatementVisitor.java b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDMLStatementVisitor.java
index fbe5d8665ae..88575017e07 100644
--- a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDMLStatementVisitor.java
@@ -271,7 +271,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
             int startIndex = currentOfClause.CURRENT().getSymbol().getStartIndex();
             int stopIndex = currentOfClause.cursorName().stop.getStopIndex();
             result.where(new WhereSegment(currentOfClause.getStart().getStartIndex(), currentOfClause.getStop().getStopIndex(),
-                    new CommonExpressionSegment(startIndex, stopIndex, currentOfClause.start.getInputStream().getText(new Interval(startIndex, stopIndex)))));
+                    new CommonExpressionSegment(startIndex, stopIndex, currentOfClause.start.getInputStream().getText(new Interval(startIndex, stopIndex)), Collections.emptyList())));
         }
         if (null != ctx.returningClause()) {
             result.returning((ReturningSegment) visit(ctx.returningClause()));
@@ -350,7 +350,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
             SubqueryExpressionSegment value = new SubqueryExpressionSegment(subquerySegment);
             return new ColumnAssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), columnSegments, value);
         }
-        CommonExpressionSegment value = new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.DEFAULT().getText());
+        CommonExpressionSegment value = new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.DEFAULT().getText(), Collections.emptyList());
         return new ColumnAssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), columnSegments, value);
     }
     
@@ -528,7 +528,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
             int startIndex = currentOfClause.CURRENT().getSymbol().getStartIndex();
             int stopIndex = currentOfClause.cursorName().stop.getStopIndex();
             result.where(new WhereSegment(currentOfClause.getStart().getStartIndex(), currentOfClause.getStop().getStopIndex(),
-                    new CommonExpressionSegment(startIndex, stopIndex, currentOfClause.start.getInputStream().getText(new Interval(startIndex, stopIndex)))));
+                    new CommonExpressionSegment(startIndex, stopIndex, currentOfClause.start.getInputStream().getText(new Interval(startIndex, stopIndex)), Collections.emptyList())));
         }
         if (null != ctx.returningClause()) {
             result.returning((ReturningSegment) visit(ctx.returningClause()));
@@ -752,7 +752,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
     @Override
     public ASTNode visitAssignmentValue(final AssignmentValueContext ctx) {
         ExprContext expr = ctx.expr();
-        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText()) : visit(expr);
+        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList()) : visit(expr);
     }
     
     @Override
@@ -1012,7 +1012,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
                 SubquerySegment subquery = new SubquerySegment(each.selectSubquery().start.getStartIndex(), each.selectSubquery().stop.getStopIndex(), (SelectStatement) visit(each),
                         getOriginalText(each));
                 CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(each.start.getStartIndex(), each.stop.getStopIndex(),
-                        (AliasSegment) visit(each.queryName().alias()), subquery);
+                        (AliasSegment) visit(each.queryName().alias()), subquery, null);
                 addCommonTableExpressionColumns(commonTableExpression, each);
                 commonTableExpressions.add(commonTableExpression);
             }
@@ -1838,7 +1838,7 @@ public final class OracleDMLStatementVisitor extends OracleStatementVisitor impl
             return new SubqueryExpressionSegment(subquerySegment);
         }
         ExprContext expr = ctx.expr();
-        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText()) : visit(expr);
+        return null == expr ? new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList()) : visit(expr);
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
index 5a9f26664cb..e62df404188 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
@@ -23,8 +23,7 @@ options {
 
 parameterMarker
     : QUESTION_ literalsType?
-    // TODO Only digits allowed after $, not a number
-    | DOLLAR_ NUMBER_
+    | DOLLAR_ NUMBER_ {$NUMBER_.text.matches("[0-9]+") }?
     ;
 
 reservedKeyword
@@ -116,7 +115,7 @@ literalsType
     ;
 
 identifier
-    : UNICODE_ESCAPE? IDENTIFIER_ uescape? | unreservedWord
+    : UNICODE_ESCAPE? IDENTIFIER_ uescape? | unreservedWord | jsonFunctionKeyword
     ;
 
 uescape
@@ -146,6 +145,25 @@ unreservedWord
     | BY
     | BYTEA
     | BOX
+    | SMALLSERIAL
+    | SERIAL
+    | BIGSERIAL
+    | CIDR
+    | DATE
+    | FLOAT4
+    | FLOAT8
+    | FORMAT
+    | INET
+    | INT2
+    | INT4
+    | INT8
+    | LINE
+    | MACADDR
+    | MACADDR8
+    | MICROSECOND
+    | TSQUERY
+    | TSVECTOR
+    | VARBIT
     | CACHE
     | CALL
     | CALLED
@@ -166,6 +184,7 @@ unreservedWord
     | COMMITTED
     | CONFIGURATION
     | CONFLICT
+    | CONNECT
     | CONNECTION
     | CONSTRAINTS
     | CONTENT
@@ -268,10 +287,12 @@ unreservedWord
     | LOCK
     | LOCKED
     | LOGGED
+    | LOGIN
     | LSEG
     | MACADDR
     | MACADDR8
     | MAIN
+    | MAINTAIN
     | MAPPING
     | MATCH
     | MATCHED
@@ -301,6 +322,7 @@ unreservedWord
     | NOWAIT
     | NULLS
     | OBJECT
+    | OBJECTS
     | OF
     | OFF
     | OIDS
@@ -357,6 +379,7 @@ unreservedWord
     | RESET
     | RESTART
     | RESTRICT
+    | RETURN
     | RETURNS
     | REVOKE
     | ROLE
@@ -383,7 +406,7 @@ unreservedWord
     | SHARE
     | SHOW
     | SIMPLE
-//    | SKIP
+    | SKIP_SYMBOL
     | SNAPSHOT
     | SQL
     | STABLE
@@ -428,6 +451,7 @@ unreservedWord
     | UNLOGGED
     | UNTIL
     | UPDATE
+    | USAGE
     | VACUUM
     | VALID
     | VALIDATE
@@ -451,6 +475,34 @@ unreservedWord
     | YES
     | ZONE
     | JSON
+    | ABSENT
+    | ATOMIC
+    | BREADTH
+    | CONDITIONAL
+    | DEPTH
+    | EMPTY
+    | ENFORCED
+    | ERROR
+    | IGNORE
+    | INDENT
+    | KEEP
+    | KEYS
+    | LOG_VERBOSITY
+    | NESTED
+    | OMIT
+    | ON_ERROR
+    | PERIOD
+    | QUOTES
+    | REJECT_LIMIT
+    | SCALAR
+    | SILENT
+    | SOURCE
+    | STOP
+    | STRING
+    | TARGET
+    | UNCONDITIONAL
+    | UTF8
+    | VIRTUAL
     | PARAM
     | TABLE
     | CONSTRAINT
@@ -557,9 +609,9 @@ patternMatchingOperator
     | SIMILAR TO
     | NOT SIMILAR TO
     | TILDE_
-    | NOT_ TILDE_
-    | TILDE_ ASTERISK_
-    | NOT_ TILDE_ ASTERISK_
+    | REGEX_NOT_MATCH_
+    | REGEX_MATCH_CASE_INSENSITIVE_
+    | REGEX_NOT_MATCH_CASE_INSENSITIVE_
     ;
 
 cursorName
@@ -571,6 +623,7 @@ aExpr
     | aExpr TYPE_CAST_ typeName
     | aExpr COLLATE anyName
     | aExpr AT TIME ZONE aExpr
+    | aExpr AT LOCAL
     | PLUS_ aExpr
     | MINUS_ aExpr
     | aExpr PLUS_ aExpr
@@ -579,10 +632,11 @@ aExpr
     | aExpr SLASH_ aExpr
     | aExpr MOD_ aExpr
     | aExpr CARET_ aExpr
+    | TILDE_ aExpr
     | aExpr AMPERSAND_ aExpr
     | aExpr VERTICAL_BAR_ aExpr
     | aExpr qualOp aExpr
-    | qualOp aExpr
+    | {QUESTION_ != _input.LA(1)}? qualOp aExpr
     | aExpr qualOp
     | aExpr comparisonOperator aExpr
     | NOT aExpr
@@ -614,6 +668,7 @@ aExpr
     | UNIQUE selectWithParens
     | aExpr IS DOCUMENT
     | aExpr IS NOT DOCUMENT
+    | aExpr IS NOT? JSON jsonValueType? jsonUniqueKeys?
     | aExpr IS NORMALIZED
     | aExpr IS unicodeNormalForm NORMALIZED
     | aExpr IS NOT NORMALIZED
@@ -628,8 +683,12 @@ bExpr
     | bExpr TYPE_CAST_ typeName
     | PLUS_ bExpr
     | MINUS_ bExpr
+    | bExpr CARET_ bExpr
+    | bExpr (ASTERISK_ | SLASH_ | MOD_) bExpr
+    | bExpr (PLUS_ | MINUS_) bExpr
+    | TILDE_ bExpr
     | bExpr qualOp bExpr
-    | qualOp bExpr
+    | {QUESTION_ != _input.LA(1)}? qualOp bExpr
     | bExpr qualOp
     | bExpr IS DISTINCT FROM bExpr
     | bExpr IS NOT DISTINCT FROM bExpr
@@ -669,6 +728,7 @@ optIndirection
 indirectionEl
     : DOT_ attrName
     | DOT_ ASTERISK_
+    | DOT_ASTERISK_
     | LBT_ aExpr RBT_
     | LBT_ sliceBound? COLON_ sliceBound? RBT_
     ;
@@ -709,6 +769,10 @@ columnref
 qualOp
     : jsonOperator
     | geometricOperator
+    | CUSTOM_OPERATOR_
+    | NOT_
+    | AT_
+    | DEQ_
     | OPERATOR LP_ anyOperator RP_
     ;
 
@@ -717,8 +781,12 @@ subqueryOp
     | OPERATOR LP_ anyOperator RP_
     | LIKE
     | NOT LIKE
+    | ILIKE
+    | NOT ILIKE
     | TILDE_
-    | NOT_ TILDE_
+    | REGEX_NOT_MATCH_
+    | REGEX_MATCH_CASE_INSENSITIVE_
+    | REGEX_NOT_MATCH_CASE_INSENSITIVE_
     ;
 
 allOp
@@ -773,6 +841,9 @@ op
     | TYPE_CAST_
     | ILIKE_
     | NOT_ILIKE_
+    | REGEX_NOT_MATCH_
+    | REGEX_MATCH_CASE_INSENSITIVE_
+    | REGEX_NOT_MATCH_CASE_INSENSITIVE_
     | UNICODE_ESCAPE
     | JSON_EXTRACT_
     | JSON_EXTRACT_TEXT_
@@ -797,6 +868,7 @@ op
     | GEOMETRIC_INTERSECT_
     | GEOMETRIC_PERPENDICULAR_
     | GEOMETRIC_SAME_AS_ )+
+    | CUSTOM_OPERATOR_
     ;
 
 mathOperator
@@ -929,7 +1001,7 @@ paramName
 funcArgExpr
     : aExpr
     | paramName CQ_ aExpr
-    | paramName GTE_ aExpr
+    | paramName NAMED_ARGUMENT_ aExpr
     ;
 
 typeList
@@ -954,7 +1026,12 @@ funcName
 aexprConst
     : numberConst
     | STRING_
+    | UNICODE_ESCAPE STRING_ uescape?
+    | BIT_NUM_
+    | HEX_DIGIT_
     | BEGIN_DOLLAR_STRING_CONSTANT DOLLAR_TEXT* END_DOLLAR_STRING_CONSTANT
+    | INTERVAL STRING_ optInterval
+    | INTERVAL LP_ NUMBER_ RP_ STRING_ optInterval
     | funcName STRING_
     | funcName LP_ funcArgList sortClause? RP_ STRING_
     | constTypeName STRING_
@@ -964,7 +1041,7 @@ aexprConst
     ;
 
 numberConst
-    : (PLUS_ | MINUS_)? NUMBER_
+    : (PLUS_ | MINUS_)? (NUMBER_ | HEX_NUMBER_ | BINARY_NUMBER_ | OCTAL_NUMBER_)
     ;
 
 qualifiedName
@@ -972,7 +1049,7 @@ qualifiedName
     ;
 
 colId
-    : identifier
+    : identifier | colNameKeyword
     ;
 
 channelName
@@ -980,7 +1057,7 @@ channelName
     ;
 
 typeFunctionName
-    : identifier
+    : UNICODE_ESCAPE? IDENTIFIER_ uescape?
     | unreservedWord
     | typeFuncNameKeyword
     | INT4RANGE
@@ -1033,7 +1110,8 @@ xmlNamespaceEl
     ;
 
 funcExpr
-    : funcApplication withinGroupClause? filterClause? overClause?
+    : jsonAggregateFunction filterClause? overClause?
+    | funcApplication withinGroupClause? filterClause? overClause?
     | functionExprCommonSubexpr
     ;
 
@@ -1054,7 +1132,8 @@ ordinality
     ;
 
 functionExprCommonSubexpr
-    : COLLATION FOR LP_ aExpr RP_
+    : jsonFunction
+    | COLLATION FOR LP_ aExpr RP_
     | CURRENT_DATE
     | CURRENT_TIME
     | CURRENT_TIME LP_ NUMBER_ RP_
@@ -1097,7 +1176,122 @@ functionExprCommonSubexpr
     | XMLPI LP_ NAME identifier RP_
     | XMLPI LP_ NAME identifier COMMA_ aExpr RP_
     | XMLROOT LP_ aExpr COMMA_ xmlRootVersion xmlRootStandalone? RP_
-    | XMLSERIALIZE LP_ documentOrContent aExpr AS simpleTypeName RP_
+    | XMLSERIALIZE LP_ documentOrContent aExpr AS simpleTypeName (NO? INDENT)? RP_
+    ;
+
+jsonValueType
+    : VALUE | SCALAR | ARRAY | OBJECT
+    ;
+
+jsonFormat
+    : FORMAT JSON (ENCODING UTF8)?
+    ;
+
+jsonValueExpr
+    : aExpr jsonFormat?
+    ;
+
+jsonNullClause
+    : (NULL | ABSENT) ON NULL
+    ;
+
+jsonUniqueKeys
+    : (WITH | WITHOUT) UNIQUE KEYS?
+    ;
+
+jsonReturningClause
+    : RETURNING typeName jsonFormat?
+    ;
+
+jsonNameAndValue
+    : cExpr VALUE jsonValueExpr
+    | aExpr COLON_ jsonValueExpr
+    ;
+
+jsonFunction
+    : JSON_OBJECT LP_ funcArgList RP_
+    | JSON_OBJECT LP_ jsonNameAndValue (COMMA_ jsonNameAndValue)* jsonNullClause? jsonUniqueKeys? jsonReturningClause? RP_
+    | JSON_OBJECT LP_ jsonReturningClause? RP_
+    | JSON_ARRAY LP_ jsonValueExpr (COMMA_ jsonValueExpr)* jsonNullClause? jsonReturningClause? RP_
+    | JSON_ARRAY LP_ selectNoParens jsonFormat? jsonReturningClause? RP_
+    | JSON_ARRAY LP_ jsonReturningClause? RP_
+    | JSON LP_ jsonValueExpr jsonUniqueKeys? RP_
+    | JSON_SCALAR LP_ aExpr RP_
+    | JSON_SERIALIZE LP_ jsonValueExpr jsonReturningClause? RP_
+    | JSON_EXISTS LP_ jsonValueExpr COMMA_ aExpr jsonPassingClause? jsonExistsErrorClause? RP_
+    | JSON_VALUE LP_ jsonValueExpr COMMA_ aExpr jsonPassingClause? (RETURNING typeName)? jsonValueEmptyClause? jsonValueErrorClause? RP_
+    | JSON_QUERY LP_ jsonValueExpr COMMA_ aExpr jsonPassingClause? jsonReturningClause? jsonWrapperClause? jsonQuotesClause? jsonQueryEmptyClause? jsonQueryErrorClause? RP_
+    ;
+
+jsonAggregateFunction
+    : JSON_ARRAYAGG LP_ jsonValueExpr sortClause? jsonNullClause? jsonReturningClause? RP_
+    | JSON_OBJECTAGG LP_ jsonNameAndValue jsonNullClause? jsonUniqueKeys? jsonReturningClause? RP_
+    ;
+
+jsonPassingClause
+    : PASSING jsonPassingArgument (COMMA_ jsonPassingArgument)*
+    ;
+
+jsonPassingArgument
+    : aExpr AS colId
+    ;
+
+jsonWrapperClause
+    : WITHOUT ARRAY? WRAPPER
+    | WITH (CONDITIONAL | UNCONDITIONAL)? ARRAY? WRAPPER
+    ;
+
+jsonQuotesClause
+    : (KEEP | OMIT) QUOTES (ON SCALAR STRING)?
+    ;
+
+jsonValueBehavior
+    : ERROR | NULL | DEFAULT aExpr
+    ;
+
+jsonQueryBehavior
+    : jsonValueBehavior | EMPTY (ARRAY | OBJECT)?
+    ;
+
+jsonValueEmptyClause
+    : jsonValueBehavior ON EMPTY
+    ;
+
+jsonValueErrorClause
+    : jsonValueBehavior ON ERROR
+    ;
+
+jsonQueryEmptyClause
+    : jsonQueryBehavior ON EMPTY
+    ;
+
+jsonQueryErrorClause
+    : jsonQueryBehavior ON ERROR
+    ;
+
+jsonExistsErrorClause
+    : (ERROR | TRUE | FALSE | UNKNOWN) ON ERROR
+    ;
+
+jsonTable
+    : JSON_TABLE LP_ jsonValueExpr COMMA_ aExpr (AS colId)? jsonPassingClause? COLUMNS LP_ jsonTableColumn (COMMA_ jsonTableColumn)* RP_ jsonTableErrorClause? RP_
+    ;
+
+jsonTableColumn
+    : colId FOR ORDINALITY
+    | colId typeName jsonFormat? (PATH jsonTablePath)? jsonWrapperClause? jsonQuotesClause? jsonQueryEmptyClause? jsonQueryErrorClause?
+    | colId typeName EXISTS (PATH jsonTablePath)? jsonExistsErrorClause?
+    | NESTED PATH? jsonTablePath (AS colId)? COLUMNS LP_ jsonTableColumn (COMMA_ jsonTableColumn)* RP_
+    ;
+
+jsonTablePath
+    : STRING_
+    | UNICODE_ESCAPE STRING_ uescape?
+    | BEGIN_DOLLAR_STRING_CONSTANT DOLLAR_TEXT* END_DOLLAR_STRING_CONSTANT
+    ;
+
+jsonTableErrorClause
+    : (ERROR | EMPTY ARRAY?) ON ERROR
     ;
 
 typeName
@@ -1292,6 +1486,7 @@ substrList
     | aExpr substrFor substrFrom
     | aExpr substrFrom
     | aExpr substrFor
+    | aExpr SIMILAR aExpr ESCAPE aExpr
     | exprList
     |
     ;
@@ -1339,7 +1534,7 @@ xmlRootStandalone
     ;
 
 rowsFromItem
-    : functionExprWindowless columnDefList
+    : functionExprWindowless columnDefList?
     ;
 
 rowsFromList
@@ -1482,7 +1677,7 @@ defArg
     : funcType
     | reservedKeyword
     | qualAllOp
-    | NUMBER_
+    | numericOnly
     | STRING_
     | NONE
     | funcName (LP_ funcArgsList RP_ | LP_ RP_)
@@ -1546,6 +1741,19 @@ nonReservedWord
     | typeFuncNameKeyword
     ;
 
+jsonFunctionKeyword
+    : JSON_ARRAY
+    | JSON_ARRAYAGG
+    | JSON_EXISTS
+    | JSON_OBJECT
+    | JSON_OBJECTAGG
+    | JSON_QUERY
+    | JSON_SCALAR
+    | JSON_SERIALIZE
+    | JSON_TABLE
+    | JSON_VALUE
+    ;
+
 colNameKeyword
     : BETWEEN
     | BIGINT
@@ -1565,6 +1773,7 @@ colNameKeyword
     | INT
     | INTEGER
     | INTERVAL
+    | jsonFunctionKeyword
     | LEAST
     | NATIONAL
     | NCHAR
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DALStatement.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DALStatement.g4
index 88deadeb328..dbbe120d1b6 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DALStatement.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DALStatement.g4
@@ -53,7 +53,7 @@ configurationParameterClause
     ;
 
 resetParameter
-    : RESET (ALL | identifier)
+    : RESET (ALL | varName | SESSION AUTHORIZATION | TIME ZONE)
     ;
 
 explain
@@ -65,7 +65,16 @@ explain
     ;
 
 explainableStmt
-    : select | insert | update | delete | declare | executeStmt | createMaterializedView | refreshMatViewStmt
+    : select
+    | insert
+    | update
+    | delete
+    | merge
+    | declare
+    | executeStmt
+    | createTable {null != $createTable.ctx.AS()}?
+    | createMaterializedView
+    | refreshMatViewStmt
     ;
 
 explainOptionList
@@ -77,7 +86,7 @@ explainOptionElem
     ;
 
 explainOptionArg
-    : booleanOrString | numericOnly
+    : booleanOrString | numericOnly | JSON
     ;
 
 explainOptionName
@@ -97,7 +106,7 @@ vacuumRelationList
     ;
 
 vacuumRelation
-    : qualifiedName optNameList
+    : ONLY? qualifiedName optNameList
     ;
 
 vacAnalyzeOptionList
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DCLStatement.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DCLStatement.g4
index c261df598a1..2d8874bd64b 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DCLStatement.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DCLStatement.g4
@@ -26,11 +26,11 @@ grant
     ;
 
 revoke
-    : REVOKE optionForClause? (privilegeClause | roleClause) (CASCADE | RESTRICT)?
+    : REVOKE ((GRANT OPTION FOR)? privilegeClause | optionForClause? roleClause) (CASCADE | RESTRICT)?
     ;
 
 optionForClause
-    : (GRANT | ADMIN) OPTION FOR
+    : (ADMIN | INHERIT | SET) OPTION FOR
     ;
 
 createUser
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
index c6907a223e7..402aaa51cbb 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
@@ -25,8 +25,9 @@ createTable
     : CREATE createTableSpecification TABLE ifNotExists? tableName
       (createDefinitionClause | (OF anyName (LP_ typedTableElementList RP_)?) | (PARTITION OF qualifiedName (LP_ typedTableElementList RP_)? partitionBoundSpec))?
       inheritClause partitionSpec? tableAccessMethodClause? withOption? onCommitOption? tablespace?
-      (AS select withData?)?
-      (EXECUTE name executeParamClause withData?)?
+      (AS (select | EXECUTE name executeParamClause?) withData?)?
+    | CREATE createTableSpecification TABLE ifNotExists? tableName columnNames
+      tableAccessMethodClause? withOption? onCommitOption? tablespace? AS (select | EXECUTE name executeParamClause?) withData?
     ;
 
 executeParamClause
@@ -58,7 +59,7 @@ typedTableElement
     ;
 
 columnOptions
-    : colId (WITH OPTIONS)? colQualList
+    : colId (WITH OPTIONS)? (columnConstraint | collateClause)*
     ;
 
 colQualList
@@ -91,7 +92,7 @@ accessMethod
 
 createIndex
     : CREATE createIndexSpecification INDEX concurrentlyClause (ifNotExists? indexName)? ON onlyClause tableName
-      accessMethodClause? LP_ indexParams RP_ include? (WITH reloptions)? tablespace? whereClause?
+      accessMethodClause? LP_ indexParams RP_ include? nullsDistinct? (WITH reloptions)? tablespace? whereClause?
     ;
 
 include
@@ -115,7 +116,7 @@ createView
       (LP_ (columnList (COMMA_ columnList)*)? RP_)?
       (WITH reloptions)?
       AS select
-      (WITH (CASCADE | LOCAL)? CHECK OPTION)?
+      (WITH (CASCADED | LOCAL)? CHECK OPTION)?
     ;
 
 columnList
@@ -127,7 +128,7 @@ columnElem
     ;
 
 dropDatabase
-    : DROP DATABASE ifExists? name
+    : DROP DATABASE ifExists? name (WITH? LP_ FORCE RP_)?
     ;
 
 dropGroup
@@ -175,7 +176,7 @@ dropIndexOpt
     ;
 
 truncateTable
-    : TRUNCATE TABLE? onlyClause tableNamesClause restartSeqs? dropTableOpt?
+    : TRUNCATE TABLE? tableNamesClause restartSeqs? dropTableOpt?
     ;
 
 restartSeqs
@@ -196,7 +197,7 @@ createDefinition
     ;
 
 columnDefinition
-    : columnName dataType collateClause? columnConstraint*
+    : columnName dataType (STORAGE colId)? columnCompression? collateClause? columnConstraint*
     ;
 
 columnConstraint
@@ -211,11 +212,11 @@ columnConstraintOption
     : NOT? NULL
     | checkOption
     | DEFAULT defaultExpr
-    | GENERATED ALWAYS AS LP_ aExpr RP_ STORED
+    | GENERATED ALWAYS AS LP_ aExpr RP_ (STORED | VIRTUAL)?
     | GENERATED (ALWAYS | BY DEFAULT) AS IDENTITY (LP_ sequenceOptions RP_)?
-    | UNIQUE indexParameters
+    | UNIQUE nullsDistinct? indexParameters
     | primaryKey indexParameters
-    | REFERENCES tableName columnNames? (MATCH FULL | MATCH PARTIAL | MATCH SIMPLE)? (ON (DELETE | UPDATE) action)*
+    | REFERENCES tableName columnNames? (MATCH FULL | MATCH PARTIAL | MATCH SIMPLE)? (ON (DELETE | UPDATE) action | ON DELETE SET (NULL | DEFAULT) columnNames)*
     ;
 
 checkOption
@@ -254,11 +255,11 @@ action
     ;
 
 constraintOptionalParam
-    : (NOT? DEFERRABLE)? (INITIALLY (DEFERRED | IMMEDIATE))?
+    : constraintAttributeElem*
     ;
 
 likeOption
-    : (INCLUDING | EXCLUDING) (COMMENTS | CONSTRAINTS | DEFAULTS | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL)
+    : (INCLUDING | EXCLUDING) (COMMENTS | COMPRESSION | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL)
     ;
 
 tableConstraint
@@ -267,10 +268,23 @@ tableConstraint
 
 tableConstraintOption
     : checkOption
-    | UNIQUE columnNames indexParameters
-    | primaryKey columnNames indexParameters
+    | NOT NULL columnName
+    | UNIQUE nullsDistinct? keyColumnNames indexParameters
+    | primaryKey keyColumnNames indexParameters
     | EXCLUDE (USING ignoredIdentifier)? LP_ exclusionConstraintList RP_ indexParameters exclusionWhereClause?
-    | FOREIGN KEY columnNames REFERENCES tableName columnNames? (MATCH FULL | MATCH PARTIAL | MATCH SIMPLE)? (ON (DELETE | UPDATE) action)*
+    | FOREIGN KEY foreignKeyColumnNames REFERENCES tableName foreignKeyColumnNames? (MATCH FULL | MATCH PARTIAL | MATCH SIMPLE)? (ON (DELETE | UPDATE) action | ON DELETE SET (NULL | DEFAULT) columnNames)*
+    ;
+
+nullsDistinct
+    : NULLS NOT? DISTINCT
+    ;
+
+keyColumnNames
+    : LP_ columnName (COMMA_ columnName)* (WITHOUT OVERLAPS)? RP_
+    ;
+
+foreignKeyColumnNames
+    : LP_ columnName (COMMA_ columnName)* (COMMA_ PERIOD columnName)? RP_
     ;
 
 exclusionWhereClause
@@ -364,7 +378,7 @@ alterIndexSetTableSpace
     ;
 
 tableNamesClause
-    : tableNameClause (COMMA_ tableNameClause)*
+    : onlyClause tableNameClause (COMMA_ onlyClause tableNameClause)*
     ;
 
 tableNameClause
@@ -387,7 +401,7 @@ alterTableAction
     | ALTER COLUMN? NUMBER_ SET STATISTICS signedIconst
     | ALTER COLUMN? colId SET reloptions
     | ALTER COLUMN? colId RESET reloptions
-    | ALTER COLUMN? colId SET STORAGE colId
+    | ALTER COLUMN? colId SET STORAGE (colId | DEFAULT)
     | ALTER COLUMN? colId SET columnCompression
     | ALTER COLUMN? colId DROP EXPRESSION ifExists?
     | (DISABLE | ENABLE) TRIGGER (ignoredIdentifier | ALL | USER)?
@@ -396,15 +410,14 @@ alterTableAction
     | ENABLE (REPLICA | ALWAYS) RULE ignoredIdentifier
     | (DISABLE | ENABLE | (NO? FORCE)) ROW LEVEL SECURITY
     | CLUSTER ON indexName
-    | SET (ACCESS METHOD name) (COMMA_ ACCESS METHOD name)*
+    | SET (ACCESS METHOD (name | DEFAULT)) (COMMA_ ACCESS METHOD name)*
     | SET WITHOUT CLUSTER
     | SET (WITH | WITHOUT) OIDS
     | SET STATISTICS signedIconst
     | SET TABLESPACE ignoredIdentifier
     | SET (LOGGED | UNLOGGED)
-    | SET LP_ (storageParameterWithValue) (COMMA_ storageParameterWithValue)* RP_
-    | SET LP_ (storageParameter) (COMMA_ storageParameter)* RP_
-    | RESET LP_ storageParameterWithValue (COMMA_ storageParameterWithValue)* RP_
+    | SET reloptions
+    | RESET reloptions
     | INHERIT tableName
     | NO INHERIT tableName
     | OF dataTypeName
@@ -425,6 +438,7 @@ modifyColumnSpecification
     : modifyColumn (SET DATA)? TYPE dataType collateClause? (USING aExpr)?
     | modifyColumn SET DEFAULT aExpr
     | modifyColumn DROP DEFAULT
+    | modifyColumn SET EXPRESSION AS LP_ aExpr RP_
     | modifyColumn (SET | DROP) NOT NULL
     | modifyColumn ADD GENERATED (ALWAYS | (BY DEFAULT)) AS IDENTITY (LP_ sequenceOptions RP_)?
     | modifyColumn alterColumnSetOption alterColumnSetOption*
@@ -432,7 +446,7 @@ modifyColumnSpecification
     | modifyColumn SET STATISTICS NUMBER_
     | modifyColumn SET LP_ attributeOptions RP_
     | modifyColumn RESET LP_ attributeOptions RP_
-    | modifyColumn SET STORAGE (PLAIN | EXTERNAL | EXTENDED | MAIN)
+    | modifyColumn SET STORAGE (PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT)
     ;
 
 modifyColumn
@@ -460,7 +474,7 @@ tableConstraintUsingIndex
     ;
 
 modifyConstraintSpecification
-    : ALTER CONSTRAINT constraintName constraintOptionalParam
+    : ALTER CONSTRAINT constraintName (constraintOptionalParam | INHERIT)
     ;
 
 validateConstraintSpecification
@@ -471,14 +485,6 @@ dropConstraintSpecification
     : DROP CONSTRAINT ifExists? constraintName (RESTRICT | CASCADE)?
     ;
 
-storageParameterWithValue
-    : storageParameter EQ_ aExpr
-    ;
-
-storageParameter
-    : IDENTIFIER_
-    ;
-
 renameColumnSpecification
     : RENAME COLUMN? columnName TO columnName
     ;
@@ -530,7 +536,7 @@ alterTableCmd
     | ALTER COLUMN? NUMBER_ SET STATISTICS signedIconst
     | ALTER COLUMN? colId SET reloptions
     | ALTER COLUMN? colId RESET reloptions
-    | ALTER COLUMN? colId SET STORAGE colId
+    | ALTER COLUMN? colId SET STORAGE (colId | DEFAULT)
     | ALTER COLUMN? colId SET columnCompression
     | ALTER COLUMN? colId ADD GENERATED generatedWhen AS IDENTITY parenthesizedSeqOptList?
     | ALTER COLUMN? colId alterIdentityColumnOptionList
@@ -546,6 +552,7 @@ alterTableCmd
     | DROP CONSTRAINT ifExists name dropBehavior?
     | DROP CONSTRAINT name dropBehavior?
     | SET WITHOUT OIDS
+    | SET ACCESS METHOD (name | DEFAULT)
     | CLUSTER ON name
     | SET WITHOUT CLUSTER
     | SET LOGGED
@@ -594,6 +601,7 @@ constraintAttributeElem
     | INITIALLY DEFERRED
     | NOT VALID
     | NO INHERIT
+    | NOT? ENFORCED
     ;
 
 alterGenericOptions
@@ -660,7 +668,8 @@ alterOperatorFamily
     ;
 
 alterOperatorFamilyClauses
-    : (ADD | DROP) opclassItemList
+    : ADD opclassItemList
+    | DROP opclassDropList
     | alterOperatorClassClauses
     ;
 
@@ -668,6 +677,14 @@ opclassItemList
     : opclassItem (COMMA_ opclassItem)*
     ;
 
+opclassDropList
+    : opclassDropItem (COMMA_ opclassDropItem)*
+    ;
+
+opclassDropItem
+    : (OPERATOR | FUNCTION) NUMBER_ LP_ typeList RP_
+    ;
+
 opclassItem
     : OPERATOR NUMBER_ anyOperator opclassPurpose? RECHECK?
     | OPERATOR NUMBER_ operatorWithArgtypes opclassPurpose? RECHECK?
@@ -691,7 +708,7 @@ operatorDefList
     ;
 
 operatorDefElem
-    : (RESTRICT | JOIN) EQ_ (NONE | operatorDefArg)
+    : colLabel (EQ_ (NONE | operatorDefArg))?
     ;
 
 operatorDefArg
@@ -785,6 +802,7 @@ defaclPrivilegeTarget
     | SEQUENCES
     | TYPES
     | SCHEMAS
+    | LARGE OBJECTS
     ;
 
 privileges
@@ -825,7 +843,7 @@ alterDomain
 
 alterDomainClause
     : anyName (SET | DROP) NOT NULL
-    | anyName ADD tableConstraint (NOT VALID)?
+    | anyName ADD (tableConstraint | constraintClause? NOT NULL) (NOT VALID)?
     | anyName DROP CONSTRAINT ifExists? name dropBehavior?
     | anyName VALIDATE CONSTRAINT name
     | anyName RENAME CONSTRAINT constraintName TO constraintName
@@ -841,7 +859,7 @@ alterEventTrigger
 
 alterEventTriggerClause
     : DISABLE
-    | ENABLE (REPLICA | ALWAYS)
+    | ENABLE (REPLICA | ALWAYS)?
     | OWNER TO roleSpec
     | RENAME TO tiggerName
     ;
@@ -971,7 +989,7 @@ alterMaterializedViewClauses
     | ifExists? qualifiedName RENAME COLUMN? columnName TO columnName
     | ifExists? qualifiedName RENAME TO qualifiedName
     | ifExists? qualifiedName SET SCHEMA schemaName
-    | ALL IN TABLESPACE name (OWNED BY roleList) SET TABLESPACE name NOWAIT?
+    | ALL IN TABLESPACE name (OWNED BY roleList)? SET TABLESPACE name NOWAIT?
     ;
 
 executeStmt
@@ -1032,7 +1050,7 @@ alterPublication
     ( RENAME TO name
     | OWNER TO roleSpec
     | SET definition
-    | (ADD | SET | DROP) TABLE relationExprList)
+    | (ADD | SET | DROP) publicationObjectList)
     ;
 
 alterRoutine
@@ -1048,7 +1066,7 @@ alterSequence
     ;
 
 alterSequenceClauses
-    : OWNER TO roleSpec | seqOptList | RENAME TO name | SET SCHEMA name
+    : OWNER TO roleSpec | seqOptList | RENAME TO name | SET SCHEMA name | SET (LOGGED | UNLOGGED)
     ;
 
 alterServer
@@ -1082,6 +1100,7 @@ alterSubscription
     | SET PUBLICATION publicationNameList (WITH definition)?
     | ADD PUBLICATION publicationNameList (WITH definition)?
     | DROP PUBLICATION publicationNameList (WITH definition)?
+    | SKIP_SYMBOL definition
     | (ENABLE | DISABLE))
     ;
 
@@ -1099,7 +1118,7 @@ alterSystem
 
 alterTablespace
     : ALTER TABLESPACE name
-    ( SET|RESET reloptions
+    ( (SET | RESET) reloptions
     | RENAME TO name
     | OWNER TO roleSpec)
     ;
@@ -1152,7 +1171,7 @@ alterTypeClauses
     | RENAME TO name
     | RENAME ATTRIBUTE name TO name dropBehavior?
     | SET SCHEMA name
-    | SET LP_ typeDefList RP_
+    | SET definition
     | OWNER TO roleSpec
     ;
 
@@ -1166,22 +1185,6 @@ alterTypeCmd
     | ALTER ATTRIBUTE colId setData? TYPE typeName collateClause? dropBehavior?
     ;
 
-typeDefList
-    : typeDefElem (COMMA_ typeDefElem)*
-    ;
-
-typeDefElem
-    : (RECEIVE | SEND | TYPMOD_IN | TYPMOD_OUT | ANALYZE | SUBSCRIPT | STORAGE) EQ_ (NONE | typeDefArg)
-    ;
-
-typeDefArg
-    : funcType
-    | reservedKeyword
-    | qualAllOp
-    | numericOnly
-    | STRING_
-    ;
-
 alterUserMapping
     : ALTER USER MAPPING FOR authIdent SERVER name alterGenericOptions
     ;
@@ -1206,7 +1209,7 @@ close
     ;
 
 cluster
-    : CLUSTER clusterVerboseSpecification? tableName? clusterIndexSpecification?
+    : CLUSTER clusterVerboseSpecification? (tableName clusterIndexSpecification? | indexName ON tableName)?
     ;
 
 clusterVerboseSpecification
@@ -1411,9 +1414,8 @@ tableLikeOption
 
 createFunction
     : CREATE (OR REPLACE)? FUNCTION funcName funcArgsWithDefaults
-    ( RETURNS funcReturn createfuncOptList
-    | RETURNS TABLE LP_ tableFuncColumnList RP_ createfuncOptList
-    | createfuncOptList)
+    (RETURNS funcReturn | RETURNS TABLE LP_ tableFuncColumnList RP_)?
+    (createfuncOptList sqlRoutineBody? | sqlRoutineBody)
     ;
 
 tableFuncColumnList
@@ -1437,7 +1439,7 @@ createfuncOptItem
     ;
 
 transformTypeList
-    : FOR TYPE typeName (COMMA_ FOR TYPE typeName)
+    : FOR TYPE typeName (COMMA_ FOR TYPE typeName)*
     ;
 
 funcAs
@@ -1488,7 +1490,23 @@ createPolicy
     ;
 
 createProcedure
-    : CREATE (OR REPLACE)? PROCEDURE funcName funcArgsWithDefaults createfuncOptList
+    : CREATE (OR REPLACE)? PROCEDURE funcName funcArgsWithDefaults (createfuncOptList sqlRoutineBody? | sqlRoutineBody)
+    ;
+
+sqlRoutineBody
+    : RETURN aExpr
+    | BEGIN ATOMIC (sqlRoutineBodyStatement? SEMI_)* END
+    ;
+
+sqlRoutineBodyStatement
+    : RETURN aExpr
+    | select
+    | insert
+    | update
+    | delete
+    | merge
+    | call
+    | createTable
     ;
 
 createPublication
@@ -1496,7 +1514,24 @@ createPublication
     ;
 
 publicationForTables
-    : FOR TABLE relationExprList | FOR ALL TABLES
+    : FOR publicationObjectList | FOR ALL TABLES
+    ;
+
+publicationObjectList
+    : publicationObject (COMMA_ publicationObject)*
+    ;
+
+publicationObject
+    : TABLE publicationTable (COMMA_ publicationTable)*
+    | TABLES IN SCHEMA publicationSchema (COMMA_ publicationSchema)*
+    ;
+
+publicationTable
+    : relationExpr columnNames? (WHERE LP_ aExpr RP_)?
+    ;
+
+publicationSchema
+    : colId | CURRENT_SCHEMA
     ;
 
 createRule
@@ -1523,8 +1558,8 @@ ruleActionMulti
     ;
 
 createTrigger
-    : CREATE TRIGGER name triggerActionTime triggerEvents ON qualifiedName triggerReferencing? triggerForSpec? triggerWhen? EXECUTE (FUNCTION | PROCEDURE) funcName LP_ triggerFuncArgs? RP_
-    | CREATE CONSTRAINT TRIGGER (FROM qualifiedName)? constraintAttributeSpec FOR EACH ROW triggerWhen EXECUTE (FUNCTION | PROCEDURE) funcName LP_ triggerFuncArgs? RP_
+    : CREATE (OR REPLACE)? TRIGGER name triggerActionTime triggerEvents ON qualifiedName triggerReferencing? triggerForSpec? triggerWhen? EXECUTE (FUNCTION | PROCEDURE) funcName LP_ triggerFuncArgs? RP_
+    | CREATE (OR REPLACE)? CONSTRAINT TRIGGER name AFTER triggerEvents ON qualifiedName (FROM qualifiedName)? constraintAttributeSpec FOR EACH? ROW triggerWhen? EXECUTE (FUNCTION | PROCEDURE) funcName LP_ triggerFuncArgs? RP_
     ;
 
 triggerEvents
@@ -1592,11 +1627,11 @@ tempOption
     ;
 
 createServer
-    : CREATE SERVER ifNotExists? name (TYPE STRING_)? foreignServerVersion? FOREIGN DATA WRAPPER name createGenericOptions
+    : CREATE SERVER ifNotExists? name (TYPE STRING_)? foreignServerVersion? FOREIGN DATA WRAPPER name createGenericOptions?
     ;
 
 createStatistics
-    : CREATE STATISTICS ifNotExists? anyName optNameList ON exprList FROM fromList
+    : CREATE STATISTICS (ifNotExists anyName | anyName)? optNameList ON exprList FROM fromList
     ;
 
 createSubscription
@@ -1631,7 +1666,7 @@ enumValList
     ;
 
 createUserMapping
-    : CREATE USER MAPPING ifNotExists? FOR authIdent SERVER name createGenericOptions
+    : CREATE USER MAPPING ifNotExists? FOR authIdent SERVER name createGenericOptions?
     ;
 
 discard
@@ -1655,15 +1690,15 @@ dropCast
     ;
 
 dropCollation
-    : DROP COLLATION ifExists? name dropBehavior?
+    : DROP COLLATION ifExists? anyNameList dropBehavior?
     ;
 
 dropConversion
-    : DROP CONVERSION ifExists? name dropBehavior?
+    : DROP CONVERSION ifExists? anyName dropBehavior?
     ;
 
 dropDomain
-    : DROP DOMAIN ifExists? nameList dropBehavior?
+    : DROP DOMAIN ifExists? anyNameList dropBehavior?
     ;
 
 dropEventTrigger
@@ -1879,7 +1914,7 @@ reindexOptionList
     ;
 
 reindexOptionElem
-    : VERBOSE | CONCURRENTLY | TABLESPACE
+    : (VERBOSE | CONCURRENTLY) booleanOrString? | TABLESPACE name
     ;
 
 reindexTargetMultitable
@@ -1964,11 +1999,15 @@ grant
     ;
 
 privilegeClause
-    : privilegeTypes ON onObjectClause (FROM | TO) granteeList (WITH GRANT OPTION)?
+    : privilegeTypes ON onObjectClause (FROM | TO) granteeList (WITH GRANT OPTION)? (GRANTED BY roleSpec)?
     ;
 
 roleClause
-    : privilegeList (FROM | TO) roleList (WITH ADMIN OPTION)? (GRANTED BY roleSpec)?
+    : privilegeList (FROM | TO) roleList (WITH roleGrantOption (COMMA_ roleGrantOption)*)? (GRANTED BY roleSpec)?
+    ;
+
+roleGrantOption
+    : (ADMIN | INHERIT | SET) (OPTION | TRUE | FALSE)
     ;
 
 privilegeTypes
@@ -2017,6 +2056,7 @@ privilegeType
     | TRUNCATE
     | REFERENCES
     | TRIGGER
+    | MAINTAIN
     | CREATE
     | CONNECT
     | TEMPORARY
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
index f99eac4c5c2..dad1d1a9fb9 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
@@ -77,7 +77,7 @@ setClause
     ;
 
 setTarget
-    : colId indirection?
+    : colId optIndirection
     ;
 
 setTargetList
@@ -86,7 +86,11 @@ setTargetList
     ;
 
 returningClause
-    : RETURNING targetList
+    : RETURNING (WITH LP_ returningOption (COMMA_ returningOption)* RP_)? targetList
+    ;
+
+returningOption
+    : (OLD | NEW) AS colId
     ;
 
 delete
@@ -187,7 +191,15 @@ cteList
     ;
 
 commonTableExpr
-    :  alias optNameList AS optMaterialized LP_ preparableStmt RP_
+    : alias optNameList AS optMaterialized LP_ preparableStmt RP_ searchClause? cycleClause?
+    ;
+
+searchClause
+    : SEARCH (BREADTH | DEPTH) FIRST BY nameList SET colId
+    ;
+
+cycleClause
+    : CYCLE nameList SET colId (TO aexprConst DEFAULT aexprConst)? USING colId
     ;
 
 optMaterialized
@@ -203,6 +215,7 @@ preparableStmt
     | insert
     | update
     | delete
+    | merge
     ;
 
 forLockingClause
@@ -291,14 +304,14 @@ targetList
 targetEl
     : colId DOT_ASTERISK_
     | aExpr AS colLabel
-    | aExpr identifier
     | aExpr
+    | aExpr identifier
     | ASTERISK_
     | colId DOT_ASTERISK_ AS identifier
     ;
 
 groupClause
-    : GROUP BY groupByList
+    : GROUP BY (ALL | DISTINCT)? groupByList
     ;
 
 groupByList
@@ -400,6 +413,8 @@ tableReference
     | LATERAL functionTable funcAliasClause?
     | xmlTable aliasClause?
     | LATERAL xmlTable aliasClause?
+    | jsonTable aliasClause?
+    | LATERAL jsonTable aliasClause?
     | selectWithParens aliasClause?
     | LATERAL selectWithParens aliasClause?
     | tableReference joinedTable
@@ -435,7 +450,7 @@ joinOuter
     ;
 
 joinQual
-    : USING LP_ nameList RP_
+    : USING LP_ nameList RP_ (AS colId)?
     | ON aExpr
     ;
 
@@ -491,22 +506,38 @@ copyOption
     | FREEZE booleanValue?
     | DELIMITER STRING_
     | NULL STRING_
-    | HEADER booleanValue?
+    | DEFAULT STRING_
+    | HEADER (booleanValue | MATCH)?
     | QUOTE STRING_
     | ESCAPE STRING_
     | FORCE_QUOTE (columnNames | ASTERISK_)
-    | FORCE_NOT_NULL columnNames
-    | FORCE_NULL columnNames
+    | FORCE_NOT_NULL (columnNames | ASTERISK_)
+    | FORCE_NULL (columnNames | ASTERISK_)
+    | ON_ERROR (STOP | IGNORE)
+    | REJECT_LIMIT NUMBER_
     | ENCODING STRING_
+    | LOG_VERBOSITY (DEFAULT | VERBOSE | SILENT)
     ;
 
 
 copyWithTableOrQueryBinaryCsv
-    : COPY (qualifiedName columnNames? | LP_ preparableStmt RP_) (FROM | TO) (fileName | STDIN | STDOUT) (WITH? BINARY? (DELIMITER AS? STRING_)? (NULL AS? STRING_)? (CSV HEADER? (QUOTE AS? STRING_)? (ESCAPE AS? STRING_)? (FORCE NOT NULL columnName (COMMA_ columnName)*)? (FORCE QUOTE (columnName (COMMA_ columnName)* | ASTERISK_))?)?)?
+    : COPY (qualifiedName columnNames? | LP_ preparableStmt RP_) (FROM | TO) (fileName | STDIN | STDOUT) WITH? copyLegacyOption*
+    ;
+
+copyLegacyOption
+    : BINARY
+    | FREEZE
+    | DELIMITER AS? STRING_
+    | NULL AS? STRING_
+    | CSV
+    | HEADER
+    | QUOTE AS? STRING_
+    | ESCAPE AS? STRING_
+    | FORCE QUOTE (columnName (COMMA_ columnName)* | ASTERISK_)
+    | FORCE NOT NULL columnName (COMMA_ columnName)*
+    | ENCODING STRING_
     ;
 
 copyWithTableBinary
     : COPY BINARY? qualifiedName (FROM | TO) (fileName | STDIN | STDOUT) (USING? DELIMITERS STRING_)? (WITH NULL AS STRING_)?
     ;
-
-
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Literals.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Literals.g4
index 862d0d62dbd..92e30e36f4a 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Literals.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Literals.g4
@@ -19,35 +19,22 @@ lexer grammar Literals;
 
 import Alphabet, Symbol;
 
-IDENTIFIER_
-    : IDENTIFIER_START_CHAR_ IDENTIFIER_CHAR_*
-    | DQ_ ~'"'+ DQ_
-    ;
-
-STRING_
-    : E SQ_ ('\\'. | '\'\'' | ~('\'' | '\\'))* SQ_
-    | SQ_ ('\'\'' | ~'\'')* SQ_
-    ;
-
-NUMBER_
-    : INT_? DOT_? INT_ (E (PLUS_ | MINUS_)? INT_)?
-    ;
-
-HEX_DIGIT_
-    : '0x' HEX_+ | 'X' SQ_ HEX_+ SQ_
-    ;
-
-BIT_NUM_
-    : '0b' ('0' | '1')+ | B SQ_ ('0' | '1')+ SQ_
-    ;
-
-fragment INT_
-    : [0-9]+
-    ;
-
-fragment HEX_
-    : [0-9a-fA-F]
-    ;
+IDENTIFIER_: IDENTIFIER_START_CHAR_ IDENTIFIER_CHAR_* | DQ_ ~'"'+ DQ_;
+STRING_: E ESCAPE_STRING_LITERAL_ (STRING_CONTINUATION_ ESCAPE_STRING_LITERAL_)* | STRING_LITERAL_ (STRING_CONTINUATION_ STRING_LITERAL_)*;
+NUMBER_: (INT_ (DOT_ INT_?)? | DOT_ INT_) (E (PLUS_ | MINUS_)? INT_)?;
+HEX_DIGIT_: X SQ_ HEX_* SQ_ (STRING_CONTINUATION_ SQ_ HEX_* SQ_)*;
+BIT_NUM_: B SQ_ [01]* SQ_ (STRING_CONTINUATION_ SQ_ [01]* SQ_)*;
+HEX_NUMBER_: '0' X '_'? HEX_ ('_'? HEX_)*;
+BINARY_NUMBER_: '0' B '_'? [01] ('_'? [01])*;
+OCTAL_NUMBER_: '0' O '_'? [0-7] ('_'? [0-7])*;
+
+fragment INT_: [0-9] ('_'? [0-9])*;
+fragment HEX_: [0-9a-fA-F];
+fragment STRING_CONTENT_: '\'\'' | ~'\'';
+fragment ESCAPE_STRING_CONTENT_: '\\' . | '\'\'' | ~('\'' | '\\');
+fragment STRING_LITERAL_: SQ_ STRING_CONTENT_* SQ_;
+fragment ESCAPE_STRING_LITERAL_: SQ_ ESCAPE_STRING_CONTENT_* SQ_;
+fragment STRING_CONTINUATION_: [ \t\f]* ('\r'? '\n' | '\r') [ \t\r\n\f]*;
 
 fragment IDENTIFIER_START_CHAR_
    : [a-zA-Z_]
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
index ecedd952a54..c8d73897d9e 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
@@ -19,6 +19,46 @@ lexer grammar PostgreSQLKeyword;
 
 import Alphabet;
 
+ABSENT: A B S E N T;
+ATOMIC: A T O M I C;
+BREADTH: B R E A D T H;
+CONDITIONAL: C O N D I T I O N A L;
+DEPTH: D E P T H;
+EMPTY: E M P T Y;
+ENFORCED: E N F O R C E D;
+ERROR: E R R O R;
+IGNORE: I G N O R E;
+INDENT: I N D E N T;
+JSON_ARRAY: J S O N UL_ A R R A Y;
+JSON_ARRAYAGG: J S O N UL_ A R R A Y A G G;
+JSON_EXISTS: J S O N UL_ E X I S T S;
+JSON_OBJECT: J S O N UL_ O B J E C T;
+JSON_OBJECTAGG: J S O N UL_ O B J E C T A G G;
+JSON_QUERY: J S O N UL_ Q U E R Y;
+JSON_SCALAR: J S O N UL_ S C A L A R;
+JSON_SERIALIZE: J S O N UL_ S E R I A L I Z E;
+JSON_TABLE: J S O N UL_ T A B L E;
+JSON_VALUE: J S O N UL_ V A L U E;
+KEEP: K E E P;
+KEYS: K E Y S;
+LOG_VERBOSITY: L O G UL_ V E R B O S I T Y;
+NESTED: N E S T E D;
+OMIT: O M I T;
+ON_ERROR: O N UL_ E R R O R;
+PERIOD: P E R I O D;
+QUOTES: Q U O T E S;
+REJECT_LIMIT: R E J E C T UL_ L I M I T;
+RETURN: R E T U R N;
+SCALAR: S C A L A R;
+SILENT: S I L E N T;
+SOURCE: S O U R C E;
+STOP: S T O P;
+STRING: S T R I N G;
+TARGET: T A R G E T;
+UNCONDITIONAL: U N C O N D I T I O N A L;
+UTF8: U T F '8';
+VIRTUAL: V I R T U A L;
+
 ADMIN
     : A D M I N
     ;
@@ -299,6 +339,10 @@ MAIN
     : M A I N
     ;
 
+MAINTAIN
+    : M A I N T A I N
+    ;
+
 MATCH
     : M A T C H
     ;
@@ -323,6 +367,10 @@ OBJECT
     : O B J E C T
     ;
 
+OBJECTS
+    : O B J E C T S
+    ;
+
 OIDS
     : O I D S
     ;
@@ -1213,9 +1261,9 @@ NEW
     : N E W
     ;
 
-//SKIP
-//    : S K I P
-//    ;
+SKIP_SYMBOL
+    : S K I P
+    ;
 
 PREPARED
     : P R E P A R E D
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/StoreProcedure.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/StoreProcedure.g4
index c0daeb3608c..05168ecded9 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/StoreProcedure.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/StoreProcedure.g4
@@ -38,5 +38,5 @@ positionalNotation
     ;
 
 namedNotation
-    : identifier EQ_ GT_ aExpr
+    : identifier NAMED_ARGUMENT_ aExpr
     ;
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Symbol.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
index a509bbbaef3..f02b5ce8602 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
@@ -39,6 +39,7 @@ SAFE_EQ_:            '<=>';
 DEQ_:                '==';
 EQ_:                 '=';
 CQ_:                 ':=';
+NAMED_ARGUMENT_:     '=>';
 NEQ_:                '<>' | '!=';
 GT_:                 '>';
 GTE_:                '>=';
@@ -64,6 +65,9 @@ NOT_TILDE_TILDE_:    '!~~';
 TYPE_CAST_:          '::';
 ILIKE_:              '~~*';
 NOT_ILIKE_:          '!~~*';
+REGEX_NOT_MATCH_:    '!~';
+REGEX_MATCH_CASE_INSENSITIVE_:  '~*';
+REGEX_NOT_MATCH_CASE_INSENSITIVE_:  '!~*';
 UNICODE_ESCAPE:      'U&' | 'u&';
 JSON_EXTRACT_:       '->';
 JSON_EXTRACT_TEXT_:  '->>';
@@ -88,3 +92,7 @@ GEOMETRIC_ABOVE_:               '>^';
 GEOMETRIC_INTERSECT_:           '?#';
 GEOMETRIC_PERPENDICULAR_:       '?-|';
 GEOMETRIC_SAME_AS_:             '~=';
+CUSTOM_OPERATOR_: OPERATOR_CHAR_+ OPERATOR_END_CHAR_ | OPERATOR_CHAR_* OPERATOR_SPECIAL_CHAR_ OPERATOR_CHAR_*;
+fragment OPERATOR_CHAR_: [+\-*/<>=~!@#%^&|`] {'-' != _input.LA(-1) || '-' != _input.LA(1)}? {'/' != _input.LA(-1) || '*' != _input.LA(1)}?;
+fragment OPERATOR_END_CHAR_: [*/<>=~!@#%^&|`] {'/' != _input.LA(-1) || '*' != _input.LA(1)}?;
+fragment OPERATOR_SPECIAL_CHAR_: [~!@#%^&|`];
diff --git a/parser/sql/engine/dialect/postgresql/src/main/antlr4/org/apache/shardingsphere/sql/parser/autogen/PostgreSQLStatementParser.g4 b/parser/sql/engine/dialect/postgresql/src/main/antlr4/org/apache/shardingsphere/sql/parser/autogen/PostgreSQLStatementParser.g4
index 4456ead60c8..7d09a600d03 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/antlr4/org/apache/shardingsphere/sql/parser/autogen/PostgreSQLStatementParser.g4
+++ b/parser/sql/engine/dialect/postgresql/src/main/antlr4/org/apache/shardingsphere/sql/parser/autogen/PostgreSQLStatementParser.g4
@@ -29,6 +29,7 @@ execute
     | update
     | delete
     | merge
+    | doStatement
     | createIndex
     | alterIndex
     | dropIndex
@@ -80,6 +81,11 @@ execute
     | createFunction
     | createProcedure
     | createServer
+    | createUserMapping
+    | alterUserMapping
+    | dropUserMapping
+    | createTransform
+    | alterLargeObject
     | createTrigger
     | createView
     | createSequence
@@ -156,6 +162,10 @@ execute
     | close
     | cluster
     | alterOperator
+    | createOperatorClass
+    | alterOperatorClass
+    | createOperatorFamily
+    | alterOperatorFamily
     | createAccessMethod
     | alterPublication
     | createAggregate
@@ -169,11 +179,15 @@ execute
     | reindex
     | securityLabelStmt
     | createEventTrigger
+    | alterEventTrigger
     | createForeignDataWrapper
     | createForeignTable
+    | importForeignSchema
     | alterStatistics
+    | createStatistics
     | createGroup
     | alterSubscription
+    | createSubscription
     | createMaterializedView
     | createOperator
     | alterTextSearchConfiguration
diff --git a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/PostgreSQLStatementVisitor.java b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/PostgreSQLStatementVisitor.java
index 38c432a9d48..09ce8672ff2 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/PostgreSQLStatementVisitor.java
+++ b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/PostgreSQLStatementVisitor.java
@@ -26,6 +26,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.apache.shardingsphere.database.connector.core.metadata.database.enums.NullsOrderType;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
 import org.apache.shardingsphere.sql.parser.api.ASTNode;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AExprContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AexprConstContext;
@@ -49,6 +50,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Da
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DataTypeNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DeleteContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExecuteStmtContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExplicitRowContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExprListContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExtractArgContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ForLockingClauseContext;
@@ -63,9 +65,11 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Gr
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.HavingClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.HostVariableContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IdentifierContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ImplicitRowContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InExprContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndirectionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndirectionElContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertColumnItemContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertColumnListContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertContext;
@@ -74,6 +78,17 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.In
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IntoClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JoinQualContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JoinedTableContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonAggregateFunctionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonExistsErrorClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonFunctionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonNullClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonPassingClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonReturningClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonTableColumnContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonTableContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonTablePathContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonValueEmptyClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JsonValueErrorClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LimitClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.MergeContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.MergeMatchedThenClauseContext;
@@ -83,6 +98,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Na
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NaturalJoinTypeContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NullsOrderContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NumberLiteralsContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OptIndirectionContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OptOnConflictContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OuterJoinTypeContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OverClauseContext;
@@ -92,6 +108,8 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Qu
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.QualifiedNameListContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.RelationExprOptAliasContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ReturningClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ReturningOptionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.RowsFromItemContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SchemaNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectClauseNContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectContext;
@@ -109,11 +127,14 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Si
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SimpleSelectContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SortClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SortbyContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableFuncElementContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableNamesContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableReferenceContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TargetElContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TargetListContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TypeNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UescapeContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UnreservedWordContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UpdateContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ValuesClauseContext;
@@ -125,7 +146,12 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Wi
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WindowDefinitionListContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WindowSpecificationContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WithClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.XmlNamespaceElContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.XmlTableColumnElContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.XmlTableColumnOptionElContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.XmlTableContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParserBaseVisitor;
+import org.apache.shardingsphere.sql.parser.engine.exception.SQLParsingException;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.AggregationType;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.CombineType;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.JoinType;
@@ -146,6 +172,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.C
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BetweenExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CaseWhenExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CollateExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExistsSubqueryExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionWithParamsSegment;
@@ -154,7 +181,9 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.Func
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
@@ -184,6 +213,11 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.paginatio
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.HavingSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.LockSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.WhereSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlNamespaceStringAsIdentifierSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlNamespacesClauseSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlTableColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlTableFunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlTableOptionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasAvailable;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.DataTypeLengthSegment;
@@ -195,6 +229,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.Paren
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WindowItemSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WindowSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.DeleteMultiTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.FunctionTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.JoinTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
@@ -202,6 +237,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.ExecuteStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
@@ -219,9 +255,14 @@ import org.apache.shardingsphere.sql.parser.statement.core.value.literal.impl.Ot
 import org.apache.shardingsphere.sql.parser.statement.core.value.literal.impl.StringLiteralValue;
 import org.apache.shardingsphere.sql.parser.statement.core.value.parametermarker.ParameterMarkerValue;
 
+import javax.annotation.Nullable;
+import java.math.BigInteger;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Deque;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
@@ -248,7 +289,7 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public final ASTNode visitNumberLiterals(final NumberLiteralsContext ctx) {
-        return new NumberLiteralValue(ctx.NUMBER_().getText());
+        return new NumberLiteralValue(ctx.NUMBER_().getText().replace("_", ""));
     }
     
     @Override
@@ -326,32 +367,72 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.cExpr()) {
             return visit(ctx.cExpr());
         }
+        return createAExprSegment(ctx).orElseGet(() -> createCommonExpressionSegment(ctx));
+    }
+    
+    private Optional<ASTNode> createAExprSegment(final AExprContext ctx) {
         if (null != ctx.TYPE_CAST_()) {
-            return new TypeCastExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText(), (ExpressionSegment) visit(ctx.aExpr(0)), ctx.typeName().getText());
+            return Optional.of(new TypeCastExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText(), (ExpressionSegment) visit(ctx.aExpr(0)), ctx.typeName().getText()));
+        }
+        if (null != ctx.COLLATE()) {
+            LiteralExpressionSegment collateName = new LiteralExpressionSegment(ctx.anyName().start.getStartIndex(), ctx.anyName().stop.getStopIndex(), getOriginalText(ctx.anyName()));
+            return Optional.of(new CollateExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), collateName, (ExpressionSegment) visit(ctx.aExpr(0))));
         }
         if (null != ctx.BETWEEN()) {
-            return createBetweenSegment(ctx);
+            return Optional.of(createBetweenSegment(ctx));
         }
         if (null != ctx.IN()) {
-            return createInSegment(ctx);
+            return Optional.of(createInSegment(ctx));
         }
         if (null != ctx.patternMatchingOperator()) {
-            return createPatternMatchingOperationSegment(ctx);
+            return Optional.of(createPatternMatchingOperationSegment(ctx));
+        }
+        if (null != ctx.subqueryOp() && (null != ctx.subqueryOp().LIKE() || null != ctx.subqueryOp().ILIKE())) {
+            return Optional.of(createQuantifiedPatternMatchingOperationSegment(ctx));
         }
         if (null != ctx.NOT() && null == ctx.IS() && 1 == ctx.aExpr().size()) {
-            return new NotExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.aExpr(0)), false);
+            return Optional.of(new NotExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.aExpr(0)), false));
         }
-        Optional<String> binaryOperator = findBinaryOperator(ctx);
-        if (binaryOperator.isPresent()) {
-            return createBinaryOperationSegment(ctx, binaryOperator.get());
+        if (1 == ctx.aExpr().size() && (null != ctx.qualOp() || null != ctx.TILDE_())) {
+            String operator = null == ctx.qualOp() ? ctx.TILDE_().getText() : ctx.qualOp().getText();
+            return Optional.of(new UnaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.aExpr(0)), operator, getOriginalText(ctx)));
         }
-        super.visitAExpr(ctx);
-        String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return findBinaryOperator(ctx).map(optional -> createBinaryOperationSegment(ctx, optional));
+    }
+    
+    private BinaryOperationExpression createQuantifiedPatternMatchingOperationSegment(final AExprContext ctx) {
+        ExpressionSegment left = (ExpressionSegment) visit(ctx.aExpr(0));
+        ExpressionSegment expression;
+        if (null != ctx.selectWithParens()) {
+            SelectWithParensContext select = ctx.selectWithParens();
+            expression = new SubqueryExpressionSegment(new SubquerySegment(select.start.getStartIndex(), select.stop.getStopIndex(), createSubquerySelectStatement(select), getOriginalText(select)));
+        } else {
+            expression = (ExpressionSegment) visit(ctx.aExpr(1));
+        }
+        ListExpression right = new ListExpression(expression.getStartIndex(), expression.getStopIndex());
+        right.getItems().add(expression);
+        String operator = getOriginalText(ctx.subqueryOp()).toUpperCase() + " " + ctx.subType().getText().toUpperCase();
+        return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, getOriginalText(ctx));
+    }
+    
+    private SelectStatement createSubquerySelectStatement(final ParserRuleContext ctx) {
+        int previousMarkerCount = parameterMarkerSegments.size();
+        SelectStatement result = (SelectStatement) visit(ctx);
+        int markerCount = parameterMarkerSegments.size() - previousMarkerCount;
+        Deque<ParameterMarkerSegment> markers = new ArrayDeque<>(markerCount);
+        Iterator<ParameterMarkerSegment> iterator = ((Deque<ParameterMarkerSegment>) parameterMarkerSegments).descendingIterator();
+        for (int i = markerCount; i > 0; i--) {
+            markers.addFirst(iterator.next());
+        }
+        result.addParameterMarkers(markers);
+        return result;
     }
     
     private Optional<String> findBinaryOperator(final AExprContext ctx) {
         if (null != ctx.IS()) {
+            if (null != ctx.DISTINCT()) {
+                return Optional.of(null == ctx.NOT() ? "IS DISTINCT FROM" : "IS NOT DISTINCT FROM");
+            }
             return Optional.of(ctx.IS().getText());
         }
         if (null != ctx.ISNULL()) {
@@ -381,6 +462,9 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.SLASH_()) {
             return Optional.of(ctx.SLASH_().getText());
         }
+        if (null != ctx.qualOp() && (null != ctx.qualOp().CUSTOM_OPERATOR_() || null != ctx.qualOp().OPERATOR())) {
+            return Optional.of(ctx.qualOp().getText());
+        }
         return Optional.empty();
     }
     
@@ -432,6 +516,12 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         }
         if (null != ctx.aExpr()) {
             ASTNode result = visit(ctx.aExpr());
+            if (null != ctx.optIndirection().indirectionEl()) {
+                Collection<ExpressionSegment> children = new LinkedList<>();
+                children.add((ExpressionSegment) result);
+                collectFunctionParameters(ctx.optIndirection(), children);
+                return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), children);
+            }
             if (result instanceof ColumnSegment) {
                 ((ColumnSegment) result).setLeftParentheses(new ParenthesesSegment(ctx.LP_().getSymbol().getStartIndex(), ctx.LP_().getSymbol().getStopIndex(), ctx.LP_().getSymbol().getText()));
                 ((ColumnSegment) result).setRightParentheses(new ParenthesesSegment(ctx.RP_().getSymbol().getStartIndex(), ctx.RP_().getSymbol().getStopIndex(), ctx.RP_().getSymbol().getText()));
@@ -442,19 +532,56 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
             return visit(ctx.funcExpr());
         }
         if (null != ctx.selectWithParens()) {
-            return createSubqueryExpressionSegment(ctx);
+            ExpressionSegment result = createSubqueryExpressionSegment(ctx);
+            if (null != ctx.indirection()) {
+                Collection<ExpressionSegment> children = new LinkedList<>();
+                children.add(result);
+                collectFunctionParameters(ctx.indirection(), children);
+                return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), children);
+            }
+            return result;
         }
         if (null != ctx.caseExpr()) {
             return visit(ctx.caseExpr());
         }
-        super.visitCExpr(ctx);
-        String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), text);
+        if (null != ctx.explicitRow()) {
+            return visit(ctx.explicitRow());
+        }
+        if (null != ctx.implicitRow()) {
+            return visit(ctx.implicitRow());
+        }
+        return createCommonExpressionSegment(ctx);
+    }
+    
+    private CommonExpressionSegment createCommonExpressionSegment(final ParserRuleContext ctx) {
+        Collection<ExpressionSegment> children = new LinkedList<>();
+        collectFunctionParameters(ctx, children, true);
+        return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), children);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public ASTNode visitExplicitRow(final ExplicitRowContext ctx) {
+        RowExpression result = new RowExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
+        if (null != ctx.exprList()) {
+            result.getItems().addAll(((CollectionValue<ExpressionSegment>) visit(ctx.exprList())).getValue());
+        }
+        return result;
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public ASTNode visitImplicitRow(final ImplicitRowContext ctx) {
+        RowExpression result = new RowExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
+        result.getItems().addAll(((CollectionValue<ExpressionSegment>) visit(ctx.exprList())).getValue());
+        result.getItems().add((ExpressionSegment) visit(ctx.aExpr()));
+        return result;
     }
     
     private ExpressionSegment createSubqueryExpressionSegment(final CExprContext ctx) {
         SubquerySegment subquerySegment = new SubquerySegment(ctx.selectWithParens().getStart().getStartIndex(),
-                ctx.selectWithParens().getStop().getStopIndex(), (SelectStatement) visit(ctx.selectWithParens()), getOriginalText(ctx.selectWithParens()));
+                ctx.selectWithParens().getStop().getStopIndex(),
+                (SelectStatement) visit(ctx.selectWithParens()), getOriginalText(ctx.selectWithParens()));
         if (null != ctx.EXISTS()) {
             subquerySegment.setSelect(subquerySegment.getSelect().withSubqueryType(SubqueryType.EXISTS));
             return new ExistsSubqueryExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), subquerySegment);
@@ -464,13 +591,13 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitCaseExpr(final CaseExprContext ctx) {
+        ExpressionSegment caseExpr = null == ctx.caseArg() ? null : (ExpressionSegment) visit(ctx.caseArg().aExpr());
         Collection<ExpressionSegment> whenExprs = new LinkedList<>();
         Collection<ExpressionSegment> thenExprs = new LinkedList<>();
         for (WhenClauseContext each : ctx.whenClauseList().whenClause()) {
             whenExprs.add((ExpressionSegment) visit(each.aExpr(0)));
             thenExprs.add((ExpressionSegment) visit(each.aExpr(1)));
         }
-        ExpressionSegment caseExpr = null == ctx.caseArg() ? null : (ExpressionSegment) visit(ctx.caseArg().aExpr());
         ExpressionSegment elseExpr = null == ctx.caseDefault() ? null : (ExpressionSegment) visit(ctx.caseDefault().aExpr());
         return new CaseWhenExpression(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), caseExpr, whenExprs, thenExprs, elseExpr, getOriginalText(ctx));
     }
@@ -480,7 +607,8 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.functionExprCommonSubexpr()) {
             return visit(ctx.functionExprCommonSubexpr());
         }
-        ASTNode result = visit(ctx.funcApplication());
+        ShardingSpherePreconditions.checkState(null == ctx.filterClause(), () -> new SQLParsingException("FILTER clauses are not supported"));
+        ASTNode result = visit(null == ctx.jsonAggregateFunction() ? ctx.funcApplication() : ctx.jsonAggregateFunction());
         return null == ctx.overClause() ? result : appendWindow(ctx, result);
     }
     
@@ -493,7 +621,7 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
             return createAggregationSegmentWithWindow(ctx, (AggregationProjectionSegment) node, window);
         }
         if (node instanceof FunctionSegment) {
-            return createFunctionSegmentWithWindow(ctx, (FunctionSegment) node, window);
+            return createFunctionSegment(ctx, (FunctionSegment) node, window);
         }
         return node;
     }
@@ -515,7 +643,7 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         return result;
     }
     
-    private FunctionSegment createFunctionSegmentWithWindow(final FuncExprContext ctx, final FunctionSegment segment, final WindowItemSegment window) {
+    private FunctionSegment createFunctionSegment(final FuncExprContext ctx, final FunctionSegment segment, final WindowItemSegment window) {
         FunctionSegment result = new FunctionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), segment.getFunctionName(), getOriginalText(ctx));
         result.setOwner(segment.getOwner());
         result.getParameters().addAll(segment.getParameters());
@@ -535,18 +663,91 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitFunctionExprCommonSubexpr(final FunctionExprCommonSubexprContext ctx) {
+        if (null != ctx.jsonFunction()) {
+            return visit(ctx.jsonFunction());
+        }
         if (null != ctx.CAST()) {
             return new TypeCastExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText(), (ExpressionSegment) visit(ctx.aExpr(0)), ctx.typeName().getText());
         }
         FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getChild(0).getText(), getOriginalText(ctx));
-        Collection<ExpressionSegment> expressionSegments = getExpressionSegments(getTargetRuleContextFromParseTree(ctx, AExprContext.class));
         if ("EXTRACT".equalsIgnoreCase(ctx.getChild(0).getText())) {
             result.getParameters().add((ExpressionSegment) visit(getTargetRuleContextFromParseTree(ctx, ExtractArgContext.class).iterator().next()));
         }
-        result.getParameters().addAll(expressionSegments);
+        collectFunctionParameters(ctx, result.getParameters());
         return result;
     }
     
+    private void collectFunctionParameters(final ParseTree parseTree, final Collection<ExpressionSegment> params) {
+        collectFunctionParameters(parseTree, params, false);
+    }
+    
+    private void collectFunctionParameters(final ParseTree parseTree, final Collection<ExpressionSegment> params, final boolean expandOpaque) {
+        for (int index = 0; index < parseTree.getChildCount(); index++) {
+            ParseTree child = parseTree.getChild(index);
+            if (expandOpaque && child instanceof AExprContext) {
+                collectCommonAExprParameters((AExprContext) child, params);
+            } else if (child instanceof AExprContext || child instanceof BExprContext || child instanceof CExprContext || child instanceof JsonTablePathContext) {
+                ExpressionSegment expression = (ExpressionSegment) visit(child);
+                if (expandOpaque) {
+                    collectCommonExpressionChild(expression, params);
+                } else {
+                    params.add(expression);
+                }
+            } else if (child instanceof SelectNoParensContext) {
+                SelectNoParensContext select = (SelectNoParensContext) child;
+                SelectStatement statement = createSubquerySelectStatement(select);
+                params.add(new SubqueryExpressionSegment(new SubquerySegment(select.start.getStartIndex(), select.stop.getStopIndex(), statement, getOriginalText(select))));
+            } else if (parseTree instanceof JsonFunctionContext && (child instanceof TypeNameContext || child instanceof JsonValueEmptyClauseContext || child instanceof JsonValueErrorClauseContext
+                    || child instanceof JsonExistsErrorClauseContext || child instanceof JsonPassingClauseContext || child instanceof JsonNullClauseContext
+                    || child instanceof JsonReturningClauseContext)) {
+                ParserRuleContext parameter = (ParserRuleContext) child;
+                params.add(new CommonExpressionSegment(parameter.start.getStartIndex(), parameter.stop.getStopIndex(), getOriginalText(parameter), Collections.emptyList()));
+                if (!(child instanceof TypeNameContext)) {
+                    collectFunctionParameters(child, params, expandOpaque);
+                }
+            } else if (!(child instanceof TypeNameContext)) {
+                collectFunctionParameters(child, params, expandOpaque);
+            }
+        }
+    }
+    
+    private void collectCommonAExprParameters(final AExprContext ctx, final Collection<ExpressionSegment> params) {
+        if (null != ctx.cExpr()) {
+            collectCommonExpressionChild((ExpressionSegment) visit(ctx.cExpr()), params);
+            return;
+        }
+        Optional<ASTNode> expression = createAExprSegment(ctx);
+        if (expression.isPresent()) {
+            collectCommonExpressionChild((ExpressionSegment) expression.get(), params);
+        } else {
+            collectFunctionParameters(ctx, params, true);
+        }
+    }
+    
+    private void collectCommonExpressionChild(final ExpressionSegment expression, final Collection<ExpressionSegment> params) {
+        if (expression instanceof CommonExpressionSegment && !((CommonExpressionSegment) expression).getChildren().isEmpty()) {
+            params.addAll(((CommonExpressionSegment) expression).getChildren());
+        } else {
+            params.add(expression);
+        }
+    }
+    
+    @Override
+    public ASTNode visitJsonFunction(final JsonFunctionContext ctx) {
+        return createJsonFunction(ctx);
+    }
+    
+    private FunctionSegment createJsonFunction(final ParserRuleContext ctx) {
+        FunctionSegment result = new FunctionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getChild(0).getText(), getOriginalText(ctx));
+        collectFunctionParameters(ctx, result.getParameters());
+        return result;
+    }
+    
+    @Override
+    public ASTNode visitJsonAggregateFunction(final JsonAggregateFunctionContext ctx) {
+        return createJsonFunction(ctx);
+    }
+    
     @Override
     public ASTNode visitExtractArg(final ExtractArgContext ctx) {
         return new ExtractArgExpression(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getChild(0).getText());
@@ -577,9 +778,9 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     public ASTNode visitAexprConst(final AexprConstContext ctx) {
         LiteralValue<?> value;
         if (null != ctx.numberConst()) {
-            value = new NumberLiteralValue(ctx.numberConst().getText());
+            value = createNumberLiteralValue(ctx.numberConst().getText());
         } else if (null != ctx.STRING_()) {
-            value = new StringLiteralValue(ctx.STRING_().getText());
+            value = createStringLiteralValue(ctx.STRING_().getText(), null != ctx.UNICODE_ESCAPE(), ctx.uescape());
         } else if (null != ctx.FALSE()) {
             value = new BooleanLiteralValue(ctx.FALSE().getText());
         } else if (null != ctx.TRUE()) {
@@ -589,16 +790,125 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         } else {
             value = new OtherLiteralValue(ctx.getText());
         }
-        if (null != ctx.constTypeName() || null != ctx.funcName() && null == ctx.LP_()) {
+        if (null != ctx.INTERVAL() || null != ctx.constTypeName() || null != ctx.funcName() && null == ctx.LP_()) {
             LiteralExpressionSegment expression = new LiteralExpressionSegment(ctx.STRING_().getSymbol().getStartIndex(), ctx.STRING_().getSymbol().getStopIndex(), value.getValue().toString());
-            String dataType = null == ctx.constTypeName() ? ctx.funcName().getText() : ctx.constTypeName().getText();
+            String dataType;
+            if (null != ctx.INTERVAL()) {
+                dataType = ctx.INTERVAL().getText();
+            } else {
+                dataType = null == ctx.constTypeName() ? ctx.funcName().getText() : ctx.constTypeName().getText();
+            }
             return new TypeCastExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText(), expression, dataType);
         }
         return SQLUtils.createLiteralExpression(value, ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
     }
     
+    private NumberLiteralValue createNumberLiteralValue(final String text) {
+        String value = text.replace("_", "");
+        int startIndex = value.startsWith("-") || value.startsWith("+") ? 1 : 0;
+        int radix = 10;
+        if (value.regionMatches(true, startIndex, "0x", 0, 2)) {
+            radix = 16;
+        } else if (value.regionMatches(true, startIndex, "0o", 0, 2)) {
+            radix = 8;
+        } else if (value.regionMatches(true, startIndex, "0b", 0, 2)) {
+            radix = 2;
+        }
+        if (10 == radix) {
+            return new NumberLiteralValue(value);
+        }
+        BigInteger number = new BigInteger(value.substring(startIndex + 2), radix);
+        return new NumberLiteralValue((value.startsWith("-") ? number.negate() : number).toString());
+    }
+    
+    private StringLiteralValue createStringLiteralValue(final String literal, final boolean unicode, final UescapeContext uescape) {
+        String text = concatenateStringLiterals(literal);
+        if (unicode) {
+            char escape = null == uescape ? '\\' : getUnicodeEscapeCharacter(uescape.STRING_().getText());
+            text = "'" + decodeUnicode(text.substring(1, text.length() - 1), escape) + "'";
+        }
+        return new StringLiteralValue(text);
+    }
+    
+    private String concatenateStringLiterals(final String text) {
+        StringBuilder result = new StringBuilder("'");
+        boolean escaped = 'E' == text.charAt(0) || 'e' == text.charAt(0);
+        int index = text.indexOf('\'') + 1;
+        while (index < text.length()) {
+            char character = text.charAt(index);
+            if (escaped && '\\' == character) {
+                result.append(character).append(text.charAt(++index));
+            } else if ('\'' != character) {
+                result.append(character);
+            } else if (index + 1 < text.length() && '\'' == text.charAt(index + 1)) {
+                result.append("''");
+                index++;
+            } else {
+                int nextIndex = text.indexOf('\'', index + 1);
+                if (-1 == nextIndex) {
+                    break;
+                }
+                index = nextIndex;
+            }
+            index++;
+        }
+        return result.append('\'').toString();
+    }
+    
+    private char getUnicodeEscapeCharacter(final String text) {
+        String literal = concatenateStringLiterals(text);
+        String value = literal.substring(1, literal.length() - 1);
+        if (!text.regionMatches(true, 0, "E", 0, 1) || '\\' != value.charAt(0)) {
+            return value.charAt(0);
+        }
+        char character = value.charAt(1);
+        if ('x' == character || 'u' == character || 'U' == character) {
+            return (char) Integer.parseInt(value.substring(2), 16);
+        }
+        if ('0' <= character && '7' >= character) {
+            return (char) Integer.parseInt(value.substring(1), 8);
+        }
+        return 'b' == character ? '\b' : character;
+    }
+    
+    private String decodeUnicode(final String value, final char escape) {
+        StringBuilder result = new StringBuilder();
+        int index = 0;
+        while (index < value.length()) {
+            char character = value.charAt(index);
+            if (escape != character) {
+                result.append(character);
+                index++;
+            } else if (escape == value.charAt(index + 1)) {
+                result.append(escape);
+                index += 2;
+            } else {
+                int startIndex = index + 1;
+                int length = '+' == value.charAt(startIndex) ? 6 : 4;
+                startIndex += 6 == length ? 1 : 0;
+                result.appendCodePoint(Integer.parseInt(value.substring(startIndex, startIndex + length), 16));
+                index = startIndex + length;
+            }
+        }
+        return result.toString();
+    }
+    
     @Override
     public ASTNode visitColumnref(final ColumnrefContext ctx) {
+        if (null != ctx.indirection()) {
+            Collection<IndirectionElContext> elements = getTargetRuleContextFromParseTree(ctx.indirection(), IndirectionElContext.class);
+            if (elements.stream().anyMatch(each -> null != each.LBT_())) {
+                Collection<ExpressionSegment> children = new LinkedList<>();
+                children.add(createSubscriptColumn(ctx, elements));
+                collectFunctionParameters(ctx.indirection(), children);
+                return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), children);
+            }
+        }
+        if (null != ctx.indirection() && null != ctx.indirection().indirectionEl().DOT_ASTERISK_()) {
+            ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue("*"));
+            result.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+            return result;
+        }
         if (null != ctx.indirection() && null != ctx.indirection().indirectionEl().attrName()) {
             AttrNameContext attrName = ctx.indirection().indirectionEl().attrName();
             ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(attrName.getText()));
@@ -609,6 +919,24 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         return new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
     }
     
+    private ColumnSegment createSubscriptColumn(final ColumnrefContext ctx, final Collection<IndirectionElContext> elements) {
+        AttrNameContext columnName = null;
+        for (IndirectionElContext each : elements) {
+            if (null != each.LBT_()) {
+                break;
+            }
+            if (null != each.attrName()) {
+                columnName = each.attrName();
+            }
+        }
+        if (null == columnName) {
+            return new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+        }
+        ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), columnName.stop.getStopIndex(), new IdentifierValue(columnName.getText()));
+        result.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+        return result;
+    }
+    
     private InExpression createInSegment(final AExprContext ctx) {
         ExpressionSegment left = (ExpressionSegment) visit(ctx.aExpr(0));
         ExpressionSegment right = createInExpressionSegment(ctx.inExpr());
@@ -655,17 +983,34 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.TYPE_CAST_()) {
             return new TypeCastExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText(), (ExpressionSegment) visit(ctx.bExpr(0)), ctx.typeName().getText());
         }
+        if (null != ctx.TILDE_()) {
+            return new UnaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.bExpr(0)), ctx.TILDE_().getText(), getOriginalText(ctx));
+        }
+        if (2 == ctx.bExpr().size() && (null != ctx.CARET_() || null != ctx.ASTERISK_() || null != ctx.SLASH_() || null != ctx.MOD_() || null != ctx.PLUS_() || null != ctx.MINUS_())) {
+            ExpressionSegment left = (ExpressionSegment) visit(ctx.bExpr(0));
+            ExpressionSegment right = (ExpressionSegment) visit(ctx.bExpr(1));
+            return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, ctx.getChild(1).getText(), getOriginalText(ctx));
+        }
         if (null != ctx.qualOp()) {
+            if (1 == ctx.bExpr().size()) {
+                return new UnaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.bExpr(0)), ctx.qualOp().getText(), getOriginalText(ctx));
+            }
             ExpressionSegment left = (ExpressionSegment) visit(ctx.bExpr(0));
             ExpressionSegment right = (ExpressionSegment) visit(ctx.bExpr(1));
             String operator = ctx.qualOp().getText();
             String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
             return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
         }
-        for (BExprContext each : ctx.bExpr()) {
-            visit(each);
+        if (null != ctx.DISTINCT()) {
+            String operator = null == ctx.NOT() ? "IS DISTINCT FROM" : "IS NOT DISTINCT FROM";
+            return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.bExpr(0)),
+                    (ExpressionSegment) visit(ctx.bExpr(1)), operator, getOriginalText(ctx));
+        }
+        List<ExpressionSegment> children = ctx.bExpr().stream().map(each -> (ExpressionSegment) visit(each)).collect(Collectors.toList());
+        if (1 == children.size() && children.get(0) instanceof LiteralExpressionSegment && (null != ctx.PLUS_() || null != ctx.MINUS_())) {
+            return new LiteralExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
         }
-        return new LiteralExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx), children);
     }
     
     private ProjectionSegment createAggregationSegment(final FuncApplicationContext ctx, final String aggregationType, final Collection<ExpressionSegment> expressionSegments) {
@@ -754,22 +1099,22 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         result.setStopIndex(ctx.stop.getStartIndex());
         List<TerminalNode> numbers = ctx.NUMBER_();
         if (1 == numbers.size()) {
-            result.setPrecision(Integer.parseInt(numbers.get(0).getText()));
+            result.setPrecision(Integer.parseInt(numbers.get(0).getText().replace("_", "")));
         }
         if (2 == numbers.size()) {
-            result.setPrecision(Integer.parseInt(numbers.get(0).getText()));
-            result.setScale(Integer.parseInt(numbers.get(1).getText()));
+            result.setPrecision(Integer.parseInt(numbers.get(0).getText().replace("_", "")));
+            result.setScale(Integer.parseInt(numbers.get(1).getText().replace("_", "")));
         }
         return result;
     }
     
     @Override
     public ASTNode visitInsert(final InsertContext ctx) {
-        // TODO :FIXME, since there is no segment for insertValuesClause, InsertStatement is created by sub rule.
-        // TODO :deal with insert select
+        WithSegment with = null == ctx.withClause() ? null : (WithSegment) visit(ctx.withClause());
         InsertStatement insertStatement = (InsertStatement) visit(ctx.insertRest());
         InsertStatement.InsertStatementBuilder result = InsertStatement.builder()
                 .databaseType(insertStatement.getDatabaseType())
+                .with(with)
                 .table((SimpleTableSegment) visit(ctx.insertTarget()))
                 .insertColumns(insertStatement.getInsertColumns().orElse(null))
                 .insertSelect(insertStatement.getInsertSelect().orElse(null))
@@ -785,11 +1130,6 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         return actual;
     }
     
-    @Override
-    public ASTNode visitReturningClause(final ReturningClauseContext ctx) {
-        return new ReturningSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ProjectionsSegment) visit(ctx.targetList()));
-    }
-    
     @Override
     public ASTNode visitOptOnConflict(final OptOnConflictContext ctx) {
         Collection<ColumnAssignmentSegment> assignments = new LinkedList<>();
@@ -859,14 +1199,14 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
             InsertColumnsSegment insertColumnsSegment = new InsertColumnsSegment(insertColumns.start.getStartIndex() - 1, insertColumns.stop.getStopIndex() + 1, columns.getValue());
             result.insertColumns(insertColumnsSegment);
         }
-        if (null == ctx.DEFAULT()) {
-            SimpleSelectContext simpleSelect = ctx.select().selectNoParens().selectClauseN().simpleSelect();
-            ValuesClauseContext valuesClause = null == simpleSelect ? null : simpleSelect.valuesClause();
-            if (null == valuesClause) {
+        if (null != ctx.select()) {
+            SelectNoParensContext select = ctx.select().selectNoParens();
+            ValuesClauseContext values = null == select || null == select.selectClauseN().simpleSelect() ? null : select.selectClauseN().simpleSelect().valuesClause();
+            if (null == values || null != select.withClause() || null != select.sortClause() || null != select.selectLimit() || null != select.forLockingClause()) {
                 SelectStatement selectStatement = (SelectStatement) visit(ctx.select());
                 result.insertSelect(new SubquerySegment(ctx.select().start.getStartIndex(), ctx.select().stop.getStopIndex(), selectStatement, getOriginalText(ctx.select())));
             } else {
-                result.values(createInsertValuesSegments(valuesClause));
+                result.values(createInsertValuesSegments(values));
             }
         }
         return result.build();
@@ -885,17 +1225,23 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitInsertColumnItem(final InsertColumnItemContext ctx) {
-        visit(ctx.optIndirection());
-        if (null == ctx.optIndirection().indirectionEl()) {
-            return new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+        visitIndirectionExpressions(ctx.optIndirection());
+        if (null != ctx.optIndirection().indirectionEl() && null != ctx.optIndirection().indirectionEl().attrName()) {
+            AttrNameContext attrName = ctx.optIndirection().indirectionEl().attrName();
+            ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(attrName.getText()));
+            result.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+            return result;
         }
-        if (null == ctx.optIndirection().indirectionEl().attrName()) {
-            return new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.optIndirection().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+        return new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+    }
+    
+    private void visitIndirectionExpressions(final OptIndirectionContext ctx) {
+        if (null != ctx.optIndirection()) {
+            visitIndirectionExpressions(ctx.optIndirection());
+        }
+        if (null != ctx.indirectionEl()) {
+            visit(ctx.indirectionEl());
         }
-        ColumnSegment result = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.optIndirection().stop.getStopIndex(),
-                new IdentifierValue(ctx.optIndirection().indirectionEl().attrName().getText()));
-        result.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
-        return result;
     }
     
     private Collection<InsertValuesSegment> createInsertValuesSegments(final ValuesClauseContext ctx) {
@@ -953,11 +1299,31 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitSetTarget(final SetTargetContext ctx) {
-        if (null != ctx.indirection()) {
-            visit(ctx.indirection());
+        visitIndirectionExpressions(ctx.optIndirection());
+        List<IdentifierValue> fieldAttributes = getSetTargetFieldAttributes(ctx.optIndirection());
+        ColumnSegment result = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+        if (!fieldAttributes.isEmpty()) {
+            result.setNestedObjectAttributes(fieldAttributes);
         }
-        IdentifierValue identifierValue = new IdentifierValue(ctx.colId().getText());
-        return new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), identifierValue);
+        return result;
+    }
+    
+    private List<IdentifierValue> getSetTargetFieldAttributes(final OptIndirectionContext ctx) {
+        if (null == ctx.indirectionEl()) {
+            return Collections.emptyList();
+        }
+        List<IdentifierValue> result = new LinkedList<>();
+        OptIndirectionContext current = ctx;
+        while (null != current.indirectionEl()) {
+            ShardingSpherePreconditions.checkState(null == current.indirectionEl().ASTERISK_() && null == current.indirectionEl().DOT_ASTERISK_(),
+                    () -> new SQLParsingException("Only field indirection is supported in assignment targets"));
+            AttrNameContext attrName = current.indirectionEl().attrName();
+            if (null != attrName) {
+                result.add(0, new IdentifierValue(attrName.getText()));
+            }
+            current = current.optIndirection();
+        }
+        return result;
     }
     
     @Override
@@ -971,16 +1337,21 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitUpdate(final UpdateContext ctx) {
+        WithSegment with = null == ctx.withClause() ? null : (WithSegment) visit(ctx.withClause());
         SimpleTableSegment tableSegment = (SimpleTableSegment) visit(ctx.relationExprOptAlias());
         UpdateStatement.UpdateStatementBuilder result = UpdateStatement.builder()
                 .databaseType(databaseType)
+                .with(with)
                 .table(tableSegment)
                 .setAssignment((SetAssignmentSegment) visit(ctx.setClauseList()));
+        if (null != ctx.fromClause()) {
+            result.from((TableSegment) visit(ctx.fromClause()));
+        }
         if (null != ctx.whereOrCurrentClause()) {
             result.where((WhereSegment) visit(ctx.whereOrCurrentClause()));
         }
-        if (null != ctx.fromClause()) {
-            result.from((TableSegment) visit(ctx.fromClause()));
+        if (null != ctx.returningClause()) {
+            result.returning((ReturningSegment) visit(ctx.returningClause()));
         }
         UpdateStatement updateStatement = result.build();
         updateStatement.addParameterMarkers(getParameterMarkerSegments());
@@ -995,16 +1366,40 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitDelete(final DeleteContext ctx) {
-        SimpleTableSegment tableSegment = (SimpleTableSegment) visit(ctx.relationExprOptAlias());
-        DeleteStatement.DeleteStatementBuilder result = DeleteStatement.builder().databaseType(databaseType).table(tableSegment);
+        WithSegment with = null == ctx.withClause() ? null : (WithSegment) visit(ctx.withClause());
+        TableSegment tableSegment = createDeleteTableSegment(ctx);
+        DeleteStatement.DeleteStatementBuilder result = DeleteStatement.builder().databaseType(databaseType).table(tableSegment).with(with);
         if (null != ctx.whereOrCurrentClause()) {
             result.where((WhereSegment) visit(ctx.whereOrCurrentClause()));
         }
+        if (null != ctx.returningClause()) {
+            result.returning((ReturningSegment) visit(ctx.returningClause()));
+        }
         DeleteStatement deleteStatement = result.build();
         deleteStatement.addParameterMarkers(getParameterMarkerSegments());
         return deleteStatement;
     }
     
+    private TableSegment createDeleteTableSegment(final DeleteContext ctx) {
+        SimpleTableSegment tableSegment = (SimpleTableSegment) visit(ctx.relationExprOptAlias());
+        if (null == ctx.usingClause()) {
+            return tableSegment;
+        }
+        TableSegment usingTable = (TableSegment) visit(ctx.usingClause().fromList());
+        JoinTableSegment relationTable = new JoinTableSegment();
+        relationTable.setStartIndex(tableSegment.getStartIndex());
+        relationTable.setStopIndex(usingTable.getStopIndex());
+        relationTable.setLeft(tableSegment);
+        relationTable.setRight(usingTable);
+        relationTable.setJoinType(JoinType.COMMA.name());
+        DeleteMultiTableSegment result = new DeleteMultiTableSegment();
+        result.setStartIndex(tableSegment.getStartIndex());
+        result.setStopIndex(usingTable.getStopIndex());
+        result.getActualDeleteTables().add(tableSegment);
+        result.setRelationTable(relationTable);
+        return result;
+    }
+    
     @Override
     public ASTNode visitWhereOrCurrentClause(final WhereOrCurrentClauseContext ctx) {
         if (null != ctx.whereClause()) {
@@ -1013,7 +1408,21 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         int startIndex = ctx.CURRENT().getSymbol().getStartIndex();
         int stopIndex = ctx.stop.getStopIndex();
         String text = ctx.start.getInputStream().getText(new Interval(startIndex, stopIndex));
-        return new WhereSegment(ctx.start.getStartIndex(), stopIndex, new CommonExpressionSegment(startIndex, stopIndex, text));
+        return new WhereSegment(ctx.start.getStartIndex(), stopIndex, new CommonExpressionSegment(startIndex, stopIndex, text, Collections.emptyList()));
+    }
+    
+    @Override
+    public ASTNode visitReturningClause(final ReturningClauseContext ctx) {
+        ReturningSegment result = new ReturningSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ProjectionsSegment) visit(ctx.targetList()));
+        for (ReturningOptionContext each : ctx.returningOption()) {
+            AliasSegment alias = new AliasSegment(each.colId().start.getStartIndex(), each.colId().stop.getStopIndex(), new IdentifierValue(each.colId().getText()));
+            if (null != each.OLD()) {
+                result.setOldAlias(alias);
+            } else {
+                result.setNewAlias(alias);
+            }
+        }
+        return result;
     }
     
     @Override
@@ -1033,7 +1442,9 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.returningClause()) {
             result.returning((ReturningSegment) visit(ctx.returningClause()));
         }
-        return result.build();
+        MergeStatement mergeStatement = result.build();
+        mergeStatement.addParameterMarkers(getParameterMarkerSegments());
+        return mergeStatement;
     }
     
     @Override
@@ -1063,18 +1474,18 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitSelect(final SelectContext ctx) {
-        // TODO :Unsupported for withClause.
-        SelectStatement result = (SelectStatement) visit(ctx.selectNoParens());
+        SelectStatement result = (SelectStatement) visit(null == ctx.selectNoParens() ? ctx.selectWithParens() : ctx.selectNoParens());
         result.addParameterMarkers(getParameterMarkerSegments());
         return result;
     }
     
     @Override
     public ASTNode visitSelectNoParens(final SelectNoParensContext ctx) {
+        WithSegment with = null == ctx.withClause() ? null : (WithSegment) visit(ctx.withClause());
         SelectStatement result = (SelectStatement) visit(ctx.selectClauseN());
         SelectStatement.SelectStatementBuilder selectStatementBuilder = createSelectStatementBuilder(result);
-        if (null != ctx.withClause()) {
-            selectStatementBuilder.with((WithSegment) visit(ctx.withClause()));
+        if (null != with) {
+            selectStatementBuilder.with(with);
         }
         if (null != ctx.sortClause()) {
             selectStatementBuilder.orderBy((OrderBySegment) visit(ctx.sortClause()));
@@ -1099,15 +1510,37 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitCommonTableExpr(final CommonTableExprContext ctx) {
-        CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (AliasSegment) visit(ctx.alias()),
-                new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.preparableStmt().select()),
-                        getOriginalText(ctx.preparableStmt().select())));
+        DMLStatement statement = (DMLStatement) visit(ctx.preparableStmt());
+        int subqueryStartIndex = null == ctx.searchClause() && null == ctx.cycleClause() ? ctx.start.getStartIndex() : ctx.preparableStmt().start.getStartIndex();
+        int subqueryStopIndex = null == ctx.searchClause() && null == ctx.cycleClause() ? ctx.stop.getStopIndex() : ctx.preparableStmt().stop.getStopIndex();
+        SubquerySegment subquery = statement instanceof SelectStatement
+                ? new SubquerySegment(subqueryStartIndex, subqueryStopIndex, (SelectStatement) statement, getOriginalText(ctx.preparableStmt()))
+                : null;
+        CommonTableExpressionSegment result = new CommonTableExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (AliasSegment) visit(ctx.alias()), subquery,
+                statement instanceof SelectStatement ? null : statement);
         if (null != ctx.optNameList().nameList()) {
             result.getColumns().addAll(generateUsingColumn(ctx.optNameList().nameList()));
         }
+        if (null != ctx.searchClause()) {
+            result.getSearchColumns().addAll(generateUsingColumn(ctx.searchClause().nameList()));
+            result.getColumns().add(createColumnSegment(ctx.searchClause().colId()));
+        }
+        if (null != ctx.cycleClause()) {
+            result.getCycleColumns().addAll(generateUsingColumn(ctx.cycleClause().nameList()));
+            for (ColIdContext each : ctx.cycleClause().colId()) {
+                result.getColumns().add(createColumnSegment(each));
+            }
+            for (AexprConstContext each : ctx.cycleClause().aexprConst()) {
+                visit(each);
+            }
+        }
         return result;
     }
     
+    private ColumnSegment createColumnSegment(final ColIdContext ctx) {
+        return new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.getText()));
+    }
+    
     @Override
     public ASTNode visitAlias(final AliasContext ctx) {
         return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.identifier().getText()));
@@ -1257,7 +1690,9 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
             result.setOrderBySegment(orderBySegment);
         }
         if (null != ctx.frameClause()) {
-            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText()));
+            Collection<ExpressionSegment> children = new LinkedList<>();
+            collectFunctionParameters(ctx.frameClause(), children);
+            result.setFrameClause(new CommonExpressionSegment(ctx.frameClause().start.getStartIndex(), ctx.frameClause().stop.getStopIndex(), ctx.frameClause().getText(), children));
         }
     }
     
@@ -1382,11 +1817,25 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         if (null != ctx.tableReference()) {
             return getJoinTableSegment(ctx);
         }
-        if (null != ctx.functionTable() && null != ctx.functionTable().functionExprWindowless() && null != ctx.functionTable().functionExprWindowless().funcApplication()) {
+        if (null != ctx.functionTable()) {
             return getFunctionTableSegment(ctx);
         }
-        // TODO deal with functionTable and xmlTable
-        return new SimpleTableSegment(new TableNameSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue("not support")));
+        ExpressionSegment expression = (ExpressionSegment) visit(null == ctx.xmlTable() ? ctx.jsonTable() : ctx.xmlTable());
+        FunctionTableSegment result = new FunctionTableSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), expression);
+        if (null != ctx.aliasClause()) {
+            result.setAlias((AliasSegment) visit(ctx.aliasClause()));
+        }
+        if (null != ctx.xmlTable()) {
+            for (XmlTableColumnElContext each : ctx.xmlTable().xmlTableColumnList().xmlTableColumnEl()) {
+                result.getColumns().add(createColumnSegment(each.colId()));
+            }
+        } else {
+            collectJsonTableColumns(ctx.jsonTable().jsonTableColumn(), result.getColumns());
+        }
+        if (null != ctx.aliasClause() && null != ctx.aliasClause().nameList()) {
+            applyTableFunctionColumnAliases(result.getColumns(), ctx.aliasClause().nameList());
+        }
+        return result;
     }
     
     private SimpleTableSegment getSimpleTableSegment(final TableReferenceContext ctx) {
@@ -1409,35 +1858,146 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     private ASTNode getJoinTableSegment(final TableReferenceContext ctx) {
         JoinTableSegment result = new JoinTableSegment();
         result.setLeft((TableSegment) visit(ctx.tableReference()));
-        int startIndex = null == ctx.LP_() ? ctx.tableReference().start.getStartIndex() : ctx.LP_().getSymbol().getStartIndex();
-        int stopIndex = 0;
-        AliasSegment alias = null;
-        if (null == ctx.aliasClause()) {
-            stopIndex = null == ctx.RP_() ? ctx.tableReference().start.getStopIndex() : ctx.RP_().getSymbol().getStopIndex();
-        } else {
-            alias = (AliasSegment) visit(ctx.aliasClause());
-            startIndex = null == ctx.RP_() ? ctx.joinedTable().stop.getStopIndex() : ctx.RP_().getSymbol().getStopIndex();
-        }
-        result.setStartIndex(startIndex);
-        result.setStopIndex(stopIndex);
+        result.setStartIndex(ctx.start.getStartIndex());
+        result.setStopIndex(ctx.stop.getStopIndex());
         visitJoinedTable(ctx.joinedTable(), result);
-        result.setAlias(alias);
+        if (null != ctx.aliasClause()) {
+            result.setAlias((AliasSegment) visit(ctx.aliasClause()));
+        }
         return result;
     }
     
     private FunctionTableSegment getFunctionTableSegment(final TableReferenceContext ctx) {
-        FunctionSegment functionSegment = (FunctionSegment) visit(ctx.functionTable().functionExprWindowless().funcApplication());
-        FunctionTableSegment result = new FunctionTableSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), functionSegment);
+        ExpressionSegment expression;
+        Collection<ColumnSegment> columns = new LinkedList<>();
+        if (null != ctx.functionTable().functionExprWindowless()) {
+            expression = (ExpressionSegment) visit(ctx.functionTable().functionExprWindowless());
+        } else {
+            FunctionSegment function = new FunctionSegment(ctx.functionTable().start.getStartIndex(), ctx.functionTable().stop.getStopIndex(), "ROWS FROM", getOriginalText(ctx.functionTable()));
+            for (RowsFromItemContext each : ctx.functionTable().rowsFromList().rowsFromItem()) {
+                function.getParameters().add((ExpressionSegment) visit(each.functionExprWindowless()));
+                if (null != each.columnDefList()) {
+                    columns.addAll(createTableFunctionColumns(each.columnDefList().tableFuncElementList().tableFuncElement()));
+                }
+            }
+            expression = function;
+        }
+        FunctionTableSegment result = new FunctionTableSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), expression);
+        result.getColumns().addAll(columns);
         if (null != ctx.funcAliasClause() && null != ctx.funcAliasClause().aliasClause()) {
             AliasClauseContext aliasClause = ctx.funcAliasClause().aliasClause();
             result.setAlias((AliasSegment) visit(aliasClause));
             if (null != aliasClause.nameList()) {
-                result.getColumns().addAll(generateUsingColumn(aliasClause.nameList()));
+                applyTableFunctionColumnAliases(result.getColumns(), aliasClause.nameList());
+            }
+        } else if (null != ctx.funcAliasClause()) {
+            if (null != ctx.funcAliasClause().colId()) {
+                ColIdContext alias = ctx.funcAliasClause().colId();
+                result.setAlias(new AliasSegment(alias.start.getStartIndex(), alias.stop.getStopIndex(), new IdentifierValue(alias.getText())));
+            }
+            result.getColumns().addAll(createTableFunctionColumns(ctx.funcAliasClause().tableFuncElementList().tableFuncElement()));
+        }
+        return result;
+    }
+    
+    private Collection<ColumnSegment> createTableFunctionColumns(final Collection<TableFuncElementContext> contexts) {
+        Collection<ColumnSegment> result = new LinkedList<>();
+        for (TableFuncElementContext each : contexts) {
+            result.add(createColumnSegment(each.colId()));
+        }
+        return result;
+    }
+    
+    private void collectJsonTableColumns(final Collection<JsonTableColumnContext> contexts, final Collection<ColumnSegment> columns) {
+        for (JsonTableColumnContext each : contexts) {
+            if (null == each.NESTED()) {
+                columns.add(createColumnSegment(each.colId()));
+            } else {
+                collectJsonTableColumns(each.jsonTableColumn(), columns);
+            }
+        }
+    }
+    
+    private void applyTableFunctionColumnAliases(final Collection<ColumnSegment> columns, final NameListContext aliases) {
+        List<ColumnSegment> result = generateUsingColumn(aliases);
+        if (result.size() < columns.size()) {
+            result.addAll(new ArrayList<>(columns).subList(result.size(), columns.size()));
+        }
+        columns.clear();
+        columns.addAll(result);
+    }
+    
+    @Override
+    public ASTNode visitJsonTable(final JsonTableContext ctx) {
+        return createJsonFunction(ctx);
+    }
+    
+    @Override
+    public ASTNode visitJsonTablePath(final JsonTablePathContext ctx) {
+        if (null == ctx.STRING_()) {
+            String delimiter = ctx.BEGIN_DOLLAR_STRING_CONSTANT().getText();
+            String text = ctx.getText();
+            return new LiteralExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), text.substring(delimiter.length(), text.length() - delimiter.length()));
+        }
+        StringLiteralValue value = createStringLiteralValue(ctx.STRING_().getText(), null != ctx.UNICODE_ESCAPE(), ctx.uescape());
+        return SQLUtils.createLiteralExpression(value, ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
+    }
+    
+    @Override
+    public ASTNode visitXmlTable(final XmlTableContext ctx) {
+        XmlTableOptionsSegment options = new XmlTableOptionsSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
+        XmlNamespacesClauseSegment namespaces = createXmlNamespaces(ctx, options.getParameters());
+        options.getParameters().add((ExpressionSegment) visit(ctx.cExpr()));
+        options.getParameters().add((ExpressionSegment) visit(ctx.xmlExistsArgument().cExpr()));
+        for (XmlTableColumnElContext each : ctx.xmlTableColumnList().xmlTableColumnEl()) {
+            options.getXmlTableColumnSegments().add(createXmlTableColumn(each, options.getParameters()));
+        }
+        return new XmlTableFunctionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.XMLTABLE().getText(), namespaces, getOriginalText(ctx.cExpr()), options, getOriginalText(ctx));
+    }
+    
+    @Nullable
+    private XmlNamespacesClauseSegment createXmlNamespaces(final XmlTableContext ctx, final Collection<ExpressionSegment> params) {
+        if (null == ctx.xmlNamespaceList()) {
+            return null;
+        }
+        String defaultString = null;
+        Collection<XmlNamespaceStringAsIdentifierSegment> stringsAsIdentifiers = new LinkedList<>();
+        for (XmlNamespaceElContext each : ctx.xmlNamespaceList().xmlNamespaceEl()) {
+            params.add((ExpressionSegment) visit(each.bExpr()));
+            if (null == each.identifier()) {
+                defaultString = getOriginalText(each.bExpr());
+            } else {
+                stringsAsIdentifiers.add(new XmlNamespaceStringAsIdentifierSegment(each.start.getStartIndex(), each.stop.getStopIndex(), getOriginalText(each.bExpr()),
+                        new IdentifierValue(each.identifier().getText()).getValue(), getOriginalText(each)));
             }
         }
+        XmlNamespacesClauseSegment result = new XmlNamespacesClauseSegment(ctx.xmlNamespaceList().start.getStartIndex(), ctx.xmlNamespaceList().stop.getStopIndex(), defaultString,
+                getOriginalText(ctx.xmlNamespaceList()));
+        result.getStringAsIdentifier().addAll(stringsAsIdentifiers);
         return result;
     }
     
+    private XmlTableColumnSegment createXmlTableColumn(final XmlTableColumnElContext ctx, final Collection<ExpressionSegment> params) {
+        ExpressionSegment defaultExpr = null;
+        String path = null;
+        Collection<XmlTableColumnOptionElContext> options = null == ctx.xmlTableColumnOptionList() ? Collections.emptyList()
+                : getTargetRuleContextFromParseTree(ctx.xmlTableColumnOptionList(), XmlTableColumnOptionElContext.class);
+        for (XmlTableColumnOptionElContext each : options) {
+            if (null == each.bExpr()) {
+                continue;
+            }
+            ExpressionSegment expression = (ExpressionSegment) visit(each.bExpr());
+            if (null != each.DEFAULT()) {
+                defaultExpr = expression;
+            } else {
+                path = getOriginalText(each.bExpr());
+                params.add(expression);
+            }
+        }
+        return new XmlTableColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()).getValue(),
+                null == ctx.typeName() ? null : getOriginalText(ctx.typeName()), path, defaultExpr, getOriginalText(ctx));
+    }
+    
     @Override
     public ASTNode visitFuncApplication(final FuncApplicationContext ctx) {
         Collection<ExpressionSegment> expressionSegments = getExpressionSegments(getTargetRuleContextFromParseTree(ctx, AExprContext.class));
@@ -1512,6 +2072,9 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
         }
         if (null != ctx.USING()) {
             joinTableSource.setUsing(generateUsingColumn(ctx.nameList()));
+            if (null != ctx.colId()) {
+                joinTableSource.setUsingAlias(new AliasSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+            }
         }
     }
     
@@ -1559,10 +2122,14 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitSelectLimit(final SelectLimitContext ctx) {
-        if (null != ctx.limitClause() && null != ctx.offsetClause()) {
-            return createLimitSegmentWhenLimitAndOffset(ctx);
+        LimitSegment result = null != ctx.limitClause() && null != ctx.offsetClause() ? createLimitSegmentWhenLimitAndOffset(ctx) : createLimitSegmentWhenRowCountOrOffsetAbsent(ctx);
+        if (null != ctx.limitClause() && null != ctx.limitClause().FETCH()) {
+            result.setWithTies(null != ctx.limitClause().onlyOrWithTies().TIES());
+            if (null == ctx.limitClause().selectFetchValue()) {
+                result.setImplicitRowCount(true);
+            }
         }
-        return createLimitSegmentWhenRowCountOrOffsetAbsent(ctx);
+        return result;
     }
     
     @Override
@@ -1630,12 +2197,7 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     private LimitSegment createLimitSegmentWhenRowCountOrOffsetAbsent(final SelectLimitContext ctx) {
         if (null != ctx.limitClause()) {
-            if (null != ctx.limitClause().selectFetchValue()) {
-                LimitValueSegment limit = (LimitValueSegment) visit(ctx.limitClause().selectFetchValue());
-                return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), null, limit);
-            }
-            LimitValueSegment limit = (LimitValueSegment) visit(ctx.limitClause().selectLimitValue());
-            return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), null, limit);
+            return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), null, createRowCountValueSegment(ctx.limitClause()));
         }
         LimitValueSegment offset = (LimitValueSegment) visit(ctx.offsetClause().selectOffsetValue());
         return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, null);
@@ -1702,6 +2264,6 @@ public abstract class PostgreSQLStatementVisitor extends PostgreSQLStatementPars
     
     @Override
     public ASTNode visitSignedIconst(final SignedIconstContext ctx) {
-        return new NumberLiteralValue(ctx.getText());
+        return new NumberLiteralValue(ctx.getText().replace("_", ""));
     }
 }
diff --git a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDALStatementVisitor.java b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDALStatementVisitor.java
index 7c815d66477..065ea5e8263 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDALStatementVisitor.java
+++ b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDALStatementVisitor.java
@@ -35,16 +35,19 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Va
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.VacuumRelationContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.VacuumRelationListContext;
 import org.apache.shardingsphere.sql.parser.engine.postgresql.visitor.statement.PostgreSQLStatementVisitor;
+import org.apache.shardingsphere.sql.parser.statement.core.extractor.TableExtractor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dal.VariableAssignSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dal.VariableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.SQLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.AnalyzeTableStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.EmptyStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.ExplainStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.SetStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.ShowStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.collection.CollectionValue;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.dal.PostgreSQLCheckpointStatement;
@@ -118,7 +121,13 @@ public final class PostgreSQLDALStatementVisitor extends PostgreSQLStatementVisi
     
     @Override
     public ASTNode visitResetParameter(final ResetParameterContext ctx) {
-        return new PostgreSQLResetParameterStatement(getDatabaseType(), null == ctx.ALL() ? ctx.identifier().getText() : "ALL");
+        if (null != ctx.varName()) {
+            return new PostgreSQLResetParameterStatement(getDatabaseType(), ctx.varName().getText());
+        }
+        if (null != ctx.ZONE()) {
+            return new PostgreSQLResetParameterStatement(getDatabaseType(), "timezone");
+        }
+        return new PostgreSQLResetParameterStatement(getDatabaseType(), null == ctx.AUTHORIZATION() ? "ALL" : "session_authorization");
     }
     
     @SuppressWarnings("unchecked")
@@ -151,7 +160,17 @@ public final class PostgreSQLDALStatementVisitor extends PostgreSQLStatementVisi
     
     @Override
     public ASTNode visitExplain(final ExplainContext ctx) {
-        return new ExplainStatement(getDatabaseType(), (SQLStatement) visit(ctx.explainableStmt()));
+        SQLStatement explainableStatement = (SQLStatement) visit(ctx.explainableStmt());
+        ExplainStatement result = new ExplainStatement(getDatabaseType(), explainableStatement);
+        if (null != explainableStatement) {
+            result.addParameterMarkers(explainableStatement.getParameterMarkers());
+        }
+        if (explainableStatement instanceof MergeStatement) {
+            TableExtractor extractor = new TableExtractor();
+            extractor.extractTablesFromMerge((MergeStatement) explainableStatement);
+            result.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables().addAll(extractor.getRewriteTables());
+        }
+        return result;
     }
     
     @Override
@@ -168,6 +187,12 @@ public final class PostgreSQLDALStatementVisitor extends PostgreSQLStatementVisi
         if (null != ctx.delete()) {
             return visit(ctx.delete());
         }
+        if (null != ctx.merge()) {
+            return visit(ctx.merge());
+        }
+        if (null != ctx.createTable()) {
+            return new PostgreSQLDDLStatementVisitor(getDatabaseType()).visit(ctx.createTable());
+        }
         if (null != ctx.declare()) {
             // TODO visit declare statement
             return visit(ctx.declare());
diff --git a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDDLStatementVisitor.java b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDDLStatementVisitor.java
index 21b591ea8c0..78a2eaeb9a9 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDDLStatementVisitor.java
+++ b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDDLStatementVisitor.java
@@ -33,6 +33,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Al
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterDefaultPrivilegesContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterDefinitionClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterDomainContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterEventTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterExtensionContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterForeignDataWrapperContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterForeignTableContext;
@@ -40,8 +41,11 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Al
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterGroupContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterIndexContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterLanguageContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterLargeObjectContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterMaterializedViewContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterOperatorClassContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterOperatorContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterOperatorFamilyContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterPolicyContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterProcedureContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterPublicationContext;
@@ -62,6 +66,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Al
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterTextSearchTemplateContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterTypeContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterUserMappingContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AlterViewContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BackwardAllContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BackwardContext;
@@ -70,6 +75,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Cl
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ClusterContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnConstraintContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnDefinitionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CommentContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CountContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateAccessMethodContext;
@@ -89,18 +95,25 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Cr
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateIndexContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateLanguageContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateMaterializedViewContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateOperatorClassContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateOperatorContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateOperatorFamilyContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreatePolicyContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateProcedureContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreatePublicationContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateRuleContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateSchemaContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateSequenceContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateServerContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateStatisticsContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateSubscriptionContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTableContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTablespaceContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTextSearchContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTransformContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateTypeContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateUserMappingContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CreateViewContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CursorNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DeallocateContext;
@@ -143,6 +156,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Dr
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DropTextSearchContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DropTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DropTypeContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DropUserMappingContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DropViewContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FetchContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FirstContext;
@@ -151,10 +165,12 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Fo
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ForwardCountContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FuncArgExprContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FunctionExprWindowlessContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ImportForeignSchemaContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexElemContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexNamesContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexParamsContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.KeyColumnNamesContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LastContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ListenContext;
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ModifyColumnSpecificationContext;
@@ -182,6 +198,7 @@ import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.Un
 import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ValidateConstraintSpecificationContext;
 import org.apache.shardingsphere.sql.parser.engine.postgresql.visitor.statement.PostgreSQLStatementVisitor;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.DirectionType;
+import org.apache.shardingsphere.sql.parser.statement.core.extractor.ColumnExtractor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.AlterDefinitionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.CreateDefinitionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.column.ColumnDefinitionSegment;
@@ -204,6 +221,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.table.Ren
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.DataTypeSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.NameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.OwnerSegment;
@@ -244,6 +262,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.se
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.sequence.CreateSequenceStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.sequence.DropSequenceStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.server.AlterServerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.server.CreateServerStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.server.DropServerStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.AlterTableStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.CreateTableStatement;
@@ -266,18 +285,29 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.vi
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.view.RefreshMatViewStmtStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.collection.CollectionValue;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.apache.shardingsphere.sql.parser.statement.core.value.literal.impl.NumberLiteralValue;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterDefaultPrivilegesStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterLargeObjectStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterOperatorClassStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterOperatorFamilyStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterUserMappingStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLClusterStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateOperatorClassStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateOperatorFamilyStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateTransformStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateUserMappingStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDeclareStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDiscardStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDropOperatorClassStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDropOperatorFamilyStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDropOwnedStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDropUserMappingStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLImportForeignSchemaStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLListenStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLNotifyStmtStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLOpenStatement;
@@ -293,6 +323,7 @@ import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.cast.Postgr
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.conversion.PostgreSQLAlterConversionStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.conversion.PostgreSQLCreateConversionStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.conversion.PostgreSQLDropConversionStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event.PostgreSQLAlterEventTriggerStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event.PostgreSQLCreateEventTriggerStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event.PostgreSQLDropEventTriggerStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.extension.PostgreSQLAlterExtensionStatement;
@@ -322,8 +353,10 @@ import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.rule.Postgr
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.rule.PostgreSQLCreateRuleStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.rule.PostgreSQLDropRuleStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.statistics.PostgreSQLAlterStatisticsStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.statistics.PostgreSQLCreateStatisticsStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.statistics.PostgreSQLDropStatisticsStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription.PostgreSQLAlterSubscriptionStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription.PostgreSQLCreateSubscriptionStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription.PostgreSQLDropSubscriptionStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.textsearch.PostgreSQLAlterTextSearchStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.textsearch.PostgreSQLCreateTextSearchStatement;
@@ -334,6 +367,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
@@ -361,18 +395,30 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
                 }
             }
         }
+        List<ColumnSegment> columns = Collections.emptyList();
+        if (null != ctx.columnNames()) {
+            columns = new ArrayList<>(ctx.columnNames().columnName().size());
+            for (ColumnNameContext each : ctx.columnNames().columnName()) {
+                columns.add((ColumnSegment) visit(each));
+            }
+        }
         SelectStatement selectStatement = null == ctx.select() ? null : (SelectStatement) visit(ctx.select());
         CreateTableStatement result = CreateTableStatement.builder()
                 .databaseType(getDatabaseType())
                 .table((SimpleTableSegment) visit(ctx.tableName()))
                 .ifNotExists(null != ctx.ifNotExists())
                 .selectStatement(selectStatement)
+                .columns(columns)
                 .columnDefinitions(columnDefinitions)
                 .constraintDefinitions(constraintDefinitions)
                 .build();
         if (null != selectStatement) {
             result.addParameterMarkers(selectStatement.getParameterMarkers());
         }
+        if (null != ctx.executeParamClause()) {
+            visit(ctx.executeParamClause().exprList());
+            result.addParameterMarkers(getParameterMarkerSegments());
+        }
         return result;
     }
     
@@ -616,7 +662,7 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
             result.setConstraintName((ConstraintSegment) visit(ctx.constraintClause().constraintName()));
         }
         if (null != ctx.tableConstraintOption().primaryKey()) {
-            result.getPrimaryKeyColumns().addAll(((CollectionValue<ColumnSegment>) visit(ctx.tableConstraintOption().columnNames(0))).getValue());
+            result.getPrimaryKeyColumns().addAll(((CollectionValue<ColumnSegment>) visit(ctx.tableConstraintOption().keyColumnNames())).getValue());
         }
         if (null != ctx.tableConstraintOption().FOREIGN()) {
             result.setReferencedTable((SimpleTableSegment) visit(ctx.tableConstraintOption().tableName()));
@@ -624,6 +670,15 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
         return result;
     }
     
+    @Override
+    public ASTNode visitKeyColumnNames(final KeyColumnNamesContext ctx) {
+        CollectionValue<ColumnSegment> result = new CollectionValue<>();
+        for (ColumnNameContext each : ctx.columnName()) {
+            result.getValue().add((ColumnSegment) visit(each));
+        }
+        return result;
+    }
+    
     @Override
     public ASTNode visitModifyColumnSpecification(final ModifyColumnSpecificationContext ctx) {
         // TODO visit pk and table ref
@@ -713,7 +768,12 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
                 result.getValue().add(new ColumnSegment(each.colId().start.getStartIndex(), each.colId().stop.getStopIndex(), new IdentifierValue(each.colId().getText())));
             }
             if (null != each.functionExprWindowless()) {
-                FunctionSegment functionSegment = (FunctionSegment) visit(each.functionExprWindowless());
+                ExpressionSegment expression = (ExpressionSegment) visit(each.functionExprWindowless());
+                if (expression instanceof TypeCastExpression) {
+                    result.getValue().addAll(ColumnExtractor.extract(expression));
+                    continue;
+                }
+                FunctionSegment functionSegment = (FunctionSegment) expression;
                 functionSegment.getParameters().forEach(param -> {
                     if (param instanceof ColumnSegment) {
                         result.getValue().add((ColumnSegment) param);
@@ -726,8 +786,13 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
     
     @Override
     public ASTNode visitFunctionExprWindowless(final FunctionExprWindowlessContext ctx) {
+        if (null == ctx.funcApplication()) {
+            return visit(ctx.functionExprCommonSubexpr());
+        }
         FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.funcApplication().funcName().getText(), getOriginalText(ctx));
-        result.getParameters().addAll(getExpressions(ctx.funcApplication().funcArgList().funcArgExpr()));
+        if (null != ctx.funcApplication().funcArgList()) {
+            result.getParameters().addAll(getExpressions(ctx.funcApplication().funcArgList().funcArgExpr()));
+        }
         return result;
     }
     
@@ -810,6 +875,76 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
         return new AlterProcedureStatement(getDatabaseType());
     }
     
+    @Override
+    public ASTNode visitCreateStatistics(final CreateStatisticsContext ctx) {
+        return new PostgreSQLCreateStatisticsStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateSubscription(final CreateSubscriptionContext ctx) {
+        return new PostgreSQLCreateSubscriptionStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateOperatorClass(final CreateOperatorClassContext ctx) {
+        return new PostgreSQLCreateOperatorClassStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitAlterOperatorClass(final AlterOperatorClassContext ctx) {
+        return new PostgreSQLAlterOperatorClassStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateOperatorFamily(final CreateOperatorFamilyContext ctx) {
+        return new PostgreSQLCreateOperatorFamilyStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitAlterOperatorFamily(final AlterOperatorFamilyContext ctx) {
+        return new PostgreSQLAlterOperatorFamilyStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitAlterEventTrigger(final AlterEventTriggerContext ctx) {
+        return new PostgreSQLAlterEventTriggerStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitImportForeignSchema(final ImportForeignSchemaContext ctx) {
+        return new PostgreSQLImportForeignSchemaStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateServer(final CreateServerContext ctx) {
+        return new CreateServerStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateUserMapping(final CreateUserMappingContext ctx) {
+        return new PostgreSQLCreateUserMappingStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitAlterUserMapping(final AlterUserMappingContext ctx) {
+        return new PostgreSQLAlterUserMappingStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitDropUserMapping(final DropUserMappingContext ctx) {
+        return new PostgreSQLDropUserMappingStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitCreateTransform(final CreateTransformContext ctx) {
+        return new PostgreSQLCreateTransformStatement(getDatabaseType());
+    }
+    
+    @Override
+    public ASTNode visitAlterLargeObject(final AlterLargeObjectContext ctx) {
+        return new PostgreSQLAlterLargeObjectStatement(getDatabaseType());
+    }
+    
     @Override
     public ASTNode visitCreateFunction(final CreateFunctionContext ctx) {
         return new CreateFunctionStatement(getDatabaseType(), null, null, Collections.emptyList());
@@ -823,12 +958,8 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
     @Override
     public ASTNode visitCreateTrigger(final CreateTriggerContext ctx) {
         CreateTriggerStatement result = new CreateTriggerStatement(getDatabaseType());
-        if (null != ctx.name()) {
-            result.setTriggerName(new FunctionNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), new IdentifierValue(ctx.name().getText())));
-        }
-        if (null != ctx.qualifiedName()) {
-            result.setTable((SimpleTableSegment) visit(ctx.qualifiedName()));
-        }
+        result.setTriggerName(new FunctionNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), new IdentifierValue(ctx.name().getText())));
+        result.setTable((SimpleTableSegment) visit(ctx.qualifiedName(0)));
         return result;
     }
     
@@ -872,7 +1003,9 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
     
     @Override
     public ASTNode visitDropDatabase(final DropDatabaseContext ctx) {
-        return new DropDatabaseStatement(getDatabaseType(), ((IdentifierValue) visit(ctx.name())).getValue(), null != ctx.ifExists());
+        DropDatabaseStatement result = new DropDatabaseStatement(getDatabaseType(), ((IdentifierValue) visit(ctx.name())).getValue(), null != ctx.ifExists());
+        result.setForce(null != ctx.FORCE());
+        return result;
     }
     
     @Override
@@ -929,6 +1062,7 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
                 .insert(null == ctx.preparableStmt().insert() ? null : (InsertStatement) visit(ctx.preparableStmt().insert()))
                 .update(null == ctx.preparableStmt().update() ? null : (UpdateStatement) visit(ctx.preparableStmt().update()))
                 .delete(null == ctx.preparableStmt().delete() ? null : (DeleteStatement) visit(ctx.preparableStmt().delete()))
+                .merge(null == ctx.preparableStmt().merge() ? null : (MergeStatement) visit(ctx.preparableStmt().merge()))
                 .build();
     }
     
@@ -1258,8 +1392,13 @@ public final class PostgreSQLDDLStatementVisitor extends PostgreSQLStatementVisi
     
     @Override
     public ASTNode visitCluster(final ClusterContext ctx) {
-        return new PostgreSQLClusterStatement(getDatabaseType(), null == ctx.tableName() ? null : (SimpleTableSegment) visit(ctx.tableName()),
-                null == ctx.clusterIndexSpecification() ? null : (IndexSegment) visit(ctx.clusterIndexSpecification().indexName()));
+        IndexSegment index = null;
+        if (null != ctx.indexName()) {
+            index = (IndexSegment) visit(ctx.indexName());
+        } else if (null != ctx.clusterIndexSpecification()) {
+            index = (IndexSegment) visit(ctx.clusterIndexSpecification().indexName());
+        }
+        return new PostgreSQLClusterStatement(getDatabaseType(), null == ctx.tableName() ? null : (SimpleTableSegment) visit(ctx.tableName()), index);
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDMLStatementVisitor.java b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDMLStatementVisitor.java
index 2196f1939da..2b2af14d552 100644
--- a/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/engine/postgresql/visitor/statement/type/PostgreSQLDMLStatementVisitor.java
@@ -39,6 +39,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.Ca
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DoStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.collection.CollectionValue;
@@ -71,7 +72,7 @@ public final class PostgreSQLDMLStatementVisitor extends PostgreSQLStatementVisi
     public ASTNode visitCallArgument(final CallArgumentContext ctx) {
         if (null == ctx.positionalNotation()) {
             String text = ctx.namedNotation().start.getInputStream().getText(new Interval(ctx.namedNotation().start.getStartIndex(), ctx.namedNotation().stop.getStopIndex()));
-            return new CommonExpressionSegment(ctx.namedNotation().getStart().getStartIndex(), ctx.namedNotation().getStop().getStopIndex(), text);
+            return new CommonExpressionSegment(ctx.namedNotation().getStart().getStartIndex(), ctx.namedNotation().getStop().getStopIndex(), text, Collections.emptyList());
         }
         return visit(ctx.positionalNotation().aExpr());
     }
@@ -108,6 +109,8 @@ public final class PostgreSQLDMLStatementVisitor extends PostgreSQLStatementVisi
             result.setInsert((InsertStatement) visit(ctx.insert()));
         } else if (null != ctx.update()) {
             result.setUpdate((UpdateStatement) visit(ctx.update()));
+        } else if (null != ctx.merge()) {
+            result.setMerge((MergeStatement) visit(ctx.merge()));
         } else {
             result.setDelete((DeleteStatement) visit(ctx.delete()));
         }
diff --git a/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/PrestoStatementVisitor.java b/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/PrestoStatementVisitor.java
index 520e8b3aa3d..3a0d266e71e 100644
--- a/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/PrestoStatementVisitor.java
+++ b/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/PrestoStatementVisitor.java
@@ -98,6 +98,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.value.parametermarker
 
 import java.math.BigDecimal;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -529,7 +530,7 @@ public abstract class PrestoStatementVisitor extends PrestoStatementBaseVisitor<
             visit(each);
         }
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/type/PrestoDMLStatementVisitor.java b/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/type/PrestoDMLStatementVisitor.java
index 74689265f79..7c25ace3506 100644
--- a/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/type/PrestoDMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/presto/src/main/java/org/apache/shardingsphere/sql/parser/engine/presto/visitor/statement/type/PrestoDMLStatementVisitor.java
@@ -374,7 +374,7 @@ public final class PrestoDMLStatementVisitor extends PrestoStatementVisitor impl
         }
         if (null != ctx.windowSpecification().frameClause()) {
             result.setFrameClause(new CommonExpressionSegment(ctx.windowSpecification().frameClause().start.getStartIndex(), ctx.windowSpecification().frameClause().stop.getStopIndex(),
-                    getOriginalText(ctx.windowSpecification().frameClause())));
+                    getOriginalText(ctx.windowSpecification().frameClause()), Collections.emptyList()));
         }
         return result;
     }
@@ -751,7 +751,7 @@ public final class PrestoDMLStatementVisitor extends PrestoStatementVisitor impl
     public ASTNode visitMatchExpression(final MatchExpressionContext ctx) {
         visit(ctx.expr());
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
@@ -937,12 +937,12 @@ public final class PrestoDMLStatementVisitor extends PrestoStatementVisitor impl
         if (null != expr) {
             ASTNode result = visit(expr);
             if (result instanceof ColumnSegment) {
-                return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+                return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
             } else {
                 return result;
             }
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/SQL92StatementVisitor.java b/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/SQL92StatementVisitor.java
index cc3e7c5fcf9..6af24a5dc74 100644
--- a/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/SQL92StatementVisitor.java
+++ b/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/SQL92StatementVisitor.java
@@ -384,7 +384,7 @@ public abstract class SQL92StatementVisitor extends SQL92StatementBaseVisitor<AS
             return new SubqueryExpressionSegment((SubquerySegment) astNode);
         }
         if (astNode instanceof OtherLiteralValue) {
-            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), ((OtherLiteralValue) astNode).getValue());
+            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), ((OtherLiteralValue) astNode).getValue(), Collections.emptyList());
         }
         return astNode;
     }
@@ -414,7 +414,7 @@ public abstract class SQL92StatementVisitor extends SQL92StatementBaseVisitor<AS
         if (null != ctx.columnName()) {
             return visit(ctx.columnName());
         }
-        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText());
+        return new CommonExpressionSegment(startIndex, stopIndex, ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/type/SQL92DMLStatementVisitor.java b/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/type/SQL92DMLStatementVisitor.java
index 49c233b5bb2..84db3222bff 100644
--- a/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/type/SQL92DMLStatementVisitor.java
+++ b/parser/sql/engine/dialect/sql92/src/main/java/org/apache/shardingsphere/sql/parser/engine/sql92/visitor/statement/type/SQL92DMLStatementVisitor.java
@@ -193,7 +193,7 @@ public final class SQL92DMLStatementVisitor extends SQL92StatementVisitor implem
         if (null != expr) {
             return visit(expr);
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/engine/dialect/sqlserver/src/main/java/org/apache/shardingsphere/sql/parser/engine/sqlserver/visitor/statement/SQLServerStatementVisitor.java b/parser/sql/engine/dialect/sqlserver/src/main/java/org/apache/shardingsphere/sql/parser/engine/sqlserver/visitor/statement/SQLServerStatementVisitor.java
index 154e1d1c970..7ca5859d71a 100644
--- a/parser/sql/engine/dialect/sqlserver/src/main/java/org/apache/shardingsphere/sql/parser/engine/sqlserver/visitor/statement/SQLServerStatementVisitor.java
+++ b/parser/sql/engine/dialect/sqlserver/src/main/java/org/apache/shardingsphere/sql/parser/engine/sqlserver/visitor/statement/SQLServerStatementVisitor.java
@@ -638,7 +638,7 @@ public abstract class SQLServerStatementVisitor extends SQLServerStatementBaseVi
             return new SubqueryExpressionSegment((SubquerySegment) astNode);
         }
         if (astNode instanceof OtherLiteralValue) {
-            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText());
+            return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText(), Collections.emptyList());
         }
         return astNode;
     }
@@ -698,7 +698,7 @@ public abstract class SQLServerStatementVisitor extends SQLServerStatementBaseVi
             visit(each);
         }
         String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text, Collections.emptyList());
     }
     
     @Override
@@ -1287,7 +1287,8 @@ public abstract class SQLServerStatementVisitor extends SQLServerStatementBaseVi
         for (CteClauseContext each : ctx.cteClause()) {
             SubquerySegment subquery = new SubquerySegment(each.subquery().aggregationClause().start.getStartIndex(),
                     each.subquery().aggregationClause().stop.getStopIndex(), (SelectStatement) visit(each.subquery()), getOriginalText(each.subquery()));
-            CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(each.start.getStartIndex(), each.stop.getStopIndex(), (AliasSegment) visit(each.alias()), subquery);
+            CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(each.start.getStartIndex(), each.stop.getStopIndex(), (AliasSegment) visit(each.alias()), subquery,
+                    null);
             if (null != each.columnNames()) {
                 ColumnNamesContext columnNames = each.columnNames();
                 CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(columnNames);
@@ -1862,7 +1863,7 @@ public abstract class SQLServerStatementVisitor extends SQLServerStatementBaseVi
         if (null != expr) {
             return visit(expr);
         }
-        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+        return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), Collections.emptyList());
     }
     
     @Override
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractor.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractor.java
index 87b8aae72c9..bda55916f42 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractor.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractor.java
@@ -30,7 +30,9 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InEx
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
@@ -125,6 +127,14 @@ public final class ColumnExtractor {
             extract(((UnaryOperationExpression) expression).getExpression(), result);
             return;
         }
+        if (expression instanceof TypeCastExpression) {
+            extract(((TypeCastExpression) expression).getExpression(), result);
+            return;
+        }
+        if (expression instanceof CommonExpressionSegment) {
+            ((CommonExpressionSegment) expression).getChildren().forEach(each -> extract(each, result));
+            return;
+        }
         if (expression instanceof CollateExpression) {
             ((CollateExpression) expression).getExpr().ifPresent(optional -> extract(optional, result));
             return;
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractor.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractor.java
index 2d3fbd9933c..b7f6fbdd0fb 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractor.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractor.java
@@ -34,8 +34,11 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InEx
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ValuesExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
@@ -172,9 +175,21 @@ public final class ExpressionExtractor {
             if (each instanceof TypeCastExpression) {
                 extractParameterMarkerExpressions(segments, Collections.singleton(((TypeCastExpression) each).getExpression()));
             }
+            if (each instanceof UnaryOperationExpression) {
+                extractParameterMarkerExpressions(segments, Collections.singleton(((UnaryOperationExpression) each).getExpression()));
+            }
+            if (each instanceof CollateExpression) {
+                ((CollateExpression) each).getExpr().ifPresent(expr -> extractParameterMarkerExpressions(segments, Collections.singleton(expr)));
+            }
+            if (each instanceof CommonExpressionSegment) {
+                extractParameterMarkerExpressions(segments, ((CommonExpressionSegment) each).getChildren());
+            }
             if (each instanceof ListExpression) {
                 extractParameterMarkerExpressions(segments, ((ListExpression) each).getItems());
             }
+            if (each instanceof RowExpression) {
+                extractParameterMarkerExpressions(segments, ((RowExpression) each).getItems());
+            }
             if (each instanceof InExpression) {
                 extractParameterMarkerExpressions(segments, Collections.singleton(((InExpression) each).getLeft()));
                 extractParameterMarkerExpressions(segments, Collections.singleton(((InExpression) each).getRight()));
@@ -273,6 +288,22 @@ public final class ExpressionExtractor {
             ((CaseWhenExpression) expression).getWhenExprs().forEach(each -> result.addAll(extractColumns(each, containsSubQuery)));
             ((CaseWhenExpression) expression).getThenExprs().forEach(each -> result.addAll(extractColumns(each, containsSubQuery)));
         }
+        if (expression instanceof CommonExpressionSegment) {
+            for (ExpressionSegment each : ((CommonExpressionSegment) expression).getChildren()) {
+                result.addAll(extractColumns(each, containsSubQuery));
+            }
+        }
+        if (expression instanceof RowExpression) {
+            for (ExpressionSegment each : ((RowExpression) expression).getItems()) {
+                result.addAll(extractColumns(each, containsSubQuery));
+            }
+        }
+        if (expression instanceof UnaryOperationExpression) {
+            result.addAll(extractColumns(((UnaryOperationExpression) expression).getExpression(), containsSubQuery));
+        }
+        if (expression instanceof CollateExpression) {
+            ((CollateExpression) expression).getExpr().ifPresent(expr -> result.addAll(extractColumns(expr, containsSubQuery)));
+        }
         if (expression instanceof OuterJoinExpression) {
             result.add(((OuterJoinExpression) expression).getColumnName());
         }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractor.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractor.java
index 8319f4077c4..a2a02278b08 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractor.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractor.java
@@ -33,7 +33,10 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InEx
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
@@ -100,6 +103,9 @@ public final class SubqueryExtractor {
     
     private static void extractSubquerySegmentsFromCTEs(final List<SubquerySegment> result, final Collection<CommonTableExpressionSegment> withSegment, final boolean needRecursive) {
         for (CommonTableExpressionSegment each : withSegment) {
+            if (null != each.getDataModification()) {
+                continue;
+            }
             SubquerySegment subquery = each.getSubquery();
             subquery.setSelect(subquery.getSelect().withSubqueryType(SubqueryType.WITH));
             result.add(subquery);
@@ -210,6 +216,9 @@ public final class SubqueryExtractor {
         if (expressionSegment instanceof ListExpression) {
             ((ListExpression) expressionSegment).getItems().forEach(each -> extractSubquerySegmentsFromExpression(result, each, subqueryType, needRecursive));
         }
+        if (expressionSegment instanceof RowExpression) {
+            ((RowExpression) expressionSegment).getItems().forEach(each -> extractSubquerySegmentsFromExpression(result, each, subqueryType, needRecursive));
+        }
         if (expressionSegment instanceof BinaryOperationExpression) {
             extractSubquerySegmentsFromExpression(result, ((BinaryOperationExpression) expressionSegment).getLeft(), subqueryType, needRecursive);
             extractSubquerySegmentsFromExpression(result, ((BinaryOperationExpression) expressionSegment).getRight(), subqueryType, needRecursive);
@@ -235,6 +244,7 @@ public final class SubqueryExtractor {
             extractSubquerySegmentsFromCaseWhenExpression(result, (CaseWhenExpression) expressionSegment, SubqueryType.FUNCTION, needRecursive);
         }
         if (expressionSegment instanceof CollateExpression) {
+            ((CollateExpression) expressionSegment).getExpr().ifPresent(expr -> extractSubquerySegmentsFromExpression(result, expr, subqueryType, needRecursive));
             extractSubquerySegmentsFromExpression(result, ((CollateExpression) expressionSegment).getCollateName(), subqueryType, needRecursive);
         }
         if (expressionSegment instanceof DatetimeExpression) {
@@ -247,6 +257,12 @@ public final class SubqueryExtractor {
         if (expressionSegment instanceof TypeCastExpression) {
             extractSubquerySegmentsFromExpression(result, ((TypeCastExpression) expressionSegment).getExpression(), subqueryType, needRecursive);
         }
+        if (expressionSegment instanceof UnaryOperationExpression) {
+            extractSubquerySegmentsFromExpression(result, ((UnaryOperationExpression) expressionSegment).getExpression(), subqueryType, needRecursive);
+        }
+        if (expressionSegment instanceof CommonExpressionSegment) {
+            ((CommonExpressionSegment) expressionSegment).getChildren().forEach(each -> extractSubquerySegmentsFromExpression(result, each, subqueryType, needRecursive));
+        }
     }
     
     private static void extractSubquerySegmentsFromCaseWhenExpression(final List<SubquerySegment> result, final CaseWhenExpression expressionSegment, final SubqueryType subqueryType,
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractor.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractor.java
index 208f59f9bdf..f31377654af 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractor.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractor.java
@@ -17,10 +17,16 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.extractor;
 
+import lombok.AccessLevel;
 import lombok.Getter;
+import org.apache.shardingsphere.database.connector.core.metadata.identifier.IdentifierCasePolicy;
+import org.apache.shardingsphere.database.connector.core.metadata.identifier.IdentifierNormalizeEngine;
+import org.apache.shardingsphere.database.connector.core.metadata.identifier.IdentifierScope;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.ValidStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.ReturningSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.ColumnAssignmentSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.InsertValuesSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.CombineSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.datetime.DatetimeExpression;
@@ -36,6 +42,8 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.List
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
@@ -45,6 +53,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.Expr
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.SubqueryProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.merge.MergeWhenAndThenSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.item.ColumnOrderByItemSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.item.OrderByItemSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.LockSegment;
@@ -67,9 +76,12 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.ta
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.view.CreateViewStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 
+import javax.annotation.Nullable;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
@@ -87,152 +99,292 @@ public final class TableExtractor {
     
     private final Collection<JoinTableSegment> joinTables = new LinkedList<>();
     
+    @Nullable
+    @Getter(AccessLevel.NONE)
+    private IdentifierCasePolicy identifierCasePolicy;
+    
     /**
      * Extract table that should be rewritten from select statement.
      *
      * @param selectStatement select statement
      */
     public void extractTablesFromSelect(final SelectStatement selectStatement) {
+        TableSegment from = selectStatement.getFrom().orElse(null);
+        extractTablesFromSelect(selectStatement, from, createTableScope(selectStatement));
+    }
+    
+    private void extractTablesFromSelect(final SelectStatement selectStatement, final TableSegment from, final TableScope tableScope) {
         if (selectStatement.getCombine().isPresent()) {
             CombineSegment combineSegment = selectStatement.getCombine().get();
-            extractTablesFromSelect(combineSegment.getLeft().getSelect());
-            extractTablesFromSelect(combineSegment.getRight().getSelect());
+            extractTablesFromNestedStatement(combineSegment.getLeft().getSelect(), tableScope);
+            extractTablesFromNestedStatement(combineSegment.getRight().getSelect(), tableScope);
+        }
+        if (null != from && !selectStatement.getCombine().isPresent()) {
+            extractTablesFromTableSegment(from, tableScope);
         }
-        if (selectStatement.getFrom().isPresent() && !selectStatement.getCombine().isPresent()) {
-            extractTablesFromTableSegment(selectStatement.getFrom().get());
+        if (selectStatement.getWhere().isPresent()) {
+            extractTablesFromExpression(selectStatement.getWhere().get().getExpr(), tableScope);
         }
-        selectStatement.getWhere().ifPresent(optional -> extractTablesFromExpression(optional.getExpr()));
         if (null != selectStatement.getProjections() && !selectStatement.getCombine().isPresent()) {
-            extractTablesFromProjections(selectStatement.getProjections());
+            extractTablesFromProjections(selectStatement.getProjections(), tableScope);
+        }
+        if (selectStatement.getGroupBy().isPresent()) {
+            extractTablesFromOrderByItems(selectStatement.getGroupBy().get().getGroupByItems(), tableScope);
+        }
+        if (selectStatement.getOrderBy().isPresent()) {
+            extractTablesFromOrderByItems(selectStatement.getOrderBy().get().getOrderByItems(), tableScope);
+        }
+        if (selectStatement.getHaving().isPresent()) {
+            extractTablesFromExpression(selectStatement.getHaving().get().getExpr(), tableScope);
+        }
+        if (selectStatement.getWith().isPresent()) {
+            extractTablesFromCTEs(selectStatement.getWith().get().getCommonTableExpressions(), tableScope);
         }
-        selectStatement.getGroupBy().ifPresent(optional -> extractTablesFromOrderByItems(optional.getGroupByItems()));
-        selectStatement.getOrderBy().ifPresent(optional -> extractTablesFromOrderByItems(optional.getOrderByItems()));
-        selectStatement.getHaving().ifPresent(optional -> extractTablesFromExpression(optional.getExpr()));
-        selectStatement.getWith().ifPresent(optional -> extractTablesFromCTEs(optional.getCommonTableExpressions()));
         selectStatement.getLock().ifPresent(this::extractTablesFromLock);
     }
     
-    private void extractTablesFromCTEs(final Collection<CommonTableExpressionSegment> commonTableExpressionSegments) {
+    /**
+     * Use the flat table context when no USING alias needs a scope.
+     *
+     * @param sqlStatement statement whose table scope is inspected
+     * @return scope for USING aliases, or null to use the flat table context
+     */
+    private TableScope createTableScope(final SQLStatement sqlStatement) {
+        if (!containsUsingAlias(sqlStatement)) {
+            identifierCasePolicy = null;
+            return null;
+        }
+        identifierCasePolicy = IdentifierNormalizeEngine.resolvePolicy(sqlStatement.getDatabaseType(), null, IdentifierScope.TABLE);
+        TableScope result = new TableScope(null, tableContext);
+        result.identifierCasePolicy = identifierCasePolicy;
+        result.usingAliasScope = true;
+        return result;
+    }
+    
+    private boolean containsUsingAlias(final SQLStatement sqlStatement) {
+        if (sqlStatement instanceof SelectStatement) {
+            SelectStatement selectStatement = (SelectStatement) sqlStatement;
+            return containsUsingAlias(selectStatement.getFrom().orElse(null));
+        }
+        if (sqlStatement instanceof UpdateStatement) {
+            UpdateStatement updateStatement = (UpdateStatement) sqlStatement;
+            return containsUsingAlias(updateStatement.getTable()) || updateStatement.getFrom().isPresent() && containsUsingAlias(updateStatement.getFrom().get());
+        }
+        if (sqlStatement instanceof DeleteStatement) {
+            return containsUsingAlias(((DeleteStatement) sqlStatement).getTable());
+        }
+        if (sqlStatement instanceof InsertStatement) {
+            InsertStatement insertStatement = (InsertStatement) sqlStatement;
+            return insertStatement.getInsertSelect().isPresent() && containsUsingAlias(insertStatement.getInsertSelect().get().getSelect());
+        }
+        if (sqlStatement instanceof MergeStatement) {
+            MergeStatement mergeStatement = (MergeStatement) sqlStatement;
+            return containsUsingAlias(mergeStatement.getTarget()) || containsUsingAlias(mergeStatement.getSource());
+        }
+        return false;
+    }
+    
+    private boolean containsUsingAlias(final TableSegment tableSegment) {
+        if (tableSegment instanceof DeleteMultiTableSegment) {
+            return containsUsingAlias(((DeleteMultiTableSegment) tableSegment).getRelationTable());
+        }
+        if (!(tableSegment instanceof JoinTableSegment)) {
+            return false;
+        }
+        JoinTableSegment joinTableSegment = (JoinTableSegment) tableSegment;
+        return joinTableSegment.getUsingAliasSegment().isPresent() || containsUsingAlias(joinTableSegment.getLeft()) || containsUsingAlias(joinTableSegment.getRight());
+    }
+    
+    private void extractTablesFromNestedStatement(final SQLStatement sqlStatement, final TableScope tableScope) {
+        boolean usingAlias = containsUsingAlias(sqlStatement);
+        TableScope nestedScope = createNestedTableScope(tableScope, null != tableScope || usingAlias);
+        if (usingAlias) {
+            nestedScope.usingAliasScope = true;
+            if (null == nestedScope.identifierCasePolicy) {
+                nestedScope.identifierCasePolicy = IdentifierNormalizeEngine.resolvePolicy(sqlStatement.getDatabaseType(), null, IdentifierScope.TABLE);
+            }
+        }
+        if (sqlStatement instanceof SelectStatement) {
+            SelectStatement selectStatement = (SelectStatement) sqlStatement;
+            TableSegment from = selectStatement.getFrom().orElse(null);
+            extractTablesFromSelect(selectStatement, from, nestedScope);
+            return;
+        }
+        if (sqlStatement instanceof MergeStatement) {
+            extractTablesFromMerge((MergeStatement) sqlStatement, nestedScope);
+        } else if (sqlStatement instanceof InsertStatement) {
+            extractTablesFromInsert((InsertStatement) sqlStatement, nestedScope);
+        } else if (sqlStatement instanceof UpdateStatement) {
+            extractTablesFromUpdate((UpdateStatement) sqlStatement, nestedScope);
+        } else if (sqlStatement instanceof DeleteStatement) {
+            extractTablesFromDelete((DeleteStatement) sqlStatement, nestedScope);
+        }
+    }
+    
+    private TableScope createNestedTableScope(final TableScope tableScope, final boolean scopeRequired) {
+        if (!scopeRequired) {
+            return null;
+        }
+        TableScope parentScope = null == tableScope ? new TableScope(null, tableContext) : tableScope;
+        return new TableScope(parentScope, null);
+    }
+    
+    private void extractTablesFromCTEs(final Collection<CommonTableExpressionSegment> commonTableExpressionSegments, final TableScope tableScope) {
         for (CommonTableExpressionSegment each : commonTableExpressionSegments) {
-            extractTablesFromSelect(each.getSubquery().getSelect());
+            extractTablesFromNestedStatement(each.getStatement(), tableScope);
         }
     }
     
-    private void extractTablesFromTableSegment(final TableSegment tableSegment) {
+    private void extractTablesFromTableSegment(final TableSegment tableSegment, final TableScope tableScope) {
         if (tableSegment instanceof SimpleTableSegment) {
-            tableContext.add(tableSegment);
+            addTableContext(tableSegment, tableScope);
             rewriteTables.add((SimpleTableSegment) tableSegment);
         }
         if (tableSegment instanceof SubqueryTableSegment) {
-            tableContext.add(tableSegment);
             TableExtractor tableExtractor = new TableExtractor();
-            tableExtractor.extractTablesFromSelect(((SubqueryTableSegment) tableSegment).getSubquery().getSelect());
+            if (null != tableScope) {
+                tableExtractor.extractTablesFromNestedStatement(((SubqueryTableSegment) tableSegment).getSubquery().getSelect(), tableScope);
+            } else {
+                tableExtractor.extractTablesFromSelect(((SubqueryTableSegment) tableSegment).getSubquery().getSelect());
+            }
             rewriteTables.addAll(tableExtractor.rewriteTables);
             joinTables.addAll(tableExtractor.joinTables);
+            addTableContext(tableSegment, tableScope);
         }
         if (tableSegment instanceof JoinTableSegment) {
             joinTables.add((JoinTableSegment) tableSegment);
-            extractTablesFromJoinTableSegment((JoinTableSegment) tableSegment);
+            extractTablesFromJoinTableSegment((JoinTableSegment) tableSegment, tableScope);
         }
         if (tableSegment instanceof DeleteMultiTableSegment) {
             DeleteMultiTableSegment deleteMultiTableSegment = (DeleteMultiTableSegment) tableSegment;
             rewriteTables.addAll(deleteMultiTableSegment.getActualDeleteTables());
-            extractTablesFromTableSegment(deleteMultiTableSegment.getRelationTable());
+            extractTablesFromTableSegment(deleteMultiTableSegment.getRelationTable(), tableScope);
         }
         if (tableSegment instanceof FunctionTableSegment) {
-            tableContext.add(tableSegment);
-            extractTablesFromExpression(((FunctionTableSegment) tableSegment).getTableFunction());
+            addTableContext(tableSegment, tableScope);
+            extractTablesFromExpression(((FunctionTableSegment) tableSegment).getTableFunction(), tableScope);
+        }
+    }
+    
+    private void addTableContext(final TableSegment tableSegment, final TableScope tableScope) {
+        tableContext.add(tableSegment);
+        if (null != tableScope) {
+            tableScope.tables.add(tableSegment);
         }
     }
     
-    private void extractTablesFromJoinTableSegment(final JoinTableSegment tableSegment) {
-        extractTablesFromTableSegment(tableSegment.getLeft());
-        extractTablesFromTableSegment(tableSegment.getRight());
-        extractTablesFromExpression(tableSegment.getCondition());
+    private void extractTablesFromJoinTableSegment(final JoinTableSegment tableSegment, final TableScope tableScope) {
+        boolean scopedAlias = null != tableScope && tableScope.usingAliasScope && tableSegment.getAlias().isPresent();
+        boolean registerAlias = scopedAlias || tableSegment.getUsingAliasSegment().isPresent();
+        if (registerAlias && null == tableScope.parent) {
+            tableContext.add(tableSegment);
+        }
+        TableScope joinScope = scopedAlias ? new TableScope(tableScope, null) : tableScope;
+        extractTablesFromTableSegment(tableSegment.getLeft(), joinScope);
+        extractTablesFromTableSegment(tableSegment.getRight(), joinScope);
+        extractTablesFromExpression(tableSegment.getCondition(), joinScope);
+        if (registerAlias) {
+            tableScope.tables.add(tableSegment);
+        }
     }
     
-    private void extractTablesFromExpression(final ExpressionSegment expressionSegment) {
+    private void extractTablesFromExpression(final ExpressionSegment expressionSegment, final TableScope tableScope) {
         if (expressionSegment instanceof ColumnSegment) {
-            extractTablesFromColumnSegments(Collections.singleton((ColumnSegment) expressionSegment));
+            extractTablesFromColumnSegments(Collections.singleton((ColumnSegment) expressionSegment), tableScope);
         }
         if (expressionSegment instanceof ListExpression) {
-            ((ListExpression) expressionSegment).getItems().forEach(this::extractTablesFromExpression);
+            extractTablesFromExpressions(((ListExpression) expressionSegment).getItems(), tableScope);
+        }
+        if (expressionSegment instanceof CommonExpressionSegment) {
+            extractTablesFromExpressions(((CommonExpressionSegment) expressionSegment).getChildren(), tableScope);
+        }
+        if (expressionSegment instanceof UnaryOperationExpression) {
+            extractTablesFromExpression(((UnaryOperationExpression) expressionSegment).getExpression(), tableScope);
         }
         if (expressionSegment instanceof ExistsSubqueryExpression) {
-            extractTablesFromSelect(((ExistsSubqueryExpression) expressionSegment).getSubquery().getSelect());
+            extractTablesFromNestedStatement(((ExistsSubqueryExpression) expressionSegment).getSubquery().getSelect(), tableScope);
         }
         if (expressionSegment instanceof BetweenExpression) {
-            extractTablesFromExpression(((BetweenExpression) expressionSegment).getLeft());
-            extractTablesFromExpression(((BetweenExpression) expressionSegment).getBetweenExpr());
-            extractTablesFromExpression(((BetweenExpression) expressionSegment).getAndExpr());
+            extractTablesFromExpression(((BetweenExpression) expressionSegment).getLeft(), tableScope);
+            extractTablesFromExpression(((BetweenExpression) expressionSegment).getBetweenExpr(), tableScope);
+            extractTablesFromExpression(((BetweenExpression) expressionSegment).getAndExpr(), tableScope);
         }
         if (expressionSegment instanceof InExpression) {
-            extractTablesFromExpression(((InExpression) expressionSegment).getLeft());
-            extractTablesFromExpression(((InExpression) expressionSegment).getRight());
+            extractTablesFromExpression(((InExpression) expressionSegment).getLeft(), tableScope);
+            extractTablesFromExpression(((InExpression) expressionSegment).getRight(), tableScope);
         }
         if (expressionSegment instanceof SubqueryExpressionSegment) {
-            extractTablesFromSelect(((SubqueryExpressionSegment) expressionSegment).getSubquery().getSelect());
+            extractTablesFromNestedStatement(((SubqueryExpressionSegment) expressionSegment).getSubquery().getSelect(), tableScope);
         }
         if (expressionSegment instanceof SubquerySegment) {
-            extractTablesFromSelect(((SubquerySegment) expressionSegment).getSelect());
+            extractTablesFromNestedStatement(((SubquerySegment) expressionSegment).getSelect(), tableScope);
         }
         if (expressionSegment instanceof BinaryOperationExpression) {
-            extractTablesFromExpression(((BinaryOperationExpression) expressionSegment).getLeft());
-            extractTablesFromExpression(((BinaryOperationExpression) expressionSegment).getRight());
+            extractTablesFromExpression(((BinaryOperationExpression) expressionSegment).getLeft(), tableScope);
+            extractTablesFromExpression(((BinaryOperationExpression) expressionSegment).getRight(), tableScope);
         }
         if (expressionSegment instanceof MatchAgainstExpression) {
-            ((MatchAgainstExpression) expressionSegment).getColumns().forEach(this::extractTablesFromExpression);
-            extractTablesFromExpression(((MatchAgainstExpression) expressionSegment).getExpr());
+            extractTablesFromExpressions(((MatchAgainstExpression) expressionSegment).getColumns(), tableScope);
+            extractTablesFromExpression(((MatchAgainstExpression) expressionSegment).getExpr(), tableScope);
         }
         if (expressionSegment instanceof FunctionSegment) {
-            ((FunctionSegment) expressionSegment).getParameters().forEach(this::extractTablesFromExpression);
+            extractTablesFromExpressions(((FunctionSegment) expressionSegment).getParameters(), tableScope);
+        }
+        if (expressionSegment instanceof AggregationProjectionSegment) {
+            extractTablesFromExpressions(((AggregationProjectionSegment) expressionSegment).getParameters(), tableScope);
         }
         if (expressionSegment instanceof CaseWhenExpression) {
-            extractTablesFromCaseWhenExpression((CaseWhenExpression) expressionSegment);
+            extractTablesFromCaseWhenExpression((CaseWhenExpression) expressionSegment, tableScope);
         }
         if (expressionSegment instanceof CollateExpression) {
-            extractTablesFromExpression(((CollateExpression) expressionSegment).getCollateName());
+            extractTablesFromExpression(((CollateExpression) expressionSegment).getCollateName(), tableScope);
         }
         if (expressionSegment instanceof DatetimeExpression) {
-            extractTablesFromExpression(((DatetimeExpression) expressionSegment).getLeft());
-            extractTablesFromExpression(((DatetimeExpression) expressionSegment).getRight());
+            extractTablesFromExpression(((DatetimeExpression) expressionSegment).getLeft(), tableScope);
+            extractTablesFromExpression(((DatetimeExpression) expressionSegment).getRight(), tableScope);
         }
         if (expressionSegment instanceof NotExpression) {
-            extractTablesFromExpression(((NotExpression) expressionSegment).getExpression());
+            extractTablesFromExpression(((NotExpression) expressionSegment).getExpression(), tableScope);
         }
         if (expressionSegment instanceof TypeCastExpression) {
-            extractTablesFromExpression(((TypeCastExpression) expressionSegment).getExpression());
+            extractTablesFromExpression(((TypeCastExpression) expressionSegment).getExpression(), tableScope);
         }
         if (expressionSegment instanceof QuantifySubqueryExpression) {
-            extractTablesFromExpression(((QuantifySubqueryExpression) expressionSegment).getSubquery());
+            extractTablesFromExpression(((QuantifySubqueryExpression) expressionSegment).getSubquery(), tableScope);
         }
     }
     
-    private void extractTablesFromCaseWhenExpression(final CaseWhenExpression expressionSegment) {
-        extractTablesFromExpression(expressionSegment.getCaseExpr());
-        expressionSegment.getWhenExprs().forEach(this::extractTablesFromExpression);
-        expressionSegment.getThenExprs().forEach(this::extractTablesFromExpression);
-        extractTablesFromExpression(expressionSegment.getElseExpr());
+    private void extractTablesFromExpressions(final Collection<? extends ExpressionSegment> expressionSegments, final TableScope tableScope) {
+        for (ExpressionSegment each : expressionSegments) {
+            extractTablesFromExpression(each, tableScope);
+        }
     }
     
-    private void extractTablesFromProjections(final ProjectionsSegment projections) {
+    private void extractTablesFromCaseWhenExpression(final CaseWhenExpression expressionSegment, final TableScope tableScope) {
+        extractTablesFromExpression(expressionSegment.getCaseExpr(), tableScope);
+        extractTablesFromExpressions(expressionSegment.getWhenExprs(), tableScope);
+        extractTablesFromExpressions(expressionSegment.getThenExprs(), tableScope);
+        extractTablesFromExpression(expressionSegment.getElseExpr(), tableScope);
+    }
+    
+    private void extractTablesFromProjections(final ProjectionsSegment projections, final TableScope tableScope) {
         for (ProjectionSegment each : projections.getProjections()) {
             if (each instanceof SubqueryProjectionSegment) {
-                extractTablesFromSelect(((SubqueryProjectionSegment) each).getSubquery().getSelect());
+                extractTablesFromNestedStatement(((SubqueryProjectionSegment) each).getSubquery().getSelect(), tableScope);
             } else if (each instanceof OwnerAvailable) {
-                if (((OwnerAvailable) each).getOwner().isPresent() && needRewrite(((OwnerAvailable) each).getOwner().get())) {
+                if (((OwnerAvailable) each).getOwner().isPresent() && needRewrite(((OwnerAvailable) each).getOwner().get(), tableScope)) {
                     OwnerSegment ownerSegment = ((OwnerAvailable) each).getOwner().get();
                     rewriteTables.add(createSimpleTableSegment(ownerSegment));
                 }
             } else if (each instanceof ColumnProjectionSegment) {
-                if (((ColumnProjectionSegment) each).getColumn().getOwner().isPresent() && needRewrite(((ColumnProjectionSegment) each).getColumn().getOwner().get())) {
+                if (((ColumnProjectionSegment) each).getColumn().getOwner().isPresent() && needRewrite(((ColumnProjectionSegment) each).getColumn().getOwner().get(), tableScope)) {
                     OwnerSegment ownerSegment = ((ColumnProjectionSegment) each).getColumn().getOwner().get();
                     rewriteTables.add(createSimpleTableSegment(ownerSegment));
                 }
             } else if (each instanceof AggregationProjectionSegment) {
-                ((AggregationProjectionSegment) each).getParameters().forEach(this::extractTablesFromExpression);
+                extractTablesFromExpressions(((AggregationProjectionSegment) each).getParameters(), tableScope);
             } else if (each instanceof ExpressionProjectionSegment) {
-                extractTablesFromExpression(((ExpressionProjectionSegment) each).getExpr());
+                extractTablesFromExpression(((ExpressionProjectionSegment) each).getExpr(), tableScope);
             }
         }
     }
@@ -245,11 +397,11 @@ public final class TableExtractor {
         return result;
     }
     
-    private void extractTablesFromOrderByItems(final Collection<OrderByItemSegment> orderByItems) {
+    private void extractTablesFromOrderByItems(final Collection<OrderByItemSegment> orderByItems, final TableScope tableScope) {
         for (OrderByItemSegment each : orderByItems) {
             if (each instanceof ColumnOrderByItemSegment) {
                 Optional<OwnerSegment> owner = ((ColumnOrderByItemSegment) each).getColumn().getOwner();
-                if (owner.isPresent() && needRewrite(owner.get())) {
+                if (owner.isPresent() && needRewrite(owner.get(), tableScope)) {
                     TableNameSegment tableNameSegment = new TableNameSegment(owner.get().getStartIndex(), owner.get().getStopIndex(), owner.get().getIdentifier());
                     owner.get().getTableBoundInfo().ifPresent(tableNameSegment::setTableBoundInfo);
                     rewriteTables.add(new SimpleTableSegment(tableNameSegment));
@@ -268,9 +420,13 @@ public final class TableExtractor {
      * @param deleteStatement delete statement
      */
     public void extractTablesFromDelete(final DeleteStatement deleteStatement) {
-        extractTablesFromTableSegment(deleteStatement.getTable());
+        extractTablesFromDelete(deleteStatement, createTableScope(deleteStatement));
+    }
+    
+    private void extractTablesFromDelete(final DeleteStatement deleteStatement, final TableScope tableScope) {
+        extractTablesFromTableSegment(deleteStatement.getTable(), tableScope);
         if (deleteStatement.getWhere().isPresent()) {
-            extractTablesFromExpression(deleteStatement.getWhere().get().getExpr());
+            extractTablesFromExpression(deleteStatement.getWhere().get().getExpr(), tableScope);
         }
     }
     
@@ -280,25 +436,36 @@ public final class TableExtractor {
      * @param insertStatement insert statement
      */
     public void extractTablesFromInsert(final InsertStatement insertStatement) {
-        insertStatement.getTable().ifPresent(this::extractTablesFromTableSegment);
+        extractTablesFromInsert(insertStatement, createTableScope(insertStatement));
+    }
+    
+    private void extractTablesFromInsert(final InsertStatement insertStatement, final TableScope tableScope) {
+        if (insertStatement.getTable().isPresent()) {
+            extractTablesFromTableSegment(insertStatement.getTable().get(), tableScope);
+        }
         if (!insertStatement.getColumns().isEmpty()) {
             for (ColumnSegment each : insertStatement.getColumns()) {
-                extractTablesFromExpression(each);
+                extractTablesFromExpression(each, tableScope);
             }
         }
-        insertStatement.getOnDuplicateKeyColumns().ifPresent(optional -> extractTablesFromAssignmentItems(optional.getColumns()));
+        if (insertStatement.getOnDuplicateKeyColumns().isPresent()) {
+            extractTablesFromAssignmentItems(insertStatement.getOnDuplicateKeyColumns().get().getColumns(), tableScope);
+        }
         if (insertStatement.getInsertSelect().isPresent()) {
-            extractTablesFromSelect(insertStatement.getInsertSelect().get().getSelect());
+            SelectStatement selectStatement = insertStatement.getInsertSelect().get().getSelect();
+            extractTablesFromSelect(selectStatement, selectStatement.getFrom().orElse(null), tableScope);
         }
     }
     
-    private void extractTablesFromAssignmentItems(final Collection<ColumnAssignmentSegment> assignmentItems) {
-        assignmentItems.forEach(each -> extractTablesFromColumnSegments(each.getColumns()));
+    private void extractTablesFromAssignmentItems(final Collection<ColumnAssignmentSegment> assignmentItems, final TableScope tableScope) {
+        for (ColumnAssignmentSegment each : assignmentItems) {
+            extractTablesFromColumnSegments(each.getColumns(), tableScope);
+        }
     }
     
-    private void extractTablesFromColumnSegments(final Collection<ColumnSegment> columnSegments) {
+    private void extractTablesFromColumnSegments(final Collection<ColumnSegment> columnSegments, final TableScope tableScope) {
         for (ColumnSegment each : columnSegments) {
-            if (each.getOwner().isPresent() && needRewrite(each.getOwner().get())) {
+            if (each.getOwner().isPresent() && needRewrite(each.getOwner().get(), tableScope)) {
                 OwnerSegment ownerSegment = each.getOwner().get();
                 TableNameSegment tableSegment = new TableNameSegment(ownerSegment.getStartIndex(), ownerSegment.getStopIndex(), ownerSegment.getIdentifier());
                 ownerSegment.getTableBoundInfo().ifPresent(tableSegment::setTableBoundInfo);
@@ -313,16 +480,79 @@ public final class TableExtractor {
      * @param updateStatement update statement.
      */
     public void extractTablesFromUpdate(final UpdateStatement updateStatement) {
+        extractTablesFromUpdate(updateStatement, createTableScope(updateStatement));
+    }
+    
+    private void extractTablesFromUpdate(final UpdateStatement updateStatement, final TableScope tableScope) {
         if (!updateStatement.isTargetTableIsFromAlias()) {
-            extractTablesFromTableSegment(updateStatement.getTable());
+            extractTablesFromTableSegment(updateStatement.getTable(), tableScope);
+        }
+        if (updateStatement.getFrom().isPresent()) {
+            extractTablesFromTableSegment(updateStatement.getFrom().get(), tableScope);
+        }
+        for (ColumnAssignmentSegment each : updateStatement.getSetAssignment().getAssignments()) {
+            extractTablesFromExpression(each.getColumns().get(0), tableScope);
         }
-        updateStatement.getFrom().ifPresent(this::extractTablesFromTableSegment);
-        updateStatement.getSetAssignment().getAssignments().forEach(each -> extractTablesFromExpression(each.getColumns().get(0)));
         if (updateStatement.getWhere().isPresent()) {
-            extractTablesFromExpression(updateStatement.getWhere().get().getExpr());
+            extractTablesFromExpression(updateStatement.getWhere().get().getExpr(), tableScope);
+        }
+    }
+    
+    /**
+     * Extract tables from a MERGE body of a common table expression or prepared statement.
+     *
+     * @param mergeStatement merge statement
+     */
+    public void extractTablesFromMerge(final MergeStatement mergeStatement) {
+        extractTablesFromMerge(mergeStatement, createTableScope(mergeStatement));
+    }
+    
+    private void extractTablesFromMerge(final MergeStatement mergeStatement, final TableScope tableScope) {
+        TableScope mergeScope = null == tableScope ? new TableScope(null, tableContext) : tableScope;
+        extractTablesFromTableSegment(mergeStatement.getTarget(), mergeScope);
+        extractTablesFromTableSegment(mergeStatement.getSource(), mergeScope);
+        if (null != mergeStatement.getExpression()) {
+            extractTablesFromExpression(mergeStatement.getExpression().getExpr(), mergeScope);
+        }
+        for (MergeWhenAndThenSegment each : mergeStatement.getWhenAndThens()) {
+            extractTablesFromExpression(each.getAndExpr(), mergeScope);
+            if (null != each.getUpdate()) {
+                extractTablesFromMergeUpdate(each.getUpdate(), mergeScope);
+            }
+            if (null != each.getInsert()) {
+                extractTablesFromMergeInsert(each.getInsert(), mergeScope);
+            }
+        }
+        if (mergeStatement.getReturning().isPresent()) {
+            extractTablesFromMergeReturning(mergeStatement, mergeScope);
+        }
+        if (mergeStatement.getWith().isPresent()) {
+            extractTablesFromCTEs(mergeStatement.getWith().get().getCommonTableExpressions(), mergeScope);
+        }
+    }
+    
+    private void extractTablesFromMergeUpdate(final UpdateStatement updateStatement, final TableScope tableScope) {
+        for (ColumnAssignmentSegment each : updateStatement.getSetAssignment().getAssignments()) {
+            extractTablesFromExpression(each.getValue(), tableScope);
+        }
+    }
+    
+    private void extractTablesFromMergeInsert(final InsertStatement insertStatement, final TableScope tableScope) {
+        for (InsertValuesSegment each : insertStatement.getValues()) {
+            extractTablesFromExpressions(each.getValues(), tableScope);
         }
     }
     
+    private void extractTablesFromMergeReturning(final MergeStatement mergeStatement, final TableScope tableScope) {
+        ReturningSegment returning = mergeStatement.getReturning().get();
+        TableScope returningScope = new TableScope(tableScope, null);
+        returningScope.identifierCasePolicy = IdentifierNormalizeEngine.resolvePolicy(mergeStatement.getDatabaseType(), null, IdentifierScope.TABLE);
+        returningScope.tables.addAll(tableScope.tables);
+        returningScope.aliases.add(null == returning.getOldAlias() ? new IdentifierValue("old") : returning.getOldAlias().getIdentifier());
+        returningScope.aliases.add(null == returning.getNewAlias() ? new IdentifierValue("new") : returning.getNewAlias().getIdentifier());
+        extractTablesFromProjections(returning.getProjections(), returningScope);
+    }
+    
     /**
      * Check if the table needs to be overwritten.
      *
@@ -331,13 +561,65 @@ public final class TableExtractor {
      */
     public boolean needRewrite(final OwnerSegment owner) {
         for (TableSegment each : tableContext) {
-            if (owner.getIdentifier().getValue().equalsIgnoreCase(each.getAliasName().orElse(null))) {
+            if (isAlias(owner.getIdentifier(), each, identifierCasePolicy)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    private boolean needRewrite(final OwnerSegment owner, final TableScope tableScope) {
+        return null == tableScope ? needRewrite(owner) : needRewriteFromLocalTableContext(owner.getIdentifier(), tableScope);
+    }
+    
+    private boolean needRewriteFromLocalTableContext(final IdentifierValue owner, final TableScope scope) {
+        for (TableSegment each : scope.tables) {
+            if (isAlias(owner, each, scope.identifierCasePolicy)) {
+                return false;
+            }
+        }
+        for (TableSegment each : scope.tables) {
+            if (each instanceof SimpleTableSegment && !each.getAliasName().isPresent()
+                    && matchesIdentifier(owner, ((SimpleTableSegment) each).getTableName().getIdentifier(), scope.identifierCasePolicy)) {
+                return true;
+            }
+        }
+        if (scope.aliases.stream().anyMatch(each -> matchesIdentifier(owner, each, scope.identifierCasePolicy))) {
+            return false;
+        }
+        if (null != scope.parent) {
+            return needRewriteFromLocalTableContext(owner, scope.parent);
+        }
+        int inheritedTableIndex = 0;
+        for (TableSegment each : scope.inheritedTables) {
+            if (inheritedTableIndex++ == scope.inheritedTableCount) {
+                break;
+            }
+            if (isAlias(owner, each, scope.identifierCasePolicy)) {
                 return false;
             }
         }
         return true;
     }
     
+    private boolean isAlias(final IdentifierValue owner, final TableSegment tableSegment, @Nullable final IdentifierCasePolicy identifierCasePolicy) {
+        if (null == identifierCasePolicy) {
+            return isAlias(owner.getValue(), tableSegment);
+        }
+        return tableSegment.getAlias().filter(alias -> matchesIdentifier(owner, alias, identifierCasePolicy)).isPresent()
+                || tableSegment instanceof JoinTableSegment && !tableSegment.getAlias().isPresent() && ((JoinTableSegment) tableSegment).getUsingAliasSegment()
+                        .filter(usingAlias -> matchesIdentifier(owner, usingAlias.getIdentifier(), identifierCasePolicy)).isPresent();
+    }
+    
+    private boolean isAlias(final String ownerName, final TableSegment tableSegment) {
+        return ownerName.equalsIgnoreCase(tableSegment.getAliasName().orElse(null));
+    }
+    
+    private boolean matchesIdentifier(final IdentifierValue owner, final IdentifierValue declared, @Nullable final IdentifierCasePolicy identifierCasePolicy) {
+        return null == identifierCasePolicy ? owner.getValue().equalsIgnoreCase(declared.getValue())
+                : identifierCasePolicy.matches(identifierCasePolicy.normalizeForDefinition(declared.getValue(), declared.getQuoteCharacter()), owner.getValue(), owner.getQuoteCharacter());
+    }
+    
     /**
      * Extract the tables that should exist from routine body segment.
      *
@@ -408,17 +690,17 @@ public final class TableExtractor {
         } else if (sqlStatement instanceof DeleteStatement) {
             extractTablesFromDelete((DeleteStatement) sqlStatement);
         } else if (sqlStatement instanceof CreateTableStatement) {
-            extractTablesFromTableSegment(((CreateTableStatement) sqlStatement).getTable());
+            extractTablesFromTableSegment(((CreateTableStatement) sqlStatement).getTable(), null);
         } else if (sqlStatement instanceof AlterTableStatement) {
-            extractTablesFromTableSegment(((AlterTableStatement) sqlStatement).getTable());
+            extractTablesFromTableSegment(((AlterTableStatement) sqlStatement).getTable(), null);
         } else if (sqlStatement instanceof CommentStatement) {
-            extractTablesFromTableSegment(((CommentStatement) sqlStatement).getTable());
+            extractTablesFromTableSegment(((CommentStatement) sqlStatement).getTable(), null);
         } else if (sqlStatement instanceof CreateViewStatement) {
             extractTablesFromCreateViewStatement((CreateViewStatement) sqlStatement);
         } else if (sqlStatement instanceof CreateIndexStatement) {
-            extractTablesFromTableSegment(((CreateIndexStatement) sqlStatement).getTable());
-        } else if (sqlStatement instanceof DropIndexStatement) {
-            ((DropIndexStatement) sqlStatement).getSimpleTable().ifPresent(this::extractTablesFromTableSegment);
+            extractTablesFromTableSegment(((CreateIndexStatement) sqlStatement).getTable(), null);
+        } else if (sqlStatement instanceof DropIndexStatement && ((DropIndexStatement) sqlStatement).getSimpleTable().isPresent()) {
+            extractTablesFromTableSegment(((DropIndexStatement) sqlStatement).getSimpleTable().get(), null);
         }
     }
     
@@ -432,4 +714,29 @@ public final class TableExtractor {
         rewriteTables.add(createViewStatement.getView());
         extractTablesFromSelect(createViewStatement.getSelect());
     }
+    
+    private static final class TableScope {
+        
+        private final TableScope parent;
+        
+        private final Collection<TableSegment> inheritedTables;
+        
+        private final int inheritedTableCount;
+        
+        private final Collection<TableSegment> tables = new LinkedList<>();
+        
+        private final Collection<IdentifierValue> aliases = new LinkedList<>();
+        
+        private IdentifierCasePolicy identifierCasePolicy;
+        
+        private boolean usingAliasScope;
+        
+        private TableScope(final TableScope parent, final Collection<TableSegment> inheritedTables) {
+            this.parent = parent;
+            this.inheritedTables = inheritedTables;
+            inheritedTableCount = null == inheritedTables ? 0 : inheritedTables.size();
+            identifierCasePolicy = null == parent ? null : parent.identifierCasePolicy;
+            usingAliasScope = null != parent && parent.usingAliasScope;
+        }
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/ReturningSegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/ReturningSegment.java
index e2586c6c1f4..e17eeec2344 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/ReturningSegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/ReturningSegment.java
@@ -19,8 +19,10 @@ package org.apache.shardingsphere.sql.parser.statement.core.segment.dml;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.SQLSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
 
 /**
  * Segment for returning clause.
@@ -34,4 +36,10 @@ public final class ReturningSegment implements SQLSegment {
     private final int stopIndex;
     
     private final ProjectionsSegment projections;
+    
+    @Setter
+    private AliasSegment oldAlias;
+    
+    @Setter
+    private AliasSegment newAlias;
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
index 8e58156ac44..74ae0e835bd 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
@@ -19,6 +19,9 @@ package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.com
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+
+import java.util.Collection;
 
 /**
  * Common expression segment.
@@ -32,4 +35,6 @@ public final class CommonExpressionSegment implements ComplexExpressionSegment {
     private final int stopIndex;
     
     private final String text;
+    
+    private final Collection<ExpressionSegment> children;
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonTableExpressionSegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonTableExpressionSegment.java
index cbce35f103e..e3ae52c3e75 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonTableExpressionSegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonTableExpressionSegment.java
@@ -23,6 +23,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.Co
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 
 import java.util.Collection;
@@ -31,6 +32,7 @@ import java.util.Optional;
 
 /**
  * Common table expression segment.
+ * The body is a SELECT subquery or a data-modifying statement; the other body field is null.
  */
 @AllArgsConstructor
 @Getter
@@ -44,12 +46,23 @@ public final class CommonTableExpressionSegment implements TableSegment {
     
     private final SubquerySegment subquery;
     
+    private final DMLStatement dataModification;
+    
     private final Collection<ColumnSegment> columns = new LinkedList<>();
     
     private final Collection<ColumnSegment> searchColumns = new LinkedList<>();
     
     private final Collection<ColumnSegment> cycleColumns = new LinkedList<>();
     
+    /**
+     * Get the actual statement of the common table expression.
+     *
+     * @return SELECT or data-modifying statement
+     */
+    public DMLStatement getStatement() {
+        return null == dataModification ? subquery.getSelect() : dataModification;
+    }
+    
     @Override
     public Optional<String> getAliasName() {
         return getAlias().map(IdentifierValue::getValue);
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/pagination/limit/LimitSegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/pagination/limit/LimitSegment.java
index 4f3cad09e9c..861cd1030c8 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/pagination/limit/LimitSegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/pagination/limit/LimitSegment.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.paginati
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.SQLSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.PaginationValueSegment;
 
@@ -39,6 +40,15 @@ public final class LimitSegment implements SQLSegment {
     
     private final PaginationValueSegment rowCount;
     
+    @Setter
+    private boolean withTies;
+    
+    /**
+     * Whether FETCH omits its row count and therefore defaults to one.
+     */
+    @Setter
+    private boolean implicitRowCount;
+    
     /**
      * Get offset.
      *
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/prepare/PrepareStatementQuerySegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/prepare/PrepareStatementQuerySegment.java
index 79b4e4c0634..59b0b29d1ad 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/prepare/PrepareStatementQuerySegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/prepare/PrepareStatementQuerySegment.java
@@ -23,6 +23,7 @@ import lombok.Setter;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.SQLSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 
@@ -48,6 +49,8 @@ public final class PrepareStatementQuerySegment implements SQLSegment {
     
     private DeleteStatement delete;
     
+    private MergeStatement merge;
+    
     /**
      * Get select statement.
      *
@@ -83,4 +86,13 @@ public final class PrepareStatementQuerySegment implements SQLSegment {
     public Optional<DeleteStatement> getDelete() {
         return Optional.ofNullable(delete);
     }
+    
+    /**
+     * Get merge statement.
+     *
+     * @return merge statement
+     */
+    public Optional<MergeStatement> getMerge() {
+        return Optional.ofNullable(merge);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/generic/table/JoinTableSegment.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/generic/table/JoinTableSegment.java
index 92c01c884a2..011f2ae2aa0 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/generic/table/JoinTableSegment.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/generic/table/JoinTableSegment.java
@@ -41,6 +41,8 @@ public final class JoinTableSegment implements TableSegment {
     
     private AliasSegment alias;
     
+    private AliasSegment usingAlias;
+    
     private TableSegment left;
     
     private boolean natural;
@@ -81,4 +83,13 @@ public final class JoinTableSegment implements TableSegment {
     public Optional<AliasSegment> getAliasSegment() {
         return Optional.ofNullable(alias);
     }
+    
+    /**
+     * Get the alias of the USING columns.
+     *
+     * @return USING alias segment
+     */
+    public Optional<AliasSegment> getUsingAliasSegment() {
+        return Optional.ofNullable(usingAlias);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatement.java
index 1ed898c50b0..22971167c62 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatement.java
@@ -25,6 +25,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.S
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 
@@ -44,24 +45,30 @@ public final class PrepareStatement extends DDLStatement {
     
     private final DeleteStatement delete;
     
+    private final MergeStatement merge;
+    
     private final SQLStatementAttributes attributes;
     
     @Builder
-    private PrepareStatement(final DatabaseType databaseType, final SelectStatement select, final InsertStatement insert, final UpdateStatement update, final DeleteStatement delete) {
+    private PrepareStatement(final DatabaseType databaseType, final SelectStatement select, final InsertStatement insert, final UpdateStatement update, final DeleteStatement delete,
+                             final MergeStatement merge) {
         super(databaseType);
         this.select = select;
         this.insert = insert;
         this.update = update;
         this.delete = delete;
-        attributes = createAttributes(select, insert, update, delete);
+        this.merge = merge;
+        attributes = createAttributes(select, insert, update, delete, merge);
     }
     
-    private SQLStatementAttributes createAttributes(final SelectStatement select, final InsertStatement insert, final UpdateStatement update, final DeleteStatement delete) {
+    private SQLStatementAttributes createAttributes(final SelectStatement select, final InsertStatement insert, final UpdateStatement update, final DeleteStatement delete,
+                                                    final MergeStatement merge) {
         TableExtractor tableExtractor = new TableExtractor();
         Optional.ofNullable(select).ifPresent(tableExtractor::extractTablesFromSelect);
         Optional.ofNullable(insert).ifPresent(tableExtractor::extractTablesFromInsert);
         Optional.ofNullable(update).ifPresent(tableExtractor::extractTablesFromUpdate);
         Optional.ofNullable(delete).ifPresent(tableExtractor::extractTablesFromDelete);
+        Optional.ofNullable(merge).ifPresent(tableExtractor::extractTablesFromMerge);
         return new SQLStatementAttributes(new TableSQLStatementAttribute(tableExtractor.getRewriteTables()));
     }
     
@@ -100,4 +107,13 @@ public final class PrepareStatement extends DDLStatement {
     public Optional<DeleteStatement> getDelete() {
         return Optional.ofNullable(delete);
     }
+    
+    /**
+     * Get merge statement.
+     *
+     * @return merge statement
+     */
+    public Optional<MergeStatement> getMerge() {
+        return Optional.ofNullable(merge);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/util/SQLUtils.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/util/SQLUtils.java
index 1c642c2a16e..cb54c623138 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/util/SQLUtils.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/util/SQLUtils.java
@@ -40,6 +40,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.value.literal.impl.Te
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -287,9 +288,9 @@ public final class SQLUtils {
             return new TemporalLiteralExpressionSegment(startIndex, stopIndex, ((DateTimeLiteralValue) astNode).getDateTimeValue(), text);
         }
         if (astNode instanceof OtherLiteralValue) {
-            return new CommonExpressionSegment(startIndex, stopIndex, ((OtherLiteralValue) astNode).getValue());
+            return new CommonExpressionSegment(startIndex, stopIndex, ((OtherLiteralValue) astNode).getValue(), Collections.emptyList());
         }
-        return new CommonExpressionSegment(startIndex, stopIndex, text);
+        return new CommonExpressionSegment(startIndex, stopIndex, text, Collections.emptyList());
     }
     
     /**
diff --git a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractorTest.java b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractorTest.java
index 6fcfaaeb361..22dec131350 100644
--- a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractorTest.java
+++ b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ColumnExtractorTest.java
@@ -31,6 +31,8 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.Func
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
@@ -69,6 +71,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -76,6 +79,7 @@ import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.mockito.Mockito.mock;
 
 class ColumnExtractorTest {
@@ -99,6 +103,29 @@ class ColumnExtractorTest {
         assertThat(toColumnNames(ColumnExtractor.extract(expression)), is(expectedColumnNames));
     }
     
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("provideCommonExpressions")
+    void assertExtractFromCommonExpression(final String name, final CommonExpressionSegment expression, final List<ColumnSegment> expected) {
+        Collection<ColumnSegment> actual = ColumnExtractor.extract(expression);
+        assertThat(actual.size(), is(expected.size()));
+        Iterator<ColumnSegment> actualIterator = actual.iterator();
+        for (int index = 0; index < expected.size(); index++) {
+            assertThat(actualIterator.next(), sameInstance(expected.get(index)));
+        }
+    }
+    
+    private static Stream<Arguments> provideCommonExpressions() {
+        ColumnSegment first = createColumnSegment("foo_indexed");
+        ColumnSegment second = createColumnSegment("bar_indexed");
+        CommonExpressionSegment direct = new CommonExpressionSegment(0, 0, "(foo_indexed)[1]", Collections.singleton(first));
+        CommonExpressionSegment inner = new CommonExpressionSegment(0, 0, "bar_indexed || foo_indexed", Arrays.asList(second, first));
+        CommonExpressionSegment nested = new CommonExpressionSegment(0, 0, "(foo_indexed || (bar_indexed || foo_indexed))[1]", Arrays.asList(first, inner));
+        return Stream.of(
+                Arguments.of("Empty common expression", new CommonExpressionSegment(0, 0, "legacy", Collections.emptyList()), Collections.emptyList()),
+                Arguments.of("Common column", direct, Collections.singletonList(first)),
+                Arguments.of("Nested common order and deduplication", nested, Arrays.asList(first, second)));
+    }
+    
     private static Stream<Arguments> provideSelectStatements() {
         return Stream.of(
                 Arguments.of("FullSegments", createSelectStatementForExtraction(), true, Arrays.asList(
@@ -157,6 +184,9 @@ class ColumnExtractorTest {
                 Arguments.of("BetweenExpressionWithNonColumnOperands", createBetweenExpressionWithMixedOperands(),
                         Arrays.asList("foo_between_function_column", "foo_between_binary_left", "bar_between_binary_right")),
                 Arguments.of("ListExpressionWithColumns", createListExpression(), Arrays.asList("foo_list_left", "bar_list_right")),
+                Arguments.of("TypeCastColumn", new TypeCastExpression(0, 0, "", createColumnSegment("foo_cast_column"), "text"), Collections.singletonList("foo_cast_column")),
+                Arguments.of("BinaryOperationWithTypeCastOperand", new BinaryOperationExpression(0, 0, new TypeCastExpression(0, 0, "", createColumnSegment("foo_cast_left"), "integer"),
+                        createColumnSegment("bar_cast_right"), "+", ""), Arrays.asList("bar_cast_right", "foo_cast_left")),
                 Arguments.of("AggregationProjectionWithFunctionParameters", createAggregationProjectionExpression(),
                         Arrays.asList("foo_agg_direct", "foo_agg_func_direct", "foo_agg_func_binary_left", "bar_agg_func_binary_right")),
                 Arguments.of("AggregationProjectionWithWindow", createAggregationProjectionWithWindow(),
@@ -164,6 +194,7 @@ class ColumnExtractorTest {
                                 "foo_agg_window_order_column", "foo_agg_window_order_expr_left", "bar_agg_window_order_expr_right", "foo_agg_window_frame_column")),
                 Arguments.of("FunctionSegmentWithNestedBinary", createFunctionWithColumnAndBinaryParameter(),
                         Arrays.asList("foo_function_direct", "foo_function_binary_left", "bar_function_binary_right")),
+                Arguments.of("FunctionSegmentWithTypeCastParameters", createFunctionWithTypeCastParameters(), Collections.singletonList("foo_cast_column")),
                 Arguments.of("FunctionSegmentWithWindow", createFunctionWithWindow(),
                         Arrays.asList("foo_function_param", "foo_window_partition", "bar_window_partition_func",
                                 "foo_window_order_column", "foo_window_order_expr_left", "bar_window_order_expr_right", "foo_window_frame_column")),
@@ -173,6 +204,13 @@ class ColumnExtractorTest {
                         Arrays.asList("foo_xml_serialize_param", "bar_xml_serialize_attr")));
     }
     
+    private static FunctionSegment createFunctionWithTypeCastParameters() {
+        FunctionSegment result = new FunctionSegment(0, 0, "FUNC", "func");
+        result.getParameters().add(new TypeCastExpression(0, 0, "", new TypeCastExpression(0, 0, "", createColumnSegment("foo_cast_column"), "integer"), "text"));
+        result.getParameters().add(new TypeCastExpression(0, 0, "", new LiteralExpressionSegment(0, 0, 1), "integer"));
+        return result;
+    }
+    
     private static Collection<WhereSegment> createWhereSegments() {
         BinaryOperationExpression leftExpression = new BinaryOperationExpression(10, 24,
                 new ColumnSegment(10, 13, new IdentifierValue("foo_name")), new LiteralExpressionSegment(18, 22, "LiLei"), "=", "foo_name = 'LiLei'");
@@ -241,7 +279,7 @@ class ColumnExtractorTest {
         JoinTableSegment innerJoin = new JoinTableSegment();
         innerJoin.setLeft(new CollectionTableSegment(createColumnSegment("foo_collection_expr")));
         CommonTableExpressionSegment commonTableExpressionSegment = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("cte_alias")),
-                new SubquerySegment(0, 0, createSelectStatementWithProjection("foo_cte_subquery_column"), ""));
+                new SubquerySegment(0, 0, createSelectStatementWithProjection("foo_cte_subquery_column"), ""), null);
         innerJoin.setRight(commonTableExpressionSegment);
         innerJoin.setCondition(createBinaryOperation("foo_inner_join_left", "bar_inner_join_right"));
         JoinTableSegment result = new JoinTableSegment();
diff --git a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractorTest.java b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractorTest.java
index f495285096c..44c6a507cda 100644
--- a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractorTest.java
+++ b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/ExpressionExtractorTest.java
@@ -20,16 +20,20 @@ package org.apache.shardingsphere.sql.parser.statement.core.extractor;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.ParameterMarkerType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CollateExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.AndPredicate;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.WhereSegment;
@@ -38,15 +42,21 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.Se
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
 
 class ExpressionExtractorTest {
     
@@ -198,21 +208,47 @@ class ExpressionExtractorTest {
         BinaryOperationExpression param1 = new BinaryOperationExpression(0, 0,
                 new BinaryOperationExpression(0, 0, new ColumnSegment(0, 0, new IdentifierValue("number")), new LiteralExpressionSegment(0, 0, 1), "+", "number + 1"),
                 new ParameterMarkerExpressionSegment(0, 0, 2), "<=", "number + 1 <= ?");
-        CommonExpressionSegment param2 = new CommonExpressionSegment(0, 0, "1");
-        CommonExpressionSegment param3 = new CommonExpressionSegment(0, 0, "-1");
+        CommonExpressionSegment param2 = new CommonExpressionSegment(0, 0, "1", Collections.emptyList());
+        CommonExpressionSegment param3 = new CommonExpressionSegment(0, 0, "-1", Collections.emptyList());
         functionSegment.getParameters().add(param1);
         functionSegment.getParameters().add(param2);
         functionSegment.getParameters().add(param3);
         assertThat(ExpressionExtractor.getParameterMarkerExpressions(Collections.singleton(functionSegment)).size(), is(1));
     }
     
-    @Test
-    void assertGetParameterMarkerExpressionsFromTypeCastExpression() {
-        ParameterMarkerExpressionSegment expected = new ParameterMarkerExpressionSegment(0, 0, 1, ParameterMarkerType.DOLLAR);
-        Collection<ExpressionSegment> input = Collections.singleton(new TypeCastExpression(0, 0, "$2::varchar", expected, "varchar"));
-        List<ParameterMarkerExpressionSegment> actual = ExpressionExtractor.getParameterMarkerExpressions(input);
-        assertThat(actual.size(), is(1));
-        assertThat(actual.get(0), is(expected));
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("provideParameterMarkerExpressions")
+    void assertGetParameterMarkerExpressions(final String name, final Collection<ExpressionSegment> expressions, final List<ParameterMarkerExpressionSegment> expected) {
+        List<ParameterMarkerExpressionSegment> actual = ExpressionExtractor.getParameterMarkerExpressions(expressions);
+        assertThat(actual.size(), is(expected.size()));
+        for (int index = 0; index < expected.size(); index++) {
+            assertThat(actual.get(index), sameInstance(expected.get(index)));
+        }
+    }
+    
+    private static Stream<Arguments> provideParameterMarkerExpressions() {
+        ParameterMarkerExpressionSegment direct = new ParameterMarkerExpressionSegment(0, 0, 1, ParameterMarkerType.DOLLAR);
+        ParameterMarkerExpressionSegment question = new ParameterMarkerExpressionSegment(1, 1, 0, ParameterMarkerType.QUESTION);
+        TypeCastExpression cast = new TypeCastExpression(1, 8, "?::int[]", question, "int[]");
+        CommonExpressionSegment wrappedCast = new CommonExpressionSegment(0, 12, "(?::int[])[1]", Arrays.asList(cast, new LiteralExpressionSegment(11, 11, 1)));
+        ParameterMarkerExpressionSegment firstDollar = new ParameterMarkerExpressionSegment(2, 3, 1, ParameterMarkerType.DOLLAR);
+        ParameterMarkerExpressionSegment secondDollar = new ParameterMarkerExpressionSegment(18, 19, 0, ParameterMarkerType.DOLLAR);
+        TypeCastExpression dollarCast = new TypeCastExpression(2, 10, "$2::int[]", firstDollar, "int[]");
+        CommonExpressionSegment inner = new CommonExpressionSegment(1, 14, "($2::int[])[1]", Arrays.asList(dollarCast, new LiteralExpressionSegment(13, 13, 1)));
+        CommonExpressionSegment nested = new CommonExpressionSegment(0, 15, "(($2::int[])[1])", Collections.singleton(inner));
+        RowExpression innerRow = new RowExpression(1, 19, "ROW($2, $1)");
+        innerRow.getItems().addAll(Arrays.asList(firstDollar, secondDollar));
+        RowExpression row = new RowExpression(0, 20, "ROW(?, ROW($2, $1))");
+        row.getItems().addAll(Arrays.asList(question, innerRow));
+        return Stream.of(
+                Arguments.of("Direct type cast", Collections.singleton(new TypeCastExpression(0, 0, "$2::varchar", direct, "varchar")), Collections.singletonList(direct)),
+                Arguments.of("Empty common expression", Collections.singleton(new CommonExpressionSegment(0, 0, "legacy", Collections.emptyList())), Collections.emptyList()),
+                Arguments.of("Wrapped type cast", Collections.singleton(wrappedCast), Collections.singletonList(question)),
+                Arguments.of("Nested common and sibling", Arrays.asList(nested, secondDollar), Arrays.asList(firstDollar, secondDollar)),
+                Arguments.of("Nested row marker order", Collections.singleton(row), Arrays.asList(question, firstDollar, secondDollar)),
+                Arguments.of("Unary marker", Collections.singleton(new UnaryOperationExpression(0, 3, firstDollar, "~", "~$2")), Collections.singletonList(firstDollar)),
+                Arguments.of("Collate expression marker", Collections.singleton(new CollateExpression(0, 20, new LiteralExpressionSegment(18, 20, "C"), dollarCast)),
+                        Collections.singletonList(firstDollar)));
     }
     
     @Test
@@ -246,6 +282,56 @@ class ExpressionExtractorTest {
         assertThat(actual.iterator().next(), is(binaryExpression));
     }
     
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("provideColumnExpressions")
+    void assertExtractColumns(final String name, final ExpressionSegment expression, final boolean containsSubquery, final Collection<ColumnSegment> expectedColumns) {
+        Collection<ColumnSegment> actual = ExpressionExtractor.extractColumns(expression, containsSubquery);
+        assertThat(actual.size(), is(expectedColumns.size()));
+        Iterator<ColumnSegment> actualColumns = actual.iterator();
+        for (ColumnSegment each : expectedColumns) {
+            assertThat(actualColumns.next(), sameInstance(each));
+        }
+    }
+    
+    private static Stream<Arguments> provideColumnExpressions() {
+        ColumnSegment first = new ColumnSegment(1, 7, new IdentifierValue("foo_col"));
+        ColumnSegment second = new ColumnSegment(9, 15, new IdentifierValue("bar_col"));
+        RowExpression row = new RowExpression(0, 25, "ROW(foo_col, bar_col, foo_col)");
+        row.getItems().addAll(Arrays.asList(first, second, first));
+        UnaryOperationExpression unary = new UnaryOperationExpression(0, 7, first, "~", "~foo_col");
+        CollateExpression collate = new CollateExpression(0, 20, new LiteralExpressionSegment(10, 20, "foo_collation"), second);
+        CommonExpressionSegment common = new CommonExpressionSegment(0, 25, "foo_col[bar_col][foo_col]", Arrays.asList(first, second, first));
+        CommonExpressionSegment nested = new CommonExpressionSegment(0, 50, "foo_nested", Arrays.asList(unary, row, collate));
+        SelectStatement select = SelectStatement.builder().projections(new ProjectionsSegment(0, 20)).build();
+        select.getProjections().getProjections().add(new ColumnProjectionSegment(first));
+        SubqueryExpressionSegment subquery = new SubqueryExpressionSegment(new SubquerySegment(0, 20, select, "(SELECT foo_col)"));
+        CommonExpressionSegment commonSubquery = new CommonExpressionSegment(0, 30, "(SELECT foo_col)[bar_col]", Arrays.asList(subquery, second));
+        UnaryOperationExpression unarySubquery = new UnaryOperationExpression(0, 21, subquery, "~", "~(SELECT foo_col)");
+        CollateExpression collateSubquery = new CollateExpression(0, 40, new LiteralExpressionSegment(22, 34, "foo_collation"), subquery);
+        RowExpression rowSubquery = new RowExpression(0, 40, "ROW((SELECT foo_col), bar_col)");
+        rowSubquery.getItems().addAll(Arrays.asList(subquery, second));
+        return Stream.of(
+                Arguments.of("Plain column", first, false, Collections.singletonList(first)),
+                Arguments.of("Literal without columns", new LiteralExpressionSegment(0, 0, 1), false, Collections.emptyList()),
+                Arguments.of("Common column order and duplicates", common, false, Arrays.asList(first, second, first)),
+                Arguments.of("Empty common expression", new CommonExpressionSegment(0, 0, "foo_empty", Collections.emptyList()), false, Collections.emptyList()),
+                Arguments.of("Nested expression columns", nested, false, Arrays.asList(first, first, second, first, second)),
+                Arguments.of("Row column order and duplicates", row, false, Arrays.asList(first, second, first)),
+                Arguments.of("Empty row", new RowExpression(0, 4, "ROW()"), false, Collections.emptyList()),
+                Arguments.of("Unary column", unary, false, Collections.singletonList(first)),
+                Arguments.of("Unary literal", new UnaryOperationExpression(0, 1, new LiteralExpressionSegment(1, 1, 1), "~", "~1"), false, Collections.emptyList()),
+                Arguments.of("Collate operand column", collate, false, Collections.singletonList(second)),
+                Arguments.of("Absent collate operand", new CollateExpression(0, 12, new LiteralExpressionSegment(0, 12, "foo_collation"), null), false, Collections.emptyList()),
+                Arguments.of("Common excludes subquery columns", commonSubquery, false, Collections.singletonList(second)),
+                Arguments.of("Common includes subquery columns", commonSubquery, true, Arrays.asList(first, second)),
+                Arguments.of("Unary excludes subquery columns", unarySubquery, false, Collections.emptyList()),
+                Arguments.of("Unary includes subquery columns", unarySubquery, true, Collections.singletonList(first)),
+                Arguments.of("Collate excludes subquery columns", collateSubquery, false, Collections.emptyList()),
+                Arguments.of("Collate includes subquery columns", collateSubquery, true, Collections.singletonList(first)),
+                Arguments.of("Row excludes subquery columns", rowSubquery, false, Collections.singletonList(second)),
+                Arguments.of("Row includes subquery columns", rowSubquery, true, Arrays.asList(first, second)));
+    }
+    
     @Test
     void assertGetNestedSubqueryCompareExpressionsFromUpdateStatement() {
         ExpressionSegment expectedExpression = createSubqueryCompareExpression(">");
diff --git a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractorTest.java b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractorTest.java
index 03d2378877b..e1ddd1a6b83 100644
--- a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractorTest.java
+++ b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/SubqueryExtractorTest.java
@@ -19,12 +19,18 @@ package org.apache.shardingsphere.sql.parser.statement.core.extractor;
 
 import org.apache.shardingsphere.sql.parser.statement.core.enums.AggregationType;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.CombineType;
+import org.apache.shardingsphere.sql.parser.statement.core.enums.SubqueryType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.CombineSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CollateExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
@@ -34,20 +40,32 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.Expr
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.SubqueryProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.WhereSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.JoinTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SubqueryTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Optional;
+import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -207,6 +225,110 @@ class SubqueryExtractorTest {
         assertThat(SubqueryExtractor.extractSubquerySegments(selectStatement, false).size(), is(1));
     }
     
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("provideExpressionSubqueries")
+    void assertExtractSubquerySegmentsFromExpression(final String name, final SelectStatement selectStatement, final boolean needRecursive,
+                                                     final List<SubquerySegment> expected, final List<SubqueryType> expectedTypes) {
+        Collection<SubquerySegment> actual = SubqueryExtractor.extractSubquerySegments(selectStatement, needRecursive);
+        assertThat(actual.size(), is(expected.size()));
+        Iterator<SubquerySegment> actualIterator = actual.iterator();
+        for (int index = 0; index < expected.size(); index++) {
+            SubquerySegment actualSubquery = actualIterator.next();
+            assertThat(actualSubquery, sameInstance(expected.get(index)));
+            assertThat(actualSubquery.getSelect().getSubqueryType().orElse(null), is(expectedTypes.get(index)));
+        }
+    }
+    
+    private static Stream<Arguments> provideExpressionSubqueries() {
+        SubquerySegment first = new SubquerySegment(1, 9, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment second = new SubquerySegment(11, 19, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        CommonExpressionSegment inner = new CommonExpressionSegment(10, 20, "nested", Collections.singleton(new SubqueryExpressionSegment(second)));
+        CommonExpressionSegment siblings = new CommonExpressionSegment(0, 21, "indexed", Arrays.asList(new SubqueryExpressionSegment(first), inner));
+        SubquerySegment predicate = new SubquerySegment(1, 9, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SelectStatement predicateStatement = SelectStatement.builder().projections(new ProjectionsSegment(0, 0))
+                .where(new WhereSegment(0, 10, new CommonExpressionSegment(0, 10, "indexed", Collections.singleton(new SubqueryExpressionSegment(predicate))))).build();
+        SubquerySegment directNested = new SubquerySegment(2, 8, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment directOuter = createSubqueryWithNestedPredicate(directNested);
+        SubquerySegment recursiveNested = new SubquerySegment(2, 8, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment recursiveOuter = createSubqueryWithNestedPredicate(recursiveNested);
+        SubquerySegment firstRow = new SubquerySegment(1, 9, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment secondRow = new SubquerySegment(11, 19, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        RowExpression innerRow = new RowExpression(10, 20, "ROW");
+        innerRow.getItems().add(new SubqueryExpressionSegment(secondRow));
+        RowExpression row = new RowExpression(0, 21, "ROW");
+        row.getItems().addAll(Arrays.asList(new SubqueryExpressionSegment(firstRow), innerRow));
+        SubquerySegment unaryNested = new SubquerySegment(2, 8, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment unaryOuter = createSubqueryWithNestedPredicate(unaryNested);
+        SelectStatement unaryPredicate = SelectStatement.builder().projections(new ProjectionsSegment(0, 0))
+                .where(new WhereSegment(0, 10, new UnaryOperationExpression(0, 10, new SubqueryExpressionSegment(unaryOuter), "~", "~(SELECT)"))).build();
+        SubquerySegment collateNested = new SubquerySegment(2, 8, SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).build(), "");
+        SubquerySegment collateOuter = createSubqueryWithNestedPredicate(collateNested);
+        CollateExpression collate = new CollateExpression(0, 15, new LiteralExpressionSegment(12, 14, "C"), new SubqueryExpressionSegment(collateOuter));
+        return Stream.of(
+                Arguments.of("Empty common expression", createSelectWithExpressionProjection(new CommonExpressionSegment(0, 0, "legacy", Collections.emptyList())), false,
+                        Collections.emptyList(), Collections.emptyList()),
+                Arguments.of("Nested common projection order", createSelectWithExpressionProjection(siblings), false,
+                        Arrays.asList(first, second), Arrays.asList(SubqueryType.PROJECTION, SubqueryType.PROJECTION)),
+                Arguments.of("Common predicate type", predicateStatement, false, Collections.singletonList(predicate), Collections.singletonList(SubqueryType.PREDICATE)),
+                Arguments.of("Common without SELECT recursion", createSelectWithExpressionProjection(
+                        new CommonExpressionSegment(0, 10, "indexed", Collections.singleton(new SubqueryExpressionSegment(directOuter)))), false,
+                        Collections.singletonList(directOuter), Collections.singletonList(SubqueryType.PROJECTION)),
+                Arguments.of("Common with SELECT recursion", createSelectWithExpressionProjection(
+                        new CommonExpressionSegment(0, 10, "indexed", Collections.singleton(new SubqueryExpressionSegment(recursiveOuter)))), true,
+                        Arrays.asList(recursiveOuter, recursiveNested), Arrays.asList(SubqueryType.PROJECTION, SubqueryType.PREDICATE)),
+                Arguments.of("Nested row projection order", createSelectWithExpressionProjection(row), false,
+                        Arrays.asList(firstRow, secondRow), Arrays.asList(SubqueryType.PROJECTION, SubqueryType.PROJECTION)),
+                Arguments.of("Unary predicate without SELECT recursion", unaryPredicate, false, Collections.singletonList(unaryOuter), Collections.singletonList(SubqueryType.PREDICATE)),
+                Arguments.of("Collate with SELECT recursion", createSelectWithExpressionProjection(collate), true,
+                        Arrays.asList(collateOuter, collateNested), Arrays.asList(SubqueryType.PROJECTION, SubqueryType.PREDICATE)));
+    }
+    
+    private static SubquerySegment createSubqueryWithNestedPredicate(final SubquerySegment nested) {
+        SelectStatement selectStatement = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).where(new WhereSegment(0, 10, new SubqueryExpressionSegment(nested))).build();
+        return new SubquerySegment(0, 10, selectStatement, "");
+    }
+    
+    private static SelectStatement createSelectWithExpressionProjection(final ExpressionSegment expression) {
+        ProjectionsSegment projections = new ProjectionsSegment(expression.getStartIndex(), expression.getStopIndex());
+        projections.getProjections().add(new ExpressionProjectionSegment(expression.getStartIndex(), expression.getStopIndex(), expression.getText(), expression));
+        return SelectStatement.builder().projections(projections).build();
+    }
+    
+    @Test
+    void assertExtractSubquerySegmentsInDataModifyingCTE() {
+        CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_cte")), null, mock(UpdateStatement.class));
+        WithSegment withSegment = new WithSegment(0, 0, Collections.singletonList(commonTableExpression), false);
+        SelectStatement selectStatement = mockSelectStatement();
+        when(selectStatement.getWith()).thenReturn(Optional.of(withSegment));
+        assertTrue(SubqueryExtractor.extractSubquerySegments(selectStatement, true).isEmpty());
+    }
+    
+    @Test
+    void assertExtractSubquerySegmentsInCTEWithRecursion() {
+        SubquerySegment nestedSubquery = new SubquerySegment(0, 0, mockSelectStatement(), "");
+        SelectStatement commonTableSelect = mockSelectStatement();
+        when(commonTableSelect.getFrom()).thenReturn(Optional.of(new SubqueryTableSegment(0, 0, nestedSubquery)));
+        SubquerySegment commonTableSubquery = new SubquerySegment(0, 0, commonTableSelect, "");
+        CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_cte")), commonTableSubquery, null);
+        WithSegment withSegment = new WithSegment(0, 0, Collections.singletonList(commonTableExpression), false);
+        SelectStatement selectStatement = mockSelectStatement();
+        when(selectStatement.getWith()).thenReturn(Optional.of(withSegment));
+        assertThat(SubqueryExtractor.extractSubquerySegments(selectStatement, true), is(Arrays.asList(commonTableSubquery, nestedSubquery)));
+    }
+    
+    @Test
+    void assertExtractSubquerySegmentsInCTEWithoutRecursion() {
+        SubquerySegment nestedSubquery = new SubquerySegment(0, 0, mockSelectStatement(), "");
+        SelectStatement commonTableSelect = mockSelectStatement();
+        when(commonTableSelect.getFrom()).thenReturn(Optional.of(new SubqueryTableSegment(0, 0, nestedSubquery)));
+        SubquerySegment commonTableSubquery = new SubquerySegment(0, 0, commonTableSelect, "");
+        CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_cte")), commonTableSubquery, null);
+        WithSegment withSegment = new WithSegment(0, 0, Collections.singletonList(commonTableExpression), false);
+        SelectStatement selectStatement = mockSelectStatement();
+        when(selectStatement.getWith()).thenReturn(Optional.of(withSegment));
+        assertThat(SubqueryExtractor.extractSubquerySegments(selectStatement, false), is(Collections.singletonList(commonTableSubquery)));
+    }
+    
     private SelectStatement mockSelectStatement() {
         SelectStatement result = mock(SelectStatement.class);
         when(result.withSubqueryType(any())).thenReturn(result);
diff --git a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractorTest.java b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractorTest.java
index d91afdcabed..7509f35db4b 100644
--- a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractorTest.java
+++ b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/extractor/TableExtractorTest.java
@@ -17,31 +17,47 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.extractor;
 
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.AggregationType;
 import org.apache.shardingsphere.sql.parser.statement.core.enums.CombineType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.ValidStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.ReturningSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.ColumnAssignmentSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.InsertValuesSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.assignment.SetAssignmentSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.OnDuplicateKeyColumnsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.CombineSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExistsSubqueryExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionWithParamsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ExpressionProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ShorthandProjectionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.SubqueryProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.merge.MergeWhenAndThenSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.LockSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.predicate.WhereSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.OwnerSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.FunctionTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.JoinTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SubqueryTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.SQLStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.CommentStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
@@ -49,18 +65,30 @@ import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.in
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.index.DropIndexStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.AlterTableStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.CreateTableStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
+import org.apache.shardingsphere.test.infra.fixture.database.MockedDatabaseType;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.is;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
@@ -70,6 +98,202 @@ class TableExtractorTest {
     
     private final TableExtractor tableExtractor = new TableExtractor();
     
+    @Test
+    void assertExtractUnaryExpressionTableOwner() {
+        SimpleTableSegment table = new SimpleTableSegment(new TableNameSegment(30, 38, new IdentifierValue("foo_table")));
+        ColumnSegment column = new ColumnSegment(14, 15, new IdentifierValue("id"));
+        column.setOwner(new OwnerSegment(4, 12, new IdentifierValue("foo_table")));
+        ProjectionsSegment projections = new ProjectionsSegment(0, 15);
+        projections.getProjections().add(new ExpressionProjectionSegment(3, 15, "~foo_table.id", new UnaryOperationExpression(3, 15, column, "~", "~foo_table.id")));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).from(table).build());
+        assertThat(tableExtractor.getRewriteTables().size(), is(2));
+        Iterator<SimpleTableSegment> actualTables = tableExtractor.getRewriteTables().iterator();
+        assertThat(actualTables.next(), is(table));
+        SimpleTableSegment actualOwner = actualTables.next();
+        assertThat(actualOwner.getStartIndex(), is(4));
+        assertThat(actualOwner.getStopIndex(), is(12));
+        assertThat(actualOwner.getTableName().getIdentifier().getValue(), is("foo_table"));
+    }
+    
+    @Test
+    void assertExtractUnaryExpressionTableAlias() {
+        SimpleTableSegment table = new SimpleTableSegment(new TableNameSegment(30, 38, new IdentifierValue("foo_table")));
+        table.setAlias(new AliasSegment(40, 40, new IdentifierValue("f")));
+        ColumnSegment column = new ColumnSegment(6, 7, new IdentifierValue("id"));
+        column.setOwner(new OwnerSegment(4, 4, new IdentifierValue("f")));
+        ProjectionsSegment projections = new ProjectionsSegment(0, 7);
+        projections.getProjections().add(new ExpressionProjectionSegment(3, 7, "~f.id", new UnaryOperationExpression(3, 7, column, "~", "~f.id")));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).from(table).build());
+        assertThat(tableExtractor.getRewriteTables(), contains(table));
+    }
+    
+    @Test
+    void assertExtractNestedUnarySubqueryTables() {
+        SimpleTableSegment table = new SimpleTableSegment(new TableNameSegment(30, 39, new IdentifierValue("foo_nested")));
+        SelectStatement subquery = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).from(table).build();
+        SubqueryExpressionSegment subqueryExpression = new SubqueryExpressionSegment(new SubquerySegment(5, 40, subquery, "SELECT id FROM foo_nested"));
+        UnaryOperationExpression inner = new UnaryOperationExpression(4, 41, subqueryExpression, "~", "~(SELECT id FROM foo_nested)");
+        UnaryOperationExpression expression = new UnaryOperationExpression(3, 41, inner, "~", "~~(SELECT id FROM foo_nested)");
+        ProjectionsSegment projections = new ProjectionsSegment(0, 41);
+        projections.getProjections().add(new ExpressionProjectionSegment(3, 41, expression.getText(), expression));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).build());
+        assertThat(tableExtractor.getRewriteTables(), contains(table));
+    }
+    
+    @Test
+    void assertExtractCommonExpressionTableOrder() {
+        SimpleTableSegment first = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_first")));
+        SimpleTableSegment second = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_second")));
+        CommonExpressionSegment indexed = new CommonExpressionSegment(0, 0, "ARRAY[(SELECT id FROM foo_first)][(SELECT id FROM foo_second)]",
+                Arrays.asList(createSubqueryExpression(first), new CommonExpressionSegment(0, 0, "(SELECT id FROM foo_second)", Collections.singletonList(createSubqueryExpression(second)))));
+        ProjectionsSegment projections = new ProjectionsSegment(0, 0);
+        projections.getProjections().add(new ExpressionProjectionSegment(0, 0, "", indexed));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).build());
+        assertThat(tableExtractor.getRewriteTables(), contains(first, second));
+    }
+    
+    private static SubqueryExpressionSegment createSubqueryExpression(final SimpleTableSegment table) {
+        SelectStatement statement = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).from(table).build();
+        return new SubqueryExpressionSegment(new SubquerySegment(0, 0, statement, ""));
+    }
+    
+    @Test
+    void assertExtractLegacyCommonExpressionTables() {
+        ProjectionsSegment projections = new ProjectionsSegment(0, 10);
+        projections.getProjections().add(new ExpressionProjectionSegment(0, 10, "legacy text", new CommonExpressionSegment(0, 10, "legacy text", Collections.emptyList())));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).build());
+        assertTrue(tableExtractor.getRewriteTables().isEmpty());
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getDataModificationArguments")
+    void assertExtractTablesFromDataModification(final String name, final DMLStatement body, final int expectedTableCount) {
+        CommonTableExpressionSegment commonTable = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_changed")), null, body);
+        WithSegment with = new WithSegment(0, 0, Collections.singletonList(commonTable));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).with(with).build());
+        assertThat(tableExtractor.getRewriteTables().size(), is(expectedTableCount));
+        assertThat(tableExtractor.getRewriteTables().iterator().next().getTableName().getIdentifier().getValue(), is("foo_target"));
+    }
+    
+    private static Stream<Arguments> getDataModificationArguments() {
+        SimpleTableSegment target = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_target")));
+        SimpleTableSegment source = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_source")));
+        SelectStatement select = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).from(source).build();
+        return Stream.of(Arguments.of("insert", InsertStatement.builder().table(target).build(), 1),
+                Arguments.of("insert select", InsertStatement.builder().table(target).insertSelect(new SubquerySegment(0, 0, select, "")).build(), 2),
+                Arguments.of("update", UpdateStatement.builder().table(target).setAssignment(new SetAssignmentSegment(0, 0, Collections.emptyList())).build(), 1),
+                Arguments.of("update from", UpdateStatement.builder().table(target).from(source).setAssignment(new SetAssignmentSegment(0, 0, Collections.emptyList())).build(), 2),
+                Arguments.of("delete", DeleteStatement.builder().table(target).build(), 1),
+                Arguments.of("merge", MergeStatement.builder().target(target).source(source).build(), 2));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getMergeArguments")
+    void assertExtractTablesFromMerge(final String name, final MergeStatement mergeStatement, final Collection<SimpleTableSegment> expected) {
+        tableExtractor.extractTablesFromMerge(mergeStatement);
+        assertThat(tableExtractor.getRewriteTables().size(), is(expected.size()));
+        Iterator<SimpleTableSegment> actual = tableExtractor.getRewriteTables().iterator();
+        for (SimpleTableSegment each : expected) {
+            assertTableSegment(actual.next(), each.getStartIndex(), each.getStopIndex(), each.getTableName().getIdentifier().getValue());
+        }
+    }
+    
+    private static Stream<Arguments> getMergeArguments() {
+        SimpleTableSegment nested = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_nested")));
+        SelectStatement nestedSelect = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).from(nested).build();
+        ExistsSubqueryExpression expression = new ExistsSubqueryExpression(0, 0, new SubquerySegment(0, 0, nestedSelect, ""));
+        SimpleTableSegment updateConditionTable = createScopeTable("foo_update_condition", 100);
+        SimpleTableSegment firstUpdateTable = createScopeTable("foo_first_update", 150);
+        SimpleTableSegment secondUpdateTable = createScopeTable("foo_second_update", 200);
+        MergeWhenAndThenSegment update = new MergeWhenAndThenSegment(0, 0, "WHEN MATCHED AND EXISTS (...) THEN UPDATE SET id = (...), value = (...)");
+        update.setAndExpr(new ExistsSubqueryExpression(0, 0, createSubqueryExpression(updateConditionTable).getSubquery()));
+        update.setUpdate(UpdateStatement.builder().setAssignment(new SetAssignmentSegment(0, 0, Arrays.asList(
+                new ColumnAssignmentSegment(0, 0, Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("id"))), createSubqueryExpression(firstUpdateTable)),
+                new ColumnAssignmentSegment(0, 0, Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("value"))), createSubqueryExpression(secondUpdateTable))))).build());
+        SimpleTableSegment insertConditionTable = createScopeTable("foo_insert_condition", 250);
+        SimpleTableSegment firstInsertTable = createScopeTable("foo_first_insert", 300);
+        SimpleTableSegment secondInsertTable = createScopeTable("foo_second_insert", 350);
+        MergeWhenAndThenSegment insert = new MergeWhenAndThenSegment(0, 0, "WHEN NOT MATCHED AND EXISTS (...) THEN INSERT VALUES ((...), (...))");
+        insert.setAndExpr(new ExistsSubqueryExpression(0, 0, createSubqueryExpression(insertConditionTable).getSubquery()));
+        insert.setInsert(InsertStatement.builder().values(Collections.singletonList(new InsertValuesSegment(0, 0,
+                Arrays.asList(createSubqueryExpression(firstInsertTable), createSubqueryExpression(secondInsertTable))))).build());
+        SimpleTableSegment commonTableSource = createScopeTable("foo_common_source", 450);
+        CommonTableExpressionSegment commonTable = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_source")),
+                createSubqueryExpression(commonTableSource).getSubquery(), null);
+        MergeWhenAndThenSegment delete = new MergeWhenAndThenSegment(0, 0, "WHEN MATCHED AND EXISTS (...) THEN DELETE");
+        delete.setAndExpr(expression);
+        delete.setDelete(DeleteStatement.builder().build());
+        MergeWhenAndThenSegment doNothing = new MergeWhenAndThenSegment(0, 0, "WHEN NOT MATCHED THEN DO NOTHING");
+        ExpressionWithParamsSegment onExpression = new ExpressionWithParamsSegment(0, 0, new LiteralExpressionSegment(0, 0, true));
+        MergeWhenAndThenSegment defaultInsert = new MergeWhenAndThenSegment(0, 0, "WHEN NOT MATCHED THEN INSERT DEFAULT VALUES");
+        defaultInsert.setInsert(InsertStatement.builder().build());
+        SimpleTableSegment innerTarget = createScopeTable("foo_inner_target", 10);
+        MergeStatement innerMerge = MergeStatement.builder().target(innerTarget).source(nested).expression(onExpression).whenAndThens(Collections.singletonList(doNothing)).build();
+        CommonTableExpressionSegment mergingCommonTable = new CommonTableExpressionSegment(0, 0, new AliasSegment(0, 0, new IdentifierValue("foo_merged")), null, innerMerge);
+        WithSegment mergingWith = new WithSegment(0, 0, Arrays.asList(mergingCommonTable, commonTable));
+        ReturningSegment defaultReturning = new ReturningSegment(0, 0, createScopeProjections(
+                new ColumnProjectionSegment(createScopeColumn("old", 70)), new ColumnProjectionSegment(createScopeColumn("new", 90))));
+        ReturningSegment aliasedReturning = new ReturningSegment(0, 0, createScopeProjections(
+                new ColumnProjectionSegment(createScopeColumn("old_row", 70)), new ColumnProjectionSegment(createScopeColumn("new_row", 90))));
+        aliasedReturning.setOldAlias(new AliasSegment(0, 0, new IdentifierValue("old_row")));
+        aliasedReturning.setNewAlias(new AliasSegment(0, 0, new IdentifierValue("new_row")));
+        SimpleTableSegment shadowingTable = createScopeTable("old_row", 150);
+        SelectStatement shadowingSelect = SelectStatement.builder().from(shadowingTable)
+                .projections(createScopeProjections(new ColumnProjectionSegment(createScopeColumn("old_row", 180)))).build();
+        ReturningSegment shadowingReturning = new ReturningSegment(0, 0, createScopeProjections(
+                new ColumnProjectionSegment(createScopeColumn("old_row", 70)), new SubqueryProjectionSegment(new SubquerySegment(0, 0, shadowingSelect, ""), "")));
+        shadowingReturning.setOldAlias(new AliasSegment(0, 0, new IdentifierValue("old_row")));
+        SimpleTableSegment oldTable = createScopeTable("old", 10);
+        SimpleTableSegment newTable = createScopeTable("new", 30);
+        SelectStatement correlatedSelect = SelectStatement.builder().projections(createScopeProjections(new ColumnProjectionSegment(createScopeColumn("old", 150)))).build();
+        SubqueryTableSegment derivedTable = new SubqueryTableSegment(0, 0, new SubquerySegment(0, 0, correlatedSelect, ""));
+        derivedTable.setAlias(new AliasSegment(0, 0, new IdentifierValue("x")));
+        SelectStatement derivedSelect = SelectStatement.builder().from(derivedTable).projections(createScopeProjections(new ColumnProjectionSegment(createScopeColumn("x", 180)))).build();
+        ReturningSegment derivedReturning = new ReturningSegment(0, 0,
+                createScopeProjections(new SubqueryProjectionSegment(new SubquerySegment(0, 0, derivedSelect, ""), "")));
+        SimpleTableSegment target = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_target")));
+        SimpleTableSegment source = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_source")));
+        MergeStatement mergeStatement = MergeStatement.builder().target(target).source(source).expression(new ExpressionWithParamsSegment(0, 0, expression)).build();
+        SimpleTableSegment left = createScopeTable("foo_left", 40);
+        SimpleTableSegment right = createScopeTable("bar_right", 60);
+        MergeStatement usingAliasMerge = MergeStatement.builder().databaseType(new MockedDatabaseType()).target(target).source(createUsingAliasJoin(left, right))
+                .expression(new ExpressionWithParamsSegment(20, 32, createScopeColumn("foo_outer", 20))).build();
+        DatabaseType databaseType = new MockedDatabaseType();
+        SimpleTableSegment returningTable = createScopeTable("foo_returning", 400);
+        ReturningSegment returning = new ReturningSegment(0, 0, createScopeProjections(new SubqueryProjectionSegment(createSubqueryExpression(returningTable).getSubquery(), "")));
+        MergeStatement allClauses = MergeStatement.builder().databaseType(databaseType).target(target).source(source).expression(new ExpressionWithParamsSegment(0, 0, expression))
+                .whenAndThens(Arrays.asList(update, insert)).returning(returning).with(new WithSegment(0, 0, Collections.singletonList(commonTable))).build();
+        ReturningSegment usingAliasReturning = new ReturningSegment(0, 0, createScopeProjections(
+                new ColumnProjectionSegment(createScopeColumn("foo_outer", 70)), new ColumnProjectionSegment(createScopeColumn("old", 90))));
+        return Stream.of(
+                Arguments.of("ON subquery", mergeStatement, Arrays.asList(target, source, nested)),
+                Arguments.of("Source USING alias", usingAliasMerge, Arrays.asList(target, left, right)),
+                Arguments.of("Without ON expression", MergeStatement.builder().target(target).source(source).build(), Arrays.asList(target, source)),
+                Arguments.of("WHEN actions and traversal order", allClauses,
+                        Arrays.asList(target, source, nested, updateConditionTable, firstUpdateTable, secondUpdateTable, insertConditionTable, firstInsertTable, secondInsertTable,
+                                returningTable, commonTableSource)),
+                Arguments.of("DELETE and DO NOTHING", MergeStatement.builder().target(target).source(source).expression(onExpression).whenAndThens(Arrays.asList(delete, doNothing)).build(),
+                        Arrays.asList(target, source, nested)),
+                Arguments.of("INSERT DEFAULT VALUES", MergeStatement.builder().target(target).source(source).expression(onExpression).whenAndThens(Collections.singletonList(defaultInsert)).build(),
+                        Arrays.asList(target, source)),
+                Arguments.of("MERGE and SELECT CTE bodies", MergeStatement.builder().target(target).source(source).expression(onExpression).whenAndThens(Collections.singletonList(doNothing))
+                        .with(mergingWith).build(), Arrays.asList(target, source, innerTarget, nested, commonTableSource)),
+                Arguments.of("Default RETURNING row aliases", MergeStatement.builder().databaseType(databaseType).target(target).source(source).returning(defaultReturning).build(),
+                        Arrays.asList(target, source)),
+                Arguments.of("Explicit RETURNING row aliases", MergeStatement.builder().databaseType(databaseType).target(target).source(source).returning(aliasedReturning).build(),
+                        Arrays.asList(target, source)),
+                Arguments.of("Local table shadows RETURNING row alias", MergeStatement.builder().databaseType(databaseType).target(target).source(source).returning(shadowingReturning).build(),
+                        Arrays.asList(target, source, shadowingTable, createScopeTable("old_row", 180))),
+                Arguments.of("Physical tables mask default RETURNING aliases",
+                        MergeStatement.builder().databaseType(databaseType).target(oldTable).source(newTable).returning(defaultReturning).build(),
+                        Arrays.asList(oldTable, newTable, createScopeTable("old", 70), createScopeTable("new", 90))),
+                Arguments.of("Derived query inherits RETURNING aliases", MergeStatement.builder().databaseType(databaseType).target(target).source(source).returning(derivedReturning).build(),
+                        Arrays.asList(target, source)),
+                Arguments.of("RETURNING respects source USING alias",
+                        MergeStatement.builder().databaseType(databaseType).target(target).source(createUsingAliasJoin(left, right)).returning(usingAliasReturning).build(),
+                        Arrays.asList(target, left, right)));
+    }
+    
     @Test
     void assertExtractTablesFromSelectProjects() {
         AggregationProjectionSegment aggregationProjection = new AggregationProjectionSegment(10, 20, AggregationType.SUM, "SUM(t_order.id)");
@@ -241,6 +465,248 @@ class TableExtractorTest {
         assertThat(tableExtractor.getJoinTables().iterator().next(), is(joinTableSegment));
     }
     
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getUsingAliasArguments")
+    void assertExtractTablesFromSelectUsingAlias(final String name, final String owner) {
+        SimpleTableSegment left = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_first")));
+        left.setAlias(new AliasSegment(0, 0, new IdentifierValue("f")));
+        SimpleTableSegment right = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_second")));
+        right.setAlias(new AliasSegment(0, 0, new IdentifierValue("b")));
+        JoinTableSegment joinTable = new JoinTableSegment();
+        joinTable.setLeft(left);
+        joinTable.setRight(right);
+        joinTable.setUsing(Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("id"))));
+        joinTable.setUsingAlias(new AliasSegment(0, 0, new IdentifierValue("joined")));
+        ColumnSegment column = new ColumnSegment(0, 0, new IdentifierValue("id"));
+        column.setOwner(new OwnerSegment(0, 0, new IdentifierValue(owner)));
+        ProjectionsSegment projections = new ProjectionsSegment(0, 0);
+        projections.getProjections().add(new ColumnProjectionSegment(column));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(projections).from(joinTable).build());
+        assertThat(tableExtractor.getRewriteTables(), contains(left, right));
+    }
+    
+    private static Stream<Arguments> getUsingAliasArguments() {
+        return Stream.of(Arguments.of("USING alias", "joined"), Arguments.of("Left table alias", "f"), Arguments.of("Right table alias", "b"));
+    }
+    
+    @Test
+    void assertExtractTablesFromSelectWithCorrelatedDerivedUsingAlias() {
+        SimpleTableSegment left = createScopeTable("foo_left", 20);
+        SimpleTableSegment right = createScopeTable("bar_right", 40);
+        SelectStatement correlated = SelectStatement.builder().projections(createScopeProjections(new ColumnProjectionSegment(createScopeColumn("foo_outer", 80)))).build();
+        SubqueryTableSegment derived = new SubqueryTableSegment(70, 110, new SubquerySegment(70, 110, correlated, ""));
+        derived.setAlias(new AliasSegment(115, 115, new IdentifierValue("x")));
+        JoinTableSegment from = new JoinTableSegment();
+        from.setLeft(createUsingAliasJoin(left, right));
+        from.setRight(derived);
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().databaseType(new MockedDatabaseType()).from(from).projections(new ProjectionsSegment(0, 0)).build());
+        assertThat(tableExtractor.getRewriteTables(), contains(left, right));
+    }
+    
+    @Test
+    void assertExtractTablesFromSelectWithNestedUsingAlias() {
+        JoinTableSegment innerJoin = new JoinTableSegment();
+        innerJoin.setLeft(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_inner_left"))));
+        innerJoin.setRight(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_inner_right"))));
+        innerJoin.setUsing(Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("id"))));
+        innerJoin.setUsingAlias(new AliasSegment(0, 0, new IdentifierValue("foo_outer")));
+        SelectStatement innerSelect = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(new ProjectionsSegment(0, 0)).from(innerJoin).build();
+        SubqueryTableSegment subqueryTable = new SubqueryTableSegment(0, 0, new SubquerySegment(0, 0, innerSelect, ""));
+        subqueryTable.setAlias(new AliasSegment(0, 0, new IdentifierValue("foo_nested")));
+        JoinTableSegment outerJoin = new JoinTableSegment();
+        outerJoin.setLeft(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_outer"))));
+        outerJoin.setRight(subqueryTable);
+        ColumnSegment column = new ColumnSegment(0, 0, new IdentifierValue("id"));
+        column.setOwner(new OwnerSegment(0, 0, new IdentifierValue("foo_outer")));
+        ProjectionsSegment projections = new ProjectionsSegment(0, 0);
+        projections.getProjections().add(new ColumnProjectionSegment(column));
+        tableExtractor.extractTablesFromSelect(SelectStatement.builder().projections(projections).from(outerJoin).build());
+        Collection<String> actualTableNames = tableExtractor.getRewriteTables().stream().map(each -> each.getTableName().getIdentifier().getValue()).collect(Collectors.toList());
+        assertThat(actualTableNames, contains("foo_outer", "foo_inner_left", "foo_inner_right", "foo_outer"));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("getTableScopeArguments")
+    void assertExtractTablesFromSelectScope(final String name, final SelectStatement selectStatement, final Collection<TableSegment> inheritedTables, final Collection<String> expectedRewriteTables,
+                                            final Collection<TableSegment> expectedTableContext, final Collection<JoinTableSegment> expectedJoinTables) {
+        tableExtractor.getTableContext().addAll(inheritedTables);
+        tableExtractor.extractTablesFromSelect(selectStatement);
+        Collection<String> actualRewriteTables = tableExtractor.getRewriteTables().stream()
+                .map(each -> each.getTableName().getIdentifier().getValue() + "@" + each.getStartIndex() + ":" + each.getStopIndex()).collect(Collectors.toList());
+        assertThat(actualRewriteTables, is(expectedRewriteTables));
+        assertThat(tableExtractor.getTableContext(), is(expectedTableContext));
+        assertThat(tableExtractor.getJoinTables(), is(expectedJoinTables));
+    }
+    
+    private static Stream<Arguments> getTableScopeArguments() {
+        SimpleTableSegment parentLeft = createScopeTable("foo_parent", 150);
+        SimpleTableSegment parentRight = createScopeTable("bar_parent", 170);
+        JoinTableSegment parentJoin = createUsingAliasJoin(parentLeft, parentRight);
+        ProjectionsSegment childProjections = createScopeProjections(new ColumnProjectionSegment(createScopeColumn("foo_outer", 120)));
+        SimpleTableSegment tailTable = createScopeTable("foo_tail", 200);
+        JoinTableSegment leftUsingJoin = new JoinTableSegment();
+        leftUsingJoin.setLeft(parentJoin);
+        leftUsingJoin.setRight(tailTable);
+        JoinTableSegment rightUsingJoin = new JoinTableSegment();
+        rightUsingJoin.setLeft(tailTable);
+        rightUsingJoin.setRight(parentJoin);
+        SelectStatement leftUsingSelect = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(childProjections).from(leftUsingJoin).build();
+        SelectStatement rightUsingSelect = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(childProjections).from(rightUsingJoin).build();
+        SelectStatement correlated = SelectStatement.builder().projections(childProjections).build();
+        SimpleTableSegment localPhysical = createScopeTable("foo_outer", 100);
+        SelectStatement physicalShadow = SelectStatement.builder().projections(childProjections).from(localPhysical).build();
+        SimpleTableSegment localAlias = createScopeTable("foo_local", 80);
+        localAlias.setAlias(new AliasSegment(90, 98, new IdentifierValue("foo_outer")));
+        SelectStatement aliasShadow = SelectStatement.builder().projections(childProjections).from(localAlias).build();
+        FunctionTableSegment localFunction = new FunctionTableSegment(80, 95, new FunctionSegment(80, 95, "foo_function", "foo_function()"));
+        localFunction.setAlias(new AliasSegment(100, 108, new IdentifierValue("foo_outer")));
+        SelectStatement functionShadow = SelectStatement.builder().projections(childProjections).from(localFunction).build();
+        SelectStatement derivedSelect = SelectStatement.builder().projections(createScopeProjections(new ShorthandProjectionSegment(0, 0))).from(localPhysical).build();
+        SubqueryTableSegment localSubquery = new SubqueryTableSegment(80, 115, new SubquerySegment(80, 115, derivedSelect, ""));
+        localSubquery.setAlias(new AliasSegment(116, 124, new IdentifierValue("foo_outer")));
+        SelectStatement subqueryShadow = SelectStatement.builder().projections(childProjections).from(localSubquery).build();
+        SubquerySegment grandchild = new SubquerySegment(100, 115, derivedSelect, "");
+        WhereSegment grandchildExists = new WhereSegment(95, 115, new ExistsSubqueryExpression(95, 115, grandchild));
+        SelectStatement grandchildMetadata = SelectStatement.builder().projections(childProjections).where(grandchildExists).build();
+        SimpleTableSegment middlePhysical = createScopeTable("foo_outer", 80);
+        SelectStatement grandchildWithLocal = SelectStatement.builder().projections(childProjections).from(middlePhysical).where(grandchildExists).build();
+        SimpleTableSegment innerLeft = createScopeTable("foo_left", 40);
+        SimpleTableSegment innerRight = createScopeTable("bar_right", 60);
+        JoinTableSegment innerJoin = createUsingAliasJoin(innerLeft, innerRight);
+        SelectStatement innerSelect = SelectStatement.builder().databaseType(new MockedDatabaseType())
+                .projections(createScopeProjections(new ExpressionProjectionSegment(0, 0, "true", new LiteralExpressionSegment(0, 0, true))))
+                .from(innerJoin).build();
+        SubquerySegment innerSubquery = new SubquerySegment(30, 90, innerSelect, "");
+        SelectStatement combine = SelectStatement.builder().combine(new CombineSegment(0, 130, innerSubquery, CombineType.UNION, new SubquerySegment(95, 130, physicalShadow, ""))).build();
+        CommonTableExpressionSegment firstCTE = new CommonTableExpressionSegment(0, 90, new AliasSegment(0, 0, new IdentifierValue("foo_first")), innerSubquery, null);
+        CommonTableExpressionSegment secondCTE = new CommonTableExpressionSegment(95, 130, new AliasSegment(95, 95, new IdentifierValue("bar_second")),
+                new SubquerySegment(95, 130, physicalShadow, ""), null);
+        SelectStatement commonTables = SelectStatement.builder().projections(new ProjectionsSegment(0, 0)).with(new WithSegment(0, 130, Arrays.asList(firstCTE, secondCTE), false)).build();
+        SimpleTableSegment updateTarget = createScopeTable("foo_target", 5);
+        SetAssignmentSegment assignments = new SetAssignmentSegment(0, 0, Collections.singletonList(new ColumnAssignmentSegment(0, 0,
+                Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("id"))), new LiteralExpressionSegment(0, 0, 1))));
+        UpdateStatement firstUpdate = UpdateStatement.builder().databaseType(new MockedDatabaseType()).table(updateTarget).from(innerJoin).setAssignment(assignments).build();
+        UpdateStatement secondUpdate = UpdateStatement.builder().table(localPhysical).setAssignment(assignments)
+                .where(new WhereSegment(120, 134, new BinaryOperationExpression(120, 134, createScopeColumn("foo_outer", 120), new LiteralExpressionSegment(134, 134, 1), "=", ""))).build();
+        CommonTableExpressionSegment firstUpdateCTE = new CommonTableExpressionSegment(0, 90, new AliasSegment(0, 0, new IdentifierValue("foo_updated")), null, firstUpdate);
+        CommonTableExpressionSegment secondUpdateCTE = new CommonTableExpressionSegment(95, 134, new AliasSegment(95, 95, new IdentifierValue("bar_updated")), null, secondUpdate);
+        SelectStatement modifyingCommonTables = SelectStatement.builder().projections(new ProjectionsSegment(0, 0))
+                .with(new WithSegment(0, 134, Arrays.asList(firstUpdateCTE, secondUpdateCTE), false)).build();
+        SelectStatement scopedModifyingCommonTable = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(new ProjectionsSegment(0, 0)).from(parentJoin)
+                .with(new WithSegment(95, 134, Collections.singletonList(secondUpdateCTE), false)).build();
+        InsertStatement firstInsert = InsertStatement.builder().databaseType(new MockedDatabaseType()).table(updateTarget).insertSelect(innerSubquery).build();
+        CommonTableExpressionSegment firstInsertCTE = new CommonTableExpressionSegment(0, 90, new AliasSegment(0, 0, new IdentifierValue("foo_inserted")), null, firstInsert);
+        SelectStatement insertingCommonTables = SelectStatement.builder().projections(new ProjectionsSegment(0, 0))
+                .with(new WithSegment(0, 134, Arrays.asList(firstInsertCTE, secondUpdateCTE), false)).build();
+        SimpleTableSegment inheritedAlias = createScopeTable("foo_inherited", 200);
+        inheritedAlias.setAlias(new AliasSegment(214, 214, new IdentifierValue("f")));
+        ProjectionsSegment inheritedProjections = createScopeProjections(new ColumnProjectionSegment(createScopeColumn("f", 20)));
+        SelectStatement inheritedUsingSelect = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(inheritedProjections).from(innerJoin).build();
+        SimpleTableSegment inheritedPhysical = createScopeTable("f", 150);
+        SimpleTableSegment descendantAlias = createScopeTable("foo_shadow", 100);
+        descendantAlias.setAlias(new AliasSegment(114, 114, new IdentifierValue("f")));
+        SelectStatement descendantSelect = SelectStatement.builder().projections(createScopeProjections(new ShorthandProjectionSegment(0, 0))).from(descendantAlias).build();
+        SelectStatement inheritedPhysicalSelect = SelectStatement.builder().databaseType(new MockedDatabaseType()).projections(inheritedProjections).from(innerJoin)
+                .where(new WhereSegment(95, 115, new ExistsSubqueryExpression(95, 115, new SubquerySegment(100, 115, descendantSelect, "")))).build();
+        SimpleTableSegment differentlyAliased = createScopeTable("foo_outer", 100);
+        differentlyAliased.setAlias(new AliasSegment(112, 122, new IdentifierValue("local_alias")));
+        SelectStatement hiddenPhysical = SelectStatement.builder().projections(childProjections).from(differentlyAliased).build();
+        SelectStatement unresolved = SelectStatement.builder().projections(createScopeProjections(new SubqueryProjectionSegment(new SubquerySegment(0, 130, correlated, ""), ""))).build();
+        Collection<TableSegment> parentContext = Arrays.asList(parentJoin, parentLeft, parentRight);
+        Collection<String> parentRewrites = Arrays.asList("foo_parent@150:159", "bar_parent@170:179");
+        Collection<JoinTableSegment> parentJoins = Collections.singletonList(parentJoin);
+        Collection<String> outwardRewrites = Arrays.asList("foo_outer@10:18", "foo_left@40:47", "bar_right@60:68", "foo_outer@20:28");
+        SimpleTableSegment outerTable = createScopeTable("foo_outer", 10);
+        Collection<TableSegment> outwardContext = Arrays.asList(outerTable, innerLeft, innerRight);
+        Collection<JoinTableSegment> innerJoins = Collections.singletonList(innerJoin);
+        ColumnSegment outerColumn = createScopeColumn("foo_outer", 20);
+        ProjectionsSegment outerProjections = createScopeProjections(new ColumnProjectionSegment(outerColumn));
+        SelectStatement exists = SelectStatement.builder().projections(outerProjections).from(outerTable).where(new WhereSegment(30, 90, new ExistsSubqueryExpression(30, 90, innerSubquery))).build();
+        SelectStatement scalar = SelectStatement.builder().projections(outerProjections).from(outerTable).where(new WhereSegment(30, 90, new SubqueryExpressionSegment(innerSubquery))).build();
+        SelectStatement rawSubquery = SelectStatement.builder().projections(outerProjections).from(outerTable).where(new WhereSegment(30, 90, innerSubquery)).build();
+        SelectStatement projection = SelectStatement.builder().projections(createScopeProjections(new SubqueryProjectionSegment(innerSubquery, ""), new ColumnProjectionSegment(outerColumn)))
+                .from(outerTable).build();
+        return Stream.of(
+                Arguments.of("EXISTS alias isolation", exists, Collections.emptyList(), outwardRewrites, outwardContext, innerJoins),
+                Arguments.of("Scalar alias isolation", scalar, Collections.emptyList(), outwardRewrites, outwardContext, innerJoins),
+                Arguments.of("Subquery node alias isolation", rawSubquery, Collections.emptyList(), outwardRewrites, outwardContext, innerJoins),
+                Arguments.of("Projection alias isolation", projection, Collections.emptyList(), outwardRewrites, outwardContext, innerJoins),
+                Arguments.of("Left join subtree USING alias", leftUsingSelect, Collections.emptyList(), Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_tail@200:207"),
+                        Arrays.asList(parentJoin, parentLeft, parentRight, tailTable), Arrays.asList(leftUsingJoin, parentJoin)),
+                Arguments.of("Right join subtree USING alias", rightUsingSelect, Collections.emptyList(), Arrays.asList("foo_tail@200:207", "foo_parent@150:159", "bar_parent@170:179"),
+                        Arrays.asList(tailTable, parentJoin, parentLeft, parentRight), Arrays.asList(rightUsingJoin, parentJoin)),
+                Arguments.of("Correlated USING alias", createScopeOuterSelect(parentJoin, correlated), Collections.emptyList(), parentRewrites, parentContext, parentJoins),
+                Arguments.of("Correlated table alias", createScopeOuterSelect(localAlias, correlated), Collections.emptyList(), Collections.singletonList("foo_local@80:98"),
+                        Collections.singletonList(localAlias), Collections.emptyList()),
+                Arguments.of("Local physical shadow", createScopeOuterSelect(parentJoin, physicalShadow), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(parentJoin, parentLeft, parentRight, localPhysical), parentJoins),
+                Arguments.of("Local table alias", createScopeOuterSelect(parentJoin, aliasShadow), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_local@80:98"), Arrays.asList(parentJoin, parentLeft, parentRight, localAlias), parentJoins),
+                Arguments.of("Local function alias", createScopeOuterSelect(parentJoin, functionShadow), Collections.emptyList(), parentRewrites,
+                        Arrays.asList(parentJoin, parentLeft, parentRight, localFunction), parentJoins),
+                Arguments.of("Local derived alias", createScopeOuterSelect(parentJoin, subqueryShadow), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@100:108"), Arrays.asList(parentJoin, parentLeft, parentRight, localSubquery), parentJoins),
+                Arguments.of("Grandchild metadata is not local", createScopeOuterSelect(parentJoin, grandchildMetadata), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@100:108"), Arrays.asList(parentJoin, parentLeft, parentRight, localPhysical), parentJoins),
+                Arguments.of("Local physical shadows with grandchild", createScopeOuterSelect(parentJoin, grandchildWithLocal), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@80:88", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(parentJoin, parentLeft, parentRight, middlePhysical, localPhysical), parentJoins),
+                Arguments.of("Combine sibling isolation", combine, Collections.emptyList(), Arrays.asList("foo_left@40:47", "bar_right@60:68", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(innerLeft, innerRight, localPhysical), innerJoins),
+                Arguments.of("CTE sibling isolation", commonTables, Collections.emptyList(), Arrays.asList("foo_left@40:47", "bar_right@60:68", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(innerLeft, innerRight, localPhysical), innerJoins),
+                Arguments.of("DML CTE sibling isolation", modifyingCommonTables, Collections.emptyList(),
+                        Arrays.asList("foo_target@5:14", "foo_left@40:47", "bar_right@60:68", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(updateTarget, innerLeft, innerRight, localPhysical), innerJoins),
+                Arguments.of("DML CTE below USING source", scopedModifyingCommonTable, Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(parentJoin, parentLeft, parentRight, localPhysical), parentJoins),
+                Arguments.of("INSERT SELECT CTE sibling isolation", insertingCommonTables, Collections.emptyList(),
+                        Arrays.asList("foo_target@5:14", "foo_left@40:47", "bar_right@60:68", "foo_outer@100:108", "foo_outer@120:128"),
+                        Arrays.asList(updateTarget, innerLeft, innerRight, localPhysical), innerJoins),
+                Arguments.of("Inherited alias prefix", createScopeOuterSelect(inheritedAlias, inheritedUsingSelect), Collections.emptyList(),
+                        Arrays.asList("foo_inherited@200:214", "foo_left@40:47", "bar_right@60:68"), Arrays.asList(inheritedAlias, innerLeft, innerRight), innerJoins),
+                Arguments.of("Inherited prefix excludes descendants", createScopeOuterSelect(inheritedPhysical, inheritedPhysicalSelect), Collections.emptyList(),
+                        Arrays.asList("f@150:150", "foo_left@40:47", "bar_right@60:68", "foo_shadow@100:114", "f@20:20"),
+                        Arrays.asList(inheritedPhysical, innerLeft, innerRight, descendantAlias), innerJoins),
+                Arguments.of("Different alias hides local physical name", createScopeOuterSelect(parentJoin, hiddenPhysical), Collections.emptyList(),
+                        Arrays.asList("foo_parent@150:159", "bar_parent@170:179", "foo_outer@100:122"),
+                        Arrays.asList(parentJoin, parentLeft, parentRight, differentlyAliased), parentJoins),
+                Arguments.of("Unresolved parent lookup", unresolved, Collections.emptyList(), Collections.singletonList("foo_outer@120:128"), Collections.emptyList(), Collections.emptyList()),
+                Arguments.of("Inherited correlated alias", unresolved, Collections.singletonList(localAlias), Collections.emptyList(), Collections.singletonList(localAlias), Collections.emptyList()));
+    }
+    
+    private static SimpleTableSegment createScopeTable(final String tableName, final int startIndex) {
+        return new SimpleTableSegment(new TableNameSegment(startIndex, startIndex + tableName.length() - 1, new IdentifierValue(tableName)));
+    }
+    
+    private static JoinTableSegment createUsingAliasJoin(final SimpleTableSegment left, final SimpleTableSegment right) {
+        JoinTableSegment result = new JoinTableSegment();
+        result.setLeft(left);
+        result.setRight(right);
+        result.setUsing(Collections.singletonList(new ColumnSegment(0, 0, new IdentifierValue("id"))));
+        result.setUsingAlias(new AliasSegment(0, 0, new IdentifierValue("foo_outer")));
+        return result;
+    }
+    
+    private static ColumnSegment createScopeColumn(final String owner, final int startIndex) {
+        ColumnSegment result = new ColumnSegment(startIndex + owner.length() + 1, startIndex + owner.length() + 2, new IdentifierValue("id"));
+        result.setOwner(new OwnerSegment(startIndex, startIndex + owner.length() - 1, new IdentifierValue(owner)));
+        return result;
+    }
+    
+    private static ProjectionsSegment createScopeProjections(final ProjectionSegment... projections) {
+        ProjectionsSegment result = new ProjectionsSegment(0, 0);
+        result.getProjections().addAll(Arrays.asList(projections));
+        return result;
+    }
+    
+    private static SelectStatement createScopeOuterSelect(final TableSegment from, final SelectStatement child) {
+        return SelectStatement.builder().databaseType(new MockedDatabaseType())
+                .projections(createScopeProjections(new SubqueryProjectionSegment(new SubquerySegment(0, 130, child, ""), ""))).from(from).build();
+    }
+    
     @Test
     void assertExtractTablesFromCreateTableStatement() {
         CreateTableStatement createTableStatement = mock(CreateTableStatement.class);
diff --git a/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatementTest.java b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatementTest.java
new file mode 100644
index 00000000000..9910a96c5a4
--- /dev/null
+++ b/parser/sql/statement/core/src/test/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/PrepareStatementTest.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl;
+
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+class PrepareStatementTest {
+    
+    @Test
+    void assertMergeBodyAndTableAttribute() {
+        SimpleTableSegment target = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_target")));
+        SimpleTableSegment source = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("foo_source")));
+        MergeStatement merge = MergeStatement.builder().target(target).source(source).build();
+        PrepareStatement actual = PrepareStatement.builder().merge(merge).build();
+        assertThat(actual.getMerge().orElse(null), is(merge));
+        assertThat(actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables(), is(Arrays.asList(target, source)));
+    }
+}
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterLargeObjectStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterLargeObjectStatement.java
index 8e58156ac44..62299dbbf33 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterLargeObjectStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Alter large object statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLAlterLargeObjectStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLAlterLargeObjectStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorClassStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorClassStatement.java
index 8e58156ac44..3dd592270ef 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorClassStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Alter operator class statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLAlterOperatorClassStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLAlterOperatorClassStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorFamilyStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorFamilyStatement.java
index 8e58156ac44..0189b4d219f 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterOperatorFamilyStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Alter operator family statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLAlterOperatorFamilyStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLAlterOperatorFamilyStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterUserMappingStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterUserMappingStatement.java
index 8e58156ac44..d925cda225c 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLAlterUserMappingStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Alter user mapping statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLAlterUserMappingStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLAlterUserMappingStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorClassStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorClassStatement.java
index 8e58156ac44..22d552e2bb4 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorClassStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create operator class statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateOperatorClassStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateOperatorClassStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorFamilyStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorFamilyStatement.java
index 8e58156ac44..fa26db8acf5 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateOperatorFamilyStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create operator family statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateOperatorFamilyStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateOperatorFamilyStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateTransformStatement.java
similarity index 63%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateTransformStatement.java
index 8e58156ac44..898bd79f6eb 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateTransformStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create transform statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateTransformStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateTransformStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateUserMappingStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateUserMappingStatement.java
index 8e58156ac44..75ed695439a 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLCreateUserMappingStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create user mapping statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateUserMappingStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateUserMappingStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLDropUserMappingStatement.java
similarity index 63%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLDropUserMappingStatement.java
index 8e58156ac44..b6f78cf3b4a 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLDropUserMappingStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Drop user mapping statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLDropUserMappingStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLDropUserMappingStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLImportForeignSchemaStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLImportForeignSchemaStatement.java
index 8e58156ac44..bc8281a54cf 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/PostgreSQLImportForeignSchemaStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Import foreign schema statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLImportForeignSchemaStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLImportForeignSchemaStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/event/PostgreSQLAlterEventTriggerStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/event/PostgreSQLAlterEventTriggerStatement.java
index 8e58156ac44..eed9006e634 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/event/PostgreSQLAlterEventTriggerStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Alter event trigger statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLAlterEventTriggerStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLAlterEventTriggerStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/statistics/PostgreSQLCreateStatisticsStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/statistics/PostgreSQLCreateStatisticsStatement.java
index 8e58156ac44..0c5abccd957 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/statistics/PostgreSQLCreateStatisticsStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.statistics;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create statistics statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateStatisticsStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateStatisticsStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/subscription/PostgreSQLCreateSubscriptionStatement.java
similarity index 62%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
copy to parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/subscription/PostgreSQLCreateSubscriptionStatement.java
index 8e58156ac44..8be4816a1c8 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/segment/dml/expr/complex/CommonExpressionSegment.java
+++ b/parser/sql/statement/dialect/postgresql/src/main/java/org/apache/shardingsphere/sql/parser/statement/postgresql/ddl/subscription/PostgreSQLCreateSubscriptionStatement.java
@@ -15,21 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex;
+package org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription;
 
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 /**
- * Common expression segment.
+ * Create subscription statement for PostgreSQL.
  */
-@RequiredArgsConstructor
-@Getter
-public final class CommonExpressionSegment implements ComplexExpressionSegment {
+public final class PostgreSQLCreateSubscriptionStatement extends DDLStatement {
     
-    private final int startIndex;
-    
-    private final int stopIndex;
-    
-    private final String text;
+    public PostgreSQLCreateSubscriptionStatement(final DatabaseType databaseType) {
+        super(databaseType);
+    }
 }
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
index f4c42090cf8..e5b901b6f35 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
@@ -499,7 +499,7 @@ class ProxySQLExecutorTest {
                 when(insertStatementContext.getGeneratedKeyContext()).thenReturn(Optional.of(generatedKeyContext));
                 when(insertStatementContext.getColumnNames()).thenReturn(Collections.singletonList("foo_id"));
                 InsertValueContext insertValueContext = mock(InsertValueContext.class);
-                when(insertValueContext.getValueExpressions()).thenReturn(Collections.singletonList(new CommonExpressionSegment(0, 0, "DEFAULT")));
+                when(insertValueContext.getValueExpressions()).thenReturn(Collections.singletonList(new CommonExpressionSegment(0, 0, "DEFAULT", Collections.emptyList())));
                 when(insertStatementContext.getInsertValueContexts()).thenReturn(Collections.singletonList(insertValueContext));
             } else if ("execute-with-driver-and-no-column-list-special-default".equals(name)) {
                 GeneratedKeyContext generatedKeyContext = new GeneratedKeyContext("foo_id", false);
@@ -507,7 +507,7 @@ class ProxySQLExecutorTest {
                 when(insertStatementContext.getInsertColumnNames()).thenReturn(Collections.emptyList());
                 when(insertStatementContext.getColumnNames()).thenReturn(Arrays.asList("foo_id", "name"));
                 InsertValueContext insertValueContext = mock(InsertValueContext.class);
-                when(insertValueContext.getValueExpressions()).thenReturn(Arrays.asList(new CommonExpressionSegment(0, 0, "DEFAULT"), mock(LiteralExpressionSegment.class)));
+                when(insertValueContext.getValueExpressions()).thenReturn(Arrays.asList(new CommonExpressionSegment(0, 0, "DEFAULT", Collections.emptyList()), mock(LiteralExpressionSegment.class)));
                 when(insertStatementContext.getInsertValueContexts()).thenReturn(Collections.singletonList(insertValueContext));
             } else if ("execute-with-driver-and-no-column-list-special-null".equals(name)) {
                 GeneratedKeyContext generatedKeyContext = new GeneratedKeyContext("foo_id", false);
@@ -530,7 +530,7 @@ class ProxySQLExecutorTest {
                 when(insertStatementContext.getGeneratedKeyContext()).thenReturn(Optional.of(generatedKeyContext));
                 when(insertStatementContext.getColumnNames()).thenReturn(Collections.singletonList("foo_id"));
                 InsertValueContext insertValueContext = mock(InsertValueContext.class);
-                when(insertValueContext.getValueExpressions()).thenReturn(Collections.singletonList(new CommonExpressionSegment(0, 0, "DEFAULT")));
+                when(insertValueContext.getValueExpressions()).thenReturn(Collections.singletonList(new CommonExpressionSegment(0, 0, "DEFAULT", Collections.emptyList())));
                 when(insertStatementContext.getInsertValueContexts()).thenReturn(Collections.singletonList(insertValueContext));
             } else {
                 GeneratedKeyContext generatedKeyContext = new GeneratedKeyContext("foo_id", isReturnGeneratedKeys);
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/assignment/AssignmentValueAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/assignment/AssignmentValueAssert.java
index f8d5026258d..9b6934a0dd0 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/assignment/AssignmentValueAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/assignment/AssignmentValueAssert.java
@@ -24,6 +24,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.Bina
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CaseWhenExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
@@ -33,6 +34,7 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAsse
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.column.ColumnAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.expression.ExpressionAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.assignment.ExpectedAssignmentValue;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExpression;
 
 /**
  * Assignment value assert.
@@ -82,6 +84,12 @@ public final class AssignmentValueAssert {
             ExpressionAssert.assertCaseWhenExpression(assertContext, (CaseWhenExpression) actual, expected.getCaseWhenExpression());
             return;
         }
+        if (actual instanceof RowExpression) {
+            ExpectedExpression expectedExpression = new ExpectedExpression();
+            expectedExpression.setRowExpression(expected.getRowExpression());
+            ExpressionAssert.assertExpression(assertContext, actual, expectedExpression);
+            return;
+        }
         if (actual instanceof BinaryOperationExpression) {
             ExpressionAssert.assertBinaryOperationExpression(assertContext, (BinaryOperationExpression) actual, expected.getBinaryOperationExpression());
         }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/expression/ExpressionAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/expression/ExpressionAssert.java
index 3c8e47c8d7b..987bc7a54df 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/expression/ExpressionAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/expression/ExpressionAssert.java
@@ -174,6 +174,18 @@ public final class ExpressionAssert {
             String expectedText = SQLCaseType.LITERAL == assertContext.getCaseType() && null != expected.getLiteralText() ? expected.getLiteralText() : expected.getText();
             assertThat(assertContext.getText("Common expression text assertion error: "), actual.getText(), is(expectedText));
             SQLSegmentAssert.assertIs(assertContext, actual, expected);
+            if (null != expected.getChildren()) {
+                assertCommonExpressionChildren(assertContext, actual, expected);
+            }
+        }
+    }
+    
+    private static void assertCommonExpressionChildren(final SQLCaseAssertContext assertContext, final ComplexExpressionSegment actual, final ExpectedCommonExpression expected) {
+        CommonExpressionSegment expression = (CommonExpressionSegment) (actual instanceof ExpressionProjectionSegment ? ((ExpressionProjectionSegment) actual).getExpr() : actual);
+        assertThat(assertContext.getText("Common expression children size assertion error: "), expression.getChildren().size(), is(expected.getChildren().size()));
+        Iterator<ExpressionSegment> actualChildren = expression.getChildren().iterator();
+        for (ExpectedExpression each : expected.getChildren()) {
+            assertExpression(assertContext, actualChildren.next(), each);
         }
     }
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/limit/LimitClauseAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/limit/LimitClauseAssert.java
index 436ed5d577b..41b7603b0d5 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/limit/LimitClauseAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/limit/LimitClauseAssert.java
@@ -23,10 +23,11 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.paginatio
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.NumberLiteralPaginationValueSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.PaginationValueSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.ParameterMarkerPaginationValueSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.LimitSegment;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.SQLSegmentAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.limit.ExpectedLimitClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.limit.ExpectedPaginationValue;
-import org.apache.shardingsphere.test.it.sql.parser.internal.cases.sql.type.SQLCaseType;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
@@ -38,6 +39,18 @@ import static org.junit.jupiter.api.Assertions.assertNull;
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class LimitClauseAssert {
     
+    /**
+     * Assert FETCH mode and implicit row count.
+     *
+     * @param assertContext assert context
+     * @param actual actual limit
+     * @param expected expected limit
+     */
+    public static void assertFetch(final SQLCaseAssertContext assertContext, final LimitSegment actual, final ExpectedLimitClause expected) {
+        assertThat(assertContext.getText("FETCH WITH TIES assertion error: "), actual.isWithTies(), is(expected.isWithTies()));
+        assertThat(assertContext.getText("FETCH implicit row count assertion error: "), actual.isImplicitRowCount(), is(expected.isImplicitRowCount()));
+    }
+    
     /**
      * Assert actual offset segment is correct with expected offset.
      *
@@ -73,7 +86,7 @@ public final class LimitClauseAssert {
             assertNull(expected, assertContext.getText("Row count should not exist."));
             return;
         }
-        if (SQLCaseType.PLACEHOLDER == assertContext.getCaseType()) {
+        if (actual instanceof ParameterMarkerPaginationValueSegment) {
             assertThat(assertContext.getText("Row count index assertion error: "),
                     ((ParameterMarkerPaginationValueSegment) actual).getParameterIndex(), is(expected.getParameterIndex()));
         } else if (actual instanceof ExpressionPaginationValueSegment) {
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/prepare/PrepareStatementQueryAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/prepare/PrepareStatementQueryAssert.java
index bf91d639b41..8bf8c8ca396 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/prepare/PrepareStatementQueryAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/prepare/PrepareStatementQueryAssert.java
@@ -24,6 +24,7 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAsse
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.SQLSegmentAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.DeleteStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.InsertStatementAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.MergeStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.SelectStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.UpdateStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.query.ExpectedPrepareStatementQuery;
@@ -49,6 +50,7 @@ public final class PrepareStatementQueryAssert {
         assertInsert(assertContext, actual, expected);
         assertUpdate(assertContext, actual, expected);
         assertDelete(assertContext, actual, expected);
+        assertMerge(assertContext, actual, expected);
         SQLSegmentAssert.assertIs(assertContext, actual, expected);
     }
     
@@ -87,4 +89,13 @@ public final class PrepareStatementQueryAssert {
             DeleteStatementAssert.assertIs(assertContext, actual.getDelete().get(), expected.getDeleteClause());
         }
     }
+    
+    private static void assertMerge(final SQLCaseAssertContext assertContext, final PrepareStatementQuerySegment actual, final ExpectedPrepareStatementQuery expected) {
+        if (null == expected.getMergeClause()) {
+            assertFalse(actual.getMerge().isPresent(), assertContext.getText("Actual merge statement should not exist."));
+        } else {
+            assertTrue(actual.getMerge().isPresent(), assertContext.getText("Actual merge statement should exist."));
+            MergeStatementAssert.assertIs(assertContext, actual.getMerge().get(), expected.getMergeClause());
+        }
+    }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/returning/ReturningClauseAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/returning/ReturningClauseAssert.java
index 1c4c447b006..cdfa48d97c4 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/returning/ReturningClauseAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/returning/ReturningClauseAssert.java
@@ -21,10 +21,16 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.ReturningSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.AliasSegment;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.projection.ProjectionAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.insert.ExpectedReturningClause;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 /**
  * Returning clause assert.
  */
@@ -39,9 +45,22 @@ public final class ReturningClauseAssert {
      * @param expected expected returning clause
      */
     public static void assertIs(final SQLCaseAssertContext assertContext, final ReturningSegment actual, final ExpectedReturningClause expected) {
+        assertAlias(actual.getOldAlias(), expected.getOldAlias(), expected.getOldAliasStartIndex(), expected.getOldAliasStopIndex());
+        assertAlias(actual.getNewAlias(), expected.getNewAlias(), expected.getNewAliasStartIndex(), expected.getNewAliasStopIndex());
         ProjectionsSegment actualProjections = actual.getProjections();
         if (null != actualProjections.getProjections() || expected.getProjections().getSize() > 0) {
             ProjectionAssert.assertIs(assertContext, actualProjections, expected.getProjections());
         }
     }
+    
+    private static void assertAlias(final AliasSegment actual, final String expectedName, final Integer expectedStartIndex, final Integer expectedStopIndex) {
+        if (null == expectedName) {
+            assertNull(actual);
+            return;
+        }
+        assertNotNull(actual);
+        assertThat(actual.getIdentifier().getValue(), is(expectedName));
+        assertThat(actual.getStartIndex(), is(expectedStartIndex));
+        assertThat(actual.getStopIndex(), is(expectedStopIndex));
+    }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/table/TableAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/table/TableAssert.java
index 8be818cddea..4dbf87672d4 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/table/TableAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/table/TableAssert.java
@@ -23,6 +23,7 @@ import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlTableColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlTableFunctionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.PivotSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.CollectionTableSegment;
@@ -42,7 +43,9 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.own
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.MergeStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.SelectStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.column.ExpectedColumn;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExpression;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedTableFunction;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedXmlTableColumn;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.table.ExpectedCollectionTable;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.table.ExpectedFunctionTable;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.table.ExpectedHintIndexName;
@@ -59,6 +62,7 @@ import java.util.List;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -225,29 +229,6 @@ public final class TableAssert {
         assertPivot(assertContext, actual.getPivot().orElse(null), expected.getPivot());
     }
     
-    /**
-     * Assert join table.
-     *
-     * @param assertContext assert context
-     * @param actual actual JoinTableSegment
-     * @param expected expected ExpectedJoinTable
-     */
-    public static void assertIs(final SQLCaseAssertContext assertContext, final JoinTableSegment actual, final ExpectedJoinTable expected) {
-        assertIs(assertContext, actual.getLeft(), expected.getLeft());
-        assertIs(assertContext, actual.getRight(), expected.getRight());
-        ExpressionAssert.assertExpression(assertContext, actual.getCondition(), expected.getOnCondition());
-        assertJoinType(assertContext, actual.getJoinType(), expected.getJoinType());
-        assertThat(assertContext.getText("Natural should be the same."), actual.isNatural(), is(expected.isNatural()));
-        assertThat(assertContext.getText("Column size assertion error: "), actual.getUsing().size(), is(expected.getUsingColumns().size()));
-        int count = 0;
-        for (ExpectedColumn each : expected.getUsingColumns()) {
-            ColumnAssert.assertIs(assertContext, actual.getUsing().get(count), each);
-            count++;
-        }
-        assertColumns(assertContext, actual.getLeftQueryPartitionListSegments(), expected.getLeftQueryPartitionColumns(), "Left query partition");
-        assertColumns(assertContext, actual.getRightQueryPartitionListSegments(), expected.getRightQueryPartitionColumns(), "Right query partition");
-    }
-    
     /**
      * Assert actual table segments is correct with expected tables.
      *
@@ -279,6 +260,41 @@ public final class TableAssert {
         }
     }
     
+    /**
+     * Assert join table.
+     *
+     * @param assertContext assert context
+     * @param actual actual JoinTableSegment
+     * @param expected expected ExpectedJoinTable
+     */
+    public static void assertIs(final SQLCaseAssertContext assertContext, final JoinTableSegment actual, final ExpectedJoinTable expected) {
+        assertIs(assertContext, actual.getLeft(), expected.getLeft());
+        assertIs(assertContext, actual.getRight(), expected.getRight());
+        ExpressionAssert.assertExpression(assertContext, actual.getCondition(), expected.getOnCondition());
+        assertJoinType(assertContext, actual.getJoinType(), expected.getJoinType());
+        assertThat(assertContext.getText("Natural should be the same."), actual.isNatural(), is(expected.isNatural()));
+        assertThat(assertContext.getText("Column size assertion error: "), actual.getUsing().size(), is(expected.getUsingColumns().size()));
+        int count = 0;
+        for (ExpectedColumn each : expected.getUsingColumns()) {
+            ColumnAssert.assertIs(assertContext, actual.getUsing().get(count), each);
+            count++;
+        }
+        assertUsingAlias(assertContext, actual, expected);
+        assertColumns(assertContext, actual.getLeftQueryPartitionListSegments(), expected.getLeftQueryPartitionColumns(), "Left query partition");
+        assertColumns(assertContext, actual.getRightQueryPartitionListSegments(), expected.getRightQueryPartitionColumns(), "Right query partition");
+    }
+    
+    private static void assertUsingAlias(final SQLCaseAssertContext assertContext, final JoinTableSegment actual, final ExpectedJoinTable expected) {
+        if (null == expected.getUsingAlias()) {
+            assertFalse(actual.getUsingAliasSegment().isPresent(), assertContext.getText("USING alias should not exist."));
+            return;
+        }
+        assertTrue(actual.getUsingAliasSegment().isPresent(), assertContext.getText("USING alias should exist."));
+        assertThat(actual.getUsingAliasSegment().get().getIdentifier().getValue(), is(expected.getUsingAlias()));
+        assertThat(actual.getUsingAliasSegment().get().getStartIndex(), is(expected.getUsingAliasStartIndex()));
+        assertThat(actual.getUsingAliasSegment().get().getStopIndex(), is(expected.getUsingAliasStopIndex()));
+    }
+    
     private static void assertPivot(final SQLCaseAssertContext assertContext, final PivotSegment actual, final ExpectedPivot expected) {
         if (null == expected) {
             return;
@@ -304,7 +320,7 @@ public final class TableAssert {
         Iterator<? extends ExpressionSegment> actualIterator = actual.iterator();
         for (ExpectedColumn each : expected) {
             ExpressionSegment actualExpression = actualIterator.next();
-            assertTrue(actualExpression instanceof ColumnSegment, assertContext.getText(segmentName + " column expression assertion error: "));
+            assertThat(assertContext.getText(segmentName + " column expression assertion error: "), actualExpression, isA(ColumnSegment.class));
             ColumnAssert.assertIs(assertContext, (ColumnSegment) actualExpression, each);
         }
     }
@@ -322,10 +338,40 @@ public final class TableAssert {
             XmlTableFunctionSegment actualXmlTableFunction = (XmlTableFunctionSegment) actual;
             assertThat(assertContext.getText("Function name assertion error"), actualXmlTableFunction.getFunctionName(), is(expected.getFunctionName()));
             assertThat(assertContext.getText("Function text assert error"), actual.getText(), is(expected.getText()));
+            assertFunctionParameters(assertContext, actualXmlTableFunction.getXmlTableOption().getParameters(), expected.getParameters());
+            assertXmlTableColumns(assertContext, actualXmlTableFunction.getXmlTableOption().getXmlTableColumnSegments(), expected.getXmlColumns());
         } else if (actual instanceof FunctionSegment) {
             FunctionSegment actualTableFunction = (FunctionSegment) actual;
             assertThat(assertContext.getText("Function name assertion error"), actualTableFunction.getFunctionName(), is(expected.getFunctionName()));
             assertThat(assertContext.getText("Function text assert error"), actual.getText(), is(expected.getText()));
+            assertFunctionParameters(assertContext, actualTableFunction.getParameters(), expected.getParameters());
+        }
+    }
+    
+    private static void assertFunctionParameters(final SQLCaseAssertContext assertContext, final Collection<ExpressionSegment> actual, final List<ExpectedExpression> expected) {
+        if (expected.isEmpty()) {
+            return;
+        }
+        assertThat(assertContext.getText("Table function parameter count assertion error"), actual.size(), is(expected.size()));
+        int count = 0;
+        for (ExpressionSegment each : actual) {
+            ExpressionAssert.assertExpression(assertContext, each, expected.get(count++));
+        }
+    }
+    
+    private static void assertXmlTableColumns(final SQLCaseAssertContext assertContext, final Collection<XmlTableColumnSegment> actual, final List<ExpectedXmlTableColumn> expected) {
+        if (expected.isEmpty()) {
+            return;
+        }
+        assertThat(assertContext.getText("XMLTABLE column count assertion error"), actual.size(), is(expected.size()));
+        int count = 0;
+        for (XmlTableColumnSegment each : actual) {
+            ExpectedXmlTableColumn expectedColumn = expected.get(count++);
+            assertThat(each.getColumnName(), is(expectedColumn.getName()));
+            assertThat(each.getDataType(), is(expectedColumn.getDataType()));
+            assertThat(each.getPath(), is(expectedColumn.getPath()));
+            ExpressionAssert.assertExpression(assertContext, each.getDefaultExpr(), expectedColumn.getDefaultExpr());
+            SQLSegmentAssert.assertIs(assertContext, each, expectedColumn);
         }
     }
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/with/WithClauseAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/with/WithClauseAssert.java
index 7fa1d594bbc..f3d04c81ec6 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/with/WithClauseAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/segment/with/WithClauseAssert.java
@@ -22,16 +22,27 @@ import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonTableExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.SQLSegmentAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.column.ColumnAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.expression.ExpressionAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.DMLStatementAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.column.ExpectedColumn;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.with.ExpectedCommonTableExpressionClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.with.ExpectedWithClause;
 
+import java.util.Collection;
+import java.util.List;
+
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 /**
  * With clause assert.
@@ -68,9 +79,37 @@ public final class WithClauseAssert {
             ColumnAssert.assertIs(assertContext, each, expected.getColumns().get(count));
             count++;
         }
+        assertColumns(assertContext, actual.getSearchColumns(), expected.getSearchColumns());
+        assertColumns(assertContext, actual.getCycleColumns(), expected.getCycleColumns());
         if (null != expected.getSubquery()) {
             ExpressionAssert.assertSubquery(assertContext, actual.getSubquery(), expected.getSubquery());
         }
+        if (null != expected.getInsert()) {
+            assertThat(actual.getDataModification(), isA(InsertStatement.class));
+            DMLStatementAssert.assertIs(assertContext, actual.getDataModification(), expected.getInsert());
+        } else if (null != expected.getUpdate()) {
+            assertThat(actual.getDataModification(), isA(UpdateStatement.class));
+            DMLStatementAssert.assertIs(assertContext, actual.getDataModification(), expected.getUpdate());
+        } else if (null != expected.getDelete()) {
+            assertThat(actual.getDataModification(), isA(DeleteStatement.class));
+            DMLStatementAssert.assertIs(assertContext, actual.getDataModification(), expected.getDelete());
+        } else if (null != expected.getMerge()) {
+            assertThat(actual.getDataModification(), isA(MergeStatement.class));
+            DMLStatementAssert.assertIs(assertContext, actual.getDataModification(), expected.getMerge());
+        } else {
+            assertNull(actual.getDataModification());
+        }
         SQLSegmentAssert.assertIs(assertContext, actual, expected);
     }
+    
+    private static void assertColumns(final SQLCaseAssertContext assertContext, final Collection<ColumnSegment> actual, final List<ExpectedColumn> expected) {
+        if (expected.isEmpty()) {
+            return;
+        }
+        assertThat(assertContext.getText("Common table expression search/cycle key count assertion error: "), actual.size(), is(expected.size()));
+        int count = 0;
+        for (ColumnSegment each : actual) {
+            ColumnAssert.assertIs(assertContext, each, expected.get(count++));
+        }
+    }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dal/standard/type/ExplainStatementAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dal/standard/type/ExplainStatementAssert.java
index aa75aab7b5f..6aaec4a3a32 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dal/standard/type/ExplainStatementAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dal/standard/type/ExplainStatementAssert.java
@@ -19,11 +19,17 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dal.ExplainStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.CreateTableStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.MergeStatement;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.table.TableAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.SQLStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dal.standard.ExplainStatementTestCase;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
@@ -52,9 +58,15 @@ public final class ExplainStatementAssert {
         } else if (null != expected.getDeleteClause()) {
             assertNotNull(actual.getExplainableSQLStatement(), assertContext.getText("Actual statement should exist."));
             SQLStatementAssert.assertIs(assertContext, actual.getExplainableSQLStatement(), expected.getDeleteClause());
+        } else if (null != expected.getMergeClause()) {
+            assertThat(assertContext.getText("Actual statement type assertion error: "), actual.getExplainableSQLStatement(), isA(MergeStatement.class));
+            SQLStatementAssert.assertIs(assertContext, actual.getExplainableSQLStatement(), expected.getMergeClause());
         } else if (null != expected.getCreateTableAsSelectClause()) {
-            assertNotNull(actual.getExplainableSQLStatement(), assertContext.getText("Actual statement should exist."));
+            assertThat(assertContext.getText("Actual statement type assertion error: "), actual.getExplainableSQLStatement(), isA(CreateTableStatement.class));
             SQLStatementAssert.assertIs(assertContext, actual.getExplainableSQLStatement(), expected.getCreateTableAsSelectClause());
         }
+        if (!expected.getTables().isEmpty()) {
+            TableAssert.assertIs(assertContext, actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables(), expected.getTables());
+        }
     }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/postgresql/PostgreSQLDDLStatementAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/postgresql/PostgreSQLDDLStatementAssert.java
index 7dc6d8e0b42..d87b105e8aa 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/postgresql/PostgreSQLDDLStatementAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/postgresql/PostgreSQLDDLStatementAssert.java
@@ -19,15 +19,49 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.constraint.ConstraintDefinitionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.PrepareStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.collation.DropCollationStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.domain.AlterDomainStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.domain.DropDomainStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function.CreateFunctionStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.operator.AlterOperatorStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.procedure.CreateProcedureStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.sequence.AlterSequenceStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.server.CreateServerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.CreateTableStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.type.AlterTypeStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.view.AlterMaterializedViewStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterDefaultPrivilegesStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterLargeObjectStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterOperatorClassStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterOperatorFamilyStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLAlterUserMappingStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLClusterStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateOperatorClassStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateOperatorFamilyStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateTransformStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLCreateUserMappingStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDeclareStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLDropUserMappingStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLImportForeignSchemaStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLListenStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLNotifyStmtStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLOpenStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLSecurityLabelStmtStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.PostgreSQLUnlistenStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.aggregate.PostgreSQLCreateAggregateStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.conversion.PostgreSQLDropConversionStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event.PostgreSQLAlterEventTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.event.PostgreSQLCreateEventTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.foreigntable.PostgreSQLAlterForeignTableStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.index.PostgreSQLReindexStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.publication.PostgreSQLAlterPublicationStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.publication.PostgreSQLCreatePublicationStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.statistics.PostgreSQLCreateStatisticsStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription.PostgreSQLAlterSubscriptionStatement;
+import org.apache.shardingsphere.sql.parser.statement.postgresql.ddl.subscription.PostgreSQLCreateSubscriptionStatement;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.ddl.dialect.postgresql.type.PostgreSQLClusterStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.ddl.dialect.postgresql.type.PostgreSQLDeclareStatementAssert;
@@ -37,15 +71,55 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.d
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.ddl.dialect.postgresql.type.PostgreSQLReindexStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.ddl.dialect.postgresql.type.PostgreSQLSecurityLabelStmtStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.ddl.dialect.postgresql.type.PostgreSQLUnlistenStatementAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.MergeStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.oracle.OracleAlterMaterializedViewStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterDefaultPrivilegesTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterLargeObjectStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterOperatorClassStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterOperatorFamilyStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterUserMappingStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLClusterStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateOperatorClassStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateOperatorFamilyStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateTransformStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateUserMappingStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDeclareStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropDomainStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropUserMappingStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLImportForeignSchemaStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLListenStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLNotifyStmtStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLOpenStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLReindexStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLSecurityLabelStmtStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLUnlistenStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.aggregate.PostgreSQLCreateAggregateStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.collation.PostgreSQLDropCollationStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.conversion.PostgreSQLDropConversionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event.PostgreSQLAlterEventTriggerStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event.PostgreSQLCreateEventTriggerStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.foreigntable.PostgreSQLAlterForeignTableStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.publication.PostgreSQLAlterPublicationStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.publication.PostgreSQLCreatePublicationStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.statistics.PostgreSQLCreateStatisticsStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription.PostgreSQLAlterSubscriptionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription.PostgreSQLCreateSubscriptionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.PreparedStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.domain.AlterDomainStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.function.CreateFunctionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.operator.AlterOperatorStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.sequence.AlterSequenceStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.server.CreateServerStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.table.CreateTableStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.type.AlterTypeStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.plsql.CreateProcedureTestCase;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * DDL statement assert for PostgreSQL.
@@ -61,6 +135,16 @@ public final class PostgreSQLDDLStatementAssert {
      * @param expected expected parser result
      */
     public static void assertIs(final SQLCaseAssertContext assertContext, final DDLStatement actual, final SQLParserTestCase expected) {
+        if ("PostgreSQL".equals(actual.getDatabaseType().getType())) {
+            assertStatementType(assertContext, actual, expected);
+            if (actual instanceof CreateTableStatement) {
+                int count = 0;
+                for (ConstraintDefinitionSegment each : ((CreateTableStatement) actual).getConstraintDefinitions()) {
+                    assertThat(assertContext.getText("Constraint definition primary key column size assertion error: "), each.getPrimaryKeyColumns().size(),
+                            is(((CreateTableStatementTestCase) expected).getConstraintDefinitions().get(count++).getPrimaryKeyColumns().size()));
+                }
+            }
+        }
         if (actual instanceof PostgreSQLDeclareStatement) {
             PostgreSQLDeclareStatementAssert.assertIs(assertContext, (PostgreSQLDeclareStatement) actual, (PostgreSQLDeclareStatementTestCase) expected);
         } else if (actual instanceof PostgreSQLClusterStatement) {
@@ -79,4 +163,81 @@ public final class PostgreSQLDDLStatementAssert {
             PostgreSQLOpenStatementAssert.assertIs(assertContext, (PostgreSQLOpenStatement) actual, (PostgreSQLOpenStatementTestCase) expected);
         }
     }
+    
+    private static void assertStatementType(final SQLCaseAssertContext assertContext, final DDLStatement actual, final SQLParserTestCase expected) {
+        if (expected instanceof PostgreSQLCreateUserMappingStatementTestCase) {
+            assertThat(assertContext.getText("Create user mapping statement type assertion error."), actual, isA(PostgreSQLCreateUserMappingStatement.class));
+        } else if (expected instanceof PostgreSQLAlterUserMappingStatementTestCase) {
+            assertThat(assertContext.getText("Alter user mapping statement type assertion error."), actual, isA(PostgreSQLAlterUserMappingStatement.class));
+        } else if (expected instanceof PostgreSQLDropUserMappingStatementTestCase) {
+            assertThat(assertContext.getText("Drop user mapping statement type assertion error."), actual, isA(PostgreSQLDropUserMappingStatement.class));
+        } else if (expected instanceof PostgreSQLCreateTransformStatementTestCase) {
+            assertThat(assertContext.getText("Create transform statement type assertion error."), actual, isA(PostgreSQLCreateTransformStatement.class));
+        } else if (expected instanceof PostgreSQLAlterLargeObjectStatementTestCase) {
+            assertThat(assertContext.getText("Alter large object statement type assertion error."), actual, isA(PostgreSQLAlterLargeObjectStatement.class));
+        } else if (expected instanceof PostgreSQLCreateStatisticsStatementTestCase) {
+            assertThat(assertContext.getText("Create statistics statement type assertion error."), actual, isA(PostgreSQLCreateStatisticsStatement.class));
+        } else if (expected instanceof PostgreSQLCreateSubscriptionStatementTestCase) {
+            assertThat(assertContext.getText("Create subscription statement type assertion error."), actual, isA(PostgreSQLCreateSubscriptionStatement.class));
+        } else if (expected instanceof PostgreSQLCreateOperatorClassStatementTestCase) {
+            assertThat(assertContext.getText("Create operator class statement type assertion error."), actual, isA(PostgreSQLCreateOperatorClassStatement.class));
+        } else if (expected instanceof PostgreSQLAlterOperatorClassStatementTestCase) {
+            assertThat(assertContext.getText("Alter operator class statement type assertion error."), actual, isA(PostgreSQLAlterOperatorClassStatement.class));
+        } else if (expected instanceof PostgreSQLCreateOperatorFamilyStatementTestCase) {
+            assertThat(assertContext.getText("Create operator family statement type assertion error."), actual, isA(PostgreSQLCreateOperatorFamilyStatement.class));
+        } else if (expected instanceof PostgreSQLAlterOperatorFamilyStatementTestCase) {
+            assertThat(assertContext.getText("Alter operator family statement type assertion error."), actual, isA(PostgreSQLAlterOperatorFamilyStatement.class));
+        } else if (expected instanceof PostgreSQLAlterEventTriggerStatementTestCase) {
+            assertThat(assertContext.getText("Alter event trigger statement type assertion error."), actual, isA(PostgreSQLAlterEventTriggerStatement.class));
+        } else if (expected instanceof PostgreSQLImportForeignSchemaStatementTestCase) {
+            assertThat(assertContext.getText("Import foreign schema statement type assertion error."), actual, isA(PostgreSQLImportForeignSchemaStatement.class));
+        } else if (expected instanceof PostgreSQLCreatePublicationStatementTestCase) {
+            assertThat(assertContext.getText("Create publication statement type assertion error."), actual, isA(PostgreSQLCreatePublicationStatement.class));
+        } else if (expected instanceof PostgreSQLAlterPublicationStatementTestCase) {
+            assertThat(assertContext.getText("Alter publication statement type assertion error."), actual, isA(PostgreSQLAlterPublicationStatement.class));
+        } else if (expected instanceof CreateServerStatementTestCase) {
+            assertThat(assertContext.getText("Create server statement type assertion error."), actual, isA(CreateServerStatement.class));
+        } else if (expected instanceof PostgreSQLAlterForeignTableStatementTestCase) {
+            assertThat(assertContext.getText("Alter foreign table statement type assertion error."), actual, isA(PostgreSQLAlterForeignTableStatement.class));
+        } else if (expected instanceof OracleAlterMaterializedViewStatementTestCase) {
+            assertThat(assertContext.getText("Alter materialized view statement type assertion error."), actual, isA(AlterMaterializedViewStatement.class));
+        } else if (expected instanceof PostgreSQLAlterDefaultPrivilegesTestCase) {
+            assertThat(assertContext.getText("Alter default privileges statement type assertion error."), actual, isA(PostgreSQLAlterDefaultPrivilegesStatement.class));
+        } else if (expected instanceof PostgreSQLCreateAggregateStatementTestCase) {
+            assertThat(assertContext.getText("Create aggregate statement type assertion error."), actual, isA(PostgreSQLCreateAggregateStatement.class));
+        } else if (expected instanceof PostgreSQLCreateEventTriggerStatementTestCase) {
+            assertThat(assertContext.getText("Create event trigger statement type assertion error."), actual, isA(PostgreSQLCreateEventTriggerStatement.class));
+        } else if (expected instanceof PostgreSQLAlterSubscriptionStatementTestCase) {
+            assertThat(assertContext.getText("Alter subscription statement type assertion error."), actual, isA(PostgreSQLAlterSubscriptionStatement.class));
+        } else if (expected instanceof PostgreSQLReindexStatementTestCase) {
+            assertThat(assertContext.getText("Reindex statement type assertion error."), actual, isA(PostgreSQLReindexStatement.class));
+        } else if (expected instanceof AlterDomainStatementTestCase) {
+            assertThat(assertContext.getText("Alter domain statement type assertion error."), actual, isA(AlterDomainStatement.class));
+        } else if (expected instanceof AlterTypeStatementTestCase) {
+            assertThat(assertContext.getText("Alter type statement type assertion error."), actual, isA(AlterTypeStatement.class));
+        } else if (expected instanceof AlterSequenceStatementTestCase) {
+            assertThat(assertContext.getText("Alter sequence statement type assertion error."), actual, isA(AlterSequenceStatement.class));
+        } else if (expected instanceof AlterOperatorStatementTestCase) {
+            assertThat(assertContext.getText("Alter operator statement type assertion error."), actual, isA(AlterOperatorStatement.class));
+        } else if (expected instanceof PostgreSQLDropCollationStatementTestCase) {
+            assertThat(assertContext.getText("Drop collation statement type assertion error."), actual, isA(DropCollationStatement.class));
+        } else if (expected instanceof PostgreSQLDropConversionStatementTestCase) {
+            assertThat(assertContext.getText("Drop conversion statement type assertion error."), actual, isA(PostgreSQLDropConversionStatement.class));
+        } else if (expected instanceof PostgreSQLDropDomainStatementTestCase) {
+            assertThat(assertContext.getText("Drop domain statement type assertion error."), actual, isA(DropDomainStatement.class));
+        } else if (expected instanceof CreateFunctionStatementTestCase) {
+            assertThat(assertContext.getText("Create function statement type assertion error."), actual, isA(CreateFunctionStatement.class));
+        } else if (expected instanceof CreateProcedureTestCase) {
+            assertThat(assertContext.getText("Create procedure statement type assertion error."), actual, isA(CreateProcedureStatement.class));
+        } else if (expected instanceof PreparedStatementTestCase) {
+            assertThat(assertContext.getText("Prepare statement type assertion error."), actual, isA(PrepareStatement.class));
+            PrepareStatement prepareStatement = (PrepareStatement) actual;
+            if (null == ((PreparedStatementTestCase) expected).getMerge()) {
+                assertFalse(prepareStatement.getMerge().isPresent(), assertContext.getText("Actual merge statement should not exist."));
+            } else {
+                assertTrue(prepareStatement.getMerge().isPresent(), assertContext.getText("Actual merge statement should exist."));
+                MergeStatementAssert.assertIs(assertContext, prepareStatement.getMerge().get(), ((PreparedStatementTestCase) expected).getMerge());
+            }
+        }
+    }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/dialect/postgresql/PostgreSQLDMLStatementAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/dialect/postgresql/PostgreSQLDMLStatementAssert.java
index 9d283483fdf..378f42f6d3b 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/dialect/postgresql/PostgreSQLDMLStatementAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/dialect/postgresql/PostgreSQLDMLStatementAssert.java
@@ -19,12 +19,25 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.ReturningSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DMLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.DeleteStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.UpdateStatement;
 import org.apache.shardingsphere.sql.parser.statement.postgresql.dml.PostgreSQLCopyStatement;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.returning.ReturningClauseAssert;
+import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.with.WithClauseAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.dialect.postgresql.type.PostgreSQLCopyStatementAssert;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.insert.ExpectedReturningClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.dialect.postgresql.PostgreSQLCopyStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.DeleteStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.UpdateStatementTestCase;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * DML statement assert for PostgreSQL.
@@ -43,5 +56,42 @@ public final class PostgreSQLDMLStatementAssert {
         if (actual instanceof PostgreSQLCopyStatement) {
             PostgreSQLCopyStatementAssert.assertIs(assertContext, (PostgreSQLCopyStatement) actual, (PostgreSQLCopyStatementTestCase) expected);
         }
+        if (!"PostgreSQL".equals(actual.getDatabaseType().getType())) {
+            return;
+        }
+        if (actual instanceof DeleteStatement) {
+            assertReturningClause(assertContext, ((DeleteStatement) actual).getReturning().orElse(null), ((DeleteStatementTestCase) expected).getReturningClause());
+        }
+        if (actual instanceof UpdateStatement) {
+            UpdateStatement actualUpdateStatement = (UpdateStatement) actual;
+            UpdateStatementTestCase expectedUpdateStatement = (UpdateStatementTestCase) expected;
+            assertWithClause(assertContext, actualUpdateStatement, expectedUpdateStatement);
+            assertReturningClause(assertContext, actualUpdateStatement.getReturning().orElse(null), expectedUpdateStatement.getReturningClause());
+        }
+    }
+    
+    /**
+     * Assert the presence and contents of a RETURNING clause.
+     *
+     * @param assertContext assert context
+     * @param actual returning segment, or null if absent
+     * @param expected returning clause, or null if absent
+     */
+    private static void assertReturningClause(final SQLCaseAssertContext assertContext, final ReturningSegment actual, final ExpectedReturningClause expected) {
+        if (null == expected) {
+            assertNull(actual, assertContext.getText("Actual returning segment should not exist."));
+        } else {
+            assertNotNull(actual, assertContext.getText("Actual returning segment should exist."));
+            ReturningClauseAssert.assertIs(assertContext, actual, expected);
+        }
+    }
+    
+    private static void assertWithClause(final SQLCaseAssertContext assertContext, final UpdateStatement actual, final UpdateStatementTestCase expected) {
+        if (null == expected.getWithClause()) {
+            assertFalse(actual.getWith().isPresent(), assertContext.getText("Actual with segment should not exist."));
+        } else {
+            assertTrue(actual.getWith().isPresent(), assertContext.getText("Actual with segment should exist."));
+            WithClauseAssert.assertIs(assertContext, actual.getWith().get(), expected.getWithClause());
+        }
     }
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/standard/type/SelectStatementAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/standard/type/SelectStatementAssert.java
index 994594a4192..482848185d6 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/standard/type/SelectStatementAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/dml/standard/type/SelectStatementAssert.java
@@ -175,6 +175,7 @@ public final class SelectStatementAssert {
             assertFalse(limitSegment.isPresent(), assertContext.getText("Actual limit segment should not exist."));
         } else {
             assertTrue(limitSegment.isPresent(), assertContext.getText("Actual limit segment should exist."));
+            LimitClauseAssert.assertFetch(assertContext, limitSegment.get(), expected.getLimitClause());
             LimitClauseAssert.assertOffset(assertContext, limitSegment.get().getOffset().orElse(null), expected.getLimitClause().getOffset());
             LimitClauseAssert.assertRowCount(assertContext, limitSegment.get().getRowCount().orElse(null), expected.getLimitClause().getRowCount());
             SQLSegmentAssert.assertIs(assertContext, limitSegment.get(), expected.getLimitClause());
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/RootSQLParserTestCases.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/RootSQLParserTestCases.java
index 1be2956c4ed..4320f0fceda 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/RootSQLParserTestCases.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/RootSQLParserTestCases.java
@@ -254,7 +254,15 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.oracle.zone.OracleAlterMaterializedZonemapStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.oracle.zone.OracleDropMaterializedZonemapStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterDefaultPrivilegesTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterLargeObjectStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterOperatorClassStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterOperatorFamilyStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLAlterUserMappingStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLClusterStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateOperatorClassStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateOperatorFamilyStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateTransformStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLCreateUserMappingStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDeclareStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDiscardStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropDomainStatementTestCase;
@@ -262,6 +270,8 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropOperatorFamilyStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropOwnedStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropTypeStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLDropUserMappingStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLImportForeignSchemaStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLListenStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLNotifyStmtStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.PostgreSQLOpenStatementTestCase;
@@ -280,6 +290,7 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.conversion.PostgreSQLAlterConversionStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.conversion.PostgreSQLCreateConversionStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.conversion.PostgreSQLDropConversionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event.PostgreSQLAlterEventTriggerStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event.PostgreSQLCreateEventTriggerStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event.PostgreSQLDropEventTriggerStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.extension.PostgreSQLAlterExtensionStatementTestCase;
@@ -308,8 +319,10 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.rule.PostgreSQLCreateRuleStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.rule.PostgreSQLDropRuleStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.statistics.PostgreSQLAlterStatisticsStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.statistics.PostgreSQLCreateStatisticsStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.statistics.PostgreSQLDropStatisticsStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription.PostgreSQLAlterSubscriptionStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription.PostgreSQLCreateSubscriptionStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription.PostgreSQLDropSubscriptionStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.textsearch.PostgreSQLAlterTextSearchStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.textsearch.PostgreSQLCreateTextSearchStatementTestCase;
@@ -1068,6 +1081,45 @@ public final class RootSQLParserTestCases {
     @XmlElement(name = "create-dimension")
     private final List<OracleCreateDimensionStatementTestCase> createDimensionTestCases = new LinkedList<>();
     
+    @XmlElement(name = "create-statistics")
+    private final List<PostgreSQLCreateStatisticsStatementTestCase> createStatisticsTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "create-subscription")
+    private final List<PostgreSQLCreateSubscriptionStatementTestCase> createSubscriptionTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "create-user-mapping")
+    private final List<PostgreSQLCreateUserMappingStatementTestCase> createUserMappingTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "alter-user-mapping")
+    private final List<PostgreSQLAlterUserMappingStatementTestCase> alterUserMappingTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "drop-user-mapping")
+    private final List<PostgreSQLDropUserMappingStatementTestCase> dropUserMappingTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "create-transform")
+    private final List<PostgreSQLCreateTransformStatementTestCase> createTransformTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "alter-large-object")
+    private final List<PostgreSQLAlterLargeObjectStatementTestCase> alterLargeObjectTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "create-operator-class")
+    private final List<PostgreSQLCreateOperatorClassStatementTestCase> createOperatorClassTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "alter-operator-class")
+    private final List<PostgreSQLAlterOperatorClassStatementTestCase> alterOperatorClassTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "create-operator-family")
+    private final List<PostgreSQLCreateOperatorFamilyStatementTestCase> createOperatorFamilyTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "alter-operator-family")
+    private final List<PostgreSQLAlterOperatorFamilyStatementTestCase> alterOperatorFamilyTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "alter-event-trigger")
+    private final List<PostgreSQLAlterEventTriggerStatementTestCase> alterEventTriggerTestCases = new LinkedList<>();
+    
+    @XmlElement(name = "import-foreign-schema")
+    private final List<PostgreSQLImportForeignSchemaStatementTestCase> importForeignSchemaTestCases = new LinkedList<>();
+    
     @XmlElement(name = "create-function")
     private final List<CreateFunctionStatementTestCase> createFunctionTestCases = new LinkedList<>();
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/assignment/ExpectedAssignmentValue.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/assignment/ExpectedAssignmentValue.java
index 797b8ad074f..c13049aaf52 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/assignment/ExpectedAssignmentValue.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/assignment/ExpectedAssignmentValue.java
@@ -23,6 +23,7 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.column.ExpectedColumn;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedBinaryOperationExpression;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedCaseWhenExpression;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedRowExpression;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.complex.ExpectedCommonExpression;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedLiteralExpression;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedParameterMarkerExpression;
@@ -50,6 +51,9 @@ public final class ExpectedAssignmentValue extends AbstractExpectedSQLSegment {
     @XmlElement(name = "case-when-expression")
     private ExpectedCaseWhenExpression caseWhenExpression;
     
+    @XmlElement(name = "row-expression")
+    private ExpectedRowExpression rowExpression;
+    
     @XmlElement(name = "binary-operation-expression")
     private ExpectedBinaryOperationExpression binaryOperationExpression;
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java
index e050331c87a..4b009084c45 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java
@@ -22,6 +22,9 @@ import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.AbstractExpectedSQLSegment;
 
 import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import java.util.LinkedList;
+import java.util.List;
 
 /**
  * Expected table function.
@@ -30,6 +33,12 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Setter
 public final class ExpectedTableFunction extends AbstractExpectedSQLSegment implements ExpectedExpressionSegment {
     
+    @XmlElement(name = "function-parameter")
+    private final List<ExpectedExpression> parameters = new LinkedList<>();
+    
+    @XmlElement(name = "xml-column")
+    private final List<ExpectedXmlTableColumn> xmlColumns = new LinkedList<>();
+    
     @XmlAttribute(name = "function-name")
     private String functionName;
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedXmlTableColumn.java
similarity index 74%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedXmlTableColumn.java
index e050331c87a..fbe58641dfd 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedTableFunction.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/ExpectedXmlTableColumn.java
@@ -18,21 +18,26 @@
 package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr;
 
 import lombok.Getter;
-import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.AbstractExpectedSQLSegment;
 
 import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
 
 /**
- * Expected table function.
+ * Expected XMLTABLE column.
  */
 @Getter
-@Setter
-public final class ExpectedTableFunction extends AbstractExpectedSQLSegment implements ExpectedExpressionSegment {
+public final class ExpectedXmlTableColumn extends AbstractExpectedSQLSegment {
     
-    @XmlAttribute(name = "function-name")
-    private String functionName;
+    @XmlAttribute
+    private String name;
+    
+    @XmlAttribute(name = "data-type")
+    private String dataType;
     
     @XmlAttribute
-    private String text;
+    private String path;
+    
+    @XmlElement(name = "default-expr")
+    private ExpectedExpression defaultExpr;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/complex/ExpectedCommonExpression.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/complex/ExpectedCommonExpression.java
index 9a97f15e635..3579c8655fe 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/complex/ExpectedCommonExpression.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/expr/complex/ExpectedCommonExpression.java
@@ -19,8 +19,12 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.
 
 import lombok.Getter;
 import lombok.Setter;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExpression;
 
 import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlElementWrapper;
+import java.util.Collection;
 
 /**
  * Expected common expression.
@@ -31,4 +35,11 @@ public final class ExpectedCommonExpression extends ExpectedBaseComplexExpressio
     
     @XmlAttribute(name = "literal-text")
     private String literalText;
+    
+    /**
+     * Child expressions to assert, or {@code null} to retain the existing text and span assertions.
+     */
+    @XmlElementWrapper(name = "children")
+    @XmlElement(name = "expression")
+    private Collection<ExpectedExpression> children;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/insert/ExpectedReturningClause.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/insert/ExpectedReturningClause.java
index 5bc33f2c73a..755f7c7d3eb 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/insert/ExpectedReturningClause.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/insert/ExpectedReturningClause.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.
 import lombok.Getter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.projection.ExpectedProjections;
 
+import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 
 /**
@@ -28,6 +29,24 @@ import javax.xml.bind.annotation.XmlElement;
 @Getter
 public class ExpectedReturningClause {
     
+    @XmlAttribute(name = "old-alias")
+    private String oldAlias;
+    
+    @XmlAttribute(name = "old-alias-start-index")
+    private Integer oldAliasStartIndex;
+    
+    @XmlAttribute(name = "old-alias-stop-index")
+    private Integer oldAliasStopIndex;
+    
+    @XmlAttribute(name = "new-alias")
+    private String newAlias;
+    
+    @XmlAttribute(name = "new-alias-start-index")
+    private Integer newAliasStartIndex;
+    
+    @XmlAttribute(name = "new-alias-stop-index")
+    private Integer newAliasStopIndex;
+    
     @XmlElement
     private final ExpectedProjections projections = new ExpectedProjections();
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/limit/ExpectedLimitClause.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/limit/ExpectedLimitClause.java
index b53f5c174fe..ee3f66a464c 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/limit/ExpectedLimitClause.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/limit/ExpectedLimitClause.java
@@ -21,6 +21,7 @@ import lombok.Getter;
 import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.AbstractExpectedSQLSegment;
 
+import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 
 /**
@@ -35,4 +36,10 @@ public final class ExpectedLimitClause extends AbstractExpectedSQLSegment {
     
     @XmlElement(name = "row-count")
     private ExpectedPaginationValue rowCount;
+    
+    @XmlAttribute(name = "with-ties")
+    private boolean withTies;
+    
+    @XmlAttribute(name = "row-count-implicit")
+    private boolean implicitRowCount;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/query/ExpectedPrepareStatementQuery.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/query/ExpectedPrepareStatementQuery.java
index 8294118ab0c..1c48ca222a1 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/query/ExpectedPrepareStatementQuery.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/query/ExpectedPrepareStatementQuery.java
@@ -22,6 +22,7 @@ import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.AbstractExpectedSQLSegment;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.DeleteStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.InsertStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.MergeStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.SelectStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.UpdateStatementTestCase;
 
@@ -43,6 +44,9 @@ public final class ExpectedPrepareStatementQuery extends AbstractExpectedSQLSegm
     @XmlElement(name = "update")
     private UpdateStatementTestCase updateClause;
     
+    @XmlElement(name = "merge")
+    private MergeStatementTestCase mergeClause;
+    
     @XmlElement(name = "delete")
     private DeleteStatementTestCase deleteClause;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/table/ExpectedJoinTable.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/table/ExpectedJoinTable.java
index 3a4343f42eb..e703a17fe33 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/table/ExpectedJoinTable.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/table/ExpectedJoinTable.java
@@ -56,6 +56,15 @@ public final class ExpectedJoinTable extends AbstractExpectedDelimiterSQLSegment
     @XmlElement(name = "column")
     private final List<ExpectedColumn> rightQueryPartitionColumns = new LinkedList<>();
     
+    @XmlAttribute(name = "using-alias")
+    private String usingAlias;
+    
+    @XmlAttribute(name = "using-alias-start-index")
+    private Integer usingAliasStartIndex;
+    
+    @XmlAttribute(name = "using-alias-stop-index")
+    private Integer usingAliasStopIndex;
+    
     @XmlAttribute(name = "join-type")
     private String joinType;
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/with/ExpectedCommonTableExpressionClause.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/with/ExpectedCommonTableExpressionClause.java
index 4995c1aea57..9fba530d722 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/with/ExpectedCommonTableExpressionClause.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/segment/impl/with/ExpectedCommonTableExpressionClause.java
@@ -22,6 +22,10 @@ import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.AbstractExpectedSQLSegment;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.column.ExpectedColumn;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedSubquery;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.DeleteStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.InsertStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.MergeStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.UpdateStatementTestCase;
 
 import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
@@ -41,6 +45,24 @@ public final class ExpectedCommonTableExpressionClause extends AbstractExpectedS
     @XmlElement(name = "column")
     private final List<ExpectedColumn> columns = new LinkedList<>();
     
+    @XmlElement(name = "search-column")
+    private final List<ExpectedColumn> searchColumns = new LinkedList<>();
+    
+    @XmlElement(name = "cycle-column")
+    private final List<ExpectedColumn> cycleColumns = new LinkedList<>();
+    
     @XmlElement(name = "subquery-expression")
     private ExpectedSubquery subquery;
+    
+    @XmlElement(name = "insert")
+    private InsertStatementTestCase insert;
+    
+    @XmlElement(name = "update")
+    private UpdateStatementTestCase update;
+    
+    @XmlElement(name = "delete")
+    private DeleteStatementTestCase delete;
+    
+    @XmlElement(name = "merge")
+    private MergeStatementTestCase merge;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dal/standard/ExplainStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dal/standard/ExplainStatementTestCase.java
index 4b83cc1bc15..5bd5f24f46d 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dal/standard/ExplainStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dal/standard/ExplainStatementTestCase.java
@@ -20,13 +20,17 @@ package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.
 import lombok.Getter;
 import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.table.ExpectedSimpleTable;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard.table.CreateTableStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.DeleteStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.InsertStatementTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.MergeStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.SelectStatementTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.UpdateStatementTestCase;
 
 import javax.xml.bind.annotation.XmlElement;
+import java.util.LinkedList;
+import java.util.List;
 
 /**
  * Describe statement test case.
@@ -47,6 +51,12 @@ public final class ExplainStatementTestCase extends SQLParserTestCase {
     @XmlElement(name = "delete")
     private DeleteStatementTestCase deleteClause;
     
+    @XmlElement(name = "merge")
+    private MergeStatementTestCase mergeClause;
+    
     @XmlElement(name = "create-table")
     private CreateTableStatementTestCase createTableAsSelectClause;
+    
+    @XmlElement(name = "table")
+    private final List<ExpectedSimpleTable> tables = new LinkedList<>();
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterLargeObjectStatementTestCase.java
similarity index 83%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterLargeObjectStatementTestCase.java
index e6bd50e2755..998a726f2e2 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterLargeObjectStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Alter large object statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLAlterLargeObjectStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorClassStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorClassStatementTestCase.java
index e6bd50e2755..37735d4f31b 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorClassStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Alter operator class statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLAlterOperatorClassStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorFamilyStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorFamilyStatementTestCase.java
index e6bd50e2755..63ca38efe43 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterOperatorFamilyStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Alter operator family statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLAlterOperatorFamilyStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterUserMappingStatementTestCase.java
similarity index 83%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterUserMappingStatementTestCase.java
index e6bd50e2755..f33915ecc7c 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLAlterUserMappingStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Alter user mapping statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLAlterUserMappingStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorClassStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorClassStatementTestCase.java
index e6bd50e2755..8e14ef623fb 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorClassStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create operator class statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateOperatorClassStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorFamilyStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorFamilyStatementTestCase.java
index e6bd50e2755..11719f8aaf5 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateOperatorFamilyStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create operator family statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateOperatorFamilyStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateTransformStatementTestCase.java
similarity index 83%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateTransformStatementTestCase.java
index e6bd50e2755..77226def4c4 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateTransformStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create transform statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateTransformStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateUserMappingStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateUserMappingStatementTestCase.java
index e6bd50e2755..9ae732ad135 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLCreateUserMappingStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create user mapping statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateUserMappingStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLDropUserMappingStatementTestCase.java
similarity index 83%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLDropUserMappingStatementTestCase.java
index e6bd50e2755..3b9fd72d275 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLDropUserMappingStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Drop user mapping statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLDropUserMappingStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLImportForeignSchemaStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLImportForeignSchemaStatementTestCase.java
index e6bd50e2755..49b8f720365 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/PostgreSQLImportForeignSchemaStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Import foreign schema statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLImportForeignSchemaStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/event/PostgreSQLAlterEventTriggerStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/event/PostgreSQLAlterEventTriggerStatementTestCase.java
index e6bd50e2755..6a01c25113a 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/event/PostgreSQLAlterEventTriggerStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.event;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Alter event trigger statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLAlterEventTriggerStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/statistics/PostgreSQLCreateStatisticsStatementTestCase.java
similarity index 82%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/statistics/PostgreSQLCreateStatisticsStatementTestCase.java
index e6bd50e2755..74d3aecbb26 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/statistics/PostgreSQLCreateStatisticsStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.statistics;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create statistics statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateStatisticsStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/subscription/PostgreSQLCreateSubscriptionStatementTestCase.java
similarity index 81%
copy from test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
copy to test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/subscription/PostgreSQLCreateSubscriptionStatementTestCase.java
index e6bd50e2755..a4261047555 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/postgresql/subscription/PostgreSQLCreateSubscriptionStatementTestCase.java
@@ -15,12 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
+package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.dialect.postgresql.subscription;
 
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 
 /**
- * Prepared statement test case.
+ * Create subscription statement test case for PostgreSQL.
  */
-public final class PreparedStatementTestCase extends SQLParserTestCase {
+public final class PostgreSQLCreateSubscriptionStatementTestCase extends SQLParserTestCase {
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
index e6bd50e2755..7d7ed05d7ed 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/standard/PreparedStatementTestCase.java
@@ -17,10 +17,18 @@
 
 package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl.standard;
 
+import lombok.Getter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.dml.standard.MergeStatementTestCase;
+
+import javax.xml.bind.annotation.XmlElement;
 
 /**
  * Prepared statement test case.
  */
+@Getter
 public final class PreparedStatementTestCase extends SQLParserTestCase {
+    
+    @XmlElement(name = "merge")
+    private MergeStatementTestCase merge;
 }
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/DeleteStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/DeleteStatementTestCase.java
index 98331e430c4..b86ba056ef2 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/DeleteStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/DeleteStatementTestCase.java
@@ -21,6 +21,7 @@ import lombok.Getter;
 import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.error.ExpectedErrorLoggingClause;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.insert.ExpectedReturningClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.limit.ExpectedLimitClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.orderby.ExpectedOrderByClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.output.ExpectedOutputClause;
@@ -41,6 +42,9 @@ import java.util.List;
 @Setter
 public final class DeleteStatementTestCase extends SQLParserTestCase {
     
+    @XmlElement(name = "returning")
+    private ExpectedReturningClause returningClause;
+    
     @XmlElement(name = "with")
     private ExpectedWithClause withClause;
     
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/UpdateStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/UpdateStatementTestCase.java
index 9acdf8c23d8..8ec81ccc4c3 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/UpdateStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/dml/standard/UpdateStatementTestCase.java
@@ -22,6 +22,7 @@ import lombok.Setter;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.error.ExpectedErrorLoggingClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.hint.ExpectedOptionHint;
+import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.insert.ExpectedReturningClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.limit.ExpectedLimitClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.orderby.ExpectedOrderByClause;
 import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.output.ExpectedOutputClause;
@@ -39,6 +40,9 @@ import javax.xml.bind.annotation.XmlElement;
 @Setter
 public final class UpdateStatementTestCase extends SQLParserTestCase {
     
+    @XmlElement(name = "returning")
+    private ExpectedReturningClause returningClause;
+    
     @XmlElement(name = "with")
     private ExpectedWithClause withClause;
     
diff --git a/test/it/parser/src/main/resources/case/dal/postgresql-regression.xml b/test/it/parser/src/main/resources/case/dal/postgresql-regression.xml
new file mode 100644
index 00000000000..c2e3078f545
--- /dev/null
+++ b/test/it/parser/src/main/resources/case/dal/postgresql-regression.xml
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<sql-parser-test-cases>
+    <reset-parameter sql-case-id="reset_session_authorization_postgresql" configuration-parameter="session_authorization" />
+    <reset-parameter sql-case-id="reset_time_zone_postgresql" configuration-parameter="timezone" />
+    <reset-parameter sql-case-id="reset_custom_parameter_postgresql" configuration-parameter="custom.foo" />
+    <reset-parameter sql-case-id="reset_all_postgresql" configuration-parameter="ALL" />
+    <explain sql-case-id="explain_merge_format_json_postgresql">
+        <merge>
+            <target>
+                <simple-table name="foo" start-index="33" stop-index="35" />
+            </target>
+            <source>
+                <simple-table name="bar" start-index="43" stop-index="45" />
+            </source>
+            <expr>
+                <binary-operation-expression start-index="50" stop-index="64">
+                    <left>
+                        <column name="id" start-index="50" stop-index="55">
+                            <owner name="foo" start-index="50" stop-index="52" />
+                        </column>
+                    </left>
+                    <operator>=</operator>
+                    <right>
+                        <column name="id" start-index="59" stop-index="64">
+                            <owner name="bar" start-index="59" stop-index="61" />
+                        </column>
+                    </right>
+                </binary-operation-expression>
+            </expr>
+            <merge-items />
+        </merge>
+        <table name="foo" start-index="33" stop-index="35" />
+        <table name="bar" start-index="43" stop-index="45" />
+        <table name="foo" start-index="50" stop-index="52" />
+        <table name="bar" start-index="59" stop-index="61" />
+    </explain>
+    <explain sql-case-id="explain_create_table_as_postgresql">
+        <create-table>
+            <table name="foo" start-index="21" stop-index="23" />
+            <select>
+                <from>
+                    <simple-table name="bar" start-index="43" stop-index="45" />
+                </from>
+                <projections start-index="35" stop-index="36">
+                    <column-projection name="id" start-index="35" stop-index="36" />
+                </projections>
+            </select>
+        </create-table>
+    </explain>
+    <common sql-case-id="analyze_only_postgresql" />
+    <common sql-case-id="vacuum_only_postgresql" />
+    <explain sql-case-id="explain_create_table_as_column_names_postgresql">
+        <create-table>
+            <table name="foo" start-index="21" stop-index="23" />
+            <column name="id" start-index="25" stop-index="26" />
+            <select>
+                <from>
+                    <simple-table name="bar" start-index="47" stop-index="49" />
+                </from>
+                <projections start-index="39" stop-index="40">
+                    <column-projection name="id" start-index="39" stop-index="40" />
+                </projections>
+            </select>
+        </create-table>
+    </explain>
+    <explain sql-case-id="explain_create_table_as_execute_postgresql" parameters="1">
+        <create-table parameters="1">
+            <table name="foo" start-index="21" stop-index="23" />
+            <column name="id" start-index="25" stop-index="26" />
+        </create-table>
+    </explain>
+</sql-parser-test-cases>
diff --git a/test/it/parser/src/main/resources/case/dcl/grant.xml b/test/it/parser/src/main/resources/case/dcl/grant.xml
index abd8af5584f..d329742a28d 100644
--- a/test/it/parser/src/main/resources/case/dcl/grant.xml
+++ b/test/it/parser/src/main/resources/case/dcl/grant.xml
@@ -310,12 +310,26 @@
     <grant sql-case-id="grant_create_tablespace_doris" />
     <grant sql-case-id="grant_create_role_privilege_doris" />
     <grant sql-case-id="grant_drop_role_privilege_doris" />
-    
     <grant sql-case-id="grant_select_sql92">
         <table name="t_order" start-index="27" stop-index="33" />
         <column name="order_id" start-index="14" stop-index="21" />
     </grant>
+    <grant sql-case-id="grant_maintain_on_table_postgresql">
+        <table name="foo" start-index="18" stop-index="31">
+            <owner name="foo_schema" start-index="18" stop-index="27" />
+        </table>
+    </grant>
+    <grant sql-case-id="grant_privilege_granted_by_current_user_postgresql">
+        <table name="foo" start-index="16" stop-index="18" />
+    </grant>
+    <grant sql-case-id="grant_privilege_granted_by_current_role_postgresql">
+        <table name="foo" start-index="18" stop-index="20" />
+    </grant>
+    <grant sql-case-id="grant_privileges_granted_by_role_postgresql">
+        <table name="foo" start-index="24" stop-index="26" />
+    </grant>
+    <grant sql-case-id="grant_role_options_postgresql" />
+    <grant sql-case-id="grant_role_option_keyword_postgresql" />
     <grant sql-case-id="grant_global_spaced_wildcard" />
-
     <grant sql-case-id="grant_database_spaced_wildcard" />
 </sql-parser-test-cases>
diff --git a/test/it/parser/src/main/resources/case/dcl/revoke.xml b/test/it/parser/src/main/resources/case/dcl/revoke.xml
index aa2200e20dc..3d92d9524c6 100644
--- a/test/it/parser/src/main/resources/case/dcl/revoke.xml
+++ b/test/it/parser/src/main/resources/case/dcl/revoke.xml
@@ -266,4 +266,18 @@
         <table name="t_order" start-index="28" stop-index="34" />
         <column name="order_id" start-index="14" stop-index="21" />
     </revoke>
+    <revoke sql-case-id="revoke_maintain_on_table_postgresql">
+        <table name="foo" start-index="19" stop-index="32">
+            <owner name="foo_schema" start-index="19" stop-index="28" />
+        </table>
+    </revoke>
+    <revoke sql-case-id="revoke_privileges_granted_by_role_postgresql">
+        <table name="foo" start-index="25" stop-index="27" />
+    </revoke>
+    <revoke sql-case-id="revoke_grant_option_granted_by_postgresql">
+        <table name="foo" start-index="34" stop-index="36" />
+    </revoke>
+    <revoke sql-case-id="revoke_role_admin_option_for_postgresql" />
+    <revoke sql-case-id="revoke_role_inherit_option_for_postgresql" />
+    <revoke sql-case-id="revoke_role_set_option_for_postgresql" />
 </sql-parser-test-cases>
diff --git a/test/it/parser/src/main/resources/case/ddl/create-trigger.xml b/test/it/parser/src/main/resources/case/ddl/create-trigger.xml
index 7a90953182c..89fa506e022 100644
--- a/test/it/parser/src/main/resources/case/ddl/create-trigger.xml
+++ b/test/it/parser/src/main/resources/case/ddl/create-trigger.xml
@@ -103,7 +103,8 @@
         <table name="t_merge_target" start-index="55" stop-index="68" />
     </create-trigger>
     <create-trigger sql-case-id="create_trigger_pg_constraint">
-        <table name="t_merge_target" start-index="31" stop-index="44" />
+        <trigger-name name="t_merge_constraint" start-index="26" stop-index="43" />
+        <table name="t_merge_target" start-index="61" stop-index="74" />
     </create-trigger>
     <create-trigger sql-case-id="create_trigger_if_not_exists_mysql" />
 </sql-parser-test-cases>
diff --git a/test/it/parser/src/main/resources/case/ddl/postgresql-regression.xml b/test/it/parser/src/main/resources/case/ddl/postgresql-regression.xml
new file mode 100644
index 00000000000..81132f6c724
--- /dev/null
+++ b/test/it/parser/src/main/resources/case/ddl/postgresql-regression.xml
@@ -0,0 +1,443 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<sql-parser-test-cases>
+    <create-table sql-case-id="create_table_generated_virtual_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int" start-index="26" stop-index="73">
+            <column name="doubled" />
+        </column-definition>
+    </create-table>
+    <create-table sql-case-id="create_table_generated_implicit_virtual_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int" start-index="26" stop-index="65">
+            <column name="doubled" />
+        </column-definition>
+    </create-table>
+    <create-table sql-case-id="create_table_generated_stored_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int" start-index="26" stop-index="72">
+            <column name="doubled" />
+        </column-definition>
+    </create-table>
+    <create-table sql-case-id="create_table_check_enforced_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <constraint-definition start-index="26" stop-index="48" />
+    </create-table>
+    <create-table sql-case-id="create_table_check_not_enforced_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <constraint-definition start-index="26" stop-index="52" />
+    </create-table>
+    <create-table sql-case-id="create_table_unique_nulls_not_distinct_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <constraint-definition start-index="26" stop-index="55" />
+    </create-table>
+    <create-table sql-case-id="create_table_column_unique_nulls_not_distinct_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="49">
+            <column name="id" />
+        </column-definition>
+    </create-table>
+    <create-table sql-case-id="create_table_not_null_no_inherit_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <constraint-definition start-index="26" stop-index="47" />
+    </create-table>
+    <create-table sql-case-id="create_table_temporal_primary_key_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int4range" start-index="26" stop-index="43">
+            <column name="valid_at" />
+        </column-definition>
+        <constraint-definition start-index="46" stop-index="88">
+            <primary-key-column name="id" start-index="59" stop-index="60" />
+            <primary-key-column name="valid_at" start-index="63" stop-index="70" />
+        </constraint-definition>
+    </create-table>
+    <create-table sql-case-id="create_table_temporal_unique_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int4range" start-index="26" stop-index="43">
+            <column name="valid_at" />
+        </column-definition>
+        <constraint-definition start-index="46" stop-index="83" />
+    </create-table>
+    <create-table sql-case-id="create_table_temporal_foreign_key_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="23">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="int4range" start-index="26" stop-index="43">
+            <column name="valid_at" />
+        </column-definition>
+        <constraint-definition start-index="46" stop-index="115">
+            <referenced-table name="bar" start-index="91" stop-index="93" />
+        </constraint-definition>
+    </create-table>
+    <alter-table sql-case-id="alter_table_set_expression_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+        <modify-column>
+            <column-definition start-index="16" stop-index="62">
+                <column name="doubled" />
+            </column-definition>
+        </modify-column>
+    </alter-table>
+    <alter-table sql-case-id="alter_table_add_not_null_no_inherit_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+        <add-constraint start-index="20" stop-index="41" />
+    </alter-table>
+    <create-publication sql-case-id="create_publication_columns_where_postgresql" />
+    <create-publication sql-case-id="create_publication_schemas_postgresql" />
+    <create-publication sql-case-id="create_publication_mixed_objects_postgresql" />
+    <alter-publication sql-case-id="alter_publication_add_schema_postgresql" />
+    <alter-publication sql-case-id="alter_publication_set_schema_postgresql" />
+    <alter-publication sql-case-id="alter_publication_drop_schema_postgresql" />
+    <alter-publication sql-case-id="alter_publication_table_filter_postgresql" />
+    <create-function sql-case-id="create_function_return_body_postgresql" />
+    <create-function sql-case-id="create_function_atomic_body_postgresql" />
+    <create-function sql-case-id="create_function_atomic_empty_statements_postgresql" />
+    <create-function sql-case-id="create_function_atomic_table_body_postgresql" />
+    <create-procedure sql-case-id="create_procedure_atomic_body_postgresql" />
+    <create-procedure sql-case-id="create_procedure_atomic_ddl_body_postgresql" />
+    <create-procedure sql-case-id="create_procedure_atomic_empty_body_postgresql" />
+    <create-trigger sql-case-id="create_or_replace_trigger_postgresql">
+        <trigger-name name="foo_trigger" start-index="26" stop-index="36" />
+        <table name="foo" start-index="55" stop-index="57" />
+    </create-trigger>
+    <create-trigger sql-case-id="create_constraint_trigger_postgresql">
+        <trigger-name name="foo_trigger" start-index="26" stop-index="36" />
+        <table name="foo" start-index="54" stop-index="56" />
+    </create-trigger>
+    <create-trigger sql-case-id="create_constraint_trigger_optional_clauses_postgresql">
+        <trigger-name name="foo_trigger" start-index="26" stop-index="36" />
+        <table name="foo" start-index="54" stop-index="56" />
+    </create-trigger>
+    <create-statistics sql-case-id="create_statistics_named_postgresql" />
+    <create-statistics sql-case-id="create_statistics_unnamed_postgresql" />
+    <create-subscription sql-case-id="create_subscription_postgresql" />
+    <create-operator-class sql-case-id="create_operator_class_postgresql" />
+    <alter-operator-class sql-case-id="alter_operator_class_postgresql" />
+    <create-operator-family sql-case-id="create_operator_family_postgresql" />
+    <alter-operator-family sql-case-id="alter_operator_family_add_postgresql" />
+    <alter-operator-family sql-case-id="alter_operator_family_drop_postgresql" />
+    <alter-operator-family sql-case-id="alter_operator_family_rename_postgresql" />
+    <alter-event-trigger sql-case-id="alter_event_trigger_enable_postgresql" />
+    <alter-event-trigger sql-case-id="alter_event_trigger_enable_replica_postgresql" />
+    <alter-event-trigger sql-case-id="alter_event_trigger_enable_always_postgresql" />
+    <import-foreign-schema sql-case-id="import_foreign_schema_postgresql" />
+    <create-index sql-case-id="create_index_zero_argument_function_postgresql">
+        <table>
+            <simple-table name="foo" start-index="24" stop-index="26" />
+        </table>
+        <index name="foo_idx" start-index="13" stop-index="19" />
+    </create-index>
+    <create-index sql-case-id="create_index_coalesce_postgresql">
+        <table>
+            <simple-table name="foo" start-index="24" stop-index="26" />
+        </table>
+        <index name="foo_idx" start-index="13" stop-index="19" />
+        <column name="id" start-index="38" stop-index="39" />
+    </create-index>
+    <create-index sql-case-id="create_index_function_column_postgresql">
+        <table>
+            <simple-table name="foo" start-index="24" stop-index="26" />
+        </table>
+        <index name="foo_idx" start-index="13" stop-index="19" />
+        <column name="name" start-index="35" stop-index="38" />
+    </create-index>
+    <create-index sql-case-id="create_index_cast_postgresql">
+        <table>
+            <simple-table name="foo" start-index="24" stop-index="26" />
+        </table>
+        <index name="foo_idx" start-index="13" stop-index="19" />
+        <column name="a" start-index="34" stop-index="34" />
+    </create-index>
+    <create-index sql-case-id="create_index_nested_cast_postgresql">
+        <table>
+            <simple-table name="foo" start-index="24" stop-index="26" />
+        </table>
+        <index name="foo_idx" start-index="13" stop-index="19" />
+        <column name="a" start-index="34" stop-index="34" />
+        <column name="b" start-index="43" stop-index="43" />
+    </create-index>
+    <prepared sql-case-id="prepare_merge_postgresql">
+        <merge>
+            <target>
+                <simple-table name="foo" start-index="34" stop-index="36" />
+            </target>
+            <source>
+                <simple-table name="bar" start-index="44" stop-index="46" />
+            </source>
+            <expr>
+                <binary-operation-expression start-index="51" stop-index="65">
+                    <left>
+                        <column name="id" start-index="51" stop-index="56">
+                            <owner name="foo" start-index="51" stop-index="53" />
+                        </column>
+                    </left>
+                    <operator>=</operator>
+                    <right>
+                        <column name="id" start-index="60" stop-index="65">
+                            <owner name="bar" start-index="60" stop-index="62" />
+                        </column>
+                    </right>
+                </binary-operation-expression>
+            </expr>
+            <merge-items />
+        </merge>
+    </prepared>
+    <create-table sql-case-id="create_table_as_select_columns_parameter_postgresql" parameters="1" parameter-marker-count="1">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column name="id" start-index="18" stop-index="19" />
+        <column name="name" start-index="22" stop-index="25" />
+        <select>
+            <from>
+                <simple-table name="bar" start-index="52" stop-index="54" />
+            </from>
+            <projections start-index="38" stop-index="45">
+                <column-projection name="id" start-index="38" stop-index="39" />
+                <column-projection name="name" start-index="42" stop-index="45" />
+            </projections>
+            <where start-index="56" stop-index="67">
+                <expr>
+                    <binary-operation-expression start-index="62" stop-index="67">
+                        <left>
+                            <column name="id" start-index="62" stop-index="63" />
+                        </left>
+                        <operator>=</operator>
+                        <right>
+                            <parameter-marker-expression parameter-index="0" start-index="67" stop-index="67" />
+                        </right>
+                    </binary-operation-expression>
+                </expr>
+            </where>
+        </select>
+    </create-table>
+
+    <create-table sql-case-id="create_table_as_values_columns_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column name="id" start-index="18" stop-index="19" />
+        <select>
+            <projections start-index="25" stop-index="34">
+                <expression-projection text="1" start-index="33" stop-index="33">
+                    <expr>
+                        <literal-expression value="1" start-index="33" stop-index="33" />
+                    </expr>
+                </expression-projection>
+            </projections>
+        </select>
+    </create-table>
+
+    <create-table sql-case-id="create_table_as_execute_parameters_postgresql" parameters="1,2" parameter-marker-count="2">
+        <table name="foo" start-index="13" stop-index="15" />
+    </create-table>
+
+    <create-table sql-case-id="create_table_as_execute_columns_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column name="id" start-index="18" stop-index="19" />
+        <column name="name" start-index="22" stop-index="25" />
+    </create-table>
+
+    <create-table sql-case-id="create_table_storage_compression_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="37">
+            <column name="id" />
+        </column-definition>
+        <column-definition type="text" start-index="40" stop-index="65">
+            <column name="name" />
+        </column-definition>
+    </create-table>
+
+    <create-table sql-case-id="create_table_like_generated_compression_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+    </create-table>
+
+    <create-table sql-case-id="create_table_foreign_key_delete_set_columns_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+        <column-definition type="int" start-index="18" stop-index="67">
+            <column name="id" />
+            <referenced-table name="bar" start-index="36" stop-index="38" />
+        </column-definition>
+        <column-definition type="int" start-index="70" stop-index="81">
+            <column name="other_id" />
+        </column-definition>
+        <constraint-definition start-index="84" stop-index="158">
+            <referenced-table name="bar" start-index="118" stop-index="120" />
+        </constraint-definition>
+    </create-table>
+
+    <create-table sql-case-id="create_table_typed_column_constraints_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+    </create-table>
+
+    <create-table sql-case-id="create_table_partition_generated_with_options_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+    </create-table>
+
+    <create-table sql-case-id="create_table_partition_primary_unique_postgresql">
+        <table name="foo" start-index="13" stop-index="15" />
+    </create-table>
+
+    <create-view sql-case-id="create_view_cascaded_check_option_postgresql" view-definition="SELECT * FROM bar">
+        <view name="foo_view" start-index="12" stop-index="19" />
+        <select>
+            <from>
+                <simple-table name="bar" start-index="38" stop-index="40" />
+            </from>
+            <projections start-index="31" stop-index="31">
+                <shorthand-projection start-index="31" stop-index="31" />
+            </projections>
+        </select>
+    </create-view>
+
+    <alter-table sql-case-id="alter_table_constraint_inheritance_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+        <modify-constraint constraint-name="foo_check" start-index="16" stop-index="49" />
+        <modify-constraint constraint-name="bar_check" start-index="52" stop-index="88" />
+    </alter-table>
+
+    <alter-table sql-case-id="alter_table_storage_default_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+        <modify-column>
+            <column-definition start-index="16" stop-index="50">
+                <column name="id" />
+            </column-definition>
+        </modify-column>
+    </alter-table>
+
+    <alter-table sql-case-id="alter_table_access_method_default_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+    </alter-table>
+
+    <alter-table sql-case-id="alter_table_reloptions_qualified_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+    </alter-table>
+
+    <alter-table sql-case-id="alter_table_reset_reloptions_postgresql">
+        <table name="foo" start-index="12" stop-index="14" />
+    </alter-table>
+
+    <create-index sql-case-id="create_index_nulls_distinct_postgresql">
+        <table>
+            <simple-table name="foo" start-index="31" stop-index="33" />
... 5062 lines suppressed ...