Skip to content

Backport to branch(3) : Add alter column type tests for imported tables #3077

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Oct 21, 2025
Merged

Backport to branch(3) : Add alter column type tests for imported tables #3077

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
74e99e2
Empty commit [skip ci]
KodaiD Oct 20, 2025
ce68ac6
Resolve conflicts
KodaiD Oct 20, 2025
88af2ef
Fix tests
KodaiD Oct 20, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
195 changes: 195 additions & 0 deletions ...integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminImportTableIntegrationTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,9 +1,15 @@
package com.scalar.db.storage.jdbc;

import static org.assertj.core.api.Assertions.assertThat;

import com.scalar.db.api.DistributedStorageAdminImportTableIntegrationTestBase;
import com.scalar.db.api.TableMetadata;
import com.scalar.db.exception.storage.ExecutionException;
import com.scalar.db.io.DataType;
import java.sql.SQLException;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledIf;
Expand Down Expand Up @@ -39,16 +45,51 @@ protected List<TestData> createExistingDatabaseWithAllDataTypes() throws SQLExce
return testUtils.createExistingDatabaseWithAllDataTypes(getNamespace());
}

@Override
protected List<String> getIntCompatibleColumnNamesOnExistingDatabase(String table) {
return testUtils.getIntCompatibleColumnNamesOnExistingDatabase(table);
}

@Override
protected List<String> getFloatCompatibleColumnNamesOnExistingDatabase(String table) {
return testUtils.getFloatCompatibleColumnNamesOnExistingDatabase(table);
}

@Override
protected void dropNonImportableTable(String table) throws SQLException {
testUtils.dropTable(getNamespace(), table);
}

@SuppressWarnings("unused")
private boolean isOracle() {
return JdbcEnv.isOracle();
}

@SuppressWarnings("unused")
private boolean isSqlServer() {
return JdbcEnv.isSqlServer();
}

@SuppressWarnings("unused")
private boolean isDb2() {
return JdbcEnv.isDb2();
}

@SuppressWarnings("unused")
private boolean isSqlite() {
return JdbcEnv.isSqlite();
}

@SuppressWarnings("unused")
private boolean isColumnTypeConversionToTextNotFullySupported() {
return JdbcEnv.isDb2() || JdbcEnv.isSqlServer() || JdbcEnv.isOracle() || JdbcEnv.isSqlite();
}

@SuppressWarnings("unused")
private boolean isWideningColumnTypeConversionNotFullySupported() {
return JdbcEnv.isOracle() || JdbcEnv.isSqlite();
}

@Test
@Override
@DisabledIf("isSqlite")
Expand All @@ -63,4 +104,158 @@ public void importTable_ForUnsupportedDatabase_ShouldThrowUnsupportedOperationEx
throws ExecutionException {
super.importTable_ForUnsupportedDatabase_ShouldThrowUnsupportedOperationException();
}

@Test
@Override
@DisabledIf("isColumnTypeConversionToTextNotFullySupported")
public void
alterColumnType_AlterColumnTypeFromEachExistingDataTypeToText_ForImportedTable_ShouldAlterColumnTypesCorrectly()
throws Exception {
super
.alterColumnType_AlterColumnTypeFromEachExistingDataTypeToText_ForImportedTable_ShouldAlterColumnTypesCorrectly();
}

@Test
@EnabledIf("isSqlServer")
public void
alterColumnType_SqlServer_AlterColumnTypeFromEachExistingDataTypeToText_ForImportedTable_ShouldAlterColumnTypesCorrectly()
throws Exception {
// Arrange
admin.createNamespace(getNamespace(), getCreationOptions());
testDataList.addAll(createExistingDatabaseWithAllDataTypes());
for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
admin.importTable(
getNamespace(),
testData.getTableName(),
Collections.emptyMap(),
testData.getOverrideColumnsType());
}
}

for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
// Act
TableMetadata metadata = testData.getTableMetadata();
for (String column : metadata.getColumnNames()) {
if (!metadata.getPartitionKeyNames().contains(column)
&& !metadata.getClusteringKeyNames().contains(column)) {
if (Objects.equals(column, "col16")) {
// Conversion from IMAGE to VARCHAR(8000) is not supported in SQL Server engine
continue;
}
admin.alterColumnType(getNamespace(), testData.getTableName(), column, DataType.TEXT);
}
}

// Assert
TableMetadata newMetadata = admin.getTableMetadata(getNamespace(), testData.getTableName());
assertThat(newMetadata).isNotNull();
for (String column : metadata.getColumnNames()) {
if (!metadata.getPartitionKeyNames().contains(column)
&& !metadata.getClusteringKeyNames().contains(column)) {
if (Objects.equals(column, "col16")) {
continue;
}
assertThat(newMetadata.getColumnDataType(column)).isEqualTo(DataType.TEXT);
}
}
}
}
}

