Change default mapping for BLOB column for Db2 from "VARBINARY(32672)" to "BLOB(2G)" [skip ci]

Torch3333 · Torch3333 · commit 683f011884f2 · 2025-09-04T14:50:46.000+09:00
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
@@ -22,11 +22,16 @@ protected AdminTestUtils getAdminTestUtils(String testName) {
   }
 
   @Override
-  protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {
-    // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs
+  protected boolean isCreateIndexOnTextColumnEnabled() {
+    // "admin.createIndex()" for TEXT column fails (the "create index" query runs
     // indefinitely) on the Db2 community edition docker version which we use for the CI.
     // However, the index creation is successful on Db2 hosted on IBM Cloud.
     // So we disable these tests until the issue with the Db2 community edition is resolved.
     return !JdbcTestUtils.isDb2(rdbEngine);
   }
+
+  @Override
+  protected boolean isIndexOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminCaseSensitivityIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminCaseSensitivityIntegrationTest.java
@@ -22,10 +22,15 @@ protected AdminTestUtils getAdminTestUtils(String testName) {
   }
 
   @Override
-  protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {
-    // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs
+  protected boolean isCreateIndexOnTextColumnEnabled() {
+    // "admin.createIndex()" for TEXT column fails (the "create index" query runs
     // indefinitely) on Db2 community edition version but works on Db2 hosted on IBM Cloud.
     // So we disable these tests until the issue is resolved.
     return !JdbcTestUtils.isDb2(rdbEngine);
   }
+
+  @Override
+  protected boolean isIndexOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcAdminIntegrationTest.java
@@ -21,10 +21,15 @@ protected AdminTestUtils getAdminTestUtils(String testName) {
   }
 
   @Override
-  protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {
-    // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs
+  protected boolean isCreateIndexOnTextColumnEnabled() {
+    // "admin.createIndex()" for TEXT columns fails (the "create index" query runs
     // indefinitely) on Db2 community edition version but works on Db2 hosted on IBM Cloud.
     // So we disable these tests until the issue is resolved.
     return !JdbcTestUtils.isDb2(rdbEngine);
   }
+
+  @Override
+  protected boolean isIndexOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseCrossPartitionScanIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseCrossPartitionScanIntegrationTest.java
@@ -80,4 +80,9 @@ protected Stream<Arguments> provideColumnsForCNFConditionsTest() {
     }
     return Stream.of(Arguments.of(allColumnNames));
   }
+
+  @Override
+  protected boolean isOrderingOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseMultipleClusteringKeyScanIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseMultipleClusteringKeyScanIntegrationTest.java
@@ -94,9 +94,14 @@ protected Column<?> getColumnWithMaxValue(String columnName, DataType dataType)
   @Override
   protected List<DataType> getDataTypes() {
     // TIMESTAMP WITH TIME ZONE type cannot be used as a primary key in Oracle
+    // BLOB type cannot be used as a clustering key in Db2
     return JdbcTestUtils.filterDataTypes(
         super.getDataTypes(),
         rdbEngine,
-        ImmutableMap.of(RdbEngineOracle.class, ImmutableList.of(DataType.TIMESTAMPTZ)));
+        ImmutableMap.of(
+            RdbEngineOracle.class,
+            ImmutableList.of(DataType.TIMESTAMPTZ),
+            RdbEngineDb2.class,
+            ImmutableList.of(DataType.BLOB)));
   }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseMultiplePartitionKeyIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseMultiplePartitionKeyIntegrationTest.java
@@ -88,13 +88,16 @@ protected Column<?> getColumnWithMaxValue(String columnName, DataType dataType)
   protected List<DataType> getDataTypes() {
     // TIMESTAMP WITH TIME ZONE type cannot be used as a primary key in Oracle
     // FLOAT and DOUBLE types cannot be used as partition key in Yugabyte
+    // BLOB type cannot be used as a partition key in Db2
     return JdbcTestUtils.filterDataTypes(
         super.getDataTypes(),
         rdbEngine,
         ImmutableMap.of(
             RdbEngineOracle.class,
             ImmutableList.of(DataType.TIMESTAMPTZ),
             RdbEngineYugabyte.class,
-            ImmutableList.of(DataType.FLOAT, DataType.DOUBLE)));
+            ImmutableList.of(DataType.FLOAT, DataType.DOUBLE),
+            RdbEngineDb2.class,
+            ImmutableList.of(DataType.BLOB)));
   }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSecondaryIndexIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSecondaryIndexIntegrationTest.java
