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

Public Member Functions

 HeavyAIResultSet (TQueryResult tsqlResult, String sql) throws SQLException
 
boolean next () throws SQLException
 
void close () throws SQLException
 
boolean wasNull () throws SQLException
 
String getString (int columnIndex) throws SQLException
 
boolean getBoolean (int columnIndex) throws SQLException
 
byte getByte (int columnIndex) throws SQLException
 
short getShort (int columnIndex) throws SQLException
 
int getInt (int columnIndex) throws SQLException
 
long getLong (int columnIndex) throws SQLException
 
float getFloat (int columnIndex) throws SQLException
 
double getDouble (int columnIndex) throws SQLException
 
BigDecimal getBigDecimal (int columnIndex, int scale) throws SQLException
 
byte[] getBytes (int columnIndex) throws SQLException
 
Date getDate (int columnIndex) throws SQLException
 
Time getTime (int columnIndex) throws SQLException
 
Timestamp getTimestamp (int columnIndex) throws SQLException
 
InputStream getAsciiStream (int columnIndex) throws SQLException
 
InputStream getUnicodeStream (int columnIndex) throws SQLException
 
InputStream getBinaryStream (int columnIndex) throws SQLException
 
String getString (String columnLabel) throws SQLException
 
boolean getBoolean (String columnLabel) throws SQLException
 
byte getByte (String columnLabel) throws SQLException
 
short getShort (String columnLabel) throws SQLException
 
int getInt (String columnLabel) throws SQLException
 
long getLong (String columnLabel) throws SQLException
 
float getFloat (String columnLabel) throws SQLException
 
double getDouble (String columnLabel) throws SQLException
 
BigDecimal getBigDecimal (String columnLabel, int scale) throws SQLException
 
byte[] getBytes (String columnLabel) throws SQLException
 
Date getDate (String columnLabel) throws SQLException
 
Time getTime (String columnLabel) throws SQLException
 
Timestamp getTimestamp (String columnLabel) throws SQLException
 
InputStream getAsciiStream (String columnLabel) throws SQLException
 
InputStream getUnicodeStream (String columnLabel) throws SQLException
 
InputStream getBinaryStream (String columnLabel) throws SQLException
 
SQLWarning getWarnings () throws SQLException
 
void clearWarnings () throws SQLException
 
String getCursorName () throws SQLException
 
ResultSetMetaData getMetaData () throws SQLException
 
Object getObject (int columnIndex) throws SQLException
 
Object getObject (String columnLabel) throws SQLException
 
int findColumn (String columnLabel) throws SQLException
 
Reader getCharacterStream (int columnIndex) throws SQLException
 
Reader getCharacterStream (String columnLabel) throws SQLException
 
BigDecimal getBigDecimal (int columnIndex) throws SQLException
 
BigDecimal getBigDecimal (String columnLabel) throws SQLException
 
boolean isBeforeFirst () throws SQLException
 
boolean isAfterLast () throws SQLException
 
boolean isFirst () throws SQLException
 
boolean isLast () throws SQLException
 
void beforeFirst () throws SQLException
 
void afterLast () throws SQLException
 
boolean first () throws SQLException
 
boolean last () throws SQLException
 
int getRow () throws SQLException
 
boolean absolute (int row) throws SQLException
 
boolean relative (int rows) throws SQLException
 
boolean previous () throws SQLException
 
void setFetchDirection (int direction) throws SQLException
 
int getFetchDirection () throws SQLException
 
void setFetchSize (int rows) throws SQLException
 
int getFetchSize () throws SQLException
 
int getType () throws SQLException
 
int getConcurrency () throws SQLException
 
boolean rowUpdated () throws SQLException
 
boolean rowInserted () throws SQLException
 
boolean rowDeleted () throws SQLException
 
void updateNull (int columnIndex) throws SQLException
 
void updateBoolean (int columnIndex, boolean x) throws SQLException
 
void updateByte (int columnIndex, byte x) throws SQLException
 
void updateShort (int columnIndex, short x) throws SQLException
 
void updateInt (int columnIndex, int x) throws SQLException
 
void updateLong (int columnIndex, long x) throws SQLException
 
void updateFloat (int columnIndex, float x) throws SQLException
 
void updateDouble (int columnIndex, double x) throws SQLException
 
void updateBigDecimal (int columnIndex, BigDecimal x) throws SQLException
 
void updateString (int columnIndex, String x) throws SQLException
 
void updateBytes (int columnIndex, byte[] x) throws SQLException
 
void updateDate (int columnIndex, Date x) throws SQLException
 
void updateTime (int columnIndex, Time x) throws SQLException
 
void updateTimestamp (int columnIndex, Timestamp x) throws SQLException
 
void updateAsciiStream (int columnIndex, InputStream x, int length) throws SQLException
 
void updateBinaryStream (int columnIndex, InputStream x, int length) throws SQLException
 
void updateCharacterStream (int columnIndex, Reader x, int length) throws SQLException
 
void updateObject (int columnIndex, Object x, int scaleOrLength) throws SQLException
 
void updateObject (int columnIndex, Object x) throws SQLException
 
void updateNull (String columnLabel) throws SQLException
 
void updateBoolean (String columnLabel, boolean x) throws SQLException
 
void updateByte (String columnLabel, byte x) throws SQLException
 
void updateShort (String columnLabel, short x) throws SQLException
 
void updateInt (String columnLabel, int x) throws SQLException
 
void updateLong (String columnLabel, long x) throws SQLException
 
void updateFloat (String columnLabel, float x) throws SQLException
 
void updateDouble (String columnLabel, double x) throws SQLException
 
void updateBigDecimal (String columnLabel, BigDecimal x) throws SQLException
 
void updateString (String columnLabel, String x) throws SQLException
 
void updateBytes (String columnLabel, byte[] x) throws SQLException
 
void updateDate (String columnLabel, Date x) throws SQLException
 
void updateTime (String columnLabel, Time x) throws SQLException
 
void updateTimestamp (String columnLabel, Timestamp x) throws SQLException
 
void updateAsciiStream (String columnLabel, InputStream x, int length) throws SQLException
 
void updateBinaryStream (String columnLabel, InputStream x, int length) throws SQLException
 
void updateCharacterStream (String columnLabel, Reader reader, int length) throws SQLException
 
void updateObject (String columnLabel, Object x, int scaleOrLength) throws SQLException
 
void updateObject (String columnLabel, Object x) throws SQLException
 
void insertRow () throws SQLException
 
void updateRow () throws SQLException
 
void deleteRow () throws SQLException
 
void refreshRow () throws SQLException
 
void cancelRowUpdates () throws SQLException
 
void moveToInsertRow () throws SQLException
 
void moveToCurrentRow () throws SQLException
 
Statement getStatement () throws SQLException
 
Object getObject (int columnIndex, Map< String, Class<?>> map) throws SQLException
 
Ref getRef (int columnIndex) throws SQLException
 
Blob getBlob (int columnIndex) throws SQLException
 
Clob getClob (int columnIndex) throws SQLException
 
Array getArray (int columnIndex) throws SQLException
 
Object getObject (String columnLabel, Map< String, Class<?>> map) throws SQLException
 
Ref getRef (String columnLabel) throws SQLException
 
Blob getBlob (String columnLabel) throws SQLException
 
Clob getClob (String columnLabel) throws SQLException
 
Array getArray (String columnLabel) throws SQLException
 
Date getDate (int columnIndex, Calendar cal) throws SQLException
 
Date getDate (String columnLabel, Calendar cal) throws SQLException
 
Time getTime (int columnIndex, Calendar cal) throws SQLException
 
Time getTime (String columnLabel, Calendar cal) throws SQLException
 
Timestamp getTimestamp (int columnIndex, Calendar cal) throws SQLException
 
Timestamp getTimestamp (String columnLabel, Calendar cal) throws SQLException
 
URL getURL (int columnIndex) throws SQLException
 
URL getURL (String columnLabel) throws SQLException
 
void updateRef (int columnIndex, Ref x) throws SQLException
 
void updateRef (String columnLabel, Ref x) throws SQLException
 
void updateBlob (int columnIndex, Blob x) throws SQLException
 
void updateBlob (String columnLabel, Blob x) throws SQLException
 
void updateClob (int columnIndex, Clob x) throws SQLException
 
void updateClob (String columnLabel, Clob x) throws SQLException
 
void updateArray (int columnIndex, Array x) throws SQLException
 
void updateArray (String columnLabel, Array x) throws SQLException
 
RowId getRowId (int columnIndex) throws SQLException
 
RowId getRowId (String columnLabel) throws SQLException
 
void updateRowId (int columnIndex, RowId x) throws SQLException
 
void updateRowId (String columnLabel, RowId x) throws SQLException
 
int getHoldability () throws SQLException
 
boolean isClosed () throws SQLException
 
void updateNString (int columnIndex, String nString) throws SQLException
 
void updateNString (String columnLabel, String nString) throws SQLException
 
void updateNClob (int columnIndex, NClob nClob) throws SQLException
 
void updateNClob (String columnLabel, NClob nClob) throws SQLException
 
NClob getNClob (int columnIndex) throws SQLException
 
NClob getNClob (String columnLabel) throws SQLException
 
SQLXML getSQLXML (int columnIndex) throws SQLException
 
SQLXML getSQLXML (String columnLabel) throws SQLException
 
void updateSQLXML (int columnIndex, SQLXML xmlObject) throws SQLException
 
void updateSQLXML (String columnLabel, SQLXML xmlObject) throws SQLException
 
String getNString (int columnIndex) throws SQLException
 
String getNString (String columnLabel) throws SQLException
 
Reader getNCharacterStream (int columnIndex) throws SQLException
 
Reader getNCharacterStream (String columnLabel) throws SQLException
 
void updateNCharacterStream (int columnIndex, Reader x, long length) throws SQLException
 
void updateNCharacterStream (String columnLabel, Reader reader, long length) throws SQLException
 
void updateAsciiStream (int columnIndex, InputStream x, long length) throws SQLException
 
void updateBinaryStream (int columnIndex, InputStream x, long length) throws SQLException
 
void updateCharacterStream (int columnIndex, Reader x, long length) throws SQLException
 
void updateAsciiStream (String columnLabel, InputStream x, long length) throws SQLException
 
void updateBinaryStream (String columnLabel, InputStream x, long length) throws SQLException
 
void updateCharacterStream (String columnLabel, Reader reader, long length) throws SQLException
 
void updateBlob (int columnIndex, InputStream inputStream, long length) throws SQLException
 
void updateBlob (String columnLabel, InputStream inputStream, long length) throws SQLException
 
void updateClob (int columnIndex, Reader reader, long length) throws SQLException
 
void updateClob (String columnLabel, Reader reader, long length) throws SQLException
 
void updateNClob (int columnIndex, Reader reader, long length) throws SQLException
 
void updateNClob (String columnLabel, Reader reader, long length) throws SQLException
 
void updateNCharacterStream (int columnIndex, Reader x) throws SQLException
 
void updateNCharacterStream (String columnLabel, Reader reader) throws SQLException
 
void updateAsciiStream (int columnIndex, InputStream x) throws SQLException
 
void updateBinaryStream (int columnIndex, InputStream x) throws SQLException
 
void updateCharacterStream (int columnIndex, Reader x) throws SQLException
 
void updateAsciiStream (String columnLabel, InputStream x) throws SQLException
 
void updateBinaryStream (String columnLabel, InputStream x) throws SQLException
 
void updateCharacterStream (String columnLabel, Reader reader) throws SQLException
 
void updateBlob (int columnIndex, InputStream inputStream) throws SQLException
 
void updateBlob (String columnLabel, InputStream inputStream) throws SQLException
 
void updateClob (int columnIndex, Reader reader) throws SQLException
 
void updateClob (String columnLabel, Reader reader) throws SQLException
 
void updateNClob (int columnIndex, Reader reader) throws SQLException
 
void updateNClob (String columnLabel, Reader reader) throws SQLException
 
