diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/JdbcMetaDataProvider.java b/src/main/java/com/homihq/db2rest/jdbc/sql/JdbcMetaDataProvider.java index 370de922..707dd7a0 100644 --- a/src/main/java/com/homihq/db2rest/jdbc/sql/JdbcMetaDataProvider.java +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/JdbcMetaDataProvider.java @@ -1,20 +1,14 @@ package com.homihq.db2rest.jdbc.sql; import com.homihq.db2rest.core.config.Db2RestConfigProperties; -import com.homihq.db2rest.core.model.DbColumn; import com.homihq.db2rest.core.model.DbTable; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.StringUtils; import org.springframework.jdbc.support.DatabaseMetaDataCallback; - - import java.sql.*; -import java.util.ArrayList; import java.util.List; -import java.util.Objects; +import java.util.Optional; -import static com.homihq.db2rest.schema.AliasGenerator.getAlias; @Slf4j @RequiredArgsConstructor @@ -22,6 +16,9 @@ public class JdbcMetaDataProvider implements DatabaseMetaDataCallback { private final Db2RestConfigProperties db2RestConfigProperties; + List exclusions = List.of(new OracleMetaDataExtraction(), + new PostgreSQLDataExclusion(), new MySQLDataExtraction()); + //TODO include schemas , tables , view, filters filters @Override public DbMeta processMetaData(DatabaseMetaData databaseMetaData) throws SQLException { @@ -40,29 +37,16 @@ public DbMeta processMetaData(DatabaseMetaData databaseMetaData) throws SQLExcep log.info("Driver Name - {}", driverName); log.info("Driver Version - {}", driverVersion); - log.info("IncludedSchemas - {}", db2RestConfigProperties.getIncludeSchemas()); + log.info("All schema/catalog - {}", db2RestConfigProperties.isAllSchema()); + Optional metaDataExclusion = getMetaDataExtraction(productName); - List dbTables = new ArrayList<>(); - - if(db2RestConfigProperties.isAllSchema()) { - log.info("Fetching all schema meta data."); - List tables = getDbTables(databaseMetaData, null, productName, majorVersion); - - dbTables.addAll(tables); - } - else{ - log.info("Fetching meta data for selected schemas."); - - for(String schema : db2RestConfigProperties.getIncludeSchemas()) { + if(metaDataExclusion.isEmpty()) throw new RuntimeException("Unable to extract metadata. No extractor"); - log.info("Loading meta data for schema - {}", schema); + log.info("Fetching meta data for selected schemas."); - List tables = getDbTables(databaseMetaData, schema, productName, majorVersion); - - dbTables.addAll(tables); - } - } + List dbTables = metaDataExclusion.get().getTables(databaseMetaData, + db2RestConfigProperties.isAllSchema(), db2RestConfigProperties.getIncludeSchemas()); log.info("Completed loading database meta-data : {} tables", dbTables.size()); @@ -70,93 +54,13 @@ public DbMeta processMetaData(DatabaseMetaData databaseMetaData) throws SQLExcep return new DbMeta(productName, majorVersion, driverName, driverVersion, dbTables); } - private List getDbTables(DatabaseMetaData databaseMetaData, String schemaPattern, String productName, int majorVersion) throws SQLException { - List dbTables = new ArrayList<>(); - - try(ResultSet resultSet = databaseMetaData.getTables( - null, - schemaPattern, - null, - new String[]{"TABLE", "VIEW"})){ - while(resultSet.next()) { - String tableName = resultSet.getString("TABLE_NAME"); - String catalog = resultSet.getString("TABLE_CAT"); - String schema = resultSet.getString("TABLE_SCHEM"); - String tableType = resultSet.getString("TABLE_TYPE"); - - log.debug("{} , {} , {}, {} ", catalog, schema, tableName, tableType); - - String tableAlias = getAlias(tableName); - - List columns = - getAllColumns(databaseMetaData, catalog, schema, tableName, tableAlias, productName, majorVersion); - - String schemaName = StringUtils.isNotBlank(schema) ? schema : catalog; - - DbTable dbTable = new DbTable( - schema, tableName ,schemaName + "." + tableName, - tableAlias,columns, tableType); - dbTables.add(dbTable); - } - } - return dbTables; + private Optional getMetaDataExtraction(String productName) { + return this.exclusions.stream().filter( + metaDataExtraction -> metaDataExtraction.canHandle(productName) + ).findFirst(); } - private List getAllColumns(DatabaseMetaData databaseMetaData, String catalog, String schema, - String tableName, String tableAlias, String productName, int majorVersion) throws SQLException { - List pkColumns = new ArrayList<>(); - - try(ResultSet primaryKeys = databaseMetaData.getPrimaryKeys(catalog, schema, tableName)){ - while(primaryKeys.next()){ - String primaryKeyColumnName = primaryKeys.getString("COLUMN_NAME"); - //String primaryKeyName = primaryKeys.getString("PK_NAME"); - - pkColumns.add(primaryKeyColumnName); - } - } - - List dbColumns = new ArrayList<>(); - - try(ResultSet columns = databaseMetaData - .getColumns(catalog,schema, tableName, null)){ - while(columns.next()) { - String columnName = columns.getString("COLUMN_NAME"); - //String columnSize = columns.getString("COLUMN_SIZE"); - int datatype = columns.getInt("DATA_TYPE"); - String isNullable = columns.getString("IS_NULLABLE"); - String isAutoIncrement = columns.getString("IS_AUTOINCREMENT"); - - //Note workaround for oracle 9i - change to strategy classes later? - String isGenerated = "N"; - if(!(StringUtils.equalsIgnoreCase(productName, "Oracle") && majorVersion == 9)) { - isGenerated = columns.getString("IS_GENERATEDCOLUMN"); - } - - String typeName = columns.getString("TYPE_NAME"); - - Class javaType = JdbcTypeJavaClassMappings.INSTANCE.determineJavaClassForJdbcTypeCode(datatype); - - log.debug("{} , {} , {}, {}, {}", columnName, javaType, isNullable, isAutoIncrement, typeName); - - DbColumn dbColumn = - new DbColumn(tableName, columnName, - "", - tableAlias, - pkColumns.contains(columnName), - typeName, - StringUtils.equalsAnyIgnoreCase(isGenerated,"YES"), - StringUtils.equalsAnyIgnoreCase(isAutoIncrement,"YES"), - javaType - ); - - dbColumns.add(dbColumn); - } - } - - return dbColumns; - - } } diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataExtraction.java b/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataExtraction.java new file mode 100644 index 00000000..a3ae02e3 --- /dev/null +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataExtraction.java @@ -0,0 +1,98 @@ +package com.homihq.db2rest.jdbc.sql; + + +import com.homihq.db2rest.core.model.DbTable; +import org.apache.commons.lang3.StringUtils; + +import java.sql.DatabaseMetaData; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import static com.homihq.db2rest.schema.AliasGenerator.getAlias; + +public interface MetaDataExtraction { + boolean canHandle(String database); + + + List getTables(DatabaseMetaData databaseMetaData, boolean includeAllSchemas, List includedSchemas); + + default boolean include(String schemaOrCatalog, List excludedSchemasOrCatalogs) { + return excludedSchemasOrCatalogs.stream().noneMatch(i -> StringUtils.equalsIgnoreCase(schemaOrCatalog, i)); + } + + default List getAllCatalogs(DatabaseMetaData databaseMetaData, List excludedCatalogs) throws Exception{ + List includedCatalogs = new ArrayList<>(); + try(ResultSet resultSet = databaseMetaData.getCatalogs()){ + + while(resultSet.next()) { + + String catalog = resultSet.getString("TABLE_CAT"); + + if(include(catalog, excludedCatalogs)) { + includedCatalogs.add(catalog); + } + + } + } + + return includedCatalogs; + } + + default List getAllSchemas(DatabaseMetaData databaseMetaData, List excludedSchemas) throws Exception{ + List includedSchemas = new ArrayList<>(); + try(ResultSet resultSet = databaseMetaData.getSchemas()){ + + while(resultSet.next()) { + String schema = resultSet.getString("TABLE_SCHEM"); + + if(include(schema, excludedSchemas)) { + includedSchemas.add(schema); + } + + } + } + + return includedSchemas; + } + + + default List + getMetaTables(DatabaseMetaData databaseMetaData, String catalogPattern, String schemaPattern) throws SQLException { + + List tables = new ArrayList<>(); + + try(ResultSet resultSet = databaseMetaData.getTables( + catalogPattern, + schemaPattern, + null, + new String[]{"TABLE", "VIEW"})){ + while(resultSet.next()) { + String tableName = resultSet.getString("TABLE_NAME"); + String catalog = resultSet.getString("TABLE_CAT"); + String schema = resultSet.getString("TABLE_SCHEM"); + String tableType = resultSet.getString("TABLE_TYPE"); + String tableAlias = getAlias(tableName); + MetaDataTable metaDataTable = new MetaDataTable(tableName, catalog, schema, tableType, tableAlias); + + tables.add(metaDataTable); + + } + } + return tables; + } + + default List getAllPrimaryKeys(DatabaseMetaData databaseMetaData, String catalog, String schema, String tableName) throws SQLException { + List pkColumns = new ArrayList<>(); + + try(ResultSet primaryKeys = databaseMetaData.getPrimaryKeys(catalog, schema, tableName)){ + while(primaryKeys.next()){ + String primaryKeyColumnName = primaryKeys.getString("COLUMN_NAME"); + + pkColumns.add(primaryKeyColumnName); + } + } + return pkColumns; + } +} diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataTable.java b/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataTable.java new file mode 100644 index 00000000..82c69c8d --- /dev/null +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/MetaDataTable.java @@ -0,0 +1,4 @@ +package com.homihq.db2rest.jdbc.sql; + +public record MetaDataTable(String tableName, String catalog, String schema, String tableType, String tableAlias) { +} diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/MySQLDataExtraction.java b/src/main/java/com/homihq/db2rest/jdbc/sql/MySQLDataExtraction.java new file mode 100644 index 00000000..a2870700 --- /dev/null +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/MySQLDataExtraction.java @@ -0,0 +1,121 @@ +package com.homihq.db2rest.jdbc.sql; + +import com.homihq.db2rest.core.model.DbColumn; +import com.homihq.db2rest.core.model.DbTable; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; +import java.sql.DatabaseMetaData; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Slf4j +public class MySQLDataExtraction implements MetaDataExtraction { + + List excludedCatalogs = Arrays.asList("mysql", "sys", "information_schema","performance_schema"); + + @Override + public boolean canHandle(String database) { + return StringUtils.equalsIgnoreCase(database, "MySQL"); + } + + + @Override + public List getTables(DatabaseMetaData databaseMetaData, boolean includeAllCatalogs, + List includeCatalogs) { + try { + List includedCatalogs = includeCatalogs; + + if(includeAllCatalogs) includedCatalogs = getAllCatalogs(databaseMetaData, excludedCatalogs); + + List dbTables = new ArrayList<>(); + + for(String catalog : includedCatalogs) { + + log.info("Loading meta tables for catalog - {}", catalog); + + List metaDataTables = + getMetaTables(databaseMetaData, catalog, null); + + List tables = + metaDataTables.parallelStream() + .map(metaDataTable -> getDbTable( + databaseMetaData, + metaDataTable + + )) + .toList(); + + dbTables.addAll(tables); + } + + + return dbTables; + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + private List getAllColumns(DatabaseMetaData databaseMetaData, String catalog, String schema, + String tableName, String tableAlias) throws SQLException { + + List pkColumns = getAllPrimaryKeys(databaseMetaData, catalog, schema, tableName); + + List dbColumns = new ArrayList<>(); + + try(ResultSet columns = databaseMetaData + .getColumns(catalog,schema, tableName, null)){ + while(columns.next()) { + String columnName = columns.getString("COLUMN_NAME"); + int datatype = columns.getInt("DATA_TYPE"); + String isAutoIncrement = columns.getString("IS_AUTOINCREMENT"); + String isGenerated = "N"; + String typeName = columns.getString("TYPE_NAME"); + + Class javaType = JdbcTypeJavaClassMappings.INSTANCE.determineJavaClassForJdbcTypeCode(datatype); + + DbColumn dbColumn = + new DbColumn(tableName, columnName, + "", + tableAlias, + pkColumns.contains(columnName), + typeName, + StringUtils.equalsAnyIgnoreCase(isGenerated,"YES"), + StringUtils.equalsAnyIgnoreCase(isAutoIncrement,"YES"), + javaType + ); + + dbColumns.add(dbColumn); + } + } + + return dbColumns; + + } + + private DbTable getDbTable(DatabaseMetaData databaseMetaData, MetaDataTable metaDataTable) { + try { + List columns = getAllColumns(databaseMetaData, + metaDataTable.catalog(), + metaDataTable.schema(), + metaDataTable.tableName(), + metaDataTable.tableAlias()); + + String schemaName = StringUtils.isNotBlank(metaDataTable.schema()) ? + metaDataTable.schema() : metaDataTable.catalog(); + + return new DbTable( + schemaName, metaDataTable.tableName() ,schemaName + "." + metaDataTable.tableName(), + metaDataTable.tableAlias(),columns, metaDataTable.tableType()); + } catch (SQLException e) { + throw new RuntimeException(e); + } + + } + + + +} diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/OracleMetaDataExtraction.java b/src/main/java/com/homihq/db2rest/jdbc/sql/OracleMetaDataExtraction.java new file mode 100644 index 00000000..051c6f5d --- /dev/null +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/OracleMetaDataExtraction.java @@ -0,0 +1,151 @@ +package com.homihq.db2rest.jdbc.sql; + +import com.homihq.db2rest.core.model.DbColumn; +import com.homihq.db2rest.core.model.DbTable; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; + +import java.sql.DatabaseMetaData; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Slf4j +public class OracleMetaDataExtraction implements MetaDataExtraction { + + + List excludedSchemas = + Arrays.asList( + "ANONYMOUS","APEX_050000","APEX_PUBLIC_USER","APPQOSSYS","AUDSYS","BI","CTXSYS","DBSFWUSER","DBSNMP", + "DIP","DVF","DVSYS","EXFSYS","FLOWS_FILES","GGSYS","GSMADMIN_INTERNAL","GSMCATUSER","GSMUSER", + "HR","IX","LBACSYS","MDDATA","MDSYS","MGMT_VIEW","OE","OLAPSYS","OPS$ORACLE","ORACLE_OCM","ORDDATA", "RMAN", + "ORDPLUGINS","ORDSYS","OUTLN","OWBSYS","PDBADMIN","PM","RDSADMIN","REMOTE_SCHEDULER_AGENT","SCOTT", "SYSTEM", + "SH","SI_INFORMTN_SCHEMA","SPATIAL_CSW_ADMIN_USR","SPATIAL_WFS_ADMIN_USR","SYS","SYS$UMF","SYSBACKUP","SYSDG", + "SYSKM","SYSMAN","SYSRAC","\"SYSTEM\"","TSMSYS","WKPROXY","WKSYS","WK_TEST","WMSYS","XDB","XS$NULL"); + + + List excludedSchemaPatterns = Arrays.asList("APEX_[0-9]{6}", "FLOWS_[0-9]{5,6}"); + + + @Override + public boolean canHandle(String database) { + return StringUtils.equalsIgnoreCase(database, "Oracle"); + } + + + + @Override + public List getTables(DatabaseMetaData databaseMetaData, boolean includeAllSchemas, + List includeSchemas) { + try { + List includedSchemas = includeSchemas; + + if(includeAllSchemas) includedSchemas = getAllSchemas(databaseMetaData, excludedSchemas); + + List dbTables = new ArrayList<>(); + + for(String schema : includedSchemas) { + + log.info("Loading meta tables for schema - {}", schema); + + List metaDataTables = getMetaTables(databaseMetaData, null, schema); + + List tables = + metaDataTables.parallelStream() + .map(metaDataTable -> { + try { + return getDbTable( + databaseMetaData, + metaDataTable, + schema, databaseMetaData.getDatabaseProductName(), + databaseMetaData.getDatabaseMajorVersion() + ); + } catch (SQLException e) { + throw new RuntimeException(e); + } + }) + .toList(); + + dbTables.addAll(tables); + } + + + return dbTables; + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + + private DbTable getDbTable(DatabaseMetaData databaseMetaData, MetaDataTable metaDataTable, + String schema, String productName, int majorVersion) { + try { + List columns = + getAllColumns(databaseMetaData, metaDataTable.catalog(), schema, + metaDataTable.tableName(), + metaDataTable.tableAlias(), productName, majorVersion); + + String schemaName = StringUtils.isNotBlank(schema) ? schema : metaDataTable.catalog(); + + return new DbTable( + schema, metaDataTable.tableName() ,schemaName + "." + metaDataTable.tableName(), + metaDataTable.tableAlias(),columns, metaDataTable.tableType()); + } catch (SQLException e) { + throw new RuntimeException(e); + } + + } + + private List getAllColumns(DatabaseMetaData databaseMetaData, String catalog, String schema, + String tableName, String tableAlias, String productName, int majorVersion) throws SQLException { + + List pkColumns = getAllPrimaryKeys(databaseMetaData, catalog, schema, tableName); + + List dbColumns = new ArrayList<>(); + + try(ResultSet columns = databaseMetaData + .getColumns(catalog,schema, tableName, null)){ + while(columns.next()) { + String columnName = columns.getString("COLUMN_NAME"); + //String columnSize = columns.getString("COLUMN_SIZE"); + int datatype = columns.getInt("DATA_TYPE"); + String isNullable = columns.getString("IS_NULLABLE"); + String isAutoIncrement = columns.getString("IS_AUTOINCREMENT"); + + //Note workaround for oracle 9i - change to strategy classes later? + String isGenerated = "N"; + if(!(StringUtils.equalsIgnoreCase(productName, "Oracle") && majorVersion == 9)) { + isGenerated = columns.getString("IS_GENERATEDCOLUMN"); + } + + String typeName = columns.getString("TYPE_NAME"); + + Class javaType = JdbcTypeJavaClassMappings.INSTANCE.determineJavaClassForJdbcTypeCode(datatype); + + //log.debug("{} , {} , {}, {}, {}", columnName, javaType, isNullable, isAutoIncrement, typeName); + + DbColumn dbColumn = + new DbColumn(tableName, columnName, + "", + tableAlias, + pkColumns.contains(columnName), + typeName, + StringUtils.equalsAnyIgnoreCase(isGenerated,"YES"), + StringUtils.equalsAnyIgnoreCase(isAutoIncrement,"YES"), + javaType + ); + + dbColumns.add(dbColumn); + } + } + + return dbColumns; + + } + + + +} diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/PostgreSQLDataExclusion.java b/src/main/java/com/homihq/db2rest/jdbc/sql/PostgreSQLDataExclusion.java new file mode 100644 index 00000000..7eafa830 --- /dev/null +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/PostgreSQLDataExclusion.java @@ -0,0 +1,124 @@ +package com.homihq.db2rest.jdbc.sql; + +import com.homihq.db2rest.core.model.DbColumn; +import com.homihq.db2rest.core.model.DbTable; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.StringUtils; + +import java.sql.DatabaseMetaData; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + + +@Slf4j +public class PostgreSQLDataExclusion implements MetaDataExtraction { + + List excludedSchemas = Arrays.asList("pg_catalog","information_schema"); + + + @Override + public boolean canHandle(String database) { + return StringUtils.equalsIgnoreCase(database, "PostgreSQL"); + } + + + @Override + public List getTables(DatabaseMetaData databaseMetaData, boolean includeAllSchemas, + List includeSchemas) { + try { + List includedSchemas = includeSchemas; + + if(includeAllSchemas) includedSchemas = getAllSchemas(databaseMetaData, excludedSchemas); + + List dbTables = new ArrayList<>(); + + for(String schema : includedSchemas) { + + log.info("Loading meta tables for schema - {}", schema); + + List metaDataTables = getMetaTables(databaseMetaData, null, schema); + + List tables = + metaDataTables.parallelStream() + .map(metaDataTable -> getDbTable( + databaseMetaData, + metaDataTable + + )) + .toList(); + + dbTables.addAll(tables); + } + + + return dbTables; + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + private List getAllColumns(DatabaseMetaData databaseMetaData, String catalog, String schema, + String tableName, String tableAlias) throws SQLException { + + List pkColumns = getAllPrimaryKeys(databaseMetaData, catalog, schema, tableName); + + List dbColumns = new ArrayList<>(); + + try(ResultSet columns = databaseMetaData.getColumns(catalog,schema, tableName, null)){ + + while(columns.next()) { + String columnName = columns.getString("COLUMN_NAME"); + int datatype = columns.getInt("DATA_TYPE"); + String isAutoIncrement = columns.getString("IS_AUTOINCREMENT"); + String isGenerated = "N"; + String typeName = columns.getString("TYPE_NAME"); + + Class javaType = JdbcTypeJavaClassMappings.INSTANCE.determineJavaClassForJdbcTypeCode(datatype); + + DbColumn dbColumn = + new DbColumn(tableName, columnName, + "", + tableAlias, + pkColumns.contains(columnName), + typeName, + StringUtils.equalsAnyIgnoreCase(isGenerated,"YES"), + StringUtils.equalsAnyIgnoreCase(isAutoIncrement,"YES"), + javaType + ); + + dbColumns.add(dbColumn); + } + } + + return dbColumns; + + } + + + private DbTable getDbTable(DatabaseMetaData databaseMetaData, MetaDataTable metaDataTable) { + try { + List columns = getAllColumns(databaseMetaData, metaDataTable.catalog(), + metaDataTable.schema(), + metaDataTable.tableName(), + metaDataTable.tableAlias()); + + String schemaName = StringUtils.isNotBlank(metaDataTable.schema()) + ? metaDataTable.schema() : metaDataTable.catalog(); + + return new DbTable( + schemaName, metaDataTable.tableName() ,schemaName + "." + metaDataTable.tableName(), + metaDataTable.tableAlias(),columns, metaDataTable.tableType()); + } catch (SQLException e) { + throw new RuntimeException(e); + } + + } + + + + +} diff --git a/src/main/java/com/homihq/db2rest/jdbc/sql/SqlCreatorTemplate.java b/src/main/java/com/homihq/db2rest/jdbc/sql/SqlCreatorTemplate.java index b6d81263..292bbac9 100644 --- a/src/main/java/com/homihq/db2rest/jdbc/sql/SqlCreatorTemplate.java +++ b/src/main/java/com/homihq/db2rest/jdbc/sql/SqlCreatorTemplate.java @@ -132,8 +132,8 @@ public String query(ReadContext readContext) { } - log.info("limit - {}", readContext.getLimit()); - log.info("offset - {}", readContext.getOffset()); + log.debug("limit - {}", readContext.getLimit()); + log.debug("offset - {}", readContext.getOffset()); if(readContext.getLimit() > -1) data.put("limit", readContext.getLimit()); @@ -143,8 +143,8 @@ public String query(ReadContext readContext) { String template = "read"; - log.info("Product family - {}", this.dialect.getProductFamily()); - log.info("Product family - {}", this.dialect.getMajorVersion()); + log.debug("Product family - {}", this.dialect.getProductFamily()); + log.debug("Product family - {}", this.dialect.getMajorVersion()); //TODO DB specific processing must move away if(StringUtils.equalsIgnoreCase(this.dialect.getProductFamily(), "Oracle")) { @@ -156,8 +156,8 @@ public String query(ReadContext readContext) { template = "read-ora-9"; } } - log.info("template - {}", template); - log.info("data - {}", data); + log.debug("template - {}", template); + log.debug("data - {}", data); Context context = new Context(); context.setVariables(data); return templateEngine.process(template, context); diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index 80990a96..d70a1189 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -5,9 +5,7 @@ app: server: port: ${SERVER_PORT:8080} forward-headers-strategy: framework - servlet: - session: - timeout: 90m + spring: @@ -45,9 +43,6 @@ db2rest: defaultFetchLimit: ${DEFAULT_FETCH_LIMIT:100} datasource: type: ${DATASOURCE_TYPE:jdbc} - - includeTables: ${INCLUDE_TABLES:} - includeCatalogs: ${INCLUDE_CATALOGS:#{null}} includeSchemas: ${INCLUDE_SCHEMAS:#{null}} auth: @@ -81,7 +76,4 @@ logging: jdbc.service: INFO org.springframework.web : INFO org.springframework.beans : INFO - schemacrawler.schemacrawler: ERROR - schemacrawler.crawl: ERROR - us.fatehi.utility.scheduler: ERROR org.springframework.jdbc: INFO