diff --git a/src/main/java/com/firebolt/FireboltDriver.java b/src/main/java/com/firebolt/FireboltDriver.java index 60e7da25e..d8537117d 100644 --- a/src/main/java/com/firebolt/FireboltDriver.java +++ b/src/main/java/com/firebolt/FireboltDriver.java @@ -15,7 +15,7 @@ public class FireboltDriver implements Driver { public static final String JDBC_FIREBOLT = "jdbc:firebolt:"; - private static Logger rootLog; + private static final Logger rootLog; private static final Logger log; static { diff --git a/src/main/java/com/firebolt/jdbc/GenericWrapper.java b/src/main/java/com/firebolt/jdbc/GenericWrapper.java new file mode 100644 index 000000000..cb2f8059e --- /dev/null +++ b/src/main/java/com/firebolt/jdbc/GenericWrapper.java @@ -0,0 +1,19 @@ +package com.firebolt.jdbc; + +import java.sql.SQLException; +import java.sql.Wrapper; + +public interface GenericWrapper extends Wrapper { + @Override + default T unwrap(@SuppressWarnings("SpellCheckingInspection") Class iface) throws SQLException { + if (iface.isAssignableFrom(getClass())) { + return iface.cast(this); + } + throw new SQLException("Cannot unwrap to " + iface.getName()); + } + + @Override + default boolean isWrapperFor(@SuppressWarnings("SpellCheckingInspection") Class iface) { + return iface.isAssignableFrom(getClass()); + } +} diff --git a/src/main/java/com/firebolt/jdbc/JdbcBase.java b/src/main/java/com/firebolt/jdbc/JdbcBase.java index e12c45417..450f8c455 100644 --- a/src/main/java/com/firebolt/jdbc/JdbcBase.java +++ b/src/main/java/com/firebolt/jdbc/JdbcBase.java @@ -1,25 +1,10 @@ package com.firebolt.jdbc; -import java.sql.SQLException; import java.sql.SQLWarning; -import java.sql.Wrapper; -public class JdbcBase implements Wrapper { +public abstract class JdbcBase implements GenericWrapper { private SQLWarning firstWarning; - @Override - public T unwrap(Class iface) throws SQLException { - if (iface.isAssignableFrom(getClass())) { - return iface.cast(this); - } - throw new SQLException("Cannot unwrap to " + iface.getName()); - } - - @Override - public boolean isWrapperFor(Class iface) throws SQLException { - return iface.isAssignableFrom(getClass()); - } - public synchronized SQLWarning getWarnings() { return firstWarning; } diff --git a/src/main/java/com/firebolt/jdbc/client/account/FireboltAccount.java b/src/main/java/com/firebolt/jdbc/client/account/FireboltAccount.java index c8d2419bc..3a1750df1 100644 --- a/src/main/java/com/firebolt/jdbc/client/account/FireboltAccount.java +++ b/src/main/java/com/firebolt/jdbc/client/account/FireboltAccount.java @@ -15,6 +15,7 @@ public FireboltAccount(String id, String region, int infraVersion) { this.infraVersion = infraVersion; } + @SuppressWarnings("unused") // used by FireboltAccountRetriever that in turn calls its base class` method FireboltClient.jsonToObject() that calls this constructor by reflection FireboltAccount(JSONObject json) { this(json.getString("id"), json.getString("region"), json.optInt("infraVersion", 1)); } diff --git a/src/main/java/com/firebolt/jdbc/metadata/FireboltDatabaseMetadata.java b/src/main/java/com/firebolt/jdbc/metadata/FireboltDatabaseMetadata.java index d231fd273..f40348576 100644 --- a/src/main/java/com/firebolt/jdbc/metadata/FireboltDatabaseMetadata.java +++ b/src/main/java/com/firebolt/jdbc/metadata/FireboltDatabaseMetadata.java @@ -1,5 +1,6 @@ package com.firebolt.jdbc.metadata; +import com.firebolt.jdbc.GenericWrapper; import com.firebolt.jdbc.QueryResult; import com.firebolt.jdbc.annotation.ExcludeFromJacocoGeneratedReport; import com.firebolt.jdbc.annotation.NotImplemented; @@ -20,9 +21,9 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.Comparator; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.function.Predicate; @@ -149,7 +150,7 @@ import static java.util.stream.Collectors.toList; @SuppressWarnings("java:S6204") // compatibility with JDK 11 -public class FireboltDatabaseMetadata implements DatabaseMetaData { +public class FireboltDatabaseMetadata implements DatabaseMetaData, GenericWrapper { private static final String TABLE = "TABLE"; private static final String VIEW = "VIEW"; @@ -190,24 +191,17 @@ private ResultSet getSchemas(String query) throws SQLException { rows.add(List.of(schemaDescription.getString(TABLE_SCHEM), schemaDescription.getString(TABLE_CATALOG))); } } - return FireboltResultSet.of(QueryResult.builder() - .columns(List.of(QueryResult.Column.builder().name(TABLE_SCHEM).type(TEXT).build(), - QueryResult.Column.builder().name(TABLE_CATALOG).type(TEXT).build())) - .rows(rows).build()); + return createResultSet(Stream.of(entry(TABLE_SCHEM, TEXT), entry(TABLE_CATALOG, TEXT)), rows); } @Override public ResultSet getTableTypes() throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(List.of(QueryResult.Column.builder().name(TABLE_TYPE).type(TEXT).build())) - .rows(List.of(List.of(TABLE), List.of(VIEW))).build()); + return createResultSet(Stream.of(entry(TABLE_TYPE, TEXT)), List.of(List.of(TABLE), List.of(VIEW))); } @Override public ResultSet getCatalogs() throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Collections.singletonList(QueryResult.Column.builder().name(TABLE_CAT).type(TEXT).build())) - .rows(Collections.singletonList(Collections.singletonList(connection.getCatalog()))).build()); + return createResultSet(Stream.of(entry(TABLE_CAT, TEXT)), List.of(List.of(connection.getCatalog()))); } @Override @@ -216,54 +210,28 @@ public Connection getConnection() throws SQLException { } @Override - public String getDatabaseProductName() throws SQLException { + public String getDatabaseProductName() { return "Firebolt"; } @Override - public String getURL() throws SQLException { + public String getURL() { return url; } @Override - public String getDriverName() throws SQLException { + public String getDriverName() { return "Firebolt JDBC Driver"; } @Override - public boolean supportsTransactionIsolationLevel(int level) throws SQLException { + public boolean supportsTransactionIsolationLevel(int level) { return level == Connection.TRANSACTION_NONE; } @Override public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException { - List columns = Arrays.asList( - QueryResult.Column.builder().name(TABLE_CAT).type(TEXT).build(), - QueryResult.Column.builder().name(TABLE_SCHEM).type(TEXT).build(), - QueryResult.Column.builder().name(TABLE_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(COLUMN_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(TYPE_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(COLUMN_SIZE).type(INTEGER).build(), - QueryResult.Column.builder().name(BUFFER_LENGTH).type(INTEGER).build(), - QueryResult.Column.builder().name(DECIMAL_DIGITS).type(INTEGER).build(), - QueryResult.Column.builder().name(NUM_PREC_RADIX).type(INTEGER).build(), - QueryResult.Column.builder().name(NULLABLE).type(INTEGER).build(), - QueryResult.Column.builder().name(REMARKS).type(TEXT).build(), - QueryResult.Column.builder().name(COLUMN_DEF).type(TEXT).build(), - QueryResult.Column.builder().name(SQL_DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(SQL_DATETIME_SUB).type(INTEGER).build(), - QueryResult.Column.builder().name(CHAR_OCTET_LENGTH).type(INTEGER).build(), - QueryResult.Column.builder().name(ORDINAL_POSITION).type(INTEGER).build(), - QueryResult.Column.builder().name(IS_NULLABLE).type(TEXT).build(), - QueryResult.Column.builder().name(SCOPE_CATALOG).type(TEXT).build(), - QueryResult.Column.builder().name(SCOPE_SCHEMA).type(TEXT).build(), - QueryResult.Column.builder().name(SCOPE_TABLE).type(TEXT).build(), - QueryResult.Column.builder().name(SOURCE_DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(IS_AUTOINCREMENT).type(TEXT).build(), - QueryResult.Column.builder().name(IS_GENERATEDCOLUMN).type(TEXT).build()); - List> rows = new ArrayList<>(); String query = MetadataUtil.getColumnsQuery(schemaPattern, tableNamePattern, columnNamePattern); try (Statement statement = connection.createStatement(); @@ -299,7 +267,33 @@ public ResultSet getColumns(String catalog, String schemaPattern, String tableNa "NO", // IS_AUTOINCREMENT - Not supported "NO")); // IS_GENERATEDCOLUMN - Not supported } - return FireboltResultSet.of(QueryResult.builder().rows(rows).columns(columns).build()); + return createResultSet( + Stream.of( + entry(TABLE_CAT, TEXT), + entry(TABLE_SCHEM, TEXT), + entry(TABLE_NAME, TEXT), + entry(COLUMN_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(TYPE_NAME, TEXT), + entry(COLUMN_SIZE, INTEGER), + entry(BUFFER_LENGTH, INTEGER), + entry(DECIMAL_DIGITS, INTEGER), + entry(NUM_PREC_RADIX, INTEGER), + entry(NULLABLE, INTEGER), + entry(REMARKS, TEXT), + entry(COLUMN_DEF, TEXT), + entry(SQL_DATA_TYPE, INTEGER), + entry(SQL_DATETIME_SUB, INTEGER), + entry(CHAR_OCTET_LENGTH, INTEGER), + entry(ORDINAL_POSITION, INTEGER), + entry(IS_NULLABLE, TEXT), + entry(SCOPE_CATALOG, TEXT), + entry(SCOPE_SCHEMA, TEXT), + entry(SCOPE_TABLE, TEXT), + entry(SOURCE_DATA_TYPE, INTEGER), + entry(IS_AUTOINCREMENT, TEXT), + entry(IS_GENERATEDCOLUMN, TEXT)), + rows); } } @@ -318,10 +312,10 @@ private boolean isColumnNullable(ResultSet columnDescription) throws SQLExceptio @Override public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] typesArr) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of(TABLE_CAT, TABLE_SCHEM, TABLE_NAME, TABLE_TYPE, REMARKS, TYPE_CAT, TYPE_SCHEM, TYPE_NAME, SELF_REFERENCING_COL_NAME, REF_GENERATION) - .map(name -> QueryResult.Column.builder().name(name).type(TEXT).build()).collect(toList())) - .rows(getTablesData(catalog, schemaPattern, tableNamePattern, typesArr)).build()); + return createResultSet( + Stream.of(TABLE_CAT, TABLE_SCHEM, TABLE_NAME, TABLE_TYPE, REMARKS, TYPE_CAT, TYPE_SCHEM, TYPE_NAME, SELF_REFERENCING_COL_NAME, REF_GENERATION) + .map(name -> entry(name, TEXT)), + getTablesData(catalog, schemaPattern, tableNamePattern, typesArr)); } private List> getTablesData(String catalog, String schemaPattern, String tableNamePattern, String[] typesArr) throws SQLException { @@ -351,26 +345,6 @@ private List> getTablesData(String catalog, String schemaPattern, String @Override public ResultSet getTypeInfo() throws SQLException { - List columns = Arrays.asList( - QueryResult.Column.builder().name(TYPE_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(PRECISION).type(INTEGER).build(), - QueryResult.Column.builder().name(LITERAL_PREFIX).type(TEXT).build(), - QueryResult.Column.builder().name(LITERAL_SUFFIX).type(TEXT).build(), - QueryResult.Column.builder().name(CREATE_PARAMS).type(TEXT).build(), - QueryResult.Column.builder().name(NULLABLE).type(INTEGER).build(), - QueryResult.Column.builder().name(CASE_SENSITIVE).type(BOOLEAN).build(), - QueryResult.Column.builder().name(SEARCHABLE).type(INTEGER).build(), - QueryResult.Column.builder().name(UNSIGNED_ATTRIBUTE).type(BOOLEAN).build(), - QueryResult.Column.builder().name(FIXED_PREC_SCALE).type(BOOLEAN).build(), - QueryResult.Column.builder().name(AUTO_INCREMENT).type(BOOLEAN).build(), - QueryResult.Column.builder().name(LOCAL_TYPE_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(MINIMUM_SCALE).type(INTEGER).build(), - QueryResult.Column.builder().name(MAXIMUM_SCALE).type(INTEGER).build(), - QueryResult.Column.builder().name(SQL_DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(SQL_DATETIME_SUB).type(INTEGER).build(), - QueryResult.Column.builder().name(NUM_PREC_RADIX).type(INTEGER).build()); - List usableTypes = Arrays.asList(INTEGER, BIG_INT, REAL, DOUBLE_PRECISION, TEXT, DATE, TIMESTAMP, NUMERIC, ARRAY, TUPLE, BYTEA, BOOLEAN); List> rows = usableTypes.stream().map(type -> @@ -398,7 +372,27 @@ public ResultSet getTypeInfo() throws SQLException { COMMON_RADIX)) .collect(toList()); - return FireboltResultSet.of(QueryResult.builder().columns(columns).rows(rows).build()); + return createResultSet( + Stream.of( + entry(TYPE_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(PRECISION, INTEGER), + entry(LITERAL_PREFIX, TEXT), + entry(LITERAL_SUFFIX, TEXT), + entry(CREATE_PARAMS, TEXT), + entry(NULLABLE, INTEGER), + entry(CASE_SENSITIVE, BOOLEAN), + entry(SEARCHABLE, INTEGER), + entry(UNSIGNED_ATTRIBUTE, BOOLEAN), + entry(FIXED_PREC_SCALE, BOOLEAN), + entry(AUTO_INCREMENT, BOOLEAN), + entry(LOCAL_TYPE_NAME, TEXT), + entry(MINIMUM_SCALE, INTEGER), + entry(MAXIMUM_SCALE, INTEGER), + entry(SQL_DATA_TYPE, INTEGER), + entry(SQL_DATETIME_SUB, INTEGER), + entry(NUM_PREC_RADIX, INTEGER)), + rows); } @Override @@ -432,45 +426,32 @@ public int getDatabaseMinorVersion() throws SQLException { } @Override - public int getJDBCMajorVersion() throws SQLException { + public int getJDBCMajorVersion() { return VersionUtil.extractMajorVersion(VersionUtil.getSpecificationVersion()); } @Override - public int getJDBCMinorVersion() throws SQLException { + public int getJDBCMinorVersion() { return VersionUtil.extractMinorVersion(VersionUtil.getSpecificationVersion()); } @Override - public String getDriverVersion() throws SQLException { + public String getDriverVersion() { return VersionUtil.getDriverVersion(); } @Override - public boolean isWrapperFor(Class iface) throws SQLException { - return iface.isAssignableFrom(getClass()); - } - - @Override - public T unwrap(Class iface) throws SQLException { - if (isWrapperFor(iface)) { - return iface.cast(this); - } - throw new SQLException("Cannot unwrap to " + iface.getName()); - } - - @Override - public boolean allProceduresAreCallable() throws SQLException { + public boolean allProceduresAreCallable() { return false; } @Override - public boolean allTablesAreSelectable() throws SQLException { + public boolean allTablesAreSelectable() { return true; } @Override - public String getUserName() throws SQLException { + public String getUserName() { return connection.getSessionProperties().getPrincipal(); } @@ -480,77 +461,77 @@ public boolean isReadOnly() throws SQLException { } @Override - public boolean nullsAreSortedHigh() throws SQLException { + public boolean nullsAreSortedHigh() { return false; } @Override - public boolean nullsAreSortedLow() throws SQLException { + public boolean nullsAreSortedLow() { return !nullsAreSortedHigh(); } @Override - public boolean nullsAreSortedAtStart() throws SQLException { + public boolean nullsAreSortedAtStart() { return false; } @Override - public boolean nullsAreSortedAtEnd() throws SQLException { + public boolean nullsAreSortedAtEnd() { return !nullsAreSortedAtStart(); } @Override - public boolean usesLocalFiles() throws SQLException { + public boolean usesLocalFiles() { return false; } @Override - public boolean usesLocalFilePerTable() throws SQLException { + public boolean usesLocalFilePerTable() { return false; } @Override - public boolean supportsMixedCaseIdentifiers() throws SQLException { + public boolean supportsMixedCaseIdentifiers() { return false; } @Override - public boolean storesUpperCaseIdentifiers() throws SQLException { + public boolean storesUpperCaseIdentifiers() { return false; } @Override - public boolean storesLowerCaseIdentifiers() throws SQLException { + public boolean storesLowerCaseIdentifiers() { return true; } @Override - public boolean storesMixedCaseIdentifiers() throws SQLException { + public boolean storesMixedCaseIdentifiers() { return false; } @Override - public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException { + public boolean supportsMixedCaseQuotedIdentifiers() { return true; } @Override - public boolean storesUpperCaseQuotedIdentifiers() throws SQLException { + public boolean storesUpperCaseQuotedIdentifiers() { return false; } @Override - public boolean storesLowerCaseQuotedIdentifiers() throws SQLException { + public boolean storesLowerCaseQuotedIdentifiers() { return false; } @Override - public boolean storesMixedCaseQuotedIdentifiers() throws SQLException { + public boolean storesMixedCaseQuotedIdentifiers() { return true; } @Override - public String getIdentifierQuoteString() throws SQLException { + public String getIdentifierQuoteString() { return "\""; } @@ -585,102 +566,101 @@ public String getTimeDateFunctions() { } @Override - public String getSearchStringEscape() throws SQLException { + public String getSearchStringEscape() { return "\\"; } /** * Returns empty string for compatibility with PostgreSQL. * @return empty string - * @throws SQLException - if fact does not throw exception because the implementation is trivial */ @Override - public String getExtraNameCharacters() throws SQLException { + public String getExtraNameCharacters() { return ""; } @Override - public boolean supportsAlterTableWithAddColumn() throws SQLException { + public boolean supportsAlterTableWithAddColumn() { return false; } @Override - public boolean supportsAlterTableWithDropColumn() throws SQLException { + public boolean supportsAlterTableWithDropColumn() { return false; } @Override - public boolean supportsColumnAliasing() throws SQLException { + public boolean supportsColumnAliasing() { return true; } @Override - public boolean nullPlusNonNullIsNull() throws SQLException { + public boolean nullPlusNonNullIsNull() { return true; } @Override - public boolean supportsConvert() throws SQLException { + public boolean supportsConvert() { return false; } @Override - public boolean supportsConvert(int fromType, int toType) throws SQLException { + public boolean supportsConvert(int fromType, int toType) { return false; } @Override - public boolean supportsTableCorrelationNames() throws SQLException { + public boolean supportsTableCorrelationNames() { return true; } @Override - public boolean supportsDifferentTableCorrelationNames() throws SQLException { + public boolean supportsDifferentTableCorrelationNames() { return false; } @Override - public boolean supportsExpressionsInOrderBy() throws SQLException { + public boolean supportsExpressionsInOrderBy() { return true; } @Override - public boolean supportsOrderByUnrelated() throws SQLException { + public boolean supportsOrderByUnrelated() { return true; } @Override - public boolean supportsGroupBy() throws SQLException { + public boolean supportsGroupBy() { return true; } @Override - public boolean supportsGroupByUnrelated() throws SQLException { + public boolean supportsGroupByUnrelated() { return false; } @Override - public boolean supportsGroupByBeyondSelect() throws SQLException { + public boolean supportsGroupByBeyondSelect() { return false; } @Override - public boolean supportsLikeEscapeClause() throws SQLException { + public boolean supportsLikeEscapeClause() { return false; } @Override - public boolean supportsMultipleResultSets() throws SQLException { + public boolean supportsMultipleResultSets() { return false; } @Override - public boolean supportsMultipleTransactions() throws SQLException { + public boolean supportsMultipleTransactions() { return false; } @Override - public boolean supportsNonNullableColumns() throws SQLException { + public boolean supportsNonNullableColumns() { return true; } @@ -692,7 +672,7 @@ public boolean supportsNonNullableColumns() throws SQLException { * @throws SQLException - actually never throws */ @Override - public boolean supportsMinimumSQLGrammar() throws SQLException { + public boolean supportsMinimumSQLGrammar() { return true; } @@ -700,363 +680,362 @@ public boolean supportsMinimumSQLGrammar() throws SQLException { * Does this driver support the Core ODBC SQL grammar. We need SQL-92 conformance for this. * * @return false - * @throws SQLException if a database access error occurs */ @Override - public boolean supportsCoreSQLGrammar() throws SQLException { + public boolean supportsCoreSQLGrammar() { return false; } @Override - public boolean supportsExtendedSQLGrammar() throws SQLException { + public boolean supportsExtendedSQLGrammar() { return false; } @Override - public boolean supportsANSI92EntryLevelSQL() throws SQLException { + public boolean supportsANSI92EntryLevelSQL() { // We do not support it (eg: we would need to be compliant with JDBC and support 'schema') return false; } @Override - public boolean supportsANSI92IntermediateSQL() throws SQLException { + public boolean supportsANSI92IntermediateSQL() { return false; } @Override - public boolean supportsANSI92FullSQL() throws SQLException { + public boolean supportsANSI92FullSQL() { return false; } @Override - public boolean supportsIntegrityEnhancementFacility() throws SQLException { + public boolean supportsIntegrityEnhancementFacility() { // Similar approach as pgjdbc: we assume it means supported constraints return false; } @Override - public boolean supportsOuterJoins() throws SQLException { + public boolean supportsOuterJoins() { return true; } @Override - public boolean supportsFullOuterJoins() throws SQLException { + public boolean supportsFullOuterJoins() { return true; } @Override - public boolean supportsLimitedOuterJoins() throws SQLException { + public boolean supportsLimitedOuterJoins() { return true; } @Override - public String getSchemaTerm() throws SQLException { + public String getSchemaTerm() { return "schema"; } @Override - public String getProcedureTerm() throws SQLException { + public String getProcedureTerm() { return "procedure"; } @Override - public String getCatalogTerm() throws SQLException { + public String getCatalogTerm() { return "database"; } @Override - public boolean isCatalogAtStart() throws SQLException { + public boolean isCatalogAtStart() { // it is currently not supported but it will be soon return false; } @Override - public String getCatalogSeparator() throws SQLException { + public String getCatalogSeparator() { return "."; } @Override - public boolean supportsSchemasInDataManipulation() throws SQLException { + public boolean supportsSchemasInDataManipulation() { return false; } @Override - public boolean supportsSchemasInProcedureCalls() throws SQLException { + public boolean supportsSchemasInProcedureCalls() { return false; } @Override - public boolean supportsSchemasInTableDefinitions() throws SQLException { + public boolean supportsSchemasInTableDefinitions() { return false; } @Override - public boolean supportsSchemasInIndexDefinitions() throws SQLException { + public boolean supportsSchemasInIndexDefinitions() { return false; } @Override - public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException { + public boolean supportsSchemasInPrivilegeDefinitions() { return false; } @Override - public boolean supportsCatalogsInDataManipulation() throws SQLException { + public boolean supportsCatalogsInDataManipulation() { return false; } @Override - public boolean supportsCatalogsInProcedureCalls() throws SQLException { + public boolean supportsCatalogsInProcedureCalls() { return false; } @Override - public boolean supportsCatalogsInTableDefinitions() throws SQLException { + public boolean supportsCatalogsInTableDefinitions() { return false; } @Override - public boolean supportsCatalogsInIndexDefinitions() throws SQLException { + public boolean supportsCatalogsInIndexDefinitions() { return false; } @Override - public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException { + public boolean supportsCatalogsInPrivilegeDefinitions() { return false; } @Override - public boolean supportsPositionedDelete() throws SQLException { + public boolean supportsPositionedDelete() { return false; } @Override - public boolean supportsPositionedUpdate() throws SQLException { + public boolean supportsPositionedUpdate() { return false; } @Override - public boolean supportsSelectForUpdate() throws SQLException { + public boolean supportsSelectForUpdate() { return false; } @Override - public boolean supportsStoredProcedures() throws SQLException { + public boolean supportsStoredProcedures() { return false; } @Override - public boolean supportsSubqueriesInComparisons() throws SQLException { + public boolean supportsSubqueriesInComparisons() { return true; } @Override - public boolean supportsSubqueriesInExists() throws SQLException { + public boolean supportsSubqueriesInExists() { return true; } @Override - public boolean supportsSubqueriesInIns() throws SQLException { + public boolean supportsSubqueriesInIns() { return true; } @Override - public boolean supportsSubqueriesInQuantifieds() throws SQLException { + public boolean supportsSubqueriesInQuantifieds() { return false; } @Override - public boolean supportsCorrelatedSubqueries() throws SQLException { + public boolean supportsCorrelatedSubqueries() { return true; } @Override - public boolean supportsUnion() throws SQLException { + public boolean supportsUnion() { return true; } @Override - public boolean supportsUnionAll() throws SQLException { + public boolean supportsUnionAll() { return true; } @Override - public boolean supportsOpenCursorsAcrossCommit() throws SQLException { + public boolean supportsOpenCursorsAcrossCommit() { return false; } @Override - public boolean supportsOpenCursorsAcrossRollback() throws SQLException { + public boolean supportsOpenCursorsAcrossRollback() { return false; } @Override - public boolean supportsOpenStatementsAcrossCommit() throws SQLException { + public boolean supportsOpenStatementsAcrossCommit() { return false; } @Override - public boolean supportsOpenStatementsAcrossRollback() throws SQLException { + public boolean supportsOpenStatementsAcrossRollback() { return false; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxBinaryLiteralLength() throws SQLException { + public int getMaxBinaryLiteralLength() { return MAX_LITERAL_LENGTH; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxCharLiteralLength() throws SQLException { + public int getMaxCharLiteralLength() { return MAX_LITERAL_LENGTH; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxColumnNameLength() throws SQLException { + public int getMaxColumnNameLength() { return MAX_IDENTIFIER_LENGTH; } @Override - public int getMaxColumnsInGroupBy() throws SQLException { + public int getMaxColumnsInGroupBy() { return 0x10000; //65536 } /** * Indexes are not supported, so the value is irrelevant. * @return 0 - * @throws SQLException never thrown */ - public int getMaxColumnsInIndex() throws SQLException { + public int getMaxColumnsInIndex() { return 0; } @Override - public int getMaxColumnsInOrderBy() throws SQLException { + public int getMaxColumnsInOrderBy() { return 16384; } @Override - public int getMaxColumnsInSelect() throws SQLException { + public int getMaxColumnsInSelect() { return 8192; } @Override - public int getMaxColumnsInTable() throws SQLException { + public int getMaxColumnsInTable() { return 1000; } @Override - public int getMaxConnections() throws SQLException { + public int getMaxConnections() { return 0; } @Override - public int getMaxCursorNameLength() throws SQLException { + public int getMaxCursorNameLength() { return 0; } @Override - public int getMaxIndexLength() throws SQLException { + public int getMaxIndexLength() { return 0; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxSchemaNameLength() throws SQLException { + public int getMaxSchemaNameLength() { return MAX_IDENTIFIER_LENGTH; } @Override - public int getMaxProcedureNameLength() throws SQLException { + public int getMaxProcedureNameLength() { return 0; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxCatalogNameLength() throws SQLException { + public int getMaxCatalogNameLength() { return MAX_IDENTIFIER_LENGTH; } @Override @ExcludeFromJacocoGeneratedReport @NotImplemented - public int getMaxRowSize() throws SQLException { + public int getMaxRowSize() { return 0; } @Override @ExcludeFromJacocoGeneratedReport - public boolean doesMaxRowSizeIncludeBlobs() throws SQLException { + public boolean doesMaxRowSizeIncludeBlobs() { return false; } @Override @ExcludeFromJacocoGeneratedReport @NotImplemented - public int getMaxStatementLength() throws SQLException { + public int getMaxStatementLength() { return 0; } @Override - public int getMaxStatements() throws SQLException { + public int getMaxStatements() { return 0; } @Override @SuppressWarnings("java:S4144") // identical implementation - public int getMaxTableNameLength() throws SQLException { + public int getMaxTableNameLength() { return MAX_IDENTIFIER_LENGTH; } @Override - public int getMaxTablesInSelect() throws SQLException { + public int getMaxTablesInSelect() { return 0; } @Override - public int getMaxUserNameLength() throws SQLException { + @SuppressWarnings("java:S4144") // identical implementation + public int getMaxUserNameLength() { return MAX_IDENTIFIER_LENGTH; } @Override - public int getDefaultTransactionIsolation() throws SQLException { + public int getDefaultTransactionIsolation() { return Connection.TRANSACTION_NONE; } @Override - public boolean supportsTransactions() throws SQLException { + public boolean supportsTransactions() { return false; } @Override - public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException { + public boolean supportsDataDefinitionAndDataManipulationTransactions() { return false; } @Override - public boolean supportsDataManipulationTransactionsOnly() throws SQLException { + public boolean supportsDataManipulationTransactionsOnly() { return false; } @Override - public boolean dataDefinitionCausesTransactionCommit() throws SQLException { + public boolean dataDefinitionCausesTransactionCommit() { return false; } @Override - public boolean dataDefinitionIgnoredInTransactions() throws SQLException { + public boolean dataDefinitionIgnoredInTransactions() { return false; } @Override - public boolean supportsResultSetType(int type) throws SQLException { + public boolean supportsResultSetType(int type) { return TYPE_FORWARD_ONLY == type; } @Override - public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException { + public boolean supportsResultSetConcurrency(int type, int concurrency) { return type == ResultSet.TYPE_FORWARD_ONLY && concurrency == ResultSet.CONCUR_READ_ONLY; } @@ -1065,79 +1044,79 @@ public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQ * since we do not support updating ResultSet objects */ @Override - public boolean ownUpdatesAreVisible(int type) throws SQLException { + public boolean ownUpdatesAreVisible(int type) { return false; } @Override - public boolean ownDeletesAreVisible(int type) throws SQLException { + public boolean ownDeletesAreVisible(int type) { return false; } @Override - public boolean ownInsertsAreVisible(int type) throws SQLException { + public boolean ownInsertsAreVisible(int type) { return false; } @Override - public boolean othersUpdatesAreVisible(int type) throws SQLException { + public boolean othersUpdatesAreVisible(int type) { return false; } @Override - public boolean othersDeletesAreVisible(int type) throws SQLException { + public boolean othersDeletesAreVisible(int type) { return false; } @Override - public boolean othersInsertsAreVisible(int type) throws SQLException { + public boolean othersInsertsAreVisible(int type) { return false; } @Override - public boolean updatesAreDetected(int type) throws SQLException { + public boolean updatesAreDetected(int type) { return false; } @Override - public boolean deletesAreDetected(int type) throws SQLException { + public boolean deletesAreDetected(int type) { return false; } @Override - public boolean insertsAreDetected(int type) throws SQLException { + public boolean insertsAreDetected(int type) { return false; } @Override - public boolean supportsBatchUpdates() throws SQLException { + public boolean supportsBatchUpdates() { // We support it partially (via FireboltPreparedStatement but not with the // 'basic' FireboltStatement ) return false; } @Override - public boolean supportsSavepoints() throws SQLException { + public boolean supportsSavepoints() { return false; } @Override - public boolean supportsNamedParameters() throws SQLException { + public boolean supportsNamedParameters() { return false; } @Override - public boolean supportsMultipleOpenResults() throws SQLException { + public boolean supportsMultipleOpenResults() { return false; } @Override - public boolean supportsGetGeneratedKeys() throws SQLException { + public boolean supportsGetGeneratedKeys() { return false; } @Override - public boolean supportsResultSetHoldability(int holdability) throws SQLException { + public boolean supportsResultSetHoldability(int holdability) { return holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT; } @@ -1145,174 +1124,144 @@ public boolean supportsResultSetHoldability(int holdability) throws SQLException * Since Firebolt does not support transactions commit does not affect the existing {@code ResultSet} and therefore * it behaves as if it is held between transaction. Therefore, it returns {@link ResultSet#HOLD_CURSORS_OVER_COMMIT} * @return {@link ResultSet#HOLD_CURSORS_OVER_COMMIT} - * @throws SQLException if something is going wrong */ @Override - public int getResultSetHoldability() throws SQLException { + public int getResultSetHoldability() { return ResultSet.HOLD_CURSORS_OVER_COMMIT; } @Override - public int getSQLStateType() throws SQLException { + public int getSQLStateType() { return sqlStateSQL; } @Override - public boolean locatorsUpdateCopy() throws SQLException { + public boolean locatorsUpdateCopy() { return false; } @Override - public boolean supportsStatementPooling() throws SQLException { + public boolean supportsStatementPooling() { return false; } @Override - public RowIdLifetime getRowIdLifetime() throws SQLException { + public RowIdLifetime getRowIdLifetime() { return RowIdLifetime.ROWID_UNSUPPORTED; } @Override - public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException { + public boolean supportsStoredFunctionsUsingCallSyntax() { return false; } @Override - public boolean autoCommitFailureClosesAllResultSets() throws SQLException { + public boolean autoCommitFailureClosesAllResultSets() { return false; } @Override public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(PROCEDURE_CAT, TEXT), - entry(PROCEDURE_SCHEM, TEXT), - entry(PROCEDURE_NAME, TEXT), - entry(COLUMN_NAME, TEXT), - entry(COLUMN_TYPE, INTEGER), // Short - entry(DATA_TYPE, INTEGER), - entry(TYPE_NAME, TEXT), - entry(PRECISION, INTEGER), - entry(LENGTH, INTEGER), - entry(SCALE, INTEGER), // short - entry(RADIX, INTEGER), // short - entry(NULLABLE, INTEGER), // short - entry(REMARKS, TEXT), - entry(COLUMN_DEF, TEXT), - entry(SQL_DATA_TYPE, INTEGER), - entry(SQL_DATETIME_SUB, INTEGER), - entry(CHAR_OCTET_LENGTH, INTEGER), - entry(ORDINAL_POSITION, INTEGER), - entry(IS_NULLABLE, TEXT), - entry(SPECIFIC_NAME, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(PROCEDURE_CAT, TEXT), + entry(PROCEDURE_SCHEM, TEXT), + entry(PROCEDURE_NAME, TEXT), + entry(COLUMN_NAME, TEXT), + entry(COLUMN_TYPE, INTEGER), // Short + entry(DATA_TYPE, INTEGER), + entry(TYPE_NAME, TEXT), + entry(PRECISION, INTEGER), + entry(LENGTH, INTEGER), + entry(SCALE, INTEGER), // short + entry(RADIX, INTEGER), // short + entry(NULLABLE, INTEGER), // short + entry(REMARKS, TEXT), + entry(COLUMN_DEF, TEXT), + entry(SQL_DATA_TYPE, INTEGER), + entry(SQL_DATETIME_SUB, INTEGER), + entry(CHAR_OCTET_LENGTH, INTEGER), + entry(ORDINAL_POSITION, INTEGER), + entry(IS_NULLABLE, TEXT), + entry(SPECIFIC_NAME, TEXT) + )); } @Override public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TYPE_CAT, TEXT), - entry(TYPE_SCHEM, TEXT), - entry(TYPE_NAME, TEXT), - entry(CLASS_NAME, TEXT), - entry(DATA_TYPE, INTEGER), - entry(REMARKS, TEXT), - entry(BASE_TYPE, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TYPE_CAT, TEXT), + entry(TYPE_SCHEM, TEXT), + entry(TYPE_NAME, TEXT), + entry(CLASS_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(REMARKS, TEXT), + entry(BASE_TYPE, INTEGER) // short + )); } @Override public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TYPE_CAT, TEXT), - entry(TYPE_SCHEM, TEXT), - entry(TYPE_NAME, TEXT), - entry(SUPERTYPE_CAT, TEXT), - entry(SUPERTYPE_SCHEM, TEXT), - entry(SUPERTYPE_NAME, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TYPE_CAT, TEXT), + entry(TYPE_SCHEM, TEXT), + entry(TYPE_NAME, TEXT), + entry(SUPERTYPE_CAT, TEXT), + entry(SUPERTYPE_SCHEM, TEXT), + entry(SUPERTYPE_NAME, TEXT) + )); } @Override public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TYPE_CAT, TEXT), - entry(TYPE_SCHEM, TEXT), - entry(TYPE_NAME, TEXT), - entry(SUPERTABLE_NAME, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TYPE_CAT, TEXT), + entry(TYPE_SCHEM, TEXT), + entry(TYPE_NAME, TEXT), + entry(SUPERTABLE_NAME, TEXT) + )); } @Override public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TYPE_CAT, TEXT), - entry(TYPE_SCHEM, TEXT), - entry(TYPE_NAME, TEXT), - entry(ATTR_NAME, TEXT), - entry(DATA_TYPE, INTEGER), - entry(ATTR_TYPE_NAME, TEXT), - entry(ATTR_SIZE, INTEGER), - entry(DECIMAL_DIGITS, INTEGER), - entry(NUM_PREC_RADIX, INTEGER), - entry(NULLABLE, INTEGER), - entry(REMARKS, TEXT), - entry(ATTR_DEF, TEXT), - entry(SQL_DATA_TYPE, INTEGER), - entry(SQL_DATETIME_SUB, INTEGER), - entry(CHAR_OCTET_LENGTH, INTEGER), - entry(ORDINAL_POSITION, INTEGER), - entry(IS_NULLABLE, TEXT), - entry(SCOPE_CATALOG, TEXT), - entry(SCOPE_SCHEMA, TEXT), - entry(SCOPE_TABLE, TEXT), - entry(SOURCE_DATA_TYPE, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TYPE_CAT, TEXT), + entry(TYPE_SCHEM, TEXT), + entry(TYPE_NAME, TEXT), + entry(ATTR_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(ATTR_TYPE_NAME, TEXT), + entry(ATTR_SIZE, INTEGER), + entry(DECIMAL_DIGITS, INTEGER), + entry(NUM_PREC_RADIX, INTEGER), + entry(NULLABLE, INTEGER), + entry(REMARKS, TEXT), + entry(ATTR_DEF, TEXT), + entry(SQL_DATA_TYPE, INTEGER), + entry(SQL_DATETIME_SUB, INTEGER), + entry(CHAR_OCTET_LENGTH, INTEGER), + entry(ORDINAL_POSITION, INTEGER), + entry(IS_NULLABLE, TEXT), + entry(SCOPE_CATALOG, TEXT), + entry(SCOPE_SCHEMA, TEXT), + entry(SCOPE_TABLE, TEXT), + entry(SOURCE_DATA_TYPE, INTEGER) // short + )); } @Override public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(PROCEDURE_CAT, TEXT), - entry(PROCEDURE_SCHEM, TEXT), - entry(PROCEDURE_NAME, TEXT), - entry(REMARKS, TEXT), - entry(PROCEDURE_TYPE, INTEGER), // short - entry(SPECIFIC_NAME, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(PROCEDURE_CAT, TEXT), + entry(PROCEDURE_SCHEM, TEXT), + entry(PROCEDURE_NAME, TEXT), + entry(REMARKS, TEXT), + entry(PROCEDURE_TYPE, INTEGER), // short + entry(SPECIFIC_NAME, TEXT) + )); } @Override public ResultSet getColumnPrivileges(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException { - List columns = Stream.of( - entry(TABLE_CAT, TEXT), - entry(TABLE_SCHEM, TEXT), - entry(TABLE_NAME, TEXT), - entry(COLUMN_NAME, TEXT), - entry(GRANTOR, TEXT), - entry(GRANTEE, TEXT), - entry(PRIVILEGE, TEXT), - entry(IS_GRANTABLE, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList()); - List> rows = new ArrayList<>(); String query = MetadataUtil.getColumnsQuery(schemaPattern, tableNamePattern, columnNamePattern); try (Statement statement = connection.createStatement(); @@ -1328,21 +1277,20 @@ public ResultSet getColumnPrivileges(String catalog, String schemaPattern, Strin "NO")); // is_grantable } } - return FireboltResultSet.of(QueryResult.builder().columns(columns).rows(rows).build()); - } - - @Override - public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException { - List columns = Stream.of( + return createResultSet(Stream.of( entry(TABLE_CAT, TEXT), entry(TABLE_SCHEM, TEXT), entry(TABLE_NAME, TEXT), + entry(COLUMN_NAME, TEXT), entry(GRANTOR, TEXT), entry(GRANTEE, TEXT), entry(PRIVILEGE, TEXT), entry(IS_GRANTABLE, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList()); + ), rows); + } + @Override + public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException { List> rows = new ArrayList<>(); String query = MetadataUtil.getTablesQuery(catalog, schemaPattern, tableNamePattern, new String[] {"BASE TABLE", "DIMENSION", "FACT"}); try (Statement statement = connection.createStatement(); @@ -1357,172 +1305,122 @@ public ResultSet getTablePrivileges(String catalog, String schemaPattern, String "NO")); // is_grantable } } - return FireboltResultSet.of(QueryResult.builder().columns(columns).rows(rows).build()); + return createResultSet(Stream.of( + entry(TABLE_CAT, TEXT), + entry(TABLE_SCHEM, TEXT), + entry(TABLE_NAME, TEXT), + entry(GRANTOR, TEXT), + entry(GRANTEE, TEXT), + entry(PRIVILEGE, TEXT), + entry(IS_GRANTABLE, TEXT) + ), rows); } @Override public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(SCOPE, INTEGER), // short - entry(COLUMN_NAME, TEXT), - entry(DATA_TYPE, INTEGER), - entry(TYPE_NAME, TEXT), - entry(COLUMN_SIZE, INTEGER), - entry(BUFFER_LENGTH, INTEGER), - entry(DECIMAL_DIGITS, INTEGER), // short - entry(PSEUDO_COLUMN, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(SCOPE, INTEGER), // short + entry(COLUMN_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(TYPE_NAME, TEXT), + entry(COLUMN_SIZE, INTEGER), + entry(BUFFER_LENGTH, INTEGER), + entry(DECIMAL_DIGITS, INTEGER), // short + entry(PSEUDO_COLUMN, INTEGER) // short + )); } @Override public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(SCOPE, INTEGER), // short - entry(COLUMN_NAME, TEXT), - entry(DATA_TYPE, INTEGER), - entry(TYPE_NAME, TEXT), - entry(COLUMN_SIZE, INTEGER), - entry(BUFFER_LENGTH, INTEGER), - entry(DECIMAL_DIGITS, INTEGER), // short - entry(PSEUDO_COLUMN, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(SCOPE, INTEGER), // short + entry(COLUMN_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(TYPE_NAME, TEXT), + entry(COLUMN_SIZE, INTEGER), + entry(BUFFER_LENGTH, INTEGER), + entry(DECIMAL_DIGITS, INTEGER), // short + entry(PSEUDO_COLUMN, INTEGER) // short + )); } @Override public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TABLE_CAT, TEXT), - entry(TABLE_SCHEM, TEXT), - entry(TABLE_NAME, TEXT), - entry(COLUMN_NAME, TEXT), - entry(KEY_SEQ, INTEGER), // short - entry(PK_NAME, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TABLE_CAT, TEXT), + entry(TABLE_SCHEM, TEXT), + entry(TABLE_NAME, TEXT), + entry(COLUMN_NAME, TEXT), + entry(KEY_SEQ, INTEGER), // short + entry(PK_NAME, TEXT) + )); } @Override public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(PKTABLE_CAT, TEXT), - entry(PKTABLE_SCHEM, TEXT), - entry(PKTABLE_NAME, TEXT), - entry(PKCOLUMN_NAME, TEXT), - entry(FKTABLE_CAT, TEXT), - entry(FKTABLE_SCHEM, TEXT), - entry(FKTABLE_NAME, TEXT), - entry(FKCOLUMN_NAME, TEXT), - entry(KEY_SEQ, INTEGER), // short - entry(UPDATE_RULE, INTEGER), // short - entry(DELETE_RULE, INTEGER), // short - entry(FK_NAME, TEXT), - entry(PK_NAME, TEXT), - entry(DEFERRABILITY, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return getKeys(); } @Override public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(PKTABLE_CAT, TEXT), - entry(PKTABLE_SCHEM, TEXT), - entry(PKTABLE_NAME, TEXT), - entry(PKCOLUMN_NAME, TEXT), - entry(FKTABLE_CAT, TEXT), - entry(FKTABLE_SCHEM, TEXT), - entry(FKTABLE_NAME, TEXT), - entry(FKCOLUMN_NAME, TEXT), - entry(KEY_SEQ, INTEGER), // short - entry(UPDATE_RULE, INTEGER), // short - entry(DELETE_RULE, INTEGER), // short - entry(FK_NAME, TEXT), - entry(PK_NAME, TEXT), - entry(DEFERRABILITY, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return getKeys(); } - @Override public ResultSet getCrossReference(String parentCatalog, String parentSchema, String parentTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(PKTABLE_CAT, TEXT), - entry(PKTABLE_SCHEM, TEXT), - entry(PKTABLE_NAME, TEXT), - entry(PKCOLUMN_NAME, TEXT), - entry(FKTABLE_CAT, TEXT), - entry(FKTABLE_SCHEM, TEXT), - entry(FKTABLE_NAME, TEXT), - entry(FKCOLUMN_NAME, TEXT), - entry(KEY_SEQ, INTEGER), // short - entry(UPDATE_RULE, INTEGER), // short - entry(DELETE_RULE, INTEGER), // short - entry(FK_NAME, TEXT), - entry(PK_NAME, TEXT), - entry(DEFERRABILITY, INTEGER) // short - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return getKeys(); + } + + private ResultSet getKeys() throws SQLException { + return createEmptyResultSet(Stream.of( + entry(PKTABLE_CAT, TEXT), + entry(PKTABLE_SCHEM, TEXT), + entry(PKTABLE_NAME, TEXT), + entry(PKCOLUMN_NAME, TEXT), + entry(FKTABLE_CAT, TEXT), + entry(FKTABLE_SCHEM, TEXT), + entry(FKTABLE_NAME, TEXT), + entry(FKCOLUMN_NAME, TEXT), + entry(KEY_SEQ, INTEGER), // short + entry(UPDATE_RULE, INTEGER), // short + entry(DELETE_RULE, INTEGER), // short + entry(FK_NAME, TEXT), + entry(PK_NAME, TEXT), + entry(DEFERRABILITY, INTEGER) // short + )); } @Override public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TABLE_CAT, TEXT), - entry(TABLE_SCHEM, TEXT), - entry(TABLE_NAME, TEXT), - entry(NON_UNIQUE, BOOLEAN), - entry(INDEX_QUALIFIER, TEXT), - entry(INDEX_NAME, TEXT), - entry(TYPE, INTEGER), // short - entry(ORDINAL_POSITION, INTEGER), // short - entry(COLUMN_NAME, TEXT), - entry(ASC_OR_DESC, TEXT), - entry(CARDINALITY, BIG_INT), // long - entry(PAGES, BIG_INT), // long - entry(FILTER_CONDITION, INTEGER) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TABLE_CAT, TEXT), + entry(TABLE_SCHEM, TEXT), + entry(TABLE_NAME, TEXT), + entry(NON_UNIQUE, BOOLEAN), + entry(INDEX_QUALIFIER, TEXT), + entry(INDEX_NAME, TEXT), + entry(TYPE, INTEGER), // short + entry(ORDINAL_POSITION, INTEGER), // short + entry(COLUMN_NAME, TEXT), + entry(ASC_OR_DESC, TEXT), + entry(CARDINALITY, BIG_INT), // long + entry(PAGES, BIG_INT), // long + entry(FILTER_CONDITION, INTEGER) + )); } @Override public ResultSet getClientInfoProperties() throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(NAME, TEXT), - entry(MAX_LEN, INTEGER), - entry(DEFAULT_VALUE, TEXT), - entry(DESCRIPTION, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(NAME, TEXT), + entry(MAX_LEN, INTEGER), + entry(DEFAULT_VALUE, TEXT), + entry(DESCRIPTION, TEXT) + )); } @Override public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException { - List columns = Arrays.asList( - QueryResult.Column.builder().name(FUNCTION_CAT).type(TEXT).build(), - QueryResult.Column.builder().name(FUNCTION_SCHEM).type(TEXT).build(), - QueryResult.Column.builder().name(FUNCTION_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(REMARKS).type(TEXT).build(), - QueryResult.Column.builder().name(FUNCTION_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(SPECIFIC_NAME).type(TEXT).build()); Predicate functionFilter = functionNamePattern == null ? f -> true : compile(functionNamePattern, CASE_INSENSITIVE).asPredicate(); List> rows = Arrays.stream(String.join(",", getStringFunctions(), getNumericFunctions(), getTimeDateFunctions(), getSystemFunctions()).split(",")) @@ -1532,31 +1430,17 @@ public ResultSet getFunctions(String catalog, String schemaPattern, String funct .distinct() // some functions belong to different categories, e.g. TO_DATE is both date-time and string function .map(function -> Arrays.asList(null, null, function, null, functionNoTable, function)) .collect(toList()); - return FireboltResultSet.of(QueryResult.builder().columns(columns).rows(rows).build()); + return createResultSet(Stream.of( + entry(FUNCTION_CAT, TEXT), + entry(FUNCTION_SCHEM, TEXT), + entry(FUNCTION_NAME, TEXT), + entry(REMARKS, TEXT), + entry(FUNCTION_TYPE, INTEGER), + entry(SPECIFIC_NAME, TEXT)), rows); } @Override public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException { - - List columns = Arrays.asList( - QueryResult.Column.builder().name(FUNCTION_CAT).type(TEXT).build(), - QueryResult.Column.builder().name(FUNCTION_SCHEM).type(TEXT).build(), - QueryResult.Column.builder().name(FUNCTION_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(COLUMN_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(COLUMN_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(DATA_TYPE).type(INTEGER).build(), - QueryResult.Column.builder().name(TYPE_NAME).type(TEXT).build(), - QueryResult.Column.builder().name(PRECISION).type(INTEGER).build(), - QueryResult.Column.builder().name(LENGTH).type(INTEGER).build(), - QueryResult.Column.builder().name(SCALE).type(INTEGER).build(), - QueryResult.Column.builder().name(RADIX).type(INTEGER).build(), - QueryResult.Column.builder().name(NULLABLE).type(INTEGER).build(), - QueryResult.Column.builder().name(REMARKS).type(TEXT).build(), - QueryResult.Column.builder().name(CHAR_OCTET_LENGTH).type(INTEGER).build(), - QueryResult.Column.builder().name(ORDINAL_POSITION).type(INTEGER).build(), - QueryResult.Column.builder().name(IS_NULLABLE).type(TEXT).build(), - QueryResult.Column.builder().name(SPECIFIC_NAME).type(TEXT).build() - ); Predicate functionFilter = functionNamePattern == null ? f -> true : compile(functionNamePattern, CASE_INSENSITIVE).asPredicate(); List> stringFunctions = Arrays.stream(String.join(",", getStringFunctions()).split(",")).map(String::trim).filter(functionFilter) @@ -1592,31 +1476,56 @@ public ResultSet getFunctionColumns(String catalog, String schemaPattern, String }; List> allFunctions = Stream.of(stringFunctions, numericFunctions, timeDateFunctions, systemFunctions).flatMap(Collection::stream).sorted(comparator).collect(toList()); - return FireboltResultSet.of(QueryResult.builder().columns(columns).rows(allFunctions).build()); + return createResultSet(Stream.of( + entry(FUNCTION_CAT, TEXT), + entry(FUNCTION_SCHEM, TEXT), + entry(FUNCTION_NAME, TEXT), + entry(COLUMN_NAME, TEXT), + entry(COLUMN_TYPE, INTEGER), + entry(DATA_TYPE, INTEGER), + entry(TYPE_NAME, TEXT), + entry(PRECISION, INTEGER), + entry(LENGTH, INTEGER), + entry(SCALE, INTEGER), + entry(RADIX, INTEGER), + entry(NULLABLE, INTEGER), + entry(REMARKS, TEXT), + entry(CHAR_OCTET_LENGTH, INTEGER), + entry(ORDINAL_POSITION, INTEGER), + entry(IS_NULLABLE, TEXT), + entry(SPECIFIC_NAME, TEXT)), allFunctions); } @Override public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException { - return FireboltResultSet.of(QueryResult.builder() - .columns(Stream.of( - entry(TABLE_CAT, TEXT), - entry(TABLE_SCHEM, TEXT), - entry(TABLE_NAME, TEXT), - entry(COLUMN_NAME, TEXT), - entry(DATA_TYPE, INTEGER), - entry(COLUMN_SIZE, INTEGER), - entry(DECIMAL_DIGITS, INTEGER), - entry(NUM_PREC_RADIX, INTEGER), - entry(COLUMN_USAGE, TEXT), - entry(REMARKS, TEXT), - entry(CHAR_OCTET_LENGTH, INTEGER), - entry(IS_NULLABLE, TEXT) - ).map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) - .rows(List.of()) - .build()); + return createEmptyResultSet(Stream.of( + entry(TABLE_CAT, TEXT), + entry(TABLE_SCHEM, TEXT), + entry(TABLE_NAME, TEXT), + entry(COLUMN_NAME, TEXT), + entry(DATA_TYPE, INTEGER), + entry(COLUMN_SIZE, INTEGER), + entry(DECIMAL_DIGITS, INTEGER), + entry(NUM_PREC_RADIX, INTEGER), + entry(COLUMN_USAGE, TEXT), + entry(REMARKS, TEXT), + entry(CHAR_OCTET_LENGTH, INTEGER), + entry(IS_NULLABLE, TEXT) + )); } @Override - public boolean generatedKeyAlwaysReturned() throws SQLException { + public boolean generatedKeyAlwaysReturned() { return false; } + + private ResultSet createEmptyResultSet(Stream> columns) throws SQLException { + return createResultSet(columns, List.of()); + } + + private ResultSet createResultSet(Stream> columns, List> rows) throws SQLException { + return FireboltResultSet.of(QueryResult.builder() + .columns(columns.map(e -> QueryResult.Column.builder().name(e.getKey()).type(e.getValue()).build()).collect(toList())) + .rows(rows) + .build()); + } } diff --git a/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSet.java b/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSet.java index ece748fc0..3077f6808 100644 --- a/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSet.java +++ b/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSet.java @@ -444,10 +444,11 @@ public boolean isBeforeFirst() throws SQLException { } @Override - public boolean isAfterLast() throws SQLException { + public boolean isAfterLast() { return !hasNext() && currentLine == null; } + @SuppressWarnings("BooleanMethodIsAlwaysInverted") private boolean hasNext() { return reader.lines().iterator().hasNext(); } @@ -459,7 +460,7 @@ public boolean isFirst() throws SQLException { } @Override - public boolean isLast() throws SQLException { + public boolean isLast() { return !hasNext() && currentLine != null; } @@ -542,19 +543,6 @@ public int findColumn(String columnName) throws SQLException { return index; } - @Override - public boolean isWrapperFor(Class iface) { - return iface.isAssignableFrom(getClass()); - } - - @Override - public T unwrap(Class iface) throws SQLException { - if (iface.isAssignableFrom(getClass())) { - return iface.cast(this); - } - throw new SQLException("Cannot unwrap to " + iface.getName()); - } - @Override public InputStream getAsciiStream(int columnIndex) throws SQLException { return getTextStream(columnIndex, StandardCharsets.US_ASCII); @@ -632,7 +620,7 @@ public boolean previous() throws SQLException { } @Override - public int getFetchDirection() throws SQLException { + public int getFetchDirection() { return ResultSet.FETCH_FORWARD; } @@ -644,7 +632,8 @@ public void setFetchDirection(int direction) throws SQLException { } @Override - public int getFetchSize() throws SQLException { + @SuppressWarnings("SpellCheckingInspection") + public int getFetchSize() { return 0; // fetch size is not supported; 0 means unlimited like in PostgreSQL and MySQL } @@ -658,7 +647,7 @@ public void setFetchSize(int rows) throws SQLException { } @Override - public int getConcurrency() throws SQLException { + public int getConcurrency() { return ResultSet.CONCUR_READ_ONLY; } @@ -957,7 +946,7 @@ public void moveToCurrentRow() throws SQLException { } @Override - public Statement getStatement() throws SQLException { + public Statement getStatement() { return statement; } @@ -1104,7 +1093,7 @@ public void updateRowId(String columnLabel, RowId x) throws SQLException { } @Override - public int getHoldability() throws SQLException { + public int getHoldability() { return ResultSet.HOLD_CURSORS_OVER_COMMIT; } diff --git a/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSetMetaData.java b/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSetMetaData.java index 64a95df5f..ae7449ea1 100644 --- a/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSetMetaData.java +++ b/src/main/java/com/firebolt/jdbc/resultset/FireboltResultSetMetaData.java @@ -1,6 +1,6 @@ package com.firebolt.jdbc.resultset; -import com.firebolt.jdbc.exception.FireboltException; +import com.firebolt.jdbc.GenericWrapper; import com.firebolt.jdbc.resultset.column.Column; import java.sql.ResultSetMetaData; @@ -11,7 +11,7 @@ import static java.lang.String.format; @SuppressWarnings("java:S4144") // Methods should not have identical implementations - many methods here have trivial identical implementation -public class FireboltResultSetMetaData implements ResultSetMetaData { +public class FireboltResultSetMetaData implements ResultSetMetaData, GenericWrapper { private final String dbName; private final String tableName; private final List columns; @@ -89,20 +89,6 @@ Column getColumn(int column) throws SQLException { return columns.get(column - 1); } - @Override - @SuppressWarnings("unchecked") - public T unwrap(Class interfaceName) throws SQLException { - if (isWrapperFor(interfaceName)) { - return (T) this; - } - throw new FireboltException("Unable unwrap to " + interfaceName); - } - - @Override - public boolean isWrapperFor(Class interfaceName) throws SQLException { - return interfaceName != null && interfaceName.isAssignableFrom(getClass()); - } - @Override public boolean isCaseSensitive(int column) throws SQLException { return getColumn(column).getType().getDataType().isCaseSensitive(); diff --git a/src/main/java/com/firebolt/jdbc/statement/ParamMarker.java b/src/main/java/com/firebolt/jdbc/statement/ParamMarker.java index 93b011a3a..f3063583c 100644 --- a/src/main/java/com/firebolt/jdbc/statement/ParamMarker.java +++ b/src/main/java/com/firebolt/jdbc/statement/ParamMarker.java @@ -6,6 +6,6 @@ @AllArgsConstructor @Value public class ParamMarker { - int id; // Id / index of the param marker in the SQL statement + int id; // ID / index of the param marker in the SQL statement int position; // Position in the SQL subStatement } \ No newline at end of file diff --git a/src/main/java/com/firebolt/jdbc/statement/StatementUtil.java b/src/main/java/com/firebolt/jdbc/statement/StatementUtil.java index fca7e8bee..256dfc1e3 100644 --- a/src/main/java/com/firebolt/jdbc/statement/StatementUtil.java +++ b/src/main/java/com/firebolt/jdbc/statement/StatementUtil.java @@ -67,7 +67,7 @@ public List parseToStatementInfoWrappers(String sql) { /** * Parse sql statement to a {@link RawStatementWrapper}. The method construct * the {@link RawStatementWrapper} by splitting it in a list of sub-statements - * (supports multistatements) + * (supports multi-statements) * * @param sql the sql statement * @return a list of {@link StatementInfoWrapper} @@ -88,7 +88,7 @@ public RawStatementWrapper parseToRawStatementWrapper(String sql) { boolean isInSingleLineComment = false; boolean isInMultipleLinesComment = false; boolean isInComment = false; - boolean foundSubqueryEndingSemicolon = false; + boolean foundSubQueryEndingSemicolon = false; char previousChar; int subQueryParamsCount = 0; boolean isPreviousCharInComment; @@ -103,16 +103,16 @@ public RawStatementWrapper parseToRawStatementWrapper(String sql) { isInComment = isInSingleLineComment || isInMultipleLinesComment; if (!isInComment) { // Although the ending semicolon may have been found, we need to include any - // potential comments to the subquery + // potential comments to the sub-query if (!isCurrentSubstringBetweenQuotes && isEndingSemicolon(currentChar, previousChar, - foundSubqueryEndingSemicolon, isPreviousCharInComment)) { - foundSubqueryEndingSemicolon = true; - if (isEndOfSubquery(currentChar)) { + foundSubQueryEndingSemicolon, isPreviousCharInComment)) { + foundSubQueryEndingSemicolon = true; + if (isEndOfSubQuery(currentChar)) { subStatements.add(RawStatement.of(sql.substring(subQueryStart, currentIndex), subStatementParamMarkersPositions, cleanedSubQuery.toString().trim())); subStatementParamMarkersPositions = new ArrayList<>(); subQueryStart = currentIndex; - foundSubqueryEndingSemicolon = false; + foundSubQueryEndingSemicolon = false; cleanedSubQuery = new StringBuilder(); } } else if (currentChar == '?' && !isCurrentSubstringBetweenQuotes @@ -134,15 +134,15 @@ public RawStatementWrapper parseToRawStatementWrapper(String sql) { return new RawStatementWrapper(subStatements); } - private boolean isEndingSemicolon(char currentChar, char previousChar, boolean foundSubqueryEndingSemicolon, + private boolean isEndingSemicolon(char currentChar, char previousChar, boolean foundSubQueryEndingSemicolon, boolean isPreviousCharInComment) { - if (foundSubqueryEndingSemicolon) { + if (foundSubQueryEndingSemicolon) { return true; } return (';' == previousChar && currentChar != ';' && !isPreviousCharInComment); } - private boolean isEndOfSubquery(char currentChar) { + private boolean isEndOfSubQuery(char currentChar) { return currentChar != '-' && currentChar != '/' && currentChar != ' ' && currentChar != '\n'; } @@ -226,14 +226,14 @@ public static List replaceParameterMarksWithValues(@NonNul public List replaceParameterMarksWithValues(@NonNull Map params, @NonNull RawStatementWrapper rawStatement) { List subQueries = new ArrayList<>(); - for (int subqueryIndex = 0; subqueryIndex < rawStatement.getSubStatements().size(); subqueryIndex++) { + for (int subQueryIndex = 0; subQueryIndex < rawStatement.getSubStatements().size(); subQueryIndex++) { int currentPos; /* * As the parameter markers are being placed then the statement sql keeps * getting bigger, which is why we need to keep track of the offset */ int offset = 0; - RawStatement subQuery = rawStatement.getSubStatements().get(subqueryIndex); + RawStatement subQuery = rawStatement.getSubStatements().get(subQueryIndex); String subQueryWithParams = subQuery.getSql(); if (params.size() != rawStatement.getTotalParams()) { diff --git a/src/main/java/com/firebolt/jdbc/statement/preparedstatement/FireboltPreparedStatement.java b/src/main/java/com/firebolt/jdbc/statement/preparedstatement/FireboltPreparedStatement.java index aa5911fe5..e7f20b89b 100644 --- a/src/main/java/com/firebolt/jdbc/statement/preparedstatement/FireboltPreparedStatement.java +++ b/src/main/java/com/firebolt/jdbc/statement/preparedstatement/FireboltPreparedStatement.java @@ -188,7 +188,7 @@ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException { } @Override - public void clearParameters() throws SQLException { + public void clearParameters() { providedParameters.clear(); rows.clear(); } @@ -221,7 +221,7 @@ public boolean execute() throws SQLException { } @Override - public void addBatch() throws SQLException { + public void addBatch() { rows.add(providedParameters); providedParameters = new HashMap<>(); } diff --git a/src/main/java/com/firebolt/jdbc/statement/rawstatement/QueryRawStatement.java b/src/main/java/com/firebolt/jdbc/statement/rawstatement/QueryRawStatement.java index 5ca71042a..2456edb3a 100644 --- a/src/main/java/com/firebolt/jdbc/statement/rawstatement/QueryRawStatement.java +++ b/src/main/java/com/firebolt/jdbc/statement/rawstatement/QueryRawStatement.java @@ -14,7 +14,7 @@ /** * A query statement is a statement that returns data (Typically starts with - * SELECT, SHOW, etc) + * SELECT, SHOW, etc.) */ @Getter @EqualsAndHashCode(callSuper = true) diff --git a/src/main/java/com/firebolt/jdbc/type/BaseType.java b/src/main/java/com/firebolt/jdbc/type/BaseType.java index 9bd68af54..b46c2b09d 100644 --- a/src/main/java/com/firebolt/jdbc/type/BaseType.java +++ b/src/main/java/com/firebolt/jdbc/type/BaseType.java @@ -26,7 +26,7 @@ import static com.firebolt.jdbc.type.array.SqlArrayUtil.BYTE_ARRAY_PREFIX; import static com.firebolt.jdbc.type.array.SqlArrayUtil.hexStringToByteArray; -/** This class contains the java types the Firebolt datatypes are mapped to */ +/** This class contains the java types the Firebolt data types are mapped to */ public enum BaseType { LONG(TypePredicate.mayBeFloatingNumber, Long.class, conversion -> Long.parseLong(checkInfinity(conversion.getValue())), conversion -> Double.valueOf(conversion.getValue()).longValue()), INTEGER(TypePredicate.mayBeFloatingNumber, Integer.class, conversion -> Integer.parseInt(checkInfinity(conversion.getValue())), conversion -> Integer.parseInt(Long.toString(Double.valueOf(conversion.getValue()).longValue()))), diff --git a/src/main/java/com/firebolt/jdbc/type/FireboltDataType.java b/src/main/java/com/firebolt/jdbc/type/FireboltDataType.java index f2d4b36df..e1a9b6307 100644 --- a/src/main/java/com/firebolt/jdbc/type/FireboltDataType.java +++ b/src/main/java/com/firebolt/jdbc/type/FireboltDataType.java @@ -34,7 +34,7 @@ public enum FireboltDataType { DATE_32(Types.DATE, FireboltDataTypeDisplayNames.PGDATE, BaseType.DATE, false, false, 10, 0, 0, true,"Date32", "PGDate"), DATE_TIME_64(Types.TIMESTAMP, FireboltDataTypeDisplayNames.TIMESTAMP, BaseType.TIMESTAMP, false, false, 19, 0, 6, true, "DateTime64", "TIMESTAMP"), TIMESTAMP(Types.TIMESTAMP, FireboltDataTypeDisplayNames.TIMESTAMP, BaseType.TIMESTAMP, false, false, 6, 0, 0, true,"DateTime", "TIMESTAMP", "TimestampNtz"), - TIMESTAMP_WITH_TIMEZONE(Types.TIMESTAMP_WITH_TIMEZONE, FireboltDataTypeDisplayNames.TIMESTAMPTZ, BaseType.TIMESTAMP_WITH_TIMEZONE, false, false, 6, 0, 0, true,"Timestamptz"), + TIMESTAMP_WITH_TIMEZONE(Types.TIMESTAMP_WITH_TIMEZONE, FireboltDataTypeDisplayNames.TIMESTAMPTZ, BaseType.TIMESTAMP_WITH_TIMEZONE, false, false, 6, 0, 0, true,"TimestampTz"), NOTHING(Types.NULL, FireboltDataTypeDisplayNames.NULL, BaseType.NULL, false, false, 0, 0, 0, false,"Nothing", "NULL"), UNKNOWN(Types.OTHER, FireboltDataTypeDisplayNames.UNKNOWN, BaseType.OTHER, false, false, 0, 0, 0, false,"Unknown"), NUMERIC(Types.NUMERIC, FireboltDataTypeDisplayNames.NUMERIC, BaseType.NUMERIC, true, false, 38, 0, 37, false, "Decimal", "DEC", "NUMERIC"), diff --git a/src/main/java/com/firebolt/jdbc/type/FireboltDataTypeDisplayNames.java b/src/main/java/com/firebolt/jdbc/type/FireboltDataTypeDisplayNames.java index c063c5f54..a404d02bd 100644 --- a/src/main/java/com/firebolt/jdbc/type/FireboltDataTypeDisplayNames.java +++ b/src/main/java/com/firebolt/jdbc/type/FireboltDataTypeDisplayNames.java @@ -2,6 +2,7 @@ import lombok.experimental.UtilityClass; +@SuppressWarnings("SpellCheckingInspection") @UtilityClass public class FireboltDataTypeDisplayNames { static final String INTEGER = "integer"; diff --git a/src/main/java/com/firebolt/jdbc/type/JavaTypeToFireboltSQLString.java b/src/main/java/com/firebolt/jdbc/type/JavaTypeToFireboltSQLString.java index 0eb54c568..2229f622a 100644 --- a/src/main/java/com/firebolt/jdbc/type/JavaTypeToFireboltSQLString.java +++ b/src/main/java/com/firebolt/jdbc/type/JavaTypeToFireboltSQLString.java @@ -143,10 +143,6 @@ private static CheckedFunction getSQLStringValueOfString() { }; } - public Class getSourceType() { - return sourceType; - } - public String transform(Object object, Object ... more) throws SQLException { if (object == null) { return NULL_VALUE; diff --git a/src/main/java/com/firebolt/jdbc/util/LoggerUtil.java b/src/main/java/com/firebolt/jdbc/util/LoggerUtil.java index 54b8979ca..3aea5e03b 100644 --- a/src/main/java/com/firebolt/jdbc/util/LoggerUtil.java +++ b/src/main/java/com/firebolt/jdbc/util/LoggerUtil.java @@ -43,6 +43,7 @@ public static Logger getRootLogger() { * @return a copy of the {@link InputStream} provided */ public InputStream logInputStream(InputStream is) { + @SuppressWarnings("SpellCheckingInspection") // BAOS means byte array output stream ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { byte[] buffer = new byte[1024]; diff --git a/src/main/java/com/firebolt/jdbc/util/VersionUtil.java b/src/main/java/com/firebolt/jdbc/util/VersionUtil.java index 5e9b1c979..dbf9fc04d 100644 --- a/src/main/java/com/firebolt/jdbc/util/VersionUtil.java +++ b/src/main/java/com/firebolt/jdbc/util/VersionUtil.java @@ -69,8 +69,8 @@ private static void retrieveVersionInfo() throws IOException { if (retrieveVersionInfoFromManifest(VersionUtil.class.getResourceAsStream("/META-INF/MANIFEST.MF"))) { return; } - for(Enumeration eurl = Thread.currentThread().getContextClassLoader().getResources("META-INF/MANIFEST.MF"); eurl.hasMoreElements();) { - try (InputStream in = eurl.nextElement().openStream()) { + for(Enumeration eUrl = Thread.currentThread().getContextClassLoader().getResources("META-INF/MANIFEST.MF"); eUrl.hasMoreElements();) { + try (InputStream in = eUrl.nextElement().openStream()) { if (retrieveVersionInfoFromManifest(in)) { return; }