korlov42 commented on code in PR #2719: URL: https://github.com/apache/ignite-3/pull/2719#discussion_r1367061288
########## modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/SqlSchemaManagerImplTest.java: ########## @@ -0,0 +1,683 @@ +/* + * 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.ignite.internal.sql.engine.schema; + +import static org.apache.ignite.internal.sql.engine.util.TypeUtils.columnType2NativeType; +import static org.apache.ignite.internal.testframework.IgniteTestUtils.await; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Stream; +import org.apache.calcite.rel.RelCollations; +import org.apache.calcite.rel.RelFieldCollation; +import org.apache.calcite.rel.RelFieldCollation.Direction; +import org.apache.calcite.rel.RelFieldCollation.NullDirection; +import org.apache.calcite.schema.SchemaPlus; +import org.apache.calcite.schema.Table; +import org.apache.ignite.internal.catalog.CatalogCommand; +import org.apache.ignite.internal.catalog.CatalogManager; +import org.apache.ignite.internal.catalog.CatalogTestUtils; +import org.apache.ignite.internal.catalog.commands.ColumnParams; +import org.apache.ignite.internal.catalog.commands.CreateHashIndexCommand; +import org.apache.ignite.internal.catalog.commands.CreateSortedIndexCommand; +import org.apache.ignite.internal.catalog.commands.CreateSystemViewCommand; +import org.apache.ignite.internal.catalog.commands.CreateTableCommand; +import org.apache.ignite.internal.catalog.commands.CreateTableCommandBuilder; +import org.apache.ignite.internal.catalog.commands.DefaultValue; +import org.apache.ignite.internal.catalog.descriptors.CatalogColumnCollation; +import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor.SystemViewType; +import org.apache.ignite.internal.catalog.descriptors.CatalogTableColumnDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor; +import org.apache.ignite.internal.hlc.HybridClockImpl; +import org.apache.ignite.internal.schema.DefaultValueGenerator; +import org.apache.ignite.internal.sql.engine.schema.IgniteIndex.Type; +import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution; +import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions; +import org.apache.ignite.internal.sql.engine.util.cache.CaffeineCacheFactory; +import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest; +import org.apache.ignite.sql.ColumnType; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.junit.jupiter.MockitoExtension; + + +/** + * Tests for {@link SqlSchemaManagerImpl}. + */ +@ExtendWith(MockitoExtension.class) +public class SqlSchemaManagerImplTest extends BaseIgniteAbstractTest { + private static final String PUBLIC_SCHEMA_NAME = "PUBLIC"; + private static final String SYSTEM_SCHEMA_NAME = "SYSTEM"; + + private CatalogManager catalogManager; + private SqlSchemaManagerImpl sqlSchemaManager; + + @BeforeEach + void init() { + catalogManager = CatalogTestUtils.createCatalogManagerWithTestUpdateLog("test", new HybridClockImpl()); + sqlSchemaManager = new SqlSchemaManagerImpl(catalogManager, CaffeineCacheFactory.INSTANCE, 200); + + catalogManager.start(); + } + + @AfterEach + void cleanup() throws Exception { + catalogManager.stop(); + } + + @Test + void testMultipleSchemas() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + createDummyTable("T1"), + createDummySystemView("V1", SystemViewType.NODE) + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + assertNotNull(rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME)); + assertNotNull(rootSchema.getSubSchema(SYSTEM_SCHEMA_NAME)); + } + + /** Basic schema with several tables. */ + @Test + public void testBasicSchema() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + createDummyTable("T1"), + createDummyTable("T2") + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteSchema schema = unwrapSchema(schemaPlus); + + assertThat(schema.version(), equalTo(versionAfter)); + + CatalogSchemaDescriptor schemaDescriptor = catalogManager.schema(PUBLIC_SCHEMA_NAME, versionAfter); + + assertThat(schemaDescriptor, notNullValue()); + assertThat(schema.getName(), equalTo(schemaDescriptor.name())); + + for (CatalogTableDescriptor tableDescriptor : schemaDescriptor.tables()) { + assertThat(schema.getTable(tableDescriptor.name()), notNullValue()); + } + } + + /** + * Table column types. + */ + @ParameterizedTest + @MethodSource("columnTypes") + public void testTableColumns(ColumnType columnType, int precision, int scale) { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + CreateTableCommand.builder() + .schemaName(PUBLIC_SCHEMA_NAME) + .tableName("TEST") + .columns(List.of( + ColumnParams.builder().name("ID").type(ColumnType.INT32).nullable(false).build(), + column("VAL_NULLABLE", columnType, precision, scale, true), + column("VAL_NOT_NULLABLE", columnType, precision, scale, false) + )) + .primaryKeyColumns(List.of("ID")) + .zone("Default") + .build() + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteTable table = getTable(unwrapSchema(schemaPlus), "TEST"); + + CatalogTableDescriptor tableDescriptor = catalogManager.table(table.id(), versionAfter); + + assertThat(tableDescriptor, notNullValue()); + + TableDescriptor descriptor = table.descriptor(); + assertEquals(tableDescriptor.columns().size(), descriptor.columnsCount(), "column count"); + + for (int i = 0; i < descriptor.columnsCount(); i++) { + CatalogTableColumnDescriptor expectedColumnDescriptor = tableDescriptor.columns().get(i); + ColumnDescriptor actualColumnDescriptor = descriptor.columnDescriptor(i); + + checkColumns(actualColumnDescriptor, i, expectedColumnDescriptor); + } + } + + private static void checkColumns( + ColumnDescriptor actualColumnDescriptor, + int expectedIndex, + CatalogTableColumnDescriptor expectedColumnDescriptor + ) { + assertThat(actualColumnDescriptor.logicalIndex(), equalTo(expectedIndex)); + assertThat(actualColumnDescriptor.name(), equalTo(expectedColumnDescriptor.name())); + assertThat(actualColumnDescriptor.nullable(), equalTo(expectedColumnDescriptor.nullable())); + assertThat( + actualColumnDescriptor.physicalType(), + equalTo(columnType2NativeType( + expectedColumnDescriptor.type(), + expectedColumnDescriptor.precision(), + expectedColumnDescriptor.scale(), + expectedColumnDescriptor.length() + )) + ); + } + + /** + * Column default value constraint. + */ + @Test + public void testTableDefaultValue() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + CreateTableCommand.builder() + .schemaName(PUBLIC_SCHEMA_NAME) + .tableName("TEST") + .columns(List.of( + ColumnParams.builder().name("C1").type(ColumnType.INT32).nullable(false).build(), + ColumnParams.builder().name("C2").type(ColumnType.INT32) + .defaultValue(DefaultValue.constant(null)).build(), + ColumnParams.builder().name("C3").type(ColumnType.INT32) + .defaultValue(DefaultValue.constant(1)).build(), + ColumnParams.builder().name("C4").type(ColumnType.STRING).length(256) + .defaultValue(DefaultValue.functionCall(DefaultValueGenerator.GEN_RANDOM_UUID.name())).build() + )) + .primaryKeyColumns(List.of("C1")) + .zone("Default") + .build() + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteTable table = getTable(unwrapSchema(schemaPlus), "TEST"); + + ColumnDescriptor c1 = table.descriptor().columnDescriptor("C1"); + assertNull(c1.defaultValue()); + assertEquals(DefaultValueStrategy.DEFAULT_NULL, c1.defaultStrategy()); + + ColumnDescriptor c2 = table.descriptor().columnDescriptor("C2"); + assertNull(c2.defaultValue()); + assertEquals(DefaultValueStrategy.DEFAULT_NULL, c2.defaultStrategy()); + + ColumnDescriptor c3 = table.descriptor().columnDescriptor("C3"); + assertEquals(1, c3.defaultValue()); + assertEquals(DefaultValueStrategy.DEFAULT_CONSTANT, c3.defaultStrategy()); + + ColumnDescriptor c4 = table.descriptor().columnDescriptor("C4"); + assertNotNull(c4.defaultValue()); + assertEquals(DefaultValueStrategy.DEFAULT_COMPUTED, c4.defaultStrategy()); + } + + /** + * Table with primary key but w/o colocation key columns are legal. + */ + @Test + public void testTableWithPrimaryKey() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + CreateTableCommand.builder() + .schemaName(PUBLIC_SCHEMA_NAME) + .tableName("TEST") + .columns(List.of( + ColumnParams.builder().name("C1").type(ColumnType.INT32).nullable(false).build(), + ColumnParams.builder().name("C2").type(ColumnType.INT32) + .defaultValue(DefaultValue.constant(null)).build(), + ColumnParams.builder().name("C3").type(ColumnType.INT32) + .defaultValue(DefaultValue.constant(1)).build(), + ColumnParams.builder().name("C4").type(ColumnType.STRING).length(256) + .defaultValue(DefaultValue.functionCall(DefaultValueGenerator.GEN_RANDOM_UUID.name())).build() + )) + .primaryKeyColumns(List.of("C1", "C3")) + .zone("Default") + .build() + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteTable table = getTable(unwrapSchema(schemaPlus), "TEST"); + + assertTrue(table.descriptor().columnDescriptor(0).key()); + assertFalse(table.descriptor().columnDescriptor(1).key()); + assertTrue(table.descriptor().columnDescriptor(2).key()); + assertFalse(table.descriptor().columnDescriptor(3).key()); + } + + /** + * Table distribution. + */ + @Test + public void testTableDistribution() { + Function<CreateTableCommandBuilder, CreateTableCommandBuilder> tableBase = builder -> builder + .schemaName(PUBLIC_SCHEMA_NAME) + .columns(List.of( + ColumnParams.builder().name("C1").type(ColumnType.INT32).build(), + ColumnParams.builder().name("C2").type(ColumnType.INT32).build(), + ColumnParams.builder().name("C3").type(ColumnType.INT32).build(), + ColumnParams.builder().name("C4").type(ColumnType.INT32).build() + )) + .primaryKeyColumns(List.of("C1", "C2", "C3", "C4")) + .zone("Default"); + + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + tableBase.apply(CreateTableCommand.builder()) + .tableName("T1") + .colocationColumns(List.of("C2")) + .build(), + tableBase.apply(CreateTableCommand.builder()) + .tableName("T2") + .colocationColumns(List.of("C4", "C2")) + .build(), + tableBase.apply(CreateTableCommand.builder()) + .tableName("T3") + .colocationColumns(List.of("C3", "C2", "C1")) + .build() + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + { + IgniteTable table = getTable(unwrapSchema(schemaPlus), "T1"); + IgniteDistribution distribution = table.descriptor().distribution(); + + assertThat(distribution, equalTo(IgniteDistributions.affinity(List.of(1), table.id(), table.id()))); + } + + { + IgniteTable table = getTable(unwrapSchema(schemaPlus), "T2"); + IgniteDistribution distribution = table.descriptor().distribution(); + + assertThat(distribution, equalTo(IgniteDistributions.affinity(List.of(3, 1), table.id(), table.id()))); + } + + { + IgniteTable table = getTable(unwrapSchema(schemaPlus), "T3"); + IgniteDistribution distribution = table.descriptor().distribution(); + + assertThat(distribution, equalTo(IgniteDistributions.affinity(List.of(2, 1, 0), table.id(), table.id()))); + } + } + + @Test + public void testHashIndex() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + createDummyTable("T1"), + createHashIndex("T1", "VAL1_IDX", "VAL1") + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteTable table = getTable(unwrapSchema(schemaPlus), "T1"); + assertNotNull(table); + + IgniteIndex index = table.indexes().get("VAL1_IDX"); + + assertThat(index.name(), equalTo("VAL1_IDX")); + assertThat(index.type(), equalTo(Type.HASH)); + assertThat(index.collation(), equalTo(RelCollations.of( + new RelFieldCollation(1, Direction.CLUSTERED, NullDirection.UNSPECIFIED) + ))); + } + + @Test + public void testSortedIndex() { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + createDummyTable("T1"), + createSortedIndex("T1", "IDX1", List.of("VAL1", "VAL2"), + List.of(CatalogColumnCollation.ASC_NULLS_FIRST, CatalogColumnCollation.ASC_NULLS_LAST)), + createSortedIndex("T1", "IDX2", List.of("VAL1", "VAL2"), + List.of(CatalogColumnCollation.DESC_NULLS_FIRST, CatalogColumnCollation.DESC_NULLS_LAST)) + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(PUBLIC_SCHEMA_NAME); + assertNotNull(schemaPlus); + + IgniteTable table = getTable(unwrapSchema(schemaPlus), "T1"); + assertNotNull(table); + + { + IgniteIndex index = table.indexes().get("IDX1"); + + assertThat(index.name(), equalTo("IDX1")); + assertThat(index.type(), equalTo(Type.SORTED)); + assertThat(index.collation(), equalTo(RelCollations.of( + new RelFieldCollation(1, Direction.ASCENDING, NullDirection.FIRST), + new RelFieldCollation(2, Direction.ASCENDING, NullDirection.LAST) + ))); + } + + { + IgniteIndex index = table.indexes().get("IDX2"); + + assertThat(index.name(), equalTo("IDX2")); + assertThat(index.type(), equalTo(Type.SORTED)); + assertThat(index.collation(), equalTo(RelCollations.of( + new RelFieldCollation(1, Direction.DESCENDING, NullDirection.FIRST), + new RelFieldCollation(2, Direction.DESCENDING, NullDirection.LAST) + ))); + } + } + + @ParameterizedTest + @MethodSource("systemViewDistributions") + public void testBasicView(SystemViewType viewType, IgniteDistribution distribution) { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + createDummySystemView("V1", SystemViewType.NODE), + createDummySystemView("V2", SystemViewType.CLUSTER) + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(SYSTEM_SCHEMA_NAME); + assertNotNull(schemaPlus); + + { + IgniteSystemView systemView = getSystemView(unwrapSchema(schemaPlus), "V1"); + + assertThat(systemView.name(), equalTo("V1")); + assertThat(systemView.distribution(), equalTo(IgniteDistributions.identity(0))); + } + + { + IgniteSystemView systemView = getSystemView(unwrapSchema(schemaPlus), "V2"); + + assertThat(systemView.name(), equalTo("V2")); + assertThat(systemView.distribution(), equalTo(IgniteDistributions.single())); + } + } + + @ParameterizedTest + @MethodSource("systemViewColumnTypes") + public void testViewColumns(SystemViewType viewType, ColumnType columnType, int precision, int scale) { + int versionBefore = catalogManager.latestCatalogVersion(); + await(catalogManager.execute(List.of( + CreateSystemViewCommand.builder() + .name("V1") + .columns(List.of( + ColumnParams.builder().name("ID").type(ColumnType.INT32).nullable(false).build(), + column("VAL_NULLABLE", columnType, precision, scale, true), + column("VAL_NOT_NULLABLE", columnType, precision, scale, false) + )) + .type(SystemViewType.CLUSTER) + .build() + ))); + + int versionAfter = catalogManager.latestCatalogVersion(); + assertThat(versionAfter, equalTo(versionBefore + 1)); + + SchemaPlus rootSchema = sqlSchemaManager.schema(versionAfter); + assertNotNull(rootSchema); + + SchemaPlus schemaPlus = rootSchema.getSubSchema(SYSTEM_SCHEMA_NAME); + assertNotNull(schemaPlus); + + CatalogSchemaDescriptor schemaDescriptor = catalogManager.schema(SYSTEM_SCHEMA_NAME, versionAfter); + assertNotNull(schemaDescriptor); + + CatalogSystemViewDescriptor viewDescriptor = schemaDescriptor.systemView("V1"); + assertNotNull(viewDescriptor); + + IgniteSystemView systemView = getSystemView(unwrapSchema(schemaPlus), "V1"); + + TableDescriptor descriptor = systemView.descriptor(); + assertEquals(viewDescriptor.columns().size(), descriptor.columnsCount(), "column count"); + + for (int i = 0; i < descriptor.columnsCount(); i++) { + CatalogTableColumnDescriptor expectedColumnDescriptor = viewDescriptor.columns().get(i); + ColumnDescriptor actualColumnDescriptor = descriptor.columnDescriptor(i); + + checkColumns(actualColumnDescriptor, i, expectedColumnDescriptor); + } + } + + private static Stream<Arguments> systemViewColumnTypes() { + List<Arguments> allArgs = new ArrayList<>(); + + for (SystemViewType type : SystemViewType.values()) { + columnTypes().map(args -> { + Object[] vals = args.get(); + + Object[] newVals = new Object[vals.length + 1]; + newVals[0] = type; + + System.arraycopy(vals, 0, newVals, 1, vals.length); + + return Arguments.of(newVals); + }).forEach(allArgs::add); + } + + return allArgs.stream(); + } + + private static Stream<Arguments> systemViewDistributions() { + return Stream.of( + Arguments.of(SystemViewType.NODE, IgniteDistributions.identity(0)), + Arguments.of(SystemViewType.CLUSTER, IgniteDistributions.single()) + ); + } + + + private static IgniteSystemView getSystemView(IgniteSchema schema, String name) { + Table systemViewTable = schema.getTable(name); + assertNotNull(systemViewTable); + + IgniteSystemView systemView = assertInstanceOf(IgniteSystemView.class, systemViewTable); + assertEquals(systemView.name(), name); + + return systemView; + } + + private static IgniteSchema unwrapSchema(SchemaPlus schemaPlus) { + IgniteSchema igniteSchema = schemaPlus.unwrap(IgniteSchema.class); + assertNotNull(igniteSchema); + return igniteSchema; + } + + private static IgniteTable getTable(IgniteSchema schema, String name) { + IgniteTable table = (IgniteTable) schema.getTable(name); + assertNotNull(table); + return table; + } + + private static Stream<Arguments> columnTypes() { + return Stream.of( + Arguments.of(ColumnType.BOOLEAN, -1, -1), + Arguments.of(ColumnType.INT8, -1, -1), + Arguments.of(ColumnType.INT16, -1, -1), + Arguments.of(ColumnType.INT32, -1, -1), + Arguments.of(ColumnType.INT64, -1, -1), + Arguments.of(ColumnType.FLOAT, -1, -1), + Arguments.of(ColumnType.DOUBLE, -1, -1), + Arguments.of(ColumnType.DECIMAL, 4, 0), + Arguments.of(ColumnType.DECIMAL, 4, 2), + Arguments.of(ColumnType.NUMBER, 4, -1), + Arguments.of(ColumnType.STRING, 40, -1), + Arguments.of(ColumnType.BYTE_ARRAY, 40, -1), + Arguments.of(ColumnType.DATE, -1, -1), + Arguments.of(ColumnType.TIME, 2, -1), + Arguments.of(ColumnType.DATETIME, 2, -1), + Arguments.of(ColumnType.TIMESTAMP, 2, -1), + Arguments.of(ColumnType.UUID, 2, -1), Review Comment: done -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