@Test
@EnabledIf("isDb2")
public void
alterColumnType_Db2_AlterColumnTypeFromEachExistingDataTypeToText_ForImportedTable_ShouldAlterColumnTypesCorrectly()
throws Exception {
// Arrange
admin.createNamespace(getNamespace(), getCreationOptions());
testDataList.addAll(createExistingDatabaseWithAllDataTypes());
for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
admin.importTable(
getNamespace(),
testData.getTableName(),
Collections.emptyMap(),
testData.getOverrideColumnsType());
}
}

for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
// Act
TableMetadata metadata = testData.getTableMetadata();
for (String column : metadata.getColumnNames()) {
if (!metadata.getPartitionKeyNames().contains(column)
&& !metadata.getClusteringKeyNames().contains(column)) {
if (metadata.getColumnDataType(column).equals(DataType.BLOB)) {
// Conversion from BLOB to TEXT is not supported in Db2 engine
continue;
}
admin.alterColumnType(getNamespace(), testData.getTableName(), column, DataType.TEXT);
}
}

// Assert
TableMetadata newMetadata = admin.getTableMetadata(getNamespace(), testData.getTableName());
assertThat(newMetadata).isNotNull();
for (String column : metadata.getColumnNames()) {
if (!metadata.getPartitionKeyNames().contains(column)
&& !metadata.getClusteringKeyNames().contains(column)) {
if (metadata.getColumnDataType(column).equals(DataType.BLOB)) {
continue;
}
assertThat(newMetadata.getColumnDataType(column)).isEqualTo(DataType.TEXT);
}
}
}
}
}

@Test
@Override
@DisabledIf("isWideningColumnTypeConversionNotFullySupported")
public void alterColumnType_WideningConversion_ForImportedTable_ShouldAlterProperly()
throws Exception {
super.alterColumnType_WideningConversion_ForImportedTable_ShouldAlterProperly();
}

@Test
@EnabledIf("isOracle")
public void alterColumnType_Oracle_WideningConversion_ForImportedTable_ShouldAlterProperly()
throws Exception {
// Arrange
admin.createNamespace(getNamespace(), getCreationOptions());
testDataList.addAll(createExistingDatabaseWithAllDataTypes());
for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
admin.importTable(
getNamespace(),
testData.getTableName(),
Collections.emptyMap(),
testData.getOverrideColumnsType());
}
}

for (TestData testData : testDataList) {
if (testData.isImportableTable()) {
// Act
for (String intCompatibleColumn :
getIntCompatibleColumnNamesOnExistingDatabase(testData.getTableName())) {
admin.alterColumnType(
getNamespace(), testData.getTableName(), intCompatibleColumn, DataType.BIGINT);
}
// Conversion from FLOAT TO DOUBLE is not supported in Oracle engine

// Assert
TableMetadata metadata = admin.getTableMetadata(getNamespace(), testData.getTableName());
assertThat(metadata).isNotNull();
for (String intCompatibleColumn :
getIntCompatibleColumnNamesOnExistingDatabase(testData.getTableName())) {
assertThat(metadata.getColumnDataType(intCompatibleColumn)).isEqualTo(DataType.BIGINT);
}
}
}
}
}
121 changes: 121 additions & 0 deletions core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminImportTestUtils.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -148,6 +148,38 @@ public void createExistingDatabase(String namespace) throws SQLException {
execute(rdbEngine.createNamespaceSqls(rdbEngine.enclose(namespace)));
}

public List<String> getIntCompatibleColumnNamesOnExistingDatabase(String table) {
if (JdbcTestUtils.isMysql(rdbEngine)) {
return getIntCompatibleColumnNamesOnExistingMysqlDatabase(table);
} else if (JdbcTestUtils.isPostgresql(rdbEngine)) {
return getIntCompatibleColumnNamesOnExistingPostgresDatabase(table);
} else if (JdbcTestUtils.isOracle(rdbEngine)) {
return getIntCompatibleColumnNamesOnExistingOracleDatabase(table);
} else if (JdbcTestUtils.isSqlServer(rdbEngine)) {
return getIntCompatibleColumnNamesOnExistingSqlServerDatabase(table);
} else if (JdbcTestUtils.isDb2(rdbEngine)) {
return getIntCompatibleColumnNamesOnExistingDb2Database(table);
} else {
throw new AssertionError("Unsupported database engine: " + rdbEngine);
}
}