boolean isWrapperFor (Class<?> iface) throws SQLException
 

Package Functions

 HeavyAIResultSet ()
 
public< T > T getObject (int columnIndex, Class< T > type) throws SQLException
 
public< T > T getObject (String columnLabel, Class< T > type) throws SQLException
 
public< T > T unwrap (Class< T > iface) throws SQLException
 

Static Package Attributes

static final Logger logger = LoggerFactory.getLogger(HeavyAIResultSet.class)
 

Private Member Functions

String getStringInternal (int columnIndex) throws SQLException
 
double getDoubleInternal (int columnIndex) throws SQLException
 
Timestamp extract_complex_time (long val, int precision)
 
Timestamp adjust_precision (long val, int precision)
 
long getOffsetFromTZ (long actualmillis, Calendar cal, int precision)
 
Integer findColumnByName (String name) throws SQLException
 
void checkClosed () throws SQLException
 

Private Attributes

TQueryResult sqlResult = null
 
int offset = -1
 
int numOfRecords = 0
 
String sql
 
TRowSet rowSet = null
 
List< TColumnType > rowDesc
 
boolean wasNull = false
 
Map< String, Integer > columnMap
 
int fetchSize = 0
 
SQLWarning warnings = null
 
boolean isClosed = false
 

Detailed Description

Definition at line 41 of file HeavyAIResultSet.java.

Constructor & Destructor Documentation

ai.heavy.jdbc.HeavyAIResultSet.HeavyAIResultSet ( TQueryResult  tsqlResult,
String  sql 
) throws SQLException
inline

Definition at line 55 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.columnMap, ai.heavy.jdbc.HeavyAIResultSet.numOfRecords, ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowDesc, ai.heavy.jdbc.HeavyAIResultSet.rowSet, ai.heavy.jdbc.HeavyAIResultSet.sql, and ai.heavy.jdbc.HeavyAIResultSet.sqlResult.

56  { // logger.debug("Entered "+ sql );
57  sqlResult = tsqlResult;
58  offset = -1;
59  this.sql = sql;
60  rowSet = sqlResult.getRow_set();
61  rowDesc = rowSet.getRow_desc();
62 
63  // in the case of a create (maybe insert) nothing is returned in these field
64  if (rowDesc.isEmpty()) {
65  numOfRecords = 0;
66  return;
67  }
68 
69  rowDesc.get(0).getCol_name();
70 
71  columnMap = new HashMap();
72  int current = 1;
73  for (final TColumnType colType : rowDesc) {
74  columnMap.put(colType.getCol_name(), current);
75  current++;
76  }
77  if (rowSet.columns.isEmpty()) {
78  numOfRecords = 0;
79  } else {
80  numOfRecords = rowSet.getColumns().get(0).getNullsSize();
81  }
82 
83  logger.debug("number of records is " + numOfRecords);
84  // logger.debug("Record is "+ sqlResult.toString());
85  }
Map< String, Integer > columnMap
ai.heavy.jdbc.HeavyAIResultSet.HeavyAIResultSet ( )
inlinepackage

Definition at line 87 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.numOfRecords.

87  {
88  numOfRecords = 0;
89  }

Member Function Documentation

boolean ai.heavy.jdbc.HeavyAIResultSet.absolute ( int  row) throws SQLException
inline

Definition at line 696 of file HeavyAIResultSet.java.

697  { // logger.debug("Entered "+ sql );
698  throw new UnsupportedOperationException("Not supported yet,"
699  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
700  + " class:" + new Throwable().getStackTrace()[0].getClassName()
701  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
702  }
Timestamp ai.heavy.jdbc.HeavyAIResultSet.adjust_precision ( long  val,
int  precision 
)
inlineprivate

Definition at line 364 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.extract_complex_time(), and Integer.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getArray(), and ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

364  {
365  switch (precision) {
366  case 0:
367  return new Timestamp(val * 1000);
368  case 3:
369  return new Timestamp(val);
370  case 6:
371  case 9:
372  return extract_complex_time(val, precision);
373  default:
374  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
375  + "] returned. Valid values 0,3,6,9");
376  }
377  }
Timestamp extract_complex_time(long val, int precision)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void ai.heavy.jdbc.HeavyAIResultSet.afterLast ( ) throws SQLException
inline

Definition at line 664 of file HeavyAIResultSet.java.

664  { // logger.debug("Entered "+ sql );
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.HeavyAIResultSet.beforeFirst ( ) throws SQLException
inline

Definition at line 656 of file HeavyAIResultSet.java.

656  { // logger.debug("Entered "+ sql );
657  throw new UnsupportedOperationException("Not supported yet,"
658  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
659  + " class:" + new Throwable().getStackTrace()[0].getClassName()
660  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
661  }
void ai.heavy.jdbc.HeavyAIResultSet.cancelRowUpdates ( ) throws SQLException
inline

Definition at line 1161 of file HeavyAIResultSet.java.

1161  { // logger.debug("Entered "+ sql );
1162  throw new UnsupportedOperationException("Not supported yet,"
1163  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1164  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1165  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1166  }
void ai.heavy.jdbc.HeavyAIResultSet.checkClosed ( ) throws SQLException
inlineprivate
void ai.heavy.jdbc.HeavyAIResultSet.clearWarnings ( ) throws SQLException
inline

Definition at line 523 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.warnings.

523  { // logger.debug("Entered "+ sql );
524  warnings = null;
525  }
void ai.heavy.jdbc.HeavyAIResultSet.close ( ) throws SQLException
inline

Definition at line 103 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.isClosed(), ai.heavy.jdbc.HeavyAIResultSet.rowDesc, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.sqlResult.

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

103  { // logger.debug("Entered "+ sql );
104  rowDesc = null;
105  rowSet = null;
106  sqlResult = null;
107  isClosed = true;
108  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void ai.heavy.jdbc.HeavyAIResultSet.deleteRow ( ) throws SQLException
inline

Definition at line 1145 of file HeavyAIResultSet.java.

1145  { // logger.debug("Entered "+ sql );
1146  throw new UnsupportedOperationException("Not supported yet,"
1147  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1148  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1149  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1150  }
Timestamp ai.heavy.jdbc.HeavyAIResultSet.extract_complex_time ( long  val,
int  precision 
)
inlineprivate

Definition at line 350 of file HeavyAIResultSet.java.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.adjust_precision().

350  {
351  long scale = (long) Math.pow(10, precision);
352  double nano_part = Math.abs(val) % scale;
353  if (val < 0) nano_part = -nano_part;
354  nano_part = (int) ((nano_part + scale) % scale) * (long) Math.pow(10, 9 - precision);
355  long micro_sec_value = (long) (val / scale);
356  // Round value
357  micro_sec_value = micro_sec_value - ((micro_sec_value < 0 && nano_part > 0) ? 1 : 0);
358  Timestamp tm = new Timestamp(
359  micro_sec_value * 1000); // convert to milli seconds and make a time
360  tm.setNanos((int) (nano_part));
361  return tm;
362  }

+ Here is the caller graph for this function:

int ai.heavy.jdbc.HeavyAIResultSet.findColumn ( String  columnLabel) throws SQLException
inline

Definition at line 588 of file HeavyAIResultSet.java.

589  { // logger.debug("Entered "+ sql );
590  throw new UnsupportedOperationException("Not supported yet,"
591  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
592  + " class:" + new Throwable().getStackTrace()[0].getClassName()
593  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
594  }
Integer ai.heavy.jdbc.HeavyAIResultSet.findColumnByName ( String  name) throws SQLException
inlineprivate

Definition at line 2062 of file HeavyAIResultSet.java.

References Integer, and setup.name.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getArray(), ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal(), ai.heavy.jdbc.HeavyAIResultSet.getBoolean(), ai.heavy.jdbc.HeavyAIResultSet.getDate(), ai.heavy.jdbc.HeavyAIResultSet.getDouble(), ai.heavy.jdbc.HeavyAIResultSet.getFloat(), ai.heavy.jdbc.HeavyAIResultSet.getInt(), ai.heavy.jdbc.HeavyAIResultSet.getLong(), ai.heavy.jdbc.HeavyAIResultSet.getShort(), ai.heavy.jdbc.HeavyAIResultSet.getString(), ai.heavy.jdbc.HeavyAIResultSet.getTime(), and ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

2062  {
2063  Integer colNum = columnMap.get(name);
2064  if (colNum == null) {
2065  throw new SQLException("Could not find the column " + name);
2066  }
2067  return colNum;
2068  }
string name
Definition: setup.in.py:72

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIResultSet.first ( ) throws SQLException
inline

Definition at line 672 of file HeavyAIResultSet.java.

672  { // logger.debug("Entered "+ sql );
673  throw new UnsupportedOperationException("Not supported yet,"
674  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
675  + " class:" + new Throwable().getStackTrace()[0].getClassName()
676  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
677  }
Array ai.heavy.jdbc.HeavyAIResultSet.getArray ( int  columnIndex) throws SQLException
inline

Definition at line 1229 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.adjust_precision(), ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), heavydb.dtypes.Date, Double, Float, Integer, ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowDesc, ai.heavy.jdbc.HeavyAIResultSet.rowSet, heavydb.dtypes.Time, run_benchmark_import.type, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getArray(), ai.heavy.jdbc.HeavyAIResultSet.getObject(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

1230  { // logger.debug("Entered "+ sql );
1231  checkClosed();
1232  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1233  wasNull = true;
1234  return null;
1235  } else {
1236  wasNull = false;
1237  if (!rowDesc.get(columnIndex - 1).col_type.is_array) {
1238  throw new SQLException(
1239  "Column " + rowDesc.get(columnIndex - 1).col_name + " is not an array");
1240  }
1241 
1242  Object[] elements;
1243  int size =
1244  rowSet.columns.get(columnIndex - 1).data.arr_col.get(offset).nulls.size();
1245  switch (rowDesc.get(columnIndex - 1).col_type.type) {
1246  case TINYINT:
1247  elements = new Byte[size];
1248  for (int i = 0; i < size; ++i) {
1249  elements[i] = rowSet.columns.get(columnIndex - 1)
1250  .data.arr_col.get(offset)
1251  .data.int_col.get(i)
1252  .byteValue();
1253  }
1254  break;
1255  case SMALLINT:
1256  elements = new Short[size];
1257  for (int i = 0; i < size; ++i) {
1258  elements[i] = rowSet.columns.get(columnIndex - 1)
1259  .data.arr_col.get(offset)
1260  .data.int_col.get(i)
1261  .shortValue();
1262  }
1263  break;
1264  case INT:
1265  elements = new Integer[size];
1266  for (int i = 0; i < size; ++i) {
1267  elements[i] = rowSet.columns.get(columnIndex - 1)
1268  .data.arr_col.get(offset)
1269  .data.int_col.get(i)
1270  .intValue();
1271  }
1272  break;
1273  case BIGINT:
1274  elements = new Long[size];
1275  for (int i = 0; i < size; ++i) {
1276  elements[i] = rowSet.columns.get(columnIndex - 1)
1277  .data.arr_col.get(offset)
1278  .data.int_col.get(i);
1279  }
1280  break;
1281  case BOOL:
1282  elements = new Boolean[size];
1283  for (int i = 0; i < size; ++i) {
1284  elements[i] = rowSet.columns.get(columnIndex - 1)
1285  .data.arr_col.get(offset)
1286  .data.int_col.get(i)
1287  == 0;
1288  }
1289  break;
1290  case TIME:
1291  elements = new Time[size];
1292  for (int i = 0; i < size; ++i) {
1293  elements[i] = new Time(rowSet.columns.get(columnIndex - 1)
1294  .data.arr_col.get(offset)
1295  .data.int_col.get(i)
1296  * 1000);
1297  }
1298  break;
1299  case TIMESTAMP:
1300  elements = new Timestamp[size];
1301  for (int i = 0; i < size; ++i) {
1302  elements[i] = adjust_precision(rowSet.columns.get(columnIndex - 1)
1303  .data.arr_col.get(offset)
1304  .data.int_col.get(i),
1305  rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision());
1306  }
1307  break;
1308  case DATE:
1309  elements = new Date[size];
1310  for (int i = 0; i < size; ++i) {
1311  elements[i] = new Date(rowSet.columns.get(columnIndex - 1)
1312  .data.arr_col.get(offset)
1313  .data.int_col.get(i)
1314  * 1000);
1315  }
1316  break;
1317  case FLOAT:
1318  elements = new Float[size];
1319  for (int i = 0; i < size; ++i) {
1320  elements[i] = rowSet.columns.get(columnIndex - 1)
1321  .data.arr_col.get(offset)
1322  .data.real_col.get(i)
1323  .floatValue();
1324  }
1325  break;
1326  case DECIMAL:
1327  elements = new BigDecimal[size];
1328  for (int i = 0; i < size; ++i) {
1329  elements[i] = BigDecimal.valueOf(rowSet.columns.get(columnIndex - 1)
1330  .data.arr_col.get(offset)
1331  .data.real_col.get(i));
1332  }
1333  break;
1334  case DOUBLE:
1335  elements = new Double[size];
1336  for (int i = 0; i < size; ++i) {
1337  elements[i] = rowSet.columns.get(columnIndex - 1)
1338  .data.arr_col.get(offset)
1339  .data.real_col.get(i);
1340  }
1341  break;
1342  case STR:
1343  case POINT:
1344  case LINESTRING:
1345  case POLYGON:
1346  case MULTIPOLYGON:
1347  elements = new String[size];
1348  for (int i = 0; i < size; ++i) {
1349  elements[i] = rowSet.columns.get(columnIndex - 1)
1350  .data.arr_col.get(offset)
1351  .data.str_col.get(i);
1352  }
1353  break;
1354  default:
1355  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
1356  }
1357 
1358  for (int i = 0; i < size; ++i) {
1359  if (this.rowSet.columns.get(columnIndex - 1)
1360  .data.arr_col.get(offset)
1361  .nulls.get(i)) {
1362  elements[i] = null;
1363  }
1364  }
1365 
1366  return new HeavyAIArray(rowDesc.get(columnIndex - 1).col_type.type, elements);
1367  }
1368  }
Timestamp adjust_precision(long val, int precision)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Array ai.heavy.jdbc.HeavyAIResultSet.getArray ( String  columnLabel) throws SQLException
inline

Definition at line 1407 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getArray().

1408  { // logger.debug("Entered "+ sql );
1409  return getArray(findColumnByName(columnLabel));
1410  }
Integer findColumnByName(String name)

+ Here is the call graph for this function:

InputStream ai.heavy.jdbc.HeavyAIResultSet.getAsciiStream ( int  columnIndex) throws SQLException
inline

Definition at line 380 of file HeavyAIResultSet.java.

381  { // logger.debug("Entered "+ sql );
382  throw new UnsupportedOperationException("Not supported yet,"
383  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
384  + " class:" + new Throwable().getStackTrace()[0].getClassName()
385  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
386  }
InputStream ai.heavy.jdbc.HeavyAIResultSet.getAsciiStream ( String  columnLabel) throws SQLException
inline

Definition at line 491 of file HeavyAIResultSet.java.

492  { // logger.debug("Entered "+ sql );
493  throw new UnsupportedOperationException("Not supported yet,"
494  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
495  + " class:" + new Throwable().getStackTrace()[0].getClassName()
496  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
497  }
BigDecimal ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal ( int  columnIndex,
int  scale 
) throws SQLException
inline

Definition at line 309 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal().

310  { // logger.debug("Entered "+ sql );
311  checkClosed();
312  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
313  wasNull = true;
314  return null;
315  } else {
316  // assume column is str already for now
317  wasNull = false;
318  return BigDecimal.valueOf(
319  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
320  }
321  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

BigDecimal ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal ( String  columnLabel,
int  scale 
) throws SQLException
inline

Definition at line 458 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal().

459  { // logger.debug("Entered "+ sql );
460  return getBigDecimal(findColumnByName(columnLabel));
461  }
Integer findColumnByName(String name)
BigDecimal getBigDecimal(int columnIndex, int scale)

+ Here is the call graph for this function:

BigDecimal ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal ( int  columnIndex) throws SQLException
inline

Definition at line 615 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

616  { // logger.debug("Entered "+ sql );
617  checkClosed();
618  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
619  wasNull = true;
620  return null;
621  } else {
622  // assume column is str already for now
623  wasNull = false;
624  return BigDecimal.valueOf(
625  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
626  }
627  }

+ Here is the call graph for this function:

BigDecimal ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal ( String  columnLabel) throws SQLException
inline

Definition at line 630 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.columnMap, and ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal().

631  { // logger.debug("Entered "+ sql );
632  return getBigDecimal(columnMap.get(columnLabel));
633  }
BigDecimal getBigDecimal(int columnIndex, int scale)
Map< String, Integer > columnMap

+ Here is the call graph for this function:

InputStream ai.heavy.jdbc.HeavyAIResultSet.getBinaryStream ( int  columnIndex) throws SQLException
inline

Definition at line 398 of file HeavyAIResultSet.java.

399  { // logger.debug("Entered "+ sql );
400  throw new UnsupportedOperationException("Not supported yet,"
401  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
402  + " class:" + new Throwable().getStackTrace()[0].getClassName()
403  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
404  }
InputStream ai.heavy.jdbc.HeavyAIResultSet.getBinaryStream ( String  columnLabel) throws SQLException
inline

Definition at line 509 of file HeavyAIResultSet.java.

510  { // logger.debug("Entered "+ sql );
511  throw new UnsupportedOperationException("Not supported yet,"
512  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
513  + " class:" + new Throwable().getStackTrace()[0].getClassName()
514  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
515  }
Blob ai.heavy.jdbc.HeavyAIResultSet.getBlob ( int  columnIndex) throws SQLException
inline

Definition at line 1211 of file HeavyAIResultSet.java.

1212  { // logger.debug("Entered "+ sql );
1213  throw new UnsupportedOperationException("Not supported yet,"
1214  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1215  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1216  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1217  }
Blob ai.heavy.jdbc.HeavyAIResultSet.getBlob ( String  columnLabel) throws SQLException
inline

Definition at line 1389 of file HeavyAIResultSet.java.

1390  { // logger.debug("Entered "+ sql );
1391  throw new UnsupportedOperationException("Not supported yet,"
1392  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1393  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1394  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1395  }
boolean ai.heavy.jdbc.HeavyAIResultSet.getBoolean ( int  columnIndex) throws SQLException
inline

Definition at line 174 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getBoolean(), ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

175  { // logger.debug("Entered "+ sql );
176  checkClosed();
177  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
178  wasNull = true;
179  return false;
180  } else {
181  // assume column is str already for now
182  wasNull = false;
183  if (rowSet.columns.get(columnIndex - 1).data.int_col.get(offset) == 0) {
184  return false;
185  } else {
186  return true;
187  }
188  }
189  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIResultSet.getBoolean ( String  columnLabel) throws SQLException
inline

Definition at line 413 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getBoolean().

414  { // logger.debug("Entered "+ sql );
415  return getBoolean(findColumnByName(columnLabel));
416  }
Integer findColumnByName(String name)
boolean getBoolean(int columnIndex)

+ Here is the call graph for this function:

byte ai.heavy.jdbc.HeavyAIResultSet.getByte ( int  columnIndex) throws SQLException
inline

Definition at line 192 of file HeavyAIResultSet.java.

193  { // logger.debug("Entered "+ sql );
194  throw new UnsupportedOperationException("Not supported yet,"
195  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
196  + " class:" + new Throwable().getStackTrace()[0].getClassName()
197  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
198  }
byte ai.heavy.jdbc.HeavyAIResultSet.getByte ( String  columnLabel) throws SQLException
inline

Definition at line 419 of file HeavyAIResultSet.java.

420  { // logger.debug("Entered "+ sql );
421  throw new UnsupportedOperationException("Not supported yet,"
422  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
423  + " class:" + new Throwable().getStackTrace()[0].getClassName()
424  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
425  }
byte [] ai.heavy.jdbc.HeavyAIResultSet.getBytes ( int  columnIndex) throws SQLException
inline

Definition at line 324 of file HeavyAIResultSet.java.

325  { // logger.debug("Entered "+ sql );
326  throw new UnsupportedOperationException("Not supported yet,"
327  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
328  + " class:" + new Throwable().getStackTrace()[0].getClassName()
329  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
330  }
byte [] ai.heavy.jdbc.HeavyAIResultSet.getBytes ( String  columnLabel) throws SQLException
inline

Definition at line 464 of file HeavyAIResultSet.java.

465  { // logger.debug("Entered "+ sql );
466  throw new UnsupportedOperationException("Not supported yet,"
467  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
468  + " class:" + new Throwable().getStackTrace()[0].getClassName()
469  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
470  }
Reader ai.heavy.jdbc.HeavyAIResultSet.getCharacterStream ( int  columnIndex) throws SQLException
inline

Definition at line 597 of file HeavyAIResultSet.java.

598  { // logger.debug("Entered "+ sql );
599  throw new UnsupportedOperationException("Not supported yet,"
600  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
601  + " class:" + new Throwable().getStackTrace()[0].getClassName()
602  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
603  }
Reader ai.heavy.jdbc.HeavyAIResultSet.getCharacterStream ( String  columnLabel) throws SQLException
inline

Definition at line 606 of file HeavyAIResultSet.java.

607  { // logger.debug("Entered "+ sql );
608  throw new UnsupportedOperationException("Not supported yet,"
609  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
610  + " class:" + new Throwable().getStackTrace()[0].getClassName()
611  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
612  }
Clob ai.heavy.jdbc.HeavyAIResultSet.getClob ( int  columnIndex) throws SQLException
inline

Definition at line 1220 of file HeavyAIResultSet.java.

1221  { // logger.debug("Entered "+ sql );
1222  throw new UnsupportedOperationException("Not supported yet,"
1223  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1224  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1225  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1226  }
Clob ai.heavy.jdbc.HeavyAIResultSet.getClob ( String  columnLabel) throws SQLException
inline

Definition at line 1398 of file HeavyAIResultSet.java.

1399  { // logger.debug("Entered "+ sql );
1400  throw new UnsupportedOperationException("Not supported yet,"
1401  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1402  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1403  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1404  }
int ai.heavy.jdbc.HeavyAIResultSet.getConcurrency ( ) throws SQLException
inline

Definition at line 755 of file HeavyAIResultSet.java.

755  { // logger.debug("Entered "+ sql );
756  throw new UnsupportedOperationException("Not supported yet,"
757  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
758  + " class:" + new Throwable().getStackTrace()[0].getClassName()
759  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
760  }
String ai.heavy.jdbc.HeavyAIResultSet.getCursorName ( ) throws SQLException
inline

Definition at line 528 of file HeavyAIResultSet.java.

528  { // logger.debug("Entered "+ sql );
529  throw new UnsupportedOperationException("Not supported yet,"
530  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
531  + " class:" + new Throwable().getStackTrace()[0].getClassName()
532  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
533  }
Date ai.heavy.jdbc.HeavyAIResultSet.getDate ( int  columnIndex) throws SQLException
inline

Definition at line 333 of file HeavyAIResultSet.java.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDate(), ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

334  { // logger.debug("Entered "+ sql );
335  return getDate(columnIndex, null);
336  }

+ Here is the caller graph for this function:

Date ai.heavy.jdbc.HeavyAIResultSet.getDate ( String  columnLabel) throws SQLException
inline

Definition at line 473 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.getDate().

474  { // logger.debug("Entered "+ sql );
475  return getDate(columnLabel, null);
476  }

+ Here is the call graph for this function:

Date ai.heavy.jdbc.HeavyAIResultSet.getDate ( int  columnIndex,
Calendar  cal 
) throws SQLException
inline

Definition at line 1438 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), heavydb.dtypes.Date, ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

1438  {
1439  checkClosed();
1440  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1441  wasNull = true;
1442  return null;
1443  } else {
1444  // assume column is str already for now
1445  wasNull = false;
1446  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1447  if (cal != null) {
1448  val += getOffsetFromTZ(val, cal, 0);
1449  }
1450  Date d = new Date(val * 1000);
1451  return d;
1452  }
1453  }
long getOffsetFromTZ(long actualmillis, Calendar cal, int precision)

+ Here is the call graph for this function:

Date ai.heavy.jdbc.HeavyAIResultSet.getDate ( String  columnLabel,
Calendar  cal 
) throws SQLException
inline

Definition at line 1456 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getDate().

1456  {
1457  return getDate(findColumnByName(columnLabel), cal);
1458  }
Integer findColumnByName(String name)

+ Here is the call graph for this function:

double ai.heavy.jdbc.HeavyAIResultSet.getDouble ( int  columnIndex) throws SQLException
inline

Definition at line 259 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, run_benchmark_import.type, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDouble(), ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

260  { // logger.debug("Entered "+ sql );
261  checkClosed();
262  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
263  wasNull = true;
264  return 0;
265  } else {
266  // assume column is str already for now
267  wasNull = false;
268  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
269 
270  if (type == TDatumType.DOUBLE) {
271  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
272  } else {
273  return getDoubleInternal(columnIndex);
274  }
275  }
276  }
double getDoubleInternal(int columnIndex)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

double ai.heavy.jdbc.HeavyAIResultSet.getDouble ( String  columnLabel) throws SQLException
inline

Definition at line 452 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getDouble().

453  { // logger.debug("Entered "+ sql );
454  return getDouble(findColumnByName(columnLabel));
455  }
double getDouble(int columnIndex)
Integer findColumnByName(String name)

+ Here is the call graph for this function:

double ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal ( int  columnIndex) throws SQLException
inlineprivate

Definition at line 278 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.getBoolean(), ai.heavy.jdbc.HeavyAIResultSet.getDate(), ai.heavy.jdbc.HeavyAIResultSet.getDouble(), ai.heavy.jdbc.HeavyAIResultSet.getFloat(), ai.heavy.jdbc.HeavyAIResultSet.getInt(), ai.heavy.jdbc.HeavyAIResultSet.getLong(), ai.heavy.jdbc.HeavyAIResultSet.getString(), ai.heavy.jdbc.HeavyAIResultSet.getTime(), ai.heavy.jdbc.HeavyAIResultSet.getTimestamp(), and run_benchmark_import.type.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDouble().

278  {
279  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
280  switch (type) {
281  case TINYINT:
282  case SMALLINT:
283  case INT:
284  return (double) getInt(columnIndex);
285  case BIGINT:
286  return (double) getLong(columnIndex);
287  case FLOAT:
288  return (double) getFloat(columnIndex);
289  case DECIMAL:
290  return (double) getFloat(columnIndex);
291  case DOUBLE:
292  return getDouble(columnIndex);
293  case STR:
294  return Double.valueOf(getString(columnIndex));
295  case TIME:
296  return (double) getTime(columnIndex).getTime();
297  case TIMESTAMP:
298  return (double) getTimestamp(columnIndex).getTime();
299  case DATE:
300  return (double) getDate(columnIndex).getTime();
301  case BOOL:
302  return (double) (getBoolean(columnIndex) ? 1 : 0);
303  default:
304  throw new AssertionError(type.name());
305  }
306  }
double getDouble(int columnIndex)
String getString(int columnIndex)
float getFloat(int columnIndex)
Timestamp getTimestamp(int columnIndex)
boolean getBoolean(int columnIndex)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 731 of file HeavyAIResultSet.java.

731  { // logger.debug("Entered "+ sql );
732  return FETCH_FORWARD;
733  }
int ai.heavy.jdbc.HeavyAIResultSet.getFetchSize ( ) throws SQLException
inline

Definition at line 742 of file HeavyAIResultSet.java.

742  { // logger.debug("Entered "+ sql );
743  throw new UnsupportedOperationException("Not supported yet,"
744  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
745  + " class:" + new Throwable().getStackTrace()[0].getClassName()
746  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
747  }
float ai.heavy.jdbc.HeavyAIResultSet.getFloat ( int  columnIndex) throws SQLException
inline

Definition at line 245 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getFloat(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

246  { // logger.debug("Entered "+ sql );
247  checkClosed();
248  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
249  wasNull = true;
250  return 0;
251  } else {
252  // assume column is str already for now
253  wasNull = false;
254  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset).floatValue();
255  }
256  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

float ai.heavy.jdbc.HeavyAIResultSet.getFloat ( String  columnLabel) throws SQLException
inline

Definition at line 446 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getFloat().

447  { // logger.debug("Entered "+ sql );
448  return getFloat(findColumnByName(columnLabel));
449  }
Integer findColumnByName(String name)
float getFloat(int columnIndex)

+ Here is the call graph for this function:

int ai.heavy.jdbc.HeavyAIResultSet.getHoldability ( ) throws SQLException
inline

Definition at line 1636 of file HeavyAIResultSet.java.

1636  { // logger.debug("Entered "+ sql );
1637  throw new UnsupportedOperationException("Not supported yet,"
1638  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1639  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1640  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1641  }
int ai.heavy.jdbc.HeavyAIResultSet.getInt ( int  columnIndex) throws SQLException
inline

Definition at line 216 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getInt(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

217  { // logger.debug("Entered "+ sql );
218  checkClosed();
219  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
220  wasNull = true;
221  return 0;
222  } else {
223  // assume column is str already for now
224  wasNull = false;
225  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
226  return lObj.intValue();
227  }
228  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

int ai.heavy.jdbc.HeavyAIResultSet.getInt ( String  columnLabel) throws SQLException
inline

Definition at line 434 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getInt().

435  { // logger.debug("Entered "+ sql );
436  return getInt(findColumnByName(columnLabel));
437  }
Integer findColumnByName(String name)

+ Here is the call graph for this function:

long ai.heavy.jdbc.HeavyAIResultSet.getLong ( int  columnIndex) throws SQLException
inline

Definition at line 231 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getLong(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

232  { // logger.debug("Entered "+ sql );
233  checkClosed();
234  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
235  wasNull = true;
236  return 0;
237  } else {
238  // assume column is str already for now
239  wasNull = false;
240  return rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
241  }
242  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

long ai.heavy.jdbc.HeavyAIResultSet.getLong ( String  columnLabel) throws SQLException
inline

Definition at line 440 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getLong().

441  { // logger.debug("Entered "+ sql );
442  return getLong(findColumnByName(columnLabel));
443  }
Integer findColumnByName(String name)

+ Here is the call graph for this function:

ResultSetMetaData ai.heavy.jdbc.HeavyAIResultSet.getMetaData ( ) throws SQLException
inline

Definition at line 536 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.sql, and ai.heavy.jdbc.HeavyAIResultSet.sqlResult.

537  { // logger.debug("Entered "+ sql );
538  checkClosed();
539  return new HeavyAIResultSetMetaData(sqlResult, sql);
540  }

+ Here is the call graph for this function:

Reader ai.heavy.jdbc.HeavyAIResultSet.getNCharacterStream ( int  columnIndex) throws SQLException
inline

Definition at line 1757 of file HeavyAIResultSet.java.

1758  { // logger.debug("Entered "+ sql );
1759  throw new UnsupportedOperationException("Not supported yet,"
1760  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1761  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1762  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1763  }
Reader ai.heavy.jdbc.HeavyAIResultSet.getNCharacterStream ( String  columnLabel) throws SQLException
inline

Definition at line 1766 of file HeavyAIResultSet.java.

1767  { // logger.debug("Entered "+ sql );
1768  throw new UnsupportedOperationException("Not supported yet,"
1769  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1770  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1771  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1772  }
NClob ai.heavy.jdbc.HeavyAIResultSet.getNClob ( int  columnIndex) throws SQLException
inline

Definition at line 1685 of file HeavyAIResultSet.java.

1686  { // logger.debug("Entered "+ sql );
1687  throw new UnsupportedOperationException("Not supported yet,"
1688  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1689  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1690  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1691  }
NClob ai.heavy.jdbc.HeavyAIResultSet.getNClob ( String  columnLabel) throws SQLException
inline

Definition at line 1694 of file HeavyAIResultSet.java.

1695  { // logger.debug("Entered "+ sql );
1696  throw new UnsupportedOperationException("Not supported yet,"
1697  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1698  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1699  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1700  }
String ai.heavy.jdbc.HeavyAIResultSet.getNString ( int  columnIndex) throws SQLException
inline

Definition at line 1739 of file HeavyAIResultSet.java.

1740  { // logger.debug("Entered "+ sql );
1741  throw new UnsupportedOperationException("Not supported yet,"
1742  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1743  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1744  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1745  }
String ai.heavy.jdbc.HeavyAIResultSet.getNString ( String  columnLabel) throws SQLException
inline

Definition at line 1748 of file HeavyAIResultSet.java.

1749  { // logger.debug("Entered "+ sql );
1750  throw new UnsupportedOperationException("Not supported yet,"
1751  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1752  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1753  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1754  }
Object ai.heavy.jdbc.HeavyAIResultSet.getObject ( int  columnIndex) throws SQLException
inline

Definition at line 543 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.getArray(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowDesc, ai.heavy.jdbc.HeavyAIResultSet.rowSet, run_benchmark_import.type, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getObject(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

544  { // logger.debug("Entered "+ sql );
545  checkClosed();
546  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
547  wasNull = true;
548  return null;
549  } else {
550  wasNull = false;
551  if (rowDesc.get(columnIndex - 1).col_type.is_array) {
552  return getArray(columnIndex);
553  }
554 
555  switch (rowDesc.get(columnIndex - 1).col_type.type) {
556  case TINYINT:
557  case SMALLINT:
558  case INT:
559  case BIGINT:
560  case BOOL:
561  case TIME:
562  case TIMESTAMP:
563  case DATE:
564  return this.rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
565  case FLOAT:
566  case DECIMAL:
567  case DOUBLE:
568  return this.rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
569  case STR:
570  case POINT:
571  case LINESTRING:
572  case POLYGON:
573  case MULTIPOLYGON:
574  return this.rowSet.columns.get(columnIndex - 1).data.str_col.get(offset);
575  default:
576  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
577  }
578  }
579  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Object ai.heavy.jdbc.HeavyAIResultSet.getObject ( String  columnLabel) throws SQLException
inline

Definition at line 582 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.columnMap, and ai.heavy.jdbc.HeavyAIResultSet.getObject().

583  { // logger.debug("Entered "+ sql );
584  return getObject(columnMap.get(columnLabel));
585  }
Object getObject(int columnIndex)
Map< String, Integer > columnMap

+ Here is the call graph for this function:

Object ai.heavy.jdbc.HeavyAIResultSet.getObject ( int  columnIndex,
Map< String, Class<?>>  map 
) throws SQLException
inline

Definition at line 1193 of file HeavyAIResultSet.java.

1194  { // logger.debug("Entered "+ sql );
1195  throw new UnsupportedOperationException("Not supported yet,"
1196  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1197  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1198  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1199  }
Object ai.heavy.jdbc.HeavyAIResultSet.getObject ( String  columnLabel,
Map< String, Class<?>>  map 
) throws SQLException
inline

Definition at line 1371 of file HeavyAIResultSet.java.

1372  { // logger.debug("Entered "+ sql );
1373  throw new UnsupportedOperationException("Not supported yet,"
1374  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1375  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1376  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1377  }
public<T> T ai.heavy.jdbc.HeavyAIResultSet.getObject ( int  columnIndex,
Class< T >  type 
) throws SQLException
inlinepackage

Definition at line 2027 of file HeavyAIResultSet.java.

2028  { // logger.debug("Entered "+ sql );
2029  throw new UnsupportedOperationException("Not supported yet,"
2030  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2031  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2032  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2033  }
public<T> T ai.heavy.jdbc.HeavyAIResultSet.getObject ( String  columnLabel,
Class< T >  type 
) throws SQLException
inlinepackage

Definition at line 2036 of file HeavyAIResultSet.java.

2037  { // logger.debug("Entered "+ sql );
2038  throw new UnsupportedOperationException("Not supported yet,"
2039  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2040  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2041  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2042  }
long ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ ( long  actualmillis,
Calendar  cal,
int  precision 
)
inlineprivate

Definition at line 1415 of file HeavyAIResultSet.java.

References Integer, and ai.heavy.jdbc.HeavyAIResultSet.offset.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDate(), ai.heavy.jdbc.HeavyAIResultSet.getTime(), and ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

1415  {
1416  long offset;
1417  if (cal.getTimeZone() != null) {
1418  offset = cal.getTimeZone().getOffset(actualmillis);
1419  } else {
1420  offset = Calendar.getInstance().getTimeZone().getOffset(actualmillis);
1421  }
1422  switch (precision) {
1423  case 0:
1424  return offset / 1000;
1425  case 3:
1426  return offset;
1427  case 6:
1428  return offset * 1000;
1429  case 9:
1430  return offset * 1000000;
1431  default:
1432  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
1433  + "] returned. Valid values 0,3,6,9");
1434  }
1435  }

+ Here is the caller graph for this function:

Ref ai.heavy.jdbc.HeavyAIResultSet.getRef ( int  columnIndex) throws SQLException
inline

Definition at line 1202 of file HeavyAIResultSet.java.

1203  { // logger.debug("Entered "+ sql );
1204  throw new UnsupportedOperationException("Not supported yet,"
1205  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1206  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1207  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1208  }
Ref ai.heavy.jdbc.HeavyAIResultSet.getRef ( String  columnLabel) throws SQLException
inline

Definition at line 1380 of file HeavyAIResultSet.java.

1381  { // logger.debug("Entered "+ sql );
1382  throw new UnsupportedOperationException("Not supported yet,"
1383  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1384  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1385  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1386  }
int ai.heavy.jdbc.HeavyAIResultSet.getRow ( ) throws SQLException
inline

Definition at line 688 of file HeavyAIResultSet.java.

688  { // logger.debug("Entered "+ sql );
689  throw new UnsupportedOperationException("Not supported yet,"
690  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
691  + " class:" + new Throwable().getStackTrace()[0].getClassName()
692  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
693  }
RowId ai.heavy.jdbc.HeavyAIResultSet.getRowId ( int  columnIndex) throws SQLException
inline

Definition at line 1600 of file HeavyAIResultSet.java.

1601  { // logger.debug("Entered "+ sql );
1602  throw new UnsupportedOperationException("Not supported yet,"
1603  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1604  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1605  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1606  }
RowId ai.heavy.jdbc.HeavyAIResultSet.getRowId ( String  columnLabel) throws SQLException
inline

Definition at line 1609 of file HeavyAIResultSet.java.

1610  { // logger.debug("Entered "+ sql );
1611  throw new UnsupportedOperationException("Not supported yet,"
1612  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1613  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1614  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1615  }
short ai.heavy.jdbc.HeavyAIResultSet.getShort ( int  columnIndex) throws SQLException
inline

Definition at line 201 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getShort().

202  { // logger.debug("Entered "+ sql );
203  checkClosed();
204  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
205  wasNull = true;
206  return 0;
207  } else {
208  // assume column is str already for now
209  wasNull = false;
210  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
211  return lObj.shortValue();
212  }
213  }

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

short ai.heavy.jdbc.HeavyAIResultSet.getShort ( String  columnLabel) throws SQLException
inline

Definition at line 428 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getShort().

429  { // logger.debug("Entered "+ sql );
430  return getShort(findColumnByName(columnLabel));
431  }
Integer findColumnByName(String name)
short getShort(int columnIndex)

+ Here is the call graph for this function:

SQLXML ai.heavy.jdbc.HeavyAIResultSet.getSQLXML ( int  columnIndex) throws SQLException
inline

Definition at line 1703 of file HeavyAIResultSet.java.

1704  { // logger.debug("Entered "+ sql );
1705  throw new UnsupportedOperationException("Not supported yet,"
1706  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1707  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1708  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1709  }
SQLXML ai.heavy.jdbc.HeavyAIResultSet.getSQLXML ( String  columnLabel) throws SQLException
inline

Definition at line 1712 of file HeavyAIResultSet.java.

1713  { // logger.debug("Entered "+ sql );
1714  throw new UnsupportedOperationException("Not supported yet,"
1715  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1716  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1717  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1718  }
Statement ai.heavy.jdbc.HeavyAIResultSet.getStatement ( ) throws SQLException
inline

Definition at line 1185 of file HeavyAIResultSet.java.

1185  { // logger.debug("Entered "+ sql );
1186  throw new UnsupportedOperationException("Not supported yet,"
1187  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1188  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1189  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1190  }
String ai.heavy.jdbc.HeavyAIResultSet.getString ( int  columnIndex) throws SQLException
inline

Definition at line 116 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.getStringInternal(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, ai.heavy.jdbc.HeavyAIResultSet.sqlResult, run_benchmark_import.type, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getString(), and ai.heavy.jdbc.HeavyAIResultSet.getStringInternal().

116  {
117  checkClosed();
118  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
119  wasNull = true;
120  return null;
121  } else {
122  wasNull = false;
123  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
124 
125  if (type == TDatumType.STR
126  && !sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.is_array) {
127  return rowSet.columns.get(columnIndex - 1).data.str_col.get(offset);
128  } else {
129  return getStringInternal(columnIndex);
130  }
131  }
132  }
String getStringInternal(int columnIndex)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

String ai.heavy.jdbc.HeavyAIResultSet.getString ( String  columnLabel) throws SQLException
inline

Definition at line 407 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getString().

408  { // logger.debug("Entered "+ sql );
409  return getString(findColumnByName(columnLabel));
410  }
String getString(int columnIndex)
Integer findColumnByName(String name)

+ Here is the call graph for this function:

String ai.heavy.jdbc.HeavyAIResultSet.getStringInternal ( int  columnIndex) throws SQLException
inlineprivate

Definition at line 134 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.getArray(), ai.heavy.jdbc.HeavyAIResultSet.getBoolean(), ai.heavy.jdbc.HeavyAIResultSet.getDate(), ai.heavy.jdbc.HeavyAIResultSet.getDouble(), ai.heavy.jdbc.HeavyAIResultSet.getFloat(), ai.heavy.jdbc.HeavyAIResultSet.getInt(), ai.heavy.jdbc.HeavyAIResultSet.getLong(), ai.heavy.jdbc.HeavyAIResultSet.getObject(), ai.heavy.jdbc.HeavyAIResultSet.getString(), ai.heavy.jdbc.HeavyAIResultSet.getTime(), ai.heavy.jdbc.HeavyAIResultSet.getTimestamp(), ai.heavy.jdbc.HeavyAIResultSet.sqlResult, and run_benchmark_import.type.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getString().

134  {
135  if (sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.is_array) {
136  return getArray(columnIndex).toString();
137  }
138 
139  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
140  switch (type) {
141  case TINYINT:
142  case SMALLINT:
143  case INT:
144  return String.valueOf(getInt(columnIndex));
145  case BIGINT:
146  return String.valueOf(getLong(columnIndex));
147  case FLOAT:
148  return String.valueOf(getFloat(columnIndex));
149  case DECIMAL:
150  return String.valueOf(getFloat(columnIndex));
151  case DOUBLE:
152  return String.valueOf(getDouble(columnIndex));
153  case STR:
154  return getString(columnIndex);
155  case TIME:
156  return getTime(columnIndex).toString();
157  case TIMESTAMP:
158  return getTimestamp(columnIndex).toString();
159  case DATE:
160  return getDate(columnIndex).toString();
161  case BOOL:
162  return getBoolean(columnIndex) ? "1" : "0";
163  case POINT:
164  case LINESTRING:
165  case POLYGON:
166  case MULTIPOLYGON:
167  return (String) getObject(columnIndex);
168  default:
169  throw new AssertionError(type.name());
170  }
171  }
double getDouble(int columnIndex)
Object getObject(int columnIndex)
String getString(int columnIndex)
float getFloat(int columnIndex)
Timestamp getTimestamp(int columnIndex)
boolean getBoolean(int columnIndex)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Time ai.heavy.jdbc.HeavyAIResultSet.getTime ( int  columnIndex) throws SQLException
inline

Definition at line 339 of file HeavyAIResultSet.java.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getStringInternal(), and ai.heavy.jdbc.HeavyAIResultSet.getTime().

340  { // logger.debug("Entered "+ sql );
341  return getTime(columnIndex, null);
342  }

+ Here is the caller graph for this function:

Time ai.heavy.jdbc.HeavyAIResultSet.getTime ( String  columnLabel) throws SQLException
inline

Definition at line 479 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.getTime().

480  { // logger.debug("Entered "+ sql );
481  return getTime(columnLabel, null);
482  }

+ Here is the call graph for this function:

Time ai.heavy.jdbc.HeavyAIResultSet.getTime ( int  columnIndex,
Calendar  cal 
) throws SQLException
inline

Definition at line 1461 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, heavydb.dtypes.Time, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

1462  { // logger.debug("Entered "+ sql );
1463  checkClosed();
1464  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1465  wasNull = true;
1466  return null;
1467  } else {
1468  // assume column is str already for now
1469  wasNull = false;
1470  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1471  if (cal != null) {
1472  val += getOffsetFromTZ(val, cal, 0);
1473  }
1474  return new Time(val * 1000);
1475  }
1476  }
long getOffsetFromTZ(long actualmillis, Calendar cal, int precision)

+ Here is the call graph for this function:

Time ai.heavy.jdbc.HeavyAIResultSet.getTime ( String  columnLabel,
Calendar  cal 
) throws SQLException
inline

Definition at line 1479 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getTime().

1480  { // logger.debug("Entered "+ sql );
1481  return getTime(findColumnByName(columnLabel), cal);
1482  }
Integer findColumnByName(String name)

+ Here is the call graph for this function:

Timestamp ai.heavy.jdbc.HeavyAIResultSet.getTimestamp ( int  columnIndex) throws SQLException
inline

Definition at line 345 of file HeavyAIResultSet.java.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal(), ai.heavy.jdbc.HeavyAIResultSet.getStringInternal(), and ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

346  { // logger.debug("Entered "+ sql );
347  return getTimestamp(columnIndex, null);
348  }
Timestamp getTimestamp(int columnIndex)

+ Here is the caller graph for this function:

Timestamp ai.heavy.jdbc.HeavyAIResultSet.getTimestamp ( String  columnLabel) throws SQLException
inline

Definition at line 485 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

486  { // logger.debug("Entered "+ sql );
487  return getTimestamp(columnLabel, null);
488  }
Timestamp getTimestamp(int columnIndex)

+ Here is the call graph for this function:

Timestamp ai.heavy.jdbc.HeavyAIResultSet.getTimestamp ( int  columnIndex,
Calendar  cal 
) throws SQLException
inline

Definition at line 1485 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.adjust_precision(), ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ(), ai.heavy.jdbc.HeavyAIResultSet.offset, ai.heavy.jdbc.HeavyAIResultSet.rowSet, and ai.heavy.jdbc.HeavyAIResultSet.wasNull().

1486  { // logger.debug("Entered "+ sql );
1487  checkClosed();
1488  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1489  wasNull = true;
1490  return null;
1491  } else {
1492  // assume column is str already for now
1493  wasNull = false;
1494  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1495  int precision = rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision();
1496  if (cal != null) {
1497  val += getOffsetFromTZ(val, cal, precision);
1498  }
1499  return adjust_precision(val, precision);
1500  }
1501  }
Timestamp adjust_precision(long val, int precision)
long getOffsetFromTZ(long actualmillis, Calendar cal, int precision)

+ Here is the call graph for this function:

Timestamp ai.heavy.jdbc.HeavyAIResultSet.getTimestamp ( String  columnLabel,
Calendar  cal 
) throws SQLException
inline

Definition at line 1504 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.findColumnByName(), and ai.heavy.jdbc.HeavyAIResultSet.getTimestamp().

1505  { // logger.debug("Entered "+ sql );
1506  return getTimestamp(findColumnByName(columnLabel), cal);
1507  }
Integer findColumnByName(String name)
Timestamp getTimestamp(int columnIndex)

+ Here is the call graph for this function:

int ai.heavy.jdbc.HeavyAIResultSet.getType ( ) throws SQLException
inline

Definition at line 750 of file HeavyAIResultSet.java.

750  { // logger.debug("Entered "+ sql );
751  return TYPE_FORWARD_ONLY;
752  }
InputStream ai.heavy.jdbc.HeavyAIResultSet.getUnicodeStream ( int  columnIndex) throws SQLException
inline

Definition at line 389 of file HeavyAIResultSet.java.

390  { // logger.debug("Entered "+ sql );
391  throw new UnsupportedOperationException("Not supported yet,"
392  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
393  + " class:" + new Throwable().getStackTrace()[0].getClassName()
394  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
395  }
InputStream ai.heavy.jdbc.HeavyAIResultSet.getUnicodeStream ( String  columnLabel) throws SQLException
inline

Definition at line 500 of file HeavyAIResultSet.java.

501  { // logger.debug("Entered "+ sql );
502  throw new UnsupportedOperationException("Not supported yet,"
503  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
504  + " class:" + new Throwable().getStackTrace()[0].getClassName()
505  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
506  }
URL ai.heavy.jdbc.HeavyAIResultSet.getURL ( int  columnIndex) throws SQLException
inline

Definition at line 1510 of file HeavyAIResultSet.java.

1511  { // logger.debug("Entered "+ sql );
1512  throw new UnsupportedOperationException("Not supported yet,"
1513  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1514  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1515  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1516  }
URL ai.heavy.jdbc.HeavyAIResultSet.getURL ( String  columnLabel) throws SQLException
inline

Definition at line 1519 of file HeavyAIResultSet.java.

1520  { // logger.debug("Entered "+ sql );
1521  throw new UnsupportedOperationException("Not supported yet,"
1522  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1523  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1524  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1525  }
SQLWarning ai.heavy.jdbc.HeavyAIResultSet.getWarnings ( ) throws SQLException
inline

Definition at line 518 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.warnings.

518  { // logger.debug("Entered "+ sql );
519  return warnings;
520  }
void ai.heavy.jdbc.HeavyAIResultSet.insertRow ( ) throws SQLException
inline

Definition at line 1129 of file HeavyAIResultSet.java.

1129  { // logger.debug("Entered "+ sql );
1130  throw new UnsupportedOperationException("Not supported yet,"
1131  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1132  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1133  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1134  }
boolean ai.heavy.jdbc.HeavyAIResultSet.isAfterLast ( ) throws SQLException
inline

Definition at line 641 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.numOfRecords, and ai.heavy.jdbc.HeavyAIResultSet.offset.

641  { // logger.debug("Entered "+ sql );
642  return offset == numOfRecords;
643  }
boolean ai.heavy.jdbc.HeavyAIResultSet.isBeforeFirst ( ) throws SQLException
inline

Definition at line 636 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.offset.

636  { // logger.debug("Entered "+ sql );
637  return offset == -1;
638  }
boolean ai.heavy.jdbc.HeavyAIResultSet.isClosed ( ) throws SQLException
inline

Definition at line 1644 of file HeavyAIResultSet.java.

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

1644  { // logger.debug("Entered "+ sql );
1645  return isClosed;
1646  }

+ Here is the caller graph for this function:

boolean ai.heavy.jdbc.HeavyAIResultSet.isFirst ( ) throws SQLException
inline

Definition at line 646 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.offset.

646  { // logger.debug("Entered "+ sql );
647  return offset == 0;
648  }
boolean ai.heavy.jdbc.HeavyAIResultSet.isLast ( ) throws SQLException
inline

Definition at line 651 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.numOfRecords, and ai.heavy.jdbc.HeavyAIResultSet.offset.

651  { // logger.debug("Entered "+ sql );
652  return offset == numOfRecords - 1;
653  }
boolean ai.heavy.jdbc.HeavyAIResultSet.isWrapperFor ( Class<?>  iface) throws SQLException
inline

Definition at line 2054 of file HeavyAIResultSet.java.

2055  { // logger.debug("Entered "+ sql );
2056  throw new UnsupportedOperationException("Not supported yet,"
2057  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2058  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2059  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2060  }
boolean ai.heavy.jdbc.HeavyAIResultSet.last ( ) throws SQLException
inline

Definition at line 680 of file HeavyAIResultSet.java.

680  { // logger.debug("Entered "+ sql );
681  throw new UnsupportedOperationException("Not supported yet,"
682  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
683  + " class:" + new Throwable().getStackTrace()[0].getClassName()
684  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
685  }
void ai.heavy.jdbc.HeavyAIResultSet.moveToCurrentRow ( ) throws SQLException
inline

Definition at line 1177 of file HeavyAIResultSet.java.

1177  { // logger.debug("Entered "+ sql );
1178  throw new UnsupportedOperationException("Not supported yet,"
1179  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1180  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1181  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1182  }
void ai.heavy.jdbc.HeavyAIResultSet.moveToInsertRow ( ) throws SQLException
inline

Definition at line 1169 of file HeavyAIResultSet.java.

1169  { // logger.debug("Entered "+ sql );
1170  throw new UnsupportedOperationException("Not supported yet,"
1171  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1172  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1173  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1174  }
boolean ai.heavy.jdbc.HeavyAIResultSet.next ( ) throws SQLException
inline

Definition at line 92 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.checkClosed(), ai.heavy.jdbc.HeavyAIResultSet.numOfRecords, and ai.heavy.jdbc.HeavyAIResultSet.offset.

92  { // logger.debug("Entered "+ sql );
93  checkClosed();
94  // do real work
95  offset++;
96  if (offset < numOfRecords) {
97  return true;
98  }
99  return false;
100  }

+ Here is the call graph for this function:

boolean ai.heavy.jdbc.HeavyAIResultSet.previous ( ) throws SQLException
inline

Definition at line 714 of file HeavyAIResultSet.java.

714  { // logger.debug("Entered "+ sql );
715  throw new UnsupportedOperationException("Not supported yet,"
716  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
717  + " class:" + new Throwable().getStackTrace()[0].getClassName()
718  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
719  }
void ai.heavy.jdbc.HeavyAIResultSet.refreshRow ( ) throws SQLException
inline

Definition at line 1153 of file HeavyAIResultSet.java.

1153  { // logger.debug("Entered "+ sql );
1154  throw new UnsupportedOperationException("Not supported yet,"
1155  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1156  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1157  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1158  }
boolean ai.heavy.jdbc.HeavyAIResultSet.relative ( int  rows) throws SQLException
inline

Definition at line 705 of file HeavyAIResultSet.java.

706  { // logger.debug("Entered "+ sql );
707  throw new UnsupportedOperationException("Not supported yet,"
708  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
709  + " class:" + new Throwable().getStackTrace()[0].getClassName()
710  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
711  }
boolean ai.heavy.jdbc.HeavyAIResultSet.rowDeleted ( ) throws SQLException
inline

Definition at line 779 of file HeavyAIResultSet.java.

779  { // logger.debug("Entered "+ sql );
780  throw new UnsupportedOperationException("Not supported yet,"
781  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
782  + " class:" + new Throwable().getStackTrace()[0].getClassName()
783  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
784  }
boolean ai.heavy.jdbc.HeavyAIResultSet.rowInserted ( ) throws SQLException
inline

Definition at line 771 of file HeavyAIResultSet.java.

771  { // logger.debug("Entered "+ sql );
772  throw new UnsupportedOperationException("Not supported yet,"
773  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
774  + " class:" + new Throwable().getStackTrace()[0].getClassName()
775  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
776  }
boolean ai.heavy.jdbc.HeavyAIResultSet.rowUpdated ( ) throws SQLException
inline

Definition at line 763 of file HeavyAIResultSet.java.

763  { // logger.debug("Entered "+ sql );
764  throw new UnsupportedOperationException("Not supported yet,"
765  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
766  + " class:" + new Throwable().getStackTrace()[0].getClassName()
767  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
768  }
void ai.heavy.jdbc.HeavyAIResultSet.setFetchDirection ( int  direction) throws SQLException
inline

Definition at line 722 of file HeavyAIResultSet.java.

723  { // logger.debug("Entered "+ sql );
724  throw new UnsupportedOperationException("Not supported yet,"
725  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
726  + " class:" + new Throwable().getStackTrace()[0].getClassName()
727  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
728  }
void ai.heavy.jdbc.HeavyAIResultSet.setFetchSize ( int  rows) throws SQLException
inline

Definition at line 736 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.fetchSize.

737  { // logger.debug("Entered "+ sql );
738  fetchSize = rows;
739  }
public<T> T ai.heavy.jdbc.HeavyAIResultSet.unwrap ( Class< T >  iface) throws SQLException
inlinepackage

Definition at line 2045 of file HeavyAIResultSet.java.

2046  { // logger.debug("Entered "+ sql );
2047  throw new UnsupportedOperationException("Not supported yet,"
2048  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2049  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2050  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2051  }
void ai.heavy.jdbc.HeavyAIResultSet.updateArray ( int  columnIndex,
Array  x 
) throws SQLException
inline

Definition at line 1582 of file HeavyAIResultSet.java.

1583  { // logger.debug("Entered "+ sql );
1584  throw new UnsupportedOperationException("Not supported yet,"
1585  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1586  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1587  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1588  }
void ai.heavy.jdbc.HeavyAIResultSet.updateArray ( String  columnLabel,
Array  x 
) throws SQLException
inline

Definition at line 1591 of file HeavyAIResultSet.java.

1592  { // logger.debug("Entered "+ sql );
1593  throw new UnsupportedOperationException("Not supported yet,"
1594  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1595  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1596  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1597  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( int  columnIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 913 of file HeavyAIResultSet.java.

914  { // logger.debug("Entered "+ sql );
915  throw new UnsupportedOperationException("Not supported yet,"
916  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
917  + " class:" + new Throwable().getStackTrace()[0].getClassName()
918  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
919  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( String  columnLabel,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 1084 of file HeavyAIResultSet.java.

1085  { // logger.debug("Entered "+ sql );
1086  throw new UnsupportedOperationException("Not supported yet,"
1087  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1088  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1089  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1090  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( int  columnIndex,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 1793 of file HeavyAIResultSet.java.

1794  { // logger.debug("Entered "+ sql );
1795  throw new UnsupportedOperationException("Not supported yet,"
1796  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1797  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1798  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1799  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( String  columnLabel,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 1820 of file HeavyAIResultSet.java.

1821  { // logger.debug("Entered "+ sql );
1822  throw new UnsupportedOperationException("Not supported yet,"
1823  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1824  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1825  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1826  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( int  columnIndex,
InputStream  x 
) throws SQLException
inline

Definition at line 1919 of file HeavyAIResultSet.java.

1920  { // logger.debug("Entered "+ sql );
1921  throw new UnsupportedOperationException("Not supported yet,"
1922  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1923  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1924  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1925  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( String  columnLabel,
InputStream  x 
) throws SQLException
inline

Definition at line 1946 of file HeavyAIResultSet.java.

1947  { // logger.debug("Entered "+ sql );
1948  throw new UnsupportedOperationException("Not supported yet,"
1949  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1950  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1951  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1952  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBigDecimal ( int  columnIndex,
BigDecimal  x 
) throws SQLException
inline

Definition at line 859 of file HeavyAIResultSet.java.

860  { // logger.debug("Entered "+ sql );
861  throw new UnsupportedOperationException("Not supported yet,"
862  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
863  + " class:" + new Throwable().getStackTrace()[0].getClassName()
864  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
865  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBigDecimal ( String  columnLabel,
BigDecimal  x 
) throws SQLException
inline

Definition at line 1030 of file HeavyAIResultSet.java.

1031  { // logger.debug("Entered "+ sql );
1032  throw new UnsupportedOperationException("Not supported yet,"
1033  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1034  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1035  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1036  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( int  columnIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 922 of file HeavyAIResultSet.java.

923  { // logger.debug("Entered "+ sql );
924  throw new UnsupportedOperationException("Not supported yet,"
925  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
926  + " class:" + new Throwable().getStackTrace()[0].getClassName()
927  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
928  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( String  columnLabel,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 1093 of file HeavyAIResultSet.java.

1094  { // logger.debug("Entered "+ sql );
1095  throw new UnsupportedOperationException("Not supported yet,"
1096  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1097  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1098  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1099  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( int  columnIndex,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 1802 of file HeavyAIResultSet.java.

1803  { // logger.debug("Entered "+ sql );
1804  throw new UnsupportedOperationException("Not supported yet,"
1805  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1806  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1807  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1808  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( String  columnLabel,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 1829 of file HeavyAIResultSet.java.

1830  { // logger.debug("Entered "+ sql );
1831  throw new UnsupportedOperationException("Not supported yet,"
1832  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1833  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1834  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1835  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( int  columnIndex,
InputStream  x 
) throws SQLException
inline

Definition at line 1928 of file HeavyAIResultSet.java.

1929  { // logger.debug("Entered "+ sql );
1930  throw new UnsupportedOperationException("Not supported yet,"
1931  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1932  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1933  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1934  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( String  columnLabel,
InputStream  x 
) throws SQLException
inline

Definition at line 1955 of file HeavyAIResultSet.java.

1956  { // logger.debug("Entered "+ sql );
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  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( int  columnIndex,
Blob  x 
) throws SQLException
inline

Definition at line 1546 of file HeavyAIResultSet.java.

1547  { // logger.debug("Entered "+ sql );
1548  throw new UnsupportedOperationException("Not supported yet,"
1549  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1550  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1551  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1552  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
Blob  x 
) throws SQLException
inline

Definition at line 1555 of file HeavyAIResultSet.java.

1556  { // logger.debug("Entered "+ sql );
1557  throw new UnsupportedOperationException("Not supported yet,"
1558  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1559  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1560  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1561  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( int  columnIndex,
InputStream  inputStream,
long  length 
) throws SQLException
inline

Definition at line 1847 of file HeavyAIResultSet.java.

1848  { // logger.debug("Entered "+ sql );
1849  throw new UnsupportedOperationException("Not supported yet,"
1850  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1851  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1852  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1853  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
InputStream  inputStream,
long  length 
) throws SQLException
inline

Definition at line 1856 of file HeavyAIResultSet.java.

1857  { // logger.debug("Entered "+ sql );
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  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( int  columnIndex,
InputStream  inputStream 
) throws SQLException
inline

Definition at line 1973 of file HeavyAIResultSet.java.

1974  { // logger.debug("Entered "+ sql );
1975  throw new UnsupportedOperationException("Not supported yet,"
1976  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1977  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1978  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1979  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
InputStream  inputStream 
) throws SQLException
inline

Definition at line 1982 of file HeavyAIResultSet.java.

1983  { // logger.debug("Entered "+ sql );
1984  throw new UnsupportedOperationException("Not supported yet,"
1985  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1986  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1987  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1988  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBoolean ( int  columnIndex,
boolean  x 
) throws SQLException
inline

Definition at line 796 of file HeavyAIResultSet.java.

797  { // logger.debug("Entered "+ sql );
798  throw new UnsupportedOperationException("Not supported yet,"
799  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
800  + " class:" + new Throwable().getStackTrace()[0].getClassName()
801  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
802  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBoolean ( String  columnLabel,
boolean  x 
) throws SQLException
inline

Definition at line 967 of file HeavyAIResultSet.java.

968  { // logger.debug("Entered "+ sql );
969  throw new UnsupportedOperationException("Not supported yet,"
970  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
971  + " class:" + new Throwable().getStackTrace()[0].getClassName()
972  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
973  }
void ai.heavy.jdbc.HeavyAIResultSet.updateByte ( int  columnIndex,
byte  x 
) throws SQLException
inline

Definition at line 805 of file HeavyAIResultSet.java.

806  { // logger.debug("Entered "+ sql );
807  throw new UnsupportedOperationException("Not supported yet,"
808  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
809  + " class:" + new Throwable().getStackTrace()[0].getClassName()
810  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
811  }
void ai.heavy.jdbc.HeavyAIResultSet.updateByte ( String  columnLabel,
byte  x 
) throws SQLException
inline

Definition at line 976 of file HeavyAIResultSet.java.

977  { // logger.debug("Entered "+ sql );
978  throw new UnsupportedOperationException("Not supported yet,"
979  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
980  + " class:" + new Throwable().getStackTrace()[0].getClassName()
981  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
982  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBytes ( int  columnIndex,
byte[]  x 
) throws SQLException
inline

Definition at line 877 of file HeavyAIResultSet.java.

878  { // logger.debug("Entered "+ sql );
879  throw new UnsupportedOperationException("Not supported yet,"
880  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
881  + " class:" + new Throwable().getStackTrace()[0].getClassName()
882  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
883  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBytes ( String  columnLabel,
byte[]  x 
) throws SQLException
inline

Definition at line 1048 of file HeavyAIResultSet.java.

1049  { // logger.debug("Entered "+ sql );
1050  throw new UnsupportedOperationException("Not supported yet,"
1051  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1052  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1053  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1054  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( int  columnIndex,
Reader  x,
int  length 
) throws SQLException
inline

Definition at line 931 of file HeavyAIResultSet.java.

932  { // logger.debug("Entered "+ sql );
933  throw new UnsupportedOperationException("Not supported yet,"
934  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
935  + " class:" + new Throwable().getStackTrace()[0].getClassName()
936  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
937  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( String  columnLabel,
Reader  reader,
int  length 
) throws SQLException
inline

Definition at line 1102 of file HeavyAIResultSet.java.

1103  { // logger.debug("Entered "+ sql );
1104  throw new UnsupportedOperationException("Not supported yet,"
1105  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1106  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1107  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1108  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( int  columnIndex,
Reader  x,
long  length 
) throws SQLException
inline

Definition at line 1811 of file HeavyAIResultSet.java.

1812  { // logger.debug("Entered "+ sql );
1813  throw new UnsupportedOperationException("Not supported yet,"
1814  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1815  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1816  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1817  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1838 of file HeavyAIResultSet.java.

1839  { // logger.debug("Entered "+ sql );
1840  throw new UnsupportedOperationException("Not supported yet,"
1841  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1842  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1843  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1844  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( int  columnIndex,
Reader  x 
) throws SQLException
inline

Definition at line 1937 of file HeavyAIResultSet.java.

1938  { // logger.debug("Entered "+ sql );
1939  throw new UnsupportedOperationException("Not supported yet,"
1940  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1941  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1942  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1943  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 1964 of file HeavyAIResultSet.java.

1965  { // logger.debug("Entered "+ sql );
1966  throw new UnsupportedOperationException("Not supported yet,"
1967  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1968  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1969  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1970  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Clob  x 
) throws SQLException
inline

Definition at line 1564 of file HeavyAIResultSet.java.

1565  { // logger.debug("Entered "+ sql );
1566  throw new UnsupportedOperationException("Not supported yet,"
1567  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1568  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1569  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1570  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Clob  x 
) throws SQLException
inline

Definition at line 1573 of file HeavyAIResultSet.java.

1574  { // logger.debug("Entered "+ sql );
1575  throw new UnsupportedOperationException("Not supported yet,"
1576  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1577  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1578  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1579  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1865 of file HeavyAIResultSet.java.

1866  { // logger.debug("Entered "+ sql );
1867  throw new UnsupportedOperationException("Not supported yet,"
1868  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1869  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1870  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1871  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1874 of file HeavyAIResultSet.java.

1875  { // logger.debug("Entered "+ sql );
1876  throw new UnsupportedOperationException("Not supported yet,"
1877  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1878  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1879  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1880  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 1991 of file HeavyAIResultSet.java.

1992  { // logger.debug("Entered "+ sql );
1993  throw new UnsupportedOperationException("Not supported yet,"
1994  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1995  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1996  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1997  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 2000 of file HeavyAIResultSet.java.

2001  { // logger.debug("Entered "+ sql );
2002  throw new UnsupportedOperationException("Not supported yet,"
2003  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2004  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2005  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2006  }
void ai.heavy.jdbc.HeavyAIResultSet.updateDate ( int  columnIndex,
Date  x 
) throws SQLException
inline

Definition at line 886 of file HeavyAIResultSet.java.

887  { // logger.debug("Entered "+ sql );
888  throw new UnsupportedOperationException("Not supported yet,"
889  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
890  + " class:" + new Throwable().getStackTrace()[0].getClassName()
891  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
892  }
void ai.heavy.jdbc.HeavyAIResultSet.updateDate ( String  columnLabel,
Date  x 
) throws SQLException
inline

Definition at line 1057 of file HeavyAIResultSet.java.

1058  { // logger.debug("Entered "+ sql );
1059  throw new UnsupportedOperationException("Not supported yet,"
1060  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1061  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1062  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1063  }
void ai.heavy.jdbc.HeavyAIResultSet.updateDouble ( int  columnIndex,
double  x 
) throws SQLException
inline

Definition at line 850 of file HeavyAIResultSet.java.

851  { // logger.debug("Entered "+ sql );
852  throw new UnsupportedOperationException("Not supported yet,"
853  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
854  + " class:" + new Throwable().getStackTrace()[0].getClassName()
855  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
856  }
void ai.heavy.jdbc.HeavyAIResultSet.updateDouble ( String  columnLabel,
double  x 
) throws SQLException
inline

Definition at line 1021 of file HeavyAIResultSet.java.

1022  { // logger.debug("Entered "+ sql );
1023  throw new UnsupportedOperationException("Not supported yet,"
1024  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1025  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1026  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1027  }
void ai.heavy.jdbc.HeavyAIResultSet.updateFloat ( int  columnIndex,
float  x 
) throws SQLException
inline

Definition at line 841 of file HeavyAIResultSet.java.

842  { // logger.debug("Entered "+ sql );
843  throw new UnsupportedOperationException("Not supported yet,"
844  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
845  + " class:" + new Throwable().getStackTrace()[0].getClassName()
846  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
847  }
void ai.heavy.jdbc.HeavyAIResultSet.updateFloat ( String  columnLabel,
float  x 
) throws SQLException
inline

Definition at line 1012 of file HeavyAIResultSet.java.

1013  { // logger.debug("Entered "+ sql );
1014  throw new UnsupportedOperationException("Not supported yet,"
1015  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1016  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1017  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1018  }
void ai.heavy.jdbc.HeavyAIResultSet.updateInt ( int  columnIndex,
int  x 
) throws SQLException
inline

Definition at line 823 of file HeavyAIResultSet.java.

824  { // logger.debug("Entered "+ sql );
825  throw new UnsupportedOperationException("Not supported yet,"
826  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
827  + " class:" + new Throwable().getStackTrace()[0].getClassName()
828  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
829  }
void ai.heavy.jdbc.HeavyAIResultSet.updateInt ( String  columnLabel,
int  x 
) throws SQLException
inline

Definition at line 994 of file HeavyAIResultSet.java.

995  { // logger.debug("Entered "+ sql );
996  throw new UnsupportedOperationException("Not supported yet,"
997  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
998  + " class:" + new Throwable().getStackTrace()[0].getClassName()
999  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1000  }
void ai.heavy.jdbc.HeavyAIResultSet.updateLong ( int  columnIndex,
long  x 
) throws SQLException
inline

Definition at line 832 of file HeavyAIResultSet.java.

833  { // logger.debug("Entered "+ sql );
834  throw new UnsupportedOperationException("Not supported yet,"
835  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
836  + " class:" + new Throwable().getStackTrace()[0].getClassName()
837  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
838  }
void ai.heavy.jdbc.HeavyAIResultSet.updateLong ( String  columnLabel,
long  x 
) throws SQLException
inline

Definition at line 1003 of file HeavyAIResultSet.java.

1004  { // logger.debug("Entered "+ sql );
1005  throw new UnsupportedOperationException("Not supported yet,"
1006  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1007  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1008  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1009  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( int  columnIndex,
Reader  x,
long  length 
) throws SQLException
inline

Definition at line 1775 of file HeavyAIResultSet.java.

1776  { // logger.debug("Entered "+ sql );
1777  throw new UnsupportedOperationException("Not supported yet,"
1778  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1779  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1780  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1781  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1784 of file HeavyAIResultSet.java.

1785  { // logger.debug("Entered "+ sql );
1786  throw new UnsupportedOperationException("Not supported yet,"
1787  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1788  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1789  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1790  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( int  columnIndex,
Reader  x 
) throws SQLException
inline

Definition at line 1901 of file HeavyAIResultSet.java.

1902  { // logger.debug("Entered "+ sql );
1903  throw new UnsupportedOperationException("Not supported yet,"
1904  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1905  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1906  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1907  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 1910 of file HeavyAIResultSet.java.

1911  { // logger.debug("Entered "+ sql );
1912  throw new UnsupportedOperationException("Not supported yet,"
1913  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1914  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1915  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1916  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
NClob  nClob 
) throws SQLException
inline

Definition at line 1667 of file HeavyAIResultSet.java.

1668  { // logger.debug("Entered "+ sql );
1669  throw new UnsupportedOperationException("Not supported yet,"
1670  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1671  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1672  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1673  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
NClob  nClob 
) throws SQLException
inline

Definition at line 1676 of file HeavyAIResultSet.java.

1677  { // logger.debug("Entered "+ sql );
1678  throw new UnsupportedOperationException("Not supported yet,"
1679  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1680  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1681  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1682  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1883 of file HeavyAIResultSet.java.

1884  { // logger.debug("Entered "+ sql );
1885  throw new UnsupportedOperationException("Not supported yet,"
1886  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1887  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1888  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1889  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1892 of file HeavyAIResultSet.java.

1893  { // logger.debug("Entered "+ sql );
1894  throw new UnsupportedOperationException("Not supported yet,"
1895  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1896  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1897  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1898  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 2009 of file HeavyAIResultSet.java.

2010  { // logger.debug("Entered "+ sql );
2011  throw new UnsupportedOperationException("Not supported yet,"
2012  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2013  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2014  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2015  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 2018 of file HeavyAIResultSet.java.

2019  { // logger.debug("Entered "+ sql );
2020  throw new UnsupportedOperationException("Not supported yet,"
2021  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2022  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2023  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2024  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNString ( int  columnIndex,
String  nString 
) throws SQLException
inline

Definition at line 1649 of file HeavyAIResultSet.java.

1650  { // logger.debug("Entered "+ sql );
1651  throw new UnsupportedOperationException("Not supported yet,"
1652  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1653  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1654  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1655  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNString ( String  columnLabel,
String  nString 
) throws SQLException
inline

Definition at line 1658 of file HeavyAIResultSet.java.

1659  { // logger.debug("Entered "+ sql );
1660  throw new UnsupportedOperationException("Not supported yet,"
1661  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1662  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1663  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1664  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNull ( int  columnIndex) throws SQLException
inline

Definition at line 787 of file HeavyAIResultSet.java.

788  { // logger.debug("Entered "+ sql );
789  throw new UnsupportedOperationException("Not supported yet,"
790  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
791  + " class:" + new Throwable().getStackTrace()[0].getClassName()
792  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
793  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNull ( String  columnLabel) throws SQLException
inline

Definition at line 958 of file HeavyAIResultSet.java.

959  { // logger.debug("Entered "+ sql );
960  throw new UnsupportedOperationException("Not supported yet,"
961  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
962  + " class:" + new Throwable().getStackTrace()[0].getClassName()
963  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
964  }
void ai.heavy.jdbc.HeavyAIResultSet.updateObject ( int  columnIndex,
Object  x,
int  scaleOrLength 
) throws SQLException
inline

Definition at line 940 of file HeavyAIResultSet.java.

941  { // logger.debug("Entered "+ sql );
942  throw new UnsupportedOperationException("Not supported yet,"
943  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
944  + " class:" + new Throwable().getStackTrace()[0].getClassName()
945  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
946  }
void ai.heavy.jdbc.HeavyAIResultSet.updateObject ( int  columnIndex,
Object  x 
) throws SQLException
inline

Definition at line 949 of file HeavyAIResultSet.java.

950  { // logger.debug("Entered "+ sql );
951  throw new UnsupportedOperationException("Not supported yet,"
952  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
953  + " class:" + new Throwable().getStackTrace()[0].getClassName()
954  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
955  }
void ai.heavy.jdbc.HeavyAIResultSet.updateObject ( String  columnLabel,
Object  x,
int  scaleOrLength 
) throws SQLException
inline

Definition at line 1111 of file HeavyAIResultSet.java.

1112  { // logger.debug("Entered "+ sql );
1113  throw new UnsupportedOperationException("Not supported yet,"
1114  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1115  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1116  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1117  }
void ai.heavy.jdbc.HeavyAIResultSet.updateObject ( String  columnLabel,
Object  x 
) throws SQLException
inline

Definition at line 1120 of file HeavyAIResultSet.java.

1121  { // logger.debug("Entered "+ sql );
1122  throw new UnsupportedOperationException("Not supported yet,"
1123  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1124  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1125  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1126  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRef ( int  columnIndex,
Ref  x 
) throws SQLException
inline

Definition at line 1528 of file HeavyAIResultSet.java.

1529  { // logger.debug("Entered "+ sql );
1530  throw new UnsupportedOperationException("Not supported yet,"
1531  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1532  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1533  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1534  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRef ( String  columnLabel,
Ref  x 
) throws SQLException
inline

Definition at line 1537 of file HeavyAIResultSet.java.

1538  { // logger.debug("Entered "+ sql );
1539  throw new UnsupportedOperationException("Not supported yet,"
1540  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1541  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1542  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1543  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRow ( ) throws SQLException
inline

Definition at line 1137 of file HeavyAIResultSet.java.

1137  { // logger.debug("Entered "+ sql );
1138  throw new UnsupportedOperationException("Not supported yet,"
1139  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1140  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1141  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1142  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRowId ( int  columnIndex,
RowId  x 
) throws SQLException
inline

Definition at line 1618 of file HeavyAIResultSet.java.

1619  { // logger.debug("Entered "+ sql );
1620  throw new UnsupportedOperationException("Not supported yet,"
1621  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1622  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1623  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1624  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRowId ( String  columnLabel,
RowId  x 
) throws SQLException
inline

Definition at line 1627 of file HeavyAIResultSet.java.

1628  { // logger.debug("Entered "+ sql );
1629  throw new UnsupportedOperationException("Not supported yet,"
1630  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1631  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1632  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1633  }
void ai.heavy.jdbc.HeavyAIResultSet.updateShort ( int  columnIndex,
short  x 
) throws SQLException
inline

Definition at line 814 of file HeavyAIResultSet.java.

815  { // logger.debug("Entered "+ sql );
816  throw new UnsupportedOperationException("Not supported yet,"
817  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
818  + " class:" + new Throwable().getStackTrace()[0].getClassName()
819  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
820  }
void ai.heavy.jdbc.HeavyAIResultSet.updateShort ( String  columnLabel,
short  x 
) throws SQLException
inline

Definition at line 985 of file HeavyAIResultSet.java.

986  { // logger.debug("Entered "+ sql );
987  throw new UnsupportedOperationException("Not supported yet,"
988  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
989  + " class:" + new Throwable().getStackTrace()[0].getClassName()
990  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
991  }
void ai.heavy.jdbc.HeavyAIResultSet.updateSQLXML ( int  columnIndex,
SQLXML  xmlObject 
) throws SQLException
inline

Definition at line 1721 of file HeavyAIResultSet.java.

1722  { // logger.debug("Entered "+ sql );
1723  throw new UnsupportedOperationException("Not supported yet,"
1724  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1725  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1726  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1727  }
void ai.heavy.jdbc.HeavyAIResultSet.updateSQLXML ( String  columnLabel,
SQLXML  xmlObject 
) throws SQLException
inline

Definition at line 1730 of file HeavyAIResultSet.java.

1731  { // logger.debug("Entered "+ sql );
1732  throw new UnsupportedOperationException("Not supported yet,"
1733  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1734  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1735  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1736  }
void ai.heavy.jdbc.HeavyAIResultSet.updateString ( int  columnIndex,
String  x 
) throws SQLException
inline

Definition at line 868 of file HeavyAIResultSet.java.

869  { // logger.debug("Entered "+ sql );
870  throw new UnsupportedOperationException("Not supported yet,"
871  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
872  + " class:" + new Throwable().getStackTrace()[0].getClassName()
873  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
874  }
void ai.heavy.jdbc.HeavyAIResultSet.updateString ( String  columnLabel,
String  x 
) throws SQLException
inline

Definition at line 1039 of file HeavyAIResultSet.java.

1040  { // logger.debug("Entered "+ sql );
1041  throw new UnsupportedOperationException("Not supported yet,"
1042  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1043  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1044  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1045  }
void ai.heavy.jdbc.HeavyAIResultSet.updateTime ( int  columnIndex,
Time  x 
) throws SQLException
inline

Definition at line 895 of file HeavyAIResultSet.java.

896  { // logger.debug("Entered "+ sql );
897  throw new UnsupportedOperationException("Not supported yet,"
898  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
899  + " class:" + new Throwable().getStackTrace()[0].getClassName()
900  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
901  }
void ai.heavy.jdbc.HeavyAIResultSet.updateTime ( String  columnLabel,
Time  x 
) throws SQLException
inline

Definition at line 1066 of file HeavyAIResultSet.java.

1067  { // logger.debug("Entered "+ sql );
1068  throw new UnsupportedOperationException("Not supported yet,"
1069  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1070  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1071  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1072  }
void ai.heavy.jdbc.HeavyAIResultSet.updateTimestamp ( int  columnIndex,
Timestamp  x 
) throws SQLException
inline

Definition at line 904 of file HeavyAIResultSet.java.

905  { // logger.debug("Entered "+ sql );
906  throw new UnsupportedOperationException("Not supported yet,"
907  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
908  + " class:" + new Throwable().getStackTrace()[0].getClassName()
909  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
910  }
void ai.heavy.jdbc.HeavyAIResultSet.updateTimestamp ( String  columnLabel,
Timestamp  x 
) throws SQLException
inline

Definition at line 1075 of file HeavyAIResultSet.java.

1076  { // logger.debug("Entered "+ sql );
1077  throw new UnsupportedOperationException("Not supported yet,"
1078  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1079  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1080  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1081  }

Member Data Documentation

Map<String, Integer> ai.heavy.jdbc.HeavyAIResultSet.columnMap
private
int ai.heavy.jdbc.HeavyAIResultSet.fetchSize = 0
private

Definition at line 51 of file HeavyAIResultSet.java.

Referenced by ai.heavy.jdbc.HeavyAIResultSet.setFetchSize().

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

Definition at line 53 of file HeavyAIResultSet.java.

final Logger ai.heavy.jdbc.HeavyAIResultSet.logger = LoggerFactory.getLogger(HeavyAIResultSet.class)
staticpackage

Definition at line 42 of file HeavyAIResultSet.java.

SQLWarning ai.heavy.jdbc.HeavyAIResultSet.warnings = null
private
boolean ai.heavy.jdbc.HeavyAIResultSet.wasNull = false
private

Definition at line 49 of file HeavyAIResultSet.java.


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