From 77711d8474442089679ca8ef2d1cbb8ab53fe2df Mon Sep 17 00:00:00 2001 From: Madhavendra Rathore Date: Sat, 30 Aug 2025 22:40:06 +0530 Subject: [PATCH 1/5] Fixed getColumns function: SQL_DATATYPE, SQL_DATETIME_SUB, DATA_TYPE, TYPE_NAME,BUFFER_LENGTH. Used StripBaseTypeName instead of StripTypeName to fix the incorrect values in case of complex datatypes --- .../api/impl/DatabricksResultSetMetaData.java | 2 +- .../impl/common/MetadataResultSetBuilder.java | 45 ++++++++++--------- 2 files changed, 26 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSetMetaData.java b/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSetMetaData.java index 9b82aa99bd..e146e6c375 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSetMetaData.java +++ b/src/main/java/com/databricks/jdbc/api/impl/DatabricksResultSetMetaData.java @@ -108,7 +108,7 @@ public DatabricksResultSetMetaData( .columnTypeClassName(DatabricksTypeUtil.getColumnTypeClassName(columnTypeName)) .columnType(columnType) .columnTypeText( - metadataResultSetBuilder.stripTypeName( + metadataResultSetBuilder.stripBaseTypeName( columnInfo .getTypeText())) // store base type eg. DECIMAL instead of DECIMAL(7,2) .typePrecision(precision) diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java index f27589336b..4eb19f1b97 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java @@ -182,14 +182,15 @@ List> getRows( if (typeVal == null) { // safety check object = null; } else { - object = getCode(stripTypeName(typeVal)); + object = getCode(stripBaseTypeName(typeVal)); } break; case "SQL_DATETIME_SUB": // check if typeVal is a date/time related field if (typeVal != null - && (typeVal.contains(DATE_TYPE) || typeVal.contains(TIMESTAMP_TYPE))) { - object = getCode(stripTypeName(typeVal)); + && (stripBaseTypeName(typeVal).contains(DATE_TYPE) + || stripBaseTypeName(typeVal).contains(TIMESTAMP_TYPE))) { + object = getCode(stripBaseTypeName(typeVal)); } else { object = null; } @@ -216,7 +217,7 @@ List> getRows( } } catch (SQLException e) { if (mappedColumn.getColumnName().equals(DATA_TYPE_COLUMN.getColumnName())) { - object = getCode(stripTypeName(typeVal)); + object = getCode(stripBaseTypeName(typeVal)); } else if (mappedColumn .getColumnName() .equals(CHAR_OCTET_LENGTH_COLUMN.getColumnName())) { @@ -250,11 +251,12 @@ List> getRows( if (mappedColumn.getColumnName().equals(COLUMN_TYPE_COLUMN.getColumnName())) { if (typeVal != null && (typeVal.contains(ARRAY_TYPE) + || typeVal.contains(MAP_TYPE) || typeVal.contains( - MAP_TYPE))) { // for complex data types, do not strip type name + STRUCT_TYPE))) { // for complex data types, do not strip type name object = typeVal; } else { - object = stripTypeName(typeVal); + object = stripBaseTypeName(typeVal); } } // Set COLUMN_SIZE to 255 if it's not present @@ -337,7 +339,7 @@ int getColumnSize(String typeVal) { if (isTextType(typeVal)) { return ctx.getDefaultStringColumnLength(); } - String typeName = stripTypeName(typeVal); + String typeName = stripBaseTypeName(typeVal); switch (typeName) { case "DECIMAL": case "NUMERIC": @@ -401,13 +403,13 @@ int getBufferLength(String typeVal) { if (typeVal == null || typeVal.isEmpty()) { return 0; } - if (typeVal.contains("ARRAY") || typeVal.contains("MAP")) { + if (typeVal.contains("ARRAY") || typeVal.contains("MAP") || typeVal.contains("STRUCT")) { return 255; } if (isTextType(typeVal)) { return getColumnSize(typeVal); } - int sqlType = getCode(stripTypeName(typeVal)); + int sqlType = getCode(stripBaseTypeName(typeVal)); return getSizeInBytes(sqlType); } @@ -787,30 +789,31 @@ List> getThriftRows(List> rows, List col List> updatedRows = new ArrayList<>(); for (List row : rows) { List updatedRow = new ArrayList<>(); + String typeVal = null; + int col_type_index = columns.indexOf(COLUMN_TYPE_COLUMN); // only relevant for getColumns + if (col_type_index != -1) { + typeVal = (String) row.get(col_type_index); + } for (ResultColumn column : columns) { if (NULL_COLUMN_COLUMNS.contains(column) || NULL_TABLE_COLUMNS.contains(column)) { updatedRow.add(null); continue; } Object object; - String typeVal = null; - int col_type_index = columns.indexOf(COLUMN_TYPE_COLUMN); // only relevant for getColumns - if (col_type_index != -1) { - typeVal = (String) row.get(col_type_index); - } switch (column.getColumnName()) { case "SQL_DATA_TYPE": if (typeVal == null) { // safety check object = null; } else { - object = getCode(stripTypeName(typeVal)); + object = getCode(stripBaseTypeName(typeVal)); } break; case "SQL_DATETIME_SUB": // check if typeVal is a date/time related field if (typeVal != null - && (typeVal.contains(DATE_TYPE) || typeVal.contains(TIMESTAMP_TYPE))) { - object = getCode(stripTypeName(typeVal)); + && (stripBaseTypeName(typeVal).contains(DATE_TYPE) + || stripBaseTypeName(typeVal).contains(TIMESTAMP_TYPE))) { + object = getCode(stripBaseTypeName(typeVal)); } else { object = null; } @@ -848,7 +851,7 @@ List> getThriftRows(List> rows, List col } } if (column.getColumnName().equals(DATA_TYPE_COLUMN.getColumnName())) { - object = getCode(stripTypeName(typeVal)); + object = getCode(stripBaseTypeName(typeVal)); } if (column.getColumnName().equals(CHAR_OCTET_LENGTH_COLUMN.getColumnName())) { object = getCharOctetLength(typeVal); @@ -867,10 +870,12 @@ List> getThriftRows(List> rows, List col // Handle TYPE_NAME separately for potential modifications if (column.getColumnName().equals(COLUMN_TYPE_COLUMN.getColumnName())) { if (typeVal != null - && (typeVal.contains(ARRAY_TYPE) || typeVal.contains(MAP_TYPE))) { + && (typeVal.contains(ARRAY_TYPE) + || typeVal.contains(MAP_TYPE) + || typeVal.contains(STRUCT_TYPE))) { object = typeVal; } else { - object = stripTypeName(typeVal); + object = stripBaseTypeName(typeVal); } } // Set COLUMN_SIZE to 255 if it's not present From 40d7a14afb1e0211632f11697f13574a09cae3c9 Mon Sep 17 00:00:00 2001 From: Madhavendra Rathore Date: Wed, 3 Sep 2025 00:21:36 +0530 Subject: [PATCH 2/5] Changed DATA_TYPE to show 12 as code for complex datatype when EnableComplexDatatypeSuppor is 0. Added tests for the same --- .../impl/common/MetadataResultSetBuilder.java | 41 ++++++- .../impl/common/TypeValConstants.java | 1 + .../common/MetadataResultSetBuilderTest.java | 116 ++++++++++++++++++ 3 files changed, 155 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java index 4eb19f1b97..29a95e8c39 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java @@ -182,7 +182,13 @@ List> getRows( if (typeVal == null) { // safety check object = null; } else { - object = getCode(stripBaseTypeName(typeVal)); + // Check if complex datatype support is disabled and this is a complex type + if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { + object = + 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is disabled + } else { + object = getCode(stripBaseTypeName(typeVal)); + } } break; case "SQL_DATETIME_SUB": @@ -480,6 +486,23 @@ public String stripBaseTypeName(String typeName) { return typeName; } + /** + * Checks if the given type string represents a complex type (ARRAY, MAP, or STRUCT). + * + * @param typeVal The type string to check + * @return true if the type is a complex type, false otherwise + */ + private boolean isComplexType(String typeVal) { + if (typeVal == null) { + return false; + } + String baseType = stripBaseTypeName(typeVal); + return baseType.contains(ARRAY_TYPE) + || baseType.contains(MAP_TYPE) + || baseType.contains(STRUCT_TYPE) + || baseType.contains(VARIANT_TYPE); + } + int getCode(String s) { switch (s) { case "STRING": @@ -805,7 +828,13 @@ List> getThriftRows(List> rows, List col if (typeVal == null) { // safety check object = null; } else { - object = getCode(stripBaseTypeName(typeVal)); + // Check if complex datatype support is disabled and this is a complex type + if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { + object = + 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is disabled + } else { + object = getCode(stripBaseTypeName(typeVal)); + } } break; case "SQL_DATETIME_SUB": @@ -851,7 +880,13 @@ List> getThriftRows(List> rows, List col } } if (column.getColumnName().equals(DATA_TYPE_COLUMN.getColumnName())) { - object = getCode(stripBaseTypeName(typeVal)); + // Check if complex datatype support is disabled and this is a complex type + if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { + object = 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is + // disabled + } else { + object = getCode(stripBaseTypeName(typeVal)); + } } if (column.getColumnName().equals(CHAR_OCTET_LENGTH_COLUMN.getColumnName())) { object = getCharOctetLength(typeVal); diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java b/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java index 52be4245c1..f6b2dcea6e 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java @@ -14,6 +14,7 @@ public class TypeValConstants { static final String MAP_TYPE = "MAP"; static final String STRUCT_TYPE = "STRUCT"; static final String UNIONTYPE_TYPE = "UNIONTYPE"; + static final String VARIANT_TYPE = "VARIANT"; static final String BYTE_TYPE = "BYTE"; static final String SHORT_TYPE = "SHORT"; static final String LONG_TYPE = "LONG"; diff --git a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java index 465a94edfd..32caebb858 100644 --- a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java +++ b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java @@ -467,4 +467,120 @@ void testGetTablesResultWithNullTableType() throws SQLException { } assertEquals(2, rowCount); } + + @Test + void testComplexTypesReturnVarcharWhenSupportDisabled() throws SQLException { + when(connectionContext.isComplexDatatypeSupportEnabled()).thenReturn(false); + List> rows = + Arrays.asList( + Arrays.asList( + "cat", + "sch", + "tab", + "array_col", + 2003, + "ARRAY", + 0, + 0, + 0, + 0, + 1, + "", + "", + 2003, + 0, + 0, + 1, + "YES", + "", + "", + "", + 0), + Arrays.asList( + "cat", + "sch", + "tab", + "map_col", + 2002, + "MAP", + 0, + 0, + 0, + 0, + 1, + "", + "", + 2002, + 0, + 0, + 2, + "YES", + "", + "", + "", + 0)); + DatabricksResultSet resultSet = metadataResultSetBuilder.getColumnsResult(rows); + resultSet.next(); + assertEquals(12, resultSet.getInt("DATA_TYPE")); // ARRAY should be VARCHAR + resultSet.next(); + assertEquals(12, resultSet.getInt("DATA_TYPE")); // MAP should be VARCHAR + } + + @Test + void testComplexTypesReturnActualCodesWhenSupportEnabled() throws SQLException { + when(connectionContext.isComplexDatatypeSupportEnabled()).thenReturn(true); + List> rows = + Arrays.asList( + Arrays.asList( + "cat", + "sch", + "tab", + "array_col", + 2003, + "ARRAY", + 0, + 0, + 0, + 0, + 1, + "", + "", + 2003, + 0, + 0, + 1, + "YES", + "", + "", + "", + 0), + Arrays.asList( + "cat", + "sch", + "tab", + "map_col", + 2002, + "MAP", + 0, + 0, + 0, + 0, + 1, + "", + "", + 2002, + 0, + 0, + 2, + "YES", + "", + "", + "", + 0)); + DatabricksResultSet resultSet = metadataResultSetBuilder.getColumnsResult(rows); + resultSet.next(); + assertEquals(2003, resultSet.getInt("DATA_TYPE")); // ARRAY should be 2003 + resultSet.next(); + assertEquals(2002, resultSet.getInt("DATA_TYPE")); // MAP should be 2002 + } } From 0e3beb9bdf544460aec31d970d3eb90576f6a06f Mon Sep 17 00:00:00 2001 From: Madhavendra Rathore Date: Wed, 3 Sep 2025 18:28:37 +0530 Subject: [PATCH 3/5] Cleaned tests --- .../impl/common/MetadataResultSetBuilder.java | 18 +-- .../impl/common/TypeValConstants.java | 1 - .../common/MetadataResultSetBuilderTest.java | 130 ++++-------------- 3 files changed, 37 insertions(+), 112 deletions(-) diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java index b839d7a11d..5eee378a6e 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilder.java @@ -186,8 +186,7 @@ List> getRows( } else { // Check if complex datatype support is disabled and this is a complex type if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { - object = - 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is disabled + object = Types.VARCHAR; } else { object = getCode(stripBaseTypeName(typeVal)); } @@ -225,7 +224,11 @@ List> getRows( } } catch (SQLException e) { if (mappedColumn.getColumnName().equals(DATA_TYPE_COLUMN.getColumnName())) { - object = getCode(stripBaseTypeName(typeVal)); + if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { + object = Types.VARCHAR; + } else { + object = getCode(stripBaseTypeName(typeVal)); + } } else if (mappedColumn .getColumnName() .equals(CHAR_OCTET_LENGTH_COLUMN.getColumnName())) { @@ -501,8 +504,7 @@ private boolean isComplexType(String typeVal) { String baseType = stripBaseTypeName(typeVal); return baseType.contains(ARRAY_TYPE) || baseType.contains(MAP_TYPE) - || baseType.contains(STRUCT_TYPE) - || baseType.contains(VARIANT_TYPE); + || baseType.contains(STRUCT_TYPE); } int getCode(String s) { @@ -852,8 +854,7 @@ List> getThriftRows(List> rows, List col } else { // Check if complex datatype support is disabled and this is a complex type if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { - object = - 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is disabled + object = Types.VARCHAR; } else { object = getCode(stripBaseTypeName(typeVal)); } @@ -904,8 +905,7 @@ List> getThriftRows(List> rows, List col if (column.getColumnName().equals(DATA_TYPE_COLUMN.getColumnName())) { // Check if complex datatype support is disabled and this is a complex type if (!ctx.isComplexDatatypeSupportEnabled() && isComplexType(typeVal)) { - object = 12; // Return VARCHAR (Types.VARCHAR) for complex types when support is - // disabled + object = Types.VARCHAR; } else { object = getCode(stripBaseTypeName(typeVal)); } diff --git a/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java b/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java index f6b2dcea6e..52be4245c1 100644 --- a/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java +++ b/src/main/java/com/databricks/jdbc/dbclient/impl/common/TypeValConstants.java @@ -14,7 +14,6 @@ public class TypeValConstants { static final String MAP_TYPE = "MAP"; static final String STRUCT_TYPE = "STRUCT"; static final String UNIONTYPE_TYPE = "UNIONTYPE"; - static final String VARIANT_TYPE = "VARIANT"; static final String BYTE_TYPE = "BYTE"; static final String SHORT_TYPE = "SHORT"; static final String LONG_TYPE = "LONG"; diff --git a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java index 32caebb858..fd46de28fc 100644 --- a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java +++ b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java @@ -471,116 +471,42 @@ void testGetTablesResultWithNullTableType() throws SQLException { @Test void testComplexTypesReturnVarcharWhenSupportDisabled() throws SQLException { when(connectionContext.isComplexDatatypeSupportEnabled()).thenReturn(false); + + List columns = + Arrays.asList(DATA_TYPE_COLUMN, COLUMN_TYPE_COLUMN, SQL_DATA_TYPE_COLUMN); List> rows = Arrays.asList( - Arrays.asList( - "cat", - "sch", - "tab", - "array_col", - 2003, - "ARRAY", - 0, - 0, - 0, - 0, - 1, - "", - "", - 2003, - 0, - 0, - 1, - "YES", - "", - "", - "", - 0), - Arrays.asList( - "cat", - "sch", - "tab", - "map_col", - 2002, - "MAP", - 0, - 0, - 0, - 0, - 1, - "", - "", - 2002, - 0, - 0, - 2, - "YES", - "", - "", - "", - 0)); - DatabricksResultSet resultSet = metadataResultSetBuilder.getColumnsResult(rows); - resultSet.next(); - assertEquals(12, resultSet.getInt("DATA_TYPE")); // ARRAY should be VARCHAR - resultSet.next(); - assertEquals(12, resultSet.getInt("DATA_TYPE")); // MAP should be VARCHAR + Arrays.asList(2003, "ARRAY", 2003), Arrays.asList(2002, "MAP", 2002)); + + List> updatedRows = metadataResultSetBuilder.getThriftRows(rows, columns); + + List arrayRow = updatedRows.get(0); + assertEquals(12, arrayRow.get(0)); // DATA_TYPE should be 12 (VARCHAR) + assertEquals(12, arrayRow.get(2)); // SQL_DATA_TYPE should be 12 (VARCHAR) + + List mapRow = updatedRows.get(1); + assertEquals(12, mapRow.get(0)); // DATA_TYPE should be 12 (VARCHAR) + assertEquals(12, mapRow.get(2)); // SQL_DATA_TYPE should be 12 (VARCHAR) } @Test void testComplexTypesReturnActualCodesWhenSupportEnabled() throws SQLException { when(connectionContext.isComplexDatatypeSupportEnabled()).thenReturn(true); + + List columns = + Arrays.asList(DATA_TYPE_COLUMN, COLUMN_TYPE_COLUMN, SQL_DATA_TYPE_COLUMN); List> rows = Arrays.asList( - Arrays.asList( - "cat", - "sch", - "tab", - "array_col", - 2003, - "ARRAY", - 0, - 0, - 0, - 0, - 1, - "", - "", - 2003, - 0, - 0, - 1, - "YES", - "", - "", - "", - 0), - Arrays.asList( - "cat", - "sch", - "tab", - "map_col", - 2002, - "MAP", - 0, - 0, - 0, - 0, - 1, - "", - "", - 2002, - 0, - 0, - 2, - "YES", - "", - "", - "", - 0)); - DatabricksResultSet resultSet = metadataResultSetBuilder.getColumnsResult(rows); - resultSet.next(); - assertEquals(2003, resultSet.getInt("DATA_TYPE")); // ARRAY should be 2003 - resultSet.next(); - assertEquals(2002, resultSet.getInt("DATA_TYPE")); // MAP should be 2002 + Arrays.asList(2003, "ARRAY", 2003), Arrays.asList(2002, "MAP", 2002)); + + List> updatedRows = metadataResultSetBuilder.getThriftRows(rows, columns); + + List arrayRow = updatedRows.get(0); + assertEquals(2003, arrayRow.get(0)); // DATA_TYPE should be 2003 (ARRAY) + assertEquals(2003, arrayRow.get(2)); // SQL_DATA_TYPE should be 2003 (ARRAY) + + List mapRow = updatedRows.get(1); + assertEquals(2002, mapRow.get(0)); // DATA_TYPE should be 2002 (MAP) + assertEquals(2002, mapRow.get(2)); // SQL_DATA_TYPE should be 2002 (MAP) } } From 647a163e9fa9268a6a05a0f562972c72e34d6434 Mon Sep 17 00:00:00 2001 From: Madhavendra Rathore Date: Wed, 3 Sep 2025 18:36:05 +0530 Subject: [PATCH 4/5] Updated NEXT_CHANGELOG --- NEXT_CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/NEXT_CHANGELOG.md b/NEXT_CHANGELOG.md index 89acbc938b..53e4433f27 100644 --- a/NEXT_CHANGELOG.md +++ b/NEXT_CHANGELOG.md @@ -15,5 +15,6 @@ ### Fixed - Fixed `ResultSet.getString` for Boolean columns in Metadata result set. +- Fixed `connection.getMetadata().getColumns()` to return the correct SQL data type code for complex type columns. --- *Note: When making changes, please add your change under the appropriate section with a brief description.* From 52eda8acb852e0ae7910927232fbd325fd61f376 Mon Sep 17 00:00:00 2001 From: Madhavendra Rathore Date: Mon, 8 Sep 2025 18:49:34 +0530 Subject: [PATCH 5/5] Added tests for variant and struct types in the MetadataResultSetBuilderTest --- .../common/MetadataResultSetBuilderTest.java | 42 ++++++++++++++----- 1 file changed, 32 insertions(+), 10 deletions(-) diff --git a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java index fd46de28fc..01951eef56 100644 --- a/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java +++ b/src/test/java/com/databricks/jdbc/dbclient/impl/common/MetadataResultSetBuilderTest.java @@ -476,17 +476,28 @@ void testComplexTypesReturnVarcharWhenSupportDisabled() throws SQLException { Arrays.asList(DATA_TYPE_COLUMN, COLUMN_TYPE_COLUMN, SQL_DATA_TYPE_COLUMN); List> rows = Arrays.asList( - Arrays.asList(2003, "ARRAY", 2003), Arrays.asList(2002, "MAP", 2002)); + Arrays.asList(2003, "ARRAY", 2003), + Arrays.asList(2002, "MAP", 2002), + Arrays.asList(2002, "STRUCT", 2002), + Arrays.asList(1111, "VARIANT", 1111)); List> updatedRows = metadataResultSetBuilder.getThriftRows(rows, columns); List arrayRow = updatedRows.get(0); - assertEquals(12, arrayRow.get(0)); // DATA_TYPE should be 12 (VARCHAR) - assertEquals(12, arrayRow.get(2)); // SQL_DATA_TYPE should be 12 (VARCHAR) + assertEquals(12, arrayRow.get(0)); + assertEquals(12, arrayRow.get(2)); List mapRow = updatedRows.get(1); - assertEquals(12, mapRow.get(0)); // DATA_TYPE should be 12 (VARCHAR) - assertEquals(12, mapRow.get(2)); // SQL_DATA_TYPE should be 12 (VARCHAR) + assertEquals(12, mapRow.get(0)); + assertEquals(12, mapRow.get(2)); + + List structRow = updatedRows.get(2); + assertEquals(12, structRow.get(0)); + assertEquals(12, structRow.get(2)); + + List variantRow = updatedRows.get(3); + assertEquals(1111, variantRow.get(0)); + assertEquals(1111, variantRow.get(2)); } @Test @@ -497,16 +508,27 @@ void testComplexTypesReturnActualCodesWhenSupportEnabled() throws SQLException { Arrays.asList(DATA_TYPE_COLUMN, COLUMN_TYPE_COLUMN, SQL_DATA_TYPE_COLUMN); List> rows = Arrays.asList( - Arrays.asList(2003, "ARRAY", 2003), Arrays.asList(2002, "MAP", 2002)); + Arrays.asList(2003, "ARRAY", 2003), + Arrays.asList(2002, "MAP", 2002), + Arrays.asList(2002, "STRUCT", 2002), + Arrays.asList(1111, "VARIANT", 1111)); List> updatedRows = metadataResultSetBuilder.getThriftRows(rows, columns); List arrayRow = updatedRows.get(0); - assertEquals(2003, arrayRow.get(0)); // DATA_TYPE should be 2003 (ARRAY) - assertEquals(2003, arrayRow.get(2)); // SQL_DATA_TYPE should be 2003 (ARRAY) + assertEquals(2003, arrayRow.get(0)); + assertEquals(2003, arrayRow.get(2)); List mapRow = updatedRows.get(1); - assertEquals(2002, mapRow.get(0)); // DATA_TYPE should be 2002 (MAP) - assertEquals(2002, mapRow.get(2)); // SQL_DATA_TYPE should be 2002 (MAP) + assertEquals(2002, mapRow.get(0)); + assertEquals(2002, mapRow.get(2)); + + List structRow = updatedRows.get(2); + assertEquals(2002, structRow.get(0)); + assertEquals(2002, structRow.get(2)); + + List variantRow = updatedRows.get(3); + assertEquals(1111, variantRow.get(0)); + assertEquals(1111, variantRow.get(2)); } }