You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eventmesh.apache.org by mi...@apache.org on 2023/09/13 02:45:39 UTC

[eventmesh] branch master updated: [ISSUE #4409]Support source connector jdbc handle snapshot data for mysql (#4434)

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

mikexue pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/eventmesh.git


The following commit(s) were added to refs/heads/master by this push:
     new 74f9abf5e [ISSUE #4409]Support source connector jdbc handle snapshot data for mysql (#4434)
74f9abf5e is described below

commit 74f9abf5efa2f68014d167e6c13e90a7bf34b7a5
Author: mxsm <lj...@gmail.com>
AuthorDate: Wed Sep 13 10:45:33 2023 +0800

    [ISSUE #4409]Support source connector jdbc handle snapshot data for mysql (#4434)
---
 .github/workflows/ci.yml                           |   23 +-
 .../eventmesh-connector-jdbc/build.gradle          |    9 +-
 .../src/main/antlr/MySqlLexer.g4                   | 1356 ++++++++++
 .../src/main/antlr/MySqlParser.g4                  | 2837 ++++++++++++++++++++
 .../jdbc/{Field.java => AbstractPartition.java}    |    6 +-
 .../eventmesh/connector/jdbc/CatalogChanges.java   |    4 +-
 .../org/apache/eventmesh/connector/jdbc/Field.java |   49 +-
 .../eventmesh/connector/jdbc/JdbcContext.java      |    4 +
 ...Schema.java => PartitionOffSetContextPair.java} |   22 +-
 .../apache/eventmesh/connector/jdbc/Payload.java   |   18 +-
 .../apache/eventmesh/connector/jdbc/Schema.java    |   12 +-
 .../connector/jdbc/UniversalJdbcContext.java       |   76 +
 .../{Field.java => UniversalOffsetContext.java}    |    5 +-
 .../connector/jdbc/antlr4/Antlr4DdlParser.java     |   75 +
 .../listener/Antlr4DdlParserListener.java}         |   16 +-
 .../jdbc/{Field.java => common/SourceInfo.java}    |   10 +-
 .../jdbc/connection/mysql/MysqlJdbcConnection.java |  186 ++
 .../mysql/MysqlOffsetContext.java}                 |   46 +-
 .../mysql/MysqlPartition.java}                     |   43 +-
 .../connector/jdbc/ddl/AbstractDdlParser.java      |    2 +
 .../eventmesh/connector/jdbc/ddl/DdlParser.java    |   23 +-
 .../connector/jdbc/ddl/DdlParserCallback.java      |    7 +-
 .../AbstractEvent.java}                            |   52 +-
 .../Table.java => event/AlertDatabaseEvent.java}   |   22 +-
 .../Table.java => event/AlertTableEvent.java}      |   21 +-
 .../Table.java => event/CreateDatabaseEvent.java}  |   22 +-
 .../Table.java => event/CreateTableEvent.java}     |   22 +-
 .../{Schema.java => event/DeleteDataEvent.java}    |   20 +-
 .../Table.java => event/DropDatabaseEvent.java}    |   21 +-
 .../Table.java => event/DropTableEvent.java}       |   22 +-
 .../GeneralDataChangeEvent.java}                   |   25 +-
 .../GeneralSchemaChangeEvent.java}                 |   17 +-
 .../Table.java => event/InsertDataEvent.java}      |   23 +-
 .../DdlParser.java => event/UpdateDataEvent.java}  |   38 +-
 .../connector/jdbc/source/AbstractEngine.java      |  121 +
 .../AbstractEventMeshJdbcTask.java}                |   17 +-
 .../connector/jdbc/source/JdbcSourceConnector.java |   26 +-
 .../jdbc/source/SourceJdbcTaskManager.java         |   19 +-
 .../dialect/AbstractGeneralDatabaseDialect.java    |   57 +
 .../dialect/DatabaseType.java}                     |   25 +-
 .../dialect/antlr4/mysql/MysqlAntlr4DdlParser.java |  153 ++
 .../listener/ColumnDefinitionParserListener.java   |  149 +
 .../listener/CreateDatabaseParserListener.java     |   98 +
 .../mysql/listener/CreateTableParserListener.java  |  163 ++
 .../mysql/listener/DefaultValueParserListener.java |  154 ++
 .../mysql/listener/DropDatabaseParserListener.java |   64 +
 .../listener/MySqlAntlr4DdlParserListener.java     |   72 +
 .../mysql/listener/TableBaseParserListener.java    |  180 ++
 .../listener/TruncateTableParserListener.java      |   55 +
 .../EventDataDeserializationExceptionData.java}    |   41 +-
 .../jdbc/source/dialect/mysql/GtidSet.java         |  485 ++++
 .../dialect/mysql/MysqlDataTypeConvertor.java      |  230 ++
 .../source/dialect/mysql/MysqlDatabaseDialect.java |  313 +++
 .../mysql/MysqlDatabaseDialectFactory.java}        |   34 +-
 .../jdbc/source/dialect/mysql/MysqlDialectSql.java |   87 +
 .../source/dialect/mysql/MysqlJdbcContext.java     |  108 +
 .../dialect/mysql/MysqlSourceInfo.java}            |   42 +-
 .../source/dialect/mysql/MysqlSourceMateData.java  |  162 ++
 .../dialect/mysql/StopEventData.java}              |   17 +-
 .../dialect/mysql/StopEventDataDeserializer.java}  |   16 +-
 .../dialect/snapshot/AbstractSnapshotEngine.java   |  371 +++
 .../snapshot/mysql/MysqlSnapshotEngine.java        |  311 +++
 .../snapshot/mysql/MysqlSnapshotEngineFactory.java |   39 +
 .../table/catalog/AbstractColumnEditorImpl.java    |  269 ++
 .../table/catalog/AbstractTableEditorImpl.java     |  212 ++
 .../jdbc/table/catalog/CatalogTableSet.java        |   97 +
 .../connector/jdbc/table/catalog/Column.java       |   19 +-
 .../connector/jdbc/table/catalog/ColumnEditor.java |  118 +-
 .../jdbc/table/catalog/DefaultColumn.java          |   19 +-
 .../table/catalog/DefaultColumnEditorImpl.java     |  258 --
 .../connector/jdbc/table/catalog/PrimaryKey.java   |    2 +
 .../connector/jdbc/table/catalog/Table.java        |    7 +
 .../connector/jdbc/table/catalog/TableEditor.java  |  119 +
 .../connector/jdbc/table/catalog/TableId.java      |   26 +-
 .../connector/jdbc/table/catalog/TableSchema.java  |   95 +-
 .../connector/jdbc/table/catalog/UniqueKey.java    |   20 +-
 .../jdbc/table/catalog/mysql/MysqlColumn.java      |   81 +
 .../table/catalog/mysql/MysqlColumnEditor.java     |   70 +
 .../table/catalog/mysql/MysqlColumnEditorImpl.java |   83 +
 .../catalog/mysql/MysqlTableEditor.java}           |   30 +-
 .../table/catalog/mysql/MysqlTableEditorImpl.java  |   48 +
 .../{Table.java => mysql/MysqlTableOptions.java}   |   15 +-
 .../jdbc/table/catalog/mysql/MysqlTableSchema.java |   44 +
 .../connector/jdbc/table/type/CalendarType.java    |   85 +
 .../connector/jdbc/table/type/DecimalType.java     |   65 +
 .../jdbc/table/type/EventMeshDataType.java         |    9 +
 .../connector/jdbc/table/type/EventMeshRow.java    |   87 +
 .../table/type/EventMeshTypeNameConverter.java     |   62 +
 ...EventMeshDataType.java => EvetMeshRowType.java} |   29 +-
 .../connector/jdbc/table/type/MapType.java         |  105 +
 .../jdbc/table/type/PrimitiveArrayType.java        |  101 +
 ...shDataType.java => PrimitiveByteArrayType.java} |   44 +-
 .../connector/jdbc/table/type/PrimitiveType.java   |   84 +
 .../Antlr4Utils.java}                              |   28 +-
 .../catalog/Table.java => utils/MysqlUtils.java}   |   19 +-
 ...nector.jdbc.source.dialect.cdc.CdcEngineFactory |    2 +-
 .../src/main/resources/source-config.yml           |    3 +-
 .../connector/jdbc/table/catalog/TableIdTest.java  |   70 +
 .../connector/jdbc/utils/Antlr4UtilsTest.java      |   72 +
 .../connector/jdbc/utils/MysqlUtilsTest.java}      |   46 +-
 100 files changed, 10482 insertions(+), 804 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0fce610af..7721daad2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -48,12 +48,6 @@ jobs:
           # queries: ./path/to/local/query, your-org/your-repo/queries@main
           languages: ${{ matrix.language }}
 
-      - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'zulu'
-          java-version: ${{ matrix.java }}
-
       - name: Cache Gradle packages
         uses: actions/cache@v3
         with:
@@ -63,9 +57,24 @@ jobs:
           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
           restore-keys: ${{ runner.os }}-gradle-
 
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: 11
+
+      - name: GenerateGrammarSource
+        run: ./gradlew clean generateGrammarSource --parallel --daemon
+
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: ${{ matrix.java }}
+
       # https://docs.gradle.org/current/userguide/performance.html
       - name: Build
-        run: ./gradlew clean build jar dist jacocoTestReport --parallel --daemon
+        run: ./gradlew clean build jar dist jacocoTestReport -x generateGrammarSource --parallel --daemon
 
       - name: Install plugin
         run: ./gradlew installPlugin
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/build.gradle b/eventmesh-connectors/eventmesh-connector-jdbc/build.gradle
index e4fac1705..601256156 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/build.gradle
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/build.gradle
@@ -16,15 +16,14 @@
  */
 
 plugins {
-    id 'java'
-    //id 'antlr'
+    id 'antlr'
 }
 
 repositories {
     mavenCentral()
 }
 
-/*generateGrammarSource {
+generateGrammarSource {
     maxHeapSize = '64m'
     arguments += ['-package', 'org.apache.eventmesh.connector.jdbc.antlr4.autogeneration', '-visitor']
     outputDirectory = file('src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/autogeneration')
@@ -32,10 +31,10 @@ repositories {
 
 packageSources {
     dependsOn generateGrammarSource
-}*/
+}
 
 dependencies {
-    //antlr("org.antlr:antlr4:4.13.0")
+    antlr("org.antlr:antlr4:4.13.0")
     implementation 'org.antlr:antlr4-runtime:4.13.0'
     implementation project(":eventmesh-common")
     implementation project(":eventmesh-openconnect:eventmesh-openconnect-java")
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlLexer.g4 b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlLexer.g4
new file mode 100644
index 000000000..6ecef13c3
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlLexer.g4
@@ -0,0 +1,1356 @@
+/*
+ * 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.
+ */
+
+
+lexer grammar MySqlLexer;
+
+options { caseInsensitive = true; }
+
+channels { MYSQLCOMMENT, ERRORCHANNEL }
+
+// SKIP
+
+SPACE:                               [ \t\r\n]+    -> channel(HIDDEN);
+SPEC_MYSQL_COMMENT:                  '/*!' .+? '*/' -> channel(MYSQLCOMMENT);
+COMMENT_INPUT:                       '/*' .*? '*/' -> channel(HIDDEN);
+LINE_COMMENT:                        (
+                                       ('--' [ \t]* | '#') ~[\r\n]* ('\r'? '\n' | EOF)
+                                       | '--' ('\r'? '\n' | EOF)
+                                     ) -> channel(HIDDEN);
+
+
+// Keywords
+// Common Keywords
+
+ADD:                                 'ADD';
+ALL:                                 'ALL';
+ALTER:                               'ALTER';
+ALWAYS:                              'ALWAYS';
+ANALYZE:                             'ANALYZE';
+AND:                                 'AND';
+ARRAY:                               'ARRAY';
+AS:                                  'AS';
+ASC:                                 'ASC';
+ATTRIBUTE:                           'ATTRIBUTE';
+BEFORE:                              'BEFORE';
+BETWEEN:                             'BETWEEN';
+BOTH:                                'BOTH';
+BUCKETS:                             'BUCKETS';
+BY:                                  'BY';
+CALL:                                'CALL';
+CASCADE:                             'CASCADE';
+CASE:                                'CASE';
+CAST:                                'CAST';
+CHANGE:                              'CHANGE';
+CHARACTER:                           'CHARACTER';
+CHECK:                               'CHECK';
+COLLATE:                             'COLLATE';
+COLUMN:                              'COLUMN';
+CONDITION:                           'CONDITION';
+CONSTRAINT:                          'CONSTRAINT';
+CONTINUE:                            'CONTINUE';
+CONVERT:                             'CONVERT';
+CREATE:                              'CREATE';
+CROSS:                               'CROSS';
+CURRENT:                             'CURRENT';
+CURRENT_ROLE:                        'CURRENT_ROLE';
+CURRENT_USER:                        'CURRENT_USER';
+CURSOR:                              'CURSOR';
+DATABASE:                            'DATABASE';
+DATABASES:                           'DATABASES';
+DECLARE:                             'DECLARE';
+DEFAULT:                             'DEFAULT';
+DELAYED:                             'DELAYED';
+DELETE:                              'DELETE';
+DESC:                                'DESC';
+DESCRIBE:                            'DESCRIBE';
+DETERMINISTIC:                       'DETERMINISTIC';
+DIAGNOSTICS:                         'DIAGNOSTICS';
+DISTINCT:                            'DISTINCT';
+DISTINCTROW:                         'DISTINCTROW';
+DROP:                                'DROP';
+EACH:                                'EACH';
+ELSE:                                'ELSE';
+ELSEIF:                              'ELSEIF';
+EMPTY:                               'EMPTY';
+ENCLOSED:                            'ENCLOSED';
+ENFORCED:                            'ENFORCED';
+ESCAPED:                             'ESCAPED';
+EXCEPT:                              'EXCEPT';
+EXISTS:                              'EXISTS';
+EXIT:                                'EXIT';
+EXPLAIN:                             'EXPLAIN';
+FALSE:                               'FALSE';
+FETCH:                               'FETCH';
+FOR:                                 'FOR';
+FORCE:                               'FORCE';
+FOREIGN:                             'FOREIGN';
+FROM:                                'FROM';
+FULLTEXT:                            'FULLTEXT';
+GENERATED:                           'GENERATED';
+GET:                                 'GET';
+GRANT:                               'GRANT';
+GROUP:                               'GROUP';
+HAVING:                              'HAVING';
+HIGH_PRIORITY:                       'HIGH_PRIORITY';
+HISTOGRAM:                           'HISTOGRAM';
+IF:                                  'IF';
+IGNORE:                              'IGNORE';
+IGNORED:                             'IGNORED';
+IN:                                  'IN';
+INDEX:                               'INDEX';
+INFILE:                              'INFILE';
+INNER:                               'INNER';
+INOUT:                               'INOUT';
+INSERT:                              'INSERT';
+INTERVAL:                            'INTERVAL';
+INTO:                                'INTO';
+IS:                                  'IS';
+ITERATE:                             'ITERATE';
+JOIN:                                'JOIN';
+KEY:                                 'KEY';
+KEYS:                                'KEYS';
+KILL:                                'KILL';
+LATERAL:                             'LATERAL';
+LEADING:                             'LEADING';
+LEAVE:                               'LEAVE';
+LEFT:                                'LEFT';
+LIKE:                                'LIKE';
+LIMIT:                               'LIMIT';
+LINEAR:                              'LINEAR';
+LINES:                               'LINES';
+LOAD:                                'LOAD';
+LOCK:                                'LOCK';
+LOCKED:                              'LOCKED';
+LOOP:                                'LOOP';
+LOW_PRIORITY:                        'LOW_PRIORITY';
+MASTER_BIND:                         'MASTER_BIND';
+MASTER_SSL_VERIFY_SERVER_CERT:       'MASTER_SSL_VERIFY_SERVER_CERT';
+MATCH:                               'MATCH';
+MAXVALUE:                            'MAXVALUE';
+MINVALUE:                            'MINVALUE';
+MODIFIES:                            'MODIFIES';
+NATURAL:                             'NATURAL';
+NOT:                                 'NOT';
+NO_WRITE_TO_BINLOG:                  'NO_WRITE_TO_BINLOG';
+NULL_LITERAL:                        'NULL';
+NUMBER:                              'NUMBER';
+ON:                                  'ON';
+OPTIMIZE:                            'OPTIMIZE';
+OPTION:                              'OPTION';
+OPTIONAL:                            'OPTIONAL';
+OPTIONALLY:                          'OPTIONALLY';
+OR:                                  'OR';
+ORDER:                               'ORDER';
+OUT:                                 'OUT';
+OUTER:                               'OUTER';
+OUTFILE:                             'OUTFILE';
+OVER:                                'OVER';
+PARTITION:                           'PARTITION';
+PRIMARY:                             'PRIMARY';
+PROCEDURE:                           'PROCEDURE';
+PURGE:                               'PURGE';
+RANGE:                               'RANGE';
+READ:                                'READ';
+READS:                               'READS';
+REFERENCES:                          'REFERENCES';
+REGEXP:                              'REGEXP';
+RELEASE:                             'RELEASE';
+RENAME:                              'RENAME';
+REPEAT:                              'REPEAT';
+REPLACE:                             'REPLACE';
+REQUIRE:                             'REQUIRE';
+RESIGNAL:                            'RESIGNAL';
+RESTRICT:                            'RESTRICT';
+RETAIN:                              'RETAIN';
+RETURN:                              'RETURN';
+REVOKE:                              'REVOKE';
+RIGHT:                               'RIGHT';
+RLIKE:                               'RLIKE';
+SCHEMA:                              'SCHEMA';
+SCHEMAS:                             'SCHEMAS';
+SELECT:                              'SELECT';
+SET:                                 'SET';
+SEPARATOR:                           'SEPARATOR';
+SHOW:                                'SHOW';
+SIGNAL:                              'SIGNAL';
+SKIP_:                               'SKIP';
+SKIP_QUERY_REWRITE:                  'SKIP_QUERY_REWRITE';
+SPATIAL:                             'SPATIAL';
+SQL:                                 'SQL';
+SQLEXCEPTION:                        'SQLEXCEPTION';
+SQLSTATE:                            'SQLSTATE';
+SQLWARNING:                          'SQLWARNING';
+SQL_BIG_RESULT:                      'SQL_BIG_RESULT';
+SQL_CALC_FOUND_ROWS:                 'SQL_CALC_FOUND_ROWS';
+SQL_SMALL_RESULT:                    'SQL_SMALL_RESULT';
+SSL:                                 'SSL';
+STACKED:                             'STACKED';
+STARTING:                            'STARTING';
+STATEMENT:                           'STATEMENT';
+STRAIGHT_JOIN:                       'STRAIGHT_JOIN';
+TABLE:                               'TABLE';
+TERMINATED:                          'TERMINATED';
+THEN:                                'THEN';
+TO:                                  'TO';
+TRAILING:                            'TRAILING';
+TRIGGER:                             'TRIGGER';
+TRUE:                                'TRUE';
+UNDO:                                'UNDO';
+UNION:                               'UNION';
+UNIQUE:                              'UNIQUE';
+UNLOCK:                              'UNLOCK';
+UNSIGNED:                            'UNSIGNED';
+UPDATE:                              'UPDATE';
+USAGE:                               'USAGE';
+USE:                                 'USE';
+USING:                               'USING';
+VALUES:                              'VALUES';
+WHEN:                                'WHEN';
+WHERE:                               'WHERE';
+WHILE:                               'WHILE';
+WITH:                                'WITH';
+WRITE:                               'WRITE';
+XOR:                                 'XOR';
+ZEROFILL:                            'ZEROFILL';
+
+// DATA TYPE Keywords
+
+TINYINT:                             'TINYINT';
+SMALLINT:                            'SMALLINT';
+MEDIUMINT:                           'MEDIUMINT';
+MIDDLEINT:                           'MIDDLEINT';
+INT:                                 'INT';
+INT1:                                'INT1';
+INT2:                                'INT2';
+INT3:                                'INT3';
+INT4:                                'INT4';
+INT8:                                'INT8';
+INTEGER:                             'INTEGER';
+BIGINT:                              'BIGINT';
+REAL:                                'REAL';
+DOUBLE:                              'DOUBLE';
+PRECISION:                           'PRECISION';
+FLOAT:                               'FLOAT';
+FLOAT4:                              'FLOAT4';
+FLOAT8:                              'FLOAT8';
+DECIMAL:                             'DECIMAL';
+DEC:                                 'DEC';
+NUMERIC:                             'NUMERIC';
+DATE:                                'DATE';
+TIME:                                'TIME';
+TIMESTAMP:                           'TIMESTAMP';
+DATETIME:                            'DATETIME';
+YEAR:                                'YEAR';
+CHAR:                                'CHAR';
+VARCHAR:                             'VARCHAR';
+NVARCHAR:                            'NVARCHAR';
+NATIONAL:                            'NATIONAL';
+BINARY:                              'BINARY';
+VARBINARY:                           'VARBINARY';
+TINYBLOB:                            'TINYBLOB';
+BLOB:                                'BLOB';
+MEDIUMBLOB:                          'MEDIUMBLOB';
+LONG:                                'LONG';
+LONGBLOB:                            'LONGBLOB';
+TINYTEXT:                            'TINYTEXT';
+TEXT:                                'TEXT';
+MEDIUMTEXT:                          'MEDIUMTEXT';
+LONGTEXT:                            'LONGTEXT';
+ENUM:                                'ENUM';
+VARYING:                             'VARYING';
+SERIAL:                              'SERIAL';
+
+
+// Interval type Keywords
+
+YEAR_MONTH:                          'YEAR_MONTH';
+DAY_HOUR:                            'DAY_HOUR';
+DAY_MINUTE:                          'DAY_MINUTE';
+DAY_SECOND:                          'DAY_SECOND';
+HOUR_MINUTE:                         'HOUR_MINUTE';
+HOUR_SECOND:                         'HOUR_SECOND';
+MINUTE_SECOND:                       'MINUTE_SECOND';
+SECOND_MICROSECOND:                  'SECOND_MICROSECOND';
+MINUTE_MICROSECOND:                  'MINUTE_MICROSECOND';
+HOUR_MICROSECOND:                    'HOUR_MICROSECOND';
+DAY_MICROSECOND:                     'DAY_MICROSECOND';
+
+// JSON keywords
+JSON_ARRAY:                          'JSON_ARRAY';
+JSON_ARRAYAGG:                       'JSON_ARRAYAGG';
+JSON_ARRAY_APPEND:                   'JSON_ARRAY_APPEND';
+JSON_ARRAY_INSERT:                   'JSON_ARRAY_INSERT';
+JSON_CONTAINS:                       'JSON_CONTAINS';
+JSON_CONTAINS_PATH:                  'JSON_CONTAINS_PATH';
+JSON_DEPTH:                          'JSON_DEPTH';
+JSON_EXTRACT:                        'JSON_EXTRACT';
+JSON_INSERT:                         'JSON_INSERT';
+JSON_KEYS:                           'JSON_KEYS';
+JSON_LENGTH:                         'JSON_LENGTH';
+JSON_MERGE:                          'JSON_MERGE';
+JSON_MERGE_PATCH:                    'JSON_MERGE_PATCH';
+JSON_MERGE_PRESERVE:                 'JSON_MERGE_PRESERVE';
+JSON_OBJECT:                         'JSON_OBJECT';
+JSON_OBJECTAGG:                      'JSON_OBJECTAGG';
+JSON_OVERLAPS:                       'JSON_OVERLAPS';
+JSON_PRETTY:                         'JSON_PRETTY';
+JSON_QUOTE:                          'JSON_QUOTE';
+JSON_REMOVE:                         'JSON_REMOVE';
+JSON_REPLACE:                        'JSON_REPLACE';
+JSON_SCHEMA_VALID:                   'JSON_SCHEMA_VALID';
+JSON_SCHEMA_VALIDATION_REPORT:       'JSON_SCHEMA_VALIDATION_REPORT';
+JSON_SEARCH:                         'JSON_SEARCH';
+JSON_SET:                            'JSON_SET';
+JSON_STORAGE_FREE:                   'JSON_STORAGE_FREE';
+JSON_STORAGE_SIZE:                   'JSON_STORAGE_SIZE';
+JSON_TABLE:                          'JSON_TABLE';
+JSON_TYPE:                           'JSON_TYPE';
+JSON_UNQUOTE:                        'JSON_UNQUOTE';
+JSON_VALID:                          'JSON_VALID';
+JSON_VALUE:                          'JSON_VALUE';
+NESTED:                              'NESTED';
+ORDINALITY:                          'ORDINALITY';
+PATH:                                'PATH';
+
+// Group function Keywords
+
+AVG:                                 'AVG';
+BIT_AND:                             'BIT_AND';
+BIT_OR:                              'BIT_OR';
+BIT_XOR:                             'BIT_XOR';
+COUNT:                               'COUNT';
+CUME_DIST:                           'CUME_DIST';
+DENSE_RANK:                          'DENSE_RANK';
+FIRST_VALUE:                         'FIRST_VALUE';
+GROUP_CONCAT:                        'GROUP_CONCAT';
+LAG:                                 'LAG';
+LAST_VALUE:                          'LAST_VALUE';
+LEAD:                                'LEAD';
+MAX:                                 'MAX';
+MIN:                                 'MIN';
+NTILE:                               'NTILE';
+NTH_VALUE:                           'NTH_VALUE';
+PERCENT_RANK:                        'PERCENT_RANK';
+RANK:                                'RANK';
+ROW_NUMBER:                          'ROW_NUMBER';
+STD:                                 'STD';
+STDDEV:                              'STDDEV';
+STDDEV_POP:                          'STDDEV_POP';
+STDDEV_SAMP:                         'STDDEV_SAMP';
+SUM:                                 'SUM';
+VAR_POP:                             'VAR_POP';
+VAR_SAMP:                            'VAR_SAMP';
+VARIANCE:                            'VARIANCE';
+
+// Common function Keywords
+
+CURRENT_DATE:                        'CURRENT_DATE';
+CURRENT_TIME:                        'CURRENT_TIME';
+CURRENT_TIMESTAMP:                   'CURRENT_TIMESTAMP';
+LOCALTIME:                           'LOCALTIME';
+CURDATE:                             'CURDATE';
+CURTIME:                             'CURTIME';
+DATE_ADD:                            'DATE_ADD';
+DATE_SUB:                            'DATE_SUB';
+EXTRACT:                             'EXTRACT';
+LOCALTIMESTAMP:                      'LOCALTIMESTAMP';
+NOW:                                 'NOW';
+POSITION:                            'POSITION';
+SUBSTR:                              'SUBSTR';
+SUBSTRING:                           'SUBSTRING';
+SYSDATE:                             'SYSDATE';
+TRIM:                                'TRIM';
+UTC_DATE:                            'UTC_DATE';
+UTC_TIME:                            'UTC_TIME';
+UTC_TIMESTAMP:                       'UTC_TIMESTAMP';
+
+// Keywords, but can be ID
+// Common Keywords, but can be ID
+
+ACCOUNT:                             'ACCOUNT';
+ACTION:                              'ACTION';
+AFTER:                               'AFTER';
+AGGREGATE:                           'AGGREGATE';
+ALGORITHM:                           'ALGORITHM';
+ANY:                                 'ANY';
+AT:                                  'AT';
+AUTHORS:                             'AUTHORS';
+AUTOCOMMIT:                          'AUTOCOMMIT';
+AUTOEXTEND_SIZE:                     'AUTOEXTEND_SIZE';
+AUTO_INCREMENT:                      'AUTO_INCREMENT';
+AVG_ROW_LENGTH:                      'AVG_ROW_LENGTH';
+BEGIN:                               'BEGIN';
+BINLOG:                              'BINLOG';
+BIT:                                 'BIT';
+BLOCK:                               'BLOCK';
+BOOL:                                'BOOL';
+BOOLEAN:                             'BOOLEAN';
+BTREE:                               'BTREE';
+CACHE:                               'CACHE';
+CASCADED:                            'CASCADED';
+CHAIN:                               'CHAIN';
+CHANGED:                             'CHANGED';
+CHANNEL:                             'CHANNEL';
+CHECKSUM:                            'CHECKSUM';
+PAGE_CHECKSUM:                       'PAGE_CHECKSUM';
+CIPHER:                              'CIPHER';
+CLASS_ORIGIN:                        'CLASS_ORIGIN';
+CLIENT:                              'CLIENT';
+CLOSE:                               'CLOSE';
+CLUSTERING:                          'CLUSTERING';
+COALESCE:                            'COALESCE';
+CODE:                                'CODE';
+COLUMNS:                             'COLUMNS';
+COLUMN_FORMAT:                       'COLUMN_FORMAT';
+COLUMN_NAME:                         'COLUMN_NAME';
+COMMENT:                             'COMMENT';
+COMMIT:                              'COMMIT';
+COMPACT:                             'COMPACT';
+COMPLETION:                          'COMPLETION';
+COMPRESSED:                          'COMPRESSED';
+COMPRESSION:                         'COMPRESSION' | QUOTE_SYMB? 'COMPRESSION' QUOTE_SYMB?;
+CONCURRENT:                          'CONCURRENT';
+CONNECT:                             'CONNECT';
+CONNECTION:                          'CONNECTION';
+CONSISTENT:                          'CONSISTENT';
+CONSTRAINT_CATALOG:                  'CONSTRAINT_CATALOG';
+CONSTRAINT_SCHEMA:                   'CONSTRAINT_SCHEMA';
+CONSTRAINT_NAME:                     'CONSTRAINT_NAME';
+CONTAINS:                            'CONTAINS';
+CONTEXT:                             'CONTEXT';
+CONTRIBUTORS:                        'CONTRIBUTORS';
+COPY:                                'COPY';
+CPU:                                 'CPU';
+CYCLE:                               'CYCLE';
+CURSOR_NAME:                         'CURSOR_NAME';
+DATA:                                'DATA';
+DATAFILE:                            'DATAFILE';
+DEALLOCATE:                          'DEALLOCATE';
+DEFAULT_AUTH:                        'DEFAULT_AUTH';
+DEFINER:                             'DEFINER';
+DELAY_KEY_WRITE:                     'DELAY_KEY_WRITE';
+DES_KEY_FILE:                        'DES_KEY_FILE';
+DIRECTORY:                           'DIRECTORY';
+DISABLE:                             'DISABLE';
+DISCARD:                             'DISCARD';
+DISK:                                'DISK';
+DO:                                  'DO';
+DUMPFILE:                            'DUMPFILE';
+DUPLICATE:                           'DUPLICATE';
+DYNAMIC:                             'DYNAMIC';
+ENABLE:                              'ENABLE';
+ENCRYPTED:                           'ENCRYPTED';
+ENCRYPTION:                          'ENCRYPTION';
+ENCRYPTION_KEY_ID:                   'ENCRYPTION_KEY_ID';
+END:                                 'END';
+ENDS:                                'ENDS';
+ENGINE:                              'ENGINE';
+ENGINES:                             'ENGINES';
+ERROR:                               'ERROR';
+ERRORS:                              'ERRORS';
+ESCAPE:                              'ESCAPE';
+EVEN:                                'EVEN';
+EVENT:                               'EVENT';
+EVENTS:                              'EVENTS';
+EVERY:                               'EVERY';
+EXCHANGE:                            'EXCHANGE';
+EXCLUSIVE:                           'EXCLUSIVE';
+EXPIRE:                              'EXPIRE';
+EXPORT:                              'EXPORT';
+EXTENDED:                            'EXTENDED';
+EXTENT_SIZE:                         'EXTENT_SIZE';
+FAILED_LOGIN_ATTEMPTS:               'FAILED_LOGIN_ATTEMPTS';
+FAST:                                'FAST';
+FAULTS:                              'FAULTS';
+FIELDS:                              'FIELDS';
+FILE_BLOCK_SIZE:                     'FILE_BLOCK_SIZE';
+FILTER:                              'FILTER';
+FIRST:                               'FIRST';
+FIXED:                               'FIXED';
+FLUSH:                               'FLUSH';
+FOLLOWING:                           'FOLLOWING';
+FOLLOWS:                             'FOLLOWS';
+FOUND:                               'FOUND';
+FULL:                                'FULL';
+FUNCTION:                            'FUNCTION';
+GENERAL:                             'GENERAL';
+GLOBAL:                              'GLOBAL';
+GRANTS:                              'GRANTS';
+GROUP_REPLICATION:                   'GROUP_REPLICATION';
+HANDLER:                             'HANDLER';
+HASH:                                'HASH';
+HELP:                                'HELP';
+HISTORY:                             'HISTORY';
+HOST:                                'HOST';
+HOSTS:                               'HOSTS';
+IDENTIFIED:                          'IDENTIFIED';
+IGNORE_SERVER_IDS:                   'IGNORE_SERVER_IDS';
+IMPORT:                              'IMPORT';
+INCREMENT:                           'INCREMENT';
+INDEXES:                             'INDEXES';
+INITIAL_SIZE:                        'INITIAL_SIZE';
+INPLACE:                             'INPLACE';
+INSERT_METHOD:                       'INSERT_METHOD';
+INSTALL:                             'INSTALL';
+INSTANCE:                            'INSTANCE';
+INSTANT:                             'INSTANT';
+INVISIBLE:                           'INVISIBLE';
+INVOKER:                             'INVOKER';
+IO:                                  'IO';
+IO_THREAD:                           'IO_THREAD';
+IPC:                                 'IPC';
+ISOLATION:                           'ISOLATION';
+ISSUER:                              'ISSUER';
+JSON:                                'JSON';
+KEY_BLOCK_SIZE:                      'KEY_BLOCK_SIZE';
+LANGUAGE:                            'LANGUAGE';
+LAST:                                'LAST';
+LEAVES:                              'LEAVES';
+LESS:                                'LESS';
+LEVEL:                               'LEVEL';
+LIST:                                'LIST';
+LOCAL:                               'LOCAL';
+LOGFILE:                             'LOGFILE';
+LOGS:                                'LOGS';
+MASTER:                              'MASTER';
+MASTER_AUTO_POSITION:                'MASTER_AUTO_POSITION';
+MASTER_CONNECT_RETRY:                'MASTER_CONNECT_RETRY';
+MASTER_DELAY:                        'MASTER_DELAY';
+MASTER_HEARTBEAT_PERIOD:             'MASTER_HEARTBEAT_PERIOD';
+MASTER_HOST:                         'MASTER_HOST';
+MASTER_LOG_FILE:                     'MASTER_LOG_FILE';
+MASTER_LOG_POS:                      'MASTER_LOG_POS';
+MASTER_PASSWORD:                     'MASTER_PASSWORD';
+MASTER_PORT:                         'MASTER_PORT';
+MASTER_RETRY_COUNT:                  'MASTER_RETRY_COUNT';
+MASTER_SSL:                          'MASTER_SSL';
+MASTER_SSL_CA:                       'MASTER_SSL_CA';
+MASTER_SSL_CAPATH:                   'MASTER_SSL_CAPATH';
+MASTER_SSL_CERT:                     'MASTER_SSL_CERT';
+MASTER_SSL_CIPHER:                   'MASTER_SSL_CIPHER';
+MASTER_SSL_CRL:                      'MASTER_SSL_CRL';
+MASTER_SSL_CRLPATH:                  'MASTER_SSL_CRLPATH';
+MASTER_SSL_KEY:                      'MASTER_SSL_KEY';
+MASTER_TLS_VERSION:                  'MASTER_TLS_VERSION';
+MASTER_USER:                         'MASTER_USER';
+MAX_CONNECTIONS_PER_HOUR:            'MAX_CONNECTIONS_PER_HOUR';
+MAX_QUERIES_PER_HOUR:                'MAX_QUERIES_PER_HOUR';
+MAX_ROWS:                            'MAX_ROWS';
+MAX_SIZE:                            'MAX_SIZE';
+MAX_UPDATES_PER_HOUR:                'MAX_UPDATES_PER_HOUR';
+MAX_USER_CONNECTIONS:                'MAX_USER_CONNECTIONS';
+MEDIUM:                              'MEDIUM';
+MEMBER:                              'MEMBER';
+MERGE:                               'MERGE';
+MESSAGE_TEXT:                        'MESSAGE_TEXT';
+MID:                                 'MID';
+MIGRATE:                             'MIGRATE';
+MIN_ROWS:                            'MIN_ROWS';
+MODE:                                'MODE';
+MODIFY:                              'MODIFY';
+MUTEX:                               'MUTEX';
+MYSQL:                               'MYSQL';
+MYSQL_ERRNO:                         'MYSQL_ERRNO';
+NAME:                                'NAME';
+NAMES:                               'NAMES';
+NCHAR:                               'NCHAR';
+NEVER:                               'NEVER';
+NEXT:                                'NEXT';
+NO:                                  'NO';
+NOCACHE:                             'NOCACHE';
+NOCOPY:                              'NOCOPY';
+NOCYCLE:                             'NOCYCLE';
+NOMAXVALUE:                          'NOMAXVALUE';
+NOMINVALUE:                          'NOMINVALUE';
+NOWAIT:                              'NOWAIT';
+NODEGROUP:                           'NODEGROUP';
+NONE:                                'NONE';
+ODBC:                                'ODBC';
+OFFLINE:                             'OFFLINE';
+OFFSET:                              'OFFSET';
+OF:                                  'OF';
+OJ:                                  'OJ';
+OLD_PASSWORD:                        'OLD_PASSWORD';
+ONE:                                 'ONE';
+ONLINE:                              'ONLINE';
+ONLY:                                'ONLY';
+OPEN:                                'OPEN';
+OPTIMIZER_COSTS:                     'OPTIMIZER_COSTS';
+OPTIONS:                             'OPTIONS';
+OWNER:                               'OWNER';
+PACK_KEYS:                           'PACK_KEYS';
+PAGE:                                'PAGE';
+PAGE_COMPRESSED:                     'PAGE_COMPRESSED';
+PAGE_COMPRESSION_LEVEL:              'PAGE_COMPRESSION_LEVEL';
+PARSER:                              'PARSER';
+PARTIAL:                             'PARTIAL';
+PARTITIONING:                        'PARTITIONING';
+PARTITIONS:                          'PARTITIONS';
+PASSWORD:                            'PASSWORD';
+PASSWORD_LOCK_TIME:                  'PASSWORD_LOCK_TIME';
+PHASE:                               'PHASE';
+PLUGIN:                              'PLUGIN';
+PLUGIN_DIR:                          'PLUGIN_DIR';
+PLUGINS:                             'PLUGINS';
+PORT:                                'PORT';
+PRECEDES:                            'PRECEDES';
+PRECEDING:                           'PRECEDING';
+PREPARE:                             'PREPARE';
+PRESERVE:                            'PRESERVE';
+PREV:                                'PREV';
+PROCESSLIST:                         'PROCESSLIST';
+PROFILE:                             'PROFILE';
+PROFILES:                            'PROFILES';
+PROXY:                               'PROXY';
+QUERY:                               'QUERY';
+QUICK:                               'QUICK';
+REBUILD:                             'REBUILD';
+RECOVER:                             'RECOVER';
+RECURSIVE:                           'RECURSIVE';
+REDO_BUFFER_SIZE:                    'REDO_BUFFER_SIZE';
+REDUNDANT:                           'REDUNDANT';
+RELAY:                               'RELAY';
+RELAY_LOG_FILE:                      'RELAY_LOG_FILE';
+RELAY_LOG_POS:                       'RELAY_LOG_POS';
+RELAYLOG:                            'RELAYLOG';
+REMOVE:                              'REMOVE';
+REORGANIZE:                          'REORGANIZE';
+REPAIR:                              'REPAIR';
+REPLICATE_DO_DB:                     'REPLICATE_DO_DB';
+REPLICATE_DO_TABLE:                  'REPLICATE_DO_TABLE';
+REPLICATE_IGNORE_DB:                 'REPLICATE_IGNORE_DB';
+REPLICATE_IGNORE_TABLE:              'REPLICATE_IGNORE_TABLE';
+REPLICATE_REWRITE_DB:                'REPLICATE_REWRITE_DB';
+REPLICATE_WILD_DO_TABLE:             'REPLICATE_WILD_DO_TABLE';
+REPLICATE_WILD_IGNORE_TABLE:         'REPLICATE_WILD_IGNORE_TABLE';
+REPLICATION:                         'REPLICATION';
+RESET:                               'RESET';
+RESTART:                             'RESTART';
+RESUME:                              'RESUME';
+RETURNED_SQLSTATE:                   'RETURNED_SQLSTATE';
+RETURNING:                           'RETURNING';
+RETURNS:                             'RETURNS';
+REUSE:                               'REUSE';
+ROLE:                                'ROLE';
+ROLLBACK:                            'ROLLBACK';
+ROLLUP:                              'ROLLUP';
+ROTATE:                              'ROTATE';
+ROW:                                 'ROW';
+ROWS:                                'ROWS';
+ROW_FORMAT:                          'ROW_FORMAT';
+RTREE:                               'RTREE';
+SAVEPOINT:                           'SAVEPOINT';
+SCHEDULE:                            'SCHEDULE';
+SECURITY:                            'SECURITY';
+SEQUENCE:                            'SEQUENCE';
+SERVER:                              'SERVER';
+SESSION:                             'SESSION';
+SHARE:                               'SHARE';
+SHARED:                              'SHARED';
+SIGNED:                              'SIGNED';
+SIMPLE:                              'SIMPLE';
+SLAVE:                               'SLAVE';
+SLOW:                                'SLOW';
+SNAPSHOT:                            'SNAPSHOT';
+SOCKET:                              'SOCKET';
+SOME:                                'SOME';
+SONAME:                              'SONAME';
+SOUNDS:                              'SOUNDS';
+SOURCE:                              'SOURCE';
+SQL_AFTER_GTIDS:                     'SQL_AFTER_GTIDS';
+SQL_AFTER_MTS_GAPS:                  'SQL_AFTER_MTS_GAPS';
+SQL_BEFORE_GTIDS:                    'SQL_BEFORE_GTIDS';
+SQL_BUFFER_RESULT:                   'SQL_BUFFER_RESULT';
+SQL_CACHE:                           'SQL_CACHE';
+SQL_NO_CACHE:                        'SQL_NO_CACHE';
+SQL_THREAD:                          'SQL_THREAD';
+START:                               'START';
+STARTS:                              'STARTS';
+STATS_AUTO_RECALC:                   'STATS_AUTO_RECALC';
+STATS_PERSISTENT:                    'STATS_PERSISTENT';
+STATS_SAMPLE_PAGES:                  'STATS_SAMPLE_PAGES';
+STATUS:                              'STATUS';
+STOP:                                'STOP';
+STORAGE:                             'STORAGE';
+STORED:                              'STORED';
+STRING:                              'STRING';
+SUBCLASS_ORIGIN:                     'SUBCLASS_ORIGIN';
+SUBJECT:                             'SUBJECT';
+SUBPARTITION:                        'SUBPARTITION';
+SUBPARTITIONS:                       'SUBPARTITIONS';
+SUSPEND:                             'SUSPEND';
+SWAPS:                               'SWAPS';
+SWITCHES:                            'SWITCHES';
+TABLE_NAME:                          'TABLE_NAME';
+TABLESPACE:                          'TABLESPACE';
+TABLE_TYPE:                          'TABLE_TYPE';
+TEMPORARY:                           'TEMPORARY';
+TEMPTABLE:                           'TEMPTABLE';
+THAN:                                'THAN';
+TRADITIONAL:                         'TRADITIONAL';
+TRANSACTION:                         'TRANSACTION';
+TRANSACTIONAL:                       'TRANSACTIONAL';
+TRIGGERS:                            'TRIGGERS';
+TRUNCATE:                            'TRUNCATE';
+UNBOUNDED:                           'UNBOUNDED';
+UNDEFINED:                           'UNDEFINED';
+UNDOFILE:                            'UNDOFILE';
+UNDO_BUFFER_SIZE:                    'UNDO_BUFFER_SIZE';
+UNINSTALL:                           'UNINSTALL';
+UNKNOWN:                             'UNKNOWN';
+UNTIL:                               'UNTIL';
+UPGRADE:                             'UPGRADE';
+USER:                                'USER';
+USE_FRM:                             'USE_FRM';
+USER_RESOURCES:                      'USER_RESOURCES';
+VALIDATION:                          'VALIDATION';
+VALUE:                               'VALUE';
+VARIABLES:                           'VARIABLES';
+VIEW:                                'VIEW';
+VIRTUAL:                             'VIRTUAL';
+VISIBLE:                             'VISIBLE';
+WAIT:                                'WAIT';
+WARNINGS:                            'WARNINGS';
+WINDOW:                              'WINDOW';
+WITHOUT:                             'WITHOUT';
+WORK:                                'WORK';
+WRAPPER:                             'WRAPPER';
+X509:                                'X509';
+XA:                                  'XA';
+XML:                                 'XML';
+YES:                                 'YES';
+
+// Date format Keywords
+
+EUR:                                 'EUR';
+USA:                                 'USA';
+JIS:                                 'JIS';
+ISO:                                 'ISO';
+INTERNAL:                            'INTERNAL';
+
+
+// Interval type Keywords
+
+QUARTER:                             'QUARTER';
+MONTH:                               'MONTH';
+DAY:                                 'DAY';
+HOUR:                                'HOUR';
+MINUTE:                              'MINUTE';
+WEEK:                                'WEEK';
+SECOND:                              'SECOND';
+MICROSECOND:                         'MICROSECOND';
+
+
+// PRIVILEGES
+
+ADMIN:                               'ADMIN';
+APPLICATION_PASSWORD_ADMIN:          'APPLICATION_PASSWORD_ADMIN';
+AUDIT_ABORT_EXEMPT:                  'AUDIT_ABORT_EXEMPT';
+AUDIT_ADMIN:                         'AUDIT_ADMIN';
+AUTHENTICATION_POLICY_ADMIN:         'AUTHENTICATION_POLICY_ADMIN';
+BACKUP_ADMIN:                        'BACKUP_ADMIN';
+BINLOG_ADMIN:                        'BINLOG_ADMIN';
+BINLOG_ENCRYPTION_ADMIN:             'BINLOG_ENCRYPTION_ADMIN';
+CLONE_ADMIN:                         'CLONE_ADMIN';
+CONNECTION_ADMIN:                    'CONNECTION_ADMIN';
+ENCRYPTION_KEY_ADMIN:                'ENCRYPTION_KEY_ADMIN';
+EXECUTE:                             'EXECUTE';
+FILE:                                'FILE';
+FIREWALL_ADMIN:                      'FIREWALL_ADMIN';
+FIREWALL_EXEMPT:                     'FIREWALL_EXEMPT';
+FIREWALL_USER:                       'FIREWALL_USER';
+FLUSH_OPTIMIZER_COSTS:               'FLUSH_OPTIMIZER_COSTS';
+FLUSH_STATUS:                        'FLUSH_STATUS';
+FLUSH_TABLES:                        'FLUSH_TABLES';
+FLUSH_USER_RESOURCES:                'FLUSH_USER_RESOURCES';
+GROUP_REPLICATION_ADMIN:             'GROUP_REPLICATION_ADMIN';
+INNODB_REDO_LOG_ARCHIVE:             'INNODB_REDO_LOG_ARCHIVE';
+INNODB_REDO_LOG_ENABLE:              'INNODB_REDO_LOG_ENABLE';
+INVOKE:                              'INVOKE';
+LAMBDA:                              'LAMBDA';
+NDB_STORED_USER:                     'NDB_STORED_USER';
+PASSWORDLESS_USER_ADMIN:             'PASSWORDLESS_USER_ADMIN';
+PERSIST_RO_VARIABLES_ADMIN:          'PERSIST_RO_VARIABLES_ADMIN';
+PRIVILEGES:                          'PRIVILEGES';
+PROCESS:                             'PROCESS';
+RELOAD:                              'RELOAD';
+REPLICATION_APPLIER:                 'REPLICATION_APPLIER';
+REPLICATION_SLAVE_ADMIN:             'REPLICATION_SLAVE_ADMIN';
+RESOURCE_GROUP_ADMIN:                'RESOURCE_GROUP_ADMIN';
+RESOURCE_GROUP_USER:                 'RESOURCE_GROUP_USER';
+ROLE_ADMIN:                          'ROLE_ADMIN';
+ROUTINE:                             'ROUTINE';
+S3:                                  'S3';
+SERVICE_CONNECTION_ADMIN:            'SERVICE_CONNECTION_ADMIN';
+SESSION_VARIABLES_ADMIN:             QUOTE_SYMB? 'SESSION_VARIABLES_ADMIN' QUOTE_SYMB?;
+SET_USER_ID:                         'SET_USER_ID';
+SHOW_ROUTINE:                        'SHOW_ROUTINE';
+SHUTDOWN:                            'SHUTDOWN';
+SUPER:                               'SUPER';
+SYSTEM_VARIABLES_ADMIN:              'SYSTEM_VARIABLES_ADMIN';
+TABLES:                              'TABLES';
+TABLE_ENCRYPTION_ADMIN:              'TABLE_ENCRYPTION_ADMIN';
+VERSION_TOKEN_ADMIN:                 'VERSION_TOKEN_ADMIN';
+XA_RECOVER_ADMIN:                    'XA_RECOVER_ADMIN';
+
+
+// Charsets
+
+ARMSCII8:                            'ARMSCII8';
+ASCII:                               'ASCII';
+BIG5:                                'BIG5';
+CP1250:                              'CP1250';
+CP1251:                              'CP1251';
+CP1256:                              'CP1256';
+CP1257:                              'CP1257';
+CP850:                               'CP850';
+CP852:                               'CP852';
+CP866:                               'CP866';
+CP932:                               'CP932';
+DEC8:                                'DEC8';
+EUCJPMS:                             'EUCJPMS';
+EUCKR:                               'EUCKR';
+GB18030:                             'GB18030';
+GB2312:                              'GB2312';
+GBK:                                 'GBK';
+GEOSTD8:                             'GEOSTD8';
+GREEK:                               'GREEK';
+HEBREW:                              'HEBREW';
+HP8:                                 'HP8';
+KEYBCS2:                             'KEYBCS2';
+KOI8R:                               'KOI8R';
+KOI8U:                               'KOI8U';
+LATIN1:                              'LATIN1';
+LATIN2:                              'LATIN2';
+LATIN5:                              'LATIN5';
+LATIN7:                              'LATIN7';
+MACCE:                               'MACCE';
+MACROMAN:                            'MACROMAN';
+SJIS:                                'SJIS';
+SWE7:                                'SWE7';
+TIS620:                              'TIS620';
+UCS2:                                'UCS2';
+UJIS:                                'UJIS';
+UTF16:                               'UTF16';
+UTF16LE:                             'UTF16LE';
+UTF32:                               'UTF32';
+UTF8:                                'UTF8';
+UTF8MB3:                             'UTF8MB3';
+UTF8MB4:                             'UTF8MB4';
+
+
+// DB Engines
+
+ARCHIVE:                             'ARCHIVE';
+BLACKHOLE:                           'BLACKHOLE';
+CSV:                                 'CSV';
+FEDERATED:                           'FEDERATED';
+INNODB:                              'INNODB';
+MEMORY:                              'MEMORY';
+MRG_MYISAM:                          'MRG_MYISAM';
+MYISAM:                              'MYISAM';
+NDB:                                 'NDB';
+NDBCLUSTER:                          'NDBCLUSTER';
+PERFORMANCE_SCHEMA:                  'PERFORMANCE_SCHEMA';
+TOKUDB:                              'TOKUDB';
+
+
+// Transaction Levels
+
+REPEATABLE:                          'REPEATABLE';
+COMMITTED:                           'COMMITTED';
+UNCOMMITTED:                         'UNCOMMITTED';
+SERIALIZABLE:                        'SERIALIZABLE';
+
+
+// Spatial data types
+
+GEOMETRYCOLLECTION:                  'GEOMETRYCOLLECTION';
+GEOMCOLLECTION:                      'GEOMCOLLECTION';
+GEOMETRY:                            'GEOMETRY';
+LINESTRING:                          'LINESTRING';
+MULTILINESTRING:                     'MULTILINESTRING';
+MULTIPOINT:                          'MULTIPOINT';
+MULTIPOLYGON:                        'MULTIPOLYGON';
+POINT:                               'POINT';
+POLYGON:                             'POLYGON';
+
+
+// Common function names
+
+ABS:                                 'ABS';
+ACOS:                                'ACOS';
+ADDDATE:                             'ADDDATE';
+ADDTIME:                             'ADDTIME';
+AES_DECRYPT:                         'AES_DECRYPT';
+AES_ENCRYPT:                         'AES_ENCRYPT';
+AREA:                                'AREA';
+ASBINARY:                            'ASBINARY';
+ASIN:                                'ASIN';
+ASTEXT:                              'ASTEXT';
+ASWKB:                               'ASWKB';
+ASWKT:                               'ASWKT';
+ASYMMETRIC_DECRYPT:                  'ASYMMETRIC_DECRYPT';
+ASYMMETRIC_DERIVE:                   'ASYMMETRIC_DERIVE';
+ASYMMETRIC_ENCRYPT:                  'ASYMMETRIC_ENCRYPT';
+ASYMMETRIC_SIGN:                     'ASYMMETRIC_SIGN';
+ASYMMETRIC_VERIFY:                   'ASYMMETRIC_VERIFY';
+ATAN:                                'ATAN';
+ATAN2:                               'ATAN2';
+BENCHMARK:                           'BENCHMARK';
+BIN:                                 'BIN';
+BIT_COUNT:                           'BIT_COUNT';
+BIT_LENGTH:                          'BIT_LENGTH';
+BUFFER:                              'BUFFER';
+CATALOG_NAME:                        'CATALOG_NAME';
+CEIL:                                'CEIL';
+CEILING:                             'CEILING';
+CENTROID:                            'CENTROID';
+CHARACTER_LENGTH:                    'CHARACTER_LENGTH';
+CHARSET:                             'CHARSET';
+CHAR_LENGTH:                         'CHAR_LENGTH';
+COERCIBILITY:                        'COERCIBILITY';
+COLLATION:                           'COLLATION';
+COMPRESS:                            'COMPRESS';
+CONCAT:                              'CONCAT';
+CONCAT_WS:                           'CONCAT_WS';
+CONNECTION_ID:                       'CONNECTION_ID';
+CONV:                                'CONV';
+CONVERT_TZ:                          'CONVERT_TZ';
+COS:                                 'COS';
+COT:                                 'COT';
+CRC32:                               'CRC32';
+CREATE_ASYMMETRIC_PRIV_KEY:          'CREATE_ASYMMETRIC_PRIV_KEY';
+CREATE_ASYMMETRIC_PUB_KEY:           'CREATE_ASYMMETRIC_PUB_KEY';
+CREATE_DH_PARAMETERS:                'CREATE_DH_PARAMETERS';
+CREATE_DIGEST:                       'CREATE_DIGEST';
+CROSSES:                             'CROSSES';
+DATEDIFF:                            'DATEDIFF';
+DATE_FORMAT:                         'DATE_FORMAT';
+DAYNAME:                             'DAYNAME';
+DAYOFMONTH:                          'DAYOFMONTH';
+DAYOFWEEK:                           'DAYOFWEEK';
+DAYOFYEAR:                           'DAYOFYEAR';
+DECODE:                              'DECODE';
+DEGREES:                             'DEGREES';
+DES_DECRYPT:                         'DES_DECRYPT';
+DES_ENCRYPT:                         'DES_ENCRYPT';
+DIMENSION:                           'DIMENSION';
+DISJOINT:                            'DISJOINT';
+ELT:                                 'ELT';
+ENCODE:                              'ENCODE';
+ENCRYPT:                             'ENCRYPT';
+ENDPOINT:                            'ENDPOINT';
+ENGINE_ATTRIBUTE:                    'ENGINE_ATTRIBUTE';
+ENVELOPE:                            'ENVELOPE';
+EQUALS:                              'EQUALS';
+EXP:                                 'EXP';
+EXPORT_SET:                          'EXPORT_SET';
+EXTERIORRING:                        'EXTERIORRING';
+EXTRACTVALUE:                        'EXTRACTVALUE';
+FIELD:                               'FIELD';
+FIND_IN_SET:                         'FIND_IN_SET';
+FLOOR:                               'FLOOR';
+FORMAT:                              'FORMAT';
+FOUND_ROWS:                          'FOUND_ROWS';
+FROM_BASE64:                         'FROM_BASE64';
+FROM_DAYS:                           'FROM_DAYS';
+FROM_UNIXTIME:                       'FROM_UNIXTIME';
+GEOMCOLLFROMTEXT:                    'GEOMCOLLFROMTEXT';
+GEOMCOLLFROMWKB:                     'GEOMCOLLFROMWKB';
+GEOMETRYCOLLECTIONFROMTEXT:          'GEOMETRYCOLLECTIONFROMTEXT';
+GEOMETRYCOLLECTIONFROMWKB:           'GEOMETRYCOLLECTIONFROMWKB';
+GEOMETRYFROMTEXT:                    'GEOMETRYFROMTEXT';
+GEOMETRYFROMWKB:                     'GEOMETRYFROMWKB';
+GEOMETRYN:                           'GEOMETRYN';
+GEOMETRYTYPE:                        'GEOMETRYTYPE';
+GEOMFROMTEXT:                        'GEOMFROMTEXT';
+GEOMFROMWKB:                         'GEOMFROMWKB';
+GET_FORMAT:                          'GET_FORMAT';
+GET_LOCK:                            'GET_LOCK';
+GLENGTH:                             'GLENGTH';
+GREATEST:                            'GREATEST';
+GTID_SUBSET:                         'GTID_SUBSET';
+GTID_SUBTRACT:                       'GTID_SUBTRACT';
+HEX:                                 'HEX';
+IFNULL:                              'IFNULL';
+INET6_ATON:                          'INET6_ATON';
+INET6_NTOA:                          'INET6_NTOA';
+INET_ATON:                           'INET_ATON';
+INET_NTOA:                           'INET_NTOA';
+INSTR:                               'INSTR';
+INTERIORRINGN:                       'INTERIORRINGN';
+INTERSECTS:                          'INTERSECTS';
+ISCLOSED:                            'ISCLOSED';
+ISEMPTY:                             'ISEMPTY';
+ISNULL:                              'ISNULL';
+ISSIMPLE:                            'ISSIMPLE';
+IS_FREE_LOCK:                        'IS_FREE_LOCK';
+IS_IPV4:                             'IS_IPV4';
+IS_IPV4_COMPAT:                      'IS_IPV4_COMPAT';
+IS_IPV4_MAPPED:                      'IS_IPV4_MAPPED';
+IS_IPV6:                             'IS_IPV6';
+IS_USED_LOCK:                        'IS_USED_LOCK';
+LAST_INSERT_ID:                      'LAST_INSERT_ID';
+LCASE:                               'LCASE';
+LEAST:                               'LEAST';
+LENGTH:                              'LENGTH';
+LINEFROMTEXT:                        'LINEFROMTEXT';
+LINEFROMWKB:                         'LINEFROMWKB';
+LINESTRINGFROMTEXT:                  'LINESTRINGFROMTEXT';
+LINESTRINGFROMWKB:                   'LINESTRINGFROMWKB';
+LN:                                  'LN';
+LOAD_FILE:                           'LOAD_FILE';
+LOCATE:                              'LOCATE';
+LOG:                                 'LOG';
+LOG10:                               'LOG10';
+LOG2:                                'LOG2';
+LOWER:                               'LOWER';
+LPAD:                                'LPAD';
+LTRIM:                               'LTRIM';
+MAKEDATE:                            'MAKEDATE';
+MAKETIME:                            'MAKETIME';
+MAKE_SET:                            'MAKE_SET';
+MASTER_POS_WAIT:                     'MASTER_POS_WAIT';
+MBRCONTAINS:                         'MBRCONTAINS';
+MBRDISJOINT:                         'MBRDISJOINT';
+MBREQUAL:                            'MBREQUAL';
+MBRINTERSECTS:                       'MBRINTERSECTS';
+MBROVERLAPS:                         'MBROVERLAPS';
+MBRTOUCHES:                          'MBRTOUCHES';
+MBRWITHIN:                           'MBRWITHIN';
+MD5:                                 'MD5';
+MLINEFROMTEXT:                       'MLINEFROMTEXT';
+MLINEFROMWKB:                        'MLINEFROMWKB';
+MONTHNAME:                           'MONTHNAME';
+MPOINTFROMTEXT:                      'MPOINTFROMTEXT';
+MPOINTFROMWKB:                       'MPOINTFROMWKB';
+MPOLYFROMTEXT:                       'MPOLYFROMTEXT';
+MPOLYFROMWKB:                        'MPOLYFROMWKB';
+MULTILINESTRINGFROMTEXT:             'MULTILINESTRINGFROMTEXT';
+MULTILINESTRINGFROMWKB:              'MULTILINESTRINGFROMWKB';
+MULTIPOINTFROMTEXT:                  'MULTIPOINTFROMTEXT';
+MULTIPOINTFROMWKB:                   'MULTIPOINTFROMWKB';
+MULTIPOLYGONFROMTEXT:                'MULTIPOLYGONFROMTEXT';
+MULTIPOLYGONFROMWKB:                 'MULTIPOLYGONFROMWKB';
+NAME_CONST:                          'NAME_CONST';
+NULLIF:                              'NULLIF';
+NUMGEOMETRIES:                       'NUMGEOMETRIES';
+NUMINTERIORRINGS:                    'NUMINTERIORRINGS';
+NUMPOINTS:                           'NUMPOINTS';
+OCT:                                 'OCT';
+OCTET_LENGTH:                        'OCTET_LENGTH';
+ORD:                                 'ORD';
+OVERLAPS:                            'OVERLAPS';
+PERIOD_ADD:                          'PERIOD_ADD';
+PERIOD_DIFF:                         'PERIOD_DIFF';
+PI:                                  'PI';
+POINTFROMTEXT:                       'POINTFROMTEXT';
+POINTFROMWKB:                        'POINTFROMWKB';
+POINTN:                              'POINTN';
+POLYFROMTEXT:                        'POLYFROMTEXT';
+POLYFROMWKB:                         'POLYFROMWKB';
+POLYGONFROMTEXT:                     'POLYGONFROMTEXT';
+POLYGONFROMWKB:                      'POLYGONFROMWKB';
+POW:                                 'POW';
+POWER:                               'POWER';
+QUOTE:                               'QUOTE';
+RADIANS:                             'RADIANS';
+RAND:                                'RAND';
+RANDOM_BYTES:                        'RANDOM_BYTES';
+RELEASE_LOCK:                        'RELEASE_LOCK';
+REVERSE:                             'REVERSE';
+ROUND:                               'ROUND';
+ROW_COUNT:                           'ROW_COUNT';
+RPAD:                                'RPAD';
+RTRIM:                               'RTRIM';
+SEC_TO_TIME:                         'SEC_TO_TIME';
+SECONDARY_ENGINE_ATTRIBUTE:          'SECONDARY_ENGINE_ATTRIBUTE';
+SESSION_USER:                        'SESSION_USER';
+SHA:                                 'SHA';
+SHA1:                                'SHA1';
+SHA2:                                'SHA2';
+SCHEMA_NAME:                         'SCHEMA_NAME';
+SIGN:                                'SIGN';
+SIN:                                 'SIN';
+SLEEP:                               'SLEEP';
+SOUNDEX:                             'SOUNDEX';
+SQL_THREAD_WAIT_AFTER_GTIDS:         'SQL_THREAD_WAIT_AFTER_GTIDS';
+SQRT:                                'SQRT';
+SRID:                                'SRID';
+STARTPOINT:                          'STARTPOINT';
+STRCMP:                              'STRCMP';
+STR_TO_DATE:                         'STR_TO_DATE';
+ST_AREA:                             'ST_AREA';
+ST_ASBINARY:                         'ST_ASBINARY';
+ST_ASTEXT:                           'ST_ASTEXT';
+ST_ASWKB:                            'ST_ASWKB';
+ST_ASWKT:                            'ST_ASWKT';
+ST_BUFFER:                           'ST_BUFFER';
+ST_CENTROID:                         'ST_CENTROID';
+ST_CONTAINS:                         'ST_CONTAINS';
+ST_CROSSES:                          'ST_CROSSES';
+ST_DIFFERENCE:                       'ST_DIFFERENCE';
+ST_DIMENSION:                        'ST_DIMENSION';
+ST_DISJOINT:                         'ST_DISJOINT';
+ST_DISTANCE:                         'ST_DISTANCE';
+ST_ENDPOINT:                         'ST_ENDPOINT';
+ST_ENVELOPE:                         'ST_ENVELOPE';
+ST_EQUALS:                           'ST_EQUALS';
+ST_EXTERIORRING:                     'ST_EXTERIORRING';
+ST_GEOMCOLLFROMTEXT:                 'ST_GEOMCOLLFROMTEXT';
+ST_GEOMCOLLFROMTXT:                  'ST_GEOMCOLLFROMTXT';
+ST_GEOMCOLLFROMWKB:                  'ST_GEOMCOLLFROMWKB';
+ST_GEOMETRYCOLLECTIONFROMTEXT:       'ST_GEOMETRYCOLLECTIONFROMTEXT';
+ST_GEOMETRYCOLLECTIONFROMWKB:        'ST_GEOMETRYCOLLECTIONFROMWKB';
+ST_GEOMETRYFROMTEXT:                 'ST_GEOMETRYFROMTEXT';
+ST_GEOMETRYFROMWKB:                  'ST_GEOMETRYFROMWKB';
+ST_GEOMETRYN:                        'ST_GEOMETRYN';
+ST_GEOMETRYTYPE:                     'ST_GEOMETRYTYPE';
+ST_GEOMFROMTEXT:                     'ST_GEOMFROMTEXT';
+ST_GEOMFROMWKB:                      'ST_GEOMFROMWKB';
+ST_INTERIORRINGN:                    'ST_INTERIORRINGN';
+ST_INTERSECTION:                     'ST_INTERSECTION';
+ST_INTERSECTS:                       'ST_INTERSECTS';
+ST_ISCLOSED:                         'ST_ISCLOSED';
+ST_ISEMPTY:                          'ST_ISEMPTY';
+ST_ISSIMPLE:                         'ST_ISSIMPLE';
+ST_LINEFROMTEXT:                     'ST_LINEFROMTEXT';
+ST_LINEFROMWKB:                      'ST_LINEFROMWKB';
+ST_LINESTRINGFROMTEXT:               'ST_LINESTRINGFROMTEXT';
+ST_LINESTRINGFROMWKB:                'ST_LINESTRINGFROMWKB';
+ST_NUMGEOMETRIES:                    'ST_NUMGEOMETRIES';
+ST_NUMINTERIORRING:                  'ST_NUMINTERIORRING';
+ST_NUMINTERIORRINGS:                 'ST_NUMINTERIORRINGS';
+ST_NUMPOINTS:                        'ST_NUMPOINTS';
+ST_OVERLAPS:                         'ST_OVERLAPS';
+ST_POINTFROMTEXT:                    'ST_POINTFROMTEXT';
+ST_POINTFROMWKB:                     'ST_POINTFROMWKB';
+ST_POINTN:                           'ST_POINTN';
+ST_POLYFROMTEXT:                     'ST_POLYFROMTEXT';
+ST_POLYFROMWKB:                      'ST_POLYFROMWKB';
+ST_POLYGONFROMTEXT:                  'ST_POLYGONFROMTEXT';
+ST_POLYGONFROMWKB:                   'ST_POLYGONFROMWKB';
+ST_SRID:                             'ST_SRID';
+ST_STARTPOINT:                       'ST_STARTPOINT';
+ST_SYMDIFFERENCE:                    'ST_SYMDIFFERENCE';
+ST_TOUCHES:                          'ST_TOUCHES';
+ST_UNION:                            'ST_UNION';
+ST_WITHIN:                           'ST_WITHIN';
+ST_X:                                'ST_X';
+ST_Y:                                'ST_Y';
+SUBDATE:                             'SUBDATE';
+SUBSTRING_INDEX:                     'SUBSTRING_INDEX';
+SUBTIME:                             'SUBTIME';
+SYSTEM_USER:                         'SYSTEM_USER';
+TAN:                                 'TAN';
+TIMEDIFF:                            'TIMEDIFF';
+TIMESTAMPADD:                        'TIMESTAMPADD';
+TIMESTAMPDIFF:                       'TIMESTAMPDIFF';
+TIME_FORMAT:                         'TIME_FORMAT';
+TIME_TO_SEC:                         'TIME_TO_SEC';
+TOUCHES:                             'TOUCHES';
+TO_BASE64:                           'TO_BASE64';
+TO_DAYS:                             'TO_DAYS';
+TO_SECONDS:                          'TO_SECONDS';
+TP_CONNECTION_ADMIN:                 'TP_CONNECTION_ADMIN';
+UCASE:                               'UCASE';
+UNCOMPRESS:                          'UNCOMPRESS';
+UNCOMPRESSED_LENGTH:                 'UNCOMPRESSED_LENGTH';
+UNHEX:                               'UNHEX';
+UNIX_TIMESTAMP:                      'UNIX_TIMESTAMP';
+UPDATEXML:                           'UPDATEXML';
+UPPER:                               'UPPER';
+UUID:                                'UUID';
+UUID_SHORT:                          'UUID_SHORT';
+VALIDATE_PASSWORD_STRENGTH:          'VALIDATE_PASSWORD_STRENGTH';
+VERSION:                             'VERSION';
+WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS:   'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS';
+WEEKDAY:                             'WEEKDAY';
+WEEKOFYEAR:                          'WEEKOFYEAR';
+WEIGHT_STRING:                       'WEIGHT_STRING';
+WITHIN:                              'WITHIN';
+YEARWEEK:                            'YEARWEEK';
+Y_FUNCTION:                          'Y';
+X_FUNCTION:                          'X';
+
+
+
+
+// Operators
+// Operators. Assigns
+
+VAR_ASSIGN:                          ':=';
+PLUS_ASSIGN:                         '+=';
+MINUS_ASSIGN:                        '-=';
+MULT_ASSIGN:                         '*=';
+DIV_ASSIGN:                          '/=';
+MOD_ASSIGN:                          '%=';
+AND_ASSIGN:                          '&=';
+XOR_ASSIGN:                          '^=';
+OR_ASSIGN:                           '|=';
+
+
+// Operators. Arithmetics
+
+STAR:                                '*';
+DIVIDE:                              '/';
+MODULE:                              '%';
+PLUS:                                '+';
+MINUS:                               '-';
+DIV:                                 'DIV';
+MOD:                                 'MOD';
+
+
+// Operators. Comparation
+
+EQUAL_SYMBOL:                        '=';
+GREATER_SYMBOL:                      '>';
+LESS_SYMBOL:                         '<';
+EXCLAMATION_SYMBOL:                  '!';
+
+
+// Operators. Bit
+
+BIT_NOT_OP:                          '~';
+BIT_OR_OP:                           '|';
+BIT_AND_OP:                          '&';
+BIT_XOR_OP:                          '^';
+
+
+// Constructors symbols
+
+DOT:                                 '.';
+LR_BRACKET:                          '(';
+RR_BRACKET:                          ')';
+COMMA:                               ',';
+SEMI:                                ';';
+AT_SIGN:                             '@';
+ZERO_DECIMAL:                        '0';
+ONE_DECIMAL:                         '1';
+TWO_DECIMAL:                         '2';
+SINGLE_QUOTE_SYMB:                   '\'';
+DOUBLE_QUOTE_SYMB:                   '"';
+REVERSE_QUOTE_SYMB:                  '`';
+COLON_SYMB:                          ':';
+
+fragment QUOTE_SYMB
+    : SINGLE_QUOTE_SYMB | DOUBLE_QUOTE_SYMB | REVERSE_QUOTE_SYMB
+    ;
+
+
+
+// Charsets
+
+CHARSET_REVERSE_QOUTE_STRING:        '`' CHARSET_NAME '`';
+
+
+
+// File's sizes
+
+
+FILESIZE_LITERAL:                    DEC_DIGIT+ ('K'|'M'|'G'|'T');
+
+
+
+// Literal Primitives
+
+
+START_NATIONAL_STRING_LITERAL:       'N' SQUOTA_STRING;
+STRING_LITERAL:                      DQUOTA_STRING | SQUOTA_STRING | BQUOTA_STRING;
+DECIMAL_LITERAL:                     DEC_DIGIT+;
+HEXADECIMAL_LITERAL:                 'X' '\'' (HEX_DIGIT HEX_DIGIT)+ '\''
+                                     | '0X' HEX_DIGIT+;
+
+REAL_LITERAL:                        (DEC_DIGIT+)? '.' DEC_DIGIT+
+                                     | DEC_DIGIT+ '.' EXPONENT_NUM_PART
+                                     | (DEC_DIGIT+)? '.' (DEC_DIGIT+ EXPONENT_NUM_PART)
+                                     | DEC_DIGIT+ EXPONENT_NUM_PART;
+NULL_SPEC_LITERAL:                   '\\' 'N';
+BIT_STRING:                          BIT_STRING_L;
+STRING_CHARSET_NAME:                 '_' CHARSET_NAME;
+
+
+
+
+// Hack for dotID
+// Prevent recognize string:         .123somelatin AS ((.123), FLOAT_LITERAL), ((somelatin), ID)
+//  it must recoginze:               .123somelatin AS ((.), DOT), (123somelatin, ID)
+
+DOT_ID:                              '.' ID_LITERAL;
+
+
+
+// Identifiers
+
+ID:                                  ID_LITERAL;
+// DOUBLE_QUOTE_ID:                  '"' ~'"'+ '"';
+REVERSE_QUOTE_ID:                    '`' ~'`'+ '`';
+STRING_USER_NAME:                    (
+                                       SQUOTA_STRING | DQUOTA_STRING
+                                       | BQUOTA_STRING | ID_LITERAL
+                                     ) '@'
+                                     (
+                                       SQUOTA_STRING | DQUOTA_STRING
+                                       | BQUOTA_STRING | ID_LITERAL
+                                       | IP_ADDRESS
+                                     );
+IP_ADDRESS:                          (
+                                       [0-9]+ '.' [0-9.]+
+                                       | [0-9A-F:]+ ':' [0-9A-F:]+
+                                     );
+LOCAL_ID:                               '@'
+                                     (
+                                        [A-Z0-9._$]+
+                                        | SQUOTA_STRING
+                                        | DQUOTA_STRING
+                                        | BQUOTA_STRING
+                                    );
+GLOBAL_ID:                              '@' '@'
+                                    (
+                                        [A-Z0-9._$]+
+                                        | BQUOTA_STRING
+                                    );
+
+
+// Fragments for Literal primitives
+
+fragment CHARSET_NAME:               ARMSCII8 | ASCII | BIG5 | BINARY | CP1250
+                                     | CP1251 | CP1256 | CP1257 | CP850
+                                     | CP852 | CP866 | CP932 | DEC8 | EUCJPMS
+                                     | EUCKR | GB2312 | GBK | GEOSTD8 | GREEK
+                                     | HEBREW | HP8 | KEYBCS2 | KOI8R | KOI8U
+                                     | LATIN1 | LATIN2 | LATIN5 | LATIN7
+                                     | MACCE | MACROMAN | SJIS | SWE7 | TIS620
+                                     | UCS2 | UJIS | UTF16 | UTF16LE | UTF32
+                                     | UTF8 | UTF8MB3 | UTF8MB4;
+
+fragment EXPONENT_NUM_PART:          'E' [-+]? DEC_DIGIT+;
+fragment ID_LITERAL:                 [A-Z_$0-9\u0080-\uFFFF]*?[A-Z_$\u0080-\uFFFF]+?[A-Z_$0-9\u0080-\uFFFF]*;
+fragment DQUOTA_STRING:              '"' ( '\\'. | '""' | ~('"'| '\\') )* '"';
+fragment SQUOTA_STRING:              '\'' ('\\'. | '\'\'' | ~('\'' | '\\'))* '\'';
+fragment BQUOTA_STRING:              '`' ( '\\'. | '``' | ~('`'|'\\'))* '`';
+fragment HEX_DIGIT:                  [0-9A-F];
+fragment DEC_DIGIT:                  [0-9];
+fragment BIT_STRING_L:               'B' '\'' [01]+ '\'';
+
+
+
+// Last tokens must generate Errors
+
+ERROR_RECONGNIGION:                  .    -> channel(ERRORCHANNEL);
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlParser.g4 b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlParser.g4
new file mode 100644
index 000000000..53bae6ae0
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/antlr/MySqlParser.g4
@@ -0,0 +1,2837 @@
+/*
+ * 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.
+ */
+
+
+parser grammar MySqlParser;
+
+options { tokenVocab=MySqlLexer; }
+
+
+// Top Level Description
+
+root
+    : sqlStatements? (MINUS MINUS)? EOF
+    ;
+
+sqlStatements
+    : (sqlStatement (MINUS MINUS)? SEMI? | emptyStatement_)*
+    (sqlStatement ((MINUS MINUS)? SEMI)? | emptyStatement_)
+    ;
+
+sqlStatement
+    : ddlStatement | dmlStatement | transactionStatement
+    | replicationStatement | preparedStatement
+    | administrationStatement | utilityStatement
+    ;
+
+emptyStatement_
+    : SEMI
+    ;
+
+ddlStatement
+    : createDatabase | createEvent | createIndex
+    | createLogfileGroup | createProcedure | createFunction
+    | createServer | createTable | createTablespaceInnodb
+    | createTablespaceNdb | createTrigger | createView | createRole
+    | alterDatabase | alterEvent | alterFunction
+    | alterInstance | alterLogfileGroup | alterProcedure
+    | alterServer | alterTable | alterTablespace | alterView
+    | dropDatabase | dropEvent | dropIndex
+    | dropLogfileGroup | dropProcedure | dropFunction
+    | dropServer | dropTable | dropTablespace
+    | dropTrigger | dropView | dropRole | setRole
+    | renameTable | truncateTable
+    ;
+
+dmlStatement
+    : selectStatement | insertStatement | updateStatement
+    | deleteStatement | replaceStatement | callStatement
+    | loadDataStatement | loadXmlStatement | doStatement
+    | handlerStatement | valuesStatement | withStatement
+    ;
+
+transactionStatement
+    : startTransaction
+    | beginWork | commitWork | rollbackWork
+    | savepointStatement | rollbackStatement
+    | releaseStatement | lockTables | unlockTables
+    ;
+
+replicationStatement
+    : changeMaster | changeReplicationFilter | purgeBinaryLogs
+    | resetMaster | resetSlave | startSlave | stopSlave
+    | startGroupReplication | stopGroupReplication
+    | xaStartTransaction | xaEndTransaction | xaPrepareStatement
+    | xaCommitWork | xaRollbackWork | xaRecoverWork
+    ;
+
+preparedStatement
+    : prepareStatement | executeStatement | deallocatePrepare
+    ;
+
+// remark: NOT INCLUDED IN sqlStatement, but include in body
+//  of routine's statements
+compoundStatement
+    : blockStatement
+    | caseStatement | ifStatement | leaveStatement
+    | loopStatement | repeatStatement | whileStatement
+    | iterateStatement | returnStatement | cursorStatement
+    ;
+
+administrationStatement
+    : alterUser | createUser | dropUser | grantStatement
+    | grantProxy | renameUser | revokeStatement
+    | revokeProxy | analyzeTable | checkTable
+    | checksumTable | optimizeTable | repairTable
+    | createUdfunction | installPlugin | uninstallPlugin
+    | setStatement | showStatement | binlogStatement
+    | cacheIndexStatement | flushStatement | killStatement
+    | loadIndexIntoCache | resetStatement
+    | shutdownStatement
+    ;
+
+utilityStatement
+    : simpleDescribeStatement | fullDescribeStatement
+    | helpStatement | useStatement | signalStatement
+    | resignalStatement | diagnosticsStatement
+    ;
+
+
+// Data Definition Language
+
+//    Create statements
+
+createDatabase
+    : CREATE dbFormat=(DATABASE | SCHEMA)
+      ifNotExists? uid createDatabaseOption*
+    ;
+
+createEvent
+    : CREATE ownerStatement? EVENT ifNotExists? fullId
+      ON SCHEDULE scheduleExpression
+      (ON COMPLETION NOT? PRESERVE)? enableType?
+      (COMMENT STRING_LITERAL)?
+      DO routineBody
+    ;
+
+createIndex
+    : CREATE
+      intimeAction=(ONLINE | OFFLINE)?
+      indexCategory=(UNIQUE | FULLTEXT | SPATIAL)? INDEX
+      uid indexType?
+      ON tableName indexColumnNames
+      indexOption*
+      (
+        ALGORITHM EQUAL_SYMBOL? algType=(DEFAULT | INPLACE | COPY)
+        | LOCK EQUAL_SYMBOL? lockType=(DEFAULT | NONE | SHARED | EXCLUSIVE)
+      )*
+    ;
+
+createLogfileGroup
+    : CREATE LOGFILE GROUP uid
+      ADD UNDOFILE undoFile=STRING_LITERAL
+      (INITIAL_SIZE '='? initSize=fileSizeLiteral)?
+      (UNDO_BUFFER_SIZE '='? undoSize=fileSizeLiteral)?
+      (REDO_BUFFER_SIZE '='? redoSize=fileSizeLiteral)?
+      (NODEGROUP '='? uid)?
+      WAIT?
+      (COMMENT '='? comment=STRING_LITERAL)?
+      ENGINE '='? engineName
+    ;
+
+createProcedure
+    : CREATE ownerStatement?
+      PROCEDURE fullId
+      '(' procedureParameter? (',' procedureParameter)* ')'
+      routineOption*
+      routineBody
+    ;
+
+createFunction
+    : CREATE ownerStatement? AGGREGATE?
+      FUNCTION ifNotExists? fullId
+      '(' functionParameter? (',' functionParameter)* ')'
+      RETURNS dataType
+      routineOption*
+      (routineBody | returnStatement)
+    ;
+
+createRole
+    : CREATE ROLE ifNotExists? roleName (',' roleName)*
+    ;
+
+createServer
+    : CREATE SERVER uid
+    FOREIGN DATA WRAPPER wrapperName=(MYSQL | STRING_LITERAL)
+    OPTIONS '(' serverOption (',' serverOption)* ')'
+    ;
+
+createTable
+    : CREATE TEMPORARY? TABLE ifNotExists?
+       tableName
+       (
+         LIKE tableName
+         | '(' LIKE parenthesisTable=tableName ')'
+       )                                                            #copyCreateTable
+    | CREATE TEMPORARY? TABLE ifNotExists?
+       tableName createDefinitions?
+       ( tableOption (','? tableOption)* )?
+       partitionDefinitions? keyViolate=(IGNORE | REPLACE)?
+       AS? selectStatement                                          #queryCreateTable
+    | CREATE TEMPORARY? TABLE ifNotExists?
+       tableName createDefinitions
+       ( tableOption (','? tableOption)* )?
+       partitionDefinitions?                                        #columnCreateTable
+    ;
+
+createTablespaceInnodb
+    : CREATE TABLESPACE uid
+      ADD DATAFILE datafile=STRING_LITERAL
+      (FILE_BLOCK_SIZE '=' fileBlockSize=fileSizeLiteral)?
+      (ENGINE '='? engineName)?
+    ;
+
+createTablespaceNdb
+    : CREATE TABLESPACE uid
+      ADD DATAFILE datafile=STRING_LITERAL
+      USE LOGFILE GROUP uid
+      (EXTENT_SIZE '='? extentSize=fileSizeLiteral)?
+      (INITIAL_SIZE '='? initialSize=fileSizeLiteral)?
+      (AUTOEXTEND_SIZE '='? autoextendSize=fileSizeLiteral)?
+      (MAX_SIZE '='? maxSize=fileSizeLiteral)?
+      (NODEGROUP '='? uid)?
+      WAIT?
+      (COMMENT '='? comment=STRING_LITERAL)?
+      ENGINE '='? engineName
+    ;
+
+createTrigger
+    : CREATE ownerStatement?
+      TRIGGER thisTrigger=fullId
+      triggerTime=(BEFORE | AFTER)
+      triggerEvent=(INSERT | UPDATE | DELETE)
+      ON tableName FOR EACH ROW
+      (triggerPlace=(FOLLOWS | PRECEDES) otherTrigger=fullId)?
+      routineBody
+    ;
+
+withClause
+    : WITH RECURSIVE? commonTableExpressions
+    ;
+
+commonTableExpressions
+    : cteName ('(' cteColumnName (',' cteColumnName)* ')')?  AS '(' dmlStatement ')'
+      (',' commonTableExpressions)?
+    ;
+
+cteName
+    : uid
+    ;
+
+cteColumnName
+    : uid
+    ;
+
+createView
+    : CREATE orReplace?
+      (
+        ALGORITHM '=' algType=(UNDEFINED | MERGE | TEMPTABLE)
+      )?
+      ownerStatement?
+      (SQL SECURITY secContext=(DEFINER | INVOKER))?
+      VIEW fullId ('(' uidList ')')? AS
+      (
+        '(' withClause? selectStatement ')'
+        |
+        withClause? selectStatement (WITH checkOption=(CASCADED | LOCAL)? CHECK OPTION)?
+      )
+    ;
+
+
+// details
+
+createDatabaseOption
+    : DEFAULT? charSet '='? (charsetName | DEFAULT)
+    | DEFAULT? COLLATE '='? collationName
+    | DEFAULT? ENCRYPTION '='? STRING_LITERAL
+    | READ ONLY '='? (DEFAULT | ZERO_DECIMAL | ONE_DECIMAL)
+    ;
+
+charSet
+    : CHARACTER SET
+    | CHARSET
+    | CHAR SET
+    ;
+
+ownerStatement
+    : DEFINER '=' (userName | CURRENT_USER ( '(' ')')?)
+    ;
+
+scheduleExpression
+    : AT timestampValue intervalExpr*                               #preciseSchedule
+    | EVERY (decimalLiteral | expression) intervalType
+        (
+          STARTS startTimestamp=timestampValue
+          (startIntervals+=intervalExpr)*
+        )?
+        (
+          ENDS endTimestamp=timestampValue
+          (endIntervals+=intervalExpr)*
+        )?                                                          #intervalSchedule
+    ;
+
+timestampValue
+    : CURRENT_TIMESTAMP
+    | stringLiteral
+    | decimalLiteral
+    | expression
+    ;
+
+intervalExpr
+    : '+' INTERVAL (decimalLiteral | expression) intervalType
+    ;
+
+intervalType
+    : intervalTypeBase
+    | YEAR | YEAR_MONTH | DAY_HOUR | DAY_MINUTE
+    | DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND
+    | SECOND_MICROSECOND | MINUTE_MICROSECOND
+    | HOUR_MICROSECOND | DAY_MICROSECOND
+    ;
+
+enableType
+    : ENABLE | DISABLE | DISABLE ON SLAVE
+    ;
+
+indexType
+    : USING (BTREE | HASH)
+    ;
+
+indexOption
+    : KEY_BLOCK_SIZE EQUAL_SYMBOL? fileSizeLiteral
+    | indexType
+    | WITH PARSER uid
+    | COMMENT STRING_LITERAL
+    | (VISIBLE | INVISIBLE)
+    | ENGINE_ATTRIBUTE EQUAL_SYMBOL? STRING_LITERAL
+    | SECONDARY_ENGINE_ATTRIBUTE EQUAL_SYMBOL? STRING_LITERAL
+    ;
+
+procedureParameter
+    : direction=(IN | OUT | INOUT)? uid dataType
+    ;
+
+functionParameter
+    : uid dataType
+    ;
+
+routineOption
+    : COMMENT STRING_LITERAL                                        #routineComment
+    | LANGUAGE SQL                                                  #routineLanguage
+    | NOT? DETERMINISTIC                                            #routineBehavior
+    | (
+        CONTAINS SQL | NO SQL | READS SQL DATA
+        | MODIFIES SQL DATA
+      )                                                             #routineData
+    | SQL SECURITY context=(DEFINER | INVOKER)                      #routineSecurity
+    ;
+
+serverOption
+    : HOST STRING_LITERAL
+    | DATABASE STRING_LITERAL
+    | USER STRING_LITERAL
+    | PASSWORD STRING_LITERAL
+    | SOCKET STRING_LITERAL
+    | OWNER STRING_LITERAL
+    | PORT decimalLiteral
+    ;
+
+createDefinitions
+    : '(' createDefinition (',' createDefinition)* ')'
+    ;
+
+createDefinition
+    : fullColumnName columnDefinition                               #columnDeclaration
+    | tableConstraint NOT? ENFORCED?                                #constraintDeclaration
+    | indexColumnDefinition                                         #indexDeclaration
+    ;
+
+columnDefinition
+    : dataType columnConstraint* NOT? ENFORCED?
+    ;
+
+columnConstraint
+    : nullNotnull                                                   #nullColumnConstraint
+    | DEFAULT defaultValue                                          #defaultColumnConstraint
+    | VISIBLE                                                       #visibilityColumnConstraint
+    | INVISIBLE                                                     #invisibilityColumnConstraint
+    | (AUTO_INCREMENT | ON UPDATE currentTimestamp)                 #autoIncrementColumnConstraint
+    | PRIMARY? KEY                                                  #primaryKeyColumnConstraint
+    | UNIQUE KEY?                                                   #uniqueKeyColumnConstraint
+    | COMMENT STRING_LITERAL                                        #commentColumnConstraint
+    | COLUMN_FORMAT colformat=(FIXED | DYNAMIC | DEFAULT)           #formatColumnConstraint
+    | STORAGE storageval=(DISK | MEMORY | DEFAULT)                  #storageColumnConstraint
+    | referenceDefinition                                           #referenceColumnConstraint
+    | COLLATE collationName                                         #collateColumnConstraint
+    | (GENERATED ALWAYS)? AS '(' expression ')' (VIRTUAL | STORED)? #generatedColumnConstraint
+    | SERIAL DEFAULT VALUE                                          #serialDefaultColumnConstraint
+    | (CONSTRAINT name=uid?)?
+      CHECK '(' expression ')'                                      #checkColumnConstraint
+    ;
+
+tableConstraint
+    : (CONSTRAINT name=uid?)?
+      PRIMARY KEY index=uid? indexType?
+      indexColumnNames indexOption*                                 #primaryKeyTableConstraint
+    | (CONSTRAINT name=uid?)?
+      UNIQUE indexFormat=(INDEX | KEY)? index=uid?
+      indexType? indexColumnNames indexOption*                      #uniqueKeyTableConstraint
+    | (CONSTRAINT name=uid?)?
+      FOREIGN KEY index=uid? indexColumnNames
+      referenceDefinition                                           #foreignKeyTableConstraint
+    | (CONSTRAINT name=uid?)?
+      CHECK '(' expression ')'                                      #checkTableConstraint
+    ;
+
+referenceDefinition
+    : REFERENCES tableName indexColumnNames?
+      (MATCH matchType=(FULL | PARTIAL | SIMPLE))?
+      referenceAction?
+    ;
+
+referenceAction
+    : ON DELETE onDelete=referenceControlType
+      (
+        ON UPDATE onUpdate=referenceControlType
+      )?
+    | ON UPDATE onUpdate=referenceControlType
+      (
+        ON DELETE onDelete=referenceControlType
+      )?
+    ;
+
+referenceControlType
+    : RESTRICT | CASCADE | SET NULL_LITERAL | NO ACTION | SET DEFAULT
+    ;
+
+indexColumnDefinition
+    : indexFormat=(INDEX | KEY) uid? indexType?
+      indexColumnNames indexOption*                                 #simpleIndexDeclaration
+    | (FULLTEXT | SPATIAL)
+      indexFormat=(INDEX | KEY)? uid?
+      indexColumnNames indexOption*                                 #specialIndexDeclaration
+    ;
+
+tableOption
+    : ENGINE '='? engineName?                                                       #tableOptionEngine
+    | ENGINE_ATTRIBUTE '='? STRING_LITERAL                                          #tableOptionEngineAttribute
+    | AUTOEXTEND_SIZE '='? decimalLiteral                                           #tableOptionAutoextendSize
+    | AUTO_INCREMENT '='? decimalLiteral                                            #tableOptionAutoIncrement
+    | AVG_ROW_LENGTH '='? decimalLiteral                                            #tableOptionAverage
+    | DEFAULT? charSet '='? (charsetName|DEFAULT)                                   #tableOptionCharset
+    | (CHECKSUM | PAGE_CHECKSUM) '='? boolValue=('0' | '1')                         #tableOptionChecksum
+    | DEFAULT? COLLATE '='? collationName                                           #tableOptionCollate
+    | COMMENT '='? STRING_LITERAL                                                   #tableOptionComment
+    | COMPRESSION '='? (STRING_LITERAL | ID)                                        #tableOptionCompression
+    | CONNECTION '='? STRING_LITERAL                                                #tableOptionConnection
+    | (DATA | INDEX) DIRECTORY '='? STRING_LITERAL                                  #tableOptionDataDirectory
+    | DELAY_KEY_WRITE '='? boolValue=('0' | '1')                                    #tableOptionDelay
+    | ENCRYPTION '='? STRING_LITERAL                                                #tableOptionEncryption
+    | (PAGE_COMPRESSED | STRING_LITERAL) '='? ('0' | '1')                           #tableOptionPageCompressed
+    | (PAGE_COMPRESSION_LEVEL | STRING_LITERAL) '='? decimalLiteral                 #tableOptionPageCompressionLevel
+    | ENCRYPTION_KEY_ID '='? decimalLiteral                                         #tableOptionEncryptionKeyId
+    | INDEX DIRECTORY '='? STRING_LITERAL                                           #tableOptionIndexDirectory
+    | INSERT_METHOD '='? insertMethod=(NO | FIRST | LAST)                           #tableOptionInsertMethod
+    | KEY_BLOCK_SIZE '='? fileSizeLiteral                                           #tableOptionKeyBlockSize
+    | MAX_ROWS '='? decimalLiteral                                                  #tableOptionMaxRows
+    | MIN_ROWS '='? decimalLiteral                                                  #tableOptionMinRows
+    | PACK_KEYS '='? extBoolValue=('0' | '1' | DEFAULT)                             #tableOptionPackKeys
+    | PASSWORD '='? STRING_LITERAL                                                  #tableOptionPassword
+    | ROW_FORMAT '='?
+        rowFormat=(
+          DEFAULT | DYNAMIC | FIXED | COMPRESSED
+          | REDUNDANT | COMPACT | ID
+        )                                                                           #tableOptionRowFormat
+    | START TRANSACTION                                                             #tableOptionStartTransaction
+    | SECONDARY_ENGINE_ATTRIBUTE '='? STRING_LITERAL                                #tableOptionSecondaryEngineAttribute
+    | STATS_AUTO_RECALC '='? extBoolValue=(DEFAULT | '0' | '1')                     #tableOptionRecalculation
+    | STATS_PERSISTENT '='? extBoolValue=(DEFAULT | '0' | '1')                      #tableOptionPersistent
+    | STATS_SAMPLE_PAGES '='? (DEFAULT | decimalLiteral)                            #tableOptionSamplePage
+    | TABLESPACE uid tablespaceStorage?                                             #tableOptionTablespace
+    | TABLE_TYPE '=' tableType                                                      #tableOptionTableType
+    | tablespaceStorage                                                             #tableOptionTablespace
+    | TRANSACTIONAL '='? ('0' | '1')                                                #tableOptionTransactional
+    | UNION '='? '(' tables ')'                                                     #tableOptionUnion
+    ;
+
+tableType
+    : MYSQL | ODBC
+    ;
+
+tablespaceStorage
+    : STORAGE (DISK | MEMORY | DEFAULT)
+    ;
+
+partitionDefinitions
+    : PARTITION BY partitionFunctionDefinition
+      (PARTITIONS count=decimalLiteral)?
+      (
+        SUBPARTITION BY subpartitionFunctionDefinition
+        (SUBPARTITIONS subCount=decimalLiteral)?
+      )?
+    ('(' partitionDefinition (',' partitionDefinition)* ')')?
+    ;
+
+partitionFunctionDefinition
+    : LINEAR? HASH '(' expression ')'                               #partitionFunctionHash
+    | LINEAR? KEY (ALGORITHM '=' algType=('1' | '2'))?
+      '(' uidList? ')'                                              #partitionFunctionKey // Optional uidList for MySQL only
+    | RANGE ( '(' expression ')' | COLUMNS '(' uidList ')' )        #partitionFunctionRange
+    | LIST ( '(' expression ')' | COLUMNS '(' uidList ')' )         #partitionFunctionList
+    ;
+
+subpartitionFunctionDefinition
+    : LINEAR? HASH '(' expression ')'                               #subPartitionFunctionHash
+    | LINEAR? KEY (ALGORITHM '=' algType=('1' | '2'))?
+      '(' uidList ')'                                               #subPartitionFunctionKey
+    ;
+
+partitionDefinition
+    : PARTITION uid VALUES LESS THAN
+      '('
+          partitionDefinerAtom (',' partitionDefinerAtom)*
+      ')'
+      partitionOption*
+      ( '(' subpartitionDefinition (',' subpartitionDefinition)* ')' )?       #partitionComparison
+    | PARTITION uid VALUES LESS THAN
+      partitionDefinerAtom partitionOption*
+      ( '(' subpartitionDefinition (',' subpartitionDefinition)* ')' )?       #partitionComparison
+    | PARTITION uid VALUES IN
+      '('
+          partitionDefinerAtom (',' partitionDefinerAtom)*
+      ')'
+      partitionOption*
+      ( '(' subpartitionDefinition (',' subpartitionDefinition)* ')' )?       #partitionListAtom
+    | PARTITION uid VALUES IN
+      '('
+          partitionDefinerVector (',' partitionDefinerVector)*
+      ')'
+      partitionOption*
+      ( '(' subpartitionDefinition (',' subpartitionDefinition)* ')' )?       #partitionListVector
+    | PARTITION uid partitionOption*
+      ( '(' subpartitionDefinition (',' subpartitionDefinition)* ')' )?       #partitionSimple
+    ;
+
+partitionDefinerAtom
+    : constant | expression | MAXVALUE
+    ;
+
+partitionDefinerVector
+    : '(' partitionDefinerAtom (',' partitionDefinerAtom)+ ')'
+    ;
+
+subpartitionDefinition
+    : SUBPARTITION uid partitionOption*
+    ;
+
+partitionOption
+    : DEFAULT? STORAGE? ENGINE '='? engineName                      #partitionOptionEngine
+    | COMMENT '='? comment=STRING_LITERAL                           #partitionOptionComment
+    | DATA DIRECTORY '='? dataDirectory=STRING_LITERAL              #partitionOptionDataDirectory
+    | INDEX DIRECTORY '='? indexDirectory=STRING_LITERAL            #partitionOptionIndexDirectory
+    | MAX_ROWS '='? maxRows=decimalLiteral                          #partitionOptionMaxRows
+    | MIN_ROWS '='? minRows=decimalLiteral                          #partitionOptionMinRows
+    | TABLESPACE '='? tablespace=uid                                #partitionOptionTablespace
+    | NODEGROUP '='? nodegroup=uid                                  #partitionOptionNodeGroup
+    ;
+
+//    Alter statements
+
+alterDatabase
+    : ALTER dbFormat=(DATABASE | SCHEMA) uid?
+      createDatabaseOption+                                         #alterSimpleDatabase
+    | ALTER dbFormat=(DATABASE | SCHEMA) uid
+      UPGRADE DATA DIRECTORY NAME                                   #alterUpgradeName
+    ;
+
+alterEvent
+    : ALTER ownerStatement?
+      EVENT fullId
+      (ON SCHEDULE scheduleExpression)?
+      (ON COMPLETION NOT? PRESERVE)?
+      (RENAME TO fullId)? enableType?
+      (COMMENT STRING_LITERAL)?
+      (DO routineBody)?
+    ;
+
+alterFunction
+    : ALTER FUNCTION fullId routineOption*
+    ;
+
+alterInstance
+    : ALTER INSTANCE ROTATE INNODB MASTER KEY
+    ;
+
+alterLogfileGroup
+    : ALTER LOGFILE GROUP uid
+      ADD UNDOFILE STRING_LITERAL
+      (INITIAL_SIZE '='? fileSizeLiteral)?
+      WAIT? ENGINE '='? engineName
+    ;
+
+alterProcedure
+    : ALTER PROCEDURE fullId routineOption*
+    ;
+
+alterServer
+    : ALTER SERVER uid OPTIONS
+      '(' serverOption (',' serverOption)* ')'
+    ;
+
+alterTable
+    : ALTER intimeAction=(ONLINE | OFFLINE)?
+      IGNORE? TABLE tableName waitNowaitClause?
+      (alterSpecification (',' alterSpecification)*)?
+      partitionDefinitions?
+    ;
+
+alterTablespace
+    : ALTER TABLESPACE uid
+      objectAction=(ADD | DROP) DATAFILE STRING_LITERAL
+      (INITIAL_SIZE '=' fileSizeLiteral)?
+      WAIT?
+      ENGINE '='? engineName
+    ;
+
+alterView
+    : ALTER
+      (
+        ALGORITHM '=' algType=(UNDEFINED | MERGE | TEMPTABLE)
+      )?
+      ownerStatement?
+      (SQL SECURITY secContext=(DEFINER | INVOKER))?
+      VIEW fullId ('(' uidList ')')? AS selectStatement
+      (WITH checkOpt=(CASCADED | LOCAL)? CHECK OPTION)?
+    ;
+
+// details
+
+alterSpecification
+    : tableOption (','? tableOption)*                               #alterByTableOption
+    | ADD COLUMN? uid columnDefinition (FIRST | AFTER uid)?         #alterByAddColumn
+    | ADD COLUMN?
+        '('
+          uid columnDefinition ( ',' uid columnDefinition)*
+        ')'                                                         #alterByAddColumns
+    | ADD indexFormat=(INDEX | KEY) uid? indexType?
+      indexColumnNames indexOption*                                 #alterByAddIndex
+    | ADD (CONSTRAINT name=uid?)? PRIMARY KEY index=uid?
+      indexType? indexColumnNames indexOption*                      #alterByAddPrimaryKey
+    | ADD (CONSTRAINT name=uid?)? UNIQUE
+      indexFormat=(INDEX | KEY)? indexName=uid?
+      indexType? indexColumnNames indexOption*                      #alterByAddUniqueKey
+    | ADD keyType=(FULLTEXT | SPATIAL)
+      indexFormat=(INDEX | KEY)? uid?
+      indexColumnNames indexOption*                                 #alterByAddSpecialIndex
+    | ADD (CONSTRAINT name=uid?)? FOREIGN KEY
+      indexName=uid? indexColumnNames referenceDefinition           #alterByAddForeignKey
+    | ADD (CONSTRAINT name=uid?)? CHECK ( uid | stringLiteral | '(' expression ')' )
+      NOT? ENFORCED?                                                #alterByAddCheckTableConstraint
+    | ALTER (CONSTRAINT name=uid?)? CHECK ( uid | stringLiteral | '(' expression ')' )
+      NOT? ENFORCED?                                                #alterByAlterCheckTableConstraint
+    | ADD (CONSTRAINT name=uid?)? CHECK '(' expression ')'          #alterByAddCheckTableConstraint
+    | ALGORITHM '='? algType=(DEFAULT | INSTANT | INPLACE | COPY)   #alterBySetAlgorithm
+    | ALTER COLUMN? uid
+      (SET DEFAULT defaultValue | DROP DEFAULT)                     #alterByChangeDefault
+    | CHANGE COLUMN? oldColumn=uid
+      newColumn=uid columnDefinition
+      (FIRST | AFTER afterColumn=uid)?                              #alterByChangeColumn
+    | RENAME COLUMN oldColumn=uid TO newColumn=uid                  #alterByRenameColumn
+    | LOCK '='? lockType=(DEFAULT | NONE | SHARED | EXCLUSIVE)      #alterByLock
+    | MODIFY COLUMN?
+      uid columnDefinition (FIRST | AFTER uid)?                     #alterByModifyColumn
+    | DROP COLUMN? uid RESTRICT?                                    #alterByDropColumn
+    | DROP (CONSTRAINT | CHECK) uid                                 #alterByDropConstraintCheck
+    | DROP PRIMARY KEY                                              #alterByDropPrimaryKey
+    | DROP indexFormat=(INDEX | KEY) uid                            #alterByDropIndex
+    | RENAME indexFormat=(INDEX | KEY) uid TO uid                   #alterByRenameIndex
+    | ALTER COLUMN? uid (
+        SET DEFAULT ( stringLiteral | '(' expression ')' )
+        | SET (VISIBLE | INVISIBLE)
+        | DROP DEFAULT)                                             #alterByAlterColumnDefault
+    | ALTER INDEX uid (VISIBLE | INVISIBLE)                         #alterByAlterIndexVisibility
+    | DROP FOREIGN KEY uid                                          #alterByDropForeignKey
+    | DISABLE KEYS                                                  #alterByDisableKeys
+    | ENABLE KEYS                                                   #alterByEnableKeys
+    | RENAME renameFormat=(TO | AS)? (uid | fullId)                 #alterByRename
+    | ORDER BY uidList                                              #alterByOrder
+    | CONVERT TO (CHARSET | CHARACTER SET) charsetName
+      (COLLATE collationName)?                                      #alterByConvertCharset
+    | DEFAULT? CHARACTER SET '=' charsetName
+      (COLLATE '=' collationName)?                                  #alterByDefaultCharset
+    | DISCARD TABLESPACE                                            #alterByDiscardTablespace
+    | IMPORT TABLESPACE                                             #alterByImportTablespace
+    | FORCE                                                         #alterByForce
+    | validationFormat=(WITHOUT | WITH) VALIDATION                  #alterByValidate
+    | ADD PARTITION
+        '('
+          partitionDefinition (',' partitionDefinition)*
+        ')'                                                         #alterByAddPartition
+    | DROP PARTITION uidList                                        #alterByDropPartition
+    | DISCARD PARTITION (uidList | ALL) TABLESPACE                  #alterByDiscardPartition
+    | IMPORT PARTITION (uidList | ALL) TABLESPACE                   #alterByImportPartition
+    | TRUNCATE PARTITION (uidList | ALL)                            #alterByTruncatePartition
+    | COALESCE PARTITION decimalLiteral                             #alterByCoalescePartition
+    | REORGANIZE PARTITION uidList
+        INTO '('
+          partitionDefinition (',' partitionDefinition)*
+        ')'                                                         #alterByReorganizePartition
+    | EXCHANGE PARTITION uid WITH TABLE tableName
+      (validationFormat=(WITH | WITHOUT) VALIDATION)?               #alterByExchangePartition
+    | ANALYZE PARTITION (uidList | ALL)                             #alterByAnalyzePartition
+    | CHECK PARTITION (uidList | ALL)                               #alterByCheckPartition
+    | OPTIMIZE PARTITION (uidList | ALL)                            #alterByOptimizePartition
+    | REBUILD PARTITION (uidList | ALL)                             #alterByRebuildPartition
+    | REPAIR PARTITION (uidList | ALL)                              #alterByRepairPartition
+    | REMOVE PARTITIONING                                           #alterByRemovePartitioning
+    | UPGRADE PARTITIONING                                          #alterByUpgradePartitioning
+    | ADD COLUMN?
+        '(' createDefinition (',' createDefinition)* ')'            #alterByAddDefinitions
+    ;
+
+
+//    Drop statements
+
+dropDatabase
+    : DROP dbFormat=(DATABASE | SCHEMA) ifExists? uid
+    ;
+
+dropEvent
+    : DROP EVENT ifExists? fullId
+    ;
+
+dropIndex
+    : DROP INDEX intimeAction=(ONLINE | OFFLINE)?
+      uid ON tableName
+      (
+        ALGORITHM '='? algType=(DEFAULT | INPLACE | COPY)
+        | LOCK '='?
+          lockType=(DEFAULT | NONE | SHARED | EXCLUSIVE)
+      )*
+    ;
+
+dropLogfileGroup
+    : DROP LOGFILE GROUP uid ENGINE '=' engineName
+    ;
+
+dropProcedure
+    : DROP PROCEDURE ifExists? fullId
+    ;
+
+dropFunction
+    : DROP FUNCTION ifExists? fullId
+    ;
+
+dropServer
+    : DROP SERVER ifExists? uid
+    ;
+
+dropTable
+    : DROP TEMPORARY? TABLE ifExists?
+      tables dropType=(RESTRICT | CASCADE)?
+    ;
+
+dropTablespace
+    : DROP TABLESPACE uid (ENGINE '='? engineName)?
+    ;
+
+dropTrigger
+    : DROP TRIGGER ifExists? fullId
+    ;
+
+dropView
+    : DROP VIEW ifExists?
+      fullId (',' fullId)* dropType=(RESTRICT | CASCADE)?
+    ;
+
+dropRole
+    : DROP ROLE ifExists? roleName (',' roleName)*
+    ;
+
+setRole
+    : SET DEFAULT ROLE (NONE | ALL | roleName (',' roleName)*)
+      TO (userName | uid) (',' (userName | uid))*
+    | SET ROLE roleOption
+    ;
+
+//    Other DDL statements
+
+renameTable
+    : RENAME TABLE
+    renameTableClause (',' renameTableClause)*
+    ;
+
+renameTableClause
+    : tableName TO tableName
+    ;
+
+truncateTable
+    : TRUNCATE TABLE? tableName
+    ;
+
+
+// Data Manipulation Language
+
+//    Primary DML Statements
+
+
+callStatement
+    : CALL fullId
+      (
+        '(' (constants | expressions)? ')'
+      )?
+    ;
+
+deleteStatement
+    : singleDeleteStatement | multipleDeleteStatement
+    ;
+
+doStatement
+    : DO expressions
+    ;
+
+handlerStatement
+    : handlerOpenStatement
+    | handlerReadIndexStatement
+    | handlerReadStatement
+    | handlerCloseStatement
+    ;
+
+insertStatement
+    : INSERT
+      priority=(LOW_PRIORITY | DELAYED | HIGH_PRIORITY)?
+      IGNORE? INTO? tableName
+      (PARTITION '(' partitions=uidList? ')' )?
+      (
+        ('(' columns=fullColumnNameList ')')? insertStatementValue (AS? uid)?
+        | SET
+            setFirst=updatedElement
+            (',' setElements+=updatedElement)*
+      )
+      (
+        ON DUPLICATE KEY UPDATE
+        duplicatedFirst=updatedElement
+        (',' duplicatedElements+=updatedElement)*
+      )?
+    ;
+
+loadDataStatement
+    : LOAD DATA
+      priority=(LOW_PRIORITY | CONCURRENT)?
+      LOCAL? INFILE filename=STRING_LITERAL
+      violation=(REPLACE | IGNORE)?
+      INTO TABLE tableName
+      (PARTITION '(' uidList ')' )?
+      (CHARACTER SET charset=charsetName)?
+      (
+        fieldsFormat=(FIELDS | COLUMNS)
+        selectFieldsInto+
+      )?
+      (
+        LINES
+          selectLinesInto+
+      )?
+      (
+        IGNORE decimalLiteral linesFormat=(LINES | ROWS)
+      )?
+      ( '(' assignmentField (',' assignmentField)* ')' )?
+      (SET updatedElement (',' updatedElement)*)?
+    ;
+
+loadXmlStatement
+    : LOAD XML
+      priority=(LOW_PRIORITY | CONCURRENT)?
+      LOCAL? INFILE filename=STRING_LITERAL
+      violation=(REPLACE | IGNORE)?
+      INTO TABLE tableName
+      (CHARACTER SET charset=charsetName)?
+      (ROWS IDENTIFIED BY '<' tag=STRING_LITERAL '>')?
+      ( IGNORE decimalLiteral linesFormat=(LINES | ROWS) )?
+      ( '(' assignmentField (',' assignmentField)* ')' )?
+      (SET updatedElement (',' updatedElement)*)?
+    ;
+
+replaceStatement
+    : REPLACE priority=(LOW_PRIORITY | DELAYED)?
+      INTO? tableName
+      (PARTITION '(' partitions=uidList ')' )?
+      (
+        ('(' columns=uidList ')')? insertStatementValue
+        | SET
+          setFirst=updatedElement
+          (',' setElements+=updatedElement)*
+      )
+    ;
+
+selectStatement
+    : querySpecification lockClause?                                #simpleSelect
+    | queryExpression lockClause?                                   #parenthesisSelect
+    | querySpecificationNointo unionStatement+
+        (
+          UNION unionType=(ALL | DISTINCT)?
+          (querySpecification | queryExpression)
+        )?
+        orderByClause? limitClause? lockClause?                     #unionSelect
+    | queryExpressionNointo unionParenthesis+
+        (
+          UNION unionType=(ALL | DISTINCT)?
+          queryExpression
+        )?
+        orderByClause? limitClause? lockClause?                     #unionParenthesisSelect
+    | querySpecificationNointo (',' lateralStatement)+              #withLateralStatement
+    ;
+
+updateStatement
+    : singleUpdateStatement | multipleUpdateStatement
+    ;
+
+// https://dev.mysql.com/doc/refman/8.0/en/values.html
+valuesStatement
+    : VALUES
+    '(' expressionsWithDefaults? ')'
+    (',' '(' expressionsWithDefaults? ')')*
+    ;
+
+// details
+
+insertStatementValue
+    : selectStatement
+    | insertFormat=(VALUES | VALUE)
+      '(' expressionsWithDefaults? ')'
+        (',' '(' expressionsWithDefaults? ')')*
+    ;
+
+updatedElement
+    : fullColumnName '=' (expression | DEFAULT)
+    ;
+
+assignmentField
+    : uid | LOCAL_ID
+    ;
+
+lockClause
+    : FOR UPDATE | LOCK IN SHARE MODE
+    ;
+
+//    Detailed DML Statements
+
+singleDeleteStatement
+    : DELETE priority=LOW_PRIORITY? QUICK? IGNORE?
+    FROM tableName (AS? uid)?
+      (PARTITION '(' uidList ')' )?
+      (WHERE expression)?
+      orderByClause? (LIMIT limitClauseAtom)?
+    ;
+
+multipleDeleteStatement
+    : DELETE priority=LOW_PRIORITY? QUICK? IGNORE?
+      (
+        tableName ('.' '*')? ( ',' tableName ('.' '*')? )*
+            FROM tableSources
+        | FROM
+            tableName ('.' '*')? ( ',' tableName ('.' '*')? )*
+            USING tableSources
+      )
+      (WHERE expression)?
+    ;
+
+handlerOpenStatement
+    : HANDLER tableName OPEN (AS? uid)?
+    ;
+
+handlerReadIndexStatement
+    : HANDLER tableName READ index=uid
+      (
+        comparisonOperator '(' constants ')'
+        | moveOrder=(FIRST | NEXT | PREV | LAST)
+      )
+      (WHERE expression)? (LIMIT limitClauseAtom)?
+    ;
+
+handlerReadStatement
+    : HANDLER tableName READ moveOrder=(FIRST | NEXT)
+      (WHERE expression)? (LIMIT limitClauseAtom)?
+    ;
+
+handlerCloseStatement
+    : HANDLER tableName CLOSE
+    ;
+
+singleUpdateStatement
+    : UPDATE priority=LOW_PRIORITY? IGNORE? tableName (AS? uid)?
+      SET updatedElement (',' updatedElement)*
+      (WHERE expression)? orderByClause? limitClause?
+    ;
+
+multipleUpdateStatement
+    : UPDATE priority=LOW_PRIORITY? IGNORE? tableSources
+      SET updatedElement (',' updatedElement)*
+      (WHERE expression)?
+    ;
+
+// details
+
+orderByClause
+    : ORDER BY orderByExpression (',' orderByExpression)*
+    ;
+
+orderByExpression
+    : expression order=(ASC | DESC)?
+    ;
+
+tableSources
+    : tableSource (',' tableSource)*
+    ;
+
+tableSource
+    : tableSourceItem joinPart*                                     #tableSourceBase
+    | '(' tableSourceItem joinPart* ')'                             #tableSourceNested
+    | jsonTable                                                     #tableJson
+    ;
+
+tableSourceItem
+    : tableName
+      (PARTITION '(' uidList ')' )? (AS? alias=uid)?
+      (indexHint (',' indexHint)* )?                                #atomTableItem
+    | (
+      selectStatement
+      | '(' parenthesisSubquery=selectStatement ')'
+      )
+      AS? alias=uid                                                 #subqueryTableItem
+    | '(' tableSources ')'                                          #tableSourcesItem
+    ;
+
+indexHint
+    : indexHintAction=(USE | IGNORE | FORCE)
+      keyFormat=(INDEX|KEY) ( FOR indexHintType)?
+      '(' uidList ')'
+    ;
+
+indexHintType
+    : JOIN | ORDER BY | GROUP BY
+    ;
+
+joinPart
+    : (INNER | CROSS)? JOIN LATERAL? tableSourceItem
+      (
+        ON expression
+        | USING '(' uidList ')'
+      )?                                                            #innerJoin
+    | STRAIGHT_JOIN tableSourceItem (ON expression)?                #straightJoin
+    | (LEFT | RIGHT) OUTER? JOIN LATERAL? tableSourceItem
+        (
+          ON expression
+          | USING '(' uidList ')'
+        )                                                           #outerJoin
+    | NATURAL ((LEFT | RIGHT) OUTER?)? JOIN tableSourceItem         #naturalJoin
+    ;
+
+//    Select Statement's Details
+
+queryExpression
+    : '(' querySpecification ')'
+    | '(' queryExpression ')'
+    ;
+
+queryExpressionNointo
+    : '(' querySpecificationNointo ')'
+    | '(' queryExpressionNointo ')'
+    ;
+
+querySpecification
+    : SELECT selectSpec* selectElements selectIntoExpression?
+      fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause?
+    | SELECT selectSpec* selectElements
+    fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause? selectIntoExpression?
+    ;
+
+querySpecificationNointo
+    : SELECT selectSpec* selectElements
+      fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause?
+    ;
+
+unionParenthesis
+    : UNION unionType=(ALL | DISTINCT)? queryExpressionNointo
+    ;
+
+unionStatement
+    : UNION unionType=(ALL | DISTINCT)?
+      (querySpecificationNointo | queryExpressionNointo)
+    ;
+
+lateralStatement
+    : LATERAL (querySpecificationNointo |
+               queryExpressionNointo |
+               ('(' (querySpecificationNointo | queryExpressionNointo) ')' (AS? uid)?)
+              )
+    ;
+
+// JSON
+
+// https://dev.mysql.com/doc/refman/8.0/en/json-table-functions.html
+jsonTable
+    : JSON_TABLE '('
+        STRING_LITERAL ','
+        STRING_LITERAL
+        COLUMNS '(' jsonColumnList ')'
+      ')' (AS? uid)?
+    ;
+
+jsonColumnList
+    : jsonColumn (',' jsonColumn)*
+    ;
+
+jsonColumn
+    : fullColumnName ( FOR ORDINALITY
+                     | dataType ( PATH STRING_LITERAL jsonOnEmpty? jsonOnError?
+                                | EXISTS PATH STRING_LITERAL ) )
+    | NESTED PATH? STRING_LITERAL COLUMNS '(' jsonColumnList ')'
+    ;
+
+jsonOnEmpty
+    : (NULL_LITERAL | ERROR | DEFAULT defaultValue) ON EMPTY
+    ;
+
+jsonOnError
+    : (NULL_LITERAL | ERROR | DEFAULT defaultValue) ON ERROR
+    ;
+
+// details
+
+selectSpec
+    : (ALL | DISTINCT | DISTINCTROW)
+    | HIGH_PRIORITY | STRAIGHT_JOIN | SQL_SMALL_RESULT
+    | SQL_BIG_RESULT | SQL_BUFFER_RESULT
+    | (SQL_CACHE | SQL_NO_CACHE)
+    | SQL_CALC_FOUND_ROWS
+    ;
+
+selectElements
+    : (star='*' | selectElement ) (',' selectElement)*
+    ;
+
+selectElement
+    : fullId '.' '*'                                                #selectStarElement
+    | fullColumnName (AS? uid)?                                     #selectColumnElement
+    | functionCall (AS? uid)?                                       #selectFunctionElement
+    | (LOCAL_ID VAR_ASSIGN)? expression (AS? uid)?                  #selectExpressionElement
+    ;
+
+selectIntoExpression
+    : INTO assignmentField (',' assignmentField )*                  #selectIntoVariables
+    | INTO DUMPFILE STRING_LITERAL                                  #selectIntoDumpFile
+    | (
+        INTO OUTFILE filename=STRING_LITERAL
+        (CHARACTER SET charset=charsetName)?
+        (
+          fieldsFormat=(FIELDS | COLUMNS)
+          selectFieldsInto+
+        )?
+        (
+          LINES selectLinesInto+
+        )?
+      )                                                             #selectIntoTextFile
+    ;
+
+selectFieldsInto
+    : TERMINATED BY terminationField=STRING_LITERAL
+    | OPTIONALLY? ENCLOSED BY enclosion=STRING_LITERAL
+    | ESCAPED BY escaping=STRING_LITERAL
+    ;
+
+selectLinesInto
+    : STARTING BY starting=STRING_LITERAL
+    | TERMINATED BY terminationLine=STRING_LITERAL
+    ;
+
+fromClause
+    : (FROM tableSources)?
+      (WHERE whereExpr=expression)?
+    ;
+
+groupByClause
+    :  GROUP BY
+        groupByItem (',' groupByItem)*
+        (WITH ROLLUP)?
+    ;
+
+havingClause
+    :  HAVING havingExpr=expression
+    ;
+
+windowClause
+    :  WINDOW windowName AS '(' windowSpec ')' (',' windowName AS '(' windowSpec ')')*
+    ;
+
+groupByItem
+    : expression order=(ASC | DESC)?
+    ;
+
+limitClause
+    : LIMIT
+    (
+      (offset=limitClauseAtom ',')? limit=limitClauseAtom
+      | limit=limitClauseAtom OFFSET offset=limitClauseAtom
+    )
+    ;
+
+limitClauseAtom
+	: decimalLiteral | mysqlVariable | simpleId
+	;
+
+
+// Transaction's Statements
+
+startTransaction
+    : START TRANSACTION (transactionMode (',' transactionMode)* )?
+    ;
+
+beginWork
+    : BEGIN WORK?
+    ;
+
+commitWork
+    : COMMIT WORK?
+      (AND nochain=NO? CHAIN)?
+      (norelease=NO? RELEASE)?
+    ;
+
+rollbackWork
+    : ROLLBACK WORK?
+      (AND nochain=NO? CHAIN)?
+      (norelease=NO? RELEASE)?
+    ;
+
+savepointStatement
+    : SAVEPOINT uid
+    ;
+
+rollbackStatement
+    : ROLLBACK WORK? TO SAVEPOINT? uid
+    ;
+
+releaseStatement
+    : RELEASE SAVEPOINT uid
+    ;
+
+lockTables
+    : LOCK (TABLE | TABLES) lockTableElement (',' lockTableElement)* waitNowaitClause?
+    ;
+
+unlockTables
+    : UNLOCK TABLES
+    ;
+
+
+// details
+
+setAutocommitStatement
+    : SET AUTOCOMMIT '=' autocommitValue=('0' | '1')
+    ;
+
+setTransactionStatement
+    : SET transactionContext=(GLOBAL | SESSION)? TRANSACTION
+      transactionOption (',' transactionOption)*
+    ;
+
+transactionMode
+    : WITH CONSISTENT SNAPSHOT
+    | READ WRITE
+    | READ ONLY
+    ;
+
+lockTableElement
+    : tableName (AS? uid)? lockAction
+    ;
+
+lockAction
+    : READ LOCAL? | LOW_PRIORITY? WRITE
+    ;
+
+transactionOption
+    : ISOLATION LEVEL transactionLevel
+    | READ WRITE
+    | READ ONLY
+    ;
+
+transactionLevel
+    : REPEATABLE READ
+    | READ COMMITTED
+    | READ UNCOMMITTED
+    | SERIALIZABLE
+    ;
+
+
+// Replication's Statements
+
+//    Base Replication
+
+changeMaster
+    : CHANGE MASTER TO
+      masterOption (',' masterOption)* channelOption?
+    ;
+
+changeReplicationFilter
+    : CHANGE REPLICATION FILTER
+      replicationFilter (',' replicationFilter)*
+    ;
+
+purgeBinaryLogs
+    : PURGE purgeFormat=(BINARY | MASTER) LOGS
+       (
+           TO fileName=STRING_LITERAL
+           | BEFORE timeValue=STRING_LITERAL
+       )
+    ;
+
+resetMaster
+    : RESET MASTER
+    ;
+
+resetSlave
+    : RESET SLAVE ALL? channelOption?
+    ;
+
+startSlave
+    : START SLAVE (threadType (',' threadType)*)?
+      (UNTIL untilOption)?
+      connectionOption* channelOption?
+    ;
+
+stopSlave
+    : STOP SLAVE (threadType (',' threadType)*)?
+    ;
+
+startGroupReplication
+    : START GROUP_REPLICATION
+    ;
+
+stopGroupReplication
+    : STOP GROUP_REPLICATION
+    ;
+
+// details
+
+masterOption
+    : stringMasterOption '=' STRING_LITERAL                         #masterStringOption
+    | decimalMasterOption '=' decimalLiteral                        #masterDecimalOption
+    | boolMasterOption '=' boolVal=('0' | '1')                      #masterBoolOption
+    | MASTER_HEARTBEAT_PERIOD '=' REAL_LITERAL                      #masterRealOption
+    | IGNORE_SERVER_IDS '=' '(' (uid (',' uid)*)? ')'               #masterUidListOption
+    ;
+
+stringMasterOption
+    : MASTER_BIND | MASTER_HOST | MASTER_USER | MASTER_PASSWORD
+    | MASTER_LOG_FILE | RELAY_LOG_FILE | MASTER_SSL_CA
+    | MASTER_SSL_CAPATH | MASTER_SSL_CERT | MASTER_SSL_CRL
+    | MASTER_SSL_CRLPATH | MASTER_SSL_KEY | MASTER_SSL_CIPHER
+    | MASTER_TLS_VERSION
+    ;
+decimalMasterOption
+    : MASTER_PORT | MASTER_CONNECT_RETRY | MASTER_RETRY_COUNT
+    | MASTER_DELAY | MASTER_LOG_POS | RELAY_LOG_POS
+    ;
+
+boolMasterOption
+    : MASTER_AUTO_POSITION | MASTER_SSL
+    | MASTER_SSL_VERIFY_SERVER_CERT
+    ;
+
+channelOption
+    : FOR CHANNEL STRING_LITERAL
+    ;
+
+replicationFilter
+    : REPLICATE_DO_DB '=' '(' uidList ')'                           #doDbReplication
+    | REPLICATE_IGNORE_DB '=' '(' uidList ')'                       #ignoreDbReplication
+    | REPLICATE_DO_TABLE '=' '(' tables ')'                         #doTableReplication
+    | REPLICATE_IGNORE_TABLE '=' '(' tables ')'                     #ignoreTableReplication
+    | REPLICATE_WILD_DO_TABLE '=' '(' simpleStrings ')'             #wildDoTableReplication
+    | REPLICATE_WILD_IGNORE_TABLE
+       '=' '(' simpleStrings ')'                                    #wildIgnoreTableReplication
+    | REPLICATE_REWRITE_DB '='
+      '(' tablePair (',' tablePair)* ')'                            #rewriteDbReplication
+    ;
+
+tablePair
+    : '(' firstTable=tableName ',' secondTable=tableName ')'
+    ;
+
+threadType
+    : IO_THREAD | SQL_THREAD
+    ;
+
+untilOption
+    : gtids=(SQL_BEFORE_GTIDS | SQL_AFTER_GTIDS)
+      '=' gtuidSet                                                  #gtidsUntilOption
+    | MASTER_LOG_FILE '=' STRING_LITERAL
+      ',' MASTER_LOG_POS '=' decimalLiteral                         #masterLogUntilOption
+    | RELAY_LOG_FILE '=' STRING_LITERAL
+      ',' RELAY_LOG_POS '=' decimalLiteral                          #relayLogUntilOption
+    | SQL_AFTER_MTS_GAPS                                            #sqlGapsUntilOption
+    ;
+
+connectionOption
+    : USER '=' conOptUser=STRING_LITERAL                            #userConnectionOption
+    | PASSWORD '=' conOptPassword=STRING_LITERAL                    #passwordConnectionOption
+    | DEFAULT_AUTH '=' conOptDefAuth=STRING_LITERAL                 #defaultAuthConnectionOption
+    | PLUGIN_DIR '=' conOptPluginDir=STRING_LITERAL                 #pluginDirConnectionOption
+    ;
+
+gtuidSet
+    : uuidSet (',' uuidSet)*
+    | STRING_LITERAL
+    ;
+
+
+//    XA Transactions
+
+xaStartTransaction
+    : XA xaStart=(START | BEGIN) xid xaAction=(JOIN | RESUME)?
+    ;
+
+xaEndTransaction
+    : XA END xid (SUSPEND (FOR MIGRATE)?)?
+    ;
+
+xaPrepareStatement
+    : XA PREPARE xid
+    ;
+
+xaCommitWork
+    : XA COMMIT xid (ONE PHASE)?
+    ;
+
+xaRollbackWork
+    : XA ROLLBACK xid
+    ;
+
+xaRecoverWork
+    : XA RECOVER (CONVERT xid)?
+    ;
+
+
+// Prepared Statements
+
+prepareStatement
+    : PREPARE uid FROM
+      (query=STRING_LITERAL | variable=LOCAL_ID)
+    ;
+
+executeStatement
+    : EXECUTE uid (USING userVariables)?
+    ;
+
+deallocatePrepare
+    : dropFormat=(DEALLOCATE | DROP) PREPARE uid
+    ;
+
+
+// Compound Statements
+
+routineBody
+    : blockStatement | sqlStatement
+    ;
+
+// details
+
+blockStatement
+    : (uid ':')? BEGIN
+        (declareVariable SEMI)*
+        (declareCondition SEMI)*
+        (declareCursor SEMI)*
+        (declareHandler SEMI)*
+        procedureSqlStatement*
+      END uid?
+    ;
+
+caseStatement
+    : CASE (uid | expression)? caseAlternative+
+      (ELSE procedureSqlStatement+)?
+      END CASE
+    ;
+
+ifStatement
+    : IF expression
+      THEN thenStatements+=procedureSqlStatement+
+      elifAlternative*
+      (ELSE elseStatements+=procedureSqlStatement+ )?
+      END IF
+    ;
+
+iterateStatement
+    : ITERATE uid
+    ;
+
+leaveStatement
+    : LEAVE uid
+    ;
+
+loopStatement
+    : (uid ':')?
+      LOOP procedureSqlStatement+
+      END LOOP uid?
+    ;
+
+repeatStatement
+    : (uid ':')?
+      REPEAT procedureSqlStatement+
+      UNTIL expression
+      END REPEAT uid?
+    ;
+
+returnStatement
+    : RETURN expression
+    ;
+
+whileStatement
+    : (uid ':')?
+      WHILE expression
+      DO procedureSqlStatement+
+      END WHILE uid?
+    ;
+
+cursorStatement
+    : CLOSE uid                                                     #CloseCursor
+    | FETCH (NEXT? FROM)? uid INTO uidList                          #FetchCursor
+    | OPEN uid                                                      #OpenCursor
+    ;
+
+// details
+
+declareVariable
+    : DECLARE uidList dataType (DEFAULT expression)?
+    ;
+
+declareCondition
+    : DECLARE uid CONDITION FOR
+      ( decimalLiteral | SQLSTATE VALUE? STRING_LITERAL)
+    ;
+
+declareCursor
+    : DECLARE uid CURSOR FOR selectStatement
+    ;
+
+declareHandler
+    : DECLARE handlerAction=(CONTINUE | EXIT | UNDO)
+      HANDLER FOR
+      handlerConditionValue (',' handlerConditionValue)*
+      routineBody
+    ;
+
+handlerConditionValue
+    : decimalLiteral                                                #handlerConditionCode
+    | SQLSTATE VALUE? STRING_LITERAL                                #handlerConditionState
+    | uid                                                           #handlerConditionName
+    | SQLWARNING                                                    #handlerConditionWarning
+    | NOT FOUND                                                     #handlerConditionNotfound
+    | SQLEXCEPTION                                                  #handlerConditionException
+    ;
+
+procedureSqlStatement
+    : (compoundStatement | sqlStatement) SEMI
+    ;
+
+caseAlternative
+    : WHEN (constant | expression)
+      THEN procedureSqlStatement+
+    ;
+
+elifAlternative
+    : ELSEIF expression
+      THEN procedureSqlStatement+
+    ;
+
+// Administration Statements
+
+//    Account management statements
+
+alterUser
+    : ALTER USER
+      userSpecification (',' userSpecification)*                    #alterUserMysqlV56
+    | ALTER USER ifExists?
+        userAuthOption (',' userAuthOption)*
+        (
+          REQUIRE
+          (tlsNone=NONE | tlsOption (AND? tlsOption)* )
+        )?
+        (WITH userResourceOption+)?
+        (userPasswordOption | userLockOption)*
+        (COMMENT STRING_LITERAL |  ATTRIBUTE STRING_LITERAL)?       #alterUserMysqlV80
+    | ALTER USER ifExists?
+      (userName | uid) DEFAULT ROLE roleOption                      #alterUserMysqlV80
+    ;
+
+createUser
+    : CREATE USER userAuthOption (',' userAuthOption)*              #createUserMysqlV56
+    | CREATE USER ifNotExists?
+        userAuthOption (',' userAuthOption)*
+        (DEFAULT ROLE roleOption)?
+        (
+          REQUIRE
+          (tlsNone=NONE | tlsOption (AND? tlsOption)* )
+        )?
+        (WITH userResourceOption+)?
+        (userPasswordOption | userLockOption)*
+        (COMMENT STRING_LITERAL |  ATTRIBUTE STRING_LITERAL)?       #createUserMysqlV80
+    ;
+
+dropUser
+    : DROP USER ifExists? userName (',' userName)*
+    ;
+
+grantStatement
+    : GRANT privelegeClause (',' privelegeClause)*
+      ON
+      privilegeObject=(TABLE | FUNCTION | PROCEDURE)?
+      privilegeLevel
+      TO userAuthOption (',' userAuthOption)*
+      (
+          REQUIRE
+          (tlsNone=NONE | tlsOption (AND? tlsOption)* )
+        )?
+      (WITH (GRANT OPTION | userResourceOption)* )?
+      (AS userName WITH ROLE roleOption)?
+    | GRANT (userName | uid) (',' (userName | uid))*
+      TO (userName | uid) (',' (userName | uid))*
+      (WITH ADMIN OPTION)?
+    ;
+
+roleOption
+    : DEFAULT
+    | NONE
+    | ALL (EXCEPT userName (',' userName)*)?
+    | userName (',' userName)*
+    ;
+
+grantProxy
+    : GRANT PROXY ON fromFirst=userName
+      TO toFirst=userName (',' toOther+=userName)*
+      (WITH GRANT OPTION)?
+    ;
+
+renameUser
+    : RENAME USER
+      renameUserClause (',' renameUserClause)*
+    ;
+
+revokeStatement
+    : REVOKE privelegeClause (',' privelegeClause)*
+      ON
+      privilegeObject=(TABLE | FUNCTION | PROCEDURE)?
+      privilegeLevel
+      FROM userName (',' userName)*                                 #detailRevoke
+    | REVOKE ALL PRIVILEGES? ',' GRANT OPTION
+      FROM userName (',' userName)*                                 #shortRevoke
+    | REVOKE (userName | uid) (',' (userName | uid))*
+      FROM (userName | uid) (',' (userName | uid))*                 #roleRevoke
+    ;
+
+revokeProxy
+    : REVOKE PROXY ON onUser=userName
+      FROM fromFirst=userName (',' fromOther+=userName)*
+    ;
+
+setPasswordStatement
+    : SET PASSWORD (FOR userName)?
+      '=' ( passwordFunctionClause | STRING_LITERAL)
+    ;
+
+// details
+
+userSpecification
+    : userName userPasswordOption
+    ;
+
+userAuthOption
+    : userName IDENTIFIED BY PASSWORD hashed=STRING_LITERAL         #hashAuthOption
+    | userName
+      IDENTIFIED BY STRING_LITERAL (RETAIN CURRENT PASSWORD)?       #stringAuthOption
+    | userName
+      IDENTIFIED WITH
+      authenticationRule                                            #moduleAuthOption
+    | userName                                                      #simpleAuthOption
+    ;
+
+authenticationRule
+    : authPlugin
+      ((BY | USING | AS) STRING_LITERAL)?                           #module
+    | authPlugin
+      USING passwordFunctionClause                                  #passwordModuleOption
+    ;
+
+tlsOption
+    : SSL
+    | X509
+    | CIPHER STRING_LITERAL
+    | ISSUER STRING_LITERAL
+    | SUBJECT STRING_LITERAL
+    ;
+
+userResourceOption
+    : MAX_QUERIES_PER_HOUR decimalLiteral
+    | MAX_UPDATES_PER_HOUR decimalLiteral
+    | MAX_CONNECTIONS_PER_HOUR decimalLiteral
+    | MAX_USER_CONNECTIONS decimalLiteral
+    ;
+
+userPasswordOption
+    : PASSWORD EXPIRE
+      (expireType=DEFAULT
+      | expireType=NEVER
+      | expireType=INTERVAL decimalLiteral DAY
+      )?
+    | PASSWORD HISTORY (DEFAULT | decimalLiteral)
+    | PASSWORD REUSE INTERVAL (DEFAULT | decimalLiteral DAY)
+    | PASSWORD REQUIRE CURRENT (OPTIONAL | DEFAULT)?
+    | FAILED_LOGIN_ATTEMPTS decimalLiteral
+    | PASSWORD_LOCK_TIME (decimalLiteral | UNBOUNDED)
+    ;
+
+userLockOption
+    : ACCOUNT lockType=(LOCK | UNLOCK)
+    ;
+
+privelegeClause
+    : privilege ( '(' uidList ')' )?
+    ;
+
+privilege
+    : ALL PRIVILEGES?
+    | ALTER ROUTINE?
+    | CREATE
+      (TEMPORARY TABLES | ROUTINE | VIEW | USER | TABLESPACE | ROLE)?
+    | DELETE | DROP (ROLE)? | EVENT | EXECUTE | FILE | GRANT OPTION
+    | INDEX | INSERT | LOCK TABLES | PROCESS | PROXY
+    | REFERENCES | RELOAD
+    | REPLICATION (CLIENT | SLAVE)
+    | SELECT
+    | SHOW (VIEW | DATABASES)
+    | SHUTDOWN | SUPER | TRIGGER | UPDATE | USAGE
+    | APPLICATION_PASSWORD_ADMIN | AUDIT_ABORT_EXEMPT | AUDIT_ADMIN | AUTHENTICATION_POLICY_ADMIN | BACKUP_ADMIN | BINLOG_ADMIN | BINLOG_ENCRYPTION_ADMIN | CLONE_ADMIN
+    | CONNECTION_ADMIN | ENCRYPTION_KEY_ADMIN | FIREWALL_ADMIN | FIREWALL_EXEMPT | FIREWALL_USER | FLUSH_OPTIMIZER_COSTS
+    | FLUSH_STATUS | FLUSH_TABLES | FLUSH_USER_RESOURCES | GROUP_REPLICATION_ADMIN
+    | INNODB_REDO_LOG_ARCHIVE | INNODB_REDO_LOG_ENABLE | NDB_STORED_USER | PASSWORDLESS_USER_ADMIN | PERSIST_RO_VARIABLES_ADMIN | REPLICATION_APPLIER
+    | REPLICATION_SLAVE_ADMIN | RESOURCE_GROUP_ADMIN | RESOURCE_GROUP_USER | ROLE_ADMIN
+    | SERVICE_CONNECTION_ADMIN
+    | SESSION_VARIABLES_ADMIN | SET_USER_ID | SKIP_QUERY_REWRITE | SHOW_ROUTINE | SYSTEM_USER | SYSTEM_VARIABLES_ADMIN
+    | TABLE_ENCRYPTION_ADMIN | TP_CONNECTION_ADMIN | VERSION_TOKEN_ADMIN | XA_RECOVER_ADMIN
+    // MySQL on Amazon RDS
+    | LOAD FROM S3 | SELECT INTO S3 | INVOKE LAMBDA
+    ;
+
+privilegeLevel
+    : '*'                                                           #currentSchemaPriviLevel
+    | '*' '.' '*'                                                   #globalPrivLevel
+    | uid '.' '*'                                                   #definiteSchemaPrivLevel
+    | uid '.' uid                                                   #definiteFullTablePrivLevel
+    | uid dottedId                                                  #definiteFullTablePrivLevel2
+    | uid                                                           #definiteTablePrivLevel
+    ;
+
+renameUserClause
+    : fromFirst=userName TO toFirst=userName
+    ;
+
+//    Table maintenance statements
+
+analyzeTable
+    : ANALYZE actionOption=(NO_WRITE_TO_BINLOG | LOCAL)?
+       (TABLE | TABLES) tables
+       ( UPDATE HISTOGRAM ON fullColumnName (',' fullColumnName)* (WITH decimalLiteral BUCKETS)? )?
+       ( DROP HISTOGRAM ON fullColumnName (',' fullColumnName)* )?
+    ;
+
+checkTable
+    : CHECK TABLE tables checkTableOption*
+    ;
+
+checksumTable
+    : CHECKSUM TABLE tables actionOption=(QUICK | EXTENDED)?
+    ;
+
+optimizeTable
+    : OPTIMIZE actionOption=(NO_WRITE_TO_BINLOG | LOCAL)?
+      (TABLE | TABLES) tables
+    ;
+
+repairTable
+    : REPAIR actionOption=(NO_WRITE_TO_BINLOG | LOCAL)?
+      TABLE tables
+      QUICK? EXTENDED? USE_FRM?
+    ;
+
+// details
+
+checkTableOption
+    : FOR UPGRADE | QUICK | FAST | MEDIUM | EXTENDED | CHANGED
+    ;
+
+
+//    Plugin and udf statements
+
+createUdfunction
+    : CREATE AGGREGATE? FUNCTION ifNotExists? uid
+      RETURNS returnType=(STRING | INTEGER | REAL | DECIMAL)
+      SONAME STRING_LITERAL
+    ;
+
+installPlugin
+    : INSTALL PLUGIN uid SONAME STRING_LITERAL
+    ;
+
+uninstallPlugin
+    : UNINSTALL PLUGIN uid
+    ;
+
+
+//    Set and show statements
+
+setStatement
+    : SET variableClause ('=' | ':=') (expression | ON)
+      (',' variableClause ('=' | ':=') (expression | ON))*                      #setVariable
+    | SET charSet (charsetName | DEFAULT)          #setCharset
+    | SET NAMES
+        (charsetName (COLLATE collationName)? | DEFAULT)                        #setNames
+    | setPasswordStatement                                                      #setPassword
+    | setTransactionStatement                                                   #setTransaction
+    | setAutocommitStatement                                                    #setAutocommit
+    | SET fullId ('=' | ':=') expression
+      (',' fullId ('=' | ':=') expression)*                                     #setNewValueInsideTrigger
+    ;
+
+showStatement
+    : SHOW logFormat=(BINARY | MASTER) LOGS                         #showMasterLogs
+    | SHOW logFormat=(BINLOG | RELAYLOG)
+      EVENTS (IN filename=STRING_LITERAL)?
+        (FROM fromPosition=decimalLiteral)?
+        (LIMIT
+          (offset=decimalLiteral ',')?
+          rowCount=decimalLiteral
+        )?                                                          #showLogEvents
+    | SHOW showCommonEntity showFilter?                             #showObjectFilter
+    | SHOW FULL? columnsFormat=(COLUMNS | FIELDS)
+      tableFormat=(FROM | IN) tableName
+        (schemaFormat=(FROM | IN) uid)? showFilter?                 #showColumns
+    | SHOW CREATE schemaFormat=(DATABASE | SCHEMA)
+      ifNotExists? uid                                              #showCreateDb
+    | SHOW CREATE
+        namedEntity=(
+          EVENT | FUNCTION | PROCEDURE
+          | TABLE | TRIGGER | VIEW
+        )
+        fullId                                                      #showCreateFullIdObject
+    | SHOW CREATE USER userName                                     #showCreateUser
+    | SHOW ENGINE engineName engineOption=(STATUS | MUTEX)          #showEngine
+    | SHOW showGlobalInfoClause                                     #showGlobalInfo
+    | SHOW errorFormat=(ERRORS | WARNINGS)
+        (LIMIT
+          (offset=decimalLiteral ',')?
+          rowCount=decimalLiteral
+        )?                                                          #showErrors
+    | SHOW COUNT '(' '*' ')' errorFormat=(ERRORS | WARNINGS)        #showCountErrors
+    | SHOW showSchemaEntity
+        (schemaFormat=(FROM | IN) uid)? showFilter?                 #showSchemaFilter
+    | SHOW routine=(FUNCTION | PROCEDURE) CODE fullId               #showRoutine
+    | SHOW GRANTS (FOR userName)?                                   #showGrants
+    | SHOW indexFormat=(INDEX | INDEXES | KEYS)
+      tableFormat=(FROM | IN) tableName
+        (schemaFormat=(FROM | IN) uid)? (WHERE expression)?         #showIndexes
+    | SHOW OPEN TABLES ( schemaFormat=(FROM | IN) uid)?
+      showFilter?                                                   #showOpenTables
+    | SHOW PROFILE showProfileType (',' showProfileType)*
+        (FOR QUERY queryCount=decimalLiteral)?
+        (LIMIT
+          (offset=decimalLiteral ',')?
+          rowCount=decimalLiteral
+        )                                                           #showProfile
+    | SHOW SLAVE STATUS (FOR CHANNEL STRING_LITERAL)?               #showSlaveStatus
+    ;
+
+// details
+
+variableClause
+    : LOCAL_ID | GLOBAL_ID | ( ('@' '@')? (GLOBAL | SESSION | LOCAL)  )? uid
+    ;
+
+showCommonEntity
+    : CHARACTER SET | COLLATION | DATABASES | SCHEMAS
+    | FUNCTION STATUS | PROCEDURE STATUS
+    | (GLOBAL | SESSION)? (STATUS | VARIABLES)
+    ;
+
+showFilter
+    : LIKE STRING_LITERAL
+    | WHERE expression
+    ;
+
+showGlobalInfoClause
+    : STORAGE? ENGINES | MASTER STATUS | PLUGINS
+    | PRIVILEGES | FULL? PROCESSLIST | PROFILES
+    | SLAVE HOSTS | AUTHORS | CONTRIBUTORS
+    ;
+
+showSchemaEntity
+    : EVENTS | TABLE STATUS | FULL? TABLES | TRIGGERS
+    ;
+
+showProfileType
+    : ALL | BLOCK IO | CONTEXT SWITCHES | CPU | IPC | MEMORY
+    | PAGE FAULTS | SOURCE | SWAPS
+    ;
+
+
+//    Other administrative statements
+
+binlogStatement
+    : BINLOG STRING_LITERAL
+    ;
+
+cacheIndexStatement
+    : CACHE INDEX tableIndexes (',' tableIndexes)*
+      ( PARTITION '(' (uidList | ALL) ')' )?
+      IN schema=uid
+    ;
+
+flushStatement
+    : FLUSH flushFormat=(NO_WRITE_TO_BINLOG | LOCAL)?
+      flushOption (',' flushOption)*
+    ;
+
+killStatement
+    : KILL connectionFormat=(CONNECTION | QUERY)? expression
+    ;
+
+loadIndexIntoCache
+    : LOAD INDEX INTO CACHE
+      loadedTableIndexes (',' loadedTableIndexes)*
+    ;
+
+// remark reset (maser | slave) describe in replication's
+//  statements section
+resetStatement
+    : RESET QUERY CACHE
+    ;
+
+shutdownStatement
+    : SHUTDOWN
+    ;
+
+// details
+
+tableIndexes
+    : tableName ( indexFormat=(INDEX | KEY)? '(' uidList ')' )?
+    ;
+
+flushOption
+    : (
+        DES_KEY_FILE | HOSTS
+        | (
+            BINARY | ENGINE | ERROR | GENERAL | RELAY | SLOW
+          )? LOGS
+        | OPTIMIZER_COSTS | PRIVILEGES | QUERY CACHE | STATUS
+        | USER_RESOURCES | TABLES (WITH READ LOCK)?
+       )                                                            #simpleFlushOption
+    | RELAY LOGS channelOption?                                     #channelFlushOption
+    | (TABLE | TABLES) tables? flushTableOption?                    #tableFlushOption
+    ;
+
+flushTableOption
+    : WITH READ LOCK
+    | FOR EXPORT
+    ;
+
+loadedTableIndexes
+    : tableName
+      ( PARTITION '(' (partitionList=uidList | ALL) ')' )?
+      ( indexFormat=(INDEX | KEY)? '(' indexList=uidList ')' )?
+      (IGNORE LEAVES)?
+    ;
+
+
+// Utility Statements
+
+
+simpleDescribeStatement
+    : command=(EXPLAIN | DESCRIBE | DESC) tableName
+      (column=uid | pattern=STRING_LITERAL)?
+    ;
+
+fullDescribeStatement
+    : command=(EXPLAIN | DESCRIBE | DESC)
+      (
+        formatType=(EXTENDED | PARTITIONS | FORMAT )
+        '='
+        formatValue=(TRADITIONAL | JSON)
+      )?
+      describeObjectClause
+    ;
+
+helpStatement
+    : HELP STRING_LITERAL
+    ;
+
+useStatement
+    : USE uid
+    ;
+
+signalStatement
+    : SIGNAL ( ( SQLSTATE VALUE? stringLiteral ) | ID | REVERSE_QUOTE_ID )
+        ( SET signalConditionInformation ( ',' signalConditionInformation)* )?
+    ;
+
+resignalStatement
+    : RESIGNAL ( ( SQLSTATE VALUE? stringLiteral ) | ID | REVERSE_QUOTE_ID )?
+        ( SET signalConditionInformation ( ',' signalConditionInformation)* )?
+    ;
+
+signalConditionInformation
+    : ( CLASS_ORIGIN
+          | SUBCLASS_ORIGIN
+          | MESSAGE_TEXT
+          | MYSQL_ERRNO
+          | CONSTRAINT_CATALOG
+          | CONSTRAINT_SCHEMA
+          | CONSTRAINT_NAME
+          | CATALOG_NAME
+          | SCHEMA_NAME
+          | TABLE_NAME
+          | COLUMN_NAME
+          | CURSOR_NAME
+        ) '=' ( stringLiteral | DECIMAL_LITERAL | mysqlVariable | simpleId )
+    ;
+
+withStatement
+  : WITH RECURSIVE? commonTableExpressions (',' commonTableExpressions)*
+  ;
+
+diagnosticsStatement
+    : GET ( CURRENT | STACKED )? DIAGNOSTICS (
+          ( variableClause '=' ( NUMBER | ROW_COUNT ) ( ',' variableClause '=' ( NUMBER | ROW_COUNT ) )* )
+        | ( CONDITION  ( decimalLiteral | variableClause ) variableClause '=' diagnosticsConditionInformationName ( ',' variableClause '=' diagnosticsConditionInformationName )* )
+      )
+    ;
+
+diagnosticsConditionInformationName
+    : CLASS_ORIGIN
+    | SUBCLASS_ORIGIN
+    | RETURNED_SQLSTATE
+    | MESSAGE_TEXT
+    | MYSQL_ERRNO
+    | CONSTRAINT_CATALOG
+    | CONSTRAINT_SCHEMA
+    | CONSTRAINT_NAME
+    | CATALOG_NAME
+    | SCHEMA_NAME
+    | TABLE_NAME
+    | COLUMN_NAME
+    | CURSOR_NAME
+    ;
+
+// details
+
+describeObjectClause
+    : (
+        selectStatement | deleteStatement | insertStatement
+        | replaceStatement | updateStatement
+      )                                                             #describeStatements
+    | FOR CONNECTION uid                                            #describeConnection
+    ;
+
+
+// Common Clauses
+
+//    DB Objects
+
+fullId
+    : uid (DOT_ID | '.' uid)?
+    ;
+
+tableName
+    : fullId
+    ;
+
+roleName
+    : userName | uid
+    ;
+
+fullColumnName
+    : uid (dottedId dottedId? )?
+    | .? dottedId dottedId?
+    ;
+
+indexColumnName
+    : ((uid | STRING_LITERAL) ('(' decimalLiteral ')')? | expression) sortType=(ASC | DESC)?
+    ;
+
+userName
+    : STRING_USER_NAME | ID | STRING_LITERAL | ADMIN | keywordsCanBeId;
+
+mysqlVariable
+    : LOCAL_ID
+    | GLOBAL_ID
+    ;
+
+charsetName
+    : BINARY
+    | charsetNameBase
+    | STRING_LITERAL
+    | CHARSET_REVERSE_QOUTE_STRING
+    ;
+
+collationName
+    : uid | STRING_LITERAL;
+
+engineName
+    : ARCHIVE | BLACKHOLE | CSV | FEDERATED | INNODB | MEMORY
+    | MRG_MYISAM | MYISAM | NDB | NDBCLUSTER | PERFORMANCE_SCHEMA
+    | TOKUDB
+    | ID
+    | STRING_LITERAL | REVERSE_QUOTE_ID
+    | CONNECT
+    ;
+
+uuidSet
+    : decimalLiteral '-' decimalLiteral '-' decimalLiteral
+      '-' decimalLiteral '-' decimalLiteral
+      (':' decimalLiteral '-' decimalLiteral)+
+    ;
+
+xid
+    : globalTableUid=xuidStringId
+      (
+        ',' qualifier=xuidStringId
+        (',' idFormat=decimalLiteral)?
+      )?
+    ;
+
+xuidStringId
+    : STRING_LITERAL
+    | BIT_STRING
+    | HEXADECIMAL_LITERAL+
+    ;
+
+authPlugin
+    : uid | STRING_LITERAL
+    ;
+
+uid
+    : simpleId
+    //| DOUBLE_QUOTE_ID
+    | REVERSE_QUOTE_ID
+    | CHARSET_REVERSE_QOUTE_STRING
+    ;
+
+simpleId
+    : ID
+    | charsetNameBase
+    | transactionLevelBase
+    | engineName
+    | privilegesBase
+    | intervalTypeBase
+    | dataTypeBase
+    | keywordsCanBeId
+    | scalarFunctionName
+    ;
+
+dottedId
+    : DOT_ID
+    | '.' uid
+    ;
+
+
+//    Literals
+
+decimalLiteral
+    : DECIMAL_LITERAL | ZERO_DECIMAL | ONE_DECIMAL | TWO_DECIMAL | REAL_LITERAL
+    ;
+
+fileSizeLiteral
+    : FILESIZE_LITERAL | decimalLiteral;
+
+stringLiteral
+    : (
+        STRING_CHARSET_NAME? STRING_LITERAL
+        | START_NATIONAL_STRING_LITERAL
+      ) STRING_LITERAL+
+    | (
+        STRING_CHARSET_NAME? STRING_LITERAL
+        | START_NATIONAL_STRING_LITERAL
+      ) (COLLATE collationName)?
+    ;
+
+booleanLiteral
+    : TRUE | FALSE;
+
+hexadecimalLiteral
+    : STRING_CHARSET_NAME? HEXADECIMAL_LITERAL;
+
+nullNotnull
+    : NOT? (NULL_LITERAL | NULL_SPEC_LITERAL)
+    ;
+
+constant
+    : stringLiteral | decimalLiteral
+    | '-' decimalLiteral
+    | hexadecimalLiteral | booleanLiteral
+    | REAL_LITERAL | BIT_STRING
+    | NOT? nullLiteral=(NULL_LITERAL | NULL_SPEC_LITERAL)
+    ;
+
+
+//    Data Types
+
+dataType
+    : typeName=(
+      CHAR | CHARACTER | VARCHAR | TINYTEXT | TEXT | MEDIUMTEXT | LONGTEXT
+       | NCHAR | NVARCHAR | LONG
+      )
+      VARYING?
+      lengthOneDimension? BINARY?
+      (charSet charsetName)?
+      (COLLATE collationName | BINARY)?                             #stringDataType
+    | NATIONAL typeName=(CHAR | CHARACTER) VARYING
+      lengthOneDimension? BINARY?                                   #nationalVaryingStringDataType
+    | NATIONAL typeName=(VARCHAR | CHARACTER | CHAR)
+      lengthOneDimension? BINARY?                                   #nationalStringDataType
+    | NCHAR typeName=VARCHAR
+      lengthOneDimension? BINARY?                                   #nationalStringDataType
+    | typeName=(
+        TINYINT | SMALLINT | MEDIUMINT | INT | INTEGER | BIGINT
+        | MIDDLEINT | INT1 | INT2 | INT3 | INT4 | INT8
+      )
+      lengthOneDimension? (SIGNED | UNSIGNED | ZEROFILL)*           #dimensionDataType
+    | typeName=REAL
+      lengthTwoDimension? (SIGNED | UNSIGNED | ZEROFILL)*           #dimensionDataType
+    | typeName=DOUBLE PRECISION?
+      lengthTwoDimension? (SIGNED | UNSIGNED | ZEROFILL)*           #dimensionDataType
+    | typeName=(DECIMAL | DEC | FIXED | NUMERIC | FLOAT | FLOAT4 | FLOAT8)
+      lengthTwoOptionalDimension? (SIGNED | UNSIGNED | ZEROFILL)*   #dimensionDataType
+    | typeName=(
+        DATE | TINYBLOB | MEDIUMBLOB | LONGBLOB
+        | BOOL | BOOLEAN | SERIAL
+      )                                                             #simpleDataType
+    | typeName=(
+        BIT | TIME | TIMESTAMP | DATETIME | BINARY
+        | VARBINARY | BLOB | YEAR
+      )
+      lengthOneDimension?                                           #dimensionDataType
+    | typeName=(ENUM | SET)
+      collectionOptions BINARY?
+      (charSet charsetName)?                                        #collectionDataType
+    | typeName=(
+        GEOMETRYCOLLECTION | GEOMCOLLECTION | LINESTRING | MULTILINESTRING
+        | MULTIPOINT | MULTIPOLYGON | POINT | POLYGON | JSON | GEOMETRY
+      )  (SRID decimalLiteral)?                                    #spatialDataType
+    | typeName=LONG VARCHAR?
+      BINARY?
+      (charSet charsetName)?
+      (COLLATE collationName)?                                      #longVarcharDataType    // LONG VARCHAR is the same as LONG
+    | LONG VARBINARY                                                #longVarbinaryDataType
+    ;
+
+collectionOptions
+    : '(' STRING_LITERAL (',' STRING_LITERAL)* ')'
+    ;
+
+convertedDataType
+    :
+    (
+      typeName=(BINARY| NCHAR) lengthOneDimension?
+      | typeName=CHAR lengthOneDimension? (charSet charsetName)?
+      | typeName=(DATE | DATETIME | TIME | JSON | INT | INTEGER)
+      | typeName=DECIMAL lengthTwoOptionalDimension?
+      | (SIGNED | UNSIGNED) INTEGER?
+    ) ARRAY?
+    ;
+
+lengthOneDimension
+    : '(' decimalLiteral ')'
+    ;
+
+lengthTwoDimension
+    : '(' decimalLiteral ',' decimalLiteral ')'
+    ;
+
+lengthTwoOptionalDimension
+    : '(' decimalLiteral (',' decimalLiteral)? ')'
+    ;
+
+
+//    Common Lists
+
+uidList
+    : uid (',' uid)*
+    ;
+
+fullColumnNameList
+    : fullColumnName (',' fullColumnName)*
+    ;
+
+tables
+    : tableName (',' tableName)*
+    ;
+
+indexColumnNames
+    : '(' indexColumnName (',' indexColumnName)* ')'
+    ;
+
+expressions
+    : expression (',' expression)*
+    ;
+
+expressionsWithDefaults
+    : expressionOrDefault (',' expressionOrDefault)*
+    ;
+
+constants
+    : constant (',' constant)*
+    ;
+
+simpleStrings
+    : STRING_LITERAL (',' STRING_LITERAL)*
+    ;
+
+userVariables
+    : LOCAL_ID (',' LOCAL_ID)*
+    ;
+
+
+//    Common Expressons
+
+defaultValue
+    : NULL_LITERAL
+    | CAST '(' expression AS convertedDataType ')'
+    | unaryOperator? constant
+    | currentTimestamp (ON UPDATE currentTimestamp)?
+    | '(' expression ')'
+    | '(' fullId ')'
+    ;
+
+currentTimestamp
+    :
+    (
+      (CURRENT_TIMESTAMP | LOCALTIME | LOCALTIMESTAMP)
+      ('(' decimalLiteral? ')')?
+      | NOW '(' decimalLiteral? ')'
+    )
+    ;
+
+expressionOrDefault
+    : expression | DEFAULT
+    ;
+
+ifExists
+    : IF EXISTS
+    ;
+
+
+ifNotExists
+    : IF NOT EXISTS
+    ;
+
+orReplace
+    : OR REPLACE
+    ;
+
+waitNowaitClause
+    : WAIT decimalLiteral
+    | NOWAIT
+    ;
+
+//    Functions
+
+functionCall
+    : specificFunction                                              #specificFunctionCall
+    | aggregateWindowedFunction                                     #aggregateFunctionCall
+    | nonAggregateWindowedFunction                                  #nonAggregateFunctionCall
+    | scalarFunctionName '(' functionArgs? ')'                      #scalarFunctionCall
+    | fullId '(' functionArgs? ')'                                  #udfFunctionCall
+    | passwordFunctionClause                                        #passwordFunctionCall
+    ;
+
+specificFunction
+    : (
+      CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP
+      | CURRENT_USER | LOCALTIME | UTC_TIMESTAMP | SCHEMA
+      ) ('(' ')')?                                                  #simpleFunctionCall
+    | CONVERT '(' expression separator=',' convertedDataType ')'    #dataTypeFunctionCall
+    | CONVERT '(' expression USING charsetName ')'                  #dataTypeFunctionCall
+    | CAST '(' expression AS convertedDataType ')'                  #dataTypeFunctionCall
+    | VALUES '(' fullColumnName ')'                                 #valuesFunctionCall
+    | CASE expression caseFuncAlternative+
+      (ELSE elseArg=functionArg)? END                               #caseExpressionFunctionCall
+    | CASE caseFuncAlternative+
+      (ELSE elseArg=functionArg)? END                               #caseFunctionCall
+    | CHAR '(' functionArgs  (USING charsetName)? ')'               #charFunctionCall
+    | POSITION
+      '('
+          (
+            positionString=stringLiteral
+            | positionExpression=expression
+          )
+          IN
+          (
+            inString=stringLiteral
+            | inExpression=expression
+          )
+      ')'                                                           #positionFunctionCall
+    | (SUBSTR | SUBSTRING)
+      '('
+        (
+          sourceString=stringLiteral
+          | sourceExpression=expression
+        ) FROM
+        (
+          fromDecimal=decimalLiteral
+          | fromExpression=expression
+        )
+        (
+          FOR
+          (
+            forDecimal=decimalLiteral
+            | forExpression=expression
+          )
+        )?
+      ')'                                                           #substrFunctionCall
+    | TRIM
+      '('
+        positioinForm=(BOTH | LEADING | TRAILING)
+        (
+          sourceString=stringLiteral
+          | sourceExpression=expression
+        )?
+        FROM
+        (
+          fromString=stringLiteral
+          | fromExpression=expression
+        )
+      ')'                                                           #trimFunctionCall
+    | TRIM
+      '('
+        (
+          sourceString=stringLiteral
+          | sourceExpression=expression
+        )
+        FROM
+        (
+          fromString=stringLiteral
+          | fromExpression=expression
+        )
+      ')'                                                           #trimFunctionCall
+    | WEIGHT_STRING
+      '('
+        (stringLiteral | expression)
+        (AS stringFormat=(CHAR | BINARY)
+        '(' decimalLiteral ')' )?  levelsInWeightString?
+      ')'                                                           #weightFunctionCall
+    | EXTRACT
+      '('
+        intervalType
+        FROM
+        (
+          sourceString=stringLiteral
+          | sourceExpression=expression
+        )
+      ')'                                                           #extractFunctionCall
+    | GET_FORMAT
+      '('
+        datetimeFormat=(DATE | TIME | DATETIME)
+        ',' stringLiteral
+      ')'                                                           #getFormatFunctionCall
+    | JSON_VALUE
+      '(' expression
+       ',' expression
+         (RETURNING convertedDataType)?
+         jsonOnEmpty?
+         jsonOnError?
+       ')'                                                          #jsonValueFunctionCall
+    ;
+
+caseFuncAlternative
+    : WHEN condition=functionArg
+      THEN consequent=functionArg
+    ;
+
+levelsInWeightString
+    : LEVEL levelInWeightListElement
+      (',' levelInWeightListElement)*                               #levelWeightList
+    | LEVEL
+      firstLevel=decimalLiteral '-' lastLevel=decimalLiteral        #levelWeightRange
+    ;
+
+levelInWeightListElement
+    : decimalLiteral orderType=(ASC | DESC | REVERSE)?
+    ;
+
+aggregateWindowedFunction
+    : (AVG | MAX | MIN | SUM)
+      '(' aggregator=(ALL | DISTINCT)? functionArg ')' overClause?
+    | COUNT '(' (starArg='*' | aggregator=ALL? functionArg | aggregator=DISTINCT functionArgs) ')' overClause?
+    | (
+        BIT_AND | BIT_OR | BIT_XOR | STD | STDDEV | STDDEV_POP
+        | STDDEV_SAMP | VAR_POP | VAR_SAMP | VARIANCE
+      ) '(' aggregator=ALL? functionArg ')' overClause?
+    | GROUP_CONCAT '('
+        aggregator=DISTINCT? functionArgs
+        (ORDER BY
+          orderByExpression (',' orderByExpression)*
+        )? (SEPARATOR separator=STRING_LITERAL)?
+      ')'
+    ;
+
+nonAggregateWindowedFunction
+    : (LAG | LEAD) '(' expression (',' decimalLiteral)? (',' decimalLiteral)? ')' overClause
+    | (FIRST_VALUE | LAST_VALUE) '(' expression ')' overClause
+    | (CUME_DIST | DENSE_RANK | PERCENT_RANK | RANK | ROW_NUMBER) '('')' overClause
+    | NTH_VALUE '(' expression ',' decimalLiteral ')' overClause
+    | NTILE '(' decimalLiteral ')' overClause
+    ;
+
+overClause
+    : OVER ('(' windowSpec ')' | windowName)
+    ;
+
+windowSpec
+    : windowName? partitionClause? orderByClause? frameClause?
+    ;
+
+windowName
+    : uid
+    ;
+
+frameClause
+    : frameUnits frameExtent
+    ;
+
+frameUnits
+    : ROWS
+    | RANGE
+    ;
+
+frameExtent
+    : frameRange
+    | frameBetween
+    ;
+
+frameBetween
+    : BETWEEN frameRange AND frameRange
+    ;
+
+frameRange
+    : CURRENT ROW
+    | UNBOUNDED (PRECEDING | FOLLOWING)
+    | expression (PRECEDING | FOLLOWING)
+    ;
+
+partitionClause
+    : PARTITION BY expression (',' expression)*
+    ;
+
+scalarFunctionName
+    : functionNameBase
+    | ASCII | CURDATE | CURRENT_DATE | CURRENT_TIME
+    | CURRENT_TIMESTAMP | CURTIME | DATE_ADD | DATE_SUB
+    | IF | INSERT | LOCALTIME | LOCALTIMESTAMP | MID | NOW
+    | REPLACE | SUBSTR | SUBSTRING | SYSDATE | TRIM
+    | UTC_DATE | UTC_TIME | UTC_TIMESTAMP
+    ;
+
+passwordFunctionClause
+    : functionName=(PASSWORD | OLD_PASSWORD) '(' functionArg ')'
+    ;
+
+functionArgs
+    : (constant | fullColumnName | functionCall | expression)
+    (
+      ','
+      (constant | fullColumnName | functionCall | expression)
+    )*
+    ;
+
+functionArg
+    : constant | fullColumnName | functionCall | expression
+    ;
+
+
+//    Expressions, predicates
+
+// Simplified approach for expression
+expression
+    : notOperator=(NOT | '!') expression                            #notExpression
+    | expression logicalOperator expression                         #logicalExpression
+    | predicate IS NOT? testValue=(TRUE | FALSE | UNKNOWN)          #isExpression
+    | predicate                                                     #predicateExpression
+    ;
+
+predicate
+    : predicate NOT? IN '(' (selectStatement | expressions) ')'     #inPredicate
+    | predicate IS nullNotnull                                      #isNullPredicate
+    | left=predicate comparisonOperator right=predicate             #binaryComparisonPredicate
+    | predicate comparisonOperator
+      quantifier=(ALL | ANY | SOME) '(' selectStatement ')'         #subqueryComparisonPredicate
+    | predicate NOT? BETWEEN predicate AND predicate                #betweenPredicate
+    | predicate SOUNDS LIKE predicate                               #soundsLikePredicate
+    | predicate NOT? LIKE predicate (ESCAPE STRING_LITERAL)?        #likePredicate
+    | predicate NOT? regex=(REGEXP | RLIKE) predicate               #regexpPredicate
+    | (LOCAL_ID VAR_ASSIGN)? expressionAtom                         #expressionAtomPredicate
+    | predicate MEMBER OF '(' predicate ')'                         #jsonMemberOfPredicate
+    ;
+
+
+// Add in ASTVisitor nullNotnull in constant
+expressionAtom
+    : constant                                                      #constantExpressionAtom
+    | fullColumnName                                                #fullColumnNameExpressionAtom
+    | functionCall                                                  #functionCallExpressionAtom
+    | expressionAtom COLLATE collationName                          #collateExpressionAtom
+    | mysqlVariable                                                 #mysqlVariableExpressionAtom
+    | unaryOperator expressionAtom                                  #unaryExpressionAtom
+    | BINARY expressionAtom                                         #binaryExpressionAtom
+    | '(' expression (',' expression)* ')'                          #nestedExpressionAtom
+    | ROW '(' expression (',' expression)+ ')'                      #nestedRowExpressionAtom
+    | EXISTS '(' selectStatement ')'                                #existsExpressionAtom
+    | '(' selectStatement ')'                                       #subqueryExpressionAtom
+    | INTERVAL expression intervalType                              #intervalExpressionAtom
+    | left=expressionAtom bitOperator right=expressionAtom          #bitExpressionAtom
+    | left=expressionAtom mathOperator right=expressionAtom         #mathExpressionAtom
+    | left=expressionAtom jsonOperator right=expressionAtom         #jsonExpressionAtom
+    ;
+
+unaryOperator
+    : '!' | '~' | '+' | '-' | NOT
+    ;
+
+comparisonOperator
+    : '=' | '>' | '<' | '<' '=' | '>' '='
+    | '<' '>' | '!' '=' | '<' '=' '>'
+    ;
+
+logicalOperator
+    : AND | '&' '&' | XOR | OR | '|' '|'
+    ;
+
+bitOperator
+    : '<' '<' | '>' '>' | '&' | '^' | '|'
+    ;
+
+mathOperator
+    : '*' | '/' | '%' | DIV | MOD | '+' | '-'
+    ;
+
+jsonOperator
+    : '-' '>' | '-' '>' '>'
+    ;
+
+//    Simple id sets
+//     (that keyword, which can be id)
+
+charsetNameBase
+    : ARMSCII8 | ASCII | BIG5 | BINARY | CP1250 | CP1251 | CP1256 | CP1257
+    | CP850 | CP852 | CP866 | CP932 | DEC8 | EUCJPMS | EUCKR
+    | GB18030 | GB2312 | GBK | GEOSTD8 | GREEK | HEBREW | HP8 | KEYBCS2
+    | KOI8R | KOI8U | LATIN1 | LATIN2 | LATIN5 | LATIN7 | MACCE
+    | MACROMAN | SJIS | SWE7 | TIS620 | UCS2 | UJIS | UTF16
+    | UTF16LE | UTF32 | UTF8 | UTF8MB3 | UTF8MB4
+    ;
+
+transactionLevelBase
+    : REPEATABLE | COMMITTED | UNCOMMITTED | SERIALIZABLE
+    ;
+
+privilegesBase
+    : TABLES | ROUTINE | EXECUTE | FILE | PROCESS
+    | RELOAD | SHUTDOWN | SUPER | PRIVILEGES
+    ;
+
+intervalTypeBase
+    : QUARTER | MONTH | DAY | HOUR
+    | MINUTE | WEEK | SECOND | MICROSECOND
+    ;
+
+dataTypeBase
+    : DATE | TIME | TIMESTAMP | DATETIME | YEAR | ENUM | TEXT
+    ;
+
+keywordsCanBeId
+    : ACCOUNT | ACTION | ADMIN | AFTER | AGGREGATE | ALGORITHM | ANY
+    | AT | AUDIT_ADMIN | AUDIT_ABORT_EXEMPT | AUTHORS | AUTOCOMMIT | AUTOEXTEND_SIZE
+    | AUTO_INCREMENT | AUTHENTICATION_POLICY_ADMIN | AVG | AVG_ROW_LENGTH | ATTRIBUTE
+    | BACKUP_ADMIN | BEGIN | BINLOG | BINLOG_ADMIN | BINLOG_ENCRYPTION_ADMIN | BIT | BIT_AND | BIT_OR | BIT_XOR
+    | BLOCK | BOOL | BOOLEAN | BTREE | BUCKETS | CACHE | CASCADED | CHAIN | CHANGED
+    | CHANNEL | CHECKSUM | PAGE_CHECKSUM | CATALOG_NAME | CIPHER
+    | CLASS_ORIGIN | CLIENT | CLONE_ADMIN | CLOSE | CLUSTERING | COALESCE | CODE
+    | COLUMNS | COLUMN_FORMAT | COLUMN_NAME | COMMENT | COMMIT | COMPACT
+    | COMPLETION | COMPRESSED | COMPRESSION | CONCURRENT | CONDITION | CONNECT
+    | CONNECTION | CONNECTION_ADMIN | CONSISTENT | CONSTRAINT_CATALOG | CONSTRAINT_NAME
+    | CONSTRAINT_SCHEMA | CONTAINS | CONTEXT
+    | CONTRIBUTORS | COPY | COUNT | CPU | CURRENT | CURRENT_USER | CURSOR_NAME
+    | DATA | DATAFILE | DEALLOCATE
+    | DEFAULT | DEFAULT_AUTH | DEFINER | DELAY_KEY_WRITE | DES_KEY_FILE | DIAGNOSTICS | DIRECTORY
+    | DISABLE | DISCARD | DISK | DO | DUMPFILE | DUPLICATE
+    | DYNAMIC | EMPTY | ENABLE | ENCRYPTION | ENCRYPTION_KEY_ADMIN | END | ENDS | ENGINE | ENGINE_ATTRIBUTE | ENGINES | ENFORCED
+    | ERROR | ERRORS | ESCAPE | EUR | EVEN | EVENT | EVENTS | EVERY | EXCEPT
+    | EXCHANGE | EXCLUSIVE | EXPIRE | EXPORT | EXTENDED | EXTENT_SIZE | FAILED_LOGIN_ATTEMPTS | FAST | FAULTS
+    | FIELDS | FILE_BLOCK_SIZE | FILTER | FIREWALL_ADMIN | FIREWALL_EXEMPT | FIREWALL_USER | FIRST | FIXED | FLUSH
+    | FOLLOWS | FOUND | FULL | FUNCTION | GENERAL | GLOBAL | GRANTS | GROUP | GROUP_CONCAT
+    | GROUP_REPLICATION | GROUP_REPLICATION_ADMIN | HANDLER | HASH | HELP | HISTORY | HOST | HOSTS | IDENTIFIED
+    | IGNORED | IGNORE_SERVER_IDS | IMPORT | INDEXES | INITIAL_SIZE | INNODB_REDO_LOG_ARCHIVE
+    | INPLACE | INSERT_METHOD | INSTALL | INSTANCE | INSTANT | INTERNAL | INVOKE | INVOKER | IO
+    | IO_THREAD | IPC | ISO | ISOLATION | ISSUER | JIS | JSON | KEY_BLOCK_SIZE
+    | LAMBDA | LANGUAGE | LAST | LATERAL | LEAVES | LESS | LEVEL | LIST | LOCAL
+    | LOGFILE | LOGS | MASTER | MASTER_AUTO_POSITION
+    | MASTER_CONNECT_RETRY | MASTER_DELAY
+    | MASTER_HEARTBEAT_PERIOD | MASTER_HOST | MASTER_LOG_FILE
+    | MASTER_LOG_POS | MASTER_PASSWORD | MASTER_PORT
+    | MASTER_RETRY_COUNT | MASTER_SSL | MASTER_SSL_CA
+    | MASTER_SSL_CAPATH | MASTER_SSL_CERT | MASTER_SSL_CIPHER
+    | MASTER_SSL_CRL | MASTER_SSL_CRLPATH | MASTER_SSL_KEY
+    | MASTER_TLS_VERSION | MASTER_USER
+    | MAX_CONNECTIONS_PER_HOUR | MAX_QUERIES_PER_HOUR
+    | MAX | MAX_ROWS | MAX_SIZE | MAX_UPDATES_PER_HOUR
+    | MAX_USER_CONNECTIONS | MEDIUM | MEMBER | MEMORY | MERGE | MESSAGE_TEXT
+    | MID | MIGRATE
+    | MIN | MIN_ROWS | MODE | MODIFY | MUTEX | MYSQL | MYSQL_ERRNO | NAME | NAMES
+    | NCHAR | NDB_STORED_USER | NESTED | NEVER | NEXT | NO | NOCOPY | NODEGROUP | NONE | NOWAIT | NUMBER | ODBC | OFFLINE | OFFSET
+    | OF | OJ | OLD_PASSWORD | ONE | ONLINE | ONLY | OPEN | OPTIMIZER_COSTS
+    | OPTIONAL | OPTIONS | ORDER | ORDINALITY | OWNER | PACK_KEYS | PAGE | PARSER | PARTIAL
+    | PARTITIONING | PARTITIONS | PASSWORD | PASSWORDLESS_USER_ADMIN | PASSWORD_LOCK_TIME | PATH | PERSIST_RO_VARIABLES_ADMIN | PHASE | PLUGINS
+    | PLUGIN_DIR | PLUGIN | PORT | PRECEDES | PREPARE | PRESERVE | PREV | PRIMARY
+    | PROCESSLIST | PROFILE | PROFILES | PROXY | QUERY | QUICK
+    | REBUILD | RECOVER | RECURSIVE | REDO_BUFFER_SIZE | REDUNDANT
+    | RELAY | RELAYLOG | RELAY_LOG_FILE | RELAY_LOG_POS | REMOVE
+    | REORGANIZE | REPAIR | REPLICATE_DO_DB | REPLICATE_DO_TABLE
+    | REPLICATE_IGNORE_DB | REPLICATE_IGNORE_TABLE
+    | REPLICATE_REWRITE_DB | REPLICATE_WILD_DO_TABLE
+    | REPLICATE_WILD_IGNORE_TABLE | REPLICATION | REPLICATION_APPLIER | REPLICATION_SLAVE_ADMIN | RESET
+    | RESOURCE_GROUP_ADMIN | RESOURCE_GROUP_USER | RESUME
+    | RETURNED_SQLSTATE | RETURNS | REUSE | ROLE | ROLE_ADMIN | ROLLBACK | ROLLUP | ROTATE | ROW | ROWS
+    | ROW_FORMAT | RTREE | S3 | SAVEPOINT | SCHEDULE | SCHEMA_NAME | SECURITY | SECONDARY_ENGINE_ATTRIBUTE | SERIAL | SERVER
+    | SESSION | SESSION_VARIABLES_ADMIN | SET_USER_ID | SHARE | SHARED | SHOW_ROUTINE | SIGNED | SIMPLE | SLAVE
+    | SLOW | SKIP_QUERY_REWRITE | SNAPSHOT | SOCKET | SOME | SONAME | SOUNDS | SOURCE
+    | SQL_AFTER_GTIDS | SQL_AFTER_MTS_GAPS | SQL_BEFORE_GTIDS
+    | SQL_BUFFER_RESULT | SQL_CACHE | SQL_NO_CACHE | SQL_THREAD
+    | STACKED | START | STARTS | STATS_AUTO_RECALC | STATS_PERSISTENT
+    | STATS_SAMPLE_PAGES | STATUS | STD | STDDEV | STDDEV_POP | STDDEV_SAMP | STOP | STORAGE | STRING
+    | SUBCLASS_ORIGIN | SUBJECT | SUBPARTITION | SUBPARTITIONS | SUM | SUSPEND | SWAPS
+    | SWITCHES | SYSTEM_VARIABLES_ADMIN | TABLE_NAME | TABLESPACE | TABLE_ENCRYPTION_ADMIN | TABLE_TYPE
+    | TEMPORARY | TEMPTABLE | THAN | TP_CONNECTION_ADMIN | TRADITIONAL
+    | TRANSACTION | TRANSACTIONAL | TRIGGERS | TRUNCATE | UNBOUNDED | UNDEFINED | UNDOFILE
+    | UNDO_BUFFER_SIZE | UNINSTALL | UNKNOWN | UNTIL | UPGRADE | USA | USER | USE_FRM | USER_RESOURCES
+    | VALIDATION | VALUE | VAR_POP | VAR_SAMP | VARIABLES | VARIANCE | VERSION_TOKEN_ADMIN | VIEW | VIRTUAL
+    | WAIT | WARNINGS | WITHOUT | WORK | WRAPPER | X509 | XA | XA_RECOVER_ADMIN | XML
+    ;
+
+functionNameBase
+    : ABS | ACOS | ADDDATE | ADDTIME | AES_DECRYPT | AES_ENCRYPT
+    | AREA | ASBINARY | ASIN | ASTEXT | ASWKB | ASWKT
+    | ASYMMETRIC_DECRYPT | ASYMMETRIC_DERIVE
+    | ASYMMETRIC_ENCRYPT | ASYMMETRIC_SIGN | ASYMMETRIC_VERIFY
+    | ATAN | ATAN2 | BENCHMARK | BIN | BIT_COUNT | BIT_LENGTH
+    | BUFFER | CEIL | CEILING | CENTROID | CHARACTER_LENGTH
+    | CHARSET | CHAR_LENGTH | COERCIBILITY | COLLATION
+    | COMPRESS | CONCAT | CONCAT_WS | CONNECTION_ID | CONV
+    | CONVERT_TZ | COS | COT | COUNT | CRC32
+    | CREATE_ASYMMETRIC_PRIV_KEY | CREATE_ASYMMETRIC_PUB_KEY
+    | CREATE_DH_PARAMETERS | CREATE_DIGEST | CROSSES | CUME_DIST | DATABASE | DATE
+    | DATEDIFF | DATE_FORMAT | DAY | DAYNAME | DAYOFMONTH
+    | DAYOFWEEK | DAYOFYEAR | DECODE | DEGREES | DENSE_RANK | DES_DECRYPT
+    | DES_ENCRYPT | DIMENSION | DISJOINT | ELT | ENCODE
+    | ENCRYPT | ENDPOINT | ENVELOPE | EQUALS | EXP | EXPORT_SET
+    | EXTERIORRING | EXTRACTVALUE | FIELD | FIND_IN_SET | FIRST_VALUE | FLOOR
+    | FORMAT | FOUND_ROWS | FROM_BASE64 | FROM_DAYS
+    | FROM_UNIXTIME | GEOMCOLLFROMTEXT | GEOMCOLLFROMWKB
+    | GEOMETRYCOLLECTION | GEOMETRYCOLLECTIONFROMTEXT
+    | GEOMETRYCOLLECTIONFROMWKB | GEOMETRYFROMTEXT
+    | GEOMETRYFROMWKB | GEOMETRYN | GEOMETRYTYPE | GEOMFROMTEXT
+    | GEOMFROMWKB | GET_FORMAT | GET_LOCK | GLENGTH | GREATEST
+    | GTID_SUBSET | GTID_SUBTRACT | HEX | HOUR | IFNULL
+    | INET6_ATON | INET6_NTOA | INET_ATON | INET_NTOA | INSTR
+    | INTERIORRINGN | INTERSECTS | INVISIBLE
+    | ISCLOSED | ISEMPTY | ISNULL
+    | ISSIMPLE | IS_FREE_LOCK | IS_IPV4 | IS_IPV4_COMPAT
+    | IS_IPV4_MAPPED | IS_IPV6 | IS_USED_LOCK | LAG | LAST_INSERT_ID | LAST_VALUE
+    | LCASE | LEAD | LEAST | LEFT | LENGTH | LINEFROMTEXT | LINEFROMWKB
+    | LINESTRING | LINESTRINGFROMTEXT | LINESTRINGFROMWKB | LN
+    | LOAD_FILE | LOCATE | LOG | LOG10 | LOG2 | LOWER | LPAD
+    | LTRIM | MAKEDATE | MAKETIME | MAKE_SET | MASTER_POS_WAIT
+    | MBRCONTAINS | MBRDISJOINT | MBREQUAL | MBRINTERSECTS
+    | MBROVERLAPS | MBRTOUCHES | MBRWITHIN | MD5 | MICROSECOND
+    | MINUTE | MLINEFROMTEXT | MLINEFROMWKB | MOD| MONTH | MONTHNAME
+    | MPOINTFROMTEXT | MPOINTFROMWKB | MPOLYFROMTEXT
+    | MPOLYFROMWKB | MULTILINESTRING | MULTILINESTRINGFROMTEXT
+    | MULTILINESTRINGFROMWKB | MULTIPOINT | MULTIPOINTFROMTEXT
+    | MULTIPOINTFROMWKB | MULTIPOLYGON | MULTIPOLYGONFROMTEXT
+    | MULTIPOLYGONFROMWKB | NAME_CONST | NTH_VALUE | NTILE | NULLIF | NUMGEOMETRIES
+    | NUMINTERIORRINGS | NUMPOINTS | OCT | OCTET_LENGTH | ORD
+    | OVERLAPS | PERCENT_RANK | PERIOD_ADD | PERIOD_DIFF | PI | POINT
+    | POINTFROMTEXT | POINTFROMWKB | POINTN | POLYFROMTEXT
+    | POLYFROMWKB | POLYGON | POLYGONFROMTEXT | POLYGONFROMWKB
+    | POSITION | POW | POWER | QUARTER | QUOTE | RADIANS | RAND | RANK
+    | RANDOM_BYTES | RELEASE_LOCK | REVERSE | RIGHT | ROUND
+    | ROW_COUNT | ROW_NUMBER | RPAD | RTRIM | SCHEMA | SECOND | SEC_TO_TIME
+    | SESSION_USER | SESSION_VARIABLES_ADMIN
+    | SHA | SHA1 | SHA2 | SIGN | SIN | SLEEP
+    | SOUNDEX | SQL_THREAD_WAIT_AFTER_GTIDS | SQRT | SRID
+    | STARTPOINT | STRCMP | STR_TO_DATE | ST_AREA | ST_ASBINARY
+    | ST_ASTEXT | ST_ASWKB | ST_ASWKT | ST_BUFFER | ST_CENTROID
+    | ST_CONTAINS | ST_CROSSES | ST_DIFFERENCE | ST_DIMENSION
+    | ST_DISJOINT | ST_DISTANCE | ST_ENDPOINT | ST_ENVELOPE
+    | ST_EQUALS | ST_EXTERIORRING | ST_GEOMCOLLFROMTEXT
+    | ST_GEOMCOLLFROMTXT | ST_GEOMCOLLFROMWKB
+    | ST_GEOMETRYCOLLECTIONFROMTEXT
+    | ST_GEOMETRYCOLLECTIONFROMWKB | ST_GEOMETRYFROMTEXT
+    | ST_GEOMETRYFROMWKB | ST_GEOMETRYN | ST_GEOMETRYTYPE
+    | ST_GEOMFROMTEXT | ST_GEOMFROMWKB | ST_INTERIORRINGN
+    | ST_INTERSECTION | ST_INTERSECTS | ST_ISCLOSED | ST_ISEMPTY
+    | ST_ISSIMPLE | ST_LINEFROMTEXT | ST_LINEFROMWKB
+    | ST_LINESTRINGFROMTEXT | ST_LINESTRINGFROMWKB
+    | ST_NUMGEOMETRIES | ST_NUMINTERIORRING
+    | ST_NUMINTERIORRINGS | ST_NUMPOINTS | ST_OVERLAPS
+    | ST_POINTFROMTEXT | ST_POINTFROMWKB | ST_POINTN
+    | ST_POLYFROMTEXT | ST_POLYFROMWKB | ST_POLYGONFROMTEXT
+    | ST_POLYGONFROMWKB | ST_SRID | ST_STARTPOINT
+    | ST_SYMDIFFERENCE | ST_TOUCHES | ST_UNION | ST_WITHIN
+    | ST_X | ST_Y | SUBDATE | SUBSTRING_INDEX | SUBTIME
+    | SYSTEM_USER | TAN | TIME | TIMEDIFF | TIMESTAMP
+    | TIMESTAMPADD | TIMESTAMPDIFF | TIME_FORMAT | TIME_TO_SEC
+    | TOUCHES | TO_BASE64 | TO_DAYS | TO_SECONDS | UCASE
+    | UNCOMPRESS | UNCOMPRESSED_LENGTH | UNHEX | UNIX_TIMESTAMP
+    | UPDATEXML | UPPER | UUID | UUID_SHORT
+    | VALIDATE_PASSWORD_STRENGTH | VERSION | VISIBLE
+    | WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS | WEEK | WEEKDAY
+    | WEEKOFYEAR | WEIGHT_STRING | WITHIN | YEAR | YEARWEEK
+    | Y_FUNCTION | X_FUNCTION
+    | JSON_ARRAY | JSON_OBJECT | JSON_QUOTE | JSON_CONTAINS | JSON_CONTAINS_PATH
+    | JSON_EXTRACT | JSON_KEYS | JSON_OVERLAPS | JSON_SEARCH | JSON_VALUE
+    | JSON_ARRAY_APPEND | JSON_ARRAY_INSERT | JSON_INSERT | JSON_MERGE
+    | JSON_MERGE_PATCH | JSON_MERGE_PRESERVE | JSON_REMOVE | JSON_REPLACE
+    | JSON_SET | JSON_UNQUOTE | JSON_DEPTH | JSON_LENGTH | JSON_TYPE
+    | JSON_VALID | JSON_TABLE | JSON_SCHEMA_VALID | JSON_SCHEMA_VALIDATION_REPORT
+    | JSON_PRETTY | JSON_STORAGE_FREE | JSON_STORAGE_SIZE | JSON_ARRAYAGG
+    | JSON_OBJECTAGG
+    ;
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/AbstractPartition.java
similarity index 89%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/AbstractPartition.java
index 24dcb5774..ce236db09 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/AbstractPartition.java
@@ -17,9 +17,7 @@
 
 package org.apache.eventmesh.connector.jdbc;
 
-public class Field {
+public abstract class AbstractPartition implements Partition {
+
 
-    private String type;
-    private String optional;
-    private String name;
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/CatalogChanges.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/CatalogChanges.java
index a58d6c305..34d2554f6 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/CatalogChanges.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/CatalogChanges.java
@@ -35,7 +35,7 @@ public class CatalogChanges {
     /**
      * The type of change (e.g., "T(Table)" or "D(Database)").
      * <pr>
-     *     {@link SchemaChangeEventType#type}
+     * {@link SchemaChangeEventType}
      * </pr>
      */
     private String type;
@@ -43,7 +43,7 @@ public class CatalogChanges {
     /**
      * The specific operation type (e.g., "C(Create)", "D(Drop)", "A(Alert)").
      * <pr>
-     *     {@link SchemaChangeEventType#operationType}
+     * {@link SchemaChangeEventType}
      * </pr>
      */
     private String operationType;
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
index 24dcb5774..66d583de7 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
@@ -17,9 +17,56 @@
 
 package org.apache.eventmesh.connector.jdbc;
 
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class Field {
 
     private String type;
-    private String optional;
+
+    private boolean required;
+
+    private String field;
+
     private String name;
+
+    private List<Field> fields;
+
+    public Field(String type, boolean required, String field, String name) {
+        this.type = type;
+        this.required = required;
+        this.field = field;
+        this.name = name;
+    }
+
+    public Field withType(String type) {
+        this.type = type;
+        return this;
+    }
+
+    public Field withRequired(boolean required) {
+        this.required = required;
+        return this;
+    }
+
+    public Field withField(String field) {
+        this.field = field;
+        return this;
+    }
+
+    public Field withName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public Field withFields(List<Field> fields) {
+        this.fields = fields;
+        return this;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
index 506e4baa2..1c6eeb58b 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
@@ -17,6 +17,8 @@
 
 package org.apache.eventmesh.connector.jdbc;
 
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
 /**
  * Interface representing a JDBC context.
  */
@@ -26,4 +28,6 @@ public interface JdbcContext<Part extends Partition, OffSetCtx extends OffsetCon
 
     OffSetCtx getOffsetContext();
 
+    TableId ofCurrentTableId();
+
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/PartitionOffSetContextPair.java
similarity index 55%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/PartitionOffSetContextPair.java
index 7916a911c..30ec03d11 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/PartitionOffSetContextPair.java
@@ -17,14 +17,26 @@
 
 package org.apache.eventmesh.connector.jdbc;
 
-import java.util.List;
+public final class PartitionOffSetContextPair<Part extends Partition, Offset extends OffsetContext> {
 
-public class Schema {
+    private Part partition;
 
-    private boolean optional;
+    private Offset offsetContext;
 
-    private Field field;
+    private PartitionOffSetContextPair(Part partition, Offset offsetContext) {
+        this.partition = partition;
+        this.offsetContext = offsetContext;
+    }
 
-    private List<Field> fields;
+    public static <Part extends Partition, Offset extends OffsetContext> PartitionOffSetContextPair<Part, Offset> of(Part partition, Offset offset) {
+        return new PartitionOffSetContextPair<>(partition, offset);
+    }
 
+    public Part getPartition() {
+        return partition;
+    }
+
+    public Offset getOffsetContext() {
+        return offsetContext;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Payload.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Payload.java
index 2a9235bd9..262648c5e 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Payload.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Payload.java
@@ -23,18 +23,30 @@ import java.util.HashMap;
 
 public final class Payload extends HashMap<String, Object> {
 
+    /**
+     * Constructs an empty <code>HashMap</code> with the default initial capacity (16) and the default load factor (0.75).
+     */
+    public Payload() {
+        this.put("timestamp", System.currentTimeMillis());
+    }
+
     public Payload withSource(SourceMateData source) {
-        super.put("source", source);
+        this.put("source", source);
         return this;
     }
 
     public Payload withDdl(String ddl) {
-        super.put("ddl", ddl);
+        this.put("ddl", ddl);
         return this;
     }
 
     public Payload withCatalogChanges(CatalogChanges catalogChanges) {
-        super.put("catalogChanges", catalogChanges);
+        this.put("catalogChanges", catalogChanges);
+        return this;
+    }
+
+    public Payload withAfterValue(Object value) {
+        this.put("after", value);
         return this;
     }
 
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
index 7916a911c..284bc14b1 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
@@ -19,12 +19,14 @@ package org.apache.eventmesh.connector.jdbc;
 
 import java.util.List;
 
-public class Schema {
-
-    private boolean optional;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 
-    private Field field;
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Schema {
 
     private List<Field> fields;
-
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalJdbcContext.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalJdbcContext.java
new file mode 100644
index 000000000..99f0551e7
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalJdbcContext.java
@@ -0,0 +1,76 @@
+/*
+ * 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.eventmesh.connector.jdbc;
+
+import org.apache.eventmesh.connector.jdbc.ddl.DdlParser;
+import org.apache.eventmesh.connector.jdbc.table.catalog.CatalogTableSet;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
+public abstract class UniversalJdbcContext<Part extends Partition, OffSetCtx extends OffsetContext, Parser extends DdlParser> implements
+    JdbcContext<Part, OffSetCtx> {
+
+    private PartitionOffSetContextPair<Part, OffSetCtx> poCtx;
+
+    private Parser parser;
+
+    private CatalogTableSet tableSet = new CatalogTableSet();
+
+    private volatile TableId tableId;
+
+    public UniversalJdbcContext(PartitionOffSetContextPair<Part, OffSetCtx> poCtx, Parser parser) {
+        this.poCtx = poCtx;
+        this.parser = parser;
+    }
+
+    public UniversalJdbcContext(Part part, OffSetCtx offSetCtx, Parser parser) {
+        this.poCtx = PartitionOffSetContextPair.of(part, offSetCtx);
+        this.parser = parser;
+    }
+
+
+    @Override
+    public Part getPartition() {
+        return poCtx.getPartition();
+    }
+
+
+    @Override
+    public OffSetCtx getOffsetContext() {
+        return poCtx.getOffsetContext();
+    }
+
+    /**
+     * @return
+     */
+    @Override
+    public TableId ofCurrentTableId() {
+        return tableId;
+    }
+
+    public Parser getParser() {
+        return parser;
+    }
+
+    public CatalogTableSet getCatalogTableSet() {
+        return this.tableSet;
+    }
+
+    public void withTableId(TableId tableId) {
+        this.tableId = tableId;
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalOffsetContext.java
similarity index 89%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalOffsetContext.java
index 24dcb5774..baa7ba355 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/UniversalOffsetContext.java
@@ -17,9 +17,6 @@
 
 package org.apache.eventmesh.connector.jdbc;
 
-public class Field {
+public abstract class UniversalOffsetContext implements OffsetContext {
 
-    private String type;
-    private String optional;
-    private String name;
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/Antlr4DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/Antlr4DdlParser.java
new file mode 100644
index 000000000..61e79eede
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/Antlr4DdlParser.java
@@ -0,0 +1,75 @@
+/*
+ * 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.eventmesh.connector.jdbc.antlr4;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.listener.Antlr4DdlParserListener;
+import org.apache.eventmesh.connector.jdbc.ddl.AbstractDdlParser;
+import org.apache.eventmesh.connector.jdbc.ddl.DdlParserCallback;
+import org.apache.eventmesh.connector.jdbc.table.catalog.CatalogTableSet;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CodePointCharStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+public abstract class Antlr4DdlParser<L extends Lexer, P extends Parser> extends AbstractDdlParser {
+
+    private Antlr4DdlParserListener antlr4DdlParserListener;
+
+    private CatalogTableSet tableSet;
+
+    public Antlr4DdlParser(boolean skipViews, boolean skipComments) {
+        super(skipViews, skipComments);
+    }
+
+    /**
+     * Parses the given DDL SQL statement.
+     *
+     * @param ddlSql the DDL SQL statement to be parsed
+     */
+    @Override
+    public void parse(String ddlSql, DdlParserCallback callback) {
+        CodePointCharStream ddlSqlStream = CharStreams.fromString(ddlSql);
+        L lexer = buildLexerInstance(ddlSqlStream);
+        P parser = buildParserInstance(new CommonTokenStream(lexer));
+        ParseTree parseTree = parseTree(parser);
+        antlr4DdlParserListener = createParseTreeWalkerListener(callback);
+        ParseTreeWalker.DEFAULT.walk(antlr4DdlParserListener, parseTree);
+    }
+
+    protected abstract L buildLexerInstance(CharStream charStreams);
+
+    protected abstract P buildParserInstance(CommonTokenStream commonTokenStream);
+
+    protected abstract ParseTree parseTree(P parser);
+
+    protected abstract Antlr4DdlParserListener createParseTreeWalkerListener(DdlParserCallback callback);
+
+    public void setCatalogTableSet(CatalogTableSet tableSet) {
+        this.tableSet = tableSet;
+    }
+
+    public CatalogTableSet getCatalogTableSet() {
+        return this.tableSet;
+    }
+
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/listener/Antlr4DdlParserListener.java
similarity index 70%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/listener/Antlr4DdlParserListener.java
index 24dcb5774..d4128324f 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/antlr4/listener/Antlr4DdlParserListener.java
@@ -15,11 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.antlr4.listener;
 
-public class Field {
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * An interface to extend the Antlr4 {@link ParseTreeListener} for DDL parsing events.
+ */
+public interface Antlr4DdlParserListener extends ParseTreeListener {
+
+    // You can add any specific methods related to DDL parsing events here,
+    // if necessary.
 
-    private String type;
-    private String optional;
-    private String name;
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/common/SourceInfo.java
similarity index 84%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/common/SourceInfo.java
index 24dcb5774..0bbe0354b 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Field.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/common/SourceInfo.java
@@ -15,11 +15,11 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.common;
 
-public class Field {
+/**
+ * Interface representing source information.
+ */
+public interface SourceInfo {
 
-    private String type;
-    private String optional;
-    private String name;
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/connection/mysql/MysqlJdbcConnection.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/connection/mysql/MysqlJdbcConnection.java
new file mode 100644
index 000000000..d3bd6652e
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/connection/mysql/MysqlJdbcConnection.java
@@ -0,0 +1,186 @@
+/*
+ * 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.eventmesh.connector.jdbc.connection.mysql;
+
+import org.apache.eventmesh.connector.jdbc.config.JdbcConfig;
+import org.apache.eventmesh.connector.jdbc.connection.JdbcConnection;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlDialectSql;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.utils.MysqlUtils;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.OptionalLong;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class MysqlJdbcConnection extends JdbcConnection {
+
+    private static final int DEFAULT_CONNECT_TIMEOUT_SECOND = 10;
+
+    public static final String URL_WITH_PLACEHOLDER = "jdbc:mysql://%s:%s/?useInformationSchema=true"
+        + "&nullCatalogMeansCurrent=false&useUnicode=true&characterEncoding=UTF-8"
+        + "&characterSetResults=UTF-8&zeroDateTimeBehavior=CONVERT_TO_NULL&connectTimeout=%s";
+
+    public MysqlJdbcConnection(JdbcConfig jdbcConfig, InitialOperation initialOperation, ConnectionFactory connectionFactory) {
+        super(jdbcConfig, initialOperation, connectionFactory);
+    }
+
+    public MysqlJdbcConnection(JdbcConfig jdbcConfig, InitialOperation initialOperation, ConnectionFactory connectionFactory,
+        boolean lazyConnection) {
+        super(jdbcConfig, initialOperation, connectionFactory, lazyConnection);
+    }
+
+    public MysqlJdbcConnection(JdbcConfig jdbcConfig, InitialOperation initialOperation) {
+        super(jdbcConfig, initialOperation, getPatternConnectionFactory(jdbcConfig));
+    }
+
+    public MysqlJdbcConnection(JdbcConfig jdbcConfig, InitialOperation initialOperation, boolean lazyConnection) {
+        super(jdbcConfig, initialOperation, getPatternConnectionFactory(jdbcConfig), lazyConnection);
+    }
+
+    private static ConnectionFactory getPatternConnectionFactory(JdbcConfig jdbcConfig) {
+        return JdbcConnection.createPatternConnectionFactory(URL_WITH_PLACEHOLDER, jdbcConfig.getHostname(), String.valueOf(jdbcConfig.getPort()),
+            String.valueOf(jdbcConfig.getConnectTimeout() <= 0 ? DEFAULT_CONNECT_TIMEOUT_SECOND : jdbcConfig.getConnectTimeout()));
+    }
+
+    /**
+     * Checks if GTID (Global Transaction Identifier) is enabled on the database server.
+     *
+     * @return true if GTID is enabled, false otherwise.
+     */
+    public boolean enableGTID() {
+
+        boolean enableGTID = false;
+        try {
+            enableGTID = query(MysqlDialectSql.SHOW_GTID_STATUS.ofSQL(), new ResultSetMapper<Boolean>() {
+                /**
+                 * Maps a ResultSet to an object of type T.
+                 *
+                 * @param rs The ResultSet to be mapped.
+                 * @return The mapped object.
+                 * @throws SQLException if a database access error occurs.
+                 */
+                @Override
+                public Boolean map(ResultSet rs) throws SQLException {
+                    while (rs.next()) {
+                        if ("ON".equalsIgnoreCase(rs.getString(2))) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            });
+        } catch (SQLException e) {
+            log.error("Get executed gtid error", e);
+        }
+
+        return enableGTID;
+    }
+
+    /**
+     * Retrieves the executed GTID from the Mysql database.
+     *
+     * @return The executed GTID as a String.
+     */
+    public String executedGTID() {
+
+        try {
+            return query(MysqlDialectSql.SHOW_MASTER_STATUS.ofSQL(), new ResultSetMapper<String>() {
+                /**
+                 * Maps a ResultSet to an object of type T.
+                 *
+                 * @param rs The ResultSet to be mapped.
+                 * @return The mapped object.
+                 * @throws SQLException if a database access error occurs.
+                 */
+                @Override
+                public String map(ResultSet rs) throws SQLException {
+                    if (rs.next() && rs.getMetaData().getColumnCount() > 4) {
+                        return rs.getString(5);
+                    }
+                    // Return an empty string if no GTID is found.
+                    return "";
+                }
+            });
+        } catch (SQLException e) {
+            log.error("Get executed gtid error", e);
+        }
+        return "";
+    }
+
+    /**
+     * Get the purged GTID values from MySQL (gtid_purged value)
+     *
+     * @return A GTID String; may be empty if not using GTIDs or none have been purged yet
+     */
+    public String purgedGTID() {
+
+        try {
+
+            /**
+             * +----------------------------------------------+
+             * | @@global.gtid_purged                         |
+             * +----------------------------------------------+
+             * | e584735d-fde7-11ed-bf67-0242ac110002:1-12918 |
+             * +----------------------------------------------+
+             */
+            return query(MysqlDialectSql.SELECT_PURGED_GTID.ofSQL(), new ResultSetMapper<String>() {
+                /**
+                 * Maps a ResultSet to an object of type T.
+                 *
+                 * @param rs The ResultSet to be mapped.
+                 * @return The mapped object.
+                 * @throws SQLException if a database access error occurs.
+                 */
+                @Override
+                public String map(ResultSet rs) throws SQLException {
+                    if (rs.next() && rs.getMetaData().getColumnCount() > 4) {
+                        return rs.getString(1);
+                    }
+                    // Return an empty string if no GTID is found.
+                    return "";
+                }
+            });
+        } catch (SQLException e) {
+            log.error("Get executed gtid error", e);
+        }
+        return "";
+    }
+
+    public OptionalLong getRowCount4Table(TableId tableId) {
+        try {
+            //select database
+            execute(MysqlDialectSql.SELECT_DATABASE.ofWrapperSQL(MysqlUtils.wrapper(tableId.getCatalogName())));
+            //The number of rows. Some storage engines, such as MyISAM, store the exact count. For other storage engines,
+            // such as InnoDB, this value is an approximation, and may vary from the actual value by as much as 40% to 50%.
+            // In such cases, use SELECT COUNT(*) to obtain an accurate count.
+            return query(MysqlDialectSql.SHOW_TABLE_STATUS.ofWrapperSQL(tableId.getTableName()), rs -> {
+                if (rs.next()) {
+                    return OptionalLong.of(rs.getLong(5));
+                }
+                return OptionalLong.empty();
+            });
+        } catch (SQLException e) {
+            log.error("Error get number of rows in table {} : {}", tableId, e.getMessage());
+        }
+        return OptionalLong.empty();
+    }
+
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/UniqueKey.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlOffsetContext.java
similarity index 51%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/UniqueKey.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlOffsetContext.java
index c589ae381..4a19ae6b3 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/UniqueKey.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlOffsetContext.java
@@ -15,42 +15,40 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.context.mysql;
 
-import java.io.Serializable;
-import java.util.List;
+import org.apache.eventmesh.connector.jdbc.UniversalOffsetContext;
 
-import lombok.Getter;
-import lombok.Setter;
+import java.util.Map;
 
+public class MysqlOffsetContext extends UniversalOffsetContext {
 
-@Setter
-@Getter
-public class UniqueKey implements Serializable {
+    private volatile boolean snapshotRunning = false;
 
-    private String name;
+    private volatile boolean snapshotCompleted = false;
 
-    private final List<String> columnNames;
-
-    private String comment;
+    @Override
+    public Map<String, ?> getOffset() {
+        return null;
+    }
 
-    public UniqueKey(String name, List<String> columnNames, String comment) {
-        this.name = name;
-        this.columnNames = columnNames;
-        this.comment = comment;
+    @Override
+    public boolean isSnapshotRunning() {
+        return snapshotRunning;
     }
 
-    public UniqueKey(String name, List<String> columnNames) {
-        this.name = name;
-        this.columnNames = columnNames;
+    @Override
+    public void markSnapshotRunning() {
+        this.snapshotRunning = true;
     }
 
-    public UniqueKey(List<String> columnNames) {
-        this.columnNames = columnNames;
+    @Override
+    public void markSnapshotCompleted() {
+        this.snapshotCompleted = true;
     }
 
-    public UniqueKey copy() {
-        return new UniqueKey(name, columnNames, comment);
+    @Override
+    public boolean isSnapshotCompleted() {
+        return this.snapshotCompleted;
     }
 }
-
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlPartition.java
similarity index 53%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlPartition.java
index 7fcb9dfd7..bfba72777 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/context/mysql/MysqlPartition.java
@@ -15,30 +15,31 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.context.mysql;
 
-/**
- * Interface for parsing DDL SQL statements.
- */
-public interface DdlParser {
-
-    /**
-     * Parses the given DDL SQL statement.
-     *
-     * @param ddlSql the DDL SQL statement to be parsed
-     */
-    default void parse(String ddlSql) {
-        parse(ddlSql, null);
+import org.apache.eventmesh.connector.jdbc.AbstractPartition;
+import org.apache.eventmesh.connector.jdbc.Partition;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MysqlPartition extends AbstractPartition implements Partition {
+
+    private static final String TABLE_ID = "tableId";
+
+    private Map<String, String> partitions = new HashMap<>();
+
+    public MysqlPartition(TableId tableId) {
+        partitions.put(TABLE_ID, tableId.toString());
     }
 
-    void parse(String ddlSql, DdlParserCallback callback);
+    public MysqlPartition() {
 
-    /**
-     * Sets the current database.
-     *
-     * @param databaseName the name of the database to be set as current
-     */
-    void setCurrentDatabase(String databaseName);
+    }
 
-    void setCurrentSchema(String schema);
+    @Override
+    public Map<String, String> getPartition() {
+        return partitions;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java
index fdac829dd..d61d8d9b1 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java
@@ -23,8 +23,10 @@ import lombok.Getter;
 
 public abstract class AbstractDdlParser implements DdlParser {
 
+    // Indicates whether to skip parsing views.
     private final boolean skipViews;
 
+    // Indicates whether to skip parsing comments.
     private final boolean skipComments;
 
     @Getter
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
index 7fcb9dfd7..846244ab8 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
@@ -17,28 +17,41 @@
 
 package org.apache.eventmesh.connector.jdbc.ddl;
 
+
 /**
- * Interface for parsing DDL SQL statements.
+ * Interface for parsing Data Definition Language (DDL) SQL statements.
  */
 public interface DdlParser {
 
     /**
-     * Parses the given DDL SQL statement.
+     * Parses the given DDL SQL statement with a default callback.
      *
-     * @param ddlSql the DDL SQL statement to be parsed
+     * @param ddlSql The DDL SQL statement to parse.
      */
     default void parse(String ddlSql) {
         parse(ddlSql, null);
     }
 
+    /**
+     * Parses the given DDL SQL statement and provides a callback for handling the parsed events.
+     *
+     * @param ddlSql   The DDL SQL statement to parse.
+     * @param callback The DdlParserCallback to handle the parsed events.
+     */
     void parse(String ddlSql, DdlParserCallback callback);
 
     /**
-     * Sets the current database.
+     * Sets the current database name for the parser.
      *
-     * @param databaseName the name of the database to be set as current
+     * @param databaseName The name of the current database.
      */
     void setCurrentDatabase(String databaseName);
 
+    /**
+     * Sets the current schema for the parser.
+     *
+     * @param schema The name of the current schema.
+     */
     void setCurrentSchema(String schema);
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java
index b69fdcab6..c94154ee4 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java
@@ -20,17 +20,18 @@ package org.apache.eventmesh.connector.jdbc.ddl;
 import org.apache.eventmesh.connector.jdbc.event.Event;
 
 /**
- * Functional interface for a DDL parser listener.
+ * A functional interface for handling events generated during DDL parsing.
  */
 @FunctionalInterface
 public interface DdlParserCallback {
 
     /**
-     * Handles the DDL event.
+     * Handles the specified event.
      *
-     * @param event The DDL event to handle.
+     * @param event The event generated during DDL parsing.
      */
     void handle(Event event);
 
 }
 
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AbstractEvent.java
similarity index 53%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AbstractEvent.java
index fdac829dd..a5c7adf98 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/AbstractDdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AbstractEvent.java
@@ -15,46 +15,42 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.event;
 
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
 import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-import lombok.Getter;
+public abstract class AbstractEvent implements Event {
 
-public abstract class AbstractDdlParser implements DdlParser {
-
-    private final boolean skipViews;
-
-    private final boolean skipComments;
-
-    @Getter
     private final TableId tableId;
 
-    public AbstractDdlParser(boolean skipViews, boolean skipComments) {
-        this.skipViews = skipViews;
-        this.skipComments = skipComments;
-        this.tableId = new TableId();
-    }
-
-    @Override
-    public void setCurrentDatabase(String databaseName) {
-        this.tableId.setCatalogName(databaseName);
-    }
+    private JdbcConnectData data;
 
-    @Override
-    public void setCurrentSchema(String schema) {
-        this.tableId.setSchemaName(schema);
+    public AbstractEvent(TableId tableId) {
+        this.tableId = tableId;
+        this.data = new JdbcConnectData();
     }
 
-    public String getCurrentDatabase() {
-        return this.tableId.getCatalogName();
+    public AbstractEvent(TableId tableId, JdbcConnectData data) {
+        this.tableId = tableId;
+        this.data = data;
     }
 
-    public boolean isSkipViews() {
-        return skipViews;
+    /**
+     * Gets the table ID of the event.
+     *
+     * @return The table ID.
+     */
+    @Override
+    public TableId getTableId() {
+        return tableId;
     }
 
-    public boolean isSkipComments() {
-        return skipComments;
+    /**
+     * @return
+     */
+    @Override
+    public JdbcConnectData getJdbcConnectData() {
+        return data;
     }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertDatabaseEvent.java
similarity index 58%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertDatabaseEvent.java
index 4e9077191..e9ed796c7 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertDatabaseEvent.java
@@ -15,18 +15,26 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class AlertDatabaseEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public AlertDatabaseEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public AlertDatabaseEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.DATABASE_ALERT;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertTableEvent.java
similarity index 59%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertTableEvent.java
index 4e9077191..9d7dbf9b3 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/AlertTableEvent.java
@@ -15,18 +15,25 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class AlertTableEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public AlertTableEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public AlertTableEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.TABLE_ALERT;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateDatabaseEvent.java
similarity index 58%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateDatabaseEvent.java
index 4e9077191..f733435b1 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateDatabaseEvent.java
@@ -15,18 +15,26 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class CreateDatabaseEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public CreateDatabaseEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public CreateDatabaseEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.DATABASE_CREATE;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateTableEvent.java
similarity index 59%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateTableEvent.java
index 4e9077191..d7dce5161 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/CreateTableEvent.java
@@ -15,18 +15,26 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class CreateTableEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public CreateTableEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public CreateTableEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.TABLE_CREATE;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DeleteDataEvent.java
similarity index 60%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DeleteDataEvent.java
index 7916a911c..68f23ece8 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DeleteDataEvent.java
@@ -15,16 +15,24 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Schema {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private boolean optional;
+public class DeleteDataEvent extends GeneralDataChangeEvent {
 
-    private Field field;
+    public DeleteDataEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<Field> fields;
+    public DeleteDataEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
+    @Override
+    public DataChangeEventType getDataChangeEventType() {
+        return DataChangeEventType.INSERT;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropDatabaseEvent.java
similarity index 59%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropDatabaseEvent.java
index 4e9077191..1011216fa 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropDatabaseEvent.java
@@ -15,18 +15,25 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class DropDatabaseEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public DropDatabaseEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public DropDatabaseEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.DATABASE_DROP;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropTableEvent.java
similarity index 59%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropTableEvent.java
index 4e9077191..8629453f2 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/DropTableEvent.java
@@ -15,18 +15,26 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class DropTableEvent extends GeneralSchemaChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public DropTableEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
+    public DropTableEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    private String comment;
 
+    @Override
+    public SchemaChangeEventType getSchemaChangeEventType() {
+        return SchemaChangeEventType.TABLE_DROP;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralDataChangeEvent.java
similarity index 63%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralDataChangeEvent.java
index b69fdcab6..f7bcf24d3 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParserCallback.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralDataChangeEvent.java
@@ -15,22 +15,19 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import org.apache.eventmesh.connector.jdbc.event.Event;
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-/**
- * Functional interface for a DDL parser listener.
- */
-@FunctionalInterface
-public interface DdlParserCallback {
+public abstract class GeneralDataChangeEvent extends AbstractEvent implements DataChangeEvent {
 
-    /**
-     * Handles the DDL event.
-     *
-     * @param event The DDL event to handle.
-     */
-    void handle(Event event);
 
-}
+    public GeneralDataChangeEvent(TableId tableId) {
+        super(tableId);
+    }
 
+    public GeneralDataChangeEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralSchemaChangeEvent.java
similarity index 63%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralSchemaChangeEvent.java
index 506e4baa2..f07fee84b 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/GeneralSchemaChangeEvent.java
@@ -15,15 +15,18 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.event;
 
-/**
- * Interface representing a JDBC context.
- */
-public interface JdbcContext<Part extends Partition, OffSetCtx extends OffsetContext> {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    Part getPartition();
+public abstract class GeneralSchemaChangeEvent extends AbstractEvent implements SchemaChangeEvent {
 
-    OffSetCtx getOffsetContext();
+    public GeneralSchemaChangeEvent(TableId tableId) {
+        super(tableId);
+    }
 
+    public GeneralSchemaChangeEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/InsertDataEvent.java
similarity index 60%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/InsertDataEvent.java
index 4e9077191..e339689f1 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/InsertDataEvent.java
@@ -15,18 +15,25 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.event;
 
-import java.util.List;
 
-public class Table {
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
-    private String name;
+public class InsertDataEvent extends GeneralDataChangeEvent {
 
-    private PrimaryKey primaryKey;
+    public InsertDataEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    private List<UniqueKey> uniqueKeys;
-
-    private String comment;
+    public InsertDataEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
+    @Override
+    public DataChangeEventType getDataChangeEventType() {
+        return DataChangeEventType.INSERT;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/UpdateDataEvent.java
similarity index 58%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/UpdateDataEvent.java
index 7fcb9dfd7..dc1ea9c45 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/event/UpdateDataEvent.java
@@ -15,30 +15,28 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.event;
+
+
+import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 
 /**
- * Interface for parsing DDL SQL statements.
+ * Represents an event that indicates an update in data.
  */
-public interface DdlParser {
-
-    /**
-     * Parses the given DDL SQL statement.
-     *
-     * @param ddlSql the DDL SQL statement to be parsed
-     */
-    default void parse(String ddlSql) {
-        parse(ddlSql, null);
-    }
+public class UpdateDataEvent extends GeneralDataChangeEvent {
 
-    void parse(String ddlSql, DdlParserCallback callback);
+    public UpdateDataEvent(TableId tableId) {
+        super(tableId);
+    }
 
-    /**
-     * Sets the current database.
-     *
-     * @param databaseName the name of the database to be set as current
-     */
-    void setCurrentDatabase(String databaseName);
+    public UpdateDataEvent(TableId tableId, JdbcConnectData data) {
+        super(tableId, data);
+    }
 
-    void setCurrentSchema(String schema);
+    @Override
+    public DataChangeEventType getDataChangeEventType() {
+        return DataChangeEventType.INSERT;
+    }
 }
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEngine.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEngine.java
new file mode 100644
index 000000000..2d1080e05
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEngine.java
@@ -0,0 +1,121 @@
+/*
+ * 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.eventmesh.connector.jdbc.source;
+
+import org.apache.eventmesh.common.ThreadWrapper;
+import org.apache.eventmesh.connector.jdbc.DatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
+import org.apache.commons.collections4.CollectionUtils;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public abstract class AbstractEngine<DbDialect extends DatabaseDialect> extends ThreadWrapper implements Engine {
+
+    private final Set<TableId> includeDatabaseTable = new HashSet<>(64);
+
+    protected final JdbcSourceConfig jdbcSourceConfig;
+
+    protected final SourceConnectorConfig sourceConnectorConfig;
+
+    protected final DbDialect databaseDialect;
+
+    public AbstractEngine(JdbcSourceConfig jdbcSourceConfig, DbDialect databaseDialect) {
+        this.jdbcSourceConfig = jdbcSourceConfig;
+        this.sourceConnectorConfig = this.jdbcSourceConfig.getSourceConnectorConfig();
+        this.databaseDialect = databaseDialect;
+
+        calculateNeedHandleTable();
+    }
+
+    @Override
+    public Set<TableId> getHandledTables() {
+        return includeDatabaseTable;
+    }
+
+    protected Set<TableId> calculateNeedHandleTable() {
+        // Get the database and table include and exclude lists from the connector configuration
+        List<String> databaseIncludeList = sourceConnectorConfig.getDatabaseIncludeList();
+
+        // If the database include list is empty, get a list of all databases and use that as the include list
+        if (CollectionUtils.isEmpty(databaseIncludeList)) {
+            List<String> allDatabases = databaseDialect.listDatabases();
+            databaseIncludeList = new ArrayList<>(allDatabases);
+        }
+        Set<String> defaultExcludeDatabase = defaultExcludeDatabase();
+        if (CollectionUtils.isNotEmpty(defaultExcludeDatabase)) {
+            databaseIncludeList.removeAll(defaultExcludeDatabase);
+        }
+
+        List<String> databaseExcludeList = sourceConnectorConfig.getDatabaseExcludeList();
+        // Remove the default excluded databases from the include list
+        if (CollectionUtils.isNotEmpty(databaseExcludeList)) {
+            databaseIncludeList.removeAll(databaseExcludeList);
+        }
+
+        List<String> tableIncludeList = sourceConnectorConfig.getTableIncludeList();
+        // Create a list of included tables based on the table include list
+        List<TableId> includeTableList = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(tableIncludeList)) {
+            List<TableId> tableIdList = buildTableId(tableIncludeList);
+            includeTableList.addAll(tableIdList);
+        }
+
+        // If the table include list is empty, get a list of all tables for each database in the include list
+        if (CollectionUtils.isEmpty(tableIncludeList)) {
+            for (String database : databaseIncludeList) {
+                try {
+                    List<TableId> tableIds = databaseDialect.listTables(database);
+                    includeTableList.addAll(tableIds);
+                } catch (SQLException e) {
+                    log.warn("List database[{}] table error", database, e);
+                }
+            }
+        }
+
+        List<String> tableExcludeList = sourceConnectorConfig.getTableExcludeList();
+        // Remove any tables in the exclude list from the included tables list
+        if (CollectionUtils.isNotEmpty(tableExcludeList)) {
+            includeTableList.removeAll(buildTableId(tableExcludeList));
+        }
+
+        includeDatabaseTable.addAll(includeTableList);
+
+        return includeDatabaseTable;
+    }
+
+    private List<TableId> buildTableId(List<String> tables) {
+        return Optional.ofNullable(tables).orElse(new ArrayList<>(0)).stream().map(table -> {
+            String[] split = table.split("\\.");
+            return new TableId(split[0], null, split[1]);
+        }).collect(Collectors.toList());
+    }
+
+    protected abstract Set<String> defaultExcludeDatabase();
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEventMeshJdbcTask.java
similarity index 69%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEventMeshJdbcTask.java
index 7916a911c..f72aa2052 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/Schema.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/AbstractEventMeshJdbcTask.java
@@ -15,16 +15,21 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.source;
 
-import java.util.List;
+import org.apache.eventmesh.common.ThreadWrapper;
 
-public class Schema {
+public abstract class AbstractEventMeshJdbcTask extends ThreadWrapper implements EventMeshJdbcTask {
 
-    private boolean optional;
 
-    private Field field;
+    @Override
+    public void shutdown() {
+        super.shutdown();
+    }
 
-    private List<Field> fields;
+    @Override
+    public void close() throws Exception {
+        shutdown();
+    }
 
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/JdbcSourceConnector.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/JdbcSourceConnector.java
index d8147bf02..618f56339 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/JdbcSourceConnector.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/JdbcSourceConnector.java
@@ -22,11 +22,11 @@ import org.apache.eventmesh.connector.jdbc.event.Event;
 import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
 import org.apache.eventmesh.connector.jdbc.source.dialect.DatabaseDialectFactory;
 import org.apache.eventmesh.connector.jdbc.source.dialect.cdc.CdcEngine;
-import org.apache.eventmesh.connector.jdbc.source.dialect.cdc.CdcEngineFactory;
 import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotEngine;
 import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotEngineFactory;
 import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotResult;
 import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotResult.SnapshotResultStatus;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
 import org.apache.eventmesh.openconnect.api.config.Config;
 import org.apache.eventmesh.openconnect.api.config.SourceConfig;
 import org.apache.eventmesh.openconnect.api.connector.ConnectorContext;
@@ -34,9 +34,8 @@ import org.apache.eventmesh.openconnect.api.connector.SourceConnector;
 import org.apache.eventmesh.openconnect.api.connector.SourceConnectorContext;
 import org.apache.eventmesh.openconnect.offsetmgmt.api.data.ConnectRecord;
 
-import org.apache.commons.collections4.CollectionUtils;
-
 import java.util.List;
+import java.util.Set;
 
 import lombok.extern.slf4j.Slf4j;
 
@@ -118,22 +117,10 @@ public class JdbcSourceConnector extends SourceConnector {
         this.snapshotEngine.registerSnapshotEventConsumer(this::eventConsumer);
         this.snapshotEngine.init();
 
-        // Get the CDC engine factory and create the CDC engine.
-        final CdcEngineFactory cdcEngineFactory = JdbcAllFactoryLoader.getCdcEngineFactory(databaseType);
-        // Check if the CDC engine factory supports the JDBC protocol.
-        if (!cdcEngineFactory.acceptJdbcProtocol(this.databaseDialect.jdbcProtocol())) {
-            throw new IllegalArgumentException("CdcEngineFactory not supports " + databaseType);
-        }
-        // Set the CDC engine and register the CDC event consumer.
-        this.cdcEngine = cdcEngineFactory.createCdcEngine(this.sourceConfig, this.databaseDialect);
-        if (CollectionUtils.isEmpty(this.cdcEngine.getHandledTables())) {
-            throw new RuntimeException("No database tables need to be processed");
-        }
-        this.cdcEngine.registerCdcEventConsumer(this::eventConsumer);
-        this.cdcEngine.init();
+        Set<TableId> handledTables = this.snapshotEngine.getHandledTables();
 
         // Create the task manager and dispatcher.
-        this.sourceJdbcTaskManager = new SourceJdbcTaskManager(cdcEngine, this.sourceConfig);
+        this.sourceJdbcTaskManager = new SourceJdbcTaskManager(handledTables, this.sourceConfig);
         this.sourceJdbcTaskManager.init();
 
         this.dispatcher = new EventDispatcher(this.sourceJdbcTaskManager);
@@ -162,8 +149,9 @@ public class JdbcSourceConnector extends SourceConnector {
         this.snapshotEngine.close();
         //success and skip status can run cdc engine
         if (result.getStatus() != SnapshotResultStatus.ABORTED) {
-            this.cdcEngine.setContext(result.getContext());
-            this.cdcEngine.start();
+            log.info("Start Cdc Engine to handle cdc event");
+            /*this.cdcEngine.setContext(result.getContext());
+            this.cdcEngine.start();*/
         }
     }
 
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/SourceJdbcTaskManager.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/SourceJdbcTaskManager.java
index 39243e3f9..054aa76e6 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/SourceJdbcTaskManager.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/SourceJdbcTaskManager.java
@@ -20,7 +20,6 @@ package org.apache.eventmesh.connector.jdbc.source;
 import org.apache.eventmesh.connector.jdbc.JdbcConnectData;
 import org.apache.eventmesh.connector.jdbc.event.Event;
 import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
-import org.apache.eventmesh.connector.jdbc.source.dialect.cdc.CdcEngine;
 import org.apache.eventmesh.connector.jdbc.source.dialect.cdc.RandomTaskSelectStrategy;
 import org.apache.eventmesh.connector.jdbc.source.dialect.cdc.TaskSelectStrategy;
 import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
@@ -28,9 +27,7 @@ import org.apache.eventmesh.openconnect.offsetmgmt.api.data.ConnectRecord;
 import org.apache.eventmesh.openconnect.offsetmgmt.api.data.RecordOffset;
 import org.apache.eventmesh.openconnect.offsetmgmt.api.data.RecordPartition;
 
-import org.apache.commons.collections4.CollectionUtils;
-
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -46,10 +43,9 @@ public class SourceJdbcTaskManager extends AbstractJdbcTaskManager<SourceEventMe
 
     private TaskSelectStrategy<SourceEventMeshJdbcEventTask> cdcTaskSelectStrategy;
 
-    public SourceJdbcTaskManager(CdcEngine cdcEngine, JdbcSourceConfig jdbcSourceConfig) {
+    public SourceJdbcTaskManager(Set<TableId> includeDatabaseTable, JdbcSourceConfig jdbcSourceConfig) {
         this.jdbcSourceConfig = jdbcSourceConfig;
-        this.includeDatabaseTable =
-            CollectionUtils.isEmpty(cdcEngine.getHandledTables()) ? new HashSet<>() : new HashSet<>(cdcEngine.getHandledTables());
+        this.includeDatabaseTable = includeDatabaseTable == null ? new HashSet<>() : includeDatabaseTable;
     }
 
 
@@ -69,15 +65,14 @@ public class SourceJdbcTaskManager extends AbstractJdbcTaskManager<SourceEventMe
     }
 
     private void doHandleEvent(Event event) {
-
+        if (null == event) {
+            return;
+        }
         JdbcConnectData jdbcConnectData = event.getJdbcConnectData();
         RecordPartition partition = new RecordPartition();
         RecordOffset offset = new RecordOffset();
         ConnectRecord record = new ConnectRecord(partition, offset, System.currentTimeMillis(), jdbcConnectData);
-        if (null == record) {
-            return;
-        }
-        List<ConnectRecord> records = Arrays.asList(record);
+        List<ConnectRecord> records = Collections.singletonList(record);
         for (TaskManagerListener listener : listeners) {
             listener.listen(records);
         }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/AbstractGeneralDatabaseDialect.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/AbstractGeneralDatabaseDialect.java
new file mode 100644
index 000000000..ff5fcb228
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/AbstractGeneralDatabaseDialect.java
@@ -0,0 +1,57 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect;
+
+import org.apache.eventmesh.connector.jdbc.DatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.connection.JdbcConnection;
+import org.apache.eventmesh.connector.jdbc.exception.JdbcConnectionException;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+
+public abstract class AbstractGeneralDatabaseDialect<JC extends JdbcConnection> implements DatabaseDialect<JC> {
+
+    private static final int DEFAULT_BATCH_MAX_ROWS = 20;
+
+    private SourceConnectorConfig config;
+
+    private int batchMaxRows = DEFAULT_BATCH_MAX_ROWS;
+
+    public AbstractGeneralDatabaseDialect(SourceConnectorConfig config) {
+        this.config = config;
+    }
+
+    @Override
+    public boolean isValid(Connection connection, int timeout) throws JdbcConnectionException, SQLException {
+        return connection == null ? false : connection.isValid(timeout);
+    }
+
+    @Override
+    public PreparedStatement createPreparedStatement(Connection connection, String sql) throws SQLException {
+        PreparedStatement preparedStatement = connection.prepareStatement(sql);
+        if (batchMaxRows > 0) {
+            preparedStatement.setFetchSize(batchMaxRows);
+        }
+        return preparedStatement;
+    }
+
+
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/DatabaseType.java
similarity index 60%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/DatabaseType.java
index 4e9077191..50e0a8e35 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/DatabaseType.java
@@ -15,18 +15,27 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.source.dialect;
 
-import java.util.List;
+import org.apache.commons.lang3.StringUtils;
 
-public class Table {
+public enum DatabaseType {
+    MYSQL("mysql");
 
     private String name;
 
-    private PrimaryKey primaryKey;
-
-    private List<UniqueKey> uniqueKeys;
-
-    private String comment;
+    DatabaseType(String name) {
+        this.name = name;
+    }
+
+    public static DatabaseType ofValue(String name) {
+        DatabaseType[] databaseTypes = values();
+        for (DatabaseType databaseType : databaseTypes) {
+            if (StringUtils.equalsIgnoreCase(databaseType.name, name)) {
+                return databaseType;
+            }
+        }
+        return null;
+    }
 
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/MysqlAntlr4DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/MysqlAntlr4DdlParser.java
new file mode 100644
index 000000000..a857b8efa
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/MysqlAntlr4DdlParser.java
@@ -0,0 +1,153 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.Antlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlLexer;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser;
+import org.apache.eventmesh.connector.jdbc.antlr4.listener.Antlr4DdlParserListener;
+import org.apache.eventmesh.connector.jdbc.ddl.DdlParserCallback;
+import org.apache.eventmesh.connector.jdbc.event.Event;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener.MySqlAntlr4DdlParserListener;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+
+public class MysqlAntlr4DdlParser extends Antlr4DdlParser<MySqlLexer, MySqlParser> {
+
+    private DdlParserCallback callback;
+
+    private final Set<TableId> includeDatabaseTable;
+
+    private final JdbcSourceConfig sourceConfig;
+
+    public MysqlAntlr4DdlParser(boolean skipViews, boolean skipComments, Set<TableId> includeDatabaseTable, JdbcSourceConfig sourceConfig) {
+        super(skipViews, skipComments);
+        this.includeDatabaseTable = includeDatabaseTable;
+        this.sourceConfig = sourceConfig;
+    }
+
+    public MysqlAntlr4DdlParser(boolean skipViews, boolean skipComments, JdbcSourceConfig sourceConfig) {
+        this(skipViews, skipComments, new HashSet<>(), sourceConfig);
+    }
+
+    @Override
+    protected MySqlLexer buildLexerInstance(CharStream charStreams) {
+        return new MySqlLexer(charStreams);
+    }
+
+    @Override
+    protected MySqlParser buildParserInstance(CommonTokenStream commonTokenStream) {
+        return new MySqlParser(commonTokenStream);
+    }
+
+    @Override
+    protected ParseTree parseTree(MySqlParser parser) {
+        return parser.root();
+    }
+
+    @Override
+    protected Antlr4DdlParserListener createParseTreeWalkerListener(DdlParserCallback callback) {
+        this.callback = callback;
+        return new MySqlAntlr4DdlParserListener(this);
+    }
+
+
+    /**
+     * Runs the given EventMeshRunner if all the nullableObjects are not null.
+     *
+     * @param runner          the Runnable to be run
+     * @param nullableObjects the objects to be checked for null
+     */
+    public void runIfAllNotNull(Runnable runner, Object... nullableObjects) {
+        // If nullableObjects is null or empty, run the runner
+        if (nullableObjects == null || nullableObjects.length == 0) {
+            runner.run();
+        }
+        // Check each nullableObject for null
+        for (Object nullableObject : nullableObjects) {
+            // If any nullableObject is null, return without running the runner
+            if (nullableObject == null) {
+                return;
+            }
+        }
+        // Run the runner if all nullableObjects are not null
+        runner.run();
+    }
+
+    /**
+     * Parses a table ID from the given full ID text.
+     *
+     * @param fullIdText The full ID text.
+     * @return The parsed TableId object.
+     */
+    public TableId parseTableId(String fullIdText) {
+        // Remove special characters from the full ID text
+        String sanitizedText = StringUtils.replaceEach(fullIdText, new String[]{"'\\''", "\"", "`"}, new String[]{"", "", ""});
+
+        // Split the sanitized text by dot (.) to separate catalog and table name
+        String[] split = sanitizedText.split("\\.");
+
+        TableId tableId = new TableId();
+
+        // Set the table name if there is no catalog specified
+        if (split.length == 1) {
+            tableId.setTableName(split[0]);
+        } else {
+            // Set the catalog and table name if both are specified
+            tableId.setCatalogName(split[0]);
+            tableId.setTableName(split[1]);
+        }
+
+        return tableId;
+    }
+
+    public DdlParserCallback getCallback() {
+        return callback;
+    }
+
+    public void handleEvent(Event event) {
+        if (callback != null) {
+            callback.handle(event);
+        }
+    }
+
+    public boolean includeTableId(TableId tableId) {
+        return includeDatabaseTable.contains(tableId);
+    }
+
+    public void addTableIdSet(Set<TableId> tableIdSet) {
+        if (CollectionUtils.isEmpty(tableIdSet)) {
+            return;
+        }
+        this.includeDatabaseTable.addAll(tableIdSet);
+    }
+
+    public JdbcSourceConfig getSourceConfig() {
+        return sourceConfig;
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/ColumnDefinitionParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/ColumnDefinitionParserListener.java
new file mode 100644
index 000000000..499ac0910
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/ColumnDefinitionParserListener.java
@@ -0,0 +1,149 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.AutoIncrementColumnConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CollateColumnConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.ColumnDefinitionContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CommentColumnConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.NullNotnullContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.PrimaryKeyColumnConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.UniqueKeyColumnConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlDataTypeConvertor;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableEditor;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlColumnEditor;
+import org.apache.eventmesh.connector.jdbc.table.type.EventMeshDataType;
+import org.apache.eventmesh.connector.jdbc.utils.JdbcStringUtils;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class ColumnDefinitionParserListener extends MySqlParserBaseListener {
+
+    private DefaultValueParserListener defaultValueParserListener;
+
+    private final List<ParseTreeListener> listeners;
+
+    private TableEditor tableEditor;
+
+    private MysqlColumnEditor columnEditor;
+
+    private final MysqlAntlr4DdlParser parser;
+
+    private MysqlDataTypeConvertor dataTypeConvertor;
+
+    //Determines whether the current column definition should be ignored. e.g. PRIMARY KEY, UNIQUE KEY
+    private AtomicReference<Boolean> ignoreColumn = new AtomicReference<>(false);
+
+    public ColumnDefinitionParserListener(List<ParseTreeListener> listeners, TableEditor tableEditor, MysqlColumnEditor columnEditor,
+        MysqlAntlr4DdlParser parser) {
+        this.listeners = listeners;
+        this.tableEditor = tableEditor;
+        this.columnEditor = columnEditor;
+        this.parser = parser;
+        this.dataTypeConvertor = new MysqlDataTypeConvertor();
+    }
+
+    @Override
+    public void enterColumnDefinition(ColumnDefinitionContext ctx) {
+        //parse Column data type
+        this.parser.runIfAllNotNull(() -> {
+            String dataTypeString = ctx.dataType().getText();
+            EventMeshDataType<?> eventMeshType = this.dataTypeConvertor.toEventMeshType(dataTypeString);
+            this.columnEditor.withEventMeshType(eventMeshType);
+            this.columnEditor.withJdbcType(this.dataTypeConvertor.toJDBCType(dataTypeString));
+            this.columnEditor.withType(dataTypeString);
+        }, columnEditor);
+
+        this.parser.runIfAllNotNull(() -> {
+            //parse column default value
+            ColumnDefinitionParserListener.this.defaultValueParserListener = new DefaultValueParserListener(columnEditor);
+            ColumnDefinitionParserListener.this.listeners.add(defaultValueParserListener);
+        }, tableEditor, columnEditor);
+
+        super.enterColumnDefinition(ctx);
+    }
+
+
+    @Override
+    public void enterNullNotnull(NullNotnullContext ctx) {
+        columnEditor.notNull(ctx.NOT() != null);
+        super.enterNullNotnull(ctx);
+    }
+
+    @Override
+    public void enterAutoIncrementColumnConstraint(AutoIncrementColumnConstraintContext ctx) {
+        columnEditor.autoIncremented(true);
+        columnEditor.generated(true);
+        super.enterAutoIncrementColumnConstraint(ctx);
+    }
+
+    @Override
+    public void enterCommentColumnConstraint(CommentColumnConstraintContext ctx) {
+        if (ctx.COMMENT() != null && ctx.STRING_LITERAL() != null) {
+            columnEditor.comment(JdbcStringUtils.withoutWrapper(ctx.STRING_LITERAL().getText()));
+        }
+        super.enterCommentColumnConstraint(ctx);
+    }
+
+    @Override
+    public void enterPrimaryKeyColumnConstraint(PrimaryKeyColumnConstraintContext ctx) {
+        /**
+         * sql example: `id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,
+         */
+        ignoreColumn.set(false);
+        this.tableEditor.withPrimaryKeyNames(this.columnEditor.ofName());
+        super.enterPrimaryKeyColumnConstraint(ctx);
+    }
+
+    @Override
+    public void enterUniqueKeyColumnConstraint(UniqueKeyColumnConstraintContext ctx) {
+        ignoreColumn.set(false);
+        super.enterUniqueKeyColumnConstraint(ctx);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void exitColumnDefinition(ColumnDefinitionContext ctx) {
+        if (!ignoreColumn.get().booleanValue()) {
+            this.tableEditor.addColumns(columnEditor.build());
+            ignoreColumn.set(false);
+        }
+
+        //When exit column definition needs to remove DefaultValueParserListener from listener list
+        parser.runIfAllNotNull(() -> listeners.remove(defaultValueParserListener), tableEditor);
+        super.exitColumnDefinition(ctx);
+    }
+
+    @Override
+    public void enterCollateColumnConstraint(CollateColumnConstraintContext ctx) {
+        if (ctx.COLLATE() != null) {
+            columnEditor.collate(ctx.collationName().getText());
+        }
+        super.enterCollateColumnConstraint(ctx);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateDatabaseParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateDatabaseParserListener.java
new file mode 100644
index 000000000..a5d15820a
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateDatabaseParserListener.java
@@ -0,0 +1,98 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.CatalogChanges;
+import org.apache.eventmesh.connector.jdbc.Payload;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CreateDatabaseContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CreateDatabaseOptionContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.event.CreateDatabaseEvent;
+import org.apache.eventmesh.connector.jdbc.event.SchemaChangeEventType;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlSourceMateData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.CatalogSchema;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.utils.Antlr4Utils;
+import org.apache.eventmesh.connector.jdbc.utils.JdbcStringUtils;
+
+/**
+ * Listener for parsing create database statements using ANTLR4.
+ * <p>
+ * Mysql <a href="https://dev.mysql.com/doc/refman/8.0/en/create-database.html">CREATE DATABASE Statement:</a>
+ * <blockquote><pre>
+ *  CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
+ *     [create_option] ...
+ *  create_option: [DEFAULT] {
+ *     CHARACTER SET [=] charset_name
+ *   | COLLATE [=] collation_name
+ *   | ENCRYPTION [=] {'Y' | 'N'}
+ * }
+ * </pre></blockquote>
+ */
+public class CreateDatabaseParserListener extends MySqlParserBaseListener {
+
+    private String databaseName;
+
+    private String charSetName;
+
+    private String collate;
+
+    private String encryption;
+
+    private MysqlAntlr4DdlParser parser;
+
+    public CreateDatabaseParserListener(MysqlAntlr4DdlParser parser) {
+        this.parser = parser;
+    }
+
+    @Override
+    public void enterCreateDatabase(CreateDatabaseContext ctx) {
+        this.databaseName = JdbcStringUtils.withoutWrapper(ctx.uid().getText());
+        super.enterCreateDatabase(ctx);
+    }
+
+    @Override
+    public void exitCreateDatabase(CreateDatabaseContext ctx) {
+        if (parser.getCallback() != null) {
+            String sql = Antlr4Utils.getText(ctx);
+            CatalogSchema catalogSchema = new CatalogSchema(databaseName, charSetName);
+            CreateDatabaseEvent event = new CreateDatabaseEvent(new TableId(databaseName));
+            Payload payload = event.getJdbcConnectData().getPayload();
+            SourceConnectorConfig sourceConnectorConfig = parser.getSourceConfig().getSourceConnectorConfig();
+            MysqlSourceMateData sourceMateData = MysqlSourceMateData.newBuilder()
+                .name(sourceConnectorConfig.getName())
+                .catalogName(databaseName)
+                .serverId(sourceConnectorConfig.getMysqlConfig().getServerId())
+                .build();
+            CatalogChanges changes = CatalogChanges.newBuilder().operationType(SchemaChangeEventType.DATABASE_CREATE).catalog(catalogSchema).build();
+            payload.withSource(sourceMateData).withDdl(sql).withCatalogChanges(changes);
+            parser.getCallback().handle(event);
+        }
+        super.exitCreateDatabase(ctx);
+    }
+
+    @Override
+    public void enterCreateDatabaseOption(CreateDatabaseOptionContext ctx) {
+        this.charSetName = ctx.charsetName().getText();
+        this.collate = ctx.COLLATE().getText();
+        this.encryption = ctx.ENCRYPTION().getText();
+        super.enterCreateDatabaseOption(ctx);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateTableParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateTableParserListener.java
new file mode 100644
index 000000000..2ed93cfba
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/CreateTableParserListener.java
@@ -0,0 +1,163 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.CatalogChanges;
+import org.apache.eventmesh.connector.jdbc.Payload;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.ColumnCreateTableContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CopyCreateTableContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.QueryCreateTableContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.TableOptionCharsetContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.TableOptionCollateContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.TableOptionEngineContext;
+import org.apache.eventmesh.connector.jdbc.event.CreateTableEvent;
+import org.apache.eventmesh.connector.jdbc.event.SchemaChangeEventType;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlSourceMateData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.Table;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlTableEditor;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlTableOptions;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlTableSchema;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.List;
+
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * <pre>
+ * listen for events while parsing a CREATE TABLE statement in a MySQL DDL (Data Definition Language) script.
+ * </pre>
+ *
+ * <a href="https://dev.mysql.com/doc/refman/8.0/en/create-table.html">MYSQL CREATE TABLE</a>
+ *
+ * <pre>
+ * CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
+ *     (create_definition,...)
+ *     [table_options]
+ *     [partition_options]
+ * </pre>
+ *
+ * <pre>
+ * CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
+ *     [(create_definition,...)]
+ *     [table_options]
+ *     [partition_options]
+ *     [IGNORE | REPLACE]
+ *     [AS] query_expression
+ * </pre>
+ * <pre>
+ * CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
+ *     { LIKE old_tbl_name | (LIKE old_tbl_name) }
+ * </pre>
+ */
+public class CreateTableParserListener extends TableBaseParserListener {
+
+    public CreateTableParserListener(List<ParseTreeListener> listeners, MysqlAntlr4DdlParser parser) {
+        super(listeners, parser);
+    }
+
+    @Override
+    public void enterCopyCreateTable(CopyCreateTableContext ctx) {
+        //TODO support next version
+        super.enterCopyCreateTable(ctx);
+    }
+
+    @Override
+    public void enterQueryCreateTable(QueryCreateTableContext ctx) {
+        //TODO support next version
+        super.enterQueryCreateTable(ctx);
+    }
+
+    @Override
+    public void enterColumnCreateTable(ColumnCreateTableContext ctx) {
+        String tableName = ctx.tableName().fullId().getText();
+        this.tableEditor = createTableEditor(tableName);
+        super.enterColumnCreateTable(ctx);
+    }
+
+    @Override
+    public void exitColumnCreateTable(ColumnCreateTableContext ctx) {
+        String ddl = ctx.getText();
+        parser.runIfAllNotNull(() -> {
+            listeners.remove(columnDefinitionListener);
+            //help JVM GC
+            columnDefinitionListener = null;
+            MysqlTableSchema tableSchema = tableEditor.build();
+            parser.getCatalogTableSet().overrideTable(tableSchema);
+            String currentDatabase = parser.getCurrentDatabase();
+            CreateTableEvent event = new CreateTableEvent(new TableId(currentDatabase, null, tableSchema.getSimpleName()));
+            Payload payload = event.getJdbcConnectData().getPayload();
+            SourceConnectorConfig sourceConnectorConfig = parser.getSourceConfig().getSourceConnectorConfig();
+            MysqlSourceMateData sourceMateData = MysqlSourceMateData.newBuilder()
+                .name(sourceConnectorConfig.getName())
+                .catalogName(currentDatabase)
+                .serverId(sourceConnectorConfig.getMysqlConfig().getServerId())
+                .build();
+            Table table = new Table(tableSchema.getSimpleName(), tableSchema.getPrimaryKey(), tableSchema.getUniqueKeys(), tableSchema.getComment());
+            CatalogChanges changes = CatalogChanges.newBuilder().operationType(SchemaChangeEventType.TABLE_CREATE).table(table)
+                .columns(tableSchema.getColumns()).build();
+            payload.withSource(sourceMateData).withDdl(ddl).withCatalogChanges(changes);
+            parser.handleEvent(event);
+        }, tableEditor);
+        super.exitColumnCreateTable(ctx);
+    }
+
+    private MysqlTableEditor createTableEditor(String tableName) {
+        TableId tableId = parser.parseTableId(tableName);
+        if (StringUtils.isBlank(tableId.getCatalogName())) {
+            tableId.setCatalogName(parser.getCurrentDatabase());
+        }
+        return MysqlTableEditor.ofCatalogTableEditor(tableId);
+    }
+
+    @Override
+    public void enterTableOptionEngine(TableOptionEngineContext ctx) {
+        if (ctx.ENGINE() != null) {
+            this.tableEditor.withOption(MysqlTableOptions.ENGINE, ctx.ENGINE().getText());
+        }
+        super.enterTableOptionEngine(ctx);
+    }
+
+    @Override
+    public void enterTableOptionCharset(TableOptionCharsetContext ctx) {
+
+        List<TerminalNode> nodes = ctx.DEFAULT();
+        if (CollectionUtils.isNotEmpty(nodes) && nodes.size() == 2) {
+            TerminalNode node = nodes.get(1);
+            this.tableEditor.withOption(MysqlTableOptions.CHARSET, node.getText());
+        } else {
+            this.tableEditor.withOption(MysqlTableOptions.CHARSET, ctx.charsetName().getText());
+        }
+
+        super.enterTableOptionCharset(ctx);
+    }
+
+    @Override
+    public void enterTableOptionCollate(TableOptionCollateContext ctx) {
+        if (ctx.COLLATE() != null) {
+            this.tableEditor.withOption(MysqlTableOptions.COLLATE, ctx.collationName().getText());
+        }
+        super.enterTableOptionCollate(ctx);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DefaultValueParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DefaultValueParserListener.java
new file mode 100644
index 000000000..3d67d7e91
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DefaultValueParserListener.java
@@ -0,0 +1,154 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.CurrentTimestampContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.DefaultValueContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.StringLiteralContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlColumnEditor;
+
+import org.apache.commons.collections4.CollectionUtils;
+
+import java.util.List;
+
+/**
+ * Listener for parsing default values in MySQL parser.
+ */
+public class DefaultValueParserListener extends MySqlParserBaseListener {
+
+    private final MysqlColumnEditor columnEditor;
+
+    public DefaultValueParserListener(MysqlColumnEditor columnEditor) {
+        this.columnEditor = columnEditor;
+    }
+
+    @Override
+    public void enterDefaultValue(DefaultValueContext ctx) {
+
+        /**
+         * defaultValue
+         *     : NULL_LITERAL
+         *     | CAST '(' expression AS convertedDataType ')'
+         *     | unaryOperator? constant
+         *     | currentTimestamp (ON UPDATE currentTimestamp)?
+         *     | '(' expression ')'
+         *     | '(' fullId ')'
+         *     ;
+         */
+        String sign = "";
+
+        //Default value is NULL
+        if (ctx.NULL_LITERAL() != null) {
+            return;
+        }
+
+        if (ctx.CAST() != null && ctx.expression() != null) {
+            columnEditor.defaultValueExpression(ctx.getText());
+            return;
+        }
+
+        if (ctx.unaryOperator() != null) {
+            sign = ctx.unaryOperator().getText();
+        }
+
+        /**
+         * Process expression
+         * constant
+         *     : stringLiteral | decimalLiteral
+         *     | '-' decimalLiteral
+         *     | hexadecimalLiteral | booleanLiteral
+         *     | REAL_LITERAL | BIT_STRING
+         *     | NOT? nullLiteral=(NULL_LITERAL | NULL_SPEC_LITERAL)
+         *     ;
+         */
+        if (ctx.constant() != null) {
+            StringLiteralContext stringLiteralContext = ctx.constant().stringLiteral();
+            if (stringLiteralContext != null) {
+                if (stringLiteralContext.COLLATE() == null) {
+                    columnEditor.defaultValueExpression(sign + unquote(stringLiteralContext.getText()));
+                } else {
+                    columnEditor.collate(sign + unquote(stringLiteralContext.STRING_LITERAL(0).getText()));
+                }
+            } else if (ctx.constant().decimalLiteral() != null) {
+                columnEditor.defaultValueExpression(sign + ctx.constant().decimalLiteral().getText());
+            } else if (ctx.constant().BIT_STRING() != null) {
+                columnEditor.defaultValueExpression(unquoteBinary(ctx.constant().BIT_STRING().getText()));
+            } else if (ctx.constant().booleanLiteral() != null) {
+                columnEditor.defaultValueExpression(ctx.constant().booleanLiteral().getText());
+            } else if (ctx.constant().REAL_LITERAL() != null) {
+                columnEditor.defaultValueExpression(ctx.constant().REAL_LITERAL().getText());
+            }
+        } else if (CollectionUtils.isNotEmpty(ctx.currentTimestamp())) {
+
+            /**
+             * <a href="https://dev.mysql.com/doc/refman/8.0/en/timestamp-initialization.html">timestamp-initialization</a>
+             * <a href="https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html">cast-functions</a>
+             * defaultValue
+             *     : NULL_LITERAL
+             *     | CAST '(' expression AS convertedDataType ')'
+             *     | unaryOperator? constant
+             *     | currentTimestamp (ON UPDATE currentTimestamp)?
+             *     | '(' expression ')'
+             *     | '(' fullId ')'
+             *     ;
+             * currentTimestamp
+             *     :
+             *     (
+             *       (CURRENT_TIMESTAMP | LOCALTIME | LOCALTIMESTAMP)
+             *       ('(' decimalLiteral? ')')?
+             *       | NOW '(' decimalLiteral? ')'
+             *     )
+             *     ;
+             */
+            List<CurrentTimestampContext> currentTimestampContexts = ctx.currentTimestamp();
+            if (currentTimestampContexts.size() > 1 || (ctx.ON() == null && ctx.UPDATE() == null)) {
+                CurrentTimestampContext currentTimestampContext = currentTimestampContexts.get(0);
+                //
+                if (currentTimestampContext.CURRENT_TIMESTAMP() != null || currentTimestampContext.NOW() != null) {
+                    columnEditor.defaultValueExpression("1970-01-01 00:00:00");
+                } else {
+                    columnEditor.defaultValueExpression(currentTimestampContext.getText());
+                }
+            }
+        } else if (ctx.expression() != null) {
+            //e.g. CREATE TABLE t2 (b BLOB DEFAULT ('abc'));
+            columnEditor.defaultValueExpression(ctx.expression().getText());
+        } else if (ctx.fullId() != null) {
+            columnEditor.defaultValueExpression(ctx.expression().getText());
+        }
+        super.enterDefaultValue(ctx);
+    }
+
+    @Override
+    public void exitDefaultValue(DefaultValueContext ctx) {
+        super.exitDefaultValue(ctx);
+    }
+
+    private String unquote(String stringLiteral) {
+        if (stringLiteral != null && ((stringLiteral.startsWith("'") && stringLiteral.endsWith("'"))
+            || (stringLiteral.startsWith("\"") && stringLiteral.endsWith("\"")))) {
+            return stringLiteral.substring(1, stringLiteral.length() - 1);
+        }
+        return stringLiteral;
+    }
+
+    private String unquoteBinary(String stringLiteral) {
+        return stringLiteral.substring(2, stringLiteral.length() - 1);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DropDatabaseParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DropDatabaseParserListener.java
new file mode 100644
index 000000000..22a25fcd3
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/DropDatabaseParserListener.java
@@ -0,0 +1,64 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.CatalogChanges;
+import org.apache.eventmesh.connector.jdbc.Payload;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.DropDatabaseContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.event.DropDatabaseEvent;
+import org.apache.eventmesh.connector.jdbc.event.SchemaChangeEventType;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlSourceMateData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.CatalogSchema;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.utils.Antlr4Utils;
+import org.apache.eventmesh.connector.jdbc.utils.JdbcStringUtils;
+
+public class DropDatabaseParserListener extends MySqlParserBaseListener {
+
+    private MysqlAntlr4DdlParser parser;
+
+    public DropDatabaseParserListener(MysqlAntlr4DdlParser parser) {
+        this.parser = parser;
+    }
+
+    @Override
+    public void enterDropDatabase(DropDatabaseContext ctx) {
+
+        String databaseName = JdbcStringUtils.withoutWrapper(ctx.uid().getText());
+        parser.getCatalogTableSet().removeDatabase(databaseName);
+        if (parser.getCallback() != null) {
+            String sql = Antlr4Utils.getText(ctx);
+            CatalogSchema catalogSchema = new CatalogSchema(databaseName);
+            DropDatabaseEvent event = new DropDatabaseEvent(new TableId(databaseName));
+            Payload payload = event.getJdbcConnectData().getPayload();
+            SourceConnectorConfig sourceConnectorConfig = parser.getSourceConfig().getSourceConnectorConfig();
+            MysqlSourceMateData sourceMateData = MysqlSourceMateData.newBuilder()
+                .name(sourceConnectorConfig.getName())
+                .catalogName(databaseName)
+                .serverId(sourceConnectorConfig.getMysqlConfig().getServerId())
+                .build();
+            CatalogChanges changes = CatalogChanges.newBuilder().operationType(SchemaChangeEventType.DATABASE_DROP).catalog(catalogSchema).build();
+            payload.withSource(sourceMateData).withDdl(sql).withCatalogChanges(changes);
+            parser.getCallback().handle(event);
+        }
+        super.enterDropDatabase(ctx);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/MySqlAntlr4DdlParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/MySqlAntlr4DdlParserListener.java
new file mode 100644
index 000000000..8049c6b2d
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/MySqlAntlr4DdlParserListener.java
@@ -0,0 +1,72 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.listener.Antlr4DdlParserListener;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+public class MySqlAntlr4DdlParserListener implements Antlr4DdlParserListener {
+
+    private final List<ParseTreeListener> listeners = new CopyOnWriteArrayList<>();
+
+    public MySqlAntlr4DdlParserListener(MysqlAntlr4DdlParser parser) {
+        listeners.add(new CreateDatabaseParserListener(parser));
+        listeners.add(new DropDatabaseParserListener(parser));
+        listeners.add(new CreateTableParserListener(listeners, parser));
+        listeners.add(new TruncateTableParserListener(parser));
+    }
+
+    @Override
+    public void visitTerminal(TerminalNode node) {
+        for (ParseTreeListener listener : listeners) {
+            listener.visitTerminal(node);
+        }
+    }
+
+    @Override
+    public void visitErrorNode(ErrorNode node) {
+        for (ParseTreeListener listener : listeners) {
+            listener.visitErrorNode(node);
+        }
+    }
+
+    @Override
+    public void enterEveryRule(ParserRuleContext ctx) {
+
+        for (ParseTreeListener listener : listeners) {
+            listener.enterEveryRule(ctx);
+            ctx.enterRule(listener);
+        }
+    }
+
+    @Override
+    public void exitEveryRule(ParserRuleContext ctx) {
+        for (ParseTreeListener listener : listeners) {
+            ctx.exitRule(listener);
+            listener.exitEveryRule(ctx);
+        }
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TableBaseParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TableBaseParserListener.java
new file mode 100644
index 000000000..b978214b1
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TableBaseParserListener.java
@@ -0,0 +1,180 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.ColumnDeclarationContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.DottedIdContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.FullColumnNameContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.IndexColumnNamesContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.IndexOptionContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.PrimaryKeyTableConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.UidContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.UniqueKeyTableConstraintContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlColumnEditor;
+import org.apache.eventmesh.connector.jdbc.table.catalog.mysql.MysqlTableEditor;
+import org.apache.eventmesh.connector.jdbc.utils.JdbcStringUtils;
+
+import org.apache.commons.collections4.CollectionUtils;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+public class TableBaseParserListener extends MySqlParserBaseListener {
+
+    protected final List<ParseTreeListener> listeners;
+
+    protected final MysqlAntlr4DdlParser parser;
+
+    protected MysqlTableEditor tableEditor;
+
+    protected ColumnDefinitionParserListener columnDefinitionListener;
+
+    public TableBaseParserListener(List<ParseTreeListener> listeners, MysqlAntlr4DdlParser parser) {
+        this.listeners = listeners;
+        this.parser = parser;
+    }
+
+    /**
+     * Called when entering a column declaration context.
+     *
+     * @param ctx The column declaration context.
+     */
+    @Override
+    public void enterColumnDeclaration(ColumnDeclarationContext ctx) {
+
+        /**
+         * Parse
+         * createDefinition
+         *     : fullColumnName columnDefinition                               #columnDeclaration
+         *     | tableConstraint NOT? ENFORCED?                                #constraintDeclaration
+         *     | indexColumnDefinition                                         #indexDeclaration
+         *     ;
+         */
+        parser.runIfAllNotNull(() -> {
+            FullColumnNameContext fullColumnNameContext = ctx.fullColumnName();
+            //parse column name
+            UidContext uidContext = fullColumnNameContext.uid();
+            List<DottedIdContext> dottedIdContextList = fullColumnNameContext.dottedId();
+            if (CollectionUtils.isNotEmpty(dottedIdContextList)) {
+                uidContext = dottedIdContextList.get(dottedIdContextList.size() - 1).uid();
+            }
+            String columnName = JdbcStringUtils.withoutWrapper(uidContext.getText());
+            MysqlColumnEditor columnEditor = MysqlColumnEditor.ofEditor(columnName);
+            if (Objects.isNull(columnDefinitionListener)) {
+                columnDefinitionListener = new ColumnDefinitionParserListener(listeners, tableEditor, columnEditor, parser);
+                //add ColumnDefinitionParserListener to listener list
+                listeners.add(columnDefinitionListener);
+            } else {
+                columnDefinitionListener.setColumnEditor(columnEditor);
+            }
+        }, tableEditor);
+
+        super.enterColumnDeclaration(ctx);
+    }
+
+    @Override
+    public void exitColumnDeclaration(ColumnDeclarationContext ctx) {
+
+        parser.runIfAllNotNull(() -> tableEditor.addColumns(columnDefinitionListener.getColumnEditor().build()), tableEditor,
+            columnDefinitionListener);
+
+        super.exitColumnDeclaration(ctx);
+    }
+
+    @Override
+    public void enterPrimaryKeyTableConstraint(PrimaryKeyTableConstraintContext ctx) {
+        /**
+         *Although the creation of a Primary Key is defined within the column definitions when creating a table,
+         * it can be considered as part of table management in practice.
+         * SQL example: PRIMARY KEY (`id`),
+         */
+        parser.runIfAllNotNull(() -> {
+            IndexColumnNamesContext indexColumnNamesContext = ctx.indexColumnNames();
+            List<String> pkColumnNames = indexColumnNamesContext.indexColumnName().stream().map(indexColumnNameCtx -> {
+                /**
+                 * indexColumnName
+                 *     : ((uid | STRING_LITERAL) ('(' decimalLiteral ')')? | expression) sortType=(ASC | DESC)?
+                 *
+                 */
+                String pkColumnName;
+                if (indexColumnNameCtx.uid() != null) {
+                    pkColumnName = JdbcStringUtils.withoutWrapper(indexColumnNameCtx.uid().getText());
+                } else if (indexColumnNameCtx.STRING_LITERAL() != null) {
+                    pkColumnName = JdbcStringUtils.withoutWrapper(indexColumnNameCtx.STRING_LITERAL().getText());
+                } else {
+                    pkColumnName = indexColumnNameCtx.expression().getText();
+                }
+                return pkColumnName;
+            }).collect(Collectors.toList());
+            String comment = null;
+            List<IndexOptionContext> indexOptionContexts = ctx.indexOption();
+            for (IndexOptionContext indexOptionContext : indexOptionContexts) {
+                if (indexOptionContext.COMMENT() != null && indexOptionContext.STRING_LITERAL() != null) {
+                    comment = indexOptionContext.STRING_LITERAL().getText();
+                }
+            }
+            tableEditor.withPrimaryKeyNames(pkColumnNames, comment);
+        }, tableEditor);
+
+        super.enterPrimaryKeyTableConstraint(ctx);
+    }
+
+    @Override
+    public void enterUniqueKeyTableConstraint(UniqueKeyTableConstraintContext ctx) {
+
+        //sql example: UNIQUE KEY `eventmesh` (`event_mesh`) USING BTREE COMMENT 'event mesh'
+
+        parser.runIfAllNotNull(() -> {
+            IndexColumnNamesContext indexColumnNamesContext = ctx.indexColumnNames();
+            List<String> ukColumnNames = indexColumnNamesContext.indexColumnName().stream().map(indexColumnNameCtx -> {
+                /**
+                 * indexColumnName
+                 *     : ((uid | STRING_LITERAL) ('(' decimalLiteral ')')? | expression) sortType=(ASC | DESC)?
+                 *
+                 */
+                String ukColumnName;
+                if (indexColumnNameCtx.uid() != null) {
+                    ukColumnName = JdbcStringUtils.withoutWrapper(indexColumnNameCtx.uid().getText());
+                } else if (indexColumnNameCtx.STRING_LITERAL() != null) {
+                    ukColumnName = JdbcStringUtils.withoutWrapper(indexColumnNameCtx.STRING_LITERAL().getText());
+                } else {
+                    ukColumnName = indexColumnNameCtx.expression().getText();
+                }
+                return ukColumnName;
+            }).collect(Collectors.toList());
+            List<IndexOptionContext> indexOptionContexts = ctx.indexOption();
+            String comment = null;
+            if (CollectionUtils.isNotEmpty(indexOptionContexts)) {
+                for (IndexOptionContext context : indexOptionContexts) {
+                    if (context.COMMENT() != null && context.STRING_LITERAL() != null) {
+                        comment = context.STRING_LITERAL().getText();
+                    }
+                }
+            }
+            String ukName = ctx.index != null ? ctx.index.getText() : null;
+            tableEditor.withUniqueKeyColumnsNames(ukName, ukColumnNames, comment);
+        }, tableEditor);
+
+        super.enterUniqueKeyTableConstraint(ctx);
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TruncateTableParserListener.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TruncateTableParserListener.java
new file mode 100644
index 000000000..14d7bdaa1
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/antlr4/mysql/listener/TruncateTableParserListener.java
@@ -0,0 +1,55 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.listener;
+
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParser.TruncateTableContext;
+import org.apache.eventmesh.connector.jdbc.antlr4.autogeneration.MySqlParserBaseListener;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.utils.Antlr4Utils;
+import org.apache.eventmesh.connector.jdbc.utils.JdbcStringUtils;
+
+/**
+ * A custom ANTLR listener for parsing TRUNCATE TABLE statements.
+ * <a href="https://dev.mysql.com/doc/refman/8.0/en/truncate-table.html">TRUNCATE TABLE Statement</a>
+ * <pre>
+ *     TRUNCATE [TABLE] tbl_name
+ * </pre>
+ */
+public class TruncateTableParserListener extends MySqlParserBaseListener {
+
+    private MysqlAntlr4DdlParser parser;
+
+    /**
+     * Constructs a TruncateTableParserListener with the specified parser.
+     *
+     * @param parser The MysqlAntlr4DdlParser used for parsing.
+     */
+    public TruncateTableParserListener(MysqlAntlr4DdlParser parser) {
+        this.parser = parser;
+    }
+
+    @Override
+    public void enterTruncateTable(TruncateTableContext ctx) {
+        String sql = Antlr4Utils.getText(ctx);
+        String tableName = JdbcStringUtils.withoutWrapper(ctx.tableName().fullId().getText());
+        //TruncateTableEvent event = new TruncateTableEvent(parser.getCurrentDatabase(), tableName, sql);
+        parser.handleEvent(null);
+        super.enterTruncateTable(ctx);
+    }
+}
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/EventDataDeserializationExceptionData.java
similarity index 51%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/EventDataDeserializationExceptionData.java
index 7fcb9dfd7..4d06b6cc2 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/EventDataDeserializationExceptionData.java
@@ -15,30 +15,27 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.source.dialect.mysql;
 
-/**
- * Interface for parsing DDL SQL statements.
- */
-public interface DdlParser {
-
-    /**
-     * Parses the given DDL SQL statement.
-     *
-     * @param ddlSql the DDL SQL statement to be parsed
-     */
-    default void parse(String ddlSql) {
-        parse(ddlSql, null);
-    }
+import com.github.shyiko.mysql.binlog.event.EventData;
+import com.github.shyiko.mysql.binlog.event.deserialization.EventDataDeserializationException;
+
+public class EventDataDeserializationExceptionData implements EventData {
+
+    private static final long serialVersionUID = 7990993358724828999L;
 
-    void parse(String ddlSql, DdlParserCallback callback);
+    private final EventDataDeserializationException cause;
 
-    /**
-     * Sets the current database.
-     *
-     * @param databaseName the name of the database to be set as current
-     */
-    void setCurrentDatabase(String databaseName);
+    public EventDataDeserializationExceptionData(EventDataDeserializationException cause) {
+        this.cause = cause;
+    }
+
+    public EventDataDeserializationException getCause() {
+        return cause;
+    }
 
-    void setCurrentSchema(String schema);
+    @Override
+    public String toString() {
+        return "EventDataDeserializationExceptionData [cause=" + cause + "]";
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/GtidSet.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/GtidSet.java
new file mode 100644
index 000000000..a1cb8738e
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/GtidSet.java
@@ -0,0 +1,485 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public final class GtidSet {
+
+    private final Map<String, UUIDSet> uuidSetsByServerId = new TreeMap<>(); // sorts on keys
+    public static Pattern GTID_DELIMITER = Pattern.compile(":");
+
+    protected GtidSet(Map<String, UUIDSet> uuidSetsByServerId) {
+        this.uuidSetsByServerId.putAll(uuidSetsByServerId);
+    }
+
+    /**
+     * @param gtids the string representation of the GTIDs.
+     */
+    public GtidSet(String gtids) {
+        new com.github.shyiko.mysql.binlog.GtidSet(gtids).getUUIDSets().forEach(uuidSet -> {
+            uuidSetsByServerId.put(uuidSet.getServerId().toString(), new UUIDSet(uuidSet));
+        });
+        StringBuilder sb = new StringBuilder();
+        uuidSetsByServerId.values().forEach(uuidSet -> {
+            if (sb.length() != 0) {
+                sb.append(',');
+            }
+            sb.append(uuidSet.toString());
+        });
+    }
+
+    /**
+     * Obtain a copy of this {@link GtidSet} except with only the GTID ranges that have server UUIDs that match the given predicate.
+     *
+     * @param sourceFilter the predicate that returns whether a server UUID is to be included
+     * @return the new GtidSet, or this object if {@code sourceFilter} is null; never null
+     */
+    public GtidSet retainAll(Predicate<String> sourceFilter) {
+        if (sourceFilter == null) {
+            return this;
+        }
+        Map<String, UUIDSet> newSets = this.uuidSetsByServerId.entrySet()
+            .stream()
+            .filter(entry -> sourceFilter.test(entry.getKey()))
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        return new GtidSet(newSets);
+    }
+
+    /**
+     * Get an immutable collection of the {@link UUIDSet range of GTIDs for a single server}.
+     *
+     * @return the {@link UUIDSet GTID ranges for each server}; never null
+     */
+    public Collection<UUIDSet> getUUIDSets() {
+        return Collections.unmodifiableCollection(uuidSetsByServerId.values());
+    }
+
+    /**
+     * Find the {@link UUIDSet} for the server with the specified Uuid.
+     *
+     * @param uuid the Uuid of the server
+     * @return the {@link UUIDSet} for the identified server, or {@code null} if there are no GTIDs from that server.
+     */
+    public UUIDSet forServerWithId(String uuid) {
+        return uuidSetsByServerId.get(uuid);
+    }
+
+    /**
+     * Determine if the GTIDs represented by this object are contained completely within the supplied set of GTIDs.
+     *
+     * @param other the other set of GTIDs; may be null
+     * @return {@code true} if all of the GTIDs in this set are completely contained within the supplied set of GTIDs, or {@code false} otherwise
+     */
+    public boolean isContainedWithin(GtidSet other) {
+        if (other == null) {
+            return false;
+        }
+        if (this.equals(other)) {
+            return true;
+        }
+        for (UUIDSet uuidSet : uuidSetsByServerId.values()) {
+            UUIDSet thatSet = other.forServerWithId(uuidSet.getUUID());
+            if (!uuidSet.isContainedWithin(thatSet)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Obtain a copy of this {@link GtidSet} except overwritten with all of the GTID ranges in the supplied {@link GtidSet}.
+     *
+     * @param other the other {@link GtidSet} with ranges to add/overwrite on top of those in this set;
+     * @return the new GtidSet, or this object if {@code other} is null or empty; never null
+     */
+    public GtidSet with(GtidSet other) {
+        if (other == null || other.uuidSetsByServerId.isEmpty()) {
+            return this;
+        }
+        Map<String, UUIDSet> newSet = new HashMap<>();
+        newSet.putAll(this.uuidSetsByServerId);
+        newSet.putAll(other.uuidSetsByServerId);
+        return new GtidSet(newSet);
+    }
+
+    /**
+     * Retrieves the beginning GTID set.
+     *
+     * @return The starting state of the GTID set.
+     */
+    public GtidSet getGtidSetBeginning() {
+        // Create a new map to store the GTID set
+        Map<String, UUIDSet> newSet = new HashMap<>();
+
+        // Iterate over each UUID set for each server ID
+        for (UUIDSet uuidSet : uuidSetsByServerId.values()) {
+            // Store the beginning state of each UUID set as the value in the new set, with UUID as the key
+            newSet.put(uuidSet.getUUID(), uuidSet.asIntervalBeginning());
+        }
+
+        // Create and return a new GTID set object using the new map
+        return new GtidSet(newSet);
+    }
+
+    public boolean contains(String gtid) {
+        String[] split = GTID_DELIMITER.split(gtid);
+        String sourceId = split[0];
+        UUIDSet uuidSet = forServerWithId(sourceId);
+        if (uuidSet == null) {
+            return false;
+        }
+        long transactionId = Long.parseLong(split[1]);
+        return uuidSet.contains(transactionId);
+    }
+
+    public GtidSet subtract(GtidSet other) {
+        if (other == null) {
+            return this;
+        }
+        Map<String, UUIDSet> newSets = this.uuidSetsByServerId.entrySet()
+            .stream()
+            .filter(entry -> !entry.getValue().isContainedWithin(other.forServerWithId(entry.getKey())))
+            .map(entry -> new AbstractMap.SimpleEntry<>(entry.getKey(), entry.getValue().subtract(other.forServerWithId(entry.getKey()))))
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        return new GtidSet(newSets);
+    }
+
+    @Override
+    public int hashCode() {
+        return uuidSetsByServerId.keySet().hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof GtidSet) {
+            GtidSet that = (GtidSet) obj;
+            return this.uuidSetsByServerId.equals(that.uuidSetsByServerId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        List<String> gtids = new ArrayList<String>();
+        for (UUIDSet uuidSet : uuidSetsByServerId.values()) {
+            gtids.add(uuidSet.toString());
+        }
+        return String.join(",", gtids);
+    }
+
+    /**
+     * A range of GTIDs for a single server with a specific Uuid.
+     */
+
+    public static class UUIDSet {
+
+        private final String uuid;
+        private final LinkedList<Interval> intervals = new LinkedList<>();
+
+        protected UUIDSet(com.github.shyiko.mysql.binlog.GtidSet.UUIDSet uuidSet) {
+            this.uuid = uuidSet.getServerId().toString();
+            uuidSet.getIntervals().forEach(interval -> {
+                intervals.add(new Interval(interval.getStart(), interval.getEnd()));
+            });
+            Collections.sort(this.intervals);
+            if (this.intervals.size() > 1) {
+                // Collapse adjacent intervals ...
+                for (int i = intervals.size() - 1; i != 0; --i) {
+                    Interval before = this.intervals.get(i - 1);
+                    Interval after = this.intervals.get(i);
+                    if ((before.getEnd() + 1) == after.getStart()) {
+                        this.intervals.set(i - 1, new Interval(before.getStart(), after.getEnd()));
+                        this.intervals.remove(i);
+                    }
+                }
+            }
+        }
+
+        protected UUIDSet(String uuid, Interval interval) {
+            this.uuid = uuid;
+            this.intervals.add(interval);
+        }
+
+        protected UUIDSet(String uuid, List<Interval> intervals) {
+            this.uuid = uuid;
+            this.intervals.addAll(intervals);
+        }
+
+        public UUIDSet asIntervalBeginning() {
+            Interval start = new Interval(intervals.get(0).getStart(), intervals.get(0).getStart());
+            return new UUIDSet(this.uuid, start);
+        }
+
+        /**
+         * Get the Uuid for the server that generated the GTIDs.
+         *
+         * @return the server's Uuid; never null
+         */
+        public String getUUID() {
+            return uuid;
+        }
+
+        /**
+         * Get the intervals of transaction numbers.
+         *
+         * @return the immutable transaction intervals; never null
+         */
+        public List<Interval> getIntervals() {
+            return Collections.unmodifiableList(intervals);
+        }
+
+        /**
+         * Determine if the set of transaction numbers from this server is completely within the set of transaction numbers from the set of
+         * transaction numbers in the supplied set.
+         *
+         * @param other the set to compare with this set
+         * @return {@code true} if this server's transaction numbers are a subset of the transaction numbers of the supplied set, or false otherwise
+         */
+        public boolean isContainedWithin(UUIDSet other) {
+            if (other == null) {
+                return false;
+            }
+            if (!this.getUUID().equalsIgnoreCase(other.getUUID())) {
+                // Not even the same server ...
+                return false;
+            }
+            if (this.intervals.isEmpty()) {
+                return true;
+            }
+            if (other.intervals.isEmpty()) {
+                return false;
+            }
+            assert this.intervals.size() > 0;
+            assert other.intervals.size() > 0;
+
+            // Every interval in this must be within an interval of the other ...
+            for (Interval thisInterval : this.intervals) {
+                boolean found = false;
+                for (Interval otherInterval : other.intervals) {
+                    if (thisInterval.isContainedWithin(otherInterval)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    return false; // didn't find a match
+                }
+            }
+            return true;
+        }
+
+        public boolean contains(long transactionId) {
+            for (Interval interval : this.intervals) {
+                if (interval.contains(transactionId)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return uuid.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (obj instanceof UUIDSet) {
+                UUIDSet that = (UUIDSet) obj;
+                return this.getUUID().equalsIgnoreCase(that.getUUID()) && this.getIntervals().equals(that.getIntervals());
+            }
+            return super.equals(obj);
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            sb.append(uuid).append(':');
+            Iterator<Interval> iter = intervals.iterator();
+            if (iter.hasNext()) {
+                sb.append(iter.next());
+            }
+            while (iter.hasNext()) {
+                sb.append(':');
+                sb.append(iter.next());
+            }
+            return sb.toString();
+        }
+
+        public UUIDSet subtract(UUIDSet other) {
+            if (!uuid.equals(other.getUUID())) {
+                throw new IllegalArgumentException("UUIDSet subtraction is supported only within a single server UUID");
+            }
+            List<Interval> result = new ArrayList<>();
+            for (Interval interval : intervals) {
+                result.addAll(interval.removeAll(other.getIntervals()));
+            }
+            return new UUIDSet(uuid, result);
+        }
+    }
+
+
+    public static class Interval implements Comparable<Interval> {
+
+        private final long start;
+        private final long end;
+
+        public Interval(long start, long end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        /**
+         * Get the starting transaction number in this interval.
+         *
+         * @return this interval's first transaction number
+         */
+        public long getStart() {
+            return start;
+        }
+
+        /**
+         * Get the ending transaction number in this interval.
+         *
+         * @return this interval's last transaction number
+         */
+        public long getEnd() {
+            return end;
+        }
+
+        /**
+         * Determine if this interval is completely within the supplied interval.
+         *
+         * @param other the interval to compare with
+         * @return {@code true} if the {@link #getStart() start} is greater than or equal to the supplied interval's {@link #getStart() start} and the
+         * {@link #getEnd() end} is less than or equal to the supplied interval's {@link #getEnd() end}, or {@code false} otherwise
+         */
+        public boolean isContainedWithin(Interval other) {
+            if (other == this) {
+                return true;
+            }
+            if (other == null) {
+                return false;
+            }
+            return this.getStart() >= other.getStart() && this.getEnd() <= other.getEnd();
+        }
+
+        public boolean contains(long transactionId) {
+            return getStart() <= transactionId && transactionId <= getEnd();
+        }
+
+        public boolean contains(Interval other) {
+            return getStart() <= other.getStart() && getEnd() >= other.getEnd();
+        }
+
+        public boolean nonintersecting(Interval other) {
+            return other.getEnd() < this.getStart() || other.getStart() > this.getEnd();
+        }
+
+        public List<Interval> remove(Interval other) {
+            if (nonintersecting(other)) {
+                return Collections.singletonList(this);
+            }
+            if (other.contains(this)) {
+                return Collections.emptyList();
+            }
+            List<Interval> result = new LinkedList<>();
+            if (this.getStart() < other.getStart()) {
+                Interval part = new Interval(this.getStart(), other.getStart() - 1);
+                result.add(part);
+            }
+            if (other.getEnd() < this.getEnd()) {
+                Interval part = new Interval(other.getEnd() + 1, this.getEnd());
+                result.add(part);
+            }
+            return result;
+        }
+
+        public List<Interval> removeAll(List<Interval> otherIntervals) {
+            List<Interval> thisIntervals = new LinkedList<>();
+            thisIntervals.add(this);
+            List<Interval> result = new LinkedList<>();
+            result.add(this);
+            for (Interval other : otherIntervals) {
+                result = new LinkedList<>();
+                for (Interval thisInterval : thisIntervals) {
+                    result.addAll(thisInterval.remove(other));
+                }
+                thisIntervals = result;
+            }
+            return result;
+        }
+
+        @Override
+        public int compareTo(Interval that) {
+            if (that == this) {
+                return 0;
+            }
+            long diff = this.start - that.start;
+            if (diff > Integer.MAX_VALUE) {
+                return Integer.MAX_VALUE;
+            }
+            if (diff < Integer.MIN_VALUE) {
+                return Integer.MIN_VALUE;
+            }
+            return (int) diff;
+        }
+
+        @Override
+        public int hashCode() {
+            return (int) getStart();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj instanceof Interval) {
+                Interval that = (Interval) obj;
+                return this.getStart() == that.getStart() && this.getEnd() == that.getEnd();
+            }
+            return false;
+        }
+
+        @Override
+        public String toString() {
+            return "" + getStart() + "-" + getEnd();
+        }
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDataTypeConvertor.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDataTypeConvertor.java
new file mode 100644
index 000000000..cac947f60
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDataTypeConvertor.java
@@ -0,0 +1,230 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+import org.apache.eventmesh.connector.jdbc.DataTypeConvertor;
+import org.apache.eventmesh.connector.jdbc.exception.DataTypeConvertException;
+import org.apache.eventmesh.connector.jdbc.table.type.CalendarType;
+import org.apache.eventmesh.connector.jdbc.table.type.DecimalType;
+import org.apache.eventmesh.connector.jdbc.table.type.EventMeshDataType;
+import org.apache.eventmesh.connector.jdbc.table.type.PrimitiveByteArrayType;
+import org.apache.eventmesh.connector.jdbc.table.type.PrimitiveType;
+import org.apache.eventmesh.connector.jdbc.table.type.SQLType;
+
+import java.sql.JDBCType;
+import java.util.Map;
+import java.util.Objects;
+
+import com.mysql.cj.MysqlType;
+
+public class MysqlDataTypeConvertor implements DataTypeConvertor<MysqlType> {
+
+    public static final String PRECISION = "precision";
+
+    public static final String SCALE = "scale";
+
+    /**
+     * @see <a href="https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html">Fixed-Point Types (Exact Value) - DECIMAL, NUMERIC</a>
+     */
+    public static final Integer DEFAULT_PRECISION = 10;
+
+    public static final Integer DEFAULT_SCALE = 0;
+
+
+    /**
+     * Converts a string representation of a connector data type to the corresponding JDBCType.
+     *
+     * @param connectorDataType The string representation of the connector data type.
+     * @return The corresponding JDBCType, or null if the connector data type is not recognized.
+     */
+    @Override
+    public JDBCType toJDBCType(String connectorDataType) {
+        MysqlType mysqlType = MysqlType.getByName(connectorDataType);
+        return JDBCType.valueOf(mysqlType.getJdbcType());
+    }
+
+    /**
+     * Converts a connector data type to an EventMesh data type. e.g. "int", "varchar(255)","decimal(10,2)"
+     *
+     * @param connectorDataType The connector data type to be converted.
+     * @return The converted EventMesh data type.
+     * @throws DataTypeConvertException If the conversion fails.
+     */
+    @Override
+    public EventMeshDataType<?> toEventMeshType(String connectorDataType) throws DataTypeConvertException {
+        MysqlType mysqlType = MysqlType.getByName(connectorDataType);
+        return toEventMeshType(mysqlType, null);
+    }
+
+    /**
+     * Converts JDBCType and dataTypeProperties to EventMeshDataType.
+     *
+     * @param jdbcType           the JDBCType to be converted
+     * @param dataTypeProperties the properties of the data type
+     * @return the converted EventMeshDataType
+     * @throws DataTypeConvertException if there is an error during conversion
+     */
+    @Override
+    public EventMeshDataType<?> toEventMeshType(JDBCType jdbcType, Map<String, Object> dataTypeProperties) throws DataTypeConvertException {
+        return toEventMeshType(MysqlType.getByJdbcType(jdbcType.getVendorTypeNumber()), dataTypeProperties);
+    }
+
+    /**
+     * Converts a connector data type to an EventMesh data type with additional data type properties.
+     *
+     * @param connectorDataType  The connector data type to be converted.
+     * @param dataTypeProperties Additional data type properties.
+     * @return The converted EventMesh data type.
+     * @throws DataTypeConvertException If the conversion fails.
+     */
+    @Override
+    public EventMeshDataType<?> toEventMeshType(MysqlType connectorDataType, Map<String, Object> dataTypeProperties) throws DataTypeConvertException {
+
+        Objects.requireNonNull(connectorDataType, "MysqlType can't be null");
+
+        switch (connectorDataType) {
+            case NULL:
+                return PrimitiveType.VOID_TYPE;
+            case BOOLEAN:
+                return PrimitiveType.BOOLEAN_TYPE;
+            case BIT: {
+                /**
+                 *  @see <a href="https://dev.mysql.com/doc/refman/8.0/en/bit-type.html">Mysql doc</a>
+                 */
+                if (null == dataTypeProperties) {
+                    return PrimitiveByteArrayType.BYTES_TYPE;
+                }
+                Integer precision = (Integer) dataTypeProperties.get(MysqlDataTypeConvertor.PRECISION);
+                if (precision != null && precision == 1) {
+                    return PrimitiveType.BOOLEAN_TYPE;
+                }
+                return PrimitiveByteArrayType.BYTES_TYPE;
+            }
+            case TINYINT:
+                return PrimitiveType.BYTE_TYPE;
+            case TINYINT_UNSIGNED:
+            case SMALLINT:
+                return PrimitiveType.SHORT_TYPE;
+            case SMALLINT_UNSIGNED:
+            case INT:
+            case MEDIUMINT:
+            case MEDIUMINT_UNSIGNED:
+                return PrimitiveType.INT_TYPE;
+            case INT_UNSIGNED:
+            case BIGINT:
+                return PrimitiveType.LONG_TYPE;
+            case FLOAT:
+            case FLOAT_UNSIGNED:
+                return PrimitiveType.FLOAT_TYPE;
+            case DOUBLE:
+            case DOUBLE_UNSIGNED:
+                return PrimitiveType.DOUBLE_TYPE;
+            case TIME:
+                return CalendarType.LOCAL_TIME_TYPE;
+            case YEAR:
+            case DATE:
+                return CalendarType.LOCAL_DATE_TYPE;
+            case TIMESTAMP:
+            case DATETIME:
+                return CalendarType.LOCAL_DATE_TIME_TYPE;
+            case CHAR:
+            case VARCHAR:
+            case TINYTEXT:
+            case TEXT:
+            case MEDIUMTEXT:
+            case LONGTEXT:
+            case JSON:
+            case ENUM:
+                return PrimitiveType.STRING_TYPE;
+            case BINARY:
+            case VARBINARY:
+            case TINYBLOB:
+            case BLOB:
+            case MEDIUMBLOB:
+            case LONGBLOB:
+            case GEOMETRY:
+                return PrimitiveByteArrayType.BYTES_TYPE;
+            case BIGINT_UNSIGNED:
+            case DECIMAL:
+            case DECIMAL_UNSIGNED: {
+                /**
+                 *  @see <a https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html">Mysql doc-DECIMAL, NUMERIC</a>
+                 */
+                if (dataTypeProperties == null) {
+                    return new DecimalType(DEFAULT_PRECISION, DEFAULT_SCALE);
+                }
+                Integer precision = (Integer) dataTypeProperties.getOrDefault(PRECISION, DEFAULT_PRECISION);
+                Integer scale = (Integer) dataTypeProperties.getOrDefault(SCALE, DEFAULT_SCALE);
+                return new DecimalType(precision, scale);
+            }
+            default:
+                throw new DataTypeConvertException(String.format("%s type is not supported", connectorDataType.getName()));
+        }
+    }
+
+    /**
+     * Converts an EventMesh data type to a connector data type with additional data type properties.
+     *
+     * @param eventMeshDataType  The EventMesh data type to be converted.
+     * @param dataTypeProperties Additional data type properties.
+     * @return The converted connector data type.
+     * @throws DataTypeConvertException If the conversion fails.
+     */
+    @Override
+    public MysqlType toConnectorType(EventMeshDataType<?> eventMeshDataType, Map<String, Object> dataTypeProperties) throws DataTypeConvertException {
+
+        Objects.requireNonNull(eventMeshDataType, "Parameter eventMeshDataType can not be null");
+        SQLType sqlType = eventMeshDataType.getSQLType();
+
+        switch (sqlType) {
+            case BOOLEAN:
+                return MysqlType.BOOLEAN;
+            case TINYINT:
+                return MysqlType.TINYINT;
+            case SMALLINT:
+                return MysqlType.SMALLINT;
+            case INTEGER:
+                return MysqlType.INT;
+            case BIGINT:
+                return MysqlType.BIGINT;
+            case FLOAT:
+                return MysqlType.FLOAT;
+            case DOUBLE:
+                return MysqlType.DOUBLE;
+            case DECIMAL:
+                return MysqlType.DECIMAL;
+            case NULL:
+                return MysqlType.NULL;
+            case BINARY:
+                return MysqlType.BIT;
+            case DATE:
+                return MysqlType.DATE;
+            case TIME:
+                return MysqlType.DATETIME;
+            case TIMESTAMP:
+                return MysqlType.TIMESTAMP;
+            case ARRAY:
+            case MAP:
+            case ROW:
+            case STRING:
+                return MysqlType.VARCHAR;
+            default:
+                throw new DataTypeConvertException(String.format("%s type is not supported", sqlType.name()));
+        }
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialect.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialect.java
new file mode 100644
index 000000000..81b0b0195
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialect.java
@@ -0,0 +1,313 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+import org.apache.eventmesh.connector.jdbc.DataTypeConvertor;
+import org.apache.eventmesh.connector.jdbc.JdbcDriverMetaData;
+import org.apache.eventmesh.connector.jdbc.connection.mysql.MysqlJdbcConnection;
+import org.apache.eventmesh.connector.jdbc.exception.CatalogException;
+import org.apache.eventmesh.connector.jdbc.exception.DatabaseNotExistException;
+import org.apache.eventmesh.connector.jdbc.exception.TableNotExistException;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.AbstractGeneralDatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.table.catalog.CatalogTable;
+import org.apache.eventmesh.connector.jdbc.table.catalog.DefaultColumn;
+import org.apache.eventmesh.connector.jdbc.table.catalog.PrimaryKey;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableSchema;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+import com.mysql.cj.MysqlType;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class MysqlDatabaseDialect extends AbstractGeneralDatabaseDialect<MysqlJdbcConnection> {
+
+    private MysqlJdbcConnection connection;
+
+    private DataTypeConvertor<MysqlType> dataTypeConvertor = new MysqlDataTypeConvertor();
+
+    private SourceConnectorConfig config;
+
+    public MysqlDatabaseDialect(JdbcSourceConfig config) {
+        super(config.getSourceConnectorConfig());
+        this.config = config.getSourceConnectorConfig();
+    }
+
+    @Override
+    public void init() {
+
+        boolean initSuccess;
+        do {
+            try {
+                this.connection = initJdbcConnection();
+                initSuccess = true;
+            } catch (Exception e) {
+                log.error("Init jdbc connection error,The connection will be retried in three seconds", e);
+                initSuccess = false;
+                try {
+                    TimeUnit.SECONDS.sleep(3);
+                } catch (InterruptedException ex) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        } while (!initSuccess);
+
+    }
+
+    @Override
+    public void start() {
+        //TODO?
+    }
+
+    private MysqlJdbcConnection initJdbcConnection() {
+        try {
+            return new MysqlJdbcConnection(config.getJdbcConfig(), null, false);
+        } catch (Exception e) {
+            throw new CatalogException(e);
+        }
+    }
+
+    @Override
+    public void open() throws CatalogException {
+
+    }
+
+    @Override
+    public String getDefaultDatabase() {
+        return null;
+    }
+
+    @Override
+    public boolean databaseExists(String databaseName) throws CatalogException {
+        if (null == databaseName || databaseName.trim().isEmpty()) {
+            return false;
+        }
+        List<String> databases = listDatabases();
+        return databases.contains(databaseName);
+    }
+
+    @Override
+    public List<String> listDatabases() throws CatalogException {
+        List<String> databases = new ArrayList<>(16);
+        try {
+            this.connection.query(MysqlDialectSql.SHOW_DATABASE.ofSQL(), resultSet -> {
+                while (resultSet.next()) {
+                    databases.add(resultSet.getString("Database"));
+                }
+            });
+        } catch (SQLException e) {
+            log.error("List Mysql database error", e);
+            throw new CatalogException(e);
+        }
+        return databases;
+    }
+
+    @Override
+    public List<TableId> listTables(String databaseName) throws CatalogException, DatabaseNotExistException, SQLException {
+
+        List<TableId> tableIds = new ArrayList<>(32);
+
+        // Build the SQL query to return a list of tables for the given database
+        String sql = MysqlDialectSql.SHOW_DATABASE_TABLE.ofWrapperSQL("`" + databaseName + "`");
+        if (log.isDebugEnabled()) {
+            log.debug("List tables SQL:{}", sql);
+        }
+        this.connection.query(sql, resultSet -> {
+            // Execute the query and add each table ID to the list
+            while (resultSet.next()) {
+                TableId tableId = new TableId(databaseName, null, resultSet.getString(1));
+                tableIds.add(tableId);
+            }
+        });
+        return tableIds;
+    }
+
+    @Override
+    public boolean tableExists(TableId tableId) throws CatalogException, SQLException {
+
+        List<TableId> tableIds = listTables(tableId.getCatalogName());
+
+        return tableIds.contains(tableId);
+    }
+
+    @Override
+    public CatalogTable getTable(TableId tableId) throws CatalogException, TableNotExistException, SQLException {
+
+        Objects.requireNonNull(tableId, "TableId is null");
+        if (!tableExists(tableId)) {
+            log.error("Table {} not exist in database", tableId);
+            throw new CatalogException(String.format("Table %s not exist in database", tableId));
+        }
+
+        CatalogTable table = new CatalogTable();
+        table.setTableId(tableId);
+        TableSchema tableSchema = new TableSchema();
+        table.setTableSchema(tableSchema);
+
+        // Get table creation SQL
+        final String createTableSql = MysqlDialectSql.SHOW_CREATE_TABLE.ofWrapperSQL(tableId.getId());
+        if (log.isDebugEnabled()) {
+            log.debug("Show create table SQL:{}", createTableSql);
+        }
+
+        this.connection.query(createTableSql, resultSet -> {
+            boolean hasNext = resultSet.next();
+            if (!hasNext) {
+                throw new CatalogException(String.format("Table %s not exist in database", tableId.getId()));
+            }
+            String creatTableSql = resultSet.getString("Create Table");
+            //table.setDdlSql(creatTableSql);
+        });
+
+        // Get table columns SQL
+        final String selectTableSql = MysqlDialectSql.SELECT_TABLE_COLUMNS.ofWrapperSQL(tableId.getId());
+        if (log.isDebugEnabled()) {
+            log.debug("Select table SQL:{}", selectTableSql);
+        }
+        Map<String, DefaultColumn> columns = new HashMap<>(16);
+        // Execute query to get table columns
+        this.connection.query(selectTableSql, resultSet -> {
+            ResultSetMetaData tableMetaData = resultSet.getMetaData();
+            int columnCount = tableMetaData.getColumnCount();
+            for (int columnIndex = 1; columnIndex <= columnCount; ++columnIndex) {
+                String columnName = tableMetaData.getColumnName(columnIndex);
+                DefaultColumn column = columns.computeIfAbsent(columnName, key -> new DefaultColumn());
+                column.setName(columnName);
+                int precision = tableMetaData.getPrecision(columnIndex);
+                column.setColumnLength(precision);
+                Map<String, Object> dataTypeProperties = new HashMap<>();
+                dataTypeProperties.put(MysqlDataTypeConvertor.PRECISION, precision);
+                int scale = tableMetaData.getScale(columnIndex);
+                dataTypeProperties.put(MysqlDataTypeConvertor.SCALE, scale);
+                column.setDataType(
+                    dataTypeConvertor.toEventMeshType(MysqlType.getByJdbcType(tableMetaData.getColumnType(columnIndex)), dataTypeProperties));
+                column.setDecimal(scale);
+            }
+        });
+
+        // Get table columns details SQL
+        final String showTableSql = MysqlDialectSql.SHOW_TABLE_COLUMNS.ofWrapperSQL(tableId.getTableName(), tableId.getCatalogName());
+        if (log.isDebugEnabled()) {
+            log.debug("Show table columns SQL:{}", showTableSql);
+        }
+        // Execute query to get table columns details
+        List<DefaultColumn> columnList = new ArrayList<>(columns.size());
+        this.connection.query(showTableSql, resultSet -> {
+            boolean hasNext = resultSet.next();
+            if (!hasNext) {
+                throw new CatalogException(String.format("Table %s without columns", tableId.getId()));
+            }
+            List<String> columnNames = new ArrayList<>(4);
+            do {
+                String field = resultSet.getString("Field");
+                DefaultColumn column = columns.get(field);
+                String comment = resultSet.getString("Comment");
+                column.setComment(comment);
+                //The column nullability. The value is YES if NULL values can be stored in the column, NO if not.
+                String enableNull = resultSet.getString("Null");
+                column.setNotNull("NO".equalsIgnoreCase(enableNull));
+
+                String type = resultSet.getString("Type");
+                //column.setSqlDesc(type);
+
+                //Get default value
+                Object defaultValue = resultSet.getObject("Default");
+                column.setDefaultValue(defaultValue);
+
+                String key = resultSet.getString("Key");
+                if ("PRI".equalsIgnoreCase(key)) {
+                    columnNames.add(field);
+                }
+                columnList.add(column);
+            } while (resultSet.next());
+            tableSchema.setColumns(columnList);
+            tableSchema.setColumnMap(columns);
+            if (!columnNames.isEmpty()) {
+                tableSchema.setPrimaryKey(new PrimaryKey(columnNames));
+            }
+        });
+        return table;
+    }
+
+    @Override
+    public String getName() {
+        return null;
+    }
+
+    @Override
+    public PreparedStatement createPreparedStatement(Connection connection, String sql) throws SQLException {
+        Objects.requireNonNull(connection, "Connection is null");
+        Objects.requireNonNull(sql, "SQL is null");
+        return connection.prepareStatement(sql);
+    }
+
+    /**
+     * Retrieves the JDBC driver meta-data associated with the database dialect.
+     *
+     * @return The JDBC driver meta-data.
+     */
+    @Override
+    public JdbcDriverMetaData getJdbcDriverMetaData() {
+        return this.connection.getJdbcDriverMetaData();
+    }
+
+    /**
+     * Retrieves the JDBC protocol associated with the database dialect.
+     *
+     * @return The JDBC protocol.
+     */
+    @Override
+    public String jdbcProtocol() {
+        return MysqlJdbcConnection.URL_WITH_PLACEHOLDER;
+    }
+
+    /**
+     * Obtains a database connection.
+     *
+     * @return A database connection.
+     */
+    @Override
+    public MysqlJdbcConnection getConnection() {
+        return this.connection;
+    }
+
+    @Override
+    public MysqlJdbcConnection newConnection() {
+        return initJdbcConnection();
+    }
+
+    @Override
+    public void close() throws Exception {
+        if (this.connection != null) {
+            this.connection.close();
+        }
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialectFactory.java
similarity index 56%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialectFactory.java
index 7fcb9dfd7..5f34a8a40 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDatabaseDialectFactory.java
@@ -15,30 +15,18 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.source.dialect.mysql;
 
-/**
- * Interface for parsing DDL SQL statements.
- */
-public interface DdlParser {
-
-    /**
-     * Parses the given DDL SQL statement.
-     *
-     * @param ddlSql the DDL SQL statement to be parsed
-     */
-    default void parse(String ddlSql) {
-        parse(ddlSql, null);
-    }
+import org.apache.eventmesh.connector.jdbc.DatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.DatabaseDialectFactory;
+import org.apache.eventmesh.openconnect.api.config.SourceConfig;
 
-    void parse(String ddlSql, DdlParserCallback callback);
+public class MysqlDatabaseDialectFactory implements DatabaseDialectFactory {
 
-    /**
-     * Sets the current database.
-     *
-     * @param databaseName the name of the database to be set as current
-     */
-    void setCurrentDatabase(String databaseName);
-
-    void setCurrentSchema(String schema);
+    @Override
+    public DatabaseDialect createDatabaseDialect(SourceConfig config) {
+        DatabaseDialect databaseDialect = new MysqlDatabaseDialect((JdbcSourceConfig) config);
+        return databaseDialect;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDialectSql.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDialectSql.java
new file mode 100644
index 000000000..a0f560978
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlDialectSql.java
@@ -0,0 +1,87 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+public enum MysqlDialectSql {
+
+    SHOW_DATABASE("SHOW DATABASES;", "show mysql database sql"),
+
+    SELECT_DATABASE("USE %s", " Try to access database"),
+
+    /**
+     * https://dev.mysql.com/doc/refman/8.0/en/show-tables.html
+     */
+    SHOW_DATABASE_TABLE("SHOW FULL TABLES IN %s WHERE Table_type = 'BASE TABLE';", "show mysql database tables"),
+
+    /**
+     * https://dev.mysql.com/doc/refman/8.0/en/show-columns.html
+     */
+    SHOW_TABLE_COLUMNS("SHOW FULL COLUMNS FROM %s FROM %s;", "show mysql database table columns"),
+
+    SELECT_TABLE_COLUMNS("SELECT * FROM %s WHERE 1=2", "show mysql database table columns"),
+
+    /**
+     * https://dev.mysql.com/doc/refman/8.0/en/show-create-table.html
+     */
+    SHOW_CREATE_TABLE("SHOW CREATE TABLE %s", "show mysql database table columns"),
+
+    SHOW_GTID_STATUS("SHOW GLOBAL VARIABLES LIKE 'GTID_MODE'", "Show GTID_MODE Enable or not"),
+
+    SHOW_MASTER_STATUS("SHOW MASTER STATUS", "Show master status"),
+
+    SELECT_PURGED_GTID("SELECT @@global.gtid_purged", "SELECT the purged GTID values"),
+
+    SHOW_GRANTS_FOR_CURRENT_USER("SHOW GRANTS FOR CURRENT_USER", "s=Show grants for current user"),
+
+    SHOW_CREATE_DATABASE("SHOW CREATE DATABASE %s", "Show create database sql"),
+
+    /**
+     * <a href="https://dev.mysql.com/doc/refman/8.0/en/show-table-status.html">SHOW_TABLE_STATUS</a>
+     */
+    SHOW_TABLE_STATUS("SHOW TABLE STATUS LIKE '%s'", "Show table status"),
+
+    SNAPSHOT_TABLE_SELECT_SQL("SELECT * FROM %s", "Select table data sql in snapshot"),
+
+    LOCK_TABLE_GLOBAL("FLUSH TABLES WITH READ LOCK", "global lock tables"),
+
+    LOCK_TABLES("FLUSH TABLES %s WITH READ LOCK", "lock tables"),
+
+    UNLOCK_TABLES("UNLOCK TABLES", "unlock tables");
+
+
+    private final String sql;
+
+    private final String desc;
+
+    MysqlDialectSql(String sql, String desc) {
+        this.sql = sql;
+        this.desc = desc;
+    }
+
+    public String ofSQL() {
+        return this.sql;
+    }
+
+    public String ofWrapperSQL(Object... parameters) {
+        return String.format(this.sql, parameters);
+    }
+
+    public String ofDescription() {
+        return this.desc;
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlJdbcContext.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlJdbcContext.java
new file mode 100644
index 000000000..8dc64d041
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlJdbcContext.java
@@ -0,0 +1,108 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+import org.apache.eventmesh.connector.jdbc.PartitionOffSetContextPair;
+import org.apache.eventmesh.connector.jdbc.UniversalJdbcContext;
+import org.apache.eventmesh.connector.jdbc.context.mysql.MysqlOffsetContext;
+import org.apache.eventmesh.connector.jdbc.context.mysql.MysqlPartition;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.config.SourceConnectorConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+
+import org.apache.commons.lang3.StringUtils;
+
+import lombok.Getter;
+
+public class MysqlJdbcContext extends UniversalJdbcContext<MysqlPartition, MysqlOffsetContext, MysqlAntlr4DdlParser> {
+
+    @Getter
+    private MysqlSourceInfo sourceInfo = new MysqlSourceInfo();
+
+    private volatile long currentHandleEventSize = 0;
+
+    private volatile boolean isStartTransaction = false;
+
+    private String restartGtidSet;
+
+    private String currentGtidSet;
+
+    private JdbcSourceConfig jdbcSourceConfig;
+
+    public MysqlJdbcContext(PartitionOffSetContextPair<MysqlPartition, MysqlOffsetContext> poCtx, MysqlAntlr4DdlParser parser) {
+        super(poCtx, parser);
+    }
+
+    public MysqlJdbcContext(MysqlPartition mysqlPartition, MysqlOffsetContext mysqlOffsetContext, MysqlAntlr4DdlParser parser) {
+        super(mysqlPartition, mysqlOffsetContext, parser);
+    }
+
+    public MysqlJdbcContext(JdbcSourceConfig jdbcSourceConfig, MysqlAntlr4DdlParser parser) {
+        this(new MysqlPartition(), new MysqlOffsetContext(), parser);
+        this.jdbcSourceConfig = jdbcSourceConfig;
+    }
+
+    public void setBinlogStartPoint(String binlogFilename, long beginProcessPosition) {
+        assert beginProcessPosition >= 0;
+        if (binlogFilename != null) {
+            sourceInfo.setBinlogPosition(binlogFilename, beginProcessPosition);
+
+        } else {
+            sourceInfo.setBinlogPosition(sourceInfo.getCurrentBinlogFileName(), beginProcessPosition);
+        }
+    }
+
+    public void setEventPosition(long positionOfCurrentEvent, long eventSize) {
+        this.sourceInfo.setCurrentBinlogPosition(positionOfCurrentEvent);
+        this.currentHandleEventSize = eventSize;
+    }
+
+    public static MysqlJdbcContext initialize(JdbcSourceConfig jdbcSourceConfig) {
+        SourceConnectorConfig sourceConnectorConfig = jdbcSourceConfig.getSourceConnectorConfig();
+        MysqlAntlr4DdlParser mysqlAntlr4DdlParser = new MysqlAntlr4DdlParser(sourceConnectorConfig.isSkipViews(),
+            sourceConnectorConfig.isSkipComments(), jdbcSourceConfig);
+        return new MysqlJdbcContext(new MysqlPartition(), new MysqlOffsetContext(), mysqlAntlr4DdlParser);
+    }
+
+    public void startTransaction() {
+        this.isStartTransaction = true;
+    }
+
+    public void commitTransaction() {
+        this.isStartTransaction = false;
+    }
+
+    public void complete() {
+        //TODO: What to do?
+        this.currentHandleEventSize = 0;
+    }
+
+    public void setCompletedGtidSet(String gtidSet) {
+        if (StringUtils.isNotBlank(gtidSet)) {
+            String trimmedGtidSet = gtidSet.replace("\n", "").replace("\r", "");
+            this.currentGtidSet = trimmedGtidSet;
+            this.restartGtidSet = trimmedGtidSet;
+        }
+    }
+
+    public String getGtidSet() {
+        return this.currentGtidSet != null ? this.currentGtidSet : null;
+    }
+
+
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceInfo.java
similarity index 55%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceInfo.java
index 7fcb9dfd7..f362c9be9 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/ddl/DdlParser.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceInfo.java
@@ -15,30 +15,28 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.ddl;
+package org.apache.eventmesh.connector.jdbc.source.dialect.mysql;
 
-/**
- * Interface for parsing DDL SQL statements.
- */
-public interface DdlParser {
-
-    /**
-     * Parses the given DDL SQL statement.
-     *
-     * @param ddlSql the DDL SQL statement to be parsed
-     */
-    default void parse(String ddlSql) {
-        parse(ddlSql, null);
-    }
 
-    void parse(String ddlSql, DdlParserCallback callback);
+import org.apache.eventmesh.connector.jdbc.common.SourceInfo;
+
+import lombok.Data;
+
+@Data
+public class MysqlSourceInfo implements SourceInfo {
 
-    /**
-     * Sets the current database.
-     *
-     * @param databaseName the name of the database to be set as current
-     */
-    void setCurrentDatabase(String databaseName);
+    private String currentBinlogFileName;
 
-    void setCurrentSchema(String schema);
+    private long currentBinlogPosition = 0L;
+
+    private int currentRowNumber = 0;
+
+    public void setBinlogPosition(String binlogFileName, long beginProcessPosition) {
+        if (binlogFileName != null) {
+            this.currentBinlogFileName = binlogFileName;
+        }
+        assert beginProcessPosition >= 0;
+        this.currentBinlogPosition = beginProcessPosition;
+        this.currentRowNumber = 0;
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceMateData.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceMateData.java
new file mode 100644
index 000000000..9fe750393
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/MysqlSourceMateData.java
@@ -0,0 +1,162 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.mysql;
+
+import org.apache.eventmesh.connector.jdbc.source.SourceMateData;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * Represents MySQL-specific metadata related to a data source.
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class MysqlSourceMateData extends SourceMateData {
+
+    /**
+     * The server ID of the MySQL instance.
+     */
+    private int serverId;
+
+    /**
+     * The Global Transaction Identifier (GTID) associated with the metadata.
+     */
+    private String gtid;
+
+    /**
+     * The name of the mysql binary log file.
+     */
+    private String binlogFile;
+
+    /**
+     * The position within the binary log file.
+     */
+    private long position;
+
+    /**
+     * The SQL statement associated with the metadata.
+     */
+    private String sql;
+
+    public static MysqlSourceMateDataBuilder newBuilder() {
+        return new MysqlSourceMateDataBuilder();
+    }
+
+    public static class MysqlSourceMateDataBuilder {
+
+        private String connector = "mysql";
+        private String name;
+        private long timestamp = System.currentTimeMillis();
+        private boolean snapshot;
+        private String catalogName;
+        private String schemaName;
+        private String tableName;
+        private int serverId;
+        private String gtid;
+        private String binlogFile;
+        private long position;
+        private String sql;
+
+        public MysqlSourceMateDataBuilder connector(String connector) {
+            this.connector = connector;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder name(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder timestamp(long timestamp) {
+            this.timestamp = timestamp;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder snapshot(boolean snapshot) {
+            this.snapshot = snapshot;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder withTableId(TableId tableId) {
+            this.catalogName = tableId.getCatalogName();
+            this.schemaName = tableId.getSchemaName();
+            this.tableName = tableId.getTableName();
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder catalogName(String catalogName) {
+            this.catalogName = catalogName;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder schemaName(String schemaName) {
+            this.schemaName = schemaName;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder tableName(String tableName) {
+            this.tableName = tableName;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder serverId(int serverId) {
+            this.serverId = serverId;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder gtid(String gtid) {
+            this.gtid = gtid;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder binlogFile(String binlogFile) {
+            this.binlogFile = binlogFile;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder position(long position) {
+            this.position = position;
+            return this;
+        }
+
+        public MysqlSourceMateDataBuilder sql(String sql) {
+            this.sql = sql;
+            return this;
+        }
+
+        public MysqlSourceMateData build() {
+            MysqlSourceMateData metadata = new MysqlSourceMateData();
+            metadata.setConnector(connector);
+            metadata.setName(name);
+            metadata.setTimestamp(timestamp);
+            metadata.setSnapshot(snapshot);
+            metadata.setCatalogName(catalogName);
+            metadata.setSchemaName(schemaName);
+            metadata.setTableName(tableName);
+            metadata.setServerId(serverId);
+            metadata.setGtid(gtid);
+            metadata.setBinlogFile(binlogFile);
+            metadata.setPosition(position);
+            metadata.setSql(sql);
+            return metadata;
+        }
+    }
+}
+
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventData.java
similarity index 71%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventData.java
index 4e9077191..01a1d2e35 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/Table.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventData.java
@@ -15,18 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc.table.catalog;
+package org.apache.eventmesh.connector.jdbc.source.dialect.mysql;
 
-import java.util.List;
+import com.github.shyiko.mysql.binlog.event.EventData;
 
-public class Table {
 
-    private String name;
+public class StopEventData implements EventData {
 
-    private PrimaryKey primaryKey;
-
-    private List<UniqueKey> uniqueKeys;
-
-    private String comment;
+    private static final long serialVersionUID = -7056169406695094519L;
 
+    @Override
+    public String toString() {
+        return "StopEventData";
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventDataDeserializer.java
similarity index 62%
copy from eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
copy to eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventDataDeserializer.java
index 506e4baa2..602d11dde 100644
--- a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/JdbcContext.java
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/mysql/StopEventDataDeserializer.java
@@ -15,15 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.eventmesh.connector.jdbc;
+package org.apache.eventmesh.connector.jdbc.source.dialect.mysql;
 
-/**
- * Interface representing a JDBC context.
- */
-public interface JdbcContext<Part extends Partition, OffSetCtx extends OffsetContext> {
+import java.io.IOException;
 
-    Part getPartition();
+import com.github.shyiko.mysql.binlog.event.deserialization.EventDataDeserializer;
+import com.github.shyiko.mysql.binlog.io.ByteArrayInputStream;
 
-    OffSetCtx getOffsetContext();
+public class StopEventDataDeserializer implements EventDataDeserializer<StopEventData> {
 
+    @Override
+    public StopEventData deserialize(ByteArrayInputStream inputStream) throws IOException {
+        return new StopEventData();
+    }
 }
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/AbstractSnapshotEngine.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/AbstractSnapshotEngine.java
new file mode 100644
index 000000000..348bb7efa
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/AbstractSnapshotEngine.java
@@ -0,0 +1,371 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.snapshot;
+
+import org.apache.eventmesh.common.ThreadPoolFactory;
+import org.apache.eventmesh.connector.jdbc.DatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.Field;
+import org.apache.eventmesh.connector.jdbc.JdbcContext;
+import org.apache.eventmesh.connector.jdbc.OffsetContext;
+import org.apache.eventmesh.connector.jdbc.Partition;
+import org.apache.eventmesh.connector.jdbc.Payload;
+import org.apache.eventmesh.connector.jdbc.Schema;
+import org.apache.eventmesh.connector.jdbc.UniversalJdbcContext;
+import org.apache.eventmesh.connector.jdbc.connection.JdbcConnection;
+import org.apache.eventmesh.connector.jdbc.event.Event;
+import org.apache.eventmesh.connector.jdbc.event.InsertDataEvent;
+import org.apache.eventmesh.connector.jdbc.source.AbstractEngine;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlSourceMateData;
+import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotResult.SnapshotResultStatus;
+import org.apache.eventmesh.connector.jdbc.table.catalog.Column;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableSchema;
+
+import org.apache.commons.collections4.CollectionUtils;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalLong;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletionService;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutorCompletionService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.stream.Collectors;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Abstract base class for snapshot engines.
+ *
+ * @param <DbDialect> The Database Dialect
+ * @param <Jc>        The JDBC context type
+ * @param <Part>      The partition type
+ * @param <Offset>    The offset context type
+ */
+@Slf4j
+public abstract class AbstractSnapshotEngine<DbDialect extends DatabaseDialect<Jconn>, Jc extends JdbcContext<Part, Offset>, Part extends Partition,
+    Offset extends OffsetContext, Jconn extends JdbcConnection> extends AbstractEngine<DbDialect> implements SnapshotEngine<Jc> {
+
+    private final Jconn jdbcConnection;
+
+    private Jc context;
+
+    private Part partition;
+
+    private Offset offsetContext;
+
+    protected BlockingQueue<Event> eventQueue = new LinkedBlockingQueue<>(10000);
+
+    public AbstractSnapshotEngine(JdbcSourceConfig jdbcSourceConfig, DbDialect databaseDialect, Jc jdbcContext, Part partition,
+        Offset context) {
+        super(jdbcSourceConfig, databaseDialect);
+        this.context = jdbcContext;
+        this.partition = partition;
+        this.offsetContext = context;
+        this.jdbcConnection = databaseDialect.getConnection();
+    }
+
+
+    @Override
+    public SnapshotResult<Jc> execute() {
+        if (jdbcSourceConfig.getSourceConnectorConfig().isSkipSnapshot()) {
+            return new SnapshotResult<>(SnapshotResultStatus.SKIPPED, null);
+        }
+        SnapshotContext<Part, Offset> snapshotContext = new SnapshotContext<>(partition, offsetContext);
+        return doExecute(context, snapshotContext);
+    }
+
+
+    /**
+     * Template method that executes the snapshot logic.
+     *
+     * @param context         the JDBC context
+     * @param snapshotContext the snapshot context
+     * @return the snapshot result
+     */
+    protected SnapshotResult<Jc> doExecute(Jc context, SnapshotContext<Part, Offset> snapshotContext) {
+
+        Connection masterConnection = null;
+        Queue<JdbcConnection> connectionPool = null;
+        try {
+            masterConnection = createMasterConnection();
+            log.info("Snapshot 1: Preparations for Snapshot Work");
+            preSnapshot(context, snapshotContext);
+
+            log.info("Snapshot 2: Retrieve tables requiring snapshot handling");
+            determineTable2Process(context, snapshotContext);
+
+            log.info("Snapshot 3: Put locks on the tables that need to be processed");
+            if (sourceConnectorConfig.isSnapshotSchema()) {
+                lockTables4SchemaSnapshot(context, snapshotContext);
+            }
+
+            log.info("Snapshot 4: Determining snapshot offset");
+            determineSnapshotOffset(context, snapshotContext);
+
+            log.info("Snapshot 5: Obtain the schema of the captured tables");
+            readStructureOfTables(context, snapshotContext);
+
+            //Release locks
+            releaseSnapshotLocks(context, snapshotContext);
+
+            //Whether to determine whether to process the table data?
+            if (sourceConnectorConfig.isSnapshotData()) {
+                connectionPool = createConnectionPool(snapshotContext);
+                createDataEvents(context, snapshotContext, connectionPool);
+            }
+            log.info("Snapshot 6: Release the locks");
+            releaseSnapshotLocks(context, snapshotContext);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            //close connection pool's connection
+            try {
+                if (CollectionUtils.isNotEmpty(connectionPool)) {
+                    for (JdbcConnection conn : connectionPool) {
+                        conn.close();
+                    }
+                }
+                //Roll back master connection transaction
+                rollbackMasterConnTransaction(masterConnection);
+            } catch (Exception e) {
+                log.warn("Handle snapshot finally error", e);
+            }
+        }
+        return new SnapshotResult<>(SnapshotResultStatus.COMPLETED, context);
+    }
+
+    private void rollbackMasterConnTransaction(Connection connection) {
+        if (connection != null) {
+            try {
+                connection.rollback();
+            } catch (SQLException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private Connection createMasterConnection() throws SQLException {
+        JdbcConnection connection = databaseDialect.getConnection();
+        connection.setAutoCommit(false);
+        return connection.connection();
+    }
+
+    /**
+     * Creates data events.
+     *
+     * @param context         The context.
+     * @param snapshotContext The snapshot context.
+     * @param connectionPool  The connection pool.
+     * @throws SQLException If an error occurs.
+     */
+    private void createDataEvents(Jc context, SnapshotContext<Part, Offset> snapshotContext, Queue<JdbcConnection> connectionPool)
+        throws Exception {
+
+        int handleDataThreadNum = connectionPool.size();
+        //Create thread pool to process table data
+        ThreadPoolExecutor tableDataPoolExecutor = ThreadPoolFactory.createThreadPoolExecutor(handleDataThreadNum, handleDataThreadNum,
+            "snapshot-table-data-thread");
+        CompletionService<Void> completionService = new ExecutorCompletionService<>(tableDataPoolExecutor);
+        try {
+            for (TableId tableId : snapshotContext.determineTables) {
+                String sql = getSnapshotTableSelectSql(context, snapshotContext, tableId).get();
+                Callable<Void> callable = createSnapshotDataEvent4TableCallable(context, snapshotContext, connectionPool, sql, tableId);
+                completionService.submit(callable);
+            }
+            int tableSize = snapshotContext.determineTables.size();
+            for (int index = 0; index < tableSize; ++index) {
+                completionService.take().get();
+            }
+        } finally {
+            tableDataPoolExecutor.shutdownNow();
+        }
+    }
+
+    private Callable<Void> createSnapshotDataEvent4TableCallable(Jc context, SnapshotContext<Part, Offset> snapshotContext,
+        Queue<JdbcConnection> connectionPool, String sql, TableId tableId) {
+        UniversalJdbcContext<?, ?, ?> universalJdbcContext = (UniversalJdbcContext<?, ?, ?>) context;
+        universalJdbcContext.withTableId(tableId);
+        return () -> {
+            JdbcConnection connection = connectionPool.poll();
+            try (Statement statement = connection.createStatement(jdbcSourceConfig.getSourceConnectorConfig().getSnapshotFetchSize(), 100)) {
+                ResultSet resultSet = statement.executeQuery(sql);
+                while (resultSet.next()) {
+                    int columnCount = resultSet.getMetaData().getColumnCount();
+                    InsertDataEvent event = new InsertDataEvent(tableId);
+                    Payload payload = event.getJdbcConnectData().getPayload();
+                    Map<String, Object> values = new HashMap<>(columnCount);
+                    for (int index = 1; index <= columnCount; ++index) {
+                        values.put(resultSet.getMetaData().getColumnName(index), resultSet.getObject(index));
+                    }
+                    payload.withAfterValue(values);
+                    MysqlSourceMateData sourceMateData = MysqlSourceMateData.newBuilder()
+                        .name(sourceConnectorConfig.getName())
+                        .snapshot(true)
+                        .withTableId(tableId)
+                        .serverId(sourceConnectorConfig.getMysqlConfig().getServerId())
+                        .build();
+                    payload.withSource(sourceMateData);
+                    TableSchema tableSchema = universalJdbcContext.getCatalogTableSet().getTableSchema(tableId);
+                    Field field = new Field().withField("after").withType("field").withName("payload.after").withRequired(false);
+                    List<? extends Column> columns = tableSchema.getColumns();
+                    if (CollectionUtils.isNotEmpty(columns)) {
+                        List<Field> fields = columns.stream()
+                            .map(col -> new Field(col.getDataType().getName(), col.isNotNull(), col.getName(), tableId.toString()))
+                            .collect(Collectors.toList());
+                        field.withRequired(true).withFields(fields);
+                    }
+                    event.getJdbcConnectData().setSchema(new Schema(Collections.singletonList(field)));
+                    eventQueue.put(event);
+                }
+            } finally {
+                connectionPool.add(connection);
+            }
+            return null;
+        };
+    }
+
+    private Queue<JdbcConnection> createConnectionPool(final SnapshotContext<Part, Offset> snapshotContext) throws SQLException {
+        Queue<JdbcConnection> connectionPool = new ConcurrentLinkedQueue<>();
+        int snapshotMaxThreads = Math.max(1,
+            Math.min(this.jdbcSourceConfig.getSourceConnectorConfig().getSnapshotMaxThreads(), snapshotContext.determineTables.size()));
+
+        for (int i = 0; i < snapshotMaxThreads; i++) {
+            JdbcConnection conn = databaseDialect.newConnection().setAutoCommit(false);
+            //Get transaction isolation from master connection and then set to connection of pool
+            conn.connection().setTransactionIsolation(jdbcConnection.connection().getTransactionIsolation());
+            connectionPool.add(conn);
+        }
+        log.info("Created connection pool with {} number", snapshotMaxThreads);
+        return connectionPool;
+    }
+
+    /**
+     * Pre-snapshot preparations.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     */
+    protected abstract void preSnapshot(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext);
+
+    /**
+     * Determine tables that need snapshotting.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     */
+    protected abstract void determineTable2Process(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext);
+
+    /**
+     * Lock tables for consistent snapshot schema.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     * @throws SQLException if a database error occurs
+     */
+    protected abstract void lockTables4SchemaSnapshot(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext) throws SQLException;
+
+    /**
+     * Determine snapshot offset.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     * @throws SQLException if a database error occurs
+     */
+    protected abstract void determineSnapshotOffset(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext) throws SQLException;
+
+    /**
+     * Read and store table schemas.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     * @throws SQLException         if a database error occurs
+     * @throws InterruptedException if interrupted
+     */
+    protected abstract void readStructureOfTables(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext)
+        throws SQLException, InterruptedException;
+
+    /**
+     * Release locks after snapshot.
+     *
+     * @param jdbcContext     the JDBC context
+     * @param snapshotContext the snapshot context
+     */
+    protected abstract void releaseSnapshotLocks(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext) throws Exception;
+
+    protected abstract Optional<String> getSnapshotTableSelectSql(Jc jdbcContext, SnapshotContext<Part, Offset> snapshotContext, TableId tableId);
+
+    protected OptionalLong getRowCount4Table(TableId tableId) {
+        return OptionalLong.empty();
+    }
+
+    public static class SnapshotContext<P extends Partition, O extends OffsetContext> implements AutoCloseable {
+
+        protected P partition;
+
+        protected O offset;
+
+        protected Set<TableId> determineTables = new HashSet<>();
+
+        public SnapshotContext(P partition, O offset) {
+            this.partition = partition;
+            this.offset = offset;
+        }
+
+        @Override
+        public void close() throws Exception {
+
+        }
+
+        public void add(TableId tableId) {
+            SnapshotContext.this.determineTables.add(tableId);
+        }
+
+        public void addAll(Set<TableId> tableIds) {
+            if (tableIds != null) {
+                SnapshotContext.this.determineTables.addAll(tableIds);
+            }
+        }
+
+        public P getPartition() {
+            return partition;
+        }
+
+        public O getOffset() {
+            return offset;
+        }
+
+        public Set<TableId> getDetermineTables() {
+            return determineTables;
+        }
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngine.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngine.java
new file mode 100644
index 000000000..77f054bed
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngine.java
@@ -0,0 +1,311 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.snapshot.mysql;
+
+import org.apache.eventmesh.connector.jdbc.connection.mysql.MysqlJdbcConnection;
+import org.apache.eventmesh.connector.jdbc.context.mysql.MysqlOffsetContext;
+import org.apache.eventmesh.connector.jdbc.context.mysql.MysqlPartition;
+import org.apache.eventmesh.connector.jdbc.event.Event;
+import org.apache.eventmesh.connector.jdbc.event.EventConsumer;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.config.MysqlConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlDatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlDialectSql;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlJdbcContext;
+import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.AbstractSnapshotEngine;
+import org.apache.eventmesh.connector.jdbc.table.catalog.TableId;
+import org.apache.eventmesh.connector.jdbc.utils.MysqlUtils;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalLong;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class MysqlSnapshotEngine extends
+    AbstractSnapshotEngine<MysqlDatabaseDialect, MysqlJdbcContext, MysqlPartition, MysqlOffsetContext, MysqlJdbcConnection> {
+
+    private static final Set<String> DEFAULT_EXCLUDE_DATABASE = new HashSet<>();
+
+    static {
+        DEFAULT_EXCLUDE_DATABASE.add("information_schema");
+        DEFAULT_EXCLUDE_DATABASE.add("mysql");
+        DEFAULT_EXCLUDE_DATABASE.add("performance_schema");
+        DEFAULT_EXCLUDE_DATABASE.add("sys");
+    }
+
+    private volatile boolean globalLockAcquired = false;
+
+    private volatile boolean tableLockAcquired = false;
+
+    private List<EventConsumer> consumers = new ArrayList<>(16);
+
+    private MysqlJdbcConnection connection;
+
+    public MysqlSnapshotEngine(JdbcSourceConfig jdbcSourceConfig, MysqlDatabaseDialect databaseDialect, MysqlJdbcContext jdbcContext) {
+        super(jdbcSourceConfig, databaseDialect, jdbcContext, jdbcContext.getPartition(), jdbcContext.getOffsetContext());
+        this.connection = databaseDialect.getConnection();
+        jdbcContext.getParser().addTableIdSet(getHandledTables());
+    }
+
+    @Override
+    protected Set<String> defaultExcludeDatabase() {
+        return DEFAULT_EXCLUDE_DATABASE;
+    }
+
+    @Override
+    public void close() throws Exception {
+        shutdown();
+    }
+
+    @Override
+    protected void preSnapshot(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext) {
+        //nothing to do
+    }
+
+    @Override
+    protected void determineTable2Process(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext) {
+        snapshotContext.addAll(getHandledTables());
+    }
+
+    @Override
+    protected void lockTables4SchemaSnapshot(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext)
+        throws SQLException {
+        //Set the REPEATABLE_READ isolation level to avoid the MySQL transaction isolation level being changed unexpectedly.
+        connection.connection().setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
+        connection.executeWithoutCommitting("SET SESSION lock_wait_timeout=10", "SET SESSION innodb_lock_wait_timeout=10");
+
+        //Lock tables
+        final MysqlConfig mysqlConfig = sourceConnectorConfig.getMysqlConfig();
+        if (mysqlConfig.getSnapshotLockingMode().usesLocking() && mysqlConfig.isUseGlobalLock()) {
+            globalLockAcquiredTry();
+        }
+
+    }
+
+    @Override
+    protected void determineSnapshotOffset(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext)
+        throws SQLException {
+
+        if (!globalLockAcquired && !tableLockAcquired) {
+            return;
+        }
+        log.info("Read binlog info from Mysql Server");
+        /**
+         * The result of executing the SHOW MASTER STATUS script is as follows:
+         * +-----------------+----------+--------------+------------------+-------------------------------------------+
+         * | File            | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set                         |
+         * +-----------------+----------+--------------+------------------+-------------------------------------------+
+         * | mysqlbin.000009 |      197 |              |                  | 71a89bf3-0dd0-11ee-98b2-0242ac110002:1-76 |
+         * +-----------------+----------+--------------+------------------+-------------------------------------------+
+         */
+        connection.query(MysqlDialectSql.SHOW_MASTER_STATUS.ofSQL(), resultSet -> {
+            if (resultSet.next()) {
+                final String binlogFilename = resultSet.getString(1);
+                final long position = resultSet.getLong(2);
+                jdbcContext.setBinlogStartPoint(binlogFilename, position);
+                if (resultSet.getMetaData().getColumnCount() >= 5) {
+                    final String gtidSet = resultSet.getString(5);
+                    jdbcContext.setCompletedGtidSet(gtidSet);
+                    log.info("Using binlog '{}' at position '{}' and gtid '{}'", binlogFilename, position, gtidSet);
+                } else {
+                    log.info("Using binlog '{}' at position '{}' ", binlogFilename, position);
+                }
+            } else {
+                throw new SQLException("Cannot read the binlog filename and position,Make sure Mysql server is correctly configured");
+            }
+        });
+    }
+
+    @Override
+    protected void readStructureOfTables(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext)
+        throws SQLException, InterruptedException {
+        if (sourceConnectorConfig.getMysqlConfig().getSnapshotLockingMode().usesLocking() && !globalLockAcquired) {
+            lockTable(snapshotContext);
+            determineSnapshotOffset(jdbcContext, snapshotContext);
+        }
+        // Parse all Databases from the tableId, construct creation statements
+        Set<TableId> determineTables = snapshotContext.getDetermineTables();
+        for (TableId tableId : determineTables) {
+            StringBuilder dropTableDdl = new StringBuilder("DROP TABLE IF EXISTS ");
+            dropTableDdl.append(MysqlUtils.wrapper(tableId));
+            addParseDdlAndEvent(jdbcContext, dropTableDdl.toString(), tableId);
+        }
+        final HashMap<String/*database Name*/, List<TableId>/*table list*/> databaseMapTables = determineTables.stream()
+            .collect(Collectors.groupingBy(TableId::getCatalogName, HashMap::new, Collectors.toList()));
+        Set<String> databaseSet = databaseMapTables.keySet();
+        // Read all table structures, construct DDL statements
+        for (String database : databaseSet) {
+            StringBuilder dropDatabaseDdl = new StringBuilder("DROP DATABASE IF EXISTS ").append(MysqlUtils.wrapper(database));
+            addParseDdlAndEvent(jdbcContext, dropDatabaseDdl.toString(), new TableId(database));
+            String databaseCreateDdl = connection.query(MysqlDialectSql.SHOW_CREATE_DATABASE.ofWrapperSQL(MysqlUtils.wrapper(database)), rs -> {
+                if (rs.next() && rs.getMetaData().getColumnCount() > 1) {
+                    String ddl = rs.getString(2);
+                    return ddl;
+                }
+                return null;
+            });
+            if (StringUtils.isBlank(databaseCreateDdl)) {
+                log.warn("Database {} ddl is empty", database);
+                continue;
+            }
+            TableId tableId = new TableId(database);
+            addParseDdlAndEvent(jdbcContext, databaseCreateDdl, tableId);
+            addParseDdlAndEvent(jdbcContext, "USE " + database, tableId);
+
+            //build create table snapshot event
+            List<TableId> tableIds = databaseMapTables.get(database);
+            createTableSnapshotEvent(tableIds, jdbcContext);
+        }
+    }
+
+    private void addParseDdlAndEvent(MysqlJdbcContext jdbcContext, String ddl, TableId tableId) {
+        jdbcContext.getParser().setCurrentDatabase(tableId.getCatalogName());
+        jdbcContext.getParser().setCatalogTableSet(jdbcContext.getCatalogTableSet());
+        jdbcContext.getParser().parse(ddl, event -> {
+            try {
+                if (event == null) {
+                    return;
+                }
+                event.getJdbcConnectData().getPayload().ofSourceMateData().setSnapshot(true);
+                eventQueue.put(event);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    private void createTableSnapshotEvent(List<TableId> tableIds, MysqlJdbcContext jdbcContext) throws SQLException {
+        if (CollectionUtils.isEmpty(tableIds)) {
+            return;
+        }
+        for (TableId tableId : tableIds) {
+            connection.query(MysqlDialectSql.SHOW_CREATE_TABLE.ofWrapperSQL(tableId.toString()), resultSet -> {
+                if (resultSet.next()) {
+                    //Get create table sql
+                    String createTableDdl = resultSet.getString(2);
+                    addParseDdlAndEvent(jdbcContext, createTableDdl, tableId);
+                }
+            });
+        }
+    }
+
+    private void lockTable(SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext) throws SQLException {
+
+        Boolean lockedTable = connection.query(MysqlDialectSql.SHOW_GRANTS_FOR_CURRENT_USER.ofSQL(), rs -> {
+            while (rs.next()) {
+                String grantPrivilege = rs.getString(1);
+                if (StringUtils.isBlank(grantPrivilege)) {
+                    continue;
+                }
+                if (StringUtils.containsAny(grantPrivilege.toUpperCase(), "ALL", "LOCK TABLES")) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!lockedTable) {
+            throw new SQLException("Current User does not have the 'LOCK TABLES' privilege");
+        }
+        if (CollectionUtils.isNotEmpty(snapshotContext.getDetermineTables())) {
+            /**
+             * <a href="https://dev.mysql.com/doc/refman/8.0/en/flush.html">FLUSH</a>
+             */
+            String tableNameList = snapshotContext.getDetermineTables().stream().map(TableId::toString).collect(Collectors.joining(","));
+            connection.executeWithoutCommitting(MysqlDialectSql.LOCK_TABLES.ofWrapperSQL(tableNameList));
+        }
+        tableLockAcquired = true;
+    }
+
+    @Override
+    protected void releaseSnapshotLocks(MysqlJdbcContext jdbcContext, SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext)
+        throws Exception {
+        if (globalLockAcquired) {
+            connection.executeWithoutCommitting(MysqlDialectSql.UNLOCK_TABLES.ofSQL());
+            globalLockAcquired = false;
+        }
+        if (tableLockAcquired) {
+            connection.executeWithoutCommitting(MysqlDialectSql.UNLOCK_TABLES.ofSQL());
+            globalLockAcquired = false;
+        }
+    }
+
+    @Override
+    protected Optional<String> getSnapshotTableSelectSql(MysqlJdbcContext jdbcContext,
+        SnapshotContext<MysqlPartition, MysqlOffsetContext> snapshotContext, TableId tableId) {
+        return Optional.of(MysqlDialectSql.SNAPSHOT_TABLE_SELECT_SQL.ofWrapperSQL(tableId.toString()));
+    }
+
+    private void globalLockAcquiredTry() throws SQLException {
+        //Lock tables
+        connection.executeWithoutCommitting(MysqlDialectSql.LOCK_TABLE_GLOBAL.ofSQL());
+        this.globalLockAcquired = true;
+    }
+
+
+    @Override
+    public String getThreadName() {
+        return this.getClass().getSimpleName() + "-thread";
+    }
+
+    @Override
+    public void run() {
+        while (isRunning) {
+            try {
+                Event event = eventQueue.poll(5, TimeUnit.SECONDS);
+                if (null == event) {
+                    continue;
+                }
+                consumers.forEach(consumer -> consumer.accept(event));
+            } catch (Exception e) {
+                log.warn("Consume snapshot event error", e);
+            }
+        }
+    }
+
+    @Override
+    public void init() {
+
+    }
+
+    @Override
+    public void registerSnapshotEventConsumer(EventConsumer consumer) {
+        if (consumer == null) {
+            return;
+        }
+        consumers.add(consumer);
+    }
+
+    @Override
+    protected OptionalLong getRowCount4Table(TableId tableId) {
+        return connection.getRowCount4Table(tableId);
+    }
+
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngineFactory.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngineFactory.java
new file mode 100644
index 000000000..53c5f993d
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/source/dialect/snapshot/mysql/MysqlSnapshotEngineFactory.java
@@ -0,0 +1,39 @@
+/*
+ * 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.eventmesh.connector.jdbc.source.dialect.snapshot.mysql;
+
+import org.apache.eventmesh.connector.jdbc.DatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.source.config.JdbcSourceConfig;
+import org.apache.eventmesh.connector.jdbc.source.dialect.antlr4.mysql.MysqlAntlr4DdlParser;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlDatabaseDialect;
+import org.apache.eventmesh.connector.jdbc.source.dialect.mysql.MysqlJdbcContext;
+import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotEngine;
+import org.apache.eventmesh.connector.jdbc.source.dialect.snapshot.SnapshotEngineFactory;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class MysqlSnapshotEngineFactory implements SnapshotEngineFactory {
+
+    @Override
+    public SnapshotEngine<MysqlJdbcContext> createSnapshotEngine(final JdbcSourceConfig jdbcSourceConfig,
+        final DatabaseDialect databaseDialect) {
+        return new MysqlSnapshotEngine(jdbcSourceConfig, (MysqlDatabaseDialect) databaseDialect,
+            new MysqlJdbcContext(jdbcSourceConfig, new MysqlAntlr4DdlParser(false, false, jdbcSourceConfig)));
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/AbstractColumnEditorImpl.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/AbstractColumnEditorImpl.java
new file mode 100644
index 000000000..32c416c5b
--- /dev/null
+++ b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/AbstractColumnEditorImpl.java
@@ -0,0 +1,269 @@
+/*
+ * 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.eventmesh.connector.jdbc.table.catalog;
+
+import org.apache.eventmesh.connector.jdbc.table.type.EventMeshDataType;
+
+import java.sql.JDBCType;
+
+public abstract class AbstractColumnEditorImpl<CE extends ColumnEditor, Col extends Column> implements ColumnEditor<CE, Col> {
+
+    /**
+     * Name of the column
+     */
+    private String name;
+
+    /**
+     * Data type of the column
+     */
+    private EventMeshDataType<?> eventMeshDataType;
+
+    /**
+     * Length of the column
+     */
+    private Integer columnLength;
+
+    /**
+     * Decimal point of the column
+     */
+    private Integer scale;
+
+    /**
+     * Indicates if the column can be null or not
+     */
+    private boolean notNull;
+
+    /**
+     * Comment for the column
+     */
+    private String comment;
+
+    /**
+     * Default value for the column
+     */
+    private Object defaultValue;
+
+    private String typeName;
+
+    private JDBCType jdbcType;
+
+    private String defaultValueExpression;
+
+    private boolean optional;
+
+    public AbstractColumnEditorImpl(String name) {
+        this.name = name;
+    }
+
+    public AbstractColumnEditorImpl() {
+    }
+
+
+    /**
+     * Sets the name of the column.
+     *
+     * @param name The name of the column.
+     * @return The column editor instance.
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public CE withName(String name) {
+        this.name = name;
+        return (CE) this;
+    }
+
+    /**
+     * Retrieves the name associated with this column editor.
+     *
+     * @return The name of the column.
+     */
+    @Override
+    public String ofName() {
+        return this.name;
+    }
+
+    /**
+     * Sets the data type of the column.
+     *
+     * @param typeName The data type name of the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE withType(String typeName) {
+        this.typeName = typeName;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the JDBC data type of the column.
+     *
+     * @param jdbcType The JDBC data type of the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE withJdbcType(JDBCType jdbcType) {
+        this.jdbcType = jdbcType;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the EventMesh data type of the column.
+     *
+     * @param eventMeshType The EventMesh data type of the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE withEventMeshType(EventMeshDataType<?> eventMeshType) {
+        this.eventMeshDataType = eventMeshType;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the length of the column (if applicable).
+     *
+     * @param length The length of the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE length(int length) {
+        this.columnLength = length;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the scale of the column (if applicable).
+     *
+     * @param scale The scale of the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE scale(Integer scale) {
+        this.scale = scale;
+        return (CE) this;
+    }
+
+    /**
+     * Sets whether the column is optional (nullable).
+     *
+     * @param optional Indicates whether the column is optional (true) or not (false).
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE optional(boolean optional) {
+        this.optional = optional;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the comment for the column.
+     *
+     * @param comment The comment for the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE comment(String comment) {
+        this.comment = comment;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the default value expression for the column.
+     *
+     * @param defaultValueExpression The default value expression for the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE defaultValueExpression(String defaultValueExpression) {
+        this.defaultValueExpression = defaultValueExpression;
+        return (CE) this;
+    }
+
+    /**
+     * Sets the default value for the column.
+     *
+     * @param value The default value for the column.
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE defaultValue(Object value) {
+        this.defaultValue = value;
+        return (CE) this;
+    }
+
+    /**
+     * Sets whether the column is marked as not null.
+     *
+     * @param notNull Indicates whether the column is marked as not null (true) or not (false).
+     * @return The column editor instance.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public CE notNull(boolean notNull) {
+        this.notNull = notNull;
+        return (CE) this;
+    }
+
+    public EventMeshDataType<?> ofEventMeshDataType() {
+        return eventMeshDataType;
+    }
+
+    public Integer ofColumnLength() {
+        return columnLength;
+    }
+
+    public Integer ofScale() {
+        return scale;
+    }
+
+    public boolean isNotNull() {
+        return notNull;
+    }
+
+    public String ofComment() {
+        return comment;
+    }
+
+    public Object ofDefaultValue() {
+        return defaultValue;
+    }
+
+    public String ofTypeName() {
+        return typeName;
+    }
+
+    public JDBCType ofJdbcType() {
+        return jdbcType;
+    }
+
+    public String ofDefaultValueExpression() {
+        return defaultValueExpression;
+    }
+
+    public boolean isOptional() {
+        return optional;
+    }
+}
diff --git a/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/AbstractTableEditorImpl.java b/eventmesh-connectors/eventmesh-connector-jdbc/src/main/java/org/apache/eventmesh/connector/jdbc/table/catalog/AbstractTableEditorImpl.java
new file mode 100644
index 000000000..61a7c7bf3
... 2798 lines suppressed ...


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@eventmesh.apache.org
For additional commands, e-mail: commits-help@eventmesh.apache.org