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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"""
+ }
+}