@@ -1,12 +1,17 @@
 package com.scalar.db.storage.jdbc;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
 import com.scalar.db.api.DistributedStorageSecondaryIndexIntegrationTestBase;
 import com.scalar.db.config.DatabaseConfig;
 import com.scalar.db.io.Column;
 import com.scalar.db.io.DataType;
 import com.scalar.db.util.TestUtils;
+import java.util.Arrays;
 import java.util.Properties;
 import java.util.Random;
+import java.util.Set;
 
 public class JdbcDatabaseSecondaryIndexIntegrationTest
     extends DistributedStorageSecondaryIndexIntegrationTestBase {
@@ -68,4 +73,14 @@ protected Column<?> getColumnWithMaxValue(String columnName, DataType dataType)
     }
     return super.getColumnWithMaxValue(columnName, dataType);
   }
+
+  @Override
+  protected Set<DataType> getSecondaryIndexTypes() {
+    // BLOB type cannot be used as a secondary index in Db2
+    return Sets.newHashSet(
+        JdbcTestUtils.filterDataTypes(
+            Arrays.asList(DataType.values()),
+            rdbEngine,
+            ImmutableMap.of(RdbEngineDb2.class, ImmutableList.of(DataType.BLOB))));
+  }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSingleClusteringKeyScanIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSingleClusteringKeyScanIntegrationTest.java
@@ -70,9 +70,14 @@ protected Column<?> getColumnWithMaxValue(String columnName, DataType dataType)
   @Override
   protected List<DataType> getClusteringKeyTypes() {
     // TIMESTAMP WITH TIME ZONE type cannot be used as a primary key in Oracle
+    // BLOB type cannot be used as a clustering key in Db2
     return JdbcTestUtils.filterDataTypes(
         super.getClusteringKeyTypes(),
         rdbEngine,
-        ImmutableMap.of(RdbEngineOracle.class, ImmutableList.of(DataType.TIMESTAMPTZ)));
+        ImmutableMap.of(
+            RdbEngineOracle.class,
+            ImmutableList.of(DataType.TIMESTAMPTZ),
+            RdbEngineDb2.class,
+            ImmutableList.of(DataType.BLOB)));
   }
 }
diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSinglePartitionKeyIntegrationTest.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/JdbcDatabaseSinglePartitionKeyIntegrationTest.java
@@ -71,13 +71,16 @@ protected Column<?> getColumnWithMaxValue(String columnName, DataType dataType)
   protected List<DataType> getPartitionKeyTypes() {
     // TIMESTAMP WITH TIME ZONE type cannot be used as a primary key in Oracle
     // FLOAT and DOUBLE types cannot be used as partition key in Yugabyte
+    // BLOB type cannot be used as a partition key in Db2
     return JdbcTestUtils.filterDataTypes(
         super.getPartitionKeyTypes(),
         rdbEngine,
         ImmutableMap.of(
             RdbEngineOracle.class,
             ImmutableList.of(DataType.TIMESTAMPTZ),
             RdbEngineYugabyte.class,
-            ImmutableList.of(DataType.FLOAT, DataType.DOUBLE)));
+            ImmutableList.of(DataType.FLOAT, DataType.DOUBLE),
+            RdbEngineDb2.class,
+            ImmutableList.of(DataType.BLOB)));
   }
 }
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
@@ -22,11 +22,16 @@ protected AdminTestUtils getAdminTestUtils(String testName) {
   }
 
   @Override
-  protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {
-    // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs
+  protected boolean isCreateIndexOnTextColumnEnabled() {
+    // "admin.createIndex()" for TEXT column fails (the "create index" query runs
     // indefinitely) on the Db2 community edition docker version which we use for the CI.
     // However, the index creation is successful on Db2 hosted on IBM Cloud.
     // So we disable these tests until the issue with the Db2 community edition is resolved.
     return !JdbcTestUtils.isDb2(rdbEngine);
   }
+
+  @Override
+  protected boolean isIndexOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
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
@@ -95,11 +95,16 @@ protected AdminTestUtils getAdminTestUtils(String testName) {
   }
 
   @Override
-  protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {
-    // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs
+  protected boolean isCreateIndexOnTextColumnEnabled() {
+    // "admin.createIndex()" for TEXT column fails (the "create index" query runs
     // indefinitely) on the Db2 community edition docker version which we use for the CI.
     // However, the index creation is successful on Db2 hosted on IBM Cloud.
     // So we disable these tests until the issue with the Db2 community edition is resolved.
     return !JdbcTestUtils.isDb2(rdbEngine);
   }
+
+  @Override
+  protected boolean isIndexOnBlobColumnSupported() {
+    return !JdbcTestUtils.isDb2(rdbEngine);
+  }
 }
diff --git a/core/src/main/java/com/scalar/db/common/CoreError.java b/core/src/main/java/com/scalar/db/common/CoreError.java
@@ -678,6 +678,18 @@ public enum CoreError implements ScalarDbError {
       "Mutations across multiple storages are not allowed. Mutations: %s",
       "",
       ""),
+  DB2_INDEX_OR_KEY_ON_BLOB_COLUMN_NOT_SUPPORTED(
+      Category.USER_ERROR,
+      "0216",
+      "With Db2, using a BLOB column as partition key, clustering key or secondary index is not supported.",
+      "",
+      ""),
+  DB2_CROSS_PARTITION_SCAN_ORDERING_ON_BLOB_COLUMN_NOT_SUPPORTED(
+      Category.USER_ERROR,
+      "0217",
+      "With Db2, setting an ordering on a BLOB column when using a cross partition scan operation is not supported. Ordering: %s",
+      "",
+      ""),
 
   //
   // Errors for the concurrency error category
diff --git a/core/src/main/java/com/scalar/db/common/checker/OperationChecker.java b/core/src/main/java/com/scalar/db/common/checker/OperationChecker.java
@@ -8,6 +8,7 @@
 import com.scalar.db.api.Operation;
 import com.scalar.db.api.Put;
 import com.scalar.db.api.Scan;
+import com.scalar.db.api.Scan.Ordering;
 import com.scalar.db.api.ScanAll;
 import com.scalar.db.api.Selection;
 import com.scalar.db.api.Selection.Conjunction;
@@ -19,11 +20,14 @@
 import com.scalar.db.config.DatabaseConfig;
 import com.scalar.db.exception.storage.ExecutionException;
 import com.scalar.db.io.Column;
+import com.scalar.db.io.DataType;
 import com.scalar.db.io.Key;
+import com.scalar.db.storage.jdbc.JdbcConfig;
 import com.scalar.db.util.ScalarDbUtils;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Supplier;
 import javax.annotation.concurrent.ThreadSafe;
 
@@ -159,6 +163,17 @@ private void check(ScanAll scanAll) throws ExecutionException {
       throw new IllegalArgumentException(
           CoreError.OPERATION_CHECK_ERROR_CROSS_PARTITION_SCAN_ORDERING.buildMessage(scanAll));
     }
+    Optional<Ordering> orderingOnBlobColumn =
+        scanAll.getOrderings().stream()
+            .filter(
+                ordering -> metadata.getColumnDataType(ordering.getColumnName()) == DataType.BLOB)
+            .findFirst();
+    if (orderingOnBlobColumn.isPresent()
+        && new JdbcConfig(config).getJdbcUrl().startsWith("jdbc:db2:")) {
+      throw new IllegalArgumentException(
+          CoreError.DB2_CROSS_PARTITION_SCAN_ORDERING_ON_BLOB_COLUMN_NOT_SUPPORTED.buildMessage(
+              orderingOnBlobColumn.get()));
+    }
     checkOrderings(scanAll, metadata);
 
     if (!config.isCrossPartitionScanFilteringEnabled() && !scanAll.getConjunctions().isEmpty()) {
diff --git a/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java b/core/src/main/java/com/scalar/db/storage/jdbc/RdbEngineDb2.java
@@ -65,7 +65,7 @@ public String getDataTypeForEngine(DataType scalarDbDataType) {
       case BIGINT:
         return "BIGINT";
       case BLOB:
-        return "VARBINARY(32672)";
+        return "BLOB(2G)";
       case BOOLEAN:
         return "BOOLEAN";
       case FLOAT:
@@ -358,7 +358,8 @@ public String getDataTypeForKey(DataType dataType) {
       case TEXT:
         return "VARCHAR(" + keyColumnSize + ") NOT NULL";
       case BLOB:
-        return "VARBINARY(" + keyColumnSize + ") NOT NULL";
+        throw new UnsupportedOperationException(
+            CoreError.DB2_INDEX_OR_KEY_ON_BLOB_COLUMN_NOT_SUPPORTED.buildMessage());
       default:
         return getDataTypeForEngine(dataType) + " NOT NULL";
     }
@@ -371,7 +372,8 @@ public String getDataTypeForSecondaryIndex(DataType dataType) {
       case TEXT:
         return "VARCHAR(" + keyColumnSize + ")";
       case BLOB:
-        return "VARBINARY(" + keyColumnSize + ")";
+        throw new UnsupportedOperationException(
+            CoreError.DB2_INDEX_OR_KEY_ON_BLOB_COLUMN_NOT_SUPPORTED.buildMessage());
       default:
         return null;
     }
diff --git a/core/src/test/java/com/scalar/db/common/checker/OperationCheckerTest.java b/core/src/test/java/com/scalar/db/common/checker/OperationCheckerTest.java
@@ -32,6 +32,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Properties;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -416,6 +417,42 @@ public void whenCheckingScanOperationWithEmptyOrdering_shouldNotThrowAnyExceptio
     assertThatCode(() -> operationChecker.check(scan)).doesNotThrowAnyException();
   }
 
+  @Test
+  public void
+      whenCheckingScanAllOperationWithCrossPartitionScanEnabledWithOrderingOnBlobColumnWithDb2_shouldThrowIllegalArgumentException()
+          throws ExecutionException {
+    // Arrange
+    when(metadataManager.getTableMetadata(any()))
+        .thenReturn(
+            TableMetadata.newBuilder()
+                .addColumn(PKEY1, DataType.BLOB)
+                .addColumn(COL1, DataType.INT)
+                .addColumn(COL2, DataType.BLOB)
+                .addPartitionKey(PKEY1)
+                .build());
+    Scan scan =
+        Scan.newBuilder()
+            .namespace(NAMESPACE)
+            .table(TABLE_NAME)
+            .all()
+            .ordering(Scan.Ordering.asc(COL1))
+            .ordering(Scan.Ordering.desc(COL2))
+            .build();
+    when(databaseConfig.isCrossPartitionScanEnabled()).thenReturn(true);
+    when(databaseConfig.isCrossPartitionScanOrderingEnabled()).thenReturn(true);
+    when(databaseConfig.getContactPoints())
+        .thenReturn(Collections.singletonList("jdbc:db2://localhost:50000/test_db"));
+    when(databaseConfig.getStorage()).thenReturn("jdbc");
+    when(databaseConfig.getProperties()).thenReturn(new Properties());
+
+    operationChecker = new OperationChecker(databaseConfig, metadataManager, storageInfoProvider);
+
+    // Act Assert
+    assertThatThrownBy(() -> operationChecker.check(scan))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContainingAll("Db2", "ordering", COL2);
+  }
+
   @Test
   public void
       whenCheckingScanOperationWithInvalidProjections_shouldThrowIllegalArgumentException() {
diff --git a/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java b/core/src/test/java/com/scalar/db/storage/jdbc/JdbcAdminTest.java
diff --git a/integration-test/src/main/java/com/scalar/db/api/DistributedStorageAdminIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/api/DistributedStorageAdminIntegrationTestBase.java
diff --git a/integration-test/src/main/java/com/scalar/db/api/DistributedStorageCrossPartitionScanIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/api/DistributedStorageCrossPartitionScanIntegrationTestBase.java
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

Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,16 @@ protected AdminTestUtils getAdminTestUtils(String testName) {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`@Override`
`25`		`- protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {`
`26`		`- // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs`
	`25`	`+ protected boolean isCreateIndexOnTextColumnEnabled() {`
	`26`	`+ // "admin.createIndex()" for TEXT column fails (the "create index" query runs`
`27`	`27`	`// indefinitely) on the Db2 community edition docker version which we use for the CI.`
`28`	`28`	`// However, the index creation is successful on Db2 hosted on IBM Cloud.`
`29`	`29`	`// So we disable these tests until the issue with the Db2 community edition is resolved.`
`30`	`30`	`return !JdbcTestUtils.isDb2(rdbEngine);`
`31`	`31`	`}`
	`32`	`+`
	`33`	`+ @Override`
	`34`	`+ protected boolean isIndexOnBlobColumnSupported() {`
	`35`	`+ return !JdbcTestUtils.isDb2(rdbEngine);`
	`36`	`+ }`
`32`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,15 @@ protected AdminTestUtils getAdminTestUtils(String testName) {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`@Override`
`25`		`- protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {`
`26`		`- // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs`
	`25`	`+ protected boolean isCreateIndexOnTextColumnEnabled() {`
	`26`	`+ // "admin.createIndex()" for TEXT column fails (the "create index" query runs`
`27`	`27`	`// indefinitely) on Db2 community edition version but works on Db2 hosted on IBM Cloud.`
`28`	`28`	`// So we disable these tests until the issue is resolved.`
`29`	`29`	`return !JdbcTestUtils.isDb2(rdbEngine);`
`30`	`30`	`}`
	`31`	`+`
	`32`	`+ @Override`
	`33`	`+ protected boolean isIndexOnBlobColumnSupported() {`
	`34`	`+ return !JdbcTestUtils.isDb2(rdbEngine);`
	`35`	`+ }`
`31`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,15 @@ protected AdminTestUtils getAdminTestUtils(String testName) {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`@Override`
`24`		`- protected boolean isCreateIndexOnTextAndBlobColumnsEnabled() {`
`25`		`- // "admin.createIndex()" for TEXT and BLOB columns fails (the "create index" query runs`
	`24`	`+ protected boolean isCreateIndexOnTextColumnEnabled() {`
	`25`	`+ // "admin.createIndex()" for TEXT columns fails (the "create index" query runs`
`26`	`26`	`// indefinitely) on Db2 community edition version but works on Db2 hosted on IBM Cloud.`
`27`	`27`	`// So we disable these tests until the issue is resolved.`
`28`	`28`	`return !JdbcTestUtils.isDb2(rdbEngine);`
`29`	`29`	`}`
	`30`	`+`
	`31`	`+ @Override`
	`32`	`+ protected boolean isIndexOnBlobColumnSupported() {`
	`33`	`+ return !JdbcTestUtils.isDb2(rdbEngine);`
	`34`	`+ }`
`30`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,4 +80,9 @@ protected Stream<Arguments> provideColumnsForCNFConditionsTest() {`
`80`	`80`	`}`
`81`	`81`	`return Stream.of(Arguments.of(allColumnNames));`
`82`	`82`	`}`
	`83`	`+`
	`84`	`+ @Override`
	`85`	`+ protected boolean isOrderingOnBlobColumnSupported() {`
	`86`	`+ return !JdbcTestUtils.isDb2(rdbEngine);`
	`87`	`+ }`
`83`	`88`	`}`