You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@seatunnel.apache.org by li...@apache.org on 2026/07/03 15:08:35 UTC

(seatunnel) branch dev updated: [Feature][Jdbc] Add YashanDB dialect and catalog support (#11187)

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

davidzollo pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/seatunnel.git


The following commit(s) were added to refs/heads/dev by this push:
     new c533f96a65 [Feature][Jdbc] Add YashanDB dialect and catalog support (#11187)
c533f96a65 is described below

commit c533f96a65dd70b79cbcadb716a4e0a3bc6051f8
Author: Tlinian <49...@users.noreply.github.com>
AuthorDate: Fri Jul 3 23:08:30 2026 +0800

    [Feature][Jdbc] Add YashanDB dialect and catalog support (#11187)
---
 seatunnel-connectors-v2/connector-jdbc/pom.xml     |  11 +
 .../jdbc/catalog/yashandb/YashanDbCatalog.java     | 290 ++++++++
 .../catalog/yashandb/YashanDbCatalogFactory.java   |  97 +++
 .../yashandb/YashanDbCreateTableSqlBuilder.java    | 156 ++++
 .../jdbc/internal/dialect/DatabaseIdentifier.java  |   1 +
 .../internal/dialect/yashandb/YashanDbDialect.java | 512 ++++++++++++++
 .../dialect/yashandb/YashanDbDialectFactory.java   |  60 ++
 .../dialect/yashandb/YashanDbJdbcRowConverter.java | 165 +++++
 .../dialect/yashandb/YashanDbTypeConverter.java    | 522 ++++++++++++++
 .../dialect/yashandb/YashanDbTypeMapper.java       |  59 ++
 .../jdbc/catalog/JdbcCatalogFactoryTest.java       |  43 ++
 .../YashanDbCreateTableSqlBuilderTest.java         | 315 +++++++++
 .../dialect/yashandb/YashanDbDialectTest.java      | 227 ++++++
 .../yashandb/YashanDbTypeConverterTest.java        | 786 +++++++++++++++++++++
 .../connector-jdbc-e2e-part-7/pom.xml              |   5 +
 .../connectors/seatunnel/jdbc/JdbcYashanDbIT.java  | 222 ++++++
 .../resources/jdbc_yashandb_source_and_sink.conf   |  48 ++
 .../resources/jdbc_yashandb_source_to_sink.conf    |  47 ++
 18 files changed, 3566 insertions(+)

diff --git a/seatunnel-connectors-v2/connector-jdbc/pom.xml b/seatunnel-connectors-v2/connector-jdbc/pom.xml
index 31171398f0..e42478cf46 100644
--- a/seatunnel-connectors-v2/connector-jdbc/pom.xml
+++ b/seatunnel-connectors-v2/connector-jdbc/pom.xml
@@ -60,6 +60,7 @@
         <trino.version>460</trino.version>
         <aws.sdk.version>2.31.30</aws.sdk.version>
         <duckdb.version>1.3.1.0</duckdb.version>
+        <yashandb.jdbc.version>1.9.24</yashandb.jdbc.version>
     </properties>
 
     <dependencyManagement>
@@ -252,6 +253,12 @@
                 <version>${duckdb.version}</version>
                 <scope>provided</scope>
             </dependency>
+            <dependency>
+                <groupId>com.yashandb</groupId>
+                <artifactId>yashandb-jdbc</artifactId>
+                <version>${yashandb.jdbc.version}</version>
+                <scope>provided</scope>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
@@ -350,6 +357,10 @@
             <groupId>org.apache.hive</groupId>
             <artifactId>hive-jdbc</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.yashandb</groupId>
+            <artifactId>yashandb-jdbc</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.oceanbase</groupId>
             <artifactId>oceanbase-client</artifactId>
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalog.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalog.java
new file mode 100644
index 0000000000..cd9a1b849a
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalog.java
@@ -0,0 +1,290 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.catalog.yashandb;
+
+import org.apache.seatunnel.shade.org.apache.commons.lang3.StringUtils;
+
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.ConstraintKey;
+import org.apache.seatunnel.api.table.catalog.PrimaryKey;
+import org.apache.seatunnel.api.table.catalog.TablePath;
+import org.apache.seatunnel.api.table.catalog.TableSchema;
+import org.apache.seatunnel.api.table.catalog.exception.CatalogException;
+import org.apache.seatunnel.api.table.converter.BasicTypeDefine;
+import org.apache.seatunnel.common.utils.JdbcUrlUtil;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.AbstractJdbcCatalog;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.utils.CatalogUtils;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeMapper;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class YashanDbCatalog extends AbstractJdbcCatalog {
+
+    private static final String SELECT_COLUMNS_SQL_TEMPLATE =
+            "SELECT\n"
+                    + "    cols.COLUMN_NAME,\n"
+                    + "    cols.DATA_TYPE,\n"
+                    + "    cols.data_type || \n"
+                    + "        CASE \n"
+                    + "            WHEN cols.data_type IN ('VARCHAR', 'VARCHAR2', 'CHAR') THEN '(' || cols.data_length || ')'\n"
+                    + "            WHEN cols.data_type IN ('NVARCHAR2', 'NCHAR') THEN '(' || cols.char_length || ')'\n"
+                    + "            WHEN cols.data_type IN ('NUMBER') AND cols.data_precision IS NOT NULL AND cols.data_scale IS NOT NULL THEN '(' || cols.data_precision || ', ' || cols.data_scale || ')'\n"
+                    + "            WHEN cols.data_type IN ('NUMBER') AND cols.data_precision IS NOT NULL AND cols.data_scale IS NULL THEN '(' || cols.data_precision || ')'\n"
+                    + "            WHEN cols.data_type IN ('RAW') THEN '(' || cols.data_length || ')'\n"
+                    + "        END AS FULL_TYPE_NAME,\n"
+                    + "    cols.data_length AS COLUMN_LENGTH,\n"
+                    + "    cols.data_precision AS COLUMN_PRECISION,\n"
+                    + "    cols.data_scale AS COLUMN_SCALE,\n"
+                    + "    com.comments AS COLUMN_COMMENT,\n"
+                    + "    cols.data_default AS DEFAULT_VALUE,\n"
+                    + "    cols.nullable AS IS_NULLABLE\n"
+                    + "FROM\n"
+                    + "    all_tab_columns cols\n"
+                    + "LEFT JOIN \n"
+                    + "    all_col_comments com ON cols.table_name = com.table_name AND cols.column_name = com.column_name AND cols.owner = com.owner\n"
+                    + "WHERE \n"
+                    + "    cols.owner = '%s'\n"
+                    + "    AND cols.table_name = '%s'\n"
+                    + "ORDER BY \n"
+                    + "    cols.column_id \n";
+
+    public YashanDbCatalog(
+            String catalogName,
+            String username,
+            String pwd,
+            JdbcUrlUtil.UrlInfo urlInfo,
+            String defaultSchema,
+            String driverClass) {
+        super(catalogName, username, pwd, urlInfo, defaultSchema, driverClass);
+    }
+
+    @Override
+    protected String getTableWithConditionSql(TablePath tablePath) {
+        return getListTableSql(tablePath.getDatabaseName())
+                + "  and  OWNER = '"
+                + tablePath.getSchemaName()
+                + "' and table_name = '"
+                + tablePath.getTableName()
+                + "'";
+    }
+
+    @Override
+    public boolean databaseExists(String databaseName) throws CatalogException {
+        return true;
+    }
+
+    @Override
+    public List<String> listDatabases() throws CatalogException {
+        return new ArrayList<>(Collections.singletonList("default"));
+    }
+
+    @Override
+    protected String getCreateTableSql(
+            TablePath tablePath, CatalogTable table, boolean createIndex) {
+        return getCreateTableSqls(tablePath, table, createIndex).get(0);
+    }
+
+    protected List<String> getCreateTableSqls(
+            TablePath tablePath, CatalogTable table, boolean createIndex) {
+        return new YashanDbCreateTableSqlBuilder(table, createIndex).build(tablePath);
+    }
+
+    @Override
+    protected String getDropTableSql(TablePath tablePath) {
+        return String.format("DROP TABLE %s", tablePath.getSchemaAndTableName("\""));
+    }
+
+    @Override
+    protected String getListTableSql(String databaseName) {
+        return "SELECT OWNER, TABLE_NAME FROM ALL_TABLES"
+                + "  WHERE TABLE_NAME NOT LIKE 'OL$%'"
+                + "  AND TABLE_NAME NOT LIKE 'WRM$%'"
+                + "  AND TABLE_NAME NOT LIKE 'WRH$%'"
+                + "  AND TABLE_NAME NOT LIKE 'WRI$%'"
+                + "  AND TABLE_NAME NOT LIKE 'YLS$%'"
+                + "  AND TABLE_NAME NOT LIKE 'WRM$%'";
+    }
+
+    @Override
+    protected String getTableName(ResultSet rs) throws SQLException {
+        return rs.getString(1) + "." + rs.getString(2);
+    }
+
+    @Override
+    protected String getSelectColumnsSql(TablePath tablePath) {
+        return String.format(
+                SELECT_COLUMNS_SQL_TEMPLATE, tablePath.getSchemaName(), tablePath.getTableName());
+    }
+
+    @Override
+    protected Column buildColumn(ResultSet resultSet) throws SQLException {
+        String columnName = resultSet.getString("COLUMN_NAME");
+        // e.g NUMBER, TIMESTAMP, TIMESTAMP WITH TIME ZONE
+        // DATA_TYPE from all_tab_columns may include precision like TIMESTAMP(6),
+        // strip parenthesized digits to get the pure type name
+        String typeName =
+                resultSet.getString("DATA_TYPE").toUpperCase().replaceAll("\\(\\d+\\)", "").trim();
+        // e.g NUMBER(10, 2)
+        String fullTypeName = resultSet.getString("FULL_TYPE_NAME");
+        long columnLength = resultSet.getLong("COLUMN_LENGTH");
+        Long columnPrecision = resultSet.getObject("COLUMN_PRECISION", Long.class);
+        Integer columnScale = resultSet.getObject("COLUMN_SCALE", Integer.class);
+        String columnComment = resultSet.getString("COLUMN_COMMENT");
+        Object defaultValue = resultSet.getObject("DEFAULT_VALUE");
+        boolean isNullable = resultSet.getString("IS_NULLABLE").equals("Y");
+
+        BasicTypeDefine<?> typeDefine =
+                BasicTypeDefine.builder()
+                        .name(columnName)
+                        .columnType(fullTypeName)
+                        .dataType(typeName)
+                        .length(columnLength)
+                        .precision(columnPrecision)
+                        .scale(columnScale)
+                        .nullable(isNullable)
+                        .defaultValue(defaultValue)
+                        .comment(columnComment)
+                        .build();
+        return new YashanDbTypeConverter().convert(typeDefine);
+    }
+
+    @Override
+    protected String getUrlFromDatabaseName(String databaseName) {
+        return defaultUrl;
+    }
+
+    @Override
+    protected String getOptionTableName(TablePath tablePath) {
+        return tablePath.getSchemaAndTableName();
+    }
+
+    @Override
+    public CatalogTable getTable(String sqlQuery) throws SQLException {
+        // YashanDB JDBC driver does not implement PreparedStatement.getMetaData().
+        // Use Statement.executeQuery() + ResultSet.getMetaData() as a workaround.
+        try (Connection defaultConnection = getConnection(defaultUrl);
+                Statement stmt = defaultConnection.createStatement();
+                ResultSet rs = stmt.executeQuery(sqlQuery)) {
+            ResultSetMetaData resultSetMetaData = rs.getMetaData();
+            CatalogTable catalogTable =
+                    CatalogUtils.getCatalogTable(
+                            resultSetMetaData, new YashanDbTypeMapper(), sqlQuery);
+
+            PrimaryKey primaryKey =
+                    extractPrimaryKey(defaultConnection, resultSetMetaData, sqlQuery);
+            if (primaryKey == null) {
+                return catalogTable;
+            }
+
+            Set<String> queryColumns =
+                    catalogTable.getTableSchema().getColumns().stream()
+                            .map(Column::getName)
+                            .collect(Collectors.toSet());
+            if (!queryColumns.containsAll(primaryKey.getColumnNames())) {
+                return catalogTable;
+            }
+
+            TableSchema newSchema =
+                    TableSchema.builder()
+                            .columns(catalogTable.getTableSchema().getColumns())
+                            .primaryKey(primaryKey)
+                            .constraintKey(catalogTable.getTableSchema().getConstraintKeys())
+                            .build();
+
+            return CatalogTable.of(
+                    catalogTable.getTableId(),
+                    newSchema,
+                    catalogTable.getOptions(),
+                    catalogTable.getPartitionKeys(),
+                    catalogTable.getComment(),
+                    catalogTable.getCatalogName());
+        }
+    }
+
+    private PrimaryKey extractPrimaryKey(
+            Connection connection, ResultSetMetaData resultSetMetaData, String sqlQuery) {
+        try {
+            String tableName = resultSetMetaData.getTableName(1);
+            if (StringUtils.isBlank(tableName)) {
+                return null;
+            }
+
+            String databaseName = resultSetMetaData.getCatalogName(1);
+            String schemaName = resultSetMetaData.getSchemaName(1);
+            DatabaseMetaData dbMetaData = connection.getMetaData();
+
+            TablePath tablePath =
+                    TablePath.of(
+                            StringUtils.isBlank(databaseName) ? null : databaseName,
+                            StringUtils.isBlank(schemaName) ? null : schemaName,
+                            tableName);
+
+            return CatalogUtils.getPrimaryKey(dbMetaData, tablePath).orElse(null);
+        } catch (SQLException e) {
+            log.debug(
+                    "Failed to extract primary key from database metadata for sql: {}",
+                    sqlQuery,
+                    e);
+            return null;
+        }
+    }
+
+    @Override
+    protected String getTruncateTableSql(TablePath tablePath) {
+        return String.format(
+                "TRUNCATE TABLE \"%s\".\"%s\"",
+                tablePath.getSchemaName(), tablePath.getTableName());
+    }
+
+    @Override
+    protected String getExistDataSql(TablePath tablePath) {
+        return String.format(
+                "select * from \"%s\".\"%s\" WHERE rownum = 1",
+                tablePath.getSchemaName(), tablePath.getTableName());
+    }
+
+    @Override
+    protected List<ConstraintKey> getConstraintKeys(DatabaseMetaData metaData, TablePath tablePath)
+            throws SQLException {
+        try {
+            return getConstraintKeys(
+                    metaData,
+                    tablePath.getDatabaseName(),
+                    tablePath.getSchemaName(),
+                    tablePath.getTableName());
+        } catch (SQLException e) {
+            log.info("Obtain constraint failure", e);
+            return new ArrayList<>();
+        }
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalogFactory.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalogFactory.java
new file mode 100644
index 0000000000..dcb99b83b1
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCatalogFactory.java
@@ -0,0 +1,97 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.catalog.yashandb;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.configuration.util.ConditionExtension;
+import org.apache.seatunnel.api.configuration.util.OptionRule;
+import org.apache.seatunnel.api.configuration.util.OptionValidationException;
+import org.apache.seatunnel.api.table.catalog.Catalog;
+import org.apache.seatunnel.api.table.factory.CatalogFactory;
+import org.apache.seatunnel.api.table.factory.Factory;
+import org.apache.seatunnel.common.utils.JdbcUrlUtil;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.config.JdbcCommonOptions;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+
+import com.google.auto.service.AutoService;
+
+@AutoService(Factory.class)
+public class YashanDbCatalogFactory implements CatalogFactory {
+
+    private static final String YASHANDB_URL_PREFIX = "jdbc:yasdb://";
+
+    @Override
+    public String factoryIdentifier() {
+        return DatabaseIdentifier.YASHANDB;
+    }
+
+    @Override
+    public Catalog createCatalog(String catalogName, ReadonlyConfig options) {
+        String urlWithDatabase = options.get(JdbcCommonOptions.URL);
+        JdbcUrlUtil.UrlInfo urlInfo = JdbcUrlUtil.getUrlInfo(urlWithDatabase);
+        return new YashanDbCatalog(
+                catalogName,
+                options.get(JdbcCommonOptions.USERNAME),
+                options.get(JdbcCommonOptions.PASSWORD),
+                urlInfo,
+                options.get(JdbcCommonOptions.SCHEMA),
+                options.get(JdbcCommonOptions.DRIVER));
+    }
+
+    @Override
+    public OptionRule optionRule() {
+        return JdbcCommonOptions.baseCatalogRule(new YashanDbUrlValidator()).build();
+    }
+
+    /**
+     * YashanDB-specific URL validator that rejects any JDBC URL not starting with {@code
+     * jdbc:yasdb://} before the catalog is created, providing fail-fast behaviour at configuration
+     * parsing time.
+     */
+    static class YashanDbUrlValidator implements ConditionExtension<String> {
+        @Override
+        public String description() {
+            return "YashanDB JDBC URL must start with '"
+                    + YASHANDB_URL_PREFIX
+                    + "' (e.g. jdbc:yasdb://host:port/database)";
+        }
+
+        @Override
+        public boolean evaluate(ReadonlyConfig config, String url) {
+            if (url == null || url.trim().isEmpty()) {
+                return false;
+            }
+            if (!url.startsWith(YASHANDB_URL_PREFIX)) {
+                throw new OptionValidationException(
+                        String.format(
+                                "Invalid YashanDB JDBC URL: [%s], URL must start with '%s'",
+                                url, YASHANDB_URL_PREFIX));
+            }
+            try {
+                JdbcUrlUtil.UrlInfo info = JdbcUrlUtil.getUrlInfo(url);
+                return info.getHost() != null && !info.getHost().isEmpty();
+            } catch (IllegalArgumentException e) {
+                throw new OptionValidationException(
+                        String.format(
+                                "Invalid YashanDB JDBC URL format: [%s], "
+                                        + "expected pattern: jdbc:yasdb://host:port[/database][?properties]",
+                                url));
+            }
+        }
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilder.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilder.java
new file mode 100644
index 0000000000..9c4baba0af
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilder.java
@@ -0,0 +1,156 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.catalog.yashandb;
+
+import org.apache.seatunnel.shade.org.apache.commons.lang3.StringUtils;
+
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.PrimaryKey;
+import org.apache.seatunnel.api.table.catalog.TablePath;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.utils.CatalogUtils;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+public class YashanDbCreateTableSqlBuilder {
+
+    private final List<Column> columns;
+    private final PrimaryKey primaryKey;
+    private final String comment;
+    protected String sourceCatalogName;
+    private final String fieldIde;
+    private final boolean createIndex;
+
+    public YashanDbCreateTableSqlBuilder(CatalogTable catalogTable, boolean createIndex) {
+        this.columns = catalogTable.getTableSchema().getColumns();
+        this.primaryKey = catalogTable.getTableSchema().getPrimaryKey();
+        this.comment = catalogTable.getComment();
+        this.sourceCatalogName = catalogTable.getCatalogName();
+        this.fieldIde = catalogTable.getOptions().get("fieldIde");
+        this.createIndex = createIndex;
+    }
+
+    public List<String> build(TablePath tablePath) {
+        List<String> sqls = new ArrayList<>();
+        StringBuilder createTableSql = new StringBuilder();
+        createTableSql
+                .append("CREATE TABLE ")
+                .append(tablePath.getSchemaAndTableName("\""))
+                .append(" (\n");
+
+        List<String> columnSqls =
+                columns.stream()
+                        .map(column -> CatalogUtils.getFieldIde(buildColumnSql(column), fieldIde))
+                        .collect(Collectors.toList());
+
+        // Add primary key directly in the create table statement
+        if (createIndex
+                && primaryKey != null
+                && primaryKey.getColumnNames() != null
+                && !primaryKey.getColumnNames().isEmpty()) {
+            columnSqls.add(buildPrimaryKeySql(primaryKey));
+        }
+
+        createTableSql.append(String.join(",\n", columnSqls));
+        createTableSql.append("\n)");
+        sqls.add(createTableSql.toString());
+        if (comment != null) {
+            String commentSql =
+                    "COMMENT ON TABLE "
+                            + tablePath.getSchemaAndTableName("\"")
+                            + " IS '"
+                            + comment
+                            + "'";
+            sqls.add(commentSql);
+        }
+        List<String> commentSqls =
+                columns.stream()
+                        .filter(column -> StringUtils.isNotBlank(column.getComment()))
+                        .map(
+                                column ->
+                                        buildColumnCommentSql(
+                                                column, tablePath.getSchemaAndTableName("\"")))
+                        .collect(Collectors.toList());
+        sqls.addAll(commentSqls);
+        return sqls;
+    }
+
+    protected String buildColumnSql(Column column) {
+        StringBuilder columnSql = new StringBuilder();
+        columnSql.append("\"").append(column.getName()).append("\" ");
+
+        String columnType;
+        if (column.getSinkType() != null) {
+            columnType = column.getSinkType();
+        } else if (StringUtils.equalsIgnoreCase(DatabaseIdentifier.YASHANDB, sourceCatalogName)
+                && StringUtils.isNotBlank(column.getSourceType())) {
+            columnType = column.getSourceType();
+        } else {
+            columnType = YashanDbTypeConverter.INSTANCE.reconvert(column).getColumnType();
+        }
+        columnSql.append(columnType);
+
+        if (!column.isNullable()) {
+            columnSql.append(" NOT NULL");
+        }
+
+        return columnSql.toString();
+    }
+
+    private String buildPrimaryKeySql(PrimaryKey primaryKey) {
+        String randomSuffix = UUID.randomUUID().toString().replace("-", "").substring(0, 4);
+        String columnNamesString =
+                primaryKey.getColumnNames().stream()
+                        .map(columnName -> "\"" + columnName + "\"")
+                        .collect(Collectors.joining(", "));
+
+        String primaryKeyStr = primaryKey.getPrimaryKey();
+        if (primaryKeyStr.length() > 25) {
+            primaryKeyStr = primaryKeyStr.substring(0, 25);
+        }
+
+        return CatalogUtils.getFieldIde(
+                "CONSTRAINT "
+                        + primaryKeyStr
+                        + "_"
+                        + randomSuffix
+                        + " PRIMARY KEY ("
+                        + columnNamesString
+                        + ")",
+                fieldIde);
+    }
+
+    private String buildColumnCommentSql(Column column, String tableName) {
+        StringBuilder columnCommentSql = new StringBuilder();
+        columnCommentSql
+                .append(CatalogUtils.quoteIdentifier("COMMENT ON COLUMN ", fieldIde))
+                .append(tableName)
+                .append(".");
+        columnCommentSql
+                .append(CatalogUtils.quoteIdentifier(column.getName(), fieldIde, "\""))
+                .append(CatalogUtils.quoteIdentifier(" IS '", fieldIde))
+                .append(column.getComment().replace("'", "''"))
+                .append("'");
+        return columnCommentSql.toString();
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/DatabaseIdentifier.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/DatabaseIdentifier.java
index dae180ebe1..08b1f5f048 100644
--- a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/DatabaseIdentifier.java
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/DatabaseIdentifier.java
@@ -28,6 +28,7 @@ public class DatabaseIdentifier {
     public static final String MYSQL = "MySQL";
     public static final String STARROCKS = "StarRocks";
     public static final String ORACLE = "Oracle";
+    public static final String YASHANDB = "YashanDB";
     public static final String PHOENIX = "Phoenix";
     public static final String POSTGRESQL = "Postgres";
     public static final String REDSHIFT = "Redshift";
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialect.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialect.java
new file mode 100644
index 0000000000..5d4376402e
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialect.java
@@ -0,0 +1,512 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.shade.org.apache.commons.lang3.StringUtils;
+
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.TablePath;
+import org.apache.seatunnel.api.table.converter.BasicTypeDefine;
+import org.apache.seatunnel.api.table.converter.TypeConverter;
+import org.apache.seatunnel.api.table.schema.event.AlterTableAddColumnEvent;
+import org.apache.seatunnel.api.table.schema.event.AlterTableChangeColumnEvent;
+import org.apache.seatunnel.api.table.schema.event.AlterTableColumnEvent;
+import org.apache.seatunnel.api.table.schema.event.AlterTableModifyColumnEvent;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.converter.JdbcRowConverter;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.JdbcDialect;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.JdbcDialectTypeMapper;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.SQLUtils;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.source.JdbcSourceTable;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class YashanDbDialect implements JdbcDialect {
+
+    private static final int DEFAULT_YASHANDB_FETCH_SIZE = 128;
+    public String fieldIde;
+
+    public YashanDbDialect(String fieldIde) {
+        this.fieldIde = fieldIde;
+    }
+
+    @Override
+    public String dialectName() {
+        return DatabaseIdentifier.YASHANDB;
+    }
+
+    @Override
+    public JdbcRowConverter getRowConverter() {
+        return new YashanDbJdbcRowConverter();
+    }
+
+    @Override
+    public TypeConverter<BasicTypeDefine> getTypeConverter() {
+        return new YashanDbTypeConverter();
+    }
+
+    @Override
+    public String hashModForField(String fieldName, int mod) {
+        return "MOD(ORA_HASH(" + quoteIdentifier(fieldName) + ")," + mod + ")";
+    }
+
+    @Override
+    public JdbcDialectTypeMapper getJdbcDialectTypeMapper() {
+        return new YashanDbTypeMapper();
+    }
+
+    @Override
+    public String quoteIdentifier(String identifier) {
+        if (identifier.contains(".")) {
+            String[] parts = identifier.split("\\.");
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < parts.length - 1; i++) {
+                sb.append("\"").append(parts[i]).append("\"").append(".");
+            }
+            return sb.append("\"")
+                    .append(getFieldIde(parts[parts.length - 1], fieldIde))
+                    .append("\"")
+                    .toString();
+        }
+        return "\"" + getFieldIde(identifier, fieldIde) + "\"";
+    }
+
+    @Override
+    public String tableIdentifier(String database, String tableName) {
+        return quoteIdentifier(tableName);
+    }
+
+    @Override
+    public Optional<String> getUpsertStatement(
+            String database, String tableName, String[] fieldNames, String[] uniqueKeyFields) {
+        List<String> nonUniqueKeyFields =
+                Arrays.stream(fieldNames)
+                        .filter(fieldName -> !Arrays.asList(uniqueKeyFields).contains(fieldName))
+                        .collect(Collectors.toList());
+        String valuesBinding =
+                Arrays.stream(fieldNames)
+                        .map(fieldName -> ":" + fieldName + " " + quoteIdentifier(fieldName))
+                        .collect(Collectors.joining(", "));
+
+        String usingClause = String.format("SELECT %s FROM DUAL", valuesBinding);
+        String onConditions =
+                Arrays.stream(uniqueKeyFields)
+                        .map(
+                                fieldName ->
+                                        String.format(
+                                                "TARGET.%s=SOURCE.%s",
+                                                quoteIdentifier(fieldName),
+                                                quoteIdentifier(fieldName)))
+                        .collect(Collectors.joining(" AND "));
+        String updateSetClause =
+                nonUniqueKeyFields.stream()
+                        .map(
+                                fieldName ->
+                                        String.format(
+                                                "TARGET.%s=SOURCE.%s",
+                                                quoteIdentifier(fieldName),
+                                                quoteIdentifier(fieldName)))
+                        .collect(Collectors.joining(", "));
+        String insertFields =
+                Arrays.stream(fieldNames)
+                        .map(this::quoteIdentifier)
+                        .collect(Collectors.joining(", "));
+        String insertValues =
+                Arrays.stream(fieldNames)
+                        .map(fieldName -> "SOURCE." + quoteIdentifier(fieldName))
+                        .collect(Collectors.joining(", "));
+
+        String upsertSQL =
+                String.format(
+                        " MERGE INTO %s TARGET"
+                                + " USING (%s) SOURCE"
+                                + " ON (%s) "
+                                + " WHEN MATCHED THEN"
+                                + " UPDATE SET %s"
+                                + " WHEN NOT MATCHED THEN"
+                                + " INSERT (%s) VALUES (%s)",
+                        tableIdentifier(database, tableName),
+                        usingClause,
+                        onConditions,
+                        updateSetClause,
+                        insertFields,
+                        insertValues);
+
+        return Optional.of(upsertSQL);
+    }
+
+    @Override
+    public PreparedStatement creatPreparedStatement(
+            Connection connection, String queryTemplate, int fetchSize) throws SQLException {
+        PreparedStatement statement =
+                connection.prepareStatement(
+                        queryTemplate, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+        if (fetchSize > 0) {
+            statement.setFetchSize(fetchSize);
+        } else {
+            statement.setFetchSize(DEFAULT_YASHANDB_FETCH_SIZE);
+        }
+        return statement;
+    }
+
+    @Override
+    public TablePath parse(String tablePath) {
+        return TablePath.of(tablePath, true);
+    }
+
+    @Override
+    public String tableIdentifier(TablePath tablePath) {
+        return quoteIdentifier(tablePath.getSchemaAndTableName());
+    }
+
+    @Override
+    public Long approximateRowCntStatement(Connection connection, JdbcSourceTable table)
+            throws SQLException {
+
+        // 1. Use select count
+        // 2. If no query is configured, use TABLE STATUS.
+        // 3. If a query is configured but does not contain a WHERE clause and tablePath is
+        // configured, use TABLE STATUS.
+        // 4. If a query is configured with a WHERE clause, or a query statement is configured but
+        // tablePath is TablePath.DEFAULT, use COUNT(*).
+
+        String query = table.getQuery();
+
+        boolean useTableStats =
+                StringUtils.isBlank(query)
+                        || (!query.toLowerCase().contains("where")
+                                && table.getTablePath() != null
+                                && !TablePath.DEFAULT
+                                        .getFullName()
+                                        .equals(table.getTablePath().getFullName()));
+
+        if (table.getUseSelectCount()) {
+            useTableStats = false;
+            if (StringUtils.isBlank(query)) {
+                query = "SELECT * FROM " + tableIdentifier(table.getTablePath());
+            }
+        }
+
+        if (useTableStats) {
+            TablePath tablePath = table.getTablePath();
+            String rowCountQuery =
+                    String.format(
+                            "select NUM_ROWS from all_tables where OWNER = '%s' AND TABLE_NAME = '%s' ",
+                            tablePath.getSchemaName(), tablePath.getTableName());
+            try (Statement stmt = connection.createStatement()) {
+                String analyzeTable =
+                        String.format(
+                                "analyze table %s compute statistics for table",
+                                tableIdentifier(tablePath));
+                if (!table.getSkipAnalyze()) {
+                    log.info("Split Chunk, approximateRowCntStatement: {}", analyzeTable);
+                    stmt.execute(analyzeTable);
+                } else {
+                    log.warn("Skip analyze, approximateRowCntStatement: {}", analyzeTable);
+                }
+                log.info("Split Chunk, approximateRowCntStatement: {}", rowCountQuery);
+                try (ResultSet rs = stmt.executeQuery(rowCountQuery)) {
+                    if (!rs.next()) {
+                        throw new SQLException(
+                                String.format(
+                                        "No result returned after running query [%s]",
+                                        rowCountQuery));
+                    }
+                    return rs.getLong(1);
+                }
+            }
+        }
+        return SQLUtils.countForSubquery(connection, query);
+    }
+
+    @Override
+    public Object queryNextChunkMax(
+            Connection connection,
+            JdbcSourceTable table,
+            String columnName,
+            int chunkSize,
+            Object includedLowerBound)
+            throws SQLException {
+        String quotedColumn = quoteIdentifier(columnName);
+        String sqlQuery;
+        if (StringUtils.isNotBlank(table.getQuery())) {
+            sqlQuery =
+                    String.format(
+                            "SELECT MAX(%s) FROM ("
+                                    + "SELECT %s FROM (%s) WHERE %s >= ? ORDER BY %s ASC "
+                                    + ") WHERE ROWNUM <= %s",
+                            quotedColumn,
+                            quotedColumn,
+                            table.getQuery(),
+                            quotedColumn,
+                            quotedColumn,
+                            chunkSize);
+        } else {
+            sqlQuery =
+                    String.format(
+                            "SELECT MAX(%s) FROM ("
+                                    + "SELECT %s FROM %s WHERE %s >= ? ORDER BY %s ASC "
+                                    + ") WHERE ROWNUM <= %s",
+                            quotedColumn,
+                            quotedColumn,
+                            tableIdentifier(table.getTablePath()),
+                            quotedColumn,
+                            quotedColumn,
+                            chunkSize);
+        }
+
+        try (PreparedStatement ps = connection.prepareStatement(sqlQuery)) {
+            ps.setObject(1, includedLowerBound);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) {
+                    // this should never happen
+                    throw new SQLException(
+                            String.format("No result returned after running query [%s]", sqlQuery));
+                }
+                return rs.getObject(1);
+            }
+        }
+    }
+
+    @Override
+    public Object[] sampleDataFromColumn(
+            Connection connection,
+            JdbcSourceTable table,
+            String columnName,
+            int samplingRate,
+            int fetchSize)
+            throws Exception {
+        String sampleQuery;
+        if (StringUtils.isNotBlank(table.getQuery())) {
+            sampleQuery =
+                    String.format(
+                            "SELECT %s FROM (%s) T", quoteIdentifier(columnName), table.getQuery());
+        } else {
+            sampleQuery =
+                    String.format(
+                            "SELECT %s FROM %s",
+                            quoteIdentifier(columnName), tableIdentifier(table.getTablePath()));
+        }
+
+        try (PreparedStatement stmt = creatPreparedStatement(connection, sampleQuery, fetchSize)) {
+            try (ResultSet rs = stmt.executeQuery()) {
+                int count = 0;
+                List<Object> results = new ArrayList<>();
+
+                while (rs.next()) {
+                    count++;
+                    if (count % samplingRate == 0) {
+                        results.add(rs.getObject(1));
+                    }
+                    if (Thread.currentThread().isInterrupted()) {
+                        throw new InterruptedException("Thread interrupted");
+                    }
+                }
+                Object[] resultsArray = results.toArray();
+                Arrays.sort(resultsArray);
+                return resultsArray;
+            }
+        }
+    }
+
+    @Override
+    public void applySchemaChange(
+            Connection connection, TablePath tablePath, AlterTableAddColumnEvent event)
+            throws SQLException {
+        List<String> ddlSQL = new ArrayList<>();
+        ddlSQL.add(buildUpdateColumnSQL(connection, tablePath, event));
+
+        if (event.getColumn().getComment() != null) {
+            ddlSQL.add(buildUpdateColumnCommentSQL(tablePath, event.getColumn()));
+        }
+
+        try (Statement statement = connection.createStatement()) {
+            for (String sql : ddlSQL) {
+                log.info("Executing add column SQL: {}", sql);
+                statement.execute(sql);
+            }
+        }
+    }
+
+    @Override
+    public void applySchemaChange(
+            Connection connection, TablePath tablePath, AlterTableChangeColumnEvent event)
+            throws SQLException {
+        List<String> ddlSQL = new ArrayList<>();
+        if (event.getOldColumn() != null
+                && !(event.getColumn().getName().equals(event.getOldColumn()))) {
+            StringBuilder sqlBuilder =
+                    new StringBuilder()
+                            .append("ALTER TABLE ")
+                            .append(tableIdentifier(tablePath))
+                            .append(" RENAME COLUMN ")
+                            .append(quoteIdentifier(event.getOldColumn()))
+                            .append(" TO ")
+                            .append(quoteIdentifier(event.getColumn().getName()));
+            ddlSQL.add(sqlBuilder.toString());
+        }
+
+        try (Statement statement = connection.createStatement()) {
+            for (String sql : ddlSQL) {
+                log.info("Executing change column SQL: {}", sql);
+                statement.execute(sql);
+            }
+        }
+
+        if (event.getColumn().getDataType() != null) {
+            applySchemaChange(
+                    connection,
+                    tablePath,
+                    AlterTableModifyColumnEvent.modify(event.tableIdentifier(), event.getColumn()));
+        }
+    }
+
+    @Override
+    public void applySchemaChange(
+            Connection connection, TablePath tablePath, AlterTableModifyColumnEvent event)
+            throws SQLException {
+        List<String> ddlSQL = new ArrayList<>();
+        ddlSQL.add(buildUpdateColumnSQL(connection, tablePath, event));
+
+        if (event.getColumn().getComment() != null) {
+            ddlSQL.add(buildUpdateColumnCommentSQL(tablePath, event.getColumn()));
+        }
+
+        try (Statement statement = connection.createStatement()) {
+            for (String sql : ddlSQL) {
+                log.info("Executing modify column SQL: {}", sql);
+                statement.execute(sql);
+            }
+        }
+    }
+
+    private String buildUpdateColumnSQL(
+            Connection connection, TablePath tablePath, AlterTableColumnEvent event)
+            throws SQLException {
+        Column column = extractColumn(event);
+        String actionType = getActionType(event);
+
+        String sourceDialectName = event.getSourceDialectName();
+        boolean sameCatalog = Objects.equals(dialectName(), sourceDialectName);
+        BasicTypeDefine typeDefine = getTypeConverter().reconvert(column);
+        String columnType = sameCatalog ? column.getSourceType() : typeDefine.getColumnType();
+
+        StringBuilder sqlBuilder =
+                new StringBuilder()
+                        .append("ALTER TABLE ")
+                        .append(tableIdentifier(tablePath))
+                        .append(" ")
+                        .append(actionType)
+                        .append(" ")
+                        .append(quoteIdentifier(column.getName()))
+                        .append(" ")
+                        .append(columnType);
+
+        if (column.getDefaultValue() != null && sameCatalog) {
+            sqlBuilder.append(" ").append(sqlClauseWithDefaultValue(typeDefine, sourceDialectName));
+        }
+
+        // Handle nullability based on operation type
+        appendNullableClause(sqlBuilder, connection, tablePath, column, event);
+
+        return sqlBuilder.toString();
+    }
+
+    private Column extractColumn(AlterTableColumnEvent event) {
+        if (event instanceof AlterTableModifyColumnEvent) {
+            return ((AlterTableModifyColumnEvent) event).getColumn();
+        } else if (event instanceof AlterTableAddColumnEvent) {
+            return ((AlterTableAddColumnEvent) event).getColumn();
+        }
+        throw new IllegalArgumentException("Unsupported AlterTableColumnEvent: " + event);
+    }
+
+    private String getActionType(AlterTableColumnEvent event) {
+        if (event instanceof AlterTableModifyColumnEvent) {
+            return "MODIFY";
+        } else if (event instanceof AlterTableAddColumnEvent) {
+            return "ADD";
+        }
+        throw new IllegalArgumentException("Unsupported AlterTableColumnEvent: " + event);
+    }
+
+    private void appendNullableClause(
+            StringBuilder sqlBuilder,
+            Connection connection,
+            TablePath tablePath,
+            Column column,
+            AlterTableColumnEvent event)
+            throws SQLException {
+        if (event instanceof AlterTableAddColumnEvent) {
+            // ADD: always specify nullability
+            sqlBuilder.append(" ").append(column.isNullable() ? "NULL" : "NOT NULL");
+        } else if (event instanceof AlterTableModifyColumnEvent) {
+            // MODIFY: only specify if different from current state
+            boolean targetColumnNullable =
+                    columnIsNullable(connection, tablePath, column.getName());
+            if (column.isNullable() != targetColumnNullable) {
+                sqlBuilder.append(" ").append(column.isNullable() ? "NULL" : "NOT NULL");
+            }
+        }
+    }
+
+    private String buildUpdateColumnCommentSQL(TablePath tablePath, Column column) {
+        return String.format(
+                "COMMENT ON COLUMN %s.%s IS '%s'",
+                tableIdentifier(tablePath), quoteIdentifier(column.getName()), column.getComment());
+    }
+
+    private boolean columnIsNullable(Connection connection, TablePath tablePath, String column)
+            throws SQLException {
+        String selectColumnSQL =
+                "SELECT NULLABLE FROM ALL_TAB_COLUMNS c"
+                        + " WHERE c.owner = ? AND c.table_name = ? AND c.column_name = ?";
+        try (PreparedStatement ps = connection.prepareStatement(selectColumnSQL)) {
+            ps.setString(1, tablePath.getSchemaName());
+            ps.setString(2, tablePath.getTableName());
+            ps.setString(3, column);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    return "Y".equals(rs.getString("NULLABLE"));
+                }
+                throw new SQLException(
+                        String.format(
+                                "Column %s not found in table %s",
+                                column, tablePath.getSchemaAndTableName()));
+            }
+        }
+    }
+
+    @Override
+    public String dualTable() {
+        return " FROM dual ";
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectFactory.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectFactory.java
new file mode 100644
index 0000000000..b455592638
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectFactory.java
@@ -0,0 +1,60 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.connectors.seatunnel.jdbc.config.JdbcConnectionConfig;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.JdbcDialect;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.JdbcDialectFactory;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.dialectenum.FieldIdeEnum;
+
+import com.google.auto.service.AutoService;
+
+import javax.annotation.Nonnull;
+
+/** Factory for {@link YashanDbDialect}. */
+@AutoService(JdbcDialectFactory.class)
+public class YashanDbDialectFactory implements JdbcDialectFactory {
+    @Override
+    public String dialectFactoryName() {
+        return DatabaseIdentifier.YASHANDB;
+    }
+
+    @Override
+    public boolean acceptsURL(String url) {
+        return url.startsWith("jdbc:yasdb:");
+    }
+
+    @Override
+    public JdbcDialect create() {
+        return new YashanDbDialect(FieldIdeEnum.ORIGINAL.getValue());
+    }
+
+    @Override
+    public JdbcDialect create(@Nonnull String compatibleMode, String fieldIde) {
+        return create(compatibleMode, fieldIde, null);
+    }
+
+    @Override
+    public JdbcDialect create(
+            @Nonnull String compatibleMode,
+            String fieldIde,
+            JdbcConnectionConfig jdbcConnectionConfig) {
+        return new YashanDbDialect(fieldIde);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbJdbcRowConverter.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbJdbcRowConverter.java
new file mode 100644
index 0000000000..a7332635e2
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbJdbcRowConverter.java
@@ -0,0 +1,165 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.shade.org.apache.commons.lang3.StringUtils;
+
+import org.apache.seatunnel.api.table.catalog.TableSchema;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.api.table.type.SqlType;
+import org.apache.seatunnel.common.exception.CommonError;
+import org.apache.seatunnel.common.utils.VectorUtils;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.converter.AbstractJdbcRowConverter;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.utils.JdbcFieldTypeUtils;
+
+import javax.annotation.Nullable;
+
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.OffsetDateTime;
+import java.util.Arrays;
+import java.util.Optional;
+
+public class YashanDbJdbcRowConverter extends AbstractJdbcRowConverter {
+
+    @Override
+    public String converterName() {
+        return DatabaseIdentifier.YASHANDB;
+    }
+
+    @Override
+    public SeaTunnelRow toInternal(ResultSet rs, TableSchema tableSchema) throws SQLException {
+        SeaTunnelRowType typeInfo = tableSchema.toPhysicalRowDataType();
+        Object[] fields = new Object[typeInfo.getTotalFields()];
+        for (int fieldIndex = 0; fieldIndex < typeInfo.getTotalFields(); fieldIndex++) {
+            SeaTunnelDataType<?> seaTunnelDataType = typeInfo.getFieldType(fieldIndex);
+            String fieldName = typeInfo.getFieldName(fieldIndex);
+            int resultSetIndex = fieldIndex + 1;
+            switch (seaTunnelDataType.getSqlType()) {
+                case STRING:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getString(rs, resultSetIndex);
+                    break;
+                case BOOLEAN:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getBoolean(rs, resultSetIndex);
+                    break;
+                case TINYINT:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getByte(rs, resultSetIndex);
+                    break;
+                case SMALLINT:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getShort(rs, resultSetIndex);
+                    break;
+                case INT:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getInt(rs, resultSetIndex);
+                    break;
+                case BIGINT:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getLong(rs, resultSetIndex);
+                    break;
+                case FLOAT:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getFloat(rs, resultSetIndex);
+                    break;
+                case DOUBLE:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getDouble(rs, resultSetIndex);
+                    break;
+                case DECIMAL:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getBigDecimal(rs, resultSetIndex);
+                    break;
+                case DATE:
+                    Date sqlDate = JdbcFieldTypeUtils.getDate(rs, resultSetIndex);
+                    fields[fieldIndex] =
+                            Optional.ofNullable(sqlDate).map(e -> e.toLocalDate()).orElse(null);
+                    break;
+                case TIME:
+                    fields[fieldIndex] = readTime(rs, resultSetIndex);
+                    break;
+                case TIMESTAMP:
+                    Timestamp sqlTimestamp = JdbcFieldTypeUtils.getTimestamp(rs, resultSetIndex);
+                    fields[fieldIndex] =
+                            Optional.ofNullable(sqlTimestamp)
+                                    .map(e -> e.toLocalDateTime())
+                                    .orElse(null);
+                    break;
+                case TIMESTAMP_TZ:
+                    OffsetDateTime offsetDateTime =
+                            JdbcFieldTypeUtils.getOffsetDateTime(rs, resultSetIndex);
+                    fields[fieldIndex] = offsetDateTime;
+                    break;
+                case FLOAT16_VECTOR:
+                case BFLOAT16_VECTOR:
+                case FLOAT_VECTOR:
+                    String result = JdbcFieldTypeUtils.getString(rs, resultSetIndex);
+                    if (StringUtils.isNotBlank(result)) {
+                        result = result.replace("[", "").replace("]", "");
+                        String[] stringArray = result.split(",");
+                        Float[] arrays = new Float[stringArray.length];
+                        for (int i = 0; i < stringArray.length; i++) {
+                            arrays[i] = Float.parseFloat(stringArray[i]);
+                        }
+                        fields[fieldIndex] = VectorUtils.toByteBuffer(arrays);
+                    }
+                    break;
+                case BYTES:
+                    fields[fieldIndex] = JdbcFieldTypeUtils.getBytes(rs, resultSetIndex);
+                    break;
+                case NULL:
+                    fields[fieldIndex] = null;
+                    break;
+                case ARRAY:
+                    fields[fieldIndex] =
+                            convertToArray(rs, resultSetIndex, seaTunnelDataType, fieldName);
+                    break;
+                case MAP:
+                case ROW:
+                default:
+                    throw CommonError.unsupportedDataType(
+                            converterName(), seaTunnelDataType.getSqlType().toString(), fieldName);
+            }
+        }
+        return new SeaTunnelRow(fields);
+    }
+
+    @Override
+    protected void setValueToStatementByDataType(
+            Object value,
+            PreparedStatement statement,
+            SeaTunnelDataType<?> seaTunnelDataType,
+            int statementIndex,
+            @Nullable String sourceType)
+            throws SQLException {
+        if (seaTunnelDataType.getSqlType().equals(SqlType.ARRAY)
+                || seaTunnelDataType.getSqlType().equals(SqlType.FLOAT16_VECTOR)
+                || seaTunnelDataType.getSqlType().equals(SqlType.FLOAT_VECTOR)
+                || seaTunnelDataType.getSqlType().equals(SqlType.BFLOAT16_VECTOR)) {
+            Object[] array = (Object[]) value;
+            if (array == null) {
+                statement.setNull(statementIndex, java.sql.Types.ARRAY);
+            } else {
+                String arrayStr = Arrays.toString(array);
+                statement.setString(statementIndex, arrayStr);
+            }
+        } else {
+            super.setValueToStatementByDataType(
+                    value, statement, seaTunnelDataType, statementIndex, sourceType);
+        }
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverter.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverter.java
new file mode 100644
index 0000000000..f30fdb3264
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverter.java
@@ -0,0 +1,522 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.PhysicalColumn;
+import org.apache.seatunnel.api.table.converter.BasicTypeDefine;
+import org.apache.seatunnel.api.table.converter.TypeConverter;
+import org.apache.seatunnel.api.table.type.ArrayType;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.DecimalType;
+import org.apache.seatunnel.api.table.type.LocalTimeType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.api.table.type.SqlType;
+import org.apache.seatunnel.api.table.type.VectorType;
+import org.apache.seatunnel.common.exception.CommonError;
+import org.apache.seatunnel.connectors.seatunnel.common.source.TypeDefineUtils;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+
+import com.google.auto.service.AutoService;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.HashSet;
+import java.util.Set;
+
+// reference
+// https://doc.yashandb.com/yashandb/23.5/zh/All-Manuals/Development-Guide/SQL-Reference-Manual/Data-Types/00Data-Types.html
+@Slf4j
+@AutoService(TypeConverter.class)
+public class YashanDbTypeConverter implements TypeConverter<BasicTypeDefine> {
+
+    // ============================ Numeric Data Types ============================
+
+    // Integer types: TINYINT(1B), SMALLINT(2B), INT(4B), BIGINT(8B)
+    public static final String TINYINT = "TINYINT";
+    public static final String SMALLINT = "SMALLINT";
+    public static final String INT = "INT";
+    public static final String INTEGER = "INTEGER";
+    public static final String BIGINT = "BIGINT";
+
+    // Floating-point types (IEEE 754): FLOAT(4B),
+    // DOUBLE(8B)
+    public static final String FLOAT = "FLOAT";
+    public static final String DOUBLE = "DOUBLE";
+
+    // NUMBER type: P in [1,38], S in [-84,127].
+    public static final String NUMBER = "NUMBER";
+
+    // BIT type: Size in [1,64]
+    public static final String BIT = "BIT";
+
+    // Boolean type
+    public static final String BOOLEAN = "BOOLEAN";
+
+    // ============================ Character Data Types ============================
+
+    // CHAR: [1,8000] bytes; VARCHAR: [1,65534] bytes
+    public static final String CHAR = "CHAR";
+    public static final String VARCHAR = "VARCHAR";
+
+    // NCHAR: [1,4000]; NVARCHAR: [1,32767] (Unicode)
+    public static final String NCHAR = "NCHAR";
+    public static final String NVARCHAR = "NVARCHAR";
+
+    // ============================ Date & Time Data Types ============================
+
+    public static final String DATE = "DATE";
+    public static final String TIME = "TIME";
+    public static final String TIMESTAMP = "TIMESTAMP";
+    public static final String TIMESTAMP_WITH_TIME_ZONE = TIMESTAMP + " WITH TIME ZONE";
+    public static final String TIMESTAMP_WITH_LOCAL_TIME_ZONE = TIMESTAMP + " WITH LOCAL TIME ZONE";
+
+    // Interval types
+    public static final String INTERVAL_YEAR_TO_MONTH = "INTERVAL YEAR TO MONTH";
+    public static final String INTERVAL_DAY_TO_SECOND = "INTERVAL DAY TO SECOND";
+
+    // ============================ Binary / LOB Data Types ============================
+
+    // LOB text types: max 4G*DB_BLOCK_SIZE
+    public static final String CLOB = "CLOB";
+    public static final String NCLOB = "NCLOB";
+
+    // BLOB: max 4G*DB_BLOCK_SIZE
+    public static final String BLOB = "BLOB";
+    // RAW: [1,65534] bytes
+    public static final String RAW = "RAW";
+
+    // ============================ ROWID Types ============================
+
+    // ROWID: 16 bytes; UROWID: [1,8000], default 4000
+    public static final String ROWID = "ROWID";
+    public static final String UROWID = "UROWID";
+
+    // ============================ Other Types ============================
+
+    // XMLTYPE: [1, 4G*DB_BLOCK_SIZE]
+    public static final String XMLTYPE = "XMLTYPE";
+
+    // JSON: [1, 32MB]
+    public static final String JSON = "JSON";
+
+    private static final String VECTOR_NAME = "VECTOR";
+
+    // ============================ Limits & Defaults ============================
+
+    public static final int MAX_PRECISION = 38;
+    public static final int DEFAULT_PRECISION = MAX_PRECISION;
+    public static final int MAX_SCALE = 127;
+    public static final int DEFAULT_SCALE = 18;
+    public static final int TIMESTAMP_DEFAULT_SCALE = 6;
+    public static final int MAX_TIMESTAMP_SCALE = 9;
+    public static final long MAX_RAW_LENGTH = 65534;
+    public static final long MAX_ROWID_LENGTH = 18;
+    public static final long MAX_CHAR_LENGTH = 8000;
+    public static final long MAX_VARCHAR_LENGTH = 65534;
+    public static final long MAX_NCHAR_LENGTH = 4000;
+    public static final long MAX_NVARCHAR_LENGTH = 32767;
+    public static final long MAX_UROWID_LENGTH = 4000;
+    public static final int MAX_JSON_LENGTH = 32 * 1024 * 1024;
+
+    public static final long BYTES_4GB = (long) Math.pow(2, 32);
+
+    public static final YashanDbTypeConverter INSTANCE = new YashanDbTypeConverter();
+    private static final Set<SqlType> SUPPORT_VECTOR = new HashSet<>();
+
+    static {
+        SUPPORT_VECTOR.add(SqlType.BIGINT);
+        SUPPORT_VECTOR.add(SqlType.DOUBLE);
+        SUPPORT_VECTOR.add(SqlType.FLOAT);
+        SUPPORT_VECTOR.add(SqlType.INT);
+        SUPPORT_VECTOR.add(SqlType.SMALLINT);
+        SUPPORT_VECTOR.add(SqlType.TINYINT);
+    }
+
+    public YashanDbTypeConverter() {}
+
+    @Override
+    public String identifier() {
+        return DatabaseIdentifier.YASHANDB;
+    }
+
+    @Override
+    public Column convert(BasicTypeDefine typeDefine) {
+        PhysicalColumn.PhysicalColumnBuilder builder =
+                PhysicalColumn.builder()
+                        .name(typeDefine.getName())
+                        .sourceType(typeDefine.getColumnType())
+                        .nullable(typeDefine.isNullable())
+                        .defaultValue(typeDefine.getDefaultValue())
+                        .comment(typeDefine.getComment());
+
+        String yashanType = typeDefine.getDataType().toUpperCase();
+
+        switch (yashanType) {
+                // ====================== Integer types ======================
+            case TINYINT:
+                builder.dataType(BasicType.BYTE_TYPE);
+                break;
+            case SMALLINT:
+                builder.dataType(BasicType.SHORT_TYPE);
+                break;
+            case INT:
+            case INTEGER:
+                builder.dataType(BasicType.INT_TYPE);
+                break;
+            case BIGINT:
+                builder.dataType(BasicType.LONG_TYPE);
+                break;
+
+                // ====================== NUMBER ======================
+            case NUMBER:
+                DecimalType decimalType;
+                if (typeDefine.getPrecision() != null && typeDefine.getPrecision() > 0) {
+                    decimalType =
+                            new DecimalType(
+                                    typeDefine.getPrecision().intValue(), typeDefine.getScale());
+                } else {
+                    decimalType = new DecimalType(DEFAULT_PRECISION, DEFAULT_SCALE);
+                }
+                builder.dataType(decimalType);
+                builder.columnLength((long) decimalType.getPrecision());
+                builder.scale(decimalType.getScale());
+                break;
+
+                // ====================== Floating-point types ======================
+            case FLOAT:
+                builder.dataType(BasicType.FLOAT_TYPE);
+                break;
+            case DOUBLE:
+                builder.dataType(BasicType.DOUBLE_TYPE);
+                break;
+
+                // ====================== Boolean type ======================
+            case BOOLEAN:
+                builder.dataType(BasicType.BOOLEAN_TYPE);
+                break;
+
+                // ====================== BIT type ======================
+            case BIT:
+                builder.dataType(BasicType.LONG_TYPE);
+                break;
+
+                // ====================== Character types ======================
+            case CHAR:
+            case VARCHAR:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength(TypeDefineUtils.charTo4ByteLength(typeDefine.getLength()));
+                break;
+            case NCHAR:
+            case NVARCHAR:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength(
+                        TypeDefineUtils.doubleByteTo4ByteLength(typeDefine.getLength()));
+                break;
+
+                // ====================== ROWID types ======================
+            case ROWID:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength(MAX_ROWID_LENGTH);
+                break;
+            case UROWID:
+                builder.dataType(BasicType.STRING_TYPE);
+                if (typeDefine.getLength() != null && typeDefine.getLength() > 0) {
+                    builder.columnLength(typeDefine.getLength());
+                } else {
+                    builder.columnLength(MAX_UROWID_LENGTH);
+                }
+                break;
+
+                // ====================== XML types ======================
+            case XMLTYPE:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength(typeDefine.getLength());
+                break;
+
+                // ====================== JSON type ======================
+            case JSON:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength((long) MAX_JSON_LENGTH);
+                break;
+
+                // ====================== LOB text types ======================
+            case CLOB:
+            case NCLOB:
+                builder.dataType(BasicType.STRING_TYPE);
+                builder.columnLength(BYTES_4GB - 1);
+                break;
+
+                // ====================== Binary / LOB types ======================
+            case BLOB:
+                builder.sourceType(BLOB);
+                builder.dataType(PrimitiveByteArrayType.INSTANCE);
+                builder.columnLength(typeDefine.getLength());
+                break;
+            case RAW:
+                builder.dataType(PrimitiveByteArrayType.INSTANCE);
+                if (typeDefine.getLength() == null || typeDefine.getLength() == 0) {
+                    builder.columnLength(MAX_RAW_LENGTH);
+                } else {
+                    builder.columnLength(typeDefine.getLength());
+                }
+                break;
+
+                // ====================== Date & Time types ======================
+            case DATE:
+                builder.dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE);
+                break;
+            case TIME:
+                builder.dataType(LocalTimeType.LOCAL_TIME_TYPE);
+                builder.columnLength(typeDefine.getPrecision());
+                break;
+            case TIMESTAMP:
+            case TIMESTAMP_WITH_TIME_ZONE:
+            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+                builder.dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE);
+                if (typeDefine.getScale() == null) {
+                    builder.scale(TIMESTAMP_DEFAULT_SCALE);
+                } else {
+                    builder.scale(typeDefine.getScale());
+                }
+                break;
+
+                // ====================== Interval types (as STRING) ======================
+            case INTERVAL_YEAR_TO_MONTH:
+            case INTERVAL_DAY_TO_SECOND:
+                builder.dataType(BasicType.STRING_TYPE);
+                break;
+            case VECTOR_NAME:
+                String columnType = typeDefine.getColumnType().toUpperCase();
+                if ("FLOAT64".equals(columnType)) {
+                    log.warn("{} vector convert to float32 vector.", columnType);
+                }
+                builder.dataType(VectorType.VECTOR_FLOAT_TYPE);
+                builder.scale(typeDefine.getScale());
+                builder.columnLength(typeDefine.getLength());
+                break;
+            default:
+                throw CommonError.convertToSeaTunnelTypeError(
+                        DatabaseIdentifier.YASHANDB, yashanType, typeDefine.getName());
+        }
+        return builder.build();
+    }
+
+    @Override
+    public BasicTypeDefine<?> reconvert(Column column) {
+        BasicTypeDefine.BasicTypeDefineBuilder<?> builder =
+                BasicTypeDefine.builder()
+                        .name(column.getName())
+                        .nullable(column.isNullable())
+                        .comment(column.getComment())
+                        .defaultValue(column.getDefaultValue());
+        switch (column.getDataType().getSqlType()) {
+            case BOOLEAN:
+                builder.columnType(BOOLEAN);
+                builder.dataType(BOOLEAN);
+                break;
+            case TINYINT:
+                builder.columnType(TINYINT);
+                builder.dataType(TINYINT);
+                break;
+            case SMALLINT:
+                builder.columnType(SMALLINT);
+                builder.dataType(SMALLINT);
+                break;
+            case INT:
+                builder.columnType(INT);
+                builder.dataType(INT);
+                break;
+            case BIGINT:
+                builder.columnType(BIGINT);
+                builder.dataType(BIGINT);
+                break;
+            case FLOAT:
+                builder.columnType(FLOAT);
+                builder.dataType(FLOAT);
+                break;
+            case DOUBLE:
+                builder.columnType(DOUBLE);
+                builder.dataType(DOUBLE);
+                break;
+            case DECIMAL:
+                DecimalType decimalType = (DecimalType) column.getDataType();
+                long precision = decimalType.getPrecision();
+                int scale = decimalType.getScale();
+                if (precision <= 0) {
+                    precision = DEFAULT_PRECISION;
+                    scale = DEFAULT_SCALE;
+                    log.warn(
+                            "The decimal column {} type decimal({},{}) is out of range, "
+                                    + "which is precision less than 0, "
+                                    + "it will be converted to decimal({},{})",
+                            column.getName(),
+                            decimalType.getPrecision(),
+                            decimalType.getScale(),
+                            precision,
+                            scale);
+                } else if (precision > MAX_PRECISION) {
+                    scale = (int) Math.max(0, scale - (precision - MAX_PRECISION));
+                    precision = MAX_PRECISION;
+                    log.warn(
+                            "The decimal column {} type decimal({},{}) is out of range, "
+                                    + "which exceeds the maximum precision of {}, "
+                                    + "it will be converted to decimal({},{})",
+                            column.getName(),
+                            decimalType.getPrecision(),
+                            decimalType.getScale(),
+                            MAX_PRECISION,
+                            precision,
+                            scale);
+                }
+                if (scale < 0) {
+                    scale = 0;
+                    log.warn(
+                            "The decimal column {} type decimal({},{}) is out of range, "
+                                    + "which is scale less than 0, "
+                                    + "it will be converted to decimal({},{})",
+                            column.getName(),
+                            decimalType.getPrecision(),
+                            decimalType.getScale(),
+                            precision,
+                            scale);
+                } else if (scale > MAX_SCALE) {
+                    scale = MAX_SCALE;
+                    log.warn(
+                            "The decimal column {} type decimal({},{}) is out of range, "
+                                    + "which exceeds the maximum scale of {}, "
+                                    + "it will be converted to decimal({},{})",
+                            column.getName(),
+                            decimalType.getPrecision(),
+                            decimalType.getScale(),
+                            MAX_SCALE,
+                            precision,
+                            scale);
+                }
+                builder.columnType(String.format("%s(%s,%s)", NUMBER, precision, scale));
+                builder.dataType(NUMBER);
+                builder.precision(precision);
+                builder.scale(scale);
+                break;
+            case BYTES:
+                builder.columnType(BLOB);
+                builder.dataType(BLOB);
+                break;
+            case ARRAY:
+                // YashanDB does not have a native ARRAY column type, store as vector
+                if (SUPPORT_VECTOR.contains(
+                        ((ArrayType) column.getDataType()).getElementType().getSqlType())) {
+                    log.warn(
+                            "The column {} with type ARRAY will be converted to VECTOR in YashanDB",
+                            column.getName());
+                    builder.columnType(
+                            String.format("%s(%s)", VECTOR_NAME, column.getColumnLength()));
+                    builder.dataType(VECTOR_NAME);
+                } else {
+                    throw new UnsupportedOperationException(
+                            "Unsupport "
+                                    + ((ArrayType) column.getDataType())
+                                            .getElementType()
+                                            .getSqlType()
+                                    + " ARRAY");
+                }
+                break;
+            case FLOAT_VECTOR:
+            case FLOAT16_VECTOR:
+                builder.columnType(String.format("%s(%s)", VECTOR_NAME, column.getScale()));
+                builder.dataType(VECTOR_NAME);
+                break;
+            case BFLOAT16_VECTOR:
+                // Vector types are stored as VECTOR in YashanDB
+                log.warn(
+                        "The column {} with type {} will be converted to VECTOR in YashanDB",
+                        column.getName(),
+                        column.getDataType().getSqlType().name());
+                builder.columnType(String.format("%s(%s)", VECTOR_NAME, column.getScale()));
+                builder.dataType(VECTOR_NAME);
+                break;
+            case STRING:
+                if (column.getColumnLength() == null || column.getColumnLength() <= 0) {
+                    builder.columnType(String.format("%s(%s)", VARCHAR, MAX_VARCHAR_LENGTH));
+                    builder.dataType(VARCHAR);
+                } else if (column.getColumnLength() <= MAX_VARCHAR_LENGTH) {
+                    builder.columnType(String.format("%s(%s)", VARCHAR, column.getColumnLength()));
+                    builder.dataType(VARCHAR);
+                } else {
+                    builder.columnType(CLOB);
+                    builder.dataType(CLOB);
+                }
+                break;
+            case DATE:
+                builder.columnType(DATE);
+                builder.dataType(DATE);
+                break;
+            case TIME:
+                builder.columnType(TIME);
+                builder.dataType(TIME);
+                break;
+            case TIMESTAMP:
+                if (column.getScale() == null || column.getScale() <= 0) {
+                    builder.columnType(TIMESTAMP);
+                } else {
+                    int timestampScale = column.getScale();
+                    if (column.getScale() > MAX_TIMESTAMP_SCALE) {
+                        timestampScale = MAX_TIMESTAMP_SCALE;
+                        log.warn(
+                                "The timestamp column {} type timestamp({}) is out of range, "
+                                        + "which exceeds the maximum scale of {}, "
+                                        + "it will be converted to timestamp({})",
+                                column.getName(),
+                                column.getScale(),
+                                MAX_TIMESTAMP_SCALE,
+                                timestampScale);
+                    }
+                    builder.columnType(String.format("TIMESTAMP(%s)", timestampScale));
+                    builder.scale(timestampScale);
+                }
+                builder.dataType(TIMESTAMP);
+                break;
+            case TIMESTAMP_TZ:
+                if (column.getScale() == null || column.getScale() <= 0) {
+                    builder.columnType(TIMESTAMP_WITH_TIME_ZONE);
+                } else {
+                    int tsScale = column.getScale();
+                    if (tsScale > MAX_TIMESTAMP_SCALE) {
+                        tsScale = MAX_TIMESTAMP_SCALE;
+                        log.warn(
+                                "The timestamp column {} type timestamp({}) is out of range, "
+                                        + "which exceeds the maximum scale of {}, "
+                                        + "it will be converted to timestamp({})",
+                                column.getName(),
+                                column.getScale(),
+                                MAX_TIMESTAMP_SCALE,
+                                tsScale);
+                    }
+                    builder.columnType(String.format("TIMESTAMP(%s) WITH TIME ZONE", tsScale));
+                    builder.scale(tsScale);
+                }
+                builder.dataType(TIMESTAMP_WITH_TIME_ZONE);
+                break;
+            default:
+                throw CommonError.convertToConnectorTypeError(
+                        DatabaseIdentifier.YASHANDB,
+                        column.getDataType().getSqlType().name(),
+                        column.getName());
+        }
+        return builder.build();
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeMapper.java b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeMapper.java
new file mode 100644
index 0000000000..0f000a2688
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeMapper.java
@@ -0,0 +1,59 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.converter.BasicTypeDefine;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.JdbcDialectTypeMapper;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+
+@Slf4j
+public class YashanDbTypeMapper implements JdbcDialectTypeMapper {
+
+    public YashanDbTypeMapper() {}
+
+    @Override
+    public Column mappingColumn(BasicTypeDefine typeDefine) {
+        return new YashanDbTypeConverter().convert(typeDefine);
+    }
+
+    @Override
+    public Column mappingColumn(ResultSetMetaData metadata, int colIndex) throws SQLException {
+        String columnName = metadata.getColumnLabel(colIndex);
+        String nativeType = metadata.getColumnTypeName(colIndex);
+        int isNullable = metadata.isNullable(colIndex);
+        long precision = metadata.getPrecision(colIndex);
+        int scale = metadata.getScale(colIndex);
+
+        BasicTypeDefine typeDefine =
+                BasicTypeDefine.builder()
+                        .name(columnName)
+                        .columnType(nativeType)
+                        .dataType(nativeType)
+                        .nullable(isNullable == ResultSetMetaData.columnNullable)
+                        .length(precision)
+                        .precision(precision)
+                        .scale(scale)
+                        .build();
+        return mappingColumn(typeDefine);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/JdbcCatalogFactoryTest.java b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/JdbcCatalogFactoryTest.java
index 2b827e3248..96a9251ef5 100644
--- a/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/JdbcCatalogFactoryTest.java
+++ b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/JdbcCatalogFactoryTest.java
@@ -29,6 +29,7 @@ import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.oracle.OracleCatal
 import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.psql.PostgresCatalogFactory;
 import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.saphana.SapHanaCatalogFactory;
 import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.sqlserver.SqlServerCatalogFactory;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.catalog.yashandb.YashanDbCatalogFactory;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -208,4 +209,46 @@ class JdbcCatalogFactoryTest {
         Assertions.assertDoesNotThrow(
                 () -> validate(new SapHanaCatalogFactory().optionRule(), cfg));
     }
+
+    // ==================== YashanDB dialect validator ====================
+
+    @Test
+    void testYashanDbCatalogValidUrl() {
+        OptionRule rule = new YashanDbCatalogFactory().optionRule();
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put("url", "jdbc:yasdb://localhost:1688/SYS");
+        cfg.put("username", "SYS");
+        cfg.put("password", "Cod-2022");
+        Assertions.assertDoesNotThrow(() -> validate(rule, cfg));
+    }
+
+    @Test
+    void testYashanDbCatalogValidUrlWithoutDatabase() {
+        OptionRule rule = new YashanDbCatalogFactory().optionRule();
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put("url", "jdbc:yasdb://localhost:1688");
+        cfg.put("username", "SYS");
+        cfg.put("password", "Cod-2022");
+        Assertions.assertDoesNotThrow(() -> validate(rule, cfg));
+    }
+
+    @Test
+    void testYashanDbCatalogRejectsNonYashanUrl() {
+        OptionRule rule = new YashanDbCatalogFactory().optionRule();
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put("url", "jdbc:mysql://localhost:3306/mydb");
+        cfg.put("username", "root");
+        cfg.put("password", "pass");
+        Assertions.assertThrows(OptionValidationException.class, () -> validate(rule, cfg));
+    }
+
+    @Test
+    void testYashanDbCatalogUrlWithProperties() {
+        OptionRule rule = new YashanDbCatalogFactory().optionRule();
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put("url", "jdbc:yasdb://localhost:1688/SYS?connectTimeout=30000");
+        cfg.put("username", "SYS");
+        cfg.put("password", "Cod-2022");
+        Assertions.assertDoesNotThrow(() -> validate(rule, cfg));
+    }
 }
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilderTest.java b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilderTest.java
new file mode 100644
index 0000000000..ea1e2b577f
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/catalog/yashandb/YashanDbCreateTableSqlBuilderTest.java
@@ -0,0 +1,315 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.catalog.yashandb;
+
+import org.apache.seatunnel.shade.com.google.common.collect.Lists;
+
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.ConstraintKey;
+import org.apache.seatunnel.api.table.catalog.PhysicalColumn;
+import org.apache.seatunnel.api.table.catalog.PrimaryKey;
+import org.apache.seatunnel.api.table.catalog.TableIdentifier;
+import org.apache.seatunnel.api.table.catalog.TablePath;
+import org.apache.seatunnel.api.table.catalog.TableSchema;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.LocalTimeType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class YashanDbCreateTableSqlBuilderTest {
+
+    private static final PrintStream CONSOLE = System.out;
+
+    @Test
+    public void testBuild() {
+        String dataBaseName = "test_database";
+        String tableName = "test_table";
+        TablePath tablePath = TablePath.of(dataBaseName, tableName);
+        TableSchema tableSchema =
+                TableSchema.builder()
+                        .column(PhysicalColumn.of("id", BasicType.LONG_TYPE, 22, false, null, "id"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "name", BasicType.STRING_TYPE, 128, false, null, "name"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "age", BasicType.INT_TYPE, (Long) null, true, null, "age"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "blob_v",
+                                        PrimitiveByteArrayType.INSTANCE,
+                                        Long.MAX_VALUE,
+                                        true,
+                                        null,
+                                        "blob_v"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "createTime",
+                                        LocalTimeType.LOCAL_DATE_TIME_TYPE,
+                                        3,
+                                        true,
+                                        null,
+                                        "createTime"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "lastUpdateTime",
+                                        LocalTimeType.LOCAL_DATE_TIME_TYPE,
+                                        3,
+                                        true,
+                                        null,
+                                        "lastUpdateTime"))
+                        .primaryKey(PrimaryKey.of("id", Lists.newArrayList("id")))
+                        .constraintKey(
+                                Arrays.asList(
+                                        ConstraintKey.of(
+                                                ConstraintKey.ConstraintType.INDEX_KEY,
+                                                "name",
+                                                Lists.newArrayList(
+                                                        ConstraintKey.ConstraintKeyColumn.of(
+                                                                "name", null))),
+                                        ConstraintKey.of(
+                                                ConstraintKey.ConstraintType.INDEX_KEY,
+                                                "blob_v",
+                                                Lists.newArrayList(
+                                                        ConstraintKey.ConstraintKeyColumn.of(
+                                                                "blob_v", null)))))
+                        .build();
+        CatalogTable catalogTable =
+                CatalogTable.of(
+                        TableIdentifier.of("test_catalog", dataBaseName, tableName),
+                        tableSchema,
+                        new HashMap<>(),
+                        new ArrayList<>(),
+                        "User table");
+
+        YashanDbCreateTableSqlBuilder builder =
+                new YashanDbCreateTableSqlBuilder(catalogTable, true);
+        List<String> sqls = builder.build(tablePath);
+        String createTableSql = sqls.get(0);
+
+        // YashanDB uses BIGINT for LONG, VARCHAR for STRING, BLOB for bytes, TIMESTAMP for datetime
+        String expect =
+                "CREATE TABLE \"test_table\" (\n"
+                        + "\"id\" BIGINT NOT NULL,\n"
+                        + "\"name\" VARCHAR(128) NOT NULL,\n"
+                        + "\"age\" INT,\n"
+                        + "\"blob_v\" BLOB,\n"
+                        + "\"createTime\" TIMESTAMP,\n"
+                        + "\"lastUpdateTime\" TIMESTAMP,\n"
+                        + "CONSTRAINT id_9a8b PRIMARY KEY (\"id\")\n"
+                        + ")";
+
+        // replace "CONSTRAINT id_xxxx" because it's dynamically generated(random)
+        String regex = "id_\\w+";
+        String replacedStr1 = createTableSql.replaceAll(regex, "id_");
+        String replacedStr2 = expect.replaceAll(regex, "id_");
+        CONSOLE.println(replacedStr2);
+        Assertions.assertEquals(replacedStr2, replacedStr1);
+
+        Assertions.assertEquals("COMMENT ON TABLE \"test_table\" IS 'User table'", sqls.get(1));
+
+        // skip index
+        YashanDbCreateTableSqlBuilder builderSkipIndex =
+                new YashanDbCreateTableSqlBuilder(catalogTable, false);
+        String createTableSqlSkipIndex = builderSkipIndex.build(tablePath).get(0);
+        String expectSkipIndex =
+                "CREATE TABLE \"test_table\" (\n"
+                        + "\"id\" BIGINT NOT NULL,\n"
+                        + "\"name\" VARCHAR(128) NOT NULL,\n"
+                        + "\"age\" INT,\n"
+                        + "\"blob_v\" BLOB,\n"
+                        + "\"createTime\" TIMESTAMP,\n"
+                        + "\"lastUpdateTime\" TIMESTAMP\n"
+                        + ")";
+        CONSOLE.println(expectSkipIndex);
+        Assertions.assertEquals(expectSkipIndex, createTableSqlSkipIndex);
+    }
+
+    @Test
+    public void testColumnSinkType() {
+        YashanDbCreateTableSqlBuilder sqlBuilder = mock(YashanDbCreateTableSqlBuilder.class);
+
+        Column column = mock(Column.class);
+        when(column.getSinkType()).thenReturn("VARCHAR(10)");
+        when(column.getDataType()).thenReturn((SeaTunnelDataType) BasicType.INT_TYPE);
+        when(column.getName()).thenReturn("col1");
+        when(sqlBuilder.buildColumnSql(column)).thenCallRealMethod();
+
+        String result = sqlBuilder.buildColumnSql(column);
+
+        Assertions.assertEquals("\"col1\" VARCHAR(10) NOT NULL", result);
+    }
+
+    @Test
+    public void testColumnComments() {
+        String dataBaseName = "test_db";
+        String tableName = "test_table";
+        TablePath tablePath = TablePath.of(dataBaseName, tableName);
+        TableSchema tableSchema =
+                TableSchema.builder()
+                        .column(
+                                PhysicalColumn.of(
+                                        "id", BasicType.LONG_TYPE, 22, false, null, "primary key"))
+                        .column(
+                                PhysicalColumn.of(
+                                        "name",
+                                        BasicType.STRING_TYPE,
+                                        100,
+                                        true,
+                                        null,
+                                        "user name"))
+                        .build();
+        CatalogTable catalogTable =
+                CatalogTable.of(
+                        TableIdentifier.of("test_catalog", dataBaseName, tableName),
+                        tableSchema,
+                        new HashMap<>(),
+                        new ArrayList<>(),
+                        null);
+
+        YashanDbCreateTableSqlBuilder builder =
+                new YashanDbCreateTableSqlBuilder(catalogTable, false);
+        List<String> sqls = builder.build(tablePath);
+
+        // sqls[0] = CREATE TABLE, sqls[1..n] = column comments
+        Assertions.assertTrue(sqls.size() >= 3);
+        Assertions.assertTrue(sqls.get(1).contains("COMMENT ON COLUMN"));
+        Assertions.assertTrue(sqls.get(1).contains("primary key"));
+        Assertions.assertTrue(sqls.get(2).contains("COMMENT ON COLUMN"));
+        Assertions.assertTrue(sqls.get(2).contains("user name"));
+    }
+
+    @Test
+    public void testBuildWithBooleanAndFloatColumns() {
+        String dataBaseName = "test_db";
+        String tableName = "test_types";
+        TablePath tablePath = TablePath.of(dataBaseName, tableName);
+        TableSchema tableSchema =
+                TableSchema.builder()
+                        .column(
+                                PhysicalColumn.of(
+                                        "flag",
+                                        BasicType.BOOLEAN_TYPE,
+                                        (Long) null,
+                                        false,
+                                        null,
+                                        null))
+                        .column(
+                                PhysicalColumn.of(
+                                        "score",
+                                        BasicType.DOUBLE_TYPE,
+                                        (Long) null,
+                                        true,
+                                        null,
+                                        null))
+                        .column(
+                                PhysicalColumn.of(
+                                        "tiny_val",
+                                        BasicType.BYTE_TYPE,
+                                        (Long) null,
+                                        true,
+                                        null,
+                                        null))
+                        .column(
+                                PhysicalColumn.of(
+                                        "small_val",
+                                        BasicType.SHORT_TYPE,
+                                        (Long) null,
+                                        true,
+                                        null,
+                                        null))
+                        .build();
+        CatalogTable catalogTable =
+                CatalogTable.of(
+                        TableIdentifier.of("test_catalog", dataBaseName, tableName),
+                        tableSchema,
+                        new HashMap<>(),
+                        new ArrayList<>(),
+                        null);
+
+        YashanDbCreateTableSqlBuilder builder =
+                new YashanDbCreateTableSqlBuilder(catalogTable, false);
+        List<String> sqls = builder.build(tablePath);
+        String createTableSql = sqls.get(0);
+
+        Assertions.assertTrue(createTableSql.contains("\"flag\" BOOLEAN NOT NULL"));
+        Assertions.assertTrue(createTableSql.contains("\"score\" DOUBLE"));
+        Assertions.assertTrue(createTableSql.contains("\"tiny_val\" TINYINT"));
+        Assertions.assertTrue(createTableSql.contains("\"small_val\" SMALLINT"));
+    }
+
+    @Test
+    public void testBuildWithSameSourceCatalog() {
+        String dataBaseName = "test_db";
+        String tableName = "test_source";
+        TablePath tablePath = TablePath.of(dataBaseName, tableName);
+        TableSchema tableSchema =
+                TableSchema.builder()
+                        .column(
+                                PhysicalColumn.of(
+                                        "col1", BasicType.STRING_TYPE, 100, false, null, null))
+                        .build();
+        // Simulate same source catalog (YASHANDB)
+        CatalogTable catalogTable =
+                CatalogTable.of(
+                        TableIdentifier.of("YashanDB", dataBaseName, tableName),
+                        tableSchema,
+                        new HashMap<>(),
+                        new ArrayList<>(),
+                        null);
+
+        // Column has sourceType set
+        Column columnWithSource =
+                PhysicalColumn.builder()
+                        .name("col1")
+                        .dataType(BasicType.STRING_TYPE)
+                        .columnLength(100L)
+                        .nullable(false)
+                        .sourceType("VARCHAR2(100)")
+                        .build();
+        TableSchema schemaWithSource = TableSchema.builder().column(columnWithSource).build();
+        CatalogTable catalogTableWithSource =
+                CatalogTable.of(
+                        TableIdentifier.of("YashanDB", dataBaseName, tableName),
+                        schemaWithSource,
+                        new HashMap<>(),
+                        new ArrayList<>(),
+                        null);
+
+        YashanDbCreateTableSqlBuilder builder =
+                new YashanDbCreateTableSqlBuilder(catalogTableWithSource, false);
+        List<String> sqls = builder.build(tablePath);
+        String createTableSql = sqls.get(0);
+
+        // Should use sourceType when sourceCatalogName matches YASHANDB
+        Assertions.assertTrue(createTableSql.contains("VARCHAR2(100)"));
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectTest.java b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectTest.java
new file mode 100644
index 0000000000..3b96afce2e
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbDialectTest.java
@@ -0,0 +1,227 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.api.table.catalog.TablePath;
+import org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.DatabaseIdentifier;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+public class YashanDbDialectTest {
+
+    private static final YashanDbDialect DIALECT =
+            new YashanDbDialect(
+                    org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.dialectenum
+                            .FieldIdeEnum.ORIGINAL
+                            .getValue());
+
+    @Test
+    public void testDialectName() {
+        Assertions.assertEquals(DatabaseIdentifier.YASHANDB, DIALECT.dialectName());
+    }
+
+    @Test
+    public void testQuoteIdentifier() {
+        Assertions.assertEquals("\"table_name\"", DIALECT.quoteIdentifier("table_name"));
+        Assertions.assertEquals("\"COLUMN\"", DIALECT.quoteIdentifier("COLUMN"));
+    }
+
+    @Test
+    public void testQuoteIdentifierWithDot() {
+        String result = DIALECT.quoteIdentifier("SCHEMA.TABLE");
+        Assertions.assertTrue(result.contains("\"SCHEMA\""));
+        Assertions.assertTrue(result.contains("\"TABLE\""));
+        Assertions.assertTrue(result.contains("."));
+    }
+
+    @Test
+    public void testQuoteIdentifierWithUppercase() {
+        YashanDbDialect upperDialect =
+                new YashanDbDialect(
+                        org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.dialectenum
+                                .FieldIdeEnum.UPPERCASE
+                                .getValue());
+        Assertions.assertEquals("\"MY_COLUMN\"", upperDialect.quoteIdentifier("my_column"));
+    }
+
+    @Test
+    public void testQuoteIdentifierWithLowercase() {
+        YashanDbDialect lowerDialect =
+                new YashanDbDialect(
+                        org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.dialectenum
+                                .FieldIdeEnum.LOWERCASE
+                                .getValue());
+        Assertions.assertEquals("\"my_column\"", lowerDialect.quoteIdentifier("MY_COLUMN"));
+    }
+
+    @Test
+    public void testTableIdentifier() {
+        String result = DIALECT.tableIdentifier("mydb", "mytable");
+        Assertions.assertEquals("\"mytable\"", result);
+    }
+
+    @Test
+    public void testTableIdentifierWithTablePath() {
+        // TablePath.of(database, schema, table) - schema must be set explicitly
+        TablePath tablePath = TablePath.of(null, "SCHEMA", "TABLE");
+        String result = DIALECT.tableIdentifier(tablePath);
+        // quoteIdentifier splits "SCHEMA.TABLE" on "." and quotes each part
+        Assertions.assertEquals("\"SCHEMA\".\"TABLE\"", result);
+
+        // TablePath.of(database, table) - schema is null, getSchemaAndTableName returns tableName
+        // only
+        TablePath tablePath2 = TablePath.of("mydb", "mytable");
+        String result2 = DIALECT.tableIdentifier(tablePath2);
+        Assertions.assertEquals("\"mytable\"", result2);
+    }
+
+    @Test
+    public void testParse() {
+        TablePath tablePath = DIALECT.parse("SCHEMA.TABLE");
+        Assertions.assertEquals("SCHEMA", tablePath.getSchemaName());
+        Assertions.assertEquals("TABLE", tablePath.getTableName());
+    }
+
+    @Test
+    public void testParseTableOnly() {
+        TablePath tablePath = DIALECT.parse("TABLE");
+        Assertions.assertEquals("TABLE", tablePath.getTableName());
+    }
+
+    @Test
+    public void testHashModForField() {
+        String result = DIALECT.hashModForField("col1", 10);
+        Assertions.assertTrue(result.contains("MOD"));
+        Assertions.assertTrue(result.contains("ORA_HASH"));
+        Assertions.assertTrue(result.contains("\"col1\""));
+        Assertions.assertTrue(result.contains("10"));
+    }
+
+    @Test
+    public void testDualTable() {
+        Assertions.assertEquals(" FROM dual ", DIALECT.dualTable());
+    }
+
+    @Test
+    public void testGetRowConverter() {
+        Assertions.assertNotNull(DIALECT.getRowConverter());
+        Assertions.assertTrue(DIALECT.getRowConverter() instanceof YashanDbJdbcRowConverter);
+    }
+
+    @Test
+    public void testGetTypeConverter() {
+        Assertions.assertNotNull(DIALECT.getTypeConverter());
+        Assertions.assertTrue(DIALECT.getTypeConverter() instanceof YashanDbTypeConverter);
+    }
+
+    @Test
+    public void testGetJdbcDialectTypeMapper() {
+        Assertions.assertNotNull(DIALECT.getJdbcDialectTypeMapper());
+        Assertions.assertTrue(DIALECT.getJdbcDialectTypeMapper() instanceof YashanDbTypeMapper);
+    }
+
+    @Test
+    public void testGetUpsertStatement() {
+        String[] fieldNames = {"id", "name", "age"};
+        String[] uniqueKeyFields = {"id"};
+
+        Optional<String> upsertStatement =
+                DIALECT.getUpsertStatement("test_db", "test_table", fieldNames, uniqueKeyFields);
+
+        Assertions.assertTrue(upsertStatement.isPresent());
+        String sql = upsertStatement.get();
+        Assertions.assertTrue(sql.contains("MERGE INTO"));
+        Assertions.assertTrue(sql.contains("TARGET"));
+        Assertions.assertTrue(sql.contains("SOURCE"));
+        Assertions.assertTrue(sql.contains("WHEN MATCHED THEN"));
+        Assertions.assertTrue(sql.contains("WHEN NOT MATCHED THEN"));
+        Assertions.assertTrue(sql.contains("\"test_table\""));
+        Assertions.assertTrue(sql.contains("\"id\""));
+        Assertions.assertTrue(sql.contains("\"name\""));
+        Assertions.assertTrue(sql.contains("\"age\""));
+        Assertions.assertTrue(sql.contains("UPDATE SET"));
+        Assertions.assertTrue(sql.contains("INSERT"));
+    }
+
+    @Test
+    public void testGetUpsertStatementMultipleKeys() {
+        String[] fieldNames = {"id", "code", "name", "value"};
+        String[] uniqueKeyFields = {"id", "code"};
+
+        Optional<String> upsertStatement =
+                DIALECT.getUpsertStatement("test_db", "test_table", fieldNames, uniqueKeyFields);
+
+        Assertions.assertTrue(upsertStatement.isPresent());
+        String sql = upsertStatement.get();
+        // ON condition should have both keys
+        Assertions.assertTrue(sql.contains("TARGET.\"id\"=SOURCE.\"id\""));
+        Assertions.assertTrue(sql.contains("TARGET.\"code\"=SOURCE.\"code\""));
+        // UPDATE SET should only contain non-key fields
+        Assertions.assertTrue(sql.contains("TARGET.\"name\"=SOURCE.\"name\""));
+        Assertions.assertTrue(sql.contains("TARGET.\"value\"=SOURCE.\"value\""));
+    }
+
+    @Test
+    public void testInsertIntoStatement() {
+        String[] fieldNames = {"id", "name", "age"};
+        String insertStatement =
+                DIALECT.getInsertIntoStatement("test_db", "test_table", fieldNames);
+
+        Assertions.assertNotNull(insertStatement);
+        Assertions.assertTrue(insertStatement.contains("INSERT INTO"));
+        Assertions.assertTrue(insertStatement.contains("\"test_table\""));
+        Assertions.assertTrue(insertStatement.contains("\"id\""));
+        Assertions.assertTrue(insertStatement.contains("\"name\""));
+        Assertions.assertTrue(insertStatement.contains("\"age\""));
+        Assertions.assertTrue(insertStatement.contains(":id"));
+        Assertions.assertTrue(insertStatement.contains(":name"));
+        Assertions.assertTrue(insertStatement.contains(":age"));
+    }
+
+    @Test
+    public void testUpdateStatement() {
+        String[] fieldNames = {"name", "age"};
+        String[] conditionFields = {"id"};
+        String updateStatement =
+                DIALECT.getUpdateStatement(
+                        "test_db", "test_table", fieldNames, conditionFields, false);
+
+        Assertions.assertNotNull(updateStatement);
+        Assertions.assertTrue(updateStatement.contains("UPDATE"));
+        Assertions.assertTrue(updateStatement.contains("SET"));
+        Assertions.assertTrue(updateStatement.contains("WHERE"));
+        Assertions.assertTrue(updateStatement.contains("\"name\""));
+        Assertions.assertTrue(updateStatement.contains("\"age\""));
+        Assertions.assertTrue(updateStatement.contains("\"id\""));
+    }
+
+    @Test
+    public void testDeleteStatement() {
+        String[] conditionFields = {"id"};
+        String deleteStatement =
+                DIALECT.getDeleteStatement("test_db", "test_table", conditionFields);
+
+        Assertions.assertNotNull(deleteStatement);
+        Assertions.assertTrue(deleteStatement.contains("DELETE FROM"));
+        Assertions.assertTrue(deleteStatement.contains("\"test_table\""));
+        Assertions.assertTrue(deleteStatement.contains("\"id\""));
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverterTest.java b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverterTest.java
new file mode 100644
index 0000000000..cf7e1c7c60
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-jdbc/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/yashandb/YashanDbTypeConverterTest.java
@@ -0,0 +1,786 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb;
+
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.PhysicalColumn;
+import org.apache.seatunnel.api.table.converter.BasicTypeDefine;
+import org.apache.seatunnel.api.table.type.ArrayType;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.DecimalType;
+import org.apache.seatunnel.api.table.type.LocalTimeType;
+import org.apache.seatunnel.api.table.type.MapType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.api.table.type.VectorType;
+import org.apache.seatunnel.common.exception.SeaTunnelRuntimeException;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.BYTES_4GB;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_JSON_LENGTH;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_PRECISION;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_RAW_LENGTH;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_ROWID_LENGTH;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_SCALE;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_TIMESTAMP_SCALE;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_UROWID_LENGTH;
+import static org.apache.seatunnel.connectors.seatunnel.jdbc.internal.dialect.yashandb.YashanDbTypeConverter.MAX_VARCHAR_LENGTH;
+
+public class YashanDbTypeConverterTest {
+
+    private static final YashanDbTypeConverter INSTANCE = new YashanDbTypeConverter();
+
+    // ============================ convert() tests ============================
+
+    @Test
+    public void testConvertUnsupported() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("aaa").dataType("aaa").build();
+        try {
+            INSTANCE.convert(typeDefine);
+            Assertions.fail();
+        } catch (SeaTunnelRuntimeException e) {
+            // expected
+        } catch (Throwable e) {
+            Assertions.fail();
+        }
+    }
+
+    @Test
+    public void testConvertIntegerTypes() {
+        // TINYINT -> BYTE_TYPE
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("TINYINT")
+                        .dataType("TINYINT")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals("test", column.getName());
+        Assertions.assertEquals(BasicType.BYTE_TYPE, column.getDataType());
+
+        // SMALLINT -> SHORT_TYPE
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("SMALLINT")
+                        .dataType("SMALLINT")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.SHORT_TYPE, column.getDataType());
+
+        // INT -> INT_TYPE
+        typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("INT").dataType("INT").build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.INT_TYPE, column.getDataType());
+
+        // INTEGER -> INT_TYPE
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("INTEGER")
+                        .dataType("INTEGER")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.INT_TYPE, column.getDataType());
+
+        // BIGINT -> LONG_TYPE
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("BIGINT")
+                        .dataType("BIGINT")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.LONG_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertNumber() {
+        // NUMBER without precision -> DecimalType(38, 18)
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NUMBER")
+                        .dataType("NUMBER")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(new DecimalType(38, 18), column.getDataType());
+        Assertions.assertEquals(38L, column.getColumnLength());
+        Assertions.assertEquals(18, column.getScale());
+
+        // NUMBER(10, 2) -> DecimalType(10, 2)
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NUMBER(10,2)")
+                        .dataType("NUMBER")
+                        .precision(10L)
+                        .scale(2)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(new DecimalType(10, 2), column.getDataType());
+        Assertions.assertEquals(10L, column.getColumnLength());
+        Assertions.assertEquals(2, column.getScale());
+
+        // NUMBER(38, 0) -> DecimalType(38, 0)
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NUMBER(38,0)")
+                        .dataType("NUMBER")
+                        .precision(38L)
+                        .scale(0)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(new DecimalType(38, 0), column.getDataType());
+
+        // NUMBER with precision > 38 should still use provided precision (convert does not cap)
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NUMBER(39,0)")
+                        .dataType("NUMBER")
+                        .precision(39L)
+                        .scale(0)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(new DecimalType(39, 0), column.getDataType());
+    }
+
+    @Test
+    public void testConvertFloatDouble() {
+        // FLOAT -> FLOAT_TYPE
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("FLOAT")
+                        .dataType("FLOAT")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.FLOAT_TYPE, column.getDataType());
+
+        // DOUBLE -> DOUBLE_TYPE
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("DOUBLE")
+                        .dataType("DOUBLE")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.DOUBLE_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertBoolean() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("BOOLEAN")
+                        .dataType("BOOLEAN")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.BOOLEAN_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertBit() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("BIT").dataType("BIT").build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.LONG_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertCharTypes() {
+        // CHAR(10) -> STRING with columnLength = 10 * 4
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("CHAR(10)")
+                        .dataType("CHAR")
+                        .length(10L)
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(40L, column.getColumnLength());
+
+        // VARCHAR(100) -> STRING with columnLength = 100 * 4
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("VARCHAR(100)")
+                        .dataType("VARCHAR")
+                        .length(100L)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(400L, column.getColumnLength());
+
+        // NCHAR(10) -> STRING with columnLength = 10 * 2
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NCHAR(10)")
+                        .dataType("NCHAR")
+                        .length(10L)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(20L, column.getColumnLength());
+
+        // NVARCHAR(100) -> STRING with columnLength = 100 * 2
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NVARCHAR(100)")
+                        .dataType("NVARCHAR")
+                        .length(100L)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(200L, column.getColumnLength());
+    }
+
+    @Test
+    public void testConvertRowidTypes() {
+        // ROWID -> STRING with columnLength = 18
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("ROWID")
+                        .dataType("ROWID")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(MAX_ROWID_LENGTH, column.getColumnLength());
+
+        // UROWID without length -> STRING with columnLength = MAX_UROWID_LENGTH
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("UROWID")
+                        .dataType("UROWID")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(MAX_UROWID_LENGTH, column.getColumnLength());
+
+        // UROWID(2000) -> STRING with columnLength = 2000
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("UROWID(2000)")
+                        .dataType("UROWID")
+                        .length(2000L)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(2000L, column.getColumnLength());
+    }
+
+    @Test
+    public void testConvertLobTypes() {
+        // CLOB -> STRING with columnLength = 4GB-1
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("CLOB").dataType("CLOB").build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(BYTES_4GB - 1, column.getColumnLength());
+
+        // NCLOB -> STRING with columnLength = 4GB-1
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("NCLOB")
+                        .dataType("NCLOB")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(BYTES_4GB - 1, column.getColumnLength());
+
+        // BLOB -> BYTE_ARRAY
+        typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("BLOB").dataType("BLOB").build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(PrimitiveByteArrayType.INSTANCE, column.getDataType());
+
+        // RAW without length -> BYTE_ARRAY with columnLength = MAX_RAW_LENGTH
+        typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("RAW").dataType("RAW").build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(PrimitiveByteArrayType.INSTANCE, column.getDataType());
+        Assertions.assertEquals(MAX_RAW_LENGTH, column.getColumnLength());
+
+        // RAW(100) -> BYTE_ARRAY with columnLength = 100
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("RAW(100)")
+                        .dataType("RAW")
+                        .length(100L)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(PrimitiveByteArrayType.INSTANCE, column.getDataType());
+        Assertions.assertEquals(100L, column.getColumnLength());
+    }
+
+    @Test
+    public void testConvertDateTimeTypes() {
+        // DATE -> LOCAL_DATE_TIME
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("DATE").dataType("DATE").build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_DATE_TIME_TYPE, column.getDataType());
+
+        // TIME -> LOCAL_TIME
+        typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("TIME").dataType("TIME").build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_TIME_TYPE, column.getDataType());
+
+        // TIMESTAMP -> LOCAL_DATE_TIME with default scale 6
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("TIMESTAMP")
+                        .dataType("TIMESTAMP")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_DATE_TIME_TYPE, column.getDataType());
+        Assertions.assertEquals(6, column.getScale());
+
+        // TIMESTAMP(3) -> LOCAL_DATE_TIME with scale 3
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("TIMESTAMP(3)")
+                        .dataType("TIMESTAMP")
+                        .scale(3)
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_DATE_TIME_TYPE, column.getDataType());
+        Assertions.assertEquals(3, column.getScale());
+
+        // TIMESTAMP WITH TIME ZONE -> LOCAL_DATE_TIME
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("TIMESTAMP WITH TIME ZONE")
+                        .dataType("TIMESTAMP WITH TIME ZONE")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_DATE_TIME_TYPE, column.getDataType());
+
+        // TIMESTAMP WITH LOCAL TIME ZONE -> LOCAL_DATE_TIME
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("TIMESTAMP WITH LOCAL TIME ZONE")
+                        .dataType("TIMESTAMP WITH LOCAL TIME ZONE")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(LocalTimeType.LOCAL_DATE_TIME_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertIntervalTypes() {
+        // INTERVAL YEAR TO MONTH -> STRING
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("INTERVAL YEAR TO MONTH")
+                        .dataType("INTERVAL YEAR TO MONTH")
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+
+        // INTERVAL DAY TO SECOND -> STRING
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("INTERVAL DAY TO SECOND")
+                        .dataType("INTERVAL DAY TO SECOND")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+    }
+
+    @Test
+    public void testConvertJsonType() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder().name("test").columnType("JSON").dataType("JSON").build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals((long) MAX_JSON_LENGTH, column.getColumnLength());
+    }
+
+    @Test
+    public void testConvertXmlType() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("XMLTYPE")
+                        .dataType("XMLTYPE")
+                        .length(1000L)
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+        Assertions.assertEquals(1000L, column.getColumnLength());
+    }
+
+    @Test
+    public void testConvertVectorType() {
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("VECTOR(3)")
+                        .dataType("VECTOR")
+                        .scale(3)
+                        .length(3L)
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(VectorType.VECTOR_FLOAT_TYPE, column.getDataType());
+        Assertions.assertEquals(3, column.getScale());
+    }
+
+    // ============================ reconvert() tests ============================
+
+    @Test
+    public void testReconvertUnsupported() {
+        Column column =
+                PhysicalColumn.of(
+                        "test",
+                        new MapType<>(BasicType.STRING_TYPE, BasicType.STRING_TYPE),
+                        (Long) null,
+                        true,
+                        null,
+                        null);
+        try {
+            INSTANCE.reconvert(column);
+            Assertions.fail();
+        } catch (Exception e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void testReconvertBoolean() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.BOOLEAN_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("BOOLEAN", typeDefine.getColumnType());
+        Assertions.assertEquals("BOOLEAN", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertByteTypes() {
+        // TINYINT
+        Column column =
+                PhysicalColumn.of("test", BasicType.BYTE_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TINYINT", typeDefine.getColumnType());
+        Assertions.assertEquals("TINYINT", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertShort() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.SHORT_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("SMALLINT", typeDefine.getColumnType());
+        Assertions.assertEquals("SMALLINT", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertInt() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.INT_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("INT", typeDefine.getColumnType());
+        Assertions.assertEquals("INT", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertLong() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.LONG_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("BIGINT", typeDefine.getColumnType());
+        Assertions.assertEquals("BIGINT", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertFloat() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.FLOAT_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("FLOAT", typeDefine.getColumnType());
+        Assertions.assertEquals("FLOAT", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertDouble() {
+        Column column =
+                PhysicalColumn.of("test", BasicType.DOUBLE_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("DOUBLE", typeDefine.getColumnType());
+        Assertions.assertEquals("DOUBLE", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertDecimal() {
+        // Default decimal(38, 18)
+        Column column =
+                PhysicalColumn.of("test", new DecimalType(38, 18), (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("NUMBER(38,18)", typeDefine.getColumnType());
+        Assertions.assertEquals("NUMBER", typeDefine.getDataType());
+        Assertions.assertEquals(38L, typeDefine.getPrecision());
+        Assertions.assertEquals(18, typeDefine.getScale());
+
+        // Specific decimal(10, 2)
+        column = PhysicalColumn.of("test", new DecimalType(10, 2), (Long) null, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("NUMBER(10,2)", typeDefine.getColumnType());
+        Assertions.assertEquals(10L, typeDefine.getPrecision());
+        Assertions.assertEquals(2, typeDefine.getScale());
+
+        // Decimal with precision > MAX_PRECISION -> capped at 38
+        column = PhysicalColumn.of("test", new DecimalType(50, 20), (Long) null, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(MAX_PRECISION, typeDefine.getPrecision());
+
+        // Decimal with negative precision -> uses default
+        column = PhysicalColumn.of("test", new DecimalType(-1, 2), (Long) null, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(38L, typeDefine.getPrecision());
+        Assertions.assertEquals(18, typeDefine.getScale());
+
+        // Decimal with negative scale -> capped at 0
+        column = PhysicalColumn.of("test", new DecimalType(10, -5), (Long) null, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(10L, typeDefine.getPrecision());
+        Assertions.assertEquals(0, typeDefine.getScale());
+
+        // Decimal with scale > MAX_SCALE -> capped at MAX_SCALE
+        column = PhysicalColumn.of("test", new DecimalType(10, 200), (Long) null, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(MAX_SCALE, typeDefine.getScale());
+    }
+
+    @Test
+    public void testReconvertBytes() {
+        // BYTES -> BLOB always
+        Column column =
+                PhysicalColumn.of(
+                        "test", PrimitiveByteArrayType.INSTANCE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("BLOB", typeDefine.getColumnType());
+        Assertions.assertEquals("BLOB", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertString() {
+        // Null length -> VARCHAR(MAX_VARCHAR_LENGTH)
+        Column column =
+                PhysicalColumn.of("test", BasicType.STRING_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(
+                String.format("VARCHAR(%s)", MAX_VARCHAR_LENGTH), typeDefine.getColumnType());
+
+        // Length 0 -> VARCHAR(MAX_VARCHAR_LENGTH)
+        column = PhysicalColumn.of("test", BasicType.STRING_TYPE, 0L, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(
+                String.format("VARCHAR(%s)", MAX_VARCHAR_LENGTH), typeDefine.getColumnType());
+
+        // Length within VARCHAR range
+        column = PhysicalColumn.of("test", BasicType.STRING_TYPE, 1000L, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("VARCHAR(1000)", typeDefine.getColumnType());
+
+        // Length at MAX_VARCHAR_LENGTH boundary
+        column =
+                PhysicalColumn.of(
+                        "test", BasicType.STRING_TYPE, MAX_VARCHAR_LENGTH, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(
+                String.format("VARCHAR(%s)", MAX_VARCHAR_LENGTH), typeDefine.getColumnType());
+
+        // Length exceeding MAX_VARCHAR_LENGTH -> CLOB
+        column =
+                PhysicalColumn.of(
+                        "test", BasicType.STRING_TYPE, MAX_VARCHAR_LENGTH + 1, true, null, null);
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("CLOB", typeDefine.getColumnType());
+    }
+
+    @Test
+    public void testReconvertDate() {
+        Column column =
+                PhysicalColumn.of(
+                        "test", LocalTimeType.LOCAL_DATE_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("DATE", typeDefine.getColumnType());
+        Assertions.assertEquals("DATE", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertTime() {
+        Column column =
+                PhysicalColumn.of(
+                        "test", LocalTimeType.LOCAL_TIME_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TIME", typeDefine.getColumnType());
+        Assertions.assertEquals("TIME", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertTimestamp() {
+        // TIMESTAMP without scale -> TIMESTAMP
+        Column column =
+                PhysicalColumn.of(
+                        "test", LocalTimeType.LOCAL_DATE_TIME_TYPE, (Long) null, true, null, null);
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TIMESTAMP", typeDefine.getColumnType());
+        Assertions.assertEquals("TIMESTAMP", typeDefine.getDataType());
+
+        // TIMESTAMP(3) -> TIMESTAMP(3)
+        column =
+                PhysicalColumn.of("test", LocalTimeType.LOCAL_DATE_TIME_TYPE, 3L, true, null, null);
+        column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE)
+                        .scale(3)
+                        .nullable(true)
+                        .build();
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TIMESTAMP(3)", typeDefine.getColumnType());
+        Assertions.assertEquals(3, typeDefine.getScale());
+
+        // TIMESTAMP with scale > MAX_TIMESTAMP_SCALE -> capped
+        column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE)
+                        .scale(MAX_TIMESTAMP_SCALE + 5)
+                        .nullable(true)
+                        .build();
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals(
+                String.format("TIMESTAMP(%s)", MAX_TIMESTAMP_SCALE), typeDefine.getColumnType());
+        Assertions.assertEquals(MAX_TIMESTAMP_SCALE, typeDefine.getScale());
+    }
+
+    @Test
+    public void testReconvertTimestampTz() {
+        // TIMESTAMP_TZ without scale -> TIMESTAMP WITH TIME ZONE
+        Column column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(LocalTimeType.OFFSET_DATE_TIME_TYPE)
+                        .nullable(true)
+                        .build();
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TIMESTAMP WITH TIME ZONE", typeDefine.getColumnType());
+
+        // TIMESTAMP_TZ(3) -> TIMESTAMP(3) WITH TIME ZONE
+        column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(LocalTimeType.OFFSET_DATE_TIME_TYPE)
+                        .scale(3)
+                        .nullable(true)
+                        .build();
+        typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("TIMESTAMP(3) WITH TIME ZONE", typeDefine.getColumnType());
+        Assertions.assertEquals(3, typeDefine.getScale());
+    }
+
+    @Test
+    public void testReconvertVectorTypes() {
+        // FLOAT_VECTOR -> VECTOR(n)
+        Column column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(VectorType.VECTOR_FLOAT_TYPE)
+                        .scale(3)
+                        .nullable(true)
+                        .build();
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("VECTOR(3)", typeDefine.getColumnType());
+        Assertions.assertEquals("VECTOR", typeDefine.getDataType());
+    }
+
+    @Test
+    public void testReconvertArrayToVector() {
+        // ARRAY<INT> -> VECTOR
+        Column column =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(ArrayType.INT_ARRAY_TYPE)
+                        .columnLength(10L)
+                        .nullable(true)
+                        .build();
+        BasicTypeDefine<?> typeDefine = INSTANCE.reconvert(column);
+        Assertions.assertEquals("VECTOR(10)", typeDefine.getColumnType());
+        Assertions.assertEquals("VECTOR", typeDefine.getDataType());
+
+        // ARRAY<STRING> -> unsupported
+        Column stringArrayColumn =
+                PhysicalColumn.builder()
+                        .name("test")
+                        .dataType(ArrayType.STRING_ARRAY_TYPE)
+                        .columnLength(10L)
+                        .nullable(true)
+                        .build();
+        try {
+            INSTANCE.reconvert(stringArrayColumn);
+            Assertions.fail();
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void testConvertCaseInsensitive() {
+        // lowercase type names should work
+        BasicTypeDefine<Object> typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("varchar")
+                        .dataType("varchar")
+                        .length(50L)
+                        .build();
+        Column column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.STRING_TYPE, column.getDataType());
+
+        typeDefine =
+                BasicTypeDefine.builder()
+                        .name("test")
+                        .columnType("bigint")
+                        .dataType("bigint")
+                        .build();
+        column = INSTANCE.convert(typeDefine);
+        Assertions.assertEquals(BasicType.LONG_TYPE, column.getDataType());
+    }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/pom.xml b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/pom.xml
index 9fb8c4f055..c8b636de0a 100644
--- a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/pom.xml
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/pom.xml
@@ -121,6 +121,11 @@
             <artifactId>trino-jdbc</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.yashandb</groupId>
+            <artifactId>yashandb-jdbc</artifactId>
+            <scope>test</scope>
+        </dependency>
 
     </dependencies>
 
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/JdbcYashanDbIT.java b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/JdbcYashanDbIT.java
new file mode 100644
index 0000000000..c79e909f58
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/java/org/apache/seatunnel/connectors/seatunnel/jdbc/JdbcYashanDbIT.java
@@ -0,0 +1,222 @@
+/*
+ * 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.seatunnel.connectors.seatunnel.jdbc;
+
+import org.apache.seatunnel.shade.com.google.common.collect.Lists;
+import org.apache.seatunnel.shade.org.apache.commons.lang3.tuple.Pair;
+
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.e2e.common.container.TestContainer;
+
+import org.testcontainers.containers.Container;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.utility.DockerLoggerFactory;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.math.BigDecimal;
+import java.sql.Date;
+import java.sql.Timestamp;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+public class JdbcYashanDbIT extends AbstractJdbcIT {
+
+    private static final String YASHANDB_IMAGE = "yasdb/yashandb:23.4.7.100";
+    private static final String YASHANDB_CONTAINER_HOST = "e2e_yashandb";
+    private static final String YASHANDB_SCHEMA = "SYS";
+    private static final String YASHANDB_DATABASE = "SYS";
+    private static final String YASHANDB_SOURCE = "E2E_TABLE_SOURCE";
+    private static final String YASHANDB_SINK = "E2E_TABLE_SINK";
+    private static final String YASHANDB_USERNAME = "SYS";
+    private static final String YASHANDB_PASSWORD = "Cod-2022";
+    private static final int YASHANDB_PORT = 1688;
+    private static final String YASHANDB_URL = "jdbc:yasdb://" + HOST + ":%s/%s";
+
+    private static final String DRIVER_CLASS = "com.yashandb.jdbc.Driver";
+
+    private static final List<String> CONFIG_FILE =
+            Lists.newArrayList(
+                    "/jdbc_yashandb_source_and_sink.conf", "/jdbc_yashandb_source_to_sink.conf");
+
+    private static final String CREATE_SQL =
+            "CREATE TABLE %s (\n"
+                    + "    YAS_TINYINT       TINYINT,\n"
+                    + "    YAS_SMALLINT      SMALLINT,\n"
+                    + "    YAS_INT           INT,\n"
+                    + "    YAS_BIGINT        BIGINT,\n"
+                    + "    YAS_FLOAT         FLOAT,\n"
+                    + "    YAS_DOUBLE        DOUBLE,\n"
+                    + "    YAS_NUMBER        NUMBER(10, 2),\n"
+                    + "    YAS_CHAR          CHAR(20),\n"
+                    + "    YAS_VARCHAR       VARCHAR(200),\n"
+                    + "    YAS_CLOB          CLOB,\n"
+                    + "    YAS_DATE          DATE,\n"
+                    + "    YAS_TIMESTAMP     TIMESTAMP,\n"
+                    + "    YAS_BOOLEAN       BOOLEAN,\n"
+                    + "    PRIMARY KEY(YAS_INT)\n"
+                    + ")";
+
+    private static final String[] fieldNames =
+            new String[] {
+                "YAS_TINYINT",
+                "YAS_SMALLINT",
+                "YAS_INT",
+                "YAS_BIGINT",
+                "YAS_FLOAT",
+                "YAS_DOUBLE",
+                "YAS_NUMBER",
+                "YAS_CHAR",
+                "YAS_VARCHAR",
+                "YAS_CLOB",
+                "YAS_DATE",
+                "YAS_TIMESTAMP",
+                "YAS_BOOLEAN"
+            };
+
+    @Override
+    JdbcCase getJdbcCase() {
+        String jdbcUrl = String.format(YASHANDB_URL, YASHANDB_PORT, YASHANDB_DATABASE);
+        Pair<String[], List<SeaTunnelRow>> testDataSet = initTestData();
+        String[] fieldNames = testDataSet.getKey();
+
+        String insertSql = insertTable(YASHANDB_SCHEMA, YASHANDB_SOURCE, fieldNames);
+
+        return JdbcCase.builder()
+                .dockerImage(YASHANDB_IMAGE)
+                .networkAliases(YASHANDB_CONTAINER_HOST)
+                .driverClass(DRIVER_CLASS)
+                .host(HOST)
+                .port(YASHANDB_PORT)
+                .localPort(YASHANDB_PORT)
+                .jdbcTemplate(YASHANDB_URL)
+                .jdbcUrl(jdbcUrl)
+                .userName(YASHANDB_USERNAME)
+                .password(YASHANDB_PASSWORD)
+                .schema(YASHANDB_SCHEMA)
+                .database(YASHANDB_DATABASE)
+                .sourceTable(YASHANDB_SOURCE)
+                .sinkTable(YASHANDB_SINK)
+                .createSql(CREATE_SQL)
+                .configFile(CONFIG_FILE)
+                .insertSql(insertSql)
+                .testData(testDataSet)
+                .build();
+    }
+
+    @Override
+    void checkResult(String executeKey, TestContainer container, Container.ExecResult execResult) {
+        defaultCompare(executeKey, fieldNames, "YAS_INT");
+    }
+
+    @Override
+    String driverUrl() {
+        return "https://repo1.maven.org/maven2/com/yashandb/yashandb-jdbc/1.9.24/yashandb-jdbc-1.9.24.jar";
+    }
+
+    @Override
+    Pair<String[], List<SeaTunnelRow>> initTestData() {
+        List<SeaTunnelRow> rows = new ArrayList<>();
+        LocalDate baseDate = LocalDate.of(2024, 1, 1);
+        LocalDateTime baseDateTime = LocalDateTime.of(2024, 1, 1, 9, 0, 0);
+        for (int i = 0; i < 100; i++) {
+            LocalDate rowDate = baseDate.plusDays(i);
+            LocalDateTime rowDateTime = baseDateTime.plusSeconds(i);
+            SeaTunnelRow row =
+                    new SeaTunnelRow(
+                            new Object[] {
+                                (byte) i,
+                                (short) i,
+                                i,
+                                (long) i,
+                                1.1f,
+                                1.1d,
+                                BigDecimal.valueOf(i, 2),
+                                String.format("char_%s", i),
+                                String.format("varchar_%s", i),
+                                String.format("clob_%s", i),
+                                Date.valueOf(rowDate),
+                                Timestamp.valueOf(rowDateTime),
+                                i % 2 == 0
+                            });
+            rows.add(row);
+        }
+
+        return Pair.of(fieldNames, rows);
+    }
+
+    @Override
+    protected void beforeStartUP() {
+        // YashanDB port opens well before the database is fully deployed (~156s).
+        // Wait for the init success message in container logs before proceeding.
+        long deadline = System.currentTimeMillis() + Duration.ofMinutes(5).toMillis();
+        while (System.currentTimeMillis() < deadline) {
+            String logs = dbServer.getLogs();
+            if (logs.contains("yashandb init success")) {
+                log.info("YashanDB initialization completed");
+                return;
+            }
+            try {
+                Thread.sleep(5000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                return;
+            }
+        }
+        throw new RuntimeException("YashanDB did not finish initialization within 5 minutes");
+    }
+
+    @Override
+    protected GenericContainer<?> initContainer() {
+        GenericContainer<?> container =
+                new GenericContainer<>(YASHANDB_IMAGE)
+                        .withNetwork(NETWORK)
+                        .withNetworkAliases(YASHANDB_CONTAINER_HOST)
+                        .withEnv("SYS_PASSWD", YASHANDB_PASSWORD)
+                        .waitingFor(
+                                Wait.forListeningPort().withStartupTimeout(Duration.ofMinutes(5)))
+                        .withLogConsumer(
+                                new Slf4jLogConsumer(
+                                        DockerLoggerFactory.getLogger(YASHANDB_IMAGE)));
+        container.setPortBindings(
+                Lists.newArrayList(String.format("%s:%s", YASHANDB_PORT, YASHANDB_PORT)));
+
+        return container;
+    }
+
+    @Override
+    public String quoteIdentifier(String field) {
+        return "\"" + field + "\"";
+    }
+
+    @Override
+    protected void clearTable(String database, String schema, String table) {
+        clearTable(schema, table);
+    }
+
+    @Override
+    protected String buildTableInfoWithSchema(String database, String schema, String table) {
+        return buildTableInfoWithSchema(schema, table);
+    }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_and_sink.conf b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_and_sink.conf
new file mode 100644
index 0000000000..7f50b36f61
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_and_sink.conf
@@ -0,0 +1,48 @@
+#
+# 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.
+#
+
+env {
+  execution.parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  jdbc {
+    url = "jdbc:yasdb://e2e_yashandb:1688/SYS"
+    driver = "com.yashandb.jdbc.Driver"
+    connection_check_timeout_sec = 100
+    user = "SYS"
+    password = "Cod-2022"
+    query = "select * from SYS.E2E_TABLE_SOURCE"
+  }
+}
+
+transform {
+}
+
+sink {
+  jdbc {
+    url = "jdbc:yasdb://e2e_yashandb:1688/SYS"
+    driver = "com.yashandb.jdbc.Driver"
+    user = "SYS"
+    password = "Cod-2022"
+    generate_sink_sql = true
+    primary_keys = ["YAS_INT"]
+    table = "SYS.E2E_TABLE_SINK"
+    database = "SYS"
+  }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_to_sink.conf b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_to_sink.conf
new file mode 100644
index 0000000000..1ccfc6cdf0
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-jdbc-e2e/connector-jdbc-e2e-part-7/src/test/resources/jdbc_yashandb_source_to_sink.conf
@@ -0,0 +1,47 @@
+#
+# 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.
+#
+
+env {
+  execution.parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  jdbc {
+    url = "jdbc:yasdb://e2e_yashandb:1688/SYS"
+    driver = "com.yashandb.jdbc.Driver"
+    connection_check_timeout_sec = 100
+    user = "SYS"
+    password = "Cod-2022"
+    query = "select * from SYS.E2E_TABLE_SOURCE"
+  }
+}
+
+transform {
+}
+
+sink {
+  jdbc {
+    url = "jdbc:yasdb://e2e_yashandb:1688/SYS"
+    driver = "com.yashandb.jdbc.Driver"
+    user = "SYS"
+    password = "Cod-2022"
+    query = """INSERT INTO SYS.E2E_TABLE_SINK
+             (YAS_TINYINT, YAS_SMALLINT, YAS_INT, YAS_BIGINT, YAS_FLOAT, YAS_DOUBLE, YAS_NUMBER, YAS_CHAR, YAS_VARCHAR, YAS_CLOB, YAS_DATE, YAS_TIMESTAMP, YAS_BOOLEAN)
+             VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"""
+  }
+}