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

Public Member Functions

ResultSet executeQuery () throws SQLException
 
int executeUpdate () throws SQLException
 
void setNull (int parameterIndex, int sqlType) throws SQLException
 
void setBoolean (int parameterIndex, boolean x) throws SQLException
 
void setByte (int parameterIndex, byte x) throws SQLException
 
void setShort (int parameterIndex, short x) throws SQLException
 
void setInt (int parameterIndex, int x) throws SQLException
 
void setLong (int parameterIndex, long x) throws SQLException
 
void setFloat (int parameterIndex, float x) throws SQLException
 
void setDouble (int parameterIndex, double x) throws SQLException
 
void setBigDecimal (int parameterIndex, BigDecimal x) throws SQLException
 
void setString (int parameterIndex, String x) throws SQLException
 
void setBytes (int parameterIndex, byte[] x) throws SQLException
 
void setDate (int parameterIndex, Date x) throws SQLException
 
void setTime (int parameterIndex, Time x) throws SQLException
 
void setTimestamp (int parameterIndex, Timestamp x) throws SQLException
 
void setAsciiStream (int parameterIndex, InputStream x, int length) throws SQLException
 
void setUnicodeStream (int parameterIndex, InputStream x, int length) throws SQLException
 
void setBinaryStream (int parameterIndex, InputStream x, int length) throws SQLException
 
void clearParameters () throws SQLException
 
void setObject (int parameterIndex, Object x, int targetSqlType) throws SQLException
 
void setObject (int parameterIndex, Object x) throws SQLException
 
boolean execute () throws SQLException
 
void addBatch () throws SQLException
 
void setCharacterStream (int parameterIndex, Reader reader, int length) throws SQLException
 
void setRef (int parameterIndex, Ref x) throws SQLException
 
void setBlob (int parameterIndex, Blob x) throws SQLException
 
void setClob (int parameterIndex, Clob x) throws SQLException
 
void setArray (int parameterIndex, Array x) throws SQLException
 
ResultSetMetaData getMetaData () throws SQLException
 
void setDate (int parameterIndex, Date x, Calendar cal) throws SQLException
 
void setTime (int parameterIndex, Time x, Calendar cal) throws SQLException
 
void setTimestamp (int parameterIndex, Timestamp x, Calendar cal) throws SQLException
 
void setNull (int parameterIndex, int sqlType, String typeName) throws SQLException
 
void setURL (int parameterIndex, URL x) throws SQLException
 
ParameterMetaData getParameterMetaData () throws SQLException
 
void setRowId (int parameterIndex, RowId x) throws SQLException
 
void setNString (int parameterIndex, String value) throws SQLException
 
void setNCharacterStream (int parameterIndex, Reader value, long length) throws SQLException
 
void setNClob (int parameterIndex, NClob value) throws SQLException
 
void setClob (int parameterIndex, Reader reader, long length) throws SQLException
 
void setBlob (int parameterIndex, InputStream inputStream, long length) throws SQLException
 
void setNClob (int parameterIndex, Reader reader, long length) throws SQLException
 
void setSQLXML (int parameterIndex, SQLXML xmlObject) throws SQLException
 
void setObject (int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException
 
void setAsciiStream (int parameterIndex, InputStream x, long length) throws SQLException
 
void setBinaryStream (int parameterIndex, InputStream x, long length) throws SQLException
 
void setCharacterStream (int parameterIndex, Reader reader, long length) throws SQLException
 
void setAsciiStream (int parameterIndex, InputStream x) throws SQLException
 
void setBinaryStream (int parameterIndex, InputStream x) throws SQLException
 
void setCharacterStream (int parameterIndex, Reader reader) throws SQLException
 
void setNCharacterStream (int parameterIndex, Reader value) throws SQLException
 
void setClob (int parameterIndex, Reader reader) throws SQLException
 
void setBlob (int parameterIndex, InputStream inputStream) throws SQLException
 
void setNClob (int parameterIndex, Reader reader) throws SQLException
 
ResultSet executeQuery (String sql) throws SQLException
 
int executeUpdate (String sql) throws SQLException
 
void close () throws SQLException
 
int getMaxFieldSize () throws SQLException
 
void setMaxFieldSize (int max) throws SQLException
 
int getMaxRows () throws SQLException
 
void setMaxRows (int max) throws SQLException
 
void setEscapeProcessing (boolean enable) throws SQLException
 
int getQueryTimeout () throws SQLException
 
void setQueryTimeout (int seconds) throws SQLException
 
void cancel () throws SQLException
 
SQLWarning getWarnings () throws SQLException
 
void clearWarnings () throws SQLException
 
void setCursorName (String name) throws SQLException
 
boolean execute (String sql) throws SQLException
 
ResultSet getResultSet () throws SQLException
 
int getUpdateCount () throws SQLException
 
boolean getMoreResults () throws SQLException
 
void setFetchDirection (int direction) throws SQLException
 
int getFetchDirection () throws SQLException
 
void setFetchSize (int rows) throws SQLException
 
int getFetchSize () throws SQLException
 
int getResultSetConcurrency () throws SQLException
 
int getResultSetType () throws SQLException
 
void addBatch (String sql) throws SQLException
 
void clearBatch () throws SQLException
 
int[] executeBatch () throws SQLException
 
Connection getConnection () throws SQLException
 
boolean getMoreResults (int current) throws SQLException
 
ResultSet getGeneratedKeys () throws SQLException
 
int executeUpdate (String sql, int autoGeneratedKeys) throws SQLException
 
int executeUpdate (String sql, int[] columnIndexes) throws SQLException
 
int executeUpdate (String sql, String[] columnNames) throws SQLException
 
boolean execute (String sql, int autoGeneratedKeys) throws SQLException
 
boolean execute (String sql, int[] columnIndexes) throws SQLException
 
boolean execute (String sql, String[] columnNames) throws SQLException
 
int getResultSetHoldability () throws SQLException
 
boolean isClosed () throws SQLException
 
void setPoolable (boolean poolable) throws SQLException
 
boolean isPoolable () throws SQLException
 
void closeOnCompletion () throws SQLException
 
boolean isCloseOnCompletion () throws SQLException
 
boolean isWrapperFor (Class<?> iface) throws SQLException
 

Public Attributes

SQLWarning rootWarning = null
 

Package Functions

 HeavyAIPreparedStatement (String sql, String session, HeavyAIConnection connection)
 
public< T > T unwrap (Class< T > iface) throws SQLException
 

Static Package Attributes

static final Logger HEAVYDBLOGGER
 

Private Member Functions

String getQuery ()
 
boolean isSelect ()
 
void checkClosed () throws SQLException
 

Private Attributes

String currentSQL
 
String insertTableName
 
int parmCount = 0
 
String brokenSQL []
 
String parmRep []
 
boolean parmIsNull []
 
String listOfFields []
 
int repCount
 
String session
 
Heavy.Client client
 
HeavyAIStatement stmt = null
 
boolean isInsert = false
 
boolean isNewBatch = true
 
boolean[] parmIsString = null
 
List< TStringRow > rows = null
 
boolean isClosed = false
 

Static Private Attributes

static final Pattern REGEX_PATTERN = Pattern.compile("(?i)\\s+INTO\\s+(\\w+)")
 
static final Pattern REGEX_LOF_PATTERN
 
static final Pattern REGEX_IS_SELECT_PATTERN
 

Detailed Description

Definition at line 58 of file HeavyAIPreparedStatement.java.

Constructor & Destructor Documentation

ai.heavy.jdbc.HeavyAIPreparedStatement.HeavyAIPreparedStatement ( String  sql,
String  session,
HeavyAIConnection  connection 
)
inlinepackage

Definition at line 88 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.brokenSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.currentSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.insertTableName, ai.heavy.jdbc.HeavyAIPreparedStatement.isInsert, ai.heavy.jdbc.HeavyAIPreparedStatement.parmCount, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsString, ai.heavy.jdbc.HeavyAIPreparedStatement.parmRep, ai.heavy.jdbc.HeavyAIPreparedStatement.repCount, and ai.heavy.jdbc.HeavyAIPreparedStatement.session.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.getMetaData().

88  {
89  HEAVYDBLOGGER.debug("Entered");
90  currentSQL = sql;
91  this.client = connection.client;
92  this.session = session;
93  this.stmt = new HeavyAIStatement(session, connection);
94  HEAVYDBLOGGER.debug("Prepared statement is " + currentSQL);
95  // TODO in real life this needs to check if the ? is inside quotes before we
96  // assume it
97  // a parameter
98  brokenSQL = currentSQL.split("\\?", -1);
99  parmCount = brokenSQL.length - 1;
100  parmRep = new String[parmCount];
101  parmIsNull = new boolean[parmCount];
102  parmIsString = new boolean[parmCount];
103  repCount = 0;
104  if (currentSQL.toUpperCase().contains("INSERT ")) {
105  // remove double quotes required for queries generated with " around all names
106  // like
107  // kafka connect
108  currentSQL = currentSQL.replaceAll("\"", " ");
109  HEAVYDBLOGGER.debug("Insert Prepared statement is " + currentSQL);
110  isInsert = true;
111  Matcher matcher = REGEX_PATTERN.matcher(currentSQL);
112  while (matcher.find()) {
113  insertTableName = matcher.group(1);
114  HEAVYDBLOGGER.debug("Table name for insert is '" + insertTableName + "'");
115  }
116  }
117  }

+ Here is the caller graph for this function:

Member Function Documentation

void ai.heavy.jdbc.HeavyAIPreparedStatement.addBatch ( ) throws SQLException
inline

Definition at line 364 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.currentSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.insertTableName, ai.heavy.jdbc.HeavyAIPreparedStatement.isInsert, ai.heavy.jdbc.HeavyAIPreparedStatement.isNewBatch, ai.heavy.jdbc.HeavyAIPreparedStatement.listOfFields, ai.heavy.jdbc.HeavyAIPreparedStatement.parmCount, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, ai.heavy.jdbc.HeavyAIPreparedStatement.rows, and ai.heavy.jdbc.HeavyAIPreparedStatement.session.

364  {
365  HEAVYDBLOGGER.debug("Entered");
366  if (isInsert) {
367  // take the values and use stream inserter to add them
368  if (isNewBatch) {
369  // check for columns names
370  Matcher matcher = REGEX_LOF_PATTERN.matcher(currentSQL);
371  if (matcher.find()) {
372  listOfFields = matcher.group(1).trim().split("\\s*,+\\s*,*\\s*");
373  if (listOfFields.length != parmCount) {
374  throw new SQLException("Too many or too few values");
375  } else if (Arrays.stream(listOfFields).distinct().toArray().length
376  != listOfFields.length) {
377  throw new SQLException("Duplicated column name");
378  }
379  List<String> listOfColumns = new ArrayList<String>();
380  try {
381  TTableDetails tableDetails =
382  client.get_table_details(session, insertTableName);
383  for (TColumnType column : tableDetails.row_desc) {
384  listOfColumns.add(column.col_name.toLowerCase());
385  }
386  } catch (TException ex) {
387  throw new SQLException(ex.toString());
388  }
389  for (String paramName : listOfFields) {
390  if (listOfColumns.indexOf(paramName) == -1) {
391  throw new SQLException(
392  "Column " + paramName.toLowerCase() + " does not exist");
393  }
394  }
395  } else {
396  listOfFields = new String[0];
397  }
398 
399  rows = new ArrayList(5000);
400  isNewBatch = false;
401  }
402  // add data to stream
403  TStringRow tsr = new TStringRow();
404  for (int i = 0; i < parmCount; i++) {
405  // place string in rows array
406  TStringValue tsv = new TStringValue();
407  if (parmIsNull[i]) {
408  tsv.is_null = true;
409  } else {
410  tsv.str_val = this.parmRep[i];
411  tsv.is_null = false;
412  }
413  tsr.addToCols(tsv);
414  }
415  rows.add(tsr);
416  HEAVYDBLOGGER.debug("addBatch, rows=" + rows.size());
417  } else {
418  throw new UnsupportedOperationException("addBatch only supported for insert, line:"
419  + new Throwable().getStackTrace()[0].getLineNumber());
420  }
421  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.addBatch ( String  sql) throws SQLException
inline

Definition at line 928 of file HeavyAIPreparedStatement.java.

928  {
929  HEAVYDBLOGGER.debug("Entered");
930  throw new UnsupportedOperationException("Not supported yet,"
931  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
932  + " class:" + new Throwable().getStackTrace()[0].getClassName()
933  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
934  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.cancel ( ) throws SQLException
inline

Definition at line 821 of file HeavyAIPreparedStatement.java.

821  {
822  HEAVYDBLOGGER.debug("Entered");
823  throw new UnsupportedOperationException("Not supported yet,"
824  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
825  + " class:" + new Throwable().getStackTrace()[0].getClassName()
826  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
827  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.checkClosed ( ) throws SQLException
inlineprivate

Definition at line 1114 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.isClosed().

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.executeBatch().

1114  {
1115  if (isClosed) {
1116  throw new SQLException("PreparedStatement is closed.");
1117  }
1118  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void ai.heavy.jdbc.HeavyAIPreparedStatement.clearBatch ( ) throws SQLException
inline

Definition at line 937 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.rows.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.executeBatch().

937  {
938  HEAVYDBLOGGER.debug("Entered");
939  if (rows != null) {
940  rows.clear();
941  }
942  }

+ Here is the caller graph for this function:

void ai.heavy.jdbc.HeavyAIPreparedStatement.clearParameters ( ) throws SQLException
inline

Definition at line 332 of file HeavyAIPreparedStatement.java.

332  {
333  HEAVYDBLOGGER.debug("Entered");
334  // TODO MAT we will actually need to do something here one day
335  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.clearWarnings ( ) throws SQLException
inline

Definition at line 836 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.rootWarning.

836  {
837  HEAVYDBLOGGER.debug("Entered");
838  rootWarning = null;
839  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.close ( ) throws SQLException
inline

Definition at line 753 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.isClosed(), and ai.heavy.jdbc.HeavyAIPreparedStatement.stmt.

Referenced by heavydb.connection.Connection.__del__(), heavydb.cursor.Cursor.__exit__(), and heavydb.connection.Connection.__exit__().

753  {
754  HEAVYDBLOGGER.debug("close");
755  if (stmt != null) {
756  // TODO MAT probably more needed here
757  stmt.close();
758  stmt = null;
759  }
760  isClosed = true;
761  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void ai.heavy.jdbc.HeavyAIPreparedStatement.closeOnCompletion ( ) throws SQLException
inline

Definition at line 1079 of file HeavyAIPreparedStatement.java.

1079  {
1080  HEAVYDBLOGGER.debug("Entered");
1081  throw new UnsupportedOperationException("Not supported yet,"
1082  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1083  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1084  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1085  }
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.execute ( ) throws SQLException
inline

Definition at line 357 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.getQuery().

Referenced by heavydb.cursor.Cursor.executemany().

357  {
358  HEAVYDBLOGGER.debug("Entered");
359  String tQuery = getQuery();
360  return stmt.execute(tQuery);
361  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.execute ( String  sql) throws SQLException
inline

Definition at line 851 of file HeavyAIPreparedStatement.java.

Referenced by heavydb.cursor.Cursor.executemany().

851  {
852  HEAVYDBLOGGER.debug("Entered");
853  throw new UnsupportedOperationException("Not supported yet,"
854  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
855  + " class:" + new Throwable().getStackTrace()[0].getClassName()
856  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
857  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.execute ( String  sql,
int  autoGeneratedKeys 
) throws SQLException
inline

Definition at line 1019 of file HeavyAIPreparedStatement.java.

Referenced by heavydb.cursor.Cursor.executemany().

1019  {
1020  HEAVYDBLOGGER.debug("Entered");
1021  throw new UnsupportedOperationException("Not supported yet,"
1022  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1023  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1024  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1025  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.execute ( String  sql,
int[]  columnIndexes 
) throws SQLException
inline

Definition at line 1028 of file HeavyAIPreparedStatement.java.

Referenced by heavydb.cursor.Cursor.executemany().

1028  {
1029  HEAVYDBLOGGER.debug("Entered");
1030  throw new UnsupportedOperationException("Not supported yet,"
1031  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1032  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1033  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1034  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.execute ( String  sql,
String[]  columnNames 
) throws SQLException
inline

Definition at line 1037 of file HeavyAIPreparedStatement.java.

Referenced by heavydb.cursor.Cursor.executemany().

1037  {
1038  HEAVYDBLOGGER.debug("Entered");
1039  throw new UnsupportedOperationException("Not supported yet,"
1040  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1041  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1042  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1043  }

+ Here is the caller graph for this function:

int [] ai.heavy.jdbc.HeavyAIPreparedStatement.executeBatch ( ) throws SQLException
inline

Definition at line 945 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.checkClosed(), ai.heavy.jdbc.HeavyAIPreparedStatement.clearBatch(), ai.heavy.jdbc.HeavyAIPreparedStatement.insertTableName, ai.heavy.jdbc.HeavyAIPreparedStatement.listOfFields, ai.heavy.jdbc.HeavyAIPreparedStatement.rows, and ai.heavy.jdbc.HeavyAIPreparedStatement.session.

945  {
946  checkClosed();
947  int ret[] = null;
948  if (rows != null) {
949  HEAVYDBLOGGER.debug("executeBatch, rows=" + rows.size());
950  try {
951  // send the batch
952  client.load_table(session, insertTableName, rows, Arrays.asList(listOfFields));
953  } catch (TDBException ex) {
954  throw new SQLException("executeBatch failed: " + ex.getError_msg());
955  } catch (TException ex) {
956  throw new SQLException("executeBatch failed: " + ex.toString());
957  }
958  ret = new int[rows.size()];
959  for (int i = 0; i < rows.size(); i++) {
960  ret[i] = 1;
961  }
962  clearBatch();
963  }
964  return ret;
965  }

+ Here is the call graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIPreparedStatement.executeQuery ( ) throws SQLException
inline

Definition at line 159 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.getQuery(), and ai.heavy.jdbc.HeavyAIPreparedStatement.isNewBatch.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate().

159  {
160  if (isNewBatch) {
161  String qsql = getQuery();
162  HEAVYDBLOGGER.debug("executeQuery, sql=" + qsql);
163  return stmt.executeQuery(qsql);
164  }
165  throw new UnsupportedOperationException("Not supported yet,"
166  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
167  + " class:" + new Throwable().getStackTrace()[0].getClassName()
168  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
169  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

ResultSet ai.heavy.jdbc.HeavyAIPreparedStatement.executeQuery ( String  sql) throws SQLException
inline

Definition at line 735 of file HeavyAIPreparedStatement.java.

735  {
736  HEAVYDBLOGGER.debug("Entered");
737  throw new UnsupportedOperationException("Not supported yet,"
738  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
739  + " class:" + new Throwable().getStackTrace()[0].getClassName()
740  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
741  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate ( ) throws SQLException
inline

Definition at line 172 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.executeQuery().

172  {
173  HEAVYDBLOGGER.debug("Entered");
174  executeQuery();
175  // TODO: OmniSciDB supports updates, inserts and deletes, but
176  // there is no way to get number of affected rows at the moment
177  return -1;
178  }

+ Here is the call graph for this function:

int ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate ( String  sql) throws SQLException
inline

Definition at line 744 of file HeavyAIPreparedStatement.java.

744  {
745  HEAVYDBLOGGER.debug("Entered");
746  throw new UnsupportedOperationException("Not supported yet,"
747  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
748  + " class:" + new Throwable().getStackTrace()[0].getClassName()
749  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
750  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate ( String  sql,
int  autoGeneratedKeys 
) throws SQLException
inline

Definition at line 992 of file HeavyAIPreparedStatement.java.

992  {
993  HEAVYDBLOGGER.debug("Entered");
994  throw new UnsupportedOperationException("Not supported yet,"
995  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
996  + " class:" + new Throwable().getStackTrace()[0].getClassName()
997  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
998  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate ( String  sql,
int[]  columnIndexes 
) throws SQLException
inline

Definition at line 1001 of file HeavyAIPreparedStatement.java.

1001  {
1002  HEAVYDBLOGGER.debug("Entered");
1003  throw new UnsupportedOperationException("Not supported yet,"
1004  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1005  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1006  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1007  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.executeUpdate ( String  sql,
String[]  columnNames 
) throws SQLException
inline

Definition at line 1010 of file HeavyAIPreparedStatement.java.

1010  {
1011  HEAVYDBLOGGER.debug("Entered");
1012  throw new UnsupportedOperationException("Not supported yet,"
1013  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1014  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1015  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1016  }
Connection ai.heavy.jdbc.HeavyAIPreparedStatement.getConnection ( ) throws SQLException
inline

Definition at line 968 of file HeavyAIPreparedStatement.java.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.getMetaData().

968  {
969  HEAVYDBLOGGER.debug("Entered");
970  return stmt.getConnection();
971  }

+ Here is the caller graph for this function:

int ai.heavy.jdbc.HeavyAIPreparedStatement.getFetchDirection ( ) throws SQLException
inline

Definition at line 887 of file HeavyAIPreparedStatement.java.

887  {
888  HEAVYDBLOGGER.debug("Entered");
889  return ResultSet.FETCH_FORWARD;
890  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getFetchSize ( ) throws SQLException
inline

Definition at line 901 of file HeavyAIPreparedStatement.java.

901  {
902  HEAVYDBLOGGER.debug("Entered");
903  throw new UnsupportedOperationException("Not supported yet,"
904  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
905  + " class:" + new Throwable().getStackTrace()[0].getClassName()
906  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
907  }
ResultSet ai.heavy.jdbc.HeavyAIPreparedStatement.getGeneratedKeys ( ) throws SQLException
inline

Definition at line 983 of file HeavyAIPreparedStatement.java.

983  {
984  HEAVYDBLOGGER.debug("Entered");
985  throw new UnsupportedOperationException("Not supported yet,"
986  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
987  + " class:" + new Throwable().getStackTrace()[0].getClassName()
988  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
989  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getMaxFieldSize ( ) throws SQLException
inline

Definition at line 764 of file HeavyAIPreparedStatement.java.

764  {
765  HEAVYDBLOGGER.debug("Entered");
766  throw new UnsupportedOperationException("Not supported yet,"
767  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
768  + " class:" + new Throwable().getStackTrace()[0].getClassName()
769  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
770  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getMaxRows ( ) throws SQLException
inline

Definition at line 782 of file HeavyAIPreparedStatement.java.

782  {
783  HEAVYDBLOGGER.debug("Entered");
784  return stmt.getMaxRows();
785  }
ResultSetMetaData ai.heavy.jdbc.HeavyAIPreparedStatement.getMetaData ( ) throws SQLException
inline

Definition at line 469 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.currentSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.getConnection(), ai.heavy.jdbc.HeavyAIStatement.getResultSet(), ai.heavy.jdbc.HeavyAIPreparedStatement.HeavyAIPreparedStatement(), ai.heavy.jdbc.HeavyAIPreparedStatement.isSelect(), ai.heavy.jdbc.HeavyAIPreparedStatement.session, and ai.heavy.jdbc.HeavyAIPreparedStatement.stmt.

469  {
470  HEAVYDBLOGGER.debug("Entered");
471  if (!isSelect()) {
472  return null;
473  }
474  if (stmt.getResultSet() != null) {
475  return stmt.getResultSet().getMetaData();
476  }
477  PreparedStatement ps = null;
478  try {
479  ps = new HeavyAIPreparedStatement(
480  currentSQL, session, (HeavyAIConnection) getConnection());
481  ps.setMaxRows(0);
482  for (int i = 1; i <= this.parmCount; ++i) {
483  ps.setNull(i, Types.NULL);
484  }
485  ResultSet rs = ps.executeQuery();
486  if (rs != null) {
487  return rs.getMetaData();
488  } else {
489  return null;
490  }
491  } finally {
492  if (ps != null) {
493  ps.close();
494  }
495  }
496  }
HeavyAIPreparedStatement(String sql, String session, HeavyAIConnection connection)

+ Here is the call graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.getMoreResults ( ) throws SQLException
inline

Definition at line 872 of file HeavyAIPreparedStatement.java.

872  {
873  HEAVYDBLOGGER.debug("Entered");
874  return stmt.getMoreResults();
875  }
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.getMoreResults ( int  current) throws SQLException
inline

Definition at line 974 of file HeavyAIPreparedStatement.java.

974  {
975  HEAVYDBLOGGER.debug("Entered");
976  throw new UnsupportedOperationException("Not supported yet,"
977  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
978  + " class:" + new Throwable().getStackTrace()[0].getClassName()
979  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
980  }
ParameterMetaData ai.heavy.jdbc.HeavyAIPreparedStatement.getParameterMetaData ( ) throws SQLException
inline

Definition at line 546 of file HeavyAIPreparedStatement.java.

546  {
547  HEAVYDBLOGGER.debug("Entered");
548  throw new UnsupportedOperationException("Not supported yet,"
549  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
550  + " class:" + new Throwable().getStackTrace()[0].getClassName()
551  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
552  }
String ai.heavy.jdbc.HeavyAIPreparedStatement.getQuery ( )
inlineprivate

Definition at line 119 of file HeavyAIPreparedStatement.java.

References File_Namespace.append(), ai.heavy.jdbc.HeavyAIPreparedStatement.brokenSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.currentSQL, ai.heavy.jdbc.HeavyAIPreparedStatement.parmCount, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsString, ai.heavy.jdbc.HeavyAIPreparedStatement.parmRep, and ai.heavy.jdbc.HeavyAIPreparedStatement.repCount.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.execute(), and ai.heavy.jdbc.HeavyAIPreparedStatement.executeQuery().

119  {
120  String qsql;
121  // put string together if required
122  if (parmCount > 0) {
123  if (repCount != parmCount) {
124  throw new UnsupportedOperationException(
125  "Incorrect number of replace parameters for prepared statement "
126  + currentSQL + " has only " + repCount + " parameters");
127  }
128  StringBuilder modQuery = new StringBuilder(currentSQL.length() * 5);
129  for (int i = 0; i < repCount; i++) {
130  modQuery.append(brokenSQL[i]);
131  if (parmIsNull[i]) {
132  modQuery.append("NULL");
133  } else {
134  if (parmIsString[i]) {
135  modQuery.append("'").append(parmRep[i]).append("'");
136  } else {
137  modQuery.append(parmRep[i]);
138  }
139  }
140  }
141  modQuery.append(brokenSQL[parmCount]);
142  qsql = modQuery.toString();
143  } else {
144  qsql = currentSQL;
145  }
146 
147  qsql = qsql.replace(" WHERE 1=0", " LIMIT 1 ");
148  HEAVYDBLOGGER.debug("Query is now " + qsql);
149  repCount = 0; // reset the parameters
150  return qsql;
151  }
size_t append(FILE *f, const size_t size, const int8_t *buf)
Appends the specified number of bytes to the end of the file f from buf.
Definition: File.cpp:168

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

int ai.heavy.jdbc.HeavyAIPreparedStatement.getQueryTimeout ( ) throws SQLException
inline

Definition at line 804 of file HeavyAIPreparedStatement.java.

804  {
805  HEAVYDBLOGGER.debug("Entered");
806  return 0;
807  }
ResultSet ai.heavy.jdbc.HeavyAIPreparedStatement.getResultSet ( ) throws SQLException
inline

Definition at line 860 of file HeavyAIPreparedStatement.java.

860  {
861  HEAVYDBLOGGER.debug("Entered");
862  return stmt.getResultSet();
863  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getResultSetConcurrency ( ) throws SQLException
inline

Definition at line 910 of file HeavyAIPreparedStatement.java.

910  {
911  HEAVYDBLOGGER.debug("Entered");
912  throw new UnsupportedOperationException("Not supported yet,"
913  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
914  + " class:" + new Throwable().getStackTrace()[0].getClassName()
915  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
916  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getResultSetHoldability ( ) throws SQLException
inline

Definition at line 1046 of file HeavyAIPreparedStatement.java.

1046  {
1047  HEAVYDBLOGGER.debug("Entered");
1048  throw new UnsupportedOperationException("Not supported yet,"
1049  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1050  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1051  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1052  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getResultSetType ( ) throws SQLException
inline

Definition at line 919 of file HeavyAIPreparedStatement.java.

919  {
920  HEAVYDBLOGGER.debug("Entered");
921  throw new UnsupportedOperationException("Not supported yet,"
922  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
923  + " class:" + new Throwable().getStackTrace()[0].getClassName()
924  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
925  }
int ai.heavy.jdbc.HeavyAIPreparedStatement.getUpdateCount ( ) throws SQLException
inline

Definition at line 866 of file HeavyAIPreparedStatement.java.

866  {
867  HEAVYDBLOGGER.debug("Entered");
868  return stmt.getUpdateCount();
869  }
SQLWarning ai.heavy.jdbc.HeavyAIPreparedStatement.getWarnings ( ) throws SQLException
inline

Definition at line 830 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.rootWarning.

830  {
831  HEAVYDBLOGGER.debug("Entered");
832  return rootWarning;
833  }
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isClosed ( ) throws SQLException
inline

Definition at line 1055 of file HeavyAIPreparedStatement.java.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.checkClosed(), and ai.heavy.jdbc.HeavyAIPreparedStatement.close().

1055  {
1056  HEAVYDBLOGGER.debug("Entered");
1057  return isClosed;
1058  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isCloseOnCompletion ( ) throws SQLException
inline

Definition at line 1088 of file HeavyAIPreparedStatement.java.

1088  {
1089  HEAVYDBLOGGER.debug("Entered");
1090  throw new UnsupportedOperationException("Not supported yet,"
1091  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1092  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1093  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1094  }
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isPoolable ( ) throws SQLException
inline

Definition at line 1070 of file HeavyAIPreparedStatement.java.

1070  {
1071  HEAVYDBLOGGER.debug("Entered");
1072  throw new UnsupportedOperationException("Not supported yet,"
1073  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1074  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1075  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1076  }
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isSelect ( )
inlineprivate

Definition at line 153 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.currentSQL.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.getMetaData().

153  {
154  Matcher matcher = REGEX_IS_SELECT_PATTERN.matcher(currentSQL);
155  return matcher.matches();
156  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isWrapperFor ( Class<?>  iface) throws SQLException
inline

Definition at line 1106 of file HeavyAIPreparedStatement.java.

1106  {
1107  HEAVYDBLOGGER.debug("Entered");
1108  throw new UnsupportedOperationException("Not supported yet,"
1109  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1110  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1111  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1112  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setArray ( int  parameterIndex,
Array  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setAsciiStream ( int  parameterIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 302 of file HeavyAIPreparedStatement.java.

303  {
304  HEAVYDBLOGGER.debug("Entered");
305  throw new UnsupportedOperationException("Not supported yet,"
306  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
307  + " class:" + new Throwable().getStackTrace()[0].getClassName()
308  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
309  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setAsciiStream ( int  parameterIndex,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 642 of file HeavyAIPreparedStatement.java.

643  {
644  HEAVYDBLOGGER.debug("Entered");
645  throw new UnsupportedOperationException("Not supported yet,"
646  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
647  + " class:" + new Throwable().getStackTrace()[0].getClassName()
648  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
649  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setAsciiStream ( int  parameterIndex,
InputStream  x 
) throws SQLException
inline

Definition at line 672 of file HeavyAIPreparedStatement.java.

672  {
673  HEAVYDBLOGGER.debug("Entered");
674  throw new UnsupportedOperationException("Not supported yet,"
675  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
676  + " class:" + new Throwable().getStackTrace()[0].getClassName()
677  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
678  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBigDecimal ( int  parameterIndex,
BigDecimal  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBinaryStream ( int  parameterIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 322 of file HeavyAIPreparedStatement.java.

323  {
324  HEAVYDBLOGGER.debug("Entered");
325  throw new UnsupportedOperationException("Not supported yet,"
326  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
327  + " class:" + new Throwable().getStackTrace()[0].getClassName()
328  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
329  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBinaryStream ( int  parameterIndex,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 652 of file HeavyAIPreparedStatement.java.

653  {
654  HEAVYDBLOGGER.debug("Entered");
655  throw new UnsupportedOperationException("Not supported yet,"
656  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
657  + " class:" + new Throwable().getStackTrace()[0].getClassName()
658  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
659  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBinaryStream ( int  parameterIndex,
InputStream  x 
) throws SQLException
inline

Definition at line 681 of file HeavyAIPreparedStatement.java.

681  {
682  HEAVYDBLOGGER.debug("Entered");
683  throw new UnsupportedOperationException("Not supported yet,"
684  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
685  + " class:" + new Throwable().getStackTrace()[0].getClassName()
686  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
687  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBlob ( int  parameterIndex,
Blob  x 
) throws SQLException
inline

Definition at line 443 of file HeavyAIPreparedStatement.java.

443  {
444  HEAVYDBLOGGER.debug("Entered");
445  throw new UnsupportedOperationException("Not supported yet,"
446  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
447  + " class:" + new Throwable().getStackTrace()[0].getClassName()
448  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
449  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBlob ( int  parameterIndex,
InputStream  inputStream,
long  length 
) throws SQLException
inline

Definition at line 602 of file HeavyAIPreparedStatement.java.

603  {
604  HEAVYDBLOGGER.debug("Entered");
605  throw new UnsupportedOperationException("Not supported yet,"
606  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
607  + " class:" + new Throwable().getStackTrace()[0].getClassName()
608  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
609  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBlob ( int  parameterIndex,
InputStream  inputStream 
) throws SQLException
inline

Definition at line 717 of file HeavyAIPreparedStatement.java.

717  {
718  HEAVYDBLOGGER.debug("Entered");
719  throw new UnsupportedOperationException("Not supported yet,"
720  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
721  + " class:" + new Throwable().getStackTrace()[0].getClassName()
722  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
723  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBoolean ( int  parameterIndex,
boolean  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setByte ( int  parameterIndex,
byte  x 
) throws SQLException
inline

Definition at line 197 of file HeavyAIPreparedStatement.java.

197  {
198  HEAVYDBLOGGER.debug("Entered");
199  throw new UnsupportedOperationException("Not supported yet,"
200  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
201  + " class:" + new Throwable().getStackTrace()[0].getClassName()
202  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
203  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setBytes ( int  parameterIndex,
byte[]  x 
) throws SQLException
inline

Definition at line 265 of file HeavyAIPreparedStatement.java.

265  {
266  HEAVYDBLOGGER.debug("Entered");
267  throw new UnsupportedOperationException("Not supported yet,"
268  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
269  + " class:" + new Throwable().getStackTrace()[0].getClassName()
270  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
271  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setCharacterStream ( int  parameterIndex,
Reader  reader,
int  length 
) throws SQLException
inline

Definition at line 424 of file HeavyAIPreparedStatement.java.

425  {
426  HEAVYDBLOGGER.debug("Entered");
427  throw new UnsupportedOperationException("Not supported yet,"
428  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
429  + " class:" + new Throwable().getStackTrace()[0].getClassName()
430  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
431  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setCharacterStream ( int  parameterIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 662 of file HeavyAIPreparedStatement.java.

663  {
664  HEAVYDBLOGGER.debug("Entered");
665  throw new UnsupportedOperationException("Not supported yet,"
666  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
667  + " class:" + new Throwable().getStackTrace()[0].getClassName()
668  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
669  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setCharacterStream ( int  parameterIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 690 of file HeavyAIPreparedStatement.java.

690  {
691  HEAVYDBLOGGER.debug("Entered");
692  throw new UnsupportedOperationException("Not supported yet,"
693  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
694  + " class:" + new Throwable().getStackTrace()[0].getClassName()
695  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
696  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setClob ( int  parameterIndex,
Clob  x 
) throws SQLException
inline

Definition at line 452 of file HeavyAIPreparedStatement.java.

452  {
453  HEAVYDBLOGGER.debug("Entered");
454  throw new UnsupportedOperationException("Not supported yet,"
455  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
456  + " class:" + new Throwable().getStackTrace()[0].getClassName()
457  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
458  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setClob ( int  parameterIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 592 of file HeavyAIPreparedStatement.java.

593  {
594  HEAVYDBLOGGER.debug("Entered");
595  throw new UnsupportedOperationException("Not supported yet,"
596  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
597  + " class:" + new Throwable().getStackTrace()[0].getClassName()
598  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
599  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setClob ( int  parameterIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 708 of file HeavyAIPreparedStatement.java.

708  {
709  HEAVYDBLOGGER.debug("Entered");
710  throw new UnsupportedOperationException("Not supported yet,"
711  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
712  + " class:" + new Throwable().getStackTrace()[0].getClassName()
713  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
714  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setCursorName ( String  name) throws SQLException
inline

Definition at line 842 of file HeavyAIPreparedStatement.java.

842  {
843  HEAVYDBLOGGER.debug("Entered");
844  throw new UnsupportedOperationException("Not supported yet,"
845  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
846  + " class:" + new Throwable().getStackTrace()[0].getClassName()
847  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
848  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setDate ( int  parameterIndex,
Date  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setDate ( int  parameterIndex,
Date  x,
Calendar  cal 
) throws SQLException
inline

Definition at line 499 of file HeavyAIPreparedStatement.java.

499  {
500  HEAVYDBLOGGER.debug("Entered");
501  throw new UnsupportedOperationException("Not supported yet,"
502  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
503  + " class:" + new Throwable().getStackTrace()[0].getClassName()
504  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
505  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setDouble ( int  parameterIndex,
double  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setEscapeProcessing ( boolean  enable) throws SQLException
inline

Definition at line 795 of file HeavyAIPreparedStatement.java.

795  {
796  HEAVYDBLOGGER.debug("Entered");
797  throw new UnsupportedOperationException("Not supported yet,"
798  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
799  + " class:" + new Throwable().getStackTrace()[0].getClassName()
800  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
801  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setFetchDirection ( int  direction) throws SQLException
inline

Definition at line 878 of file HeavyAIPreparedStatement.java.

878  {
879  HEAVYDBLOGGER.debug("Entered");
880  throw new UnsupportedOperationException("Not supported yet,"
881  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
882  + " class:" + new Throwable().getStackTrace()[0].getClassName()
883  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
884  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setFetchSize ( int  rows) throws SQLException
inline

Definition at line 893 of file HeavyAIPreparedStatement.java.

893  {
894  HEAVYDBLOGGER.debug("Entered");
895  // TODO we need to chnage the model to allow smaller select chunks at the moment
896  // you
897  // get everything
898  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setFloat ( int  parameterIndex,
float  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setInt ( int  parameterIndex,
int  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setLong ( int  parameterIndex,
long  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setMaxFieldSize ( int  max) throws SQLException
inline

Definition at line 773 of file HeavyAIPreparedStatement.java.

773  {
774  HEAVYDBLOGGER.debug("Entered");
775  throw new UnsupportedOperationException("Not supported yet,"
776  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
777  + " class:" + new Throwable().getStackTrace()[0].getClassName()
778  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
779  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setMaxRows ( int  max) throws SQLException
inline

Definition at line 788 of file HeavyAIPreparedStatement.java.

788  {
789  HEAVYDBLOGGER.debug("Entered");
790  HEAVYDBLOGGER.debug("SetMaxRows to " + max);
791  stmt.setMaxRows(max);
792  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNCharacterStream ( int  parameterIndex,
Reader  value,
long  length 
) throws SQLException
inline

Definition at line 573 of file HeavyAIPreparedStatement.java.

574  {
575  HEAVYDBLOGGER.debug("Entered");
576  throw new UnsupportedOperationException("Not supported yet,"
577  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
578  + " class:" + new Throwable().getStackTrace()[0].getClassName()
579  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
580  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNCharacterStream ( int  parameterIndex,
Reader  value 
) throws SQLException
inline

Definition at line 699 of file HeavyAIPreparedStatement.java.

699  {
700  HEAVYDBLOGGER.debug("Entered");
701  throw new UnsupportedOperationException("Not supported yet,"
702  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
703  + " class:" + new Throwable().getStackTrace()[0].getClassName()
704  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
705  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNClob ( int  parameterIndex,
NClob  value 
) throws SQLException
inline

Definition at line 583 of file HeavyAIPreparedStatement.java.

583  {
584  HEAVYDBLOGGER.debug("Entered");
585  throw new UnsupportedOperationException("Not supported yet,"
586  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
587  + " class:" + new Throwable().getStackTrace()[0].getClassName()
588  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
589  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNClob ( int  parameterIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 612 of file HeavyAIPreparedStatement.java.

613  {
614  HEAVYDBLOGGER.debug("Entered");
615  throw new UnsupportedOperationException("Not supported yet,"
616  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
617  + " class:" + new Throwable().getStackTrace()[0].getClassName()
618  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
619  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNClob ( int  parameterIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 726 of file HeavyAIPreparedStatement.java.

726  {
727  HEAVYDBLOGGER.debug("Entered");
728  throw new UnsupportedOperationException("Not supported yet,"
729  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
730  + " class:" + new Throwable().getStackTrace()[0].getClassName()
731  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
732  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNString ( int  parameterIndex,
String  value 
) throws SQLException
inline

Definition at line 564 of file HeavyAIPreparedStatement.java.

564  {
565  HEAVYDBLOGGER.debug("Entered");
566  throw new UnsupportedOperationException("Not supported yet,"
567  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
568  + " class:" + new Throwable().getStackTrace()[0].getClassName()
569  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
570  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNull ( int  parameterIndex,
int  sqlType 
) throws SQLException
inline

Definition at line 181 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, and ai.heavy.jdbc.HeavyAIPreparedStatement.repCount.

181  {
182  HEAVYDBLOGGER.debug("Entered");
183  parmIsNull[parameterIndex - 1] = true;
184  repCount++;
185  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setNull ( int  parameterIndex,
int  sqlType,
String  typeName 
) throws SQLException
inline

Definition at line 527 of file HeavyAIPreparedStatement.java.

528  {
529  HEAVYDBLOGGER.debug("Entered");
530  throw new UnsupportedOperationException("Not supported yet,"
531  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
532  + " class:" + new Throwable().getStackTrace()[0].getClassName()
533  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
534  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setObject ( int  parameterIndex,
Object  x,
int  targetSqlType 
) throws SQLException
inline

Definition at line 338 of file HeavyAIPreparedStatement.java.

339  {
340  HEAVYDBLOGGER.debug("Entered");
341  throw new UnsupportedOperationException("Not supported yet,"
342  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
343  + " class:" + new Throwable().getStackTrace()[0].getClassName()
344  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
345  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setObject ( int  parameterIndex,
Object  x 
) throws SQLException
inline

Definition at line 348 of file HeavyAIPreparedStatement.java.

348  {
349  HEAVYDBLOGGER.debug("Entered");
350  throw new UnsupportedOperationException("Not supported yet,"
351  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
352  + " class:" + new Throwable().getStackTrace()[0].getClassName()
353  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
354  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setObject ( int  parameterIndex,
Object  x,
int  targetSqlType,
int  scaleOrLength 
) throws SQLException
inline

Definition at line 631 of file HeavyAIPreparedStatement.java.

633  {
634  HEAVYDBLOGGER.debug("Entered");
635  throw new UnsupportedOperationException("Not supported yet,"
636  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
637  + " class:" + new Throwable().getStackTrace()[0].getClassName()
638  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
639  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setPoolable ( boolean  poolable) throws SQLException
inline

Definition at line 1061 of file HeavyAIPreparedStatement.java.

1061  {
1062  HEAVYDBLOGGER.debug("Entered");
1063  throw new UnsupportedOperationException("Not supported yet,"
1064  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1065  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1066  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1067  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setQueryTimeout ( int  seconds) throws SQLException
inline

Definition at line 810 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.rootWarning.

810  {
811  HEAVYDBLOGGER.debug("Entered");
812  SQLWarning warning = new SQLWarning(
813  "Query timeouts are not supported. Substituting a value of zero.");
814  if (rootWarning == null)
815  rootWarning = warning;
816  else
817  rootWarning.setNextWarning(warning);
818  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setRef ( int  parameterIndex,
Ref  x 
) throws SQLException
inline

Definition at line 434 of file HeavyAIPreparedStatement.java.

434  {
435  HEAVYDBLOGGER.debug("Entered");
436  throw new UnsupportedOperationException("Not supported yet,"
437  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
438  + " class:" + new Throwable().getStackTrace()[0].getClassName()
439  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
440  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setRowId ( int  parameterIndex,
RowId  x 
) throws SQLException
inline

Definition at line 555 of file HeavyAIPreparedStatement.java.

555  {
556  HEAVYDBLOGGER.debug("Entered");
557  throw new UnsupportedOperationException("Not supported yet,"
558  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
559  + " class:" + new Throwable().getStackTrace()[0].getClassName()
560  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
561  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setShort ( int  parameterIndex,
short  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setSQLXML ( int  parameterIndex,
SQLXML  xmlObject 
) throws SQLException
inline

Definition at line 622 of file HeavyAIPreparedStatement.java.

622  {
623  HEAVYDBLOGGER.debug("Entered");
624  throw new UnsupportedOperationException("Not supported yet,"
625  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
626  + " class:" + new Throwable().getStackTrace()[0].getClassName()
627  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
628  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setString ( int  parameterIndex,
String  x 
) throws SQLException
inline

Definition at line 254 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsString, ai.heavy.jdbc.HeavyAIPreparedStatement.parmRep, and ai.heavy.jdbc.HeavyAIPreparedStatement.repCount.

254  {
255  HEAVYDBLOGGER.debug("Entered");
256  // add extra ' if there are any in string
257  x = x.replaceAll("'", "''");
258  parmRep[parameterIndex - 1] = x;
259  parmIsString[parameterIndex - 1] = true;
260  parmIsNull[parameterIndex - 1] = false;
261  repCount++;
262  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setTime ( int  parameterIndex,
Time  x 
) throws SQLException
inline
void ai.heavy.jdbc.HeavyAIPreparedStatement.setTime ( int  parameterIndex,
Time  x,
Calendar  cal 
) throws SQLException
inline

Definition at line 508 of file HeavyAIPreparedStatement.java.

508  {
509  HEAVYDBLOGGER.debug("Entered");
510  throw new UnsupportedOperationException("Not supported yet,"
511  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
512  + " class:" + new Throwable().getStackTrace()[0].getClassName()
513  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
514  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setTimestamp ( int  parameterIndex,
Timestamp  x 
) throws SQLException
inline

Definition at line 292 of file HeavyAIPreparedStatement.java.

References ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsNull, ai.heavy.jdbc.HeavyAIPreparedStatement.parmIsString, ai.heavy.jdbc.HeavyAIPreparedStatement.parmRep, and ai.heavy.jdbc.HeavyAIPreparedStatement.repCount.

292  {
293  HEAVYDBLOGGER.debug("Entered");
294  parmRep[parameterIndex - 1] =
295  x.toString(); // new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(x);
296  parmIsString[parameterIndex - 1] = true;
297  parmIsNull[parameterIndex - 1] = false;
298  repCount++;
299  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setTimestamp ( int  parameterIndex,
Timestamp  x,
Calendar  cal 
) throws SQLException
inline

Definition at line 517 of file HeavyAIPreparedStatement.java.

518  {
519  HEAVYDBLOGGER.debug("Entered");
520  throw new UnsupportedOperationException("Not supported yet,"
521  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
522  + " class:" + new Throwable().getStackTrace()[0].getClassName()
523  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
524  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setUnicodeStream ( int  parameterIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 312 of file HeavyAIPreparedStatement.java.

313  {
314  HEAVYDBLOGGER.debug("Entered");
315  throw new UnsupportedOperationException("Not supported yet,"
316  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
317  + " class:" + new Throwable().getStackTrace()[0].getClassName()
318  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
319  }
void ai.heavy.jdbc.HeavyAIPreparedStatement.setURL ( int  parameterIndex,
URL  x 
) throws SQLException
inline

Definition at line 537 of file HeavyAIPreparedStatement.java.

537  {
538  HEAVYDBLOGGER.debug("Entered");
539  throw new UnsupportedOperationException("Not supported yet,"
540  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
541  + " class:" + new Throwable().getStackTrace()[0].getClassName()
542  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
543  }
public<T> T ai.heavy.jdbc.HeavyAIPreparedStatement.unwrap ( Class< T >  iface) throws SQLException
inlinepackage

Definition at line 1097 of file HeavyAIPreparedStatement.java.

1097  {
1098  HEAVYDBLOGGER.debug("Entered");
1099  throw new UnsupportedOperationException("Not supported yet,"
1100  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1101  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1102  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1103  }

Member Data Documentation

String ai.heavy.jdbc.HeavyAIPreparedStatement.brokenSQL[]
private
Heavy.Client ai.heavy.jdbc.HeavyAIPreparedStatement.client
private

Definition at line 72 of file HeavyAIPreparedStatement.java.

final Logger ai.heavy.jdbc.HeavyAIPreparedStatement.HEAVYDBLOGGER
staticpackage
Initial value:
=
LoggerFactory.getLogger(HeavyAIPreparedStatement.class)

Definition at line 59 of file HeavyAIPreparedStatement.java.

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isClosed = false
private

Definition at line 86 of file HeavyAIPreparedStatement.java.

boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isInsert = false
private
boolean ai.heavy.jdbc.HeavyAIPreparedStatement.isNewBatch = true
private
String ai.heavy.jdbc.HeavyAIPreparedStatement.listOfFields[]
private
final Pattern ai.heavy.jdbc.HeavyAIPreparedStatement.REGEX_IS_SELECT_PATTERN
staticprivate
Initial value:
=
Pattern.compile("^(?:\\s|--.*?\\R|/\\*[\\S\\s]*?\\*/|\\s*)*\\s*select[\\S\\s]*",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE)

Definition at line 83 of file HeavyAIPreparedStatement.java.

final Pattern ai.heavy.jdbc.HeavyAIPreparedStatement.REGEX_LOF_PATTERN
staticprivate
Initial value:
= Pattern.compile(
"(?i)\\s*insert\\s+into\\s+[\\w:\\.]+\\s*\\(([\\w:\\s:\\,:\\']+)\\)[\\w:\\s]+\\(")

Definition at line 79 of file HeavyAIPreparedStatement.java.

final Pattern ai.heavy.jdbc.HeavyAIPreparedStatement.REGEX_PATTERN = Pattern.compile("(?i)\\s+INTO\\s+(\\w+)")
staticprivate

Definition at line 78 of file HeavyAIPreparedStatement.java.

String ai.heavy.jdbc.HeavyAIPreparedStatement.session
private

Definition at line 71 of file HeavyAIPreparedStatement.java.

Referenced by ai.heavy.jdbc.HeavyAIPreparedStatement.addBatch(), ai.heavy.jdbc.HeavyAIPreparedStatement.executeBatch(), ai.heavy.jdbc.HeavyAIPreparedStatement.getMetaData(), ai.heavy.jdbc.HeavyAIPreparedStatement.HeavyAIPreparedStatement(), heavydb.thrift.Heavy.disconnect_args.read(), heavydb.thrift.Heavy.switch_database_args.read(), heavydb.thrift.Heavy.clone_session_args.read(), heavydb.thrift.Heavy.get_server_status_args.read(), heavydb.thrift.Heavy.get_status_args.read(), heavydb.thrift.Heavy.get_hardware_info_args.read(), heavydb.thrift.Heavy.get_tables_args.read(), heavydb.thrift.Heavy.get_tables_for_database_args.read(), heavydb.thrift.Heavy.get_physical_tables_args.read(), heavydb.thrift.Heavy.get_views_args.read(), heavydb.thrift.Heavy.get_tables_meta_args.read(), heavydb.thrift.Heavy.get_table_details_args.read(), heavydb.thrift.Heavy.get_table_details_for_database_args.read(), heavydb.thrift.Heavy.get_internal_table_details_args.read(), heavydb.thrift.Heavy.get_internal_table_details_for_database_args.read(), heavydb.thrift.Heavy.get_users_args.read(), heavydb.thrift.Heavy.get_databases_args.read(), heavydb.thrift.Heavy.start_heap_profile_args.read(), heavydb.thrift.Heavy.stop_heap_profile_args.read(), heavydb.thrift.Heavy.get_heap_profile_args.read(), heavydb.thrift.Heavy.get_memory_args.read(), heavydb.thrift.Heavy.clear_cpu_memory_args.read(), heavydb.thrift.Heavy.clear_gpu_memory_args.read(), heavydb.thrift.Heavy.set_table_epoch_args.read(), heavydb.thrift.Heavy.set_table_epoch_by_name_args.read(), heavydb.thrift.Heavy.get_table_epoch_args.read(), heavydb.thrift.Heavy.get_table_epoch_by_name_args.read(), heavydb.thrift.Heavy.get_table_epochs_args.read(), heavydb.thrift.Heavy.set_table_epochs_args.read(), heavydb.thrift.Heavy.get_session_info_args.read(), heavydb.thrift.Heavy.get_queries_info_args.read(), heavydb.thrift.Heavy.set_leaf_info_args.read(), heavydb.thrift.Heavy.sql_execute_args.read(), heavydb.thrift.Heavy.sql_execute_df_args.read(), heavydb.thrift.Heavy.sql_execute_gdf_args.read(), heavydb.thrift.Heavy.deallocate_df_args.read(), heavydb.thrift.Heavy.sql_validate_args.read(), heavydb.thrift.Heavy.get_completion_hints_args.read(), heavydb.thrift.Heavy.set_execution_mode_args.read(), heavydb.thrift.Heavy.render_vega_args.read(), heavydb.thrift.Heavy.get_result_row_for_pixel_args.read(), heavydb.thrift.Heavy.create_custom_expression_args.read(), heavydb.thrift.Heavy.get_custom_expressions_args.read(), heavydb.thrift.Heavy.update_custom_expression_args.read(), heavydb.thrift.Heavy.delete_custom_expressions_args.read(), heavydb.thrift.Heavy.get_dashboard_args.read(), heavydb.thrift.Heavy.get_dashboards_args.read(), heavydb.thrift.Heavy.create_dashboard_args.read(), heavydb.thrift.Heavy.replace_dashboard_args.read(), heavydb.thrift.Heavy.delete_dashboard_args.read(), heavydb.thrift.Heavy.share_dashboards_args.read(), heavydb.thrift.Heavy.delete_dashboards_args.read(), heavydb.thrift.Heavy.share_dashboard_args.read(), heavydb.thrift.Heavy.unshare_dashboard_args.read(), heavydb.thrift.Heavy.unshare_dashboards_args.read(), heavydb.thrift.Heavy.get_dashboard_grantees_args.read(), heavydb.thrift.Heavy.get_link_view_args.read(), heavydb.thrift.Heavy.create_link_args.read(), heavydb.thrift.Heavy.load_table_binary_args.read(), heavydb.thrift.Heavy.load_table_binary_columnar_args.read(), heavydb.thrift.Heavy.load_table_binary_columnar_polys_args.read(), heavydb.thrift.Heavy.load_table_binary_arrow_args.read(), heavydb.thrift.Heavy.load_table_args.read(), heavydb.thrift.Heavy.detect_column_types_args.read(), heavydb.thrift.Heavy.create_table_args.read(), heavydb.thrift.Heavy.import_table_args.read(), heavydb.thrift.Heavy.import_geo_table_args.read(), heavydb.thrift.Heavy.import_table_status_args.read(), heavydb.thrift.Heavy.get_first_geo_file_in_archive_args.read(), heavydb.thrift.Heavy.get_all_files_in_archive_args.read(), heavydb.thrift.Heavy.get_layers_in_geo_file_args.read(), heavydb.thrift.Heavy.query_get_outer_fragment_count_args.read(), heavydb.thrift.Heavy.check_table_consistency_args.read(), heavydb.thrift.Heavy.start_render_query_args.read(), heavydb.thrift.Heavy.insert_data_args.read(), heavydb.thrift.Heavy.insert_chunks_args.read(), heavydb.thrift.Heavy.checkpoint_args.read(), heavydb.thrift.Heavy.get_roles_args.read(), heavydb.thrift.Heavy.get_db_objects_for_grantee_args.read(), heavydb.thrift.Heavy.get_db_object_privs_args.read(), heavydb.thrift.Heavy.get_all_roles_for_user_args.read(), heavydb.thrift.Heavy.get_all_effective_roles_for_user_args.read(), heavydb.thrift.Heavy.has_role_args.read(), heavydb.thrift.Heavy.has_object_privilege_args.read(), heavydb.thrift.Heavy.set_license_key_args.read(), heavydb.thrift.Heavy.get_license_claims_args.read(), heavydb.thrift.Heavy.get_device_parameters_args.read(), heavydb.thrift.Heavy.register_runtime_extension_functions_args.read(), heavydb.thrift.Heavy.get_table_function_names_args.read(), heavydb.thrift.Heavy.get_runtime_table_function_names_args.read(), heavydb.thrift.Heavy.get_table_function_details_args.read(), heavydb.thrift.Heavy.disconnect_args.write(), heavydb.thrift.Heavy.switch_database_args.write(), heavydb.thrift.Heavy.clone_session_args.write(), heavydb.thrift.Heavy.get_server_status_args.write(), heavydb.thrift.Heavy.get_status_args.write(), heavydb.thrift.Heavy.get_hardware_info_args.write(), heavydb.thrift.Heavy.get_tables_args.write(), heavydb.thrift.Heavy.get_tables_for_database_args.write(), heavydb.thrift.Heavy.get_physical_tables_args.write(), heavydb.thrift.Heavy.get_views_args.write(), heavydb.thrift.Heavy.get_tables_meta_args.write(), heavydb.thrift.Heavy.get_table_details_args.write(), heavydb.thrift.Heavy.get_table_details_for_database_args.write(), heavydb.thrift.Heavy.get_internal_table_details_args.write(), heavydb.thrift.Heavy.get_internal_table_details_for_database_args.write(), heavydb.thrift.Heavy.get_users_args.write(), heavydb.thrift.Heavy.get_databases_args.write(), heavydb.thrift.Heavy.start_heap_profile_args.write(), heavydb.thrift.Heavy.stop_heap_profile_args.write(), heavydb.thrift.Heavy.get_heap_profile_args.write(), heavydb.thrift.Heavy.get_memory_args.write(), heavydb.thrift.Heavy.clear_cpu_memory_args.write(), heavydb.thrift.Heavy.clear_gpu_memory_args.write(), heavydb.thrift.Heavy.set_table_epoch_args.write(), heavydb.thrift.Heavy.set_table_epoch_by_name_args.write(), heavydb.thrift.Heavy.get_table_epoch_args.write(), heavydb.thrift.Heavy.get_table_epoch_by_name_args.write(), heavydb.thrift.Heavy.get_table_epochs_args.write(), heavydb.thrift.Heavy.set_table_epochs_args.write(), heavydb.thrift.Heavy.get_session_info_args.write(), heavydb.thrift.Heavy.get_queries_info_args.write(), heavydb.thrift.Heavy.set_leaf_info_args.write(), heavydb.thrift.Heavy.sql_execute_args.write(), heavydb.thrift.Heavy.sql_execute_df_args.write(), heavydb.thrift.Heavy.sql_execute_gdf_args.write(), heavydb.thrift.Heavy.deallocate_df_args.write(), heavydb.thrift.Heavy.sql_validate_args.write(), heavydb.thrift.Heavy.get_completion_hints_args.write(), heavydb.thrift.Heavy.set_execution_mode_args.write(), heavydb.thrift.Heavy.render_vega_args.write(), heavydb.thrift.Heavy.get_result_row_for_pixel_args.write(), heavydb.thrift.Heavy.create_custom_expression_args.write(), heavydb.thrift.Heavy.get_custom_expressions_args.write(), heavydb.thrift.Heavy.update_custom_expression_args.write(), heavydb.thrift.Heavy.delete_custom_expressions_args.write(), heavydb.thrift.Heavy.get_dashboard_args.write(), heavydb.thrift.Heavy.get_dashboards_args.write(), heavydb.thrift.Heavy.create_dashboard_args.write(), heavydb.thrift.Heavy.replace_dashboard_args.write(), heavydb.thrift.Heavy.delete_dashboard_args.write(), heavydb.thrift.Heavy.share_dashboards_args.write(), heavydb.thrift.Heavy.delete_dashboards_args.write(), heavydb.thrift.Heavy.share_dashboard_args.write(), heavydb.thrift.Heavy.unshare_dashboard_args.write(), heavydb.thrift.Heavy.unshare_dashboards_args.write(), heavydb.thrift.Heavy.get_dashboard_grantees_args.write(), heavydb.thrift.Heavy.get_link_view_args.write(), heavydb.thrift.Heavy.create_link_args.write(), heavydb.thrift.Heavy.load_table_binary_args.write(), heavydb.thrift.Heavy.load_table_binary_columnar_args.write(), heavydb.thrift.Heavy.load_table_binary_columnar_polys_args.write(), heavydb.thrift.Heavy.load_table_binary_arrow_args.write(), heavydb.thrift.Heavy.load_table_args.write(), heavydb.thrift.Heavy.detect_column_types_args.write(), heavydb.thrift.Heavy.create_table_args.write(), heavydb.thrift.Heavy.import_table_args.write(), heavydb.thrift.Heavy.import_geo_table_args.write(), heavydb.thrift.Heavy.import_table_status_args.write(), heavydb.thrift.Heavy.get_first_geo_file_in_archive_args.write(), heavydb.thrift.Heavy.get_all_files_in_archive_args.write(), heavydb.thrift.Heavy.get_layers_in_geo_file_args.write(), heavydb.thrift.Heavy.query_get_outer_fragment_count_args.write(), heavydb.thrift.Heavy.check_table_consistency_args.write(), heavydb.thrift.Heavy.start_render_query_args.write(), heavydb.thrift.Heavy.insert_data_args.write(), heavydb.thrift.Heavy.insert_chunks_args.write(), heavydb.thrift.Heavy.checkpoint_args.write(), heavydb.thrift.Heavy.get_roles_args.write(), heavydb.thrift.Heavy.get_db_objects_for_grantee_args.write(), heavydb.thrift.Heavy.get_db_object_privs_args.write(), heavydb.thrift.Heavy.get_all_roles_for_user_args.write(), heavydb.thrift.Heavy.get_all_effective_roles_for_user_args.write(), heavydb.thrift.Heavy.has_role_args.write(), heavydb.thrift.Heavy.has_object_privilege_args.write(), heavydb.thrift.Heavy.set_license_key_args.write(), heavydb.thrift.Heavy.get_license_claims_args.write(), heavydb.thrift.Heavy.get_device_parameters_args.write(), heavydb.thrift.Heavy.register_runtime_extension_functions_args.write(), heavydb.thrift.Heavy.get_table_function_names_args.write(), heavydb.thrift.Heavy.get_runtime_table_function_names_args.write(), and heavydb.thrift.Heavy.get_table_function_details_args.write().

HeavyAIStatement ai.heavy.jdbc.HeavyAIPreparedStatement.stmt = null
private

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