public List<String> getFloatCompatibleColumnNamesOnExistingDatabase(String table) {
if (JdbcTestUtils.isMysql(rdbEngine)) {
return getFloatCompatibleColumnNamesOnExistingMysqlDatabase(table);
} else if (JdbcTestUtils.isPostgresql(rdbEngine)) {
return getFloatCompatibleColumnNamesOnExistingPostgresDatabase(table);
} else if (JdbcTestUtils.isOracle(rdbEngine)) {
return getFloatCompatibleColumnNamesOnExistingOracleDatabase(table);
} else if (JdbcTestUtils.isSqlServer(rdbEngine)) {
return getFloatCompatibleColumnNamesOnExistingSqlServerDatabase(table);
} else if (JdbcTestUtils.isDb2(rdbEngine)) {
return getFloatCompatibleColumnNamesOnExistingDb2Database(table);
} else {
throw new AssertionError("Unsupported database engine: " + rdbEngine);
}
}

public void dropTable(String namespace, String table) throws SQLException {
String dropTable = "DROP TABLE " + rdbEngine.encloseFullTableName(namespace, table);
execute(dropTable);
Expand Down Expand Up @@ -616,6 +648,22 @@ private List<TestData> createExistingMysqlDatabaseWithAllDataTypes(String namesp
return ImmutableList.copyOf(data);
}

private ImmutableList<String> getIntCompatibleColumnNamesOnExistingMysqlDatabase(String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col02", "col04", "col05", "col06");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private ImmutableList<String> getFloatCompatibleColumnNamesOnExistingMysqlDatabase(String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col08");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private List<TestData> createExistingPostgresDatabaseWithAllDataTypes(String namespace)
throws SQLException {
List<JdbcTestData> data = new ArrayList<>();
Expand Down Expand Up @@ -650,6 +698,24 @@ private List<TestData> createExistingPostgresDatabaseWithAllDataTypes(String nam
return ImmutableList.copyOf(data);
}

private ImmutableList<String> getIntCompatibleColumnNamesOnExistingPostgresDatabase(
String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col02", "col03");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private ImmutableList<String> getFloatCompatibleColumnNamesOnExistingPostgresDatabase(
String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col05");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private List<TestData> createExistingOracleDatabaseWithAllDataTypes(String namespace)
throws SQLException {
List<JdbcTestData> data = new ArrayList<>();
Expand Down Expand Up @@ -701,6 +767,27 @@ private List<TestData> createExistingOracleDatabaseWithAllDataTypes(String names
return ImmutableList.copyOf(data);
}

private ImmutableList<String> getIntCompatibleColumnNamesOnExistingOracleDatabase(String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of();
} else if (table.equals(SUPPORTED_TABLE_NAME + "_long_raw")) {
return ImmutableList.of();
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private ImmutableList<String> getFloatCompatibleColumnNamesOnExistingOracleDatabase(
String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col04");
} else if (table.equals(SUPPORTED_TABLE_NAME + "_long_raw")) {
return ImmutableList.of();
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private List<TestData> createExistingSqlServerDatabaseWithAllDataTypes(String namespace)
throws SQLException {
List<JdbcTestData> data = new ArrayList<>();
Expand All @@ -727,6 +814,24 @@ private List<TestData> createExistingSqlServerDatabaseWithAllDataTypes(String na
return ImmutableList.copyOf(data);
}

private ImmutableList<String> getIntCompatibleColumnNamesOnExistingSqlServerDatabase(
String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col02", "col03", "col04");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private ImmutableList<String> getFloatCompatibleColumnNamesOnExistingSqlServerDatabase(
String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col06");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private List<TestData> createExistingDb2DatabaseWithAllDataTypes(String namespace)
throws SQLException {
List<JdbcTestData> data = new ArrayList<>();
Expand All @@ -753,6 +858,22 @@ private List<TestData> createExistingDb2DatabaseWithAllDataTypes(String namespac
return ImmutableList.copyOf(data);
}

private ImmutableList<String> getIntCompatibleColumnNamesOnExistingDb2Database(String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col01", "col02");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private ImmutableList<String> getFloatCompatibleColumnNamesOnExistingDb2Database(String table) {
if (table.equals(SUPPORTED_TABLE_NAME)) {
return ImmutableList.of("col04", "col05");
} else {
throw new IllegalArgumentException("Table does not exist: " + table);
}
}

private void executeCreateTableSql(List<JdbcTestData> data) throws SQLException {
String[] sqls = data.stream().map(JdbcTestData::getCreateTableSql).toArray(String[]::new);
execute(sqls);
Expand Down
Loading