OmniSciDB  a987f07e93
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ai.heavy.jdbc.HeavyAIDatabaseMetaData Class Reference
+ Inheritance diagram for ai.heavy.jdbc.HeavyAIDatabaseMetaData:
+ Collaboration diagram for ai.heavy.jdbc.HeavyAIDatabaseMetaData:

Public Member Functions

 HeavyAIDatabaseMetaData (HeavyAIConnection connection) throws SQLException
 
boolean allProceduresAreCallable () throws SQLException
 
boolean allTablesAreSelectable () throws SQLException
 
String getURL () throws SQLException
 
String getUserName () throws SQLException
 
boolean isReadOnly () throws SQLException
 
boolean nullsAreSortedHigh () throws SQLException
 
boolean nullsAreSortedLow () throws SQLException
 
boolean nullsAreSortedAtStart () throws SQLException
 
boolean nullsAreSortedAtEnd () throws SQLException
 
String getDatabaseProductName () throws SQLException
 
String getDatabaseProductVersion () throws SQLException
 
String getDriverName () throws SQLException
 
String getDriverVersion () throws SQLException
 
int getDriverMajorVersion ()
 
int getDriverMinorVersion ()
 
boolean usesLocalFiles () throws SQLException
 
boolean usesLocalFilePerTable () throws SQLException
 
boolean supportsMixedCaseIdentifiers () throws SQLException
 
boolean storesUpperCaseIdentifiers () throws SQLException
 
boolean storesLowerCaseIdentifiers () throws SQLException
 
boolean storesMixedCaseIdentifiers () throws SQLException
 
boolean supportsMixedCaseQuotedIdentifiers () throws SQLException
 
boolean storesUpperCaseQuotedIdentifiers () throws SQLException
 
boolean storesLowerCaseQuotedIdentifiers () throws SQLException
 
boolean storesMixedCaseQuotedIdentifiers () throws SQLException
 
String getIdentifierQuoteString () throws SQLException
 
String getSQLKeywords () throws SQLException
 
String getNumericFunctions () throws SQLException
 
String getStringFunctions () throws SQLException
 
String getSystemFunctions () throws SQLException
 
String getTimeDateFunctions () throws SQLException
 
String getSearchStringEscape () throws SQLException
 
String getExtraNameCharacters () throws SQLException
 
boolean supportsAlterTableWithAddColumn () throws SQLException
 
boolean supportsAlterTableWithDropColumn () throws SQLException
 
boolean supportsColumnAliasing () throws SQLException
 
boolean nullPlusNonNullIsNull () throws SQLException
 
boolean supportsConvert () throws SQLException
 
boolean supportsConvert (int fromType, int toType) throws SQLException
 
boolean supportsTableCorrelationNames () throws SQLException
 
boolean supportsDifferentTableCorrelationNames () throws SQLException
 
boolean supportsExpressionsInOrderBy () throws SQLException
 
boolean supportsOrderByUnrelated () throws SQLException
 
boolean supportsGroupBy () throws SQLException
 
boolean supportsGroupByUnrelated () throws SQLException
 
boolean supportsGroupByBeyondSelect () throws SQLException
 
boolean supportsLikeEscapeClause () throws SQLException
 
boolean supportsMultipleResultSets () throws SQLException
 
boolean supportsMultipleTransactions () throws SQLException
 
boolean supportsNonNullableColumns () throws SQLException
 
boolean supportsMinimumSQLGrammar () throws SQLException
 
boolean supportsCoreSQLGrammar () throws SQLException
 
boolean supportsExtendedSQLGrammar () throws SQLException
 
boolean supportsANSI92EntryLevelSQL () throws SQLException
 
boolean supportsANSI92IntermediateSQL () throws SQLException
 
boolean supportsANSI92FullSQL () throws SQLException
 
boolean supportsIntegrityEnhancementFacility () throws SQLException
 
boolean supportsOuterJoins () throws SQLException
 
boolean supportsFullOuterJoins () throws SQLException
 
boolean supportsLimitedOuterJoins () throws SQLException
 
String getSchemaTerm () throws SQLException
 
String getProcedureTerm () throws SQLException
 
String getCatalogTerm () throws SQLException
 
boolean isCatalogAtStart () throws SQLException
 
String getCatalogSeparator () throws SQLException
 
boolean supportsSchemasInDataManipulation () throws SQLException
 
boolean supportsSchemasInProcedureCalls () throws SQLException
 
boolean supportsSchemasInTableDefinitions () throws SQLException
 
boolean supportsSchemasInIndexDefinitions () throws SQLException
 
boolean supportsSchemasInPrivilegeDefinitions () throws SQLException
 
boolean supportsCatalogsInDataManipulation () throws SQLException
 
boolean supportsCatalogsInProcedureCalls () throws SQLException
 
boolean supportsCatalogsInTableDefinitions () throws SQLException
 
boolean supportsCatalogsInIndexDefinitions () throws SQLException
 
boolean supportsCatalogsInPrivilegeDefinitions () throws SQLException
 
boolean supportsPositionedDelete () throws SQLException
 
boolean supportsPositionedUpdate () throws SQLException
 
boolean supportsSelectForUpdate () throws SQLException
 
boolean supportsStoredProcedures () throws SQLException
 
boolean supportsSubqueriesInComparisons () throws SQLException
 
boolean supportsSubqueriesInExists () throws SQLException
 
boolean supportsSubqueriesInIns () throws SQLException
 
boolean supportsSubqueriesInQuantifieds () throws SQLException
 
boolean supportsCorrelatedSubqueries () throws SQLException
 
boolean supportsUnion () throws SQLException
 
boolean supportsUnionAll () throws SQLException
 
boolean supportsOpenCursorsAcrossCommit () throws SQLException
 
boolean supportsOpenCursorsAcrossRollback () throws SQLException
 
boolean supportsOpenStatementsAcrossCommit () throws SQLException
 
boolean supportsOpenStatementsAcrossRollback () throws SQLException
 
int getMaxBinaryLiteralLength () throws SQLException
 
int getMaxCharLiteralLength () throws SQLException
 
int getMaxColumnNameLength () throws SQLException
 
int getMaxColumnsInGroupBy () throws SQLException
 
int getMaxColumnsInIndex () throws SQLException
 
int getMaxColumnsInOrderBy () throws SQLException
 
int getMaxColumnsInSelect () throws SQLException
 
int getMaxColumnsInTable () throws SQLException
 
int getMaxConnections () throws SQLException
 
int getMaxCursorNameLength () throws SQLException
 
int getMaxIndexLength () throws SQLException
 
int getMaxSchemaNameLength () throws SQLException
 
int getMaxProcedureNameLength () throws SQLException
 
int getMaxCatalogNameLength () throws SQLException
 
int getMaxRowSize () throws SQLException
 
boolean doesMaxRowSizeIncludeBlobs () throws SQLException
 
int getMaxStatementLength () throws SQLException
 
int getMaxStatements () throws SQLException
 
int getMaxTableNameLength () throws SQLException
 
int getMaxTablesInSelect () throws SQLException
 
int getMaxUserNameLength () throws SQLException
 
int getDefaultTransactionIsolation () throws SQLException
 
boolean supportsTransactions () throws SQLException
 
boolean supportsTransactionIsolationLevel (int level) throws SQLException
 
boolean supportsDataDefinitionAndDataManipulationTransactions () throws SQLException
 
boolean supportsDataManipulationTransactionsOnly () throws SQLException
 
boolean dataDefinitionCausesTransactionCommit () throws SQLException
 
boolean dataDefinitionIgnoredInTransactions () throws SQLException
 
ResultSet getProcedures (String catalog, String schemaPattern, String procedureNamePattern) throws SQLException
 
ResultSet getProcedureColumns (String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
 
TColumnType createTColumnType (String colName, TTypeInfo colType)
 
TColumnType createTColumnType (String colName, TTypeInfo colType, Boolean irk)
 
ResultSet getTables (String catalog, String schemaPattern, String tableNamePattern, String[] types) throws SQLException
 
ResultSet getSchemas () throws SQLException
 
ResultSet getCatalogs () throws SQLException
 
ResultSet getTableTypes () throws SQLException
 
ResultSet getColumns (String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
 
ResultSet getColumnPrivileges (String catalog, String schema, String table, String columnNamePattern) throws SQLException
 
ResultSet getEmptyResultSet ()
 
ResultSet getEmptyResultSetWithDesc (TColumnType columns[]) throws SQLException
 
ResultSet getTablePrivileges (String catalog, String schemaPattern, String tableNamePattern) throws SQLException
 
ResultSet getBestRowIdentifier (String catalog, String schema, String table, int scope, boolean nullable) throws SQLException
 
ResultSet getVersionColumns (String catalog, String schema, String table) throws SQLException
 
ResultSet getPrimaryKeys (String catalog, String schema, String table) throws SQLException
 
ResultSet getImportedKeys (String catalog, String schema, String table) throws SQLException
 
ResultSet getExportedKeys (String catalog, String schema, String table) throws SQLException
 
ResultSet getCrossReference (String parentCatalog, String parentSchema, String parentTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException
 
ResultSet getTypeInfo () throws SQLException
 
ResultSet getIndexInfo (String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException
 
boolean supportsResultSetType (int type) throws SQLException
 
boolean supportsResultSetConcurrency (int type, int concurrency) throws SQLException
 
boolean ownUpdatesAreVisible (int type) throws SQLException
 
boolean ownDeletesAreVisible (int type) throws SQLException
 
boolean ownInsertsAreVisible (int type) throws SQLException
 
boolean othersUpdatesAreVisible (int type) throws SQLException
 
boolean othersDeletesAreVisible (int type) throws SQLException
 
boolean othersInsertsAreVisible (int type) throws SQLException
 
boolean updatesAreDetected (int type) throws SQLException
 
boolean deletesAreDetected (int type) throws SQLException
 
boolean insertsAreDetected (int type) throws SQLException
 
boolean supportsBatchUpdates () throws SQLException
 
ResultSet getUDTs (String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException
 
Connection getConnection () throws SQLException
 
boolean supportsSavepoints () throws SQLException
 
boolean supportsNamedParameters () throws SQLException
 
boolean supportsMultipleOpenResults () throws SQLException
 
boolean supportsGetGeneratedKeys () throws SQLException
 
ResultSet getSuperTypes (String catalog, String schemaPattern, String typeNamePattern) throws SQLException
 
ResultSet getSuperTables (String catalog, String schemaPattern, String tableNamePattern) throws SQLException
 
ResultSet getAttributes (String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern) throws SQLException
 
boolean supportsResultSetHoldability (int holdability) throws SQLException
 
int getResultSetHoldability () throws SQLException
 
int getDatabaseMajorVersion () throws SQLException
 
int getDatabaseMinorVersion () throws SQLException
 
int getJDBCMajorVersion () throws SQLException
 
int getJDBCMinorVersion () throws SQLException
 
int getSQLStateType () throws SQLException
 
boolean locatorsUpdateCopy () throws SQLException
 
boolean supportsStatementPooling () throws SQLException
 
RowIdLifetime getRowIdLifetime () throws SQLException
 
ResultSet getSchemas (String catalog, String schemaPattern) throws SQLException
 
boolean supportsStoredFunctionsUsingCallSyntax () throws SQLException
 
boolean autoCommitFailureClosesAllResultSets () throws SQLException
 
ResultSet getClientInfoProperties () throws SQLException
 
ResultSet getFunctions (String catalog, String schemaPattern, String functionNamePattern) throws SQLException
 
ResultSet getFunctionColumns (String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException
 
ResultSet getPseudoColumns (String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
 
boolean generatedKeyAlwaysReturned () throws SQLException
 
boolean isWrapperFor (Class<?> iface) throws SQLException
 

Package Functions

public< T > T unwrap (Class< T > iface) throws SQLException
 

Package Attributes

HeavyAIConnection con = null
 
int databaseMajorVersion = 0
 
int databaseMinorVersion = 0
 
String databaseVersion = null
 

Static Package Attributes

static final Logger HEAVYDBLOGGER
 

Private Member Functions

TColumn createTColumnData (Object data, List< Boolean > nullsList)
 
void tablePermProcess (List< String > tables, Map< String, HeavyAIData > dataMap, String tableNamePattern) throws TException
 

Detailed Description

Definition at line 43 of file HeavyAIDatabaseMetaData.java.

Constructor & Destructor Documentation

ai.heavy.jdbc.HeavyAIDatabaseMetaData.HeavyAIDatabaseMetaData ( HeavyAIConnection  connection) throws SQLException
inline

Definition at line 52 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseMajorVersion, ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseMinorVersion, and ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseVersion.

52  {
53  this.con = connection;
54 
55  try {
56  databaseVersion = con.client.get_version();
57  } catch (TException ex) {
58  throw new SQLException("Failed to get DB version " + ex.toString());
59  }
60  String vers[] = databaseVersion.split("\\.");
61  try {
62  databaseMajorVersion = Integer.parseInt(vers[0]);
63  databaseMinorVersion = Integer.parseInt(vers[1]);
64  } catch (NumberFormatException ex) {
65  throw new SQLException(
66  "Non-numeric version returned from HEAVY.AI server: " + ex.getMessage());
67  }
68  }

Member Function Documentation

boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.allProceduresAreCallable ( ) throws SQLException
inline

Definition at line 71 of file HeavyAIDatabaseMetaData.java.

71  {
72  HEAVYDBLOGGER.debug("Entered");
73  return false;
74  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.allTablesAreSelectable ( ) throws SQLException
inline

Definition at line 77 of file HeavyAIDatabaseMetaData.java.

77  {
78  HEAVYDBLOGGER.debug("Entered");
79  return true;
80  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.autoCommitFailureClosesAllResultSets ( ) throws SQLException
inline

Definition at line 1949 of file HeavyAIDatabaseMetaData.java.

1949  {
1950  HEAVYDBLOGGER.debug("Entered");
1951  return false;
1952  }
TColumn ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnData ( Object  data,
List< Boolean >  nullsList 
)
inlineprivate

Definition at line 953 of file HeavyAIDatabaseMetaData.java.

Referenced by ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTables().

953  {
954  TColumnData colData = new TColumnData();
955  colData.setStr_col((List<String>) data);
956 
957  TColumn col = new TColumn(colData, nullsList);
958  return col;
959  }

+ Here is the caller graph for this function:

TColumnType ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType ( String  colName,
TTypeInfo  colType 
)
inline
TColumnType ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType ( String  colName,
TTypeInfo  colType,
Boolean  irk 
)
inline

Definition at line 813 of file HeavyAIDatabaseMetaData.java.

813  {
814  TColumnType ct = new TColumnType();
815  ct.col_name = colName;
816  ct.col_type = colType;
817  ct.is_reserved_keyword = irk;
818  ct.is_system = false;
819  ct.is_physical = false;
820  return ct;
821  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.dataDefinitionCausesTransactionCommit ( ) throws SQLException
inline

Definition at line 769 of file HeavyAIDatabaseMetaData.java.

769  {
770  HEAVYDBLOGGER.debug("Entered");
771  return false;
772  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.dataDefinitionIgnoredInTransactions ( ) throws SQLException
inline

Definition at line 775 of file HeavyAIDatabaseMetaData.java.

775  {
776  HEAVYDBLOGGER.debug("Entered");
777  return false;
778  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.deletesAreDetected ( int  type) throws SQLException
inline

Definition at line 1784 of file HeavyAIDatabaseMetaData.java.

1784  {
1785  HEAVYDBLOGGER.debug("Entered");
1786  return false;
1787  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.doesMaxRowSizeIncludeBlobs ( ) throws SQLException
inline

Definition at line 702 of file HeavyAIDatabaseMetaData.java.

702  {
703  HEAVYDBLOGGER.debug("Entered");
704  return false;
705  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.generatedKeyAlwaysReturned ( ) throws SQLException
inline

Definition at line 1999 of file HeavyAIDatabaseMetaData.java.

1999  {
2000  HEAVYDBLOGGER.debug("Entered");
2001  return false;
2002  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getAttributes ( String  catalog,
String  schemaPattern,
String  typeNamePattern,
String  attributeNamePattern 
) throws SQLException
inline

Definition at line 1865 of file HeavyAIDatabaseMetaData.java.

1868  {
1869  HEAVYDBLOGGER.debug("Entered");
1870  throw new UnsupportedOperationException("Not supported yet,"
1871  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1872  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1873  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1874  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getBestRowIdentifier ( String  catalog,
String  schema,
String  table,
int  scope,
boolean  nullable 
) throws SQLException
inline

Definition at line 1448 of file HeavyAIDatabaseMetaData.java.

1450  {
1451  HEAVYDBLOGGER.debug("Entered");
1452  throw new UnsupportedOperationException("Not supported yet,"
1453  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1454  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1455  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1456  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getCatalogs ( ) throws SQLException
inline

Definition at line 1017 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemas().

1017  {
1018  HEAVYDBLOGGER.debug("Entered");
1019  return getSchemas();
1020  }

+ Here is the call graph for this function:

String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getCatalogSeparator ( ) throws SQLException
inline

Definition at line 456 of file HeavyAIDatabaseMetaData.java.

456  {
457  HEAVYDBLOGGER.debug("Entered");
458  return ".";
459  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getCatalogTerm ( ) throws SQLException
inline

Definition at line 444 of file HeavyAIDatabaseMetaData.java.

444  {
445  HEAVYDBLOGGER.debug("Entered");
446  return "N/A";
447  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getClientInfoProperties ( ) throws SQLException
inline

Definition at line 1955 of file HeavyAIDatabaseMetaData.java.

1955  {
1956  HEAVYDBLOGGER.debug("Entered");
1957  throw new UnsupportedOperationException("Not supported yet,"
1958  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1959  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1960  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1961  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getColumnPrivileges ( String  catalog,
String  schema,
String  table,
String  columnNamePattern 
) throws SQLException
inline

Definition at line 1297 of file HeavyAIDatabaseMetaData.java.

1299  {
1300  HEAVYDBLOGGER.debug("Entered");
1301  throw new UnsupportedOperationException("Not supported yet,"
1302  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1303  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1304  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1305  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getColumns ( String  catalog,
String  schemaPattern,
String  tableNamePattern,
String  columnNamePattern 
) throws SQLException
inline

Definition at line 1156 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), run_benchmark_import.result, run_benchmark_import.tables, and ai.heavy.jdbc.HeavyAIType.toJava().

1159  {
1160  HEAVYDBLOGGER.debug("Entered");
1161  HEAVYDBLOGGER.debug("TablePattern " + tableNamePattern + " columnNamePattern "
1162  + columnNamePattern);
1163  String modifiedTablePattern = tableNamePattern.replaceAll("%", ".*");
1164  String modifiedColumnPattern =
1165  (columnNamePattern == null) ? null : columnNamePattern.replaceAll("%", ".*");
1166 
1167  HEAVYDBLOGGER.debug("TablePattern " + tableNamePattern + " modifiedColumnPattern "
1168  + modifiedColumnPattern);
1169 
1170  // declare the columns in the result set
1171  TTypeInfo strTTI =
1172  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1173  TTypeInfo intTTI =
1174  new TTypeInfo(TDatumType.INT, TEncodingType.NONE, false, false, 0, 0, 0);
1175  TTypeInfo smallIntTTI =
1176  new TTypeInfo(TDatumType.SMALLINT, TEncodingType.NONE, false, false, 0, 0, 0);
1177  TColumnType columns[] = {createTColumnType("TABLE_CAT", new TTypeInfo(strTTI)),
1178  createTColumnType("TABLE_SCHEM", new TTypeInfo(strTTI)),
1179  createTColumnType("TABLE_NAME", new TTypeInfo(strTTI)),
1180  createTColumnType("COLUMN_NAME", new TTypeInfo(strTTI)),
1181  createTColumnType("DATA_TYPE", new TTypeInfo(intTTI)),
1182  createTColumnType("TYPE_NAME", new TTypeInfo(strTTI)),
1183  createTColumnType("COLUMN_SIZE", new TTypeInfo(intTTI)),
1184  createTColumnType("BUFFER_LENGTH", new TTypeInfo(strTTI)),
1185  createTColumnType("DECIMAL_DIGITS", new TTypeInfo(intTTI)),
1186  createTColumnType("NUM_PREC_RADIX", new TTypeInfo(intTTI)),
1187  createTColumnType("NULLABLE", new TTypeInfo(intTTI)),
1188  createTColumnType("REMARKS", new TTypeInfo(strTTI)),
1189  createTColumnType("COLUMN_DEF", new TTypeInfo(strTTI)),
1190  createTColumnType("SQL_DATA_TYPE", new TTypeInfo(intTTI)),
1191  createTColumnType("SQL_DATETIME_SUB", new TTypeInfo(intTTI)),
1192  createTColumnType("CHAR_OCTET_LENGTH", new TTypeInfo(intTTI)),
1193  createTColumnType("ORDINAL_POSITION", new TTypeInfo(intTTI)),
1194  createTColumnType("IS_NULLABLE", new TTypeInfo(strTTI)),
1195  createTColumnType("SCOPE_CATALOG", new TTypeInfo(strTTI)),
1196  createTColumnType("SCOPE_SCHEMA", new TTypeInfo(strTTI)),
1197  createTColumnType("SCOPE_TABLE", new TTypeInfo(strTTI)),
1198  createTColumnType("SOURCE_DATA_TYPE", new TTypeInfo(smallIntTTI)),
1199  createTColumnType("IS_AUTOINCREMENT", new TTypeInfo(strTTI)),
1200  createTColumnType("IS_GENERATEDCOLUMN", new TTypeInfo(strTTI))};
1201 
1202  Map<String, HeavyAIData> dataMap = new HashMap(columns.length);
1203 
1204  // create component to contain the meta data for the rows
1205  // and create a container to store the data and the nul indicators
1206  List<TColumnType> rowDesc = new ArrayList(columns.length);
1207  for (TColumnType col : columns) {
1208  rowDesc.add(col);
1209  dataMap.put(col.col_name, new HeavyAIData(col.col_type.type));
1210  }
1211 
1212  // Now add some actual details for table name
1213  List<String> tables;
1214  try {
1215  tables = con.client.get_tables_for_database(con.session, catalog);
1216  } catch (TException ex) {
1217  throw new SQLException("get_tables_for_database failed " + ex.toString());
1218  }
1219 
1220  for (String tableName : tables) {
1221  // check if the table matches the input pattern
1222  if (tableNamePattern == null || tableNamePattern.equals(tableName)) {
1223  // grab meta data for table
1224  TTableDetails tableDetails;
1225  try {
1226  tableDetails = con.client.get_table_details(con.session, tableName);
1227  } catch (TException ex) {
1228  throw new SQLException("get_table_details failed " + ex.toString());
1229  }
1230 
1231  int ordinal = 0;
1232  // iterate through the columns
1233  for (TColumnType value : tableDetails.row_desc) {
1234  ordinal++;
1235  if (columnNamePattern == null
1236  || value.col_name.matches(modifiedColumnPattern)) {
1237  dataMap.get("TABLE_CAT").setNull(true);
1238  dataMap.get("TABLE_SCHEM").setNull(true);
1239  dataMap.get("TABLE_NAME").add(tableName);
1240  dataMap.get("COLUMN_NAME").add(value.col_name);
1241  dataMap.get("DATA_TYPE").add(HeavyAIType.toJava(value.col_type.type));
1242  dataMap.get("TYPE_NAME")
1243  .add((value.col_type.type.name()
1244  + (value.col_type.is_array ? "[]" : "")));
1245  if (value.col_type.type == TDatumType.DECIMAL) {
1246  dataMap.get("COLUMN_SIZE").add(value.col_type.precision);
1247  } else {
1248  dataMap.get("COLUMN_SIZE").add(100);
1249  }
1250  dataMap.get("BUFFER_LENGTH").setNull(true);
1251  if (value.col_type.type == TDatumType.DECIMAL) {
1252  dataMap.get("DECIMAL_DIGITS").add(value.col_type.scale);
1253  } else {
1254  dataMap.get("DECIMAL_DIGITS").setNull(true);
1255  }
1256  dataMap.get("NUM_PREC_RADIX").add(10);
1257  dataMap.get("NULLABLE")
1258  .add(value.col_type.nullable ? DatabaseMetaData.columnNullable
1259  : DatabaseMetaData.columnNoNulls);
1260  dataMap.get("REMARKS").add(" ");
1261  dataMap.get("COLUMN_DEF").setNull(true);
1262  dataMap.get("SQL_DATA_TYPE").add(0);
1263  dataMap.get("SQL_DATETIME_SUB").setNull(true);
1264  dataMap.get("CHAR_OCTET_LENGTH").add(0);
1265  dataMap.get("ORDINAL_POSITION").add(ordinal);
1266  dataMap.get("IS_NULLABLE").add(value.col_type.nullable ? "YES" : "NO");
1267  dataMap.get("SCOPE_CATALOG").setNull(true);
1268  dataMap.get("SCOPE_SCHEMA").setNull(true);
1269  dataMap.get("SCOPE_TABLE").setNull(true);
1270  dataMap.get("SOURCE_DATA_TYPE").add(HeavyAIType.toJava(value.col_type.type));
1271  dataMap.get("IS_AUTOINCREMENT").add("NO");
1272  dataMap.get("IS_GENERATEDCOLUMN").add("NO");
1273  }
1274  }
1275  }
1276  }
1277 
1278  List<TColumn> columnsList = new ArrayList(columns.length);
1279 
1280  for (TColumnType col : columns) {
1281  TColumn schemaCol = dataMap.get(col.col_name).getTColumn();
1282  // logger.info("Tcolumn is "+ schemaCol.toString());
1283  columnsList.add(schemaCol);
1284  }
1285 
1286  // create a rowset for the result
1287  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1288 
1289  TQueryResult result = new TQueryResult(
1290  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1291 
1292  HeavyAIResultSet cols = new HeavyAIResultSet(result, "getColumns");
1293  return cols;
1294  }
TColumnType createTColumnType(String colName, TTypeInfo colType)

+ Here is the call graph for this function:

Connection ai.heavy.jdbc.HeavyAIDatabaseMetaData.getConnection ( ) throws SQLException
inline

Definition at line 1813 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.con.

1813  {
1814  HEAVYDBLOGGER.debug("Entered");
1815  return con;
1816  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getCrossReference ( String  parentCatalog,
String  parentSchema,
String  parentTable,
String  foreignCatalog,
String  foreignSchema,
String  foreignTable 
) throws SQLException
inline

Definition at line 1548 of file HeavyAIDatabaseMetaData.java.

1553  {
1554  HEAVYDBLOGGER.debug("Entered");
1555  throw new UnsupportedOperationException("Not supported yet,"
1556  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1557  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1558  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1559  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDatabaseMajorVersion ( ) throws SQLException
inline

Definition at line 1889 of file HeavyAIDatabaseMetaData.java.

1889  {
1890  HEAVYDBLOGGER.debug("Entered");
1891  return this.databaseMajorVersion;
1892  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDatabaseMinorVersion ( ) throws SQLException
inline

Definition at line 1895 of file HeavyAIDatabaseMetaData.java.

1895  {
1896  HEAVYDBLOGGER.debug("Entered");
1897  return this.databaseMinorVersion;
1898  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDatabaseProductName ( ) throws SQLException
inline

Definition at line 125 of file HeavyAIDatabaseMetaData.java.

125  {
126  HEAVYDBLOGGER.debug("Entered");
127  return "OmniSciDB";
128  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDatabaseProductVersion ( ) throws SQLException
inline

Definition at line 131 of file HeavyAIDatabaseMetaData.java.

132  { // logger.debug("Entered");
133  HEAVYDBLOGGER.debug("Entered");
134  return this.databaseVersion;
135  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDefaultTransactionIsolation ( ) throws SQLException
inline

Definition at line 738 of file HeavyAIDatabaseMetaData.java.

738  {
739  HEAVYDBLOGGER.debug("Entered");
740  return Connection.TRANSACTION_NONE;
741  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDriverMajorVersion ( )
inline
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDriverMinorVersion ( )
inline
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDriverName ( ) throws SQLException
inline

Definition at line 138 of file HeavyAIDatabaseMetaData.java.

138  {
139  HEAVYDBLOGGER.debug("Entered");
140  return "OmniSciDB JDBC Driver";
141  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getDriverVersion ( ) throws SQLException
inline

Definition at line 144 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDriver.DriverVersion.

144  { // logger.debug("Entered");
145  HEAVYDBLOGGER.debug("Entered");
147  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSet ( )
inline

Definition at line 1307 of file HeavyAIDatabaseMetaData.java.

Referenced by ai.heavy.jdbc.HeavyAIDatabaseMetaData.getIndexInfo().

1307  {
1308  return new HeavyAIResultSet();
1309  }

+ Here is the caller graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSetWithDesc ( TColumnType  columns[]) throws SQLException
inline

Definition at line 1313 of file HeavyAIDatabaseMetaData.java.

References run_benchmark_import.result.

Referenced by ai.heavy.jdbc.HeavyAIDatabaseMetaData.getExportedKeys(), ai.heavy.jdbc.HeavyAIDatabaseMetaData.getImportedKeys(), and ai.heavy.jdbc.HeavyAIDatabaseMetaData.getPrimaryKeys().

1314  { // for compatibility and future
1315  Map<String, HeavyAIData> dataMap = new HashMap(columns.length);
1316  List<TColumnType> rowDesc = new ArrayList(columns.length);
1317  for (TColumnType col : columns) {
1318  rowDesc.add(col);
1319  dataMap.put(col.col_name, new HeavyAIData(col.col_type.type));
1320  }
1321  List<TColumn> columnsList = new ArrayList(columns.length);
1322  for (TColumnType col : columns) {
1323  TColumn schemaCol = dataMap.get(col.col_name).getTColumn();
1324  columnsList.add(schemaCol);
1325  }
1326  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1327  TQueryResult result = new TQueryResult(
1328  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1329  HeavyAIResultSet cols = new HeavyAIResultSet(result, "getColumns");
1330  return cols;
1331  }

+ Here is the caller graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getExportedKeys ( String  catalog,
String  schema,
String  table 
) throws SQLException
inline

Definition at line 1519 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSetWithDesc().

1520  {
1521  HEAVYDBLOGGER.debug("Entered");
1522 
1523  TTypeInfo strTTI =
1524  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1525  TTypeInfo intTTI =
1526  new TTypeInfo(TDatumType.INT, TEncodingType.NONE, false, false, 0, 0, 0);
1527  TTypeInfo smallIntTTI =
1528  new TTypeInfo(TDatumType.SMALLINT, TEncodingType.NONE, false, false, 0, 0, 0);
1529  TColumnType columns[] = {createTColumnType("FKTABLE_CAT", new TTypeInfo(strTTI)),
1530  createTColumnType("FKTABLE_SCHEM", new TTypeInfo(strTTI)),
1531  createTColumnType("FKTABLE_NAME", new TTypeInfo(strTTI)),
1532  createTColumnType("FKCOLUMN_NAME", new TTypeInfo(strTTI)),
1533  createTColumnType("PKTABLE_CAT", new TTypeInfo(strTTI)),
1534  createTColumnType("PKTABLE_SCHEM", new TTypeInfo(strTTI)),
1535  createTColumnType("PKTABLE_NAME", new TTypeInfo(strTTI)),
1536  createTColumnType("PKCOLUMN_NAME", new TTypeInfo(strTTI)),
1537  createTColumnType("KEY_SEQ", new TTypeInfo(smallIntTTI)),
1538  createTColumnType("UPDATE_RULE", new TTypeInfo(smallIntTTI)),
1539  createTColumnType("DELETE_RULE", new TTypeInfo(smallIntTTI)),
1540  createTColumnType("PK_NAME", new TTypeInfo(strTTI)),
1541  createTColumnType("FK_NAME", new TTypeInfo(strTTI)),
1542  createTColumnType("DEFERRABILITY", new TTypeInfo(smallIntTTI))};
1543 
1544  return getEmptyResultSetWithDesc(columns);
1545  }
TColumnType createTColumnType(String colName, TTypeInfo colType)
ResultSet getEmptyResultSetWithDesc(TColumnType columns[])

+ Here is the call graph for this function:

String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getExtraNameCharacters ( ) throws SQLException
inline

Definition at line 264 of file HeavyAIDatabaseMetaData.java.

264  {
265  HEAVYDBLOGGER.debug("Entered");
266  return "";
267  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getFunctionColumns ( String  catalog,
String  schemaPattern,
String  functionNamePattern,
String  columnNamePattern 
) throws SQLException
inline

Definition at line 1975 of file HeavyAIDatabaseMetaData.java.

1978  {
1979  HEAVYDBLOGGER.debug("Entered");
1980  throw new UnsupportedOperationException("Not supported yet,"
1981  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1982  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1983  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1984  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getFunctions ( String  catalog,
String  schemaPattern,
String  functionNamePattern 
) throws SQLException
inline

Definition at line 1964 of file HeavyAIDatabaseMetaData.java.

1966  {
1967  HEAVYDBLOGGER.debug("Entered");
1968  throw new UnsupportedOperationException("Not supported yet,"
1969  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1970  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1971  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1972  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getIdentifierQuoteString ( ) throws SQLException
inline

Definition at line 220 of file HeavyAIDatabaseMetaData.java.

220  {
221  HEAVYDBLOGGER.debug("Entered");
222  return " ";
223  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getImportedKeys ( String  catalog,
String  schema,
String  table 
) throws SQLException
inline

Definition at line 1490 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSetWithDesc().

1491  {
1492  HEAVYDBLOGGER.debug("Entered");
1493 
1494  TTypeInfo strTTI =
1495  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1496  TTypeInfo intTTI =
1497  new TTypeInfo(TDatumType.INT, TEncodingType.NONE, false, false, 0, 0, 0);
1498  TTypeInfo smallIntTTI =
1499  new TTypeInfo(TDatumType.SMALLINT, TEncodingType.NONE, false, false, 0, 0, 0);
1500  TColumnType columns[] = {createTColumnType("PKTABLE_CAT", new TTypeInfo(strTTI)),
1501  createTColumnType("PKTABLE_SCHEM", new TTypeInfo(strTTI)),
1502  createTColumnType("PKTABLE_NAME", new TTypeInfo(strTTI)),
1503  createTColumnType("PKCOLUMN_NAME", new TTypeInfo(strTTI)),
1504  createTColumnType("FKTABLE_CAT", new TTypeInfo(strTTI)),
1505  createTColumnType("FKTABLE_SCHEM", new TTypeInfo(strTTI)),
1506  createTColumnType("FKTABLE_NAME", new TTypeInfo(strTTI)),
1507  createTColumnType("FKCOLUMN_NAME", new TTypeInfo(strTTI)),
1508  createTColumnType("KEY_SEQ", new TTypeInfo(smallIntTTI)),
1509  createTColumnType("UPDATE_RULE", new TTypeInfo(smallIntTTI)),
1510  createTColumnType("DELETE_RULE", new TTypeInfo(smallIntTTI)),
1511  createTColumnType("FK_NAME", new TTypeInfo(strTTI)),
1512  createTColumnType("PK_NAME", new TTypeInfo(strTTI)),
1513  createTColumnType("DEFERRABILITY", new TTypeInfo(smallIntTTI))};
1514 
1515  return getEmptyResultSetWithDesc(columns);
1516  }
TColumnType createTColumnType(String colName, TTypeInfo colType)
ResultSet getEmptyResultSetWithDesc(TColumnType columns[])

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getIndexInfo ( String  catalog,
String  schema,
String  table,
boolean  unique,
boolean  approximate 
) throws SQLException
inline

Definition at line 1719 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSet().

1723  {
1724  HEAVYDBLOGGER.debug("Entered");
1725  return getEmptyResultSet();
1726  }

+ Here is the call graph for this function:

int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getJDBCMajorVersion ( ) throws SQLException
inline

Definition at line 1901 of file HeavyAIDatabaseMetaData.java.

1901  {
1902  HEAVYDBLOGGER.debug("Entered");
1903  return 0;
1904  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getJDBCMinorVersion ( ) throws SQLException
inline

Definition at line 1907 of file HeavyAIDatabaseMetaData.java.

1907  { // logger.debug("Entered");
1908  HEAVYDBLOGGER.debug("Entered");
1909  return 0;
1910  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxBinaryLiteralLength ( ) throws SQLException
inline

Definition at line 612 of file HeavyAIDatabaseMetaData.java.

612  {
613  HEAVYDBLOGGER.debug("Entered");
614  return 0;
615  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxCatalogNameLength ( ) throws SQLException
inline

Definition at line 690 of file HeavyAIDatabaseMetaData.java.

690  {
691  HEAVYDBLOGGER.debug("Entered");
692  return 0;
693  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxCharLiteralLength ( ) throws SQLException
inline

Definition at line 618 of file HeavyAIDatabaseMetaData.java.

618  {
619  HEAVYDBLOGGER.debug("Entered");
620  return 0;
621  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnNameLength ( ) throws SQLException
inline

Definition at line 624 of file HeavyAIDatabaseMetaData.java.

624  {
625  HEAVYDBLOGGER.debug("Entered");
626  return 0;
627  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnsInGroupBy ( ) throws SQLException
inline

Definition at line 630 of file HeavyAIDatabaseMetaData.java.

630  {
631  HEAVYDBLOGGER.debug("Entered");
632  return 0;
633  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnsInIndex ( ) throws SQLException
inline

Definition at line 636 of file HeavyAIDatabaseMetaData.java.

636  {
637  HEAVYDBLOGGER.debug("Entered");
638  return 0;
639  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnsInOrderBy ( ) throws SQLException
inline

Definition at line 642 of file HeavyAIDatabaseMetaData.java.

642  {
643  HEAVYDBLOGGER.debug("Entered");
644  return 0;
645  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnsInSelect ( ) throws SQLException
inline

Definition at line 648 of file HeavyAIDatabaseMetaData.java.

648  {
649  HEAVYDBLOGGER.debug("Entered");
650  return 0;
651  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxColumnsInTable ( ) throws SQLException
inline

Definition at line 654 of file HeavyAIDatabaseMetaData.java.

654  {
655  HEAVYDBLOGGER.debug("Entered");
656  return 0;
657  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxConnections ( ) throws SQLException
inline

Definition at line 660 of file HeavyAIDatabaseMetaData.java.

660  {
661  HEAVYDBLOGGER.debug("Entered");
662  return 0;
663  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxCursorNameLength ( ) throws SQLException
inline

Definition at line 666 of file HeavyAIDatabaseMetaData.java.

666  {
667  HEAVYDBLOGGER.debug("Entered");
668  return 0;
669  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxIndexLength ( ) throws SQLException
inline

Definition at line 672 of file HeavyAIDatabaseMetaData.java.

672  {
673  HEAVYDBLOGGER.debug("Entered");
674  return 0;
675  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxProcedureNameLength ( ) throws SQLException
inline

Definition at line 684 of file HeavyAIDatabaseMetaData.java.

684  {
685  HEAVYDBLOGGER.debug("Entered");
686  return 0;
687  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxRowSize ( ) throws SQLException
inline

Definition at line 696 of file HeavyAIDatabaseMetaData.java.

696  {
697  HEAVYDBLOGGER.debug("Entered");
698  return 0;
699  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxSchemaNameLength ( ) throws SQLException
inline

Definition at line 678 of file HeavyAIDatabaseMetaData.java.

678  {
679  HEAVYDBLOGGER.debug("Entered");
680  return 0;
681  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxStatementLength ( ) throws SQLException
inline

Definition at line 708 of file HeavyAIDatabaseMetaData.java.

708  {
709  HEAVYDBLOGGER.debug("Entered");
710  return 0;
711  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxStatements ( ) throws SQLException
inline

Definition at line 714 of file HeavyAIDatabaseMetaData.java.

714  {
715  HEAVYDBLOGGER.debug("Entered");
716  return 0;
717  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxTableNameLength ( ) throws SQLException
inline

Definition at line 720 of file HeavyAIDatabaseMetaData.java.

720  {
721  HEAVYDBLOGGER.debug("Entered");
722  return 0;
723  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxTablesInSelect ( ) throws SQLException
inline

Definition at line 726 of file HeavyAIDatabaseMetaData.java.

726  {
727  HEAVYDBLOGGER.debug("Entered");
728  return 0;
729  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getMaxUserNameLength ( ) throws SQLException
inline

Definition at line 732 of file HeavyAIDatabaseMetaData.java.

732  {
733  HEAVYDBLOGGER.debug("Entered");
734  return 0;
735  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getNumericFunctions ( ) throws SQLException
inline

Definition at line 232 of file HeavyAIDatabaseMetaData.java.

232  {
233  HEAVYDBLOGGER.debug("Entered");
234  return "ACOS(float), ACOS(number), ASIN, ATAN2, CEIL, COS, COT, DEGREES, EXP, FLOOR, LN, LOG, PI(), POWER, SQRT"
235  + ", RADIANS, ROUND, SIN, TAN, ATAN, ABS, MOD SIGN, TRUNCATE";
236  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getPrimaryKeys ( String  catalog,
String  schema,
String  table 
) throws SQLException
inline

Definition at line 1469 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and ai.heavy.jdbc.HeavyAIDatabaseMetaData.getEmptyResultSetWithDesc().

1470  {
1471  HEAVYDBLOGGER.debug("Entered");
1472 
1473  TTypeInfo strTTI =
1474  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1475  TTypeInfo intTTI =
1476  new TTypeInfo(TDatumType.INT, TEncodingType.NONE, false, false, 0, 0, 0);
1477  TTypeInfo smallIntTTI =
1478  new TTypeInfo(TDatumType.SMALLINT, TEncodingType.NONE, false, false, 0, 0, 0);
1479  TColumnType columns[] = {createTColumnType("TABLE_CAT", new TTypeInfo(strTTI)),
1480  createTColumnType("TABLE_SCHEM", new TTypeInfo(strTTI)),
1481  createTColumnType("TABLE_NAME", new TTypeInfo(strTTI)),
1482  createTColumnType("COLUMN_NAME", new TTypeInfo(strTTI)),
1483  createTColumnType("KEY_SEQ", new TTypeInfo(smallIntTTI)),
1484  createTColumnType("PK_NAME", new TTypeInfo(strTTI))};
1485 
1486  return getEmptyResultSetWithDesc(columns);
1487  }
TColumnType createTColumnType(String colName, TTypeInfo colType)
ResultSet getEmptyResultSetWithDesc(TColumnType columns[])

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getProcedureColumns ( String  catalog,
String  schemaPattern,
String  procedureNamePattern,
String  columnNamePattern 
) throws SQLException
inline

Definition at line 794 of file HeavyAIDatabaseMetaData.java.

797  {
798  HEAVYDBLOGGER.debug("Entered");
799  throw new UnsupportedOperationException("Not supported yet,"
800  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
801  + " class:" + new Throwable().getStackTrace()[0].getClassName()
802  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
803  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getProcedures ( String  catalog,
String  schemaPattern,
String  procedureNamePattern 
) throws SQLException
inline

Definition at line 781 of file HeavyAIDatabaseMetaData.java.

783  {
784  HEAVYDBLOGGER.debug("Entered");
785  return null;
786  // throw new UnsupportedOperationException("Not supported yet," + " line:" + new
787  // Throwable().getStackTrace()[0].
788  // getLineNumber() + " class:" + new
789  // Throwable().getStackTrace()[0].getClassName() + " method:" + new
790  // Throwable(). getStackTrace()[0].getMethodName());
791  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getProcedureTerm ( ) throws SQLException
inline

Definition at line 438 of file HeavyAIDatabaseMetaData.java.

438  {
439  HEAVYDBLOGGER.debug("Entered");
440  return "N/A";
441  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getPseudoColumns ( String  catalog,
String  schemaPattern,
String  tableNamePattern,
String  columnNamePattern 
) throws SQLException
inline

Definition at line 1987 of file HeavyAIDatabaseMetaData.java.

1990  {
1991  HEAVYDBLOGGER.debug("Entered");
1992  throw new UnsupportedOperationException("Not supported yet,"
1993  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1994  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1995  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1996  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getResultSetHoldability ( ) throws SQLException
inline

Definition at line 1883 of file HeavyAIDatabaseMetaData.java.

1883  {
1884  HEAVYDBLOGGER.debug("Entered");
1885  return ResultSet.CLOSE_CURSORS_AT_COMMIT;
1886  }
RowIdLifetime ai.heavy.jdbc.HeavyAIDatabaseMetaData.getRowIdLifetime ( ) throws SQLException
inline

Definition at line 1931 of file HeavyAIDatabaseMetaData.java.

1931  {
1932  HEAVYDBLOGGER.debug("Entered");
1933  return RowIdLifetime.ROWID_VALID_OTHER;
1934  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemas ( ) throws SQLException
inline

Definition at line 962 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and run_benchmark_import.result.

Referenced by ai.heavy.jdbc.HeavyAIDatabaseMetaData.getCatalogs(), and ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemas().

962  {
963  HEAVYDBLOGGER.debug("Entered");
964 
965  List<TDBInfo> databases = null;
966 
967  try {
968  databases = con.client.get_databases(con.session);
969  } catch (TException ex) {
970  throw new SQLException("get_database failed " + ex.toString());
971  }
972 
973  // process info from databses into the resultset,
974  // then place in regular return from HEAVY.AI
975  TTypeInfo strTTI =
976  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
977  TColumnType columns[] = {createTColumnType("TABLE_SCHEM", new TTypeInfo(strTTI)),
978  createTColumnType("TABLE_CATALOG", new TTypeInfo(strTTI))};
979  // create component to contain the meta data for the rows
980  List<TColumnType> rowDesc = new ArrayList();
981  for (TColumnType col : columns) {
982  rowDesc.add(col);
983  }
984 
985  // Now add some actual details for schema name
986  List<String> schemaList = new ArrayList();
987  List<Boolean> nullList = new ArrayList();
988  List<Boolean> catalogNullList = new ArrayList();
989 
990  for (TDBInfo x : databases) {
991  schemaList.add(x.db_name);
992  nullList.add(false);
993  catalogNullList.add(true);
994  }
995 
996  TColumnData colData = new TColumnData();
997  colData.setStr_col(schemaList);
998 
999  TColumn schemaCol = new TColumn(colData, nullList);
1000  TColumn catalogCol = new TColumn(null, catalogNullList);
1001 
1002  List<TColumn> columnsList = new ArrayList();
1003  columnsList.add(schemaCol);
1004  columnsList.add(catalogCol);
1005 
1006  // create a rowset for the result
1007  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1008 
1009  TQueryResult result = new TQueryResult(
1010  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1011 
1012  HeavyAIResultSet schemas = new HeavyAIResultSet(result, "getSchemas");
1013  return schemas;
1014  }
TColumnType createTColumnType(String colName, TTypeInfo colType)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemas ( String  catalog,
String  schemaPattern 
) throws SQLException
inline

Definition at line 1937 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemas().

1937  {
1938  HEAVYDBLOGGER.debug("Entered");
1939  return getSchemas();
1940  }

+ Here is the call graph for this function:

String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSchemaTerm ( ) throws SQLException
inline

Definition at line 432 of file HeavyAIDatabaseMetaData.java.

432  {
433  HEAVYDBLOGGER.debug("Entered");
434  return "Database";
435  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSearchStringEscape ( ) throws SQLException
inline

Definition at line 258 of file HeavyAIDatabaseMetaData.java.

258  {
259  HEAVYDBLOGGER.debug("Entered");
260  return "\\";
261  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSQLKeywords ( ) throws SQLException
inline

Definition at line 226 of file HeavyAIDatabaseMetaData.java.

226  {
227  HEAVYDBLOGGER.debug("Entered");
228  return "";
229  }
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSQLStateType ( ) throws SQLException
inline

Definition at line 1913 of file HeavyAIDatabaseMetaData.java.

1913  {
1914  HEAVYDBLOGGER.debug("Entered");
1915  return 0;
1916  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getStringFunctions ( ) throws SQLException
inline

Definition at line 239 of file HeavyAIDatabaseMetaData.java.

239  {
240  HEAVYDBLOGGER.debug("Entered");
241  return "CHAR_LENGTH, CHAR, KEY_FOR_STRING";
242  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSuperTables ( String  catalog,
String  schemaPattern,
String  tableNamePattern 
) throws SQLException
inline

Definition at line 1854 of file HeavyAIDatabaseMetaData.java.

1856  {
1857  HEAVYDBLOGGER.debug("Entered");
1858  throw new UnsupportedOperationException("Not supported yet,"
1859  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1860  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1861  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1862  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSuperTypes ( String  catalog,
String  schemaPattern,
String  typeNamePattern 
) throws SQLException
inline

Definition at line 1843 of file HeavyAIDatabaseMetaData.java.

1845  {
1846  HEAVYDBLOGGER.debug("Entered");
1847  throw new UnsupportedOperationException("Not supported yet,"
1848  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1849  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1850  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1851  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getSystemFunctions ( ) throws SQLException
inline

Definition at line 245 of file HeavyAIDatabaseMetaData.java.

245  {
246  HEAVYDBLOGGER.debug("Entered");
247  return "";
248  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTablePrivileges ( String  catalog,
String  schemaPattern,
String  tableNamePattern 
) throws SQLException
inline

Definition at line 1389 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), run_benchmark_import.result, ai.heavy.jdbc.HeavyAIDatabaseMetaData.tablePermProcess(), run_benchmark_import.tables, and run_benchmark_import.type.

1391  {
1392  HEAVYDBLOGGER.debug("Entered");
1393 
1394  String modifiedTablePattern =
1395  (tableNamePattern == null) ? null : tableNamePattern.replaceAll("%", ".*");
1396 
1397  HEAVYDBLOGGER.debug("TablePattern " + tableNamePattern + " modifiedTableNamePattern "
1398  + modifiedTablePattern);
1399 
1400  // declare the columns in the result set
1401  final TTypeInfo strTTI =
1402  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1403  final TDatumType datumType = strTTI.type;
1404 
1405  Map<String, HeavyAIData> dataMap = new HashMap() {
1406  {
1407  put("TABLE_CAT", new HeavyAIData(datumType));
1408  put("TABLE_SCHEM", new HeavyAIData(datumType));
1409  put("TABLE_NAME", new HeavyAIData(datumType));
1410  put("GRANTOR", new HeavyAIData(datumType));
1411  put("GRANTEE", new HeavyAIData(datumType));
1412  put("PRIVILEGE", new HeavyAIData(datumType));
1413  put("IS_GRANTABLE", new HeavyAIData(datumType));
1414  }
1415  };
1416 
1417  try {
1418  // Get all the tables and then pattern match them in tablePermProcess
1419  List<String> tables = con.client.get_tables(con.session);
1420  tablePermProcess(tables, dataMap, modifiedTablePattern);
1421  } catch (TException ex) {
1422  throw new SQLException("get_privileges failed " + ex.toString());
1423  }
1424 
1425  // create component to contain the meta data for the rows
1426  // and create a container to store the data and the nul indicators
1427  // List<TColumnType> rowDesc = new ArrayList(columns.length);
1428 
1429  List<TColumnType> rowDesc = new ArrayList(dataMap.size());
1430  List<TColumn> columnsList = new ArrayList(dataMap.size());
1431 
1432  for (Map.Entry<String, HeavyAIData> pair : dataMap.entrySet()) {
1433  columnsList.add(pair.getValue().getTColumn());
1434  rowDesc.add(createTColumnType(pair.getKey(), new TTypeInfo(strTTI)));
1435  }
1436 
1437  // create a rowset for the result
1438  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1439 
1440  TQueryResult result = new TQueryResult(
1441  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1442 
1443  HeavyAIResultSet cols = new HeavyAIResultSet(result, "getPrivileges");
1444  return cols;
1445  }
void tablePermProcess(List< String > tables, Map< String, HeavyAIData > dataMap, String tableNamePattern)
TColumnType createTColumnType(String colName, TTypeInfo colType)

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTables ( String  catalog,
String  schemaPattern,
String  tableNamePattern,
String[]  types 
) throws SQLException
inline

Definition at line 869 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnData(), ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), run_benchmark_import.result, and run_benchmark_import.tables.

871  {
872  HEAVYDBLOGGER.debug("Entered");
873 
874  List<String> tables;
875  try {
876  tables = con.client.get_tables_for_database(con.session, catalog);
877  } catch (TException ex) {
878  throw new SQLException("get_tables_for_database failed " + ex.toString());
879  }
880 
881  List<String> views;
882  try {
883  views = con.client.get_views(con.session);
884  } catch (TException ex) {
885  throw new SQLException("get_views failed " + ex.toString());
886  }
887 
888  TTypeInfo strTTI =
889  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
890  TColumnType columns[] = {createTColumnType("TABLE_CAT", new TTypeInfo(strTTI)),
891  createTColumnType("TABLE_SCHEM", new TTypeInfo(strTTI)),
892  createTColumnType("TABLE_NAME", new TTypeInfo(strTTI)),
893  createTColumnType("TABLE_TYPE", new TTypeInfo(strTTI)),
894  createTColumnType("REMARKS", new TTypeInfo(strTTI)),
895  createTColumnType("TYPE_CAT", new TTypeInfo(strTTI)),
896  createTColumnType("TYPE_SCHEM", new TTypeInfo(strTTI)),
897  createTColumnType("TYPE_NAME", new TTypeInfo(strTTI)),
898  createTColumnType("SELF_REFERENCING_COL_NAME", new TTypeInfo(strTTI)),
899  createTColumnType("REF_GENERATION", new TTypeInfo(strTTI))};
900 
901  Map<String, ArrayList<String>> dataMap = new HashMap(columns.length);
902  Map<String, ArrayList<Boolean>> nullMap = new HashMap(columns.length);
903 
904  // create component to contain the meta data for the rows
905  // and create a container to store the data and the nul indicators
906  List<TColumnType> rowDesc = new ArrayList(columns.length);
907  for (TColumnType col : columns) {
908  rowDesc.add(col);
909  dataMap.put(col.col_name, new ArrayList());
910  nullMap.put(col.col_name, new ArrayList());
911  }
912  if (schemaPattern == null
913  || schemaPattern.toLowerCase().equals(con.getCatalog().toLowerCase())) {
914  // Now add some actual details for table name
915  for (String x : tables) {
916  dataMap.get("TABLE_NAME").add(x);
917  nullMap.get("TABLE_NAME").add(false);
918  nullMap.get("TABLE_SCHEM").add(true);
919  nullMap.get("TABLE_CAT").add(true);
920  if (views.contains(x) == true) {
921  dataMap.get("TABLE_TYPE").add("VIEW");
922  } else {
923  dataMap.get("TABLE_TYPE").add("TABLE");
924  }
925  nullMap.get("TABLE_TYPE").add(false);
926  nullMap.get("REMARKS").add(true);
927  nullMap.get("TYPE_CAT").add(true);
928  nullMap.get("TYPE_SCHEM").add(true);
929  nullMap.get("TYPE_NAME").add(true);
930  nullMap.get("SELF_REFERENCING_COL_NAME").add(true);
931  nullMap.get("REF_GENERATION").add(true);
932  }
933  }
934  List<TColumn> columnsList = new ArrayList(columns.length);
935 
936  for (TColumnType col : columns) {
937  TColumn schemaCol =
938  createTColumnData(dataMap.get(col.col_name), nullMap.get(col.col_name));
939  columnsList.add(schemaCol);
940  }
941 
942  // create a rowset for the result
943  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
944 
945  TQueryResult result = new TQueryResult(
946  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
947 
948  HeavyAIResultSet tab = new HeavyAIResultSet(result, "GetTables");
949  return tab;
950  }
TColumnType createTColumnType(String colName, TTypeInfo colType)
TColumn createTColumnData(Object data, List< Boolean > nullsList)

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTableTypes ( ) throws SQLException
inline

Definition at line 1023 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and run_benchmark_import.result.

1023  {
1024  HEAVYDBLOGGER.debug("Entered");
1025 
1026  TTypeInfo strTTI =
1027  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1028  TColumnType columns[] = {createTColumnType("TABLE_TYPE", new TTypeInfo(strTTI))};
1029 
1030  Map<String, HeavyAIData> dataMap = new HashMap(columns.length);
1031 
1032  // create component to contain the meta data for the rows
1033  // and create a container to store the data and the nul indicators
1034  List<TColumnType> rowDesc = new ArrayList(columns.length);
1035  for (TColumnType col : columns) {
1036  rowDesc.add(col);
1037  dataMap.put(col.col_name, new HeavyAIData(col.col_type.type));
1038  }
1039 
1040  // Now add some actual details for table name
1041  dataMap.get("TABLE_TYPE").add("TABLE");
1042  dataMap.get("TABLE_TYPE").add("VIEW");
1043 
1044  List<TColumn> columnsList = new ArrayList(columns.length);
1045 
1046  for (TColumnType col : columns) {
1047  TColumn schemaCol = dataMap.get(col.col_name).getTColumn();
1048  columnsList.add(schemaCol);
1049  }
1050 
1051  // create a rowset for the result
1052  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1053 
1054  TQueryResult result = new TQueryResult(
1055  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1056 
1057  HeavyAIResultSet tab = new HeavyAIResultSet(result, "getTableTypes");
1058 
1059  // logger.info("Dump result "+ result.toString());
1060  return tab;
1061  }
TColumnType createTColumnType(String colName, TTypeInfo colType)

+ Here is the call graph for this function:

String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTimeDateFunctions ( ) throws SQLException
inline

Definition at line 251 of file HeavyAIDatabaseMetaData.java.

251  {
252  HEAVYDBLOGGER.debug("Entered");
253  // return "NOW,CURDATE,SECOND,HOUR,YEAR,EXTRACT,QUARTER,WEEK,MONTH,DATETRUNC";
254  return "DATE_TRUNC, NOW, EXTRACT";
255  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTypeInfo ( ) throws SQLException
inline

Definition at line 1625 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.HeavyAIDatabaseMetaData.createTColumnType(), and run_benchmark_import.result.

1625  {
1626  HEAVYDBLOGGER.debug("Entered");
1627 
1628  // declare the columns in the result set
1629  TTypeInfo strTTI =
1630  new TTypeInfo(TDatumType.STR, TEncodingType.NONE, false, false, 0, 0, 0);
1631  TTypeInfo intTTI =
1632  new TTypeInfo(TDatumType.INT, TEncodingType.NONE, false, false, 0, 0, 0);
1633  TTypeInfo smallIntTTI =
1634  new TTypeInfo(TDatumType.SMALLINT, TEncodingType.NONE, false, false, 0, 0, 0);
1635  TTypeInfo boolTTI =
1636  new TTypeInfo(TDatumType.BOOL, TEncodingType.NONE, false, false, 0, 0, 0);
1637  TColumnType columns[] = {createTColumnType("TYPE_NAME", new TTypeInfo(strTTI)),
1638  createTColumnType("DATA_TYPE", new TTypeInfo(intTTI)),
1639  createTColumnType("PRECISION", new TTypeInfo(intTTI)),
1640  createTColumnType("LITERAL_PREFIX", new TTypeInfo(strTTI)),
1641  createTColumnType("LITERAL_SUFFIX", new TTypeInfo(strTTI)),
1642  createTColumnType("CREATE_PARAMS", new TTypeInfo(strTTI)),
1643  createTColumnType("NULLABLE", new TTypeInfo(smallIntTTI)),
1644  createTColumnType("CASE_SENSITIVE", new TTypeInfo(boolTTI)),
1645  createTColumnType("SEARCHABLE", new TTypeInfo(smallIntTTI)),
1646  createTColumnType("UNSIGNED_ATTRIBUTE", new TTypeInfo(boolTTI)),
1647  createTColumnType("FIXED_PREC_SCALE", new TTypeInfo(boolTTI)),
1648  createTColumnType("AUTO_INCREMENT", new TTypeInfo(boolTTI)),
1649  createTColumnType("LOCAL_TYPE_NAME", new TTypeInfo(strTTI)),
1650  createTColumnType("MINIMUM_SCALE", new TTypeInfo(smallIntTTI)),
1651  createTColumnType("MAXIMUM_SCALE", new TTypeInfo(smallIntTTI)),
1652  createTColumnType("SQL_DATA_TYPE", new TTypeInfo(intTTI)),
1653  createTColumnType("SQL_DATETIME_SUB", new TTypeInfo(intTTI)),
1654  createTColumnType("NUM_PREC_RADIX", new TTypeInfo(intTTI))};
1655 
1656  Map<String, HeavyAIData> dataMap = new HashMap(columns.length);
1657 
1658  // create component to contain the meta data for the rows
1659  // and create a container to store the data and the nul indicators
1660  List<TColumnType> rowDesc = new ArrayList(columns.length);
1661  for (TColumnType col : columns) {
1662  rowDesc.add(col);
1663  dataMap.put(col.col_name, new HeavyAIData(col.col_type.type));
1664  }
1665  // TODO this is currently a work in progress need to add actual details here
1666  // Now add some actual details for table name
1667  dataMap.get("TYPE_NAME").setNull(true); // String => Type name
1668  dataMap.get("DATA_TYPE").setNull(true); // int => SQL data type from java.sql.Types
1669  dataMap.get("PRECISION").setNull(true); // int => maximum precision
1670  dataMap.get("LITERAL_PREFIX").setNull(true); // .setNull(true);// String => prefix
1671  // used to quote a literal (may be null)
1672  dataMap.get("LITERAL_SUFFIX").setNull(true); // .setNull(true);// String => suffix
1673  // used to quote a literal (may be null)
1674  dataMap.get("CREATE_PARAMS")
1675  .setNull(
1676  true); // String => parameters used in creating the type (may be null)
1677  dataMap.get("NULLABLE").setNull(true); // short => can you use NULL for this type.
1678  // typeNoNulls - does not allow NULL values
1679  // typeNullable - allows NULL values
1680  // typeNullableUnknown - nullability unknown
1681  dataMap.get("CASE_SENSITIVE").setNull(true); // boolean=> is it case sensitive.
1682  dataMap.get("SEARCHABLE")
1683  .setNull(true); // short => can you use "WHERE" based on this type:
1684  // typePredNone - No support
1685  // typePredChar - Only supported with WHERE .. LIKE
1686  // typePredBasic - Supported except for WHERE .. LIKE
1687  // typeSearchable - Supported for all WHERE ..
1688  dataMap.get("UNSIGNED_ATTRIBUTE").setNull(true); // boolean => is it unsigned.
1689  dataMap.get("FIXED_PREC_SCALE").setNull(true); // boolean => can it be a money value.
1690  dataMap.get("AUTO_INCREMENT")
1691  .setNull(false); // boolean => can it be used for an auto-increment value.
1692  dataMap.get("LOCAL_TYPE_NAME")
1693  .setNull(true); // String => localized version of type name (may be null)
1694  dataMap.get("MINIMUM_SCALE").setNull(true); // short => minimum scale supported
1695  dataMap.get("MAXIMUM_SCALE").setNull(true); // short => maximum scale supported
1696  dataMap.get("SQL_DATA_TYPE").setNull(true); // int => unused
1697  dataMap.get("SQL_DATETIME_SUB").setNull(true); // int => unused
1698  dataMap.get("NUM_PREC_RADIX").setNull(true); //
1699 
1700  List<TColumn> columnsList = new ArrayList(columns.length);
1701 
1702  for (TColumnType col : columns) {
1703  TColumn schemaCol = dataMap.get(col.col_name).getTColumn();
1704  // logger.info("Tcolumn is "+ schemaCol.toString());
1705  columnsList.add(schemaCol);
1706  }
1707 
1708  // create a rowset for the result
1709  TRowSet rowSet = new TRowSet(rowDesc, null, columnsList, true);
1710 
1711  TQueryResult result = new TQueryResult(
1712  rowSet, 0, 0, null, null, true, ai.heavy.thrift.server.TQueryType.UNKNOWN);
1713 
1714  HeavyAIResultSet cols = new HeavyAIResultSet(result, "getTypeInfo");
1715  return cols;
1716  }
TColumnType createTColumnType(String colName, TTypeInfo colType)

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getUDTs ( String  catalog,
String  schemaPattern,
String  typeNamePattern,
int[]  types 
) throws SQLException
inline

Definition at line 1802 of file HeavyAIDatabaseMetaData.java.

1804  {
1805  HEAVYDBLOGGER.debug("Entered");
1806  throw new UnsupportedOperationException("Not supported yet,"
1807  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1808  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1809  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1810  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getURL ( ) throws SQLException
inline

Definition at line 83 of file HeavyAIDatabaseMetaData.java.

83  {
84  HEAVYDBLOGGER.debug("Entered");
85  return con.url;
86  }
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.getUserName ( ) throws SQLException
inline

Definition at line 89 of file HeavyAIDatabaseMetaData.java.

References ai.heavy.jdbc.Options.user.

89  {
90  HEAVYDBLOGGER.debug("Entered");
91  return (String) con.cP.get(Options.user);
92  }
ResultSet ai.heavy.jdbc.HeavyAIDatabaseMetaData.getVersionColumns ( String  catalog,
String  schema,
String  table 
) throws SQLException
inline

Definition at line 1459 of file HeavyAIDatabaseMetaData.java.

1460  {
1461  HEAVYDBLOGGER.debug("Entered");
1462  throw new UnsupportedOperationException("Not supported yet,"
1463  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1464  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1465  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1466  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.insertsAreDetected ( int  type) throws SQLException
inline

Definition at line 1790 of file HeavyAIDatabaseMetaData.java.

1790  {
1791  HEAVYDBLOGGER.debug("Entered");
1792  return false;
1793  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.isCatalogAtStart ( ) throws SQLException
inline

Definition at line 450 of file HeavyAIDatabaseMetaData.java.

450  {
451  HEAVYDBLOGGER.debug("Entered");
452  return true;
453  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.isReadOnly ( ) throws SQLException
inline

Definition at line 95 of file HeavyAIDatabaseMetaData.java.

95  {
96  HEAVYDBLOGGER.debug("Entered");
97  return true;
98  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.isWrapperFor ( Class<?>  iface) throws SQLException
inline

Definition at line 2011 of file HeavyAIDatabaseMetaData.java.

2011  {
2012  HEAVYDBLOGGER.debug("Entered");
2013  return false;
2014  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.locatorsUpdateCopy ( ) throws SQLException
inline

Definition at line 1919 of file HeavyAIDatabaseMetaData.java.

1919  {
1920  HEAVYDBLOGGER.debug("Entered");
1921  return false;
1922  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.nullPlusNonNullIsNull ( ) throws SQLException
inline

Definition at line 288 of file HeavyAIDatabaseMetaData.java.

288  {
289  HEAVYDBLOGGER.debug("Entered");
290  return true;
291  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.nullsAreSortedAtEnd ( ) throws SQLException
inline

Definition at line 119 of file HeavyAIDatabaseMetaData.java.

119  {
120  HEAVYDBLOGGER.debug("Entered");
121  return true;
122  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.nullsAreSortedAtStart ( ) throws SQLException
inline

Definition at line 113 of file HeavyAIDatabaseMetaData.java.

113  {
114  HEAVYDBLOGGER.debug("Entered");
115  return false;
116  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.nullsAreSortedHigh ( ) throws SQLException
inline

Definition at line 101 of file HeavyAIDatabaseMetaData.java.

101  {
102  HEAVYDBLOGGER.debug("Entered");
103  return true;
104  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.nullsAreSortedLow ( ) throws SQLException
inline

Definition at line 107 of file HeavyAIDatabaseMetaData.java.

107  {
108  HEAVYDBLOGGER.debug("Entered");
109  return false;
110  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.othersDeletesAreVisible ( int  type) throws SQLException
inline

Definition at line 1766 of file HeavyAIDatabaseMetaData.java.

1766  {
1767  HEAVYDBLOGGER.debug("Entered");
1768  return false;
1769  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.othersInsertsAreVisible ( int  type) throws SQLException
inline

Definition at line 1772 of file HeavyAIDatabaseMetaData.java.

1772  {
1773  HEAVYDBLOGGER.debug("Entered");
1774  return false;
1775  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.othersUpdatesAreVisible ( int  type) throws SQLException
inline

Definition at line 1760 of file HeavyAIDatabaseMetaData.java.

1760  {
1761  HEAVYDBLOGGER.debug("Entered");
1762  return false;
1763  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.ownDeletesAreVisible ( int  type) throws SQLException
inline

Definition at line 1748 of file HeavyAIDatabaseMetaData.java.

1748  {
1749  HEAVYDBLOGGER.debug("Entered");
1750  return false;
1751  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.ownInsertsAreVisible ( int  type) throws SQLException
inline

Definition at line 1754 of file HeavyAIDatabaseMetaData.java.

1754  {
1755  HEAVYDBLOGGER.debug("Entered");
1756  return false;
1757  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.ownUpdatesAreVisible ( int  type) throws SQLException
inline

Definition at line 1742 of file HeavyAIDatabaseMetaData.java.

1742  {
1743  HEAVYDBLOGGER.debug("Entered");
1744  return false;
1745  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesLowerCaseIdentifiers ( ) throws SQLException
inline

Definition at line 184 of file HeavyAIDatabaseMetaData.java.

184  {
185  HEAVYDBLOGGER.debug("Entered");
186  return false;
187  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesLowerCaseQuotedIdentifiers ( ) throws SQLException
inline

Definition at line 208 of file HeavyAIDatabaseMetaData.java.

208  {
209  HEAVYDBLOGGER.debug("Entered");
210  return false;
211  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesMixedCaseIdentifiers ( ) throws SQLException
inline

Definition at line 190 of file HeavyAIDatabaseMetaData.java.

190  {
191  HEAVYDBLOGGER.debug("Entered");
192  return true;
193  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesMixedCaseQuotedIdentifiers ( ) throws SQLException
inline

Definition at line 214 of file HeavyAIDatabaseMetaData.java.

214  {
215  HEAVYDBLOGGER.debug("Entered");
216  return false;
217  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesUpperCaseIdentifiers ( ) throws SQLException
inline

Definition at line 178 of file HeavyAIDatabaseMetaData.java.

178  {
179  HEAVYDBLOGGER.debug("Entered");
180  return false;
181  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.storesUpperCaseQuotedIdentifiers ( ) throws SQLException
inline

Definition at line 202 of file HeavyAIDatabaseMetaData.java.

202  {
203  HEAVYDBLOGGER.debug("Entered");
204  return false;
205  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsAlterTableWithAddColumn ( ) throws SQLException
inline

Definition at line 270 of file HeavyAIDatabaseMetaData.java.

270  {
271  HEAVYDBLOGGER.debug("Entered");
272  return true;
273  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsAlterTableWithDropColumn ( ) throws SQLException
inline

Definition at line 276 of file HeavyAIDatabaseMetaData.java.

276  {
277  HEAVYDBLOGGER.debug("Entered");
278  return true;
279  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsANSI92EntryLevelSQL ( ) throws SQLException
inline

Definition at line 390 of file HeavyAIDatabaseMetaData.java.

390  {
391  HEAVYDBLOGGER.debug("Entered");
392  return true;
393  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsANSI92FullSQL ( ) throws SQLException
inline

Definition at line 402 of file HeavyAIDatabaseMetaData.java.

402  {
403  HEAVYDBLOGGER.debug("Entered");
404  return false;
405  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsANSI92IntermediateSQL ( ) throws SQLException
inline

Definition at line 396 of file HeavyAIDatabaseMetaData.java.

396  {
397  HEAVYDBLOGGER.debug("Entered");
398  return false;
399  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsBatchUpdates ( ) throws SQLException
inline

Definition at line 1796 of file HeavyAIDatabaseMetaData.java.

1796  {
1797  HEAVYDBLOGGER.debug("Entered");
1798  return true;
1799  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCatalogsInDataManipulation ( ) throws SQLException
inline

Definition at line 492 of file HeavyAIDatabaseMetaData.java.

492  {
493  HEAVYDBLOGGER.debug("Entered");
494  return false;
495  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCatalogsInIndexDefinitions ( ) throws SQLException
inline

Definition at line 510 of file HeavyAIDatabaseMetaData.java.

510  {
511  HEAVYDBLOGGER.debug("Entered");
512  return false;
513  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCatalogsInPrivilegeDefinitions ( ) throws SQLException
inline

Definition at line 516 of file HeavyAIDatabaseMetaData.java.

516  {
517  HEAVYDBLOGGER.debug("Entered");
518  return false;
519  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCatalogsInProcedureCalls ( ) throws SQLException
inline

Definition at line 498 of file HeavyAIDatabaseMetaData.java.

498  {
499  HEAVYDBLOGGER.debug("Entered");
500  return false;
501  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCatalogsInTableDefinitions ( ) throws SQLException
inline

Definition at line 504 of file HeavyAIDatabaseMetaData.java.

504  {
505  HEAVYDBLOGGER.debug("Entered");
506  return false;
507  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsColumnAliasing ( ) throws SQLException
inline

Definition at line 282 of file HeavyAIDatabaseMetaData.java.

282  {
283  HEAVYDBLOGGER.debug("Entered");
284  return true;
285  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsConvert ( ) throws SQLException
inline

Definition at line 294 of file HeavyAIDatabaseMetaData.java.

294  {
295  HEAVYDBLOGGER.debug("Entered");
296  return false;
297  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsConvert ( int  fromType,
int  toType 
) throws SQLException
inline

Definition at line 300 of file HeavyAIDatabaseMetaData.java.

300  {
301  HEAVYDBLOGGER.debug("Entered");
302  return false;
303  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCoreSQLGrammar ( ) throws SQLException
inline

Definition at line 378 of file HeavyAIDatabaseMetaData.java.

378  {
379  HEAVYDBLOGGER.debug("Entered");
380  return true;
381  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsCorrelatedSubqueries ( ) throws SQLException
inline

Definition at line 570 of file HeavyAIDatabaseMetaData.java.

570  {
571  HEAVYDBLOGGER.debug("Entered");
572  return false;
573  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions ( ) throws SQLException
inline

Definition at line 756 of file HeavyAIDatabaseMetaData.java.

757  {
758  HEAVYDBLOGGER.debug("Entered");
759  return false;
760  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsDataManipulationTransactionsOnly ( ) throws SQLException
inline

Definition at line 763 of file HeavyAIDatabaseMetaData.java.

763  {
764  HEAVYDBLOGGER.debug("Entered");
765  return false;
766  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsDifferentTableCorrelationNames ( ) throws SQLException
inline

Definition at line 312 of file HeavyAIDatabaseMetaData.java.

312  {
313  HEAVYDBLOGGER.debug("Entered");
314  return true;
315  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsExpressionsInOrderBy ( ) throws SQLException
inline

Definition at line 318 of file HeavyAIDatabaseMetaData.java.

318  {
319  HEAVYDBLOGGER.debug("Entered");
320  return true;
321  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsExtendedSQLGrammar ( ) throws SQLException
inline

Definition at line 384 of file HeavyAIDatabaseMetaData.java.

384  {
385  HEAVYDBLOGGER.debug("Entered");
386  return true;
387  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsFullOuterJoins ( ) throws SQLException
inline

Definition at line 420 of file HeavyAIDatabaseMetaData.java.

420  {
421  HEAVYDBLOGGER.debug("Entered");
422  return false;
423  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsGetGeneratedKeys ( ) throws SQLException
inline

Definition at line 1837 of file HeavyAIDatabaseMetaData.java.

1837  {
1838  HEAVYDBLOGGER.debug("Entered");
1839  return false;
1840  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsGroupBy ( ) throws SQLException
inline

Definition at line 330 of file HeavyAIDatabaseMetaData.java.

330  {
331  HEAVYDBLOGGER.debug("Entered");
332  return true;
333  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsGroupByBeyondSelect ( ) throws SQLException
inline

Definition at line 342 of file HeavyAIDatabaseMetaData.java.

342  {
343  HEAVYDBLOGGER.debug("Entered");
344  return true;
345  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsGroupByUnrelated ( ) throws SQLException
inline

Definition at line 336 of file HeavyAIDatabaseMetaData.java.

336  {
337  HEAVYDBLOGGER.debug("Entered");
338  return true;
339  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsIntegrityEnhancementFacility ( ) throws SQLException
inline

Definition at line 408 of file HeavyAIDatabaseMetaData.java.

408  {
409  HEAVYDBLOGGER.debug("Entered");
410  return false;
411  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsLikeEscapeClause ( ) throws SQLException
inline

Definition at line 348 of file HeavyAIDatabaseMetaData.java.

348  {
349  HEAVYDBLOGGER.debug("Entered");
350  return false;
351  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsLimitedOuterJoins ( ) throws SQLException
inline

Definition at line 426 of file HeavyAIDatabaseMetaData.java.

426  {
427  HEAVYDBLOGGER.debug("Entered");
428  return true;
429  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMinimumSQLGrammar ( ) throws SQLException
inline

Definition at line 372 of file HeavyAIDatabaseMetaData.java.

372  {
373  HEAVYDBLOGGER.debug("Entered");
374  return true;
375  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMixedCaseIdentifiers ( ) throws SQLException
inline

Definition at line 172 of file HeavyAIDatabaseMetaData.java.

172  {
173  HEAVYDBLOGGER.debug("Entered");
174  return true;
175  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMixedCaseQuotedIdentifiers ( ) throws SQLException
inline

Definition at line 196 of file HeavyAIDatabaseMetaData.java.

196  {
197  HEAVYDBLOGGER.debug("Entered");
198  return true;
199  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMultipleOpenResults ( ) throws SQLException
inline

Definition at line 1831 of file HeavyAIDatabaseMetaData.java.

1831  {
1832  HEAVYDBLOGGER.debug("Entered");
1833  return false;
1834  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMultipleResultSets ( ) throws SQLException
inline

Definition at line 354 of file HeavyAIDatabaseMetaData.java.

354  {
355  HEAVYDBLOGGER.debug("Entered");
356  return false;
357  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsMultipleTransactions ( ) throws SQLException
inline

Definition at line 360 of file HeavyAIDatabaseMetaData.java.

360  {
361  HEAVYDBLOGGER.debug("Entered");
362  return false;
363  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsNamedParameters ( ) throws SQLException
inline

Definition at line 1825 of file HeavyAIDatabaseMetaData.java.

1825  {
1826  HEAVYDBLOGGER.debug("Entered");
1827  return false;
1828  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsNonNullableColumns ( ) throws SQLException
inline

Definition at line 366 of file HeavyAIDatabaseMetaData.java.

366  {
367  HEAVYDBLOGGER.debug("Entered");
368  return true;
369  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOpenCursorsAcrossCommit ( ) throws SQLException
inline

Definition at line 588 of file HeavyAIDatabaseMetaData.java.

588  {
589  HEAVYDBLOGGER.debug("Entered");
590  return false;
591  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOpenCursorsAcrossRollback ( ) throws SQLException
inline

Definition at line 594 of file HeavyAIDatabaseMetaData.java.

594  {
595  HEAVYDBLOGGER.debug("Entered");
596  return false;
597  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOpenStatementsAcrossCommit ( ) throws SQLException
inline

Definition at line 600 of file HeavyAIDatabaseMetaData.java.

600  {
601  HEAVYDBLOGGER.debug("Entered");
602  return false;
603  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOpenStatementsAcrossRollback ( ) throws SQLException
inline

Definition at line 606 of file HeavyAIDatabaseMetaData.java.

606  {
607  HEAVYDBLOGGER.debug("Entered");
608  return false;
609  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOrderByUnrelated ( ) throws SQLException
inline

Definition at line 324 of file HeavyAIDatabaseMetaData.java.

324  {
325  HEAVYDBLOGGER.debug("Entered");
326  return true;
327  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsOuterJoins ( ) throws SQLException
inline

Definition at line 414 of file HeavyAIDatabaseMetaData.java.

414  {
415  HEAVYDBLOGGER.debug("Entered");
416  return false;
417  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsPositionedDelete ( ) throws SQLException
inline

Definition at line 522 of file HeavyAIDatabaseMetaData.java.

522  {
523  HEAVYDBLOGGER.debug("Entered");
524  return false;
525  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsPositionedUpdate ( ) throws SQLException
inline

Definition at line 528 of file HeavyAIDatabaseMetaData.java.

528  {
529  HEAVYDBLOGGER.debug("Entered");
530  return false;
531  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsResultSetConcurrency ( int  type,
int  concurrency 
) throws SQLException
inline

Definition at line 1735 of file HeavyAIDatabaseMetaData.java.

1736  {
1737  HEAVYDBLOGGER.debug("Entered");
1738  return false;
1739  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsResultSetHoldability ( int  holdability) throws SQLException
inline

Definition at line 1877 of file HeavyAIDatabaseMetaData.java.

1877  {
1878  HEAVYDBLOGGER.debug("Entered");
1879  return false;
1880  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsResultSetType ( int  type) throws SQLException
inline

Definition at line 1729 of file HeavyAIDatabaseMetaData.java.

1729  {
1730  HEAVYDBLOGGER.debug("Entered");
1731  return false;
1732  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSavepoints ( ) throws SQLException
inline

Definition at line 1819 of file HeavyAIDatabaseMetaData.java.

1819  {
1820  HEAVYDBLOGGER.debug("Entered");
1821  return false;
1822  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSchemasInDataManipulation ( ) throws SQLException
inline

Definition at line 462 of file HeavyAIDatabaseMetaData.java.

462  {
463  HEAVYDBLOGGER.debug("Entered");
464  return false;
465  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSchemasInIndexDefinitions ( ) throws SQLException
inline

Definition at line 480 of file HeavyAIDatabaseMetaData.java.

480  {
481  HEAVYDBLOGGER.debug("Entered");
482  return false;
483  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSchemasInPrivilegeDefinitions ( ) throws SQLException
inline

Definition at line 486 of file HeavyAIDatabaseMetaData.java.

486  {
487  HEAVYDBLOGGER.debug("Entered");
488  return false;
489  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSchemasInProcedureCalls ( ) throws SQLException
inline

Definition at line 468 of file HeavyAIDatabaseMetaData.java.

468  {
469  HEAVYDBLOGGER.debug("Entered");
470  return false;
471  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSchemasInTableDefinitions ( ) throws SQLException
inline

Definition at line 474 of file HeavyAIDatabaseMetaData.java.

474  {
475  HEAVYDBLOGGER.debug("Entered");
476  return false;
477  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSelectForUpdate ( ) throws SQLException
inline

Definition at line 534 of file HeavyAIDatabaseMetaData.java.

534  {
535  HEAVYDBLOGGER.debug("Entered");
536  return false;
537  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsStatementPooling ( ) throws SQLException
inline

Definition at line 1925 of file HeavyAIDatabaseMetaData.java.

1925  {
1926  HEAVYDBLOGGER.debug("Entered");
1927  return false;
1928  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsStoredFunctionsUsingCallSyntax ( ) throws SQLException
inline

Definition at line 1943 of file HeavyAIDatabaseMetaData.java.

1943  {
1944  HEAVYDBLOGGER.debug("Entered");
1945  return false;
1946  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsStoredProcedures ( ) throws SQLException
inline

Definition at line 540 of file HeavyAIDatabaseMetaData.java.

540  {
541  HEAVYDBLOGGER.debug("Entered");
542  return false;
543  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSubqueriesInComparisons ( ) throws SQLException
inline

Definition at line 546 of file HeavyAIDatabaseMetaData.java.

546  {
547  HEAVYDBLOGGER.debug("Entered");
548  return true;
549  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSubqueriesInExists ( ) throws SQLException
inline

Definition at line 552 of file HeavyAIDatabaseMetaData.java.

552  {
553  HEAVYDBLOGGER.debug("Entered");
554  return true;
555  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSubqueriesInIns ( ) throws SQLException
inline

Definition at line 558 of file HeavyAIDatabaseMetaData.java.

558  {
559  HEAVYDBLOGGER.debug("Entered");
560  return true;
561  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsSubqueriesInQuantifieds ( ) throws SQLException
inline

Definition at line 564 of file HeavyAIDatabaseMetaData.java.

564  {
565  HEAVYDBLOGGER.debug("Entered");
566  return true;
567  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsTableCorrelationNames ( ) throws SQLException
inline

Definition at line 306 of file HeavyAIDatabaseMetaData.java.

306  {
307  HEAVYDBLOGGER.debug("Entered");
308  return true;
309  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsTransactionIsolationLevel ( int  level) throws SQLException
inline

Definition at line 750 of file HeavyAIDatabaseMetaData.java.

750  {
751  HEAVYDBLOGGER.debug("Entered");
752  return false;
753  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsTransactions ( ) throws SQLException
inline

Definition at line 744 of file HeavyAIDatabaseMetaData.java.

744  {
745  HEAVYDBLOGGER.debug("Entered");
746  return false;
747  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsUnion ( ) throws SQLException
inline

Definition at line 576 of file HeavyAIDatabaseMetaData.java.

576  {
577  HEAVYDBLOGGER.debug("Entered");
578  return false;
579  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.supportsUnionAll ( ) throws SQLException
inline

Definition at line 582 of file HeavyAIDatabaseMetaData.java.

582  {
583  HEAVYDBLOGGER.debug("Entered");
584  return false;
585  }
void ai.heavy.jdbc.HeavyAIDatabaseMetaData.tablePermProcess ( List< String >  tables,
Map< String, HeavyAIData dataMap,
String  tableNamePattern 
) throws TException
inlineprivate

Definition at line 1333 of file HeavyAIDatabaseMetaData.java.

References field(), TableDBObjectType, and run_benchmark_import.tables.

Referenced by ai.heavy.jdbc.HeavyAIDatabaseMetaData.getTablePrivileges().

1335  {
1336  for (String table : tables) {
1337  if (tableNamePattern != null && !table.matches(tableNamePattern)) {
1338  continue;
1339  }
1340  List<TDBObject> db_objects = con.client.get_db_object_privs(
1341  con.session, table, TDBObjectType.TableDBObjectType);
1342 
1343  // check if the table matches the input pattern
1344  for (TDBObject db_object : db_objects) {
1345  // If the user is a super user then the objectName will be super
1346  // and needs to be changed to the table name.
1347  if (db_object.objectName.equalsIgnoreCase("super")) {
1348  db_object.objectName = table;
1349  }
1350  // A bunch of db objects come back. Any with a different name throw away
1351  if (!db_object.objectName.equalsIgnoreCase(table)) {
1352  continue;
1353  }
1354 
1355  // Create set of table permissions based ont he db_object. This seems to
1356  // be the only way - though being hardwired on the number of privs is not great.
1357  TTablePermissions tt = new TTablePermissions(db_object.privs.get(0),
1358  db_object.privs.get(1),
1359  db_object.privs.get(2),
1360  db_object.privs.get(3),
1361  db_object.privs.get(4),
1362  db_object.privs.get(5),
1363  db_object.privs.get(6),
1364  db_object.privs.get(7));
1365 
1366  int ordinal = 1;
1367  for (TTablePermissions._Fields field = tt.fieldForId(ordinal); field != null;
1368  field = tt.fieldForId(++ordinal)) {
1369  Boolean x = (Boolean) tt.getFieldValue(field);
1370  if (x == false) {
1371  continue;
1372  }
1373  // standardise the fieldName upper case and remove trailing '_'. create_ =>
1374  // CREATE
1375  dataMap.get("PRIVILEGE")
1376  .add(field.getFieldName().toUpperCase().replace("_", ""));
1377  dataMap.get("TABLE_CAT").setNull(true);
1378  dataMap.get("TABLE_SCHEM").setNull(true);
1379  dataMap.get("TABLE_NAME").add(db_object.objectName);
1380  dataMap.get("GRANTOR").setNull(true);
1381  dataMap.get("GRANTEE").add(db_object.grantee);
1382  dataMap.get("IS_GRANTABLE").add("NO");
1383  }
1384  }
1385  }
1386  }
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:31

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

public<T> T ai.heavy.jdbc.HeavyAIDatabaseMetaData.unwrap ( Class< T >  iface) throws SQLException
inlinepackage

Definition at line 2005 of file HeavyAIDatabaseMetaData.java.

2005  {
2006  HEAVYDBLOGGER.debug("Entered");
2007  return null;
2008  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.updatesAreDetected ( int  type) throws SQLException
inline

Definition at line 1778 of file HeavyAIDatabaseMetaData.java.

1778  {
1779  HEAVYDBLOGGER.debug("Entered");
1780  return false;
1781  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.usesLocalFilePerTable ( ) throws SQLException
inline

Definition at line 166 of file HeavyAIDatabaseMetaData.java.

166  {
167  HEAVYDBLOGGER.debug("Entered");
168  return false;
169  }
boolean ai.heavy.jdbc.HeavyAIDatabaseMetaData.usesLocalFiles ( ) throws SQLException
inline

Definition at line 160 of file HeavyAIDatabaseMetaData.java.

160  {
161  HEAVYDBLOGGER.debug("Entered");
162  return false;
163  }

Member Data Documentation

HeavyAIConnection ai.heavy.jdbc.HeavyAIDatabaseMetaData.con = null
package
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseMajorVersion = 0
package
int ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseMinorVersion = 0
package
String ai.heavy.jdbc.HeavyAIDatabaseMetaData.databaseVersion = null
package
final Logger ai.heavy.jdbc.HeavyAIDatabaseMetaData.HEAVYDBLOGGER
staticpackage
Initial value:
=
LoggerFactory.getLogger(HeavyAIDatabaseMetaData.class)

Definition at line 44 of file HeavyAIDatabaseMetaData.java.


The documentation for this class was generated from the following file: