diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitAdminIntegrationTestWithJdbcDatabase.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitAdminIntegrationTestWithJdbcDatabase.java index c645dfd73f..f11acfa1a3 100644 --- a/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitAdminIntegrationTestWithJdbcDatabase.java +++ b/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitAdminIntegrationTestWithJdbcDatabase.java @@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.catchThrowable; import com.google.common.util.concurrent.Uninterruptibles; -import com.scalar.db.api.DistributedTransactionManager; import com.scalar.db.api.Insert; import com.scalar.db.api.InsertBuilder; import com.scalar.db.api.Result; @@ -233,8 +232,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp public void alterColumnType_Oracle_AlterColumnTypeFromEachExistingDataTypeToText_ShouldThrowUnsupportedOperationException() throws ExecutionException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -276,7 +274,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act Assert assertThatCode(() -> admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT)) @@ -311,8 +309,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp public void alterColumnType_Db2_AlterColumnTypeFromEachExistingDataTypeToText_ShouldAlterColumnTypesCorrectlyIfSupported() throws ExecutionException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -354,7 +351,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act Assert assertThatCode(() -> admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT)) @@ -418,7 +415,7 @@ public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() @EnabledIf("isOracle") public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorrectly() throws ExecutionException, TransactionException { - try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -442,7 +439,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .clusteringKey(Key.ofInt("c2", 2)) .intValue("c3", expectedColumn3Value) .floatValue("c4", expectedColumn4Value); - transactionalInsert(manager, insert.build()); + transactionalInsert(insert.build()); // Act admin.alterColumnType(namespace1, TABLE4, "c3", DataType.BIGINT); @@ -471,7 +468,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .table(TABLE4) .partitionKey(Key.ofInt("c1", 1)) .build(); - List results = transactionalScan(manager, scan); + List results = transactionalScan(scan); assertThat(results).hasSize(1); Result result = results.get(0); assertThat(result.getBigInt("c3")).isEqualTo(expectedColumn3Value); diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/SingleCrudOperationTransactionAdminIntegrationTestWithJdbcDatabase.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/SingleCrudOperationTransactionAdminIntegrationTestWithJdbcDatabase.java index a995a22f9b..ed7a4fa429 100644 --- a/core/src/integration-test/java/com/scalar/db/storage/jdbc/SingleCrudOperationTransactionAdminIntegrationTestWithJdbcDatabase.java +++ b/core/src/integration-test/java/com/scalar/db/storage/jdbc/SingleCrudOperationTransactionAdminIntegrationTestWithJdbcDatabase.java @@ -217,8 +217,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp public void alterColumnType_Oracle_AlterColumnTypeFromEachExistingDataTypeToText_ShouldThrowUnsupportedOperationException() throws ExecutionException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -260,7 +259,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act Assert assertThatCode(() -> admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT)) @@ -402,7 +401,7 @@ public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() @EnabledIf("isOracle") public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorrectly() throws ExecutionException, TransactionException { - try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -426,7 +425,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .clusteringKey(Key.ofInt("c2", 2)) .intValue("c3", expectedColumn3Value) .floatValue("c4", expectedColumn4Value); - transactionalInsert(manager, insert.build()); + transactionalInsert(insert.build()); // Act admin.alterColumnType(namespace1, TABLE4, "c3", DataType.BIGINT); @@ -455,7 +454,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .table(TABLE4) .partitionKey(Key.ofInt("c1", 1)) .build(); - List results = transactionalScan(manager, scan); + List results = transactionalScan(scan); assertThat(results).hasSize(1); Result result = results.get(0); assertThat(result.getBigInt("c3")).isEqualTo(expectedColumn3Value); diff --git a/core/src/integration-test/java/com/scalar/db/transaction/jdbc/JdbcTransactionAdminIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/transaction/jdbc/JdbcTransactionAdminIntegrationTest.java index c3f81ff9ee..cb5f5c6bba 100644 --- a/core/src/integration-test/java/com/scalar/db/transaction/jdbc/JdbcTransactionAdminIntegrationTest.java +++ b/core/src/integration-test/java/com/scalar/db/transaction/jdbc/JdbcTransactionAdminIntegrationTest.java @@ -285,8 +285,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp public void alterColumnType_Oracle_AlterColumnTypeFromEachExistingDataTypeToText_ShouldThrowUnsupportedOperationException() throws ExecutionException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -328,7 +327,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act Assert assertThatCode(() -> admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT)) @@ -406,7 +405,7 @@ public void renameColumn_Db2_ForPrimaryOrIndexKeyColumn_ShouldThrowUnsupportedOp insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act Assert assertThatCode(() -> admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT)) @@ -470,7 +469,7 @@ public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() @EnabledIf("isOracle") public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorrectly() throws ExecutionException, TransactionException { - try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -494,7 +493,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .clusteringKey(Key.ofInt("c2", 2)) .intValue("c3", expectedColumn3Value) .floatValue("c4", expectedColumn4Value); - transactionalInsert(manager, insert.build()); + transactionalInsert(insert.build()); // Act admin.alterColumnType(namespace1, TABLE4, "c3", DataType.BIGINT); @@ -523,7 +522,7 @@ public void alterColumnType_Oracle_WideningConversion_ShouldAlterColumnTypesCorr .table(TABLE4) .partitionKey(Key.ofInt("c1", 1)) .build(); - List results = transactionalScan(manager, scan); + List results = transactionalScan(scan); assertThat(results).hasSize(1); Result result = results.get(0); assertThat(result.getBigInt("c3")).isEqualTo(expectedColumn3Value); @@ -563,19 +562,27 @@ protected boolean isIndexOnBlobColumnSupported() { } @Override - protected void transactionalInsert(DistributedTransactionManager manager, Insert insert) - throws TransactionException { - DistributedTransaction transaction = manager.start(); - transaction.insert(insert); - transaction.commit(); + protected void transactionalInsert(Insert insert) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + DistributedTransaction transaction = manager.start(); + transaction.insert(insert); + transaction.commit(); + } } @Override - protected List transactionalScan(DistributedTransactionManager manager, Scan scan) - throws TransactionException { - DistributedTransaction transaction = manager.start(); - List results = transaction.scan(scan); - transaction.commit(); - return results; + protected List transactionalScan(Scan scan) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + DistributedTransaction transaction = manager.start(); + List results = transaction.scan(scan); + transaction.commit(); + return results; + } } } diff --git a/integration-test/src/main/java/com/scalar/db/api/DistributedTransactionAdminIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/api/DistributedTransactionAdminIntegrationTestBase.java index 6f28f3fe85..137bbdee96 100644 --- a/integration-test/src/main/java/com/scalar/db/api/DistributedTransactionAdminIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/api/DistributedTransactionAdminIntegrationTestBase.java @@ -430,16 +430,20 @@ public void dropTable_IfExists_ForNonExistingTable_ShouldNotThrowAnyException() @Test public void truncateTable_ShouldTruncateProperly() throws ExecutionException, TransactionException { - DistributedTransactionManager manager = null; + // Use a separate table name to avoid hitting the stale cache, which can cause test failure when + // executing DMLs + String table = "table_for_truncate"; + try { // Arrange + Map options = getCreationOptions(); + admin.createTable(namespace1, table, TABLE_METADATA, true, options); Key partitionKey = Key.of(COL_NAME2, "aaa", COL_NAME1, 1); Key clusteringKey = Key.of(COL_NAME4, 2, COL_NAME3, "bbb"); - manager = transactionFactory.getTransactionManager(); - manager.put( - Put.newBuilder() + transactionalInsert( + Insert.newBuilder() .namespace(namespace1) - .table(TABLE1) + .table(table) .partitionKey(partitionKey) .clusteringKey(clusteringKey) .intValue(COL_NAME5, 3) @@ -452,21 +456,19 @@ public void truncateTable_ShouldTruncateProperly() .build()); // Act - admin.truncateTable(namespace1, TABLE1); + admin.truncateTable(namespace1, table); // Assert List results = - manager.scan( + transactionalScan( Scan.newBuilder() .namespace(namespace1) - .table(TABLE1) + .table(table) .partitionKey(partitionKey) .build()); assertThat(results).isEmpty(); } finally { - if (manager != null) { - manager.close(); - } + admin.dropTable(namespace1, table, true); } } @@ -514,7 +516,10 @@ public void tableExists_ShouldReturnCorrectResults() throws ExecutionException { @Test public void createIndex_ForAllDataTypesWithExistingData_ShouldCreateIndexesCorrectly() throws Exception { - DistributedTransactionManager transactionManager = null; + // Use a separate table name to avoid hitting the stale cache, which can cause test failure when + // executing DMLs + String table = "table_for_create_index"; + try { // Arrange Map options = getCreationOptions(); @@ -538,12 +543,11 @@ public void createIndex_ForAllDataTypesWithExistingData_ShouldCreateIndexesCorre metadataBuilder = metadataBuilder.addColumn(COL_NAME13, DataType.TIMESTAMP); } TableMetadata metadata = metadataBuilder.build(); - admin.createTable(namespace1, TABLE4, metadata, options); - transactionManager = transactionFactory.getTransactionManager(); + admin.createTable(namespace1, table, metadata, options); InsertBuilder.Buildable insert = Insert.newBuilder() .namespace(namespace1) - .table(TABLE4) + .table(table) .partitionKey(Key.ofInt(COL_NAME1, 1)) .intValue(COL_NAME2, 2) .textValue(COL_NAME3, "3") @@ -564,53 +568,53 @@ public void createIndex_ForAllDataTypesWithExistingData_ShouldCreateIndexesCorre COL_NAME13, LocalDateTime.of(LocalDate.of(2020, 6, 2), LocalTime.of(12, 2, 6, 123_000_000))); } - transactionManager.insert(insert.build()); + transactionalInsert(insert.build()); // Act - admin.createIndex(namespace1, TABLE4, COL_NAME2, options); + admin.createIndex(namespace1, table, COL_NAME2, options); if (isCreateIndexOnTextColumnEnabled()) { - admin.createIndex(namespace1, TABLE4, COL_NAME3, options); + admin.createIndex(namespace1, table, COL_NAME3, options); } - admin.createIndex(namespace1, TABLE4, COL_NAME4, options); - admin.createIndex(namespace1, TABLE4, COL_NAME5, options); - admin.createIndex(namespace1, TABLE4, COL_NAME6, options); + admin.createIndex(namespace1, table, COL_NAME4, options); + admin.createIndex(namespace1, table, COL_NAME5, options); + admin.createIndex(namespace1, table, COL_NAME6, options); if (isIndexOnBooleanColumnSupported()) { - admin.createIndex(namespace1, TABLE4, COL_NAME7, options); + admin.createIndex(namespace1, table, COL_NAME7, options); } if (isIndexOnBlobColumnSupported()) { - admin.createIndex(namespace1, TABLE4, COL_NAME8, options); + admin.createIndex(namespace1, table, COL_NAME8, options); } - admin.createIndex(namespace1, TABLE4, COL_NAME10, options); - admin.createIndex(namespace1, TABLE4, COL_NAME11, options); - admin.createIndex(namespace1, TABLE4, COL_NAME12, options); + admin.createIndex(namespace1, table, COL_NAME10, options); + admin.createIndex(namespace1, table, COL_NAME11, options); + admin.createIndex(namespace1, table, COL_NAME12, options); if (isTimestampTypeSupported()) { - admin.createIndex(namespace1, TABLE4, COL_NAME13, options); + admin.createIndex(namespace1, table, COL_NAME13, options); } // Assert - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME2)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME2)).isTrue(); if (isCreateIndexOnTextColumnEnabled()) { - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME3)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME3)).isTrue(); } - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME4)).isTrue(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME5)).isTrue(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME6)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME4)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME5)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME6)).isTrue(); if (isIndexOnBooleanColumnSupported()) { - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME7)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME7)).isTrue(); } if (isIndexOnBlobColumnSupported()) { - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME8)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME8)).isTrue(); } - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME9)).isTrue(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME10)).isTrue(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME11)).isTrue(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME12)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME9)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME10)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME11)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME12)).isTrue(); if (isTimestampTypeSupported()) { - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME13)).isTrue(); + assertThat(admin.indexExists(namespace1, table, COL_NAME13)).isTrue(); } Set actualSecondaryIndexNames = - admin.getTableMetadata(namespace1, TABLE4).getSecondaryIndexNames(); + admin.getTableMetadata(namespace1, table).getSecondaryIndexNames(); assertThat(actualSecondaryIndexNames) .contains(COL_NAME2, COL_NAME4, COL_NAME5, COL_NAME9, COL_NAME10, COL_NAME11, COL_NAME12); int indexCount = 8; @@ -631,12 +635,8 @@ public void createIndex_ForAllDataTypesWithExistingData_ShouldCreateIndexesCorre indexCount += 1; } assertThat(actualSecondaryIndexNames).hasSize(indexCount); - } finally { - admin.dropTable(namespace1, TABLE4, true); - if (transactionManager != null) { - transactionManager.close(); - } + admin.dropTable(namespace1, table, true); } } @@ -711,7 +711,10 @@ public void createIndex_IfNotExists_ForAlreadyExistingIndex_ShouldNotThrowAnyExc @Test public void dropIndex_ForAllDataTypesWithExistingData_ShouldDropIndexCorrectly() throws Exception { - DistributedTransactionManager transactionManager = null; + // Use a separate table name to avoid hitting the stale cache, which can cause test failure when + // executing DMLs + String table = "table_for_drop_index"; + try { // Arrange Map options = getCreationOptions(); @@ -750,12 +753,12 @@ public void dropIndex_ForAllDataTypesWithExistingData_ShouldDropIndexCorrectly() metadataBuilder.addColumn(COL_NAME13, DataType.TIMESTAMP); metadataBuilder.addSecondaryIndex(COL_NAME13); } - admin.createTable(namespace1, TABLE4, metadataBuilder.build(), options); - transactionManager = transactionFactory.getTransactionManager(); - PutBuilder.Buildable put = - Put.newBuilder() + admin.createTable(namespace1, table, metadataBuilder.build(), options); + + InsertBuilder.Buildable insert = + Insert.newBuilder() .namespace(namespace1) - .table(TABLE4) + .table(table) .partitionKey(Key.ofInt(COL_NAME1, 1)) .intValue(COL_NAME2, 2) .textValue(COL_NAME3, "3") @@ -771,52 +774,49 @@ public void dropIndex_ForAllDataTypesWithExistingData_ShouldDropIndexCorrectly() LocalDateTime.of(LocalDate.of(2020, 6, 2), LocalTime.of(12, 2, 6, 123_000_000)) .toInstant(ZoneOffset.UTC)); if (isTimestampTypeSupported()) { - put.timestampValue( + insert.timestampValue( COL_NAME13, LocalDateTime.of(LocalDate.of(2020, 6, 2), LocalTime.of(12, 2, 6, 123_000_000))); } - transactionManager.put(put.build()); + transactionalInsert(insert.build()); // Act - admin.dropIndex(namespace1, TABLE4, COL_NAME2); - admin.dropIndex(namespace1, TABLE4, COL_NAME3); - admin.dropIndex(namespace1, TABLE4, COL_NAME4); - admin.dropIndex(namespace1, TABLE4, COL_NAME5); - admin.dropIndex(namespace1, TABLE4, COL_NAME6); + admin.dropIndex(namespace1, table, COL_NAME2); + admin.dropIndex(namespace1, table, COL_NAME3); + admin.dropIndex(namespace1, table, COL_NAME4); + admin.dropIndex(namespace1, table, COL_NAME5); + admin.dropIndex(namespace1, table, COL_NAME6); if (isIndexOnBooleanColumnSupported()) { - admin.dropIndex(namespace1, TABLE4, COL_NAME7); + admin.dropIndex(namespace1, table, COL_NAME7); } if (isIndexOnBlobColumnSupported()) { - admin.dropIndex(namespace1, TABLE4, COL_NAME8); + admin.dropIndex(namespace1, table, COL_NAME8); } - admin.dropIndex(namespace1, TABLE4, COL_NAME10); - admin.dropIndex(namespace1, TABLE4, COL_NAME11); - admin.dropIndex(namespace1, TABLE4, COL_NAME12); + admin.dropIndex(namespace1, table, COL_NAME10); + admin.dropIndex(namespace1, table, COL_NAME11); + admin.dropIndex(namespace1, table, COL_NAME12); if (isTimestampTypeSupported()) { - admin.dropIndex(namespace1, TABLE4, COL_NAME13); + admin.dropIndex(namespace1, table, COL_NAME13); } // Assert - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME2)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME3)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME4)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME5)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME6)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME7)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME8)).isFalse(); - assertThat(admin.getTableMetadata(namespace1, TABLE4).getSecondaryIndexNames()) + assertThat(admin.indexExists(namespace1, table, COL_NAME2)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME3)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME4)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME5)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME6)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME7)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME8)).isFalse(); + assertThat(admin.getTableMetadata(namespace1, table).getSecondaryIndexNames()) .containsOnly(COL_NAME9); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME10)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME11)).isFalse(); - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME12)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME10)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME11)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME12)).isFalse(); if (isTimestampTypeSupported()) { - assertThat(admin.indexExists(namespace1, TABLE4, COL_NAME13)).isFalse(); + assertThat(admin.indexExists(namespace1, table, COL_NAME13)).isFalse(); } } finally { - admin.dropTable(namespace1, TABLE4, true); - if (transactionManager != null) { - transactionManager.close(); - } + admin.dropTable(namespace1, table, true); } } @@ -1202,8 +1202,11 @@ public void renameColumn_ForIndexKeyColumn_ShouldRenameColumnAndIndexCorrectly() public void alterColumnType_AlterColumnTypeFromEachExistingDataTypeToText_ShouldAlterColumnTypesCorrectly() throws ExecutionException, IOException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + // Use a separate table name to avoid hitting the stale cache, which can cause test failure when + // executing DMLs + String table = "table_for_alter_1"; + + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -1226,11 +1229,11 @@ public void renameColumn_ForIndexKeyColumn_ShouldRenameColumnAndIndexCorrectly() .addColumn("c12", DataType.TIMESTAMPTZ); } TableMetadata currentTableMetadata = currentTableMetadataBuilder.build(); - admin.createTable(namespace1, TABLE4, currentTableMetadata, options); + admin.createTable(namespace1, table, currentTableMetadata, options); InsertBuilder.Buildable insert = Insert.newBuilder() .namespace(namespace1) - .table(TABLE4) + .table(table) .partitionKey(Key.ofInt("c1", 1)) .clusteringKey(Key.ofInt("c2", 2)) .intValue("c3", 1) @@ -1245,20 +1248,20 @@ public void renameColumn_ForIndexKeyColumn_ShouldRenameColumnAndIndexCorrectly() insert.timestampValue("c11", LocalDateTime.now(ZoneOffset.UTC)); insert.timestampTZValue("c12", Instant.now()); } - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act - admin.alterColumnType(namespace1, TABLE4, "c3", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c4", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c5", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c6", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c7", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c8", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c9", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c10", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c3", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c4", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c5", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c6", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c7", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c8", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c9", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c10", DataType.TEXT); if (isTimestampTypeSupported()) { - admin.alterColumnType(namespace1, TABLE4, "c11", DataType.TEXT); - admin.alterColumnType(namespace1, TABLE4, "c12", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c11", DataType.TEXT); + admin.alterColumnType(namespace1, table, "c12", DataType.TEXT); } // Assert @@ -1282,17 +1285,20 @@ public void renameColumn_ForIndexKeyColumn_ShouldRenameColumnAndIndexCorrectly() .addColumn("c12", DataType.TEXT); } TableMetadata expectedTableMetadata = expectedTableMetadataBuilder.build(); - assertThat(admin.getTableMetadata(namespace1, TABLE4)).isEqualTo(expectedTableMetadata); + assertThat(admin.getTableMetadata(namespace1, table)).isEqualTo(expectedTableMetadata); } finally { - admin.dropTable(namespace1, TABLE4, true); + admin.dropTable(namespace1, table, true); } } @Test public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() throws ExecutionException, IOException, TransactionException { - try (DistributedTransactionManager transactionManager = - transactionFactory.getTransactionManager()) { + // Use a separate table name to avoid hitting the stale cache, which can cause test failure when + // executing DMLs + String table = "table_for_alter_2"; + + try { // Arrange Map options = getCreationOptions(); TableMetadata.Builder currentTableMetadataBuilder = @@ -1304,23 +1310,23 @@ public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() .addPartitionKey("c1") .addClusteringKey("c2", Scan.Ordering.Order.ASC); TableMetadata currentTableMetadata = currentTableMetadataBuilder.build(); - admin.createTable(namespace1, TABLE4, currentTableMetadata, options); + admin.createTable(namespace1, table, currentTableMetadata, options); int expectedColumn3Value = 1; float expectedColumn4Value = 4.0f; InsertBuilder.Buildable insert = Insert.newBuilder() .namespace(namespace1) - .table(TABLE4) + .table(table) .partitionKey(Key.ofInt("c1", 1)) .clusteringKey(Key.ofInt("c2", 2)) .intValue("c3", expectedColumn3Value) .floatValue("c4", expectedColumn4Value); - transactionalInsert(transactionManager, insert.build()); + transactionalInsert(insert.build()); // Act - admin.alterColumnType(namespace1, TABLE4, "c3", DataType.BIGINT); - admin.alterColumnType(namespace1, TABLE4, "c4", DataType.DOUBLE); + admin.alterColumnType(namespace1, table, "c3", DataType.BIGINT); + admin.alterColumnType(namespace1, table, "c4", DataType.DOUBLE); // Wait for cache expiry Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); @@ -1335,20 +1341,20 @@ public void alterColumnType_WideningConversion_ShouldAlterColumnTypesCorrectly() .addPartitionKey("c1") .addClusteringKey("c2", Scan.Ordering.Order.ASC); TableMetadata expectedTableMetadata = expectedTableMetadataBuilder.build(); - assertThat(admin.getTableMetadata(namespace1, TABLE4)).isEqualTo(expectedTableMetadata); + assertThat(admin.getTableMetadata(namespace1, table)).isEqualTo(expectedTableMetadata); Scan scan = Scan.newBuilder() .namespace(namespace1) - .table(TABLE4) + .table(table) .partitionKey(Key.ofInt("c1", 1)) .build(); - List results = transactionalScan(transactionManager, scan); + List results = transactionalScan(scan); assertThat(results).hasSize(1); Result result = results.get(0); assertThat(result.getBigInt("c3")).isEqualTo(expectedColumn3Value); assertThat(result.getDouble("c4")).isEqualTo(expectedColumn4Value); } finally { - admin.dropTable(namespace1, TABLE4, true); + admin.dropTable(namespace1, table, true); } } @@ -1587,9 +1593,7 @@ protected boolean isCreateIndexOnTextColumnEnabled() { return true; } - protected abstract void transactionalInsert(DistributedTransactionManager manager, Insert insert) - throws TransactionException; + protected abstract void transactionalInsert(Insert insert) throws TransactionException; - protected abstract List transactionalScan( - DistributedTransactionManager manager, Scan scan) throws TransactionException; + protected abstract List transactionalScan(Scan scan) throws TransactionException; } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java index 133141e476..f5c9d3c32b 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java @@ -1,5 +1,6 @@ package com.scalar.db.transaction.consensuscommit; +import com.google.common.util.concurrent.Uninterruptibles; import com.scalar.db.api.DistributedTransaction; import com.scalar.db.api.DistributedTransactionAdminIntegrationTestBase; import com.scalar.db.api.DistributedTransactionManager; @@ -9,6 +10,7 @@ import com.scalar.db.exception.transaction.TransactionException; import java.util.List; import java.util.Properties; +import java.util.concurrent.TimeUnit; public abstract class ConsensusCommitAdminIntegrationTestBase extends DistributedTransactionAdminIntegrationTestBase { @@ -32,19 +34,27 @@ protected final Properties getProperties(String testName) { protected abstract Properties getProps(String testName); @Override - protected void transactionalInsert(DistributedTransactionManager manager, Insert insert) - throws TransactionException { - DistributedTransaction transaction = manager.start(); - transaction.insert(insert); - transaction.commit(); + protected void transactionalInsert(Insert insert) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + DistributedTransaction transaction = manager.start(); + transaction.insert(insert); + transaction.commit(); + } } @Override - protected List transactionalScan(DistributedTransactionManager manager, Scan scan) - throws TransactionException { - DistributedTransaction transaction = manager.start(); - List results = transaction.scan(scan); - transaction.commit(); - return results; + protected List transactionalScan(Scan scan) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + DistributedTransaction transaction = manager.start(); + List results = transaction.scan(scan); + transaction.commit(); + return results; + } } } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/singlecrudoperation/SingleCrudOperationTransactionAdminIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/singlecrudoperation/SingleCrudOperationTransactionAdminIntegrationTestBase.java index eb31c68898..c47da4254d 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/singlecrudoperation/SingleCrudOperationTransactionAdminIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/singlecrudoperation/SingleCrudOperationTransactionAdminIntegrationTestBase.java @@ -1,5 +1,6 @@ package com.scalar.db.transaction.singlecrudoperation; +import com.google.common.util.concurrent.Uninterruptibles; import com.scalar.db.api.DistributedTransactionAdminIntegrationTestBase; import com.scalar.db.api.DistributedTransactionManager; import com.scalar.db.api.Insert; @@ -10,6 +11,7 @@ import com.scalar.db.exception.transaction.TransactionException; import java.util.List; import java.util.Properties; +import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -87,14 +89,22 @@ public void dropCoordinatorTables_IfExist_CoordinatorTablesDoNotExist_ShouldNotT } @Override - protected void transactionalInsert(DistributedTransactionManager manager, Insert insert) - throws TransactionException { - manager.insert(insert); + protected void transactionalInsert(Insert insert) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + manager.insert(insert); + } } @Override - protected List transactionalScan(DistributedTransactionManager manager, Scan scan) - throws TransactionException { - return manager.scan(scan); + protected List transactionalScan(Scan scan) throws TransactionException { + // Wait for cache expiry + Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); + + try (DistributedTransactionManager manager = transactionFactory.getTransactionManager()) { + return manager.scan(scan); + } } }