OmniSciDB  ca0c39ec8f
 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 700 of file HeavyAIResultSet.java.

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

Definition at line 366 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().

366  {
367  switch (precision) {
368  case 0:
369  return new Timestamp(val * 1000);
370  case 3:
371  return new Timestamp(val);
372  case 6:
373  case 9:
374  return extract_complex_time(val, precision);
375  default:
376  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
377  + "] returned. Valid values 0,3,6,9");
378  }
379  }
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 668 of file HeavyAIResultSet.java.

668  { // logger.debug("Entered "+ sql );
669  throw new UnsupportedOperationException("Not supported yet,"
670  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
671  + " class:" + new Throwable().getStackTrace()[0].getClassName()
672  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
673  }
void ai.heavy.jdbc.HeavyAIResultSet.beforeFirst ( ) throws SQLException
inline

Definition at line 660 of file HeavyAIResultSet.java.

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

Definition at line 1165 of file HeavyAIResultSet.java.

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

Definition at line 525 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.warnings.

525  { // logger.debug("Entered "+ sql );
526  warnings = null;
527  }
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 1149 of file HeavyAIResultSet.java.

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

Definition at line 352 of file HeavyAIResultSet.java.

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

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

+ Here is the caller graph for this function:

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

Definition at line 592 of file HeavyAIResultSet.java.

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

Definition at line 2068 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().

2068  {
2069  Integer colNum = columnMap.get(name);
2070  if (colNum == null) {
2071  throw new SQLException("Could not find the column " + name);
2072  }
2073  return colNum;
2074  }
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 676 of file HeavyAIResultSet.java.

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

Definition at line 1233 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().

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

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

1414  { // logger.debug("Entered "+ sql );
1415  return getArray(findColumnByName(columnLabel));
1416  }
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 382 of file HeavyAIResultSet.java.

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

Definition at line 493 of file HeavyAIResultSet.java.

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

Definition at line 311 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().

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

+ 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 460 of file HeavyAIResultSet.java.

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

461  { // logger.debug("Entered "+ sql );
462  return getBigDecimal(findColumnByName(columnLabel));
463  }
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 619 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().

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

+ Here is the call graph for this function:

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

Definition at line 634 of file HeavyAIResultSet.java.

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

635  { // logger.debug("Entered "+ sql );
636  return getBigDecimal(columnMap.get(columnLabel));
637  }
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 400 of file HeavyAIResultSet.java.

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

Definition at line 511 of file HeavyAIResultSet.java.

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

Definition at line 1215 of file HeavyAIResultSet.java.

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

Definition at line 1395 of file HeavyAIResultSet.java.

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

Definition at line 176 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().

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

+ 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 415 of file HeavyAIResultSet.java.

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

416  { // logger.debug("Entered "+ sql );
417  return getBoolean(findColumnByName(columnLabel));
418  }
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 194 of file HeavyAIResultSet.java.

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

Definition at line 421 of file HeavyAIResultSet.java.

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

Definition at line 326 of file HeavyAIResultSet.java.

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

Definition at line 466 of file HeavyAIResultSet.java.

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

Definition at line 601 of file HeavyAIResultSet.java.

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

Definition at line 610 of file HeavyAIResultSet.java.

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

Definition at line 1224 of file HeavyAIResultSet.java.

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

Definition at line 1404 of file HeavyAIResultSet.java.

1405  { // logger.debug("Entered "+ sql );
1406  throw new UnsupportedOperationException("Not supported yet,"
1407  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1408  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1409  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1410  }
int ai.heavy.jdbc.HeavyAIResultSet.getConcurrency ( ) throws SQLException
inline

Definition at line 759 of file HeavyAIResultSet.java.

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

Definition at line 530 of file HeavyAIResultSet.java.

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

Definition at line 335 of file HeavyAIResultSet.java.

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

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

+ Here is the caller graph for this function:

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

Definition at line 475 of file HeavyAIResultSet.java.

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

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

+ Here is the call graph for this function:

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

Definition at line 1444 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().

1444  {
1445  checkClosed();
1446  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1447  wasNull = true;
1448  return null;
1449  } else {
1450  // assume column is str already for now
1451  wasNull = false;
1452  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1453  if (cal != null) {
1454  val += getOffsetFromTZ(val, cal, 0);
1455  }
1456  Date d = new Date(val * 1000);
1457  return d;
1458  }
1459  }
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 1462 of file HeavyAIResultSet.java.

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

1462  {
1463  return getDate(findColumnByName(columnLabel), cal);
1464  }
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 261 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().

262  { // logger.debug("Entered "+ sql );
263  checkClosed();
264  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
265  wasNull = true;
266  return 0;
267  } else {
268  // assume column is str already for now
269  wasNull = false;
270  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
271 
272  if (type == TDatumType.DOUBLE) {
273  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
274  } else {
275  return getDoubleInternal(columnIndex);
276  }
277  }
278  }
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 454 of file HeavyAIResultSet.java.

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

455  { // logger.debug("Entered "+ sql );
456  return getDouble(findColumnByName(columnLabel));
457  }
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 280 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().

280  {
281  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
282  switch (type) {
283  case TINYINT:
284  case SMALLINT:
285  case INT:
286  return (double) getInt(columnIndex);
287  case BIGINT:
288  return (double) getLong(columnIndex);
289  case FLOAT:
290  return (double) getFloat(columnIndex);
291  case DECIMAL:
292  return (double) getFloat(columnIndex);
293  case DOUBLE:
294  return getDouble(columnIndex);
295  case STR:
296  return Double.valueOf(getString(columnIndex));
297  case TIME:
298  return (double) getTime(columnIndex).getTime();
299  case TIMESTAMP:
300  return (double) getTimestamp(columnIndex).getTime();
301  case DATE:
302  return (double) getDate(columnIndex).getTime();
303  case BOOL:
304  return (double) (getBoolean(columnIndex) ? 1 : 0);
305  default:
306  throw new AssertionError(type.name());
307  }
308  }
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 735 of file HeavyAIResultSet.java.

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

Definition at line 746 of file HeavyAIResultSet.java.

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

Definition at line 247 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().

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

+ 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 448 of file HeavyAIResultSet.java.

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

449  { // logger.debug("Entered "+ sql );
450  return getFloat(findColumnByName(columnLabel));
451  }
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 1642 of file HeavyAIResultSet.java.

1642  { // logger.debug("Entered "+ sql );
1643  throw new UnsupportedOperationException("Not supported yet,"
1644  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1645  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1646  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1647  }
int ai.heavy.jdbc.HeavyAIResultSet.getInt ( int  columnIndex) throws SQLException
inline

Definition at line 218 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().

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

+ 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 436 of file HeavyAIResultSet.java.

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

437  { // logger.debug("Entered "+ sql );
438  return getInt(findColumnByName(columnLabel));
439  }
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 233 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().

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

+ 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 442 of file HeavyAIResultSet.java.

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

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

+ Here is the call graph for this function:

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

Definition at line 538 of file HeavyAIResultSet.java.

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

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

+ Here is the call graph for this function:

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

Definition at line 1763 of file HeavyAIResultSet.java.

1764  { // logger.debug("Entered "+ sql );
1765  throw new UnsupportedOperationException("Not supported yet,"
1766  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1767  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1768  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1769  }
Reader ai.heavy.jdbc.HeavyAIResultSet.getNCharacterStream ( String  columnLabel) throws SQLException
inline

Definition at line 1772 of file HeavyAIResultSet.java.

1773  { // logger.debug("Entered "+ sql );
1774  throw new UnsupportedOperationException("Not supported yet,"
1775  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1776  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1777  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1778  }
NClob ai.heavy.jdbc.HeavyAIResultSet.getNClob ( int  columnIndex) throws SQLException
inline

Definition at line 1691 of file HeavyAIResultSet.java.

1692  { // logger.debug("Entered "+ sql );
1693  throw new UnsupportedOperationException("Not supported yet,"
1694  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1695  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1696  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1697  }
NClob ai.heavy.jdbc.HeavyAIResultSet.getNClob ( String  columnLabel) throws SQLException
inline

Definition at line 1700 of file HeavyAIResultSet.java.

1701  { // logger.debug("Entered "+ sql );
1702  throw new UnsupportedOperationException("Not supported yet,"
1703  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1704  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1705  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1706  }
String ai.heavy.jdbc.HeavyAIResultSet.getNString ( int  columnIndex) throws SQLException
inline

Definition at line 1745 of file HeavyAIResultSet.java.

1746  { // logger.debug("Entered "+ sql );
1747  throw new UnsupportedOperationException("Not supported yet,"
1748  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1749  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1750  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1751  }
String ai.heavy.jdbc.HeavyAIResultSet.getNString ( String  columnLabel) throws SQLException
inline

Definition at line 1754 of file HeavyAIResultSet.java.

1755  { // logger.debug("Entered "+ sql );
1756  throw new UnsupportedOperationException("Not supported yet,"
1757  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1758  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1759  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1760  }
Object ai.heavy.jdbc.HeavyAIResultSet.getObject ( int  columnIndex) throws SQLException
inline

Definition at line 545 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().

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

+ 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 586 of file HeavyAIResultSet.java.

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

587  { // logger.debug("Entered "+ sql );
588  return getObject(columnMap.get(columnLabel));
589  }
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 1197 of file HeavyAIResultSet.java.

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

Definition at line 1377 of file HeavyAIResultSet.java.

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

Definition at line 2033 of file HeavyAIResultSet.java.

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

Definition at line 2042 of file HeavyAIResultSet.java.

2043  { // logger.debug("Entered "+ sql );
2044  throw new UnsupportedOperationException("Not supported yet,"
2045  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2046  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2047  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2048  }
long ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ ( long  actualmillis,
Calendar  cal,
int  precision 
)
inlineprivate

Definition at line 1421 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().

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

+ Here is the caller graph for this function:

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

Definition at line 1206 of file HeavyAIResultSet.java.

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

Definition at line 1386 of file HeavyAIResultSet.java.

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

Definition at line 692 of file HeavyAIResultSet.java.

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

Definition at line 1606 of file HeavyAIResultSet.java.

1607  { // logger.debug("Entered "+ sql );
1608  throw new UnsupportedOperationException("Not supported yet,"
1609  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1610  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1611  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1612  }
RowId ai.heavy.jdbc.HeavyAIResultSet.getRowId ( String  columnLabel) throws SQLException
inline

Definition at line 1615 of file HeavyAIResultSet.java.

1616  { // logger.debug("Entered "+ sql );
1617  throw new UnsupportedOperationException("Not supported yet,"
1618  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1619  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1620  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1621  }
short ai.heavy.jdbc.HeavyAIResultSet.getShort ( int  columnIndex) throws SQLException
inline

Definition at line 203 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().

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

+ 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 430 of file HeavyAIResultSet.java.

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

431  { // logger.debug("Entered "+ sql );
432  return getShort(findColumnByName(columnLabel));
433  }
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 1709 of file HeavyAIResultSet.java.

1710  { // logger.debug("Entered "+ sql );
1711  throw new UnsupportedOperationException("Not supported yet,"
1712  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1713  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1714  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1715  }
SQLXML ai.heavy.jdbc.HeavyAIResultSet.getSQLXML ( String  columnLabel) throws SQLException
inline

Definition at line 1718 of file HeavyAIResultSet.java.

1719  { // logger.debug("Entered "+ sql );
1720  throw new UnsupportedOperationException("Not supported yet,"
1721  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1722  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1723  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1724  }
Statement ai.heavy.jdbc.HeavyAIResultSet.getStatement ( ) throws SQLException
inline

Definition at line 1189 of file HeavyAIResultSet.java.

1189  { // logger.debug("Entered "+ sql );
1190  throw new UnsupportedOperationException("Not supported yet,"
1191  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1192  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1193  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1194  }
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 409 of file HeavyAIResultSet.java.

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

410  { // logger.debug("Entered "+ sql );
411  return getString(findColumnByName(columnLabel));
412  }
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 MULTIPOINT:
165  case LINESTRING:
166  case MULTILINESTRING:
167  case POLYGON:
168  case MULTIPOLYGON:
169  return (String) getObject(columnIndex);
170  default:
171  throw new AssertionError(type.name());
172  }
173  }
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 341 of file HeavyAIResultSet.java.

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

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

+ Here is the caller graph for this function:

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

Definition at line 481 of file HeavyAIResultSet.java.

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

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

+ Here is the call graph for this function:

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

Definition at line 1467 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().

1468  { // logger.debug("Entered "+ sql );
1469  checkClosed();
1470  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1471  wasNull = true;
1472  return null;
1473  } else {
1474  // assume column is str already for now
1475  wasNull = false;
1476  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1477  if (cal != null) {
1478  val += getOffsetFromTZ(val, cal, 0);
1479  }
1480  return new Time(val * 1000);
1481  }
1482  }
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 1485 of file HeavyAIResultSet.java.

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

1486  { // logger.debug("Entered "+ sql );
1487  return getTime(findColumnByName(columnLabel), cal);
1488  }
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 347 of file HeavyAIResultSet.java.

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

348  { // logger.debug("Entered "+ sql );
349  return getTimestamp(columnIndex, null);
350  }
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 487 of file HeavyAIResultSet.java.

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

488  { // logger.debug("Entered "+ sql );
489  return getTimestamp(columnLabel, null);
490  }
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 1491 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().

1492  { // logger.debug("Entered "+ sql );
1493  checkClosed();
1494  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1495  wasNull = true;
1496  return null;
1497  } else {
1498  // assume column is str already for now
1499  wasNull = false;
1500  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1501  int precision = rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision();
1502  if (cal != null) {
1503  val += getOffsetFromTZ(val, cal, precision);
1504  }
1505  return adjust_precision(val, precision);
1506  }
1507  }
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 1510 of file HeavyAIResultSet.java.

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

1511  { // logger.debug("Entered "+ sql );
1512  return getTimestamp(findColumnByName(columnLabel), cal);
1513  }
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 754 of file HeavyAIResultSet.java.

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

Definition at line 391 of file HeavyAIResultSet.java.

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

Definition at line 502 of file HeavyAIResultSet.java.

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

Definition at line 1516 of file HeavyAIResultSet.java.

1517  { // logger.debug("Entered "+ sql );
1518  throw new UnsupportedOperationException("Not supported yet,"
1519  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1520  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1521  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1522  }
URL ai.heavy.jdbc.HeavyAIResultSet.getURL ( String  columnLabel) throws SQLException
inline

Definition at line 1525 of file HeavyAIResultSet.java.

1526  { // logger.debug("Entered "+ sql );
1527  throw new UnsupportedOperationException("Not supported yet,"
1528  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1529  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1530  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1531  }
SQLWarning ai.heavy.jdbc.HeavyAIResultSet.getWarnings ( ) throws SQLException
inline

Definition at line 520 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.warnings.

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

Definition at line 1133 of file HeavyAIResultSet.java.

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

Definition at line 645 of file HeavyAIResultSet.java.

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

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

Definition at line 640 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.offset.

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

Definition at line 1650 of file HeavyAIResultSet.java.

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

1650  { // logger.debug("Entered "+ sql );
1651  return isClosed;
1652  }

+ Here is the caller graph for this function:

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

Definition at line 650 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.offset.

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

Definition at line 655 of file HeavyAIResultSet.java.

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

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

Definition at line 2060 of file HeavyAIResultSet.java.

2061  { // logger.debug("Entered "+ sql );
2062  throw new UnsupportedOperationException("Not supported yet,"
2063  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2064  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2065  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2066  }
boolean ai.heavy.jdbc.HeavyAIResultSet.last ( ) throws SQLException
inline

Definition at line 684 of file HeavyAIResultSet.java.

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

Definition at line 1181 of file HeavyAIResultSet.java.

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

Definition at line 1173 of file HeavyAIResultSet.java.

1173  { // logger.debug("Entered "+ sql );
1174  throw new UnsupportedOperationException("Not supported yet,"
1175  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1176  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1177  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1178  }
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 718 of file HeavyAIResultSet.java.

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

Definition at line 1157 of file HeavyAIResultSet.java.

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

Definition at line 709 of file HeavyAIResultSet.java.

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

Definition at line 783 of file HeavyAIResultSet.java.

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

Definition at line 775 of file HeavyAIResultSet.java.

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

Definition at line 767 of file HeavyAIResultSet.java.

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

Definition at line 726 of file HeavyAIResultSet.java.

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

Definition at line 740 of file HeavyAIResultSet.java.

References ai.heavy.jdbc.HeavyAIResultSet.fetchSize.

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

Definition at line 2051 of file HeavyAIResultSet.java.

2052  { // logger.debug("Entered "+ sql );
2053  throw new UnsupportedOperationException("Not supported yet,"
2054  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2055  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2056  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2057  }
void ai.heavy.jdbc.HeavyAIResultSet.updateArray ( int  columnIndex,
Array  x 
) throws SQLException
inline

Definition at line 1588 of file HeavyAIResultSet.java.

1589  { // logger.debug("Entered "+ sql );
1590  throw new UnsupportedOperationException("Not supported yet,"
1591  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1592  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1593  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1594  }
void ai.heavy.jdbc.HeavyAIResultSet.updateArray ( String  columnLabel,
Array  x 
) throws SQLException
inline

Definition at line 1597 of file HeavyAIResultSet.java.

1598  { // logger.debug("Entered "+ sql );
1599  throw new UnsupportedOperationException("Not supported yet,"
1600  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1601  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1602  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1603  }
void ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream ( int  columnIndex,
InputStream  x,
int  length 
) throws SQLException
inline

Definition at line 917 of file HeavyAIResultSet.java.

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

Definition at line 1088 of file HeavyAIResultSet.java.

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

Definition at line 1799 of file HeavyAIResultSet.java.

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

Definition at line 1826 of file HeavyAIResultSet.java.

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

Definition at line 1925 of file HeavyAIResultSet.java.

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

Definition at line 1952 of file HeavyAIResultSet.java.

1953  { // logger.debug("Entered "+ sql );
1954  throw new UnsupportedOperationException("Not supported yet,"
1955  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1956  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1957  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1958  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBigDecimal ( int  columnIndex,
BigDecimal  x 
) throws SQLException
inline

Definition at line 863 of file HeavyAIResultSet.java.

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

Definition at line 1034 of file HeavyAIResultSet.java.

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

Definition at line 926 of file HeavyAIResultSet.java.

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

Definition at line 1097 of file HeavyAIResultSet.java.

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

Definition at line 1808 of file HeavyAIResultSet.java.

1809  { // logger.debug("Entered "+ sql );
1810  throw new UnsupportedOperationException("Not supported yet,"
1811  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1812  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1813  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1814  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( String  columnLabel,
InputStream  x,
long  length 
) throws SQLException
inline

Definition at line 1835 of file HeavyAIResultSet.java.

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

Definition at line 1934 of file HeavyAIResultSet.java.

1935  { // logger.debug("Entered "+ sql );
1936  throw new UnsupportedOperationException("Not supported yet,"
1937  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1938  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1939  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1940  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream ( String  columnLabel,
InputStream  x 
) throws SQLException
inline

Definition at line 1961 of file HeavyAIResultSet.java.

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

Definition at line 1552 of file HeavyAIResultSet.java.

1553  { // logger.debug("Entered "+ sql );
1554  throw new UnsupportedOperationException("Not supported yet,"
1555  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1556  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1557  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1558  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
Blob  x 
) throws SQLException
inline

Definition at line 1561 of file HeavyAIResultSet.java.

1562  { // logger.debug("Entered "+ sql );
1563  throw new UnsupportedOperationException("Not supported yet,"
1564  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1565  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1566  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1567  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( int  columnIndex,
InputStream  inputStream,
long  length 
) throws SQLException
inline

Definition at line 1853 of file HeavyAIResultSet.java.

1854  { // logger.debug("Entered "+ sql );
1855  throw new UnsupportedOperationException("Not supported yet,"
1856  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1857  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1858  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1859  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
InputStream  inputStream,
long  length 
) throws SQLException
inline

Definition at line 1862 of file HeavyAIResultSet.java.

1863  { // logger.debug("Entered "+ sql );
1864  throw new UnsupportedOperationException("Not supported yet,"
1865  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1866  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1867  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1868  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( int  columnIndex,
InputStream  inputStream 
) throws SQLException
inline

Definition at line 1979 of file HeavyAIResultSet.java.

1980  { // logger.debug("Entered "+ sql );
1981  throw new UnsupportedOperationException("Not supported yet,"
1982  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1983  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1984  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1985  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBlob ( String  columnLabel,
InputStream  inputStream 
) throws SQLException
inline

Definition at line 1988 of file HeavyAIResultSet.java.

1989  { // logger.debug("Entered "+ sql );
1990  throw new UnsupportedOperationException("Not supported yet,"
1991  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1992  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1993  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1994  }
void ai.heavy.jdbc.HeavyAIResultSet.updateBoolean ( int  columnIndex,
boolean  x 
) throws SQLException
inline

Definition at line 800 of file HeavyAIResultSet.java.

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

Definition at line 971 of file HeavyAIResultSet.java.

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

Definition at line 809 of file HeavyAIResultSet.java.

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

Definition at line 980 of file HeavyAIResultSet.java.

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

Definition at line 881 of file HeavyAIResultSet.java.

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

Definition at line 1052 of file HeavyAIResultSet.java.

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

Definition at line 935 of file HeavyAIResultSet.java.

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

Definition at line 1106 of file HeavyAIResultSet.java.

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

Definition at line 1817 of file HeavyAIResultSet.java.

1818  { // logger.debug("Entered "+ sql );
1819  throw new UnsupportedOperationException("Not supported yet,"
1820  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1821  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1822  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1823  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1844 of file HeavyAIResultSet.java.

1845  { // logger.debug("Entered "+ sql );
1846  throw new UnsupportedOperationException("Not supported yet,"
1847  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1848  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1849  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1850  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( int  columnIndex,
Reader  x 
) throws SQLException
inline

Definition at line 1943 of file HeavyAIResultSet.java.

1944  { // logger.debug("Entered "+ sql );
1945  throw new UnsupportedOperationException("Not supported yet,"
1946  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1947  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1948  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1949  }
void ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 1970 of file HeavyAIResultSet.java.

1971  { // logger.debug("Entered "+ sql );
1972  throw new UnsupportedOperationException("Not supported yet,"
1973  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1974  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1975  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1976  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Clob  x 
) throws SQLException
inline

Definition at line 1570 of file HeavyAIResultSet.java.

1571  { // logger.debug("Entered "+ sql );
1572  throw new UnsupportedOperationException("Not supported yet,"
1573  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1574  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1575  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1576  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Clob  x 
) throws SQLException
inline

Definition at line 1579 of file HeavyAIResultSet.java.

1580  { // logger.debug("Entered "+ sql );
1581  throw new UnsupportedOperationException("Not supported yet,"
1582  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1583  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1584  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1585  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1871 of file HeavyAIResultSet.java.

1872  { // logger.debug("Entered "+ sql );
1873  throw new UnsupportedOperationException("Not supported yet,"
1874  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1875  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1876  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1877  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1880 of file HeavyAIResultSet.java.

1881  { // logger.debug("Entered "+ sql );
1882  throw new UnsupportedOperationException("Not supported yet,"
1883  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1884  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1885  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1886  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( int  columnIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 1997 of file HeavyAIResultSet.java.

1998  { // logger.debug("Entered "+ sql );
1999  throw new UnsupportedOperationException("Not supported yet,"
2000  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2001  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2002  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2003  }
void ai.heavy.jdbc.HeavyAIResultSet.updateClob ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 2006 of file HeavyAIResultSet.java.

2007  { // logger.debug("Entered "+ sql );
2008  throw new UnsupportedOperationException("Not supported yet,"
2009  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2010  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2011  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2012  }
void ai.heavy.jdbc.HeavyAIResultSet.updateDate ( int  columnIndex,
Date  x 
) throws SQLException
inline

Definition at line 890 of file HeavyAIResultSet.java.

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

Definition at line 1061 of file HeavyAIResultSet.java.

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

Definition at line 854 of file HeavyAIResultSet.java.

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

Definition at line 1025 of file HeavyAIResultSet.java.

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

Definition at line 845 of file HeavyAIResultSet.java.

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

Definition at line 1016 of file HeavyAIResultSet.java.

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

Definition at line 827 of file HeavyAIResultSet.java.

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

Definition at line 998 of file HeavyAIResultSet.java.

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

Definition at line 836 of file HeavyAIResultSet.java.

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

Definition at line 1007 of file HeavyAIResultSet.java.

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

Definition at line 1781 of file HeavyAIResultSet.java.

1782  { // logger.debug("Entered "+ sql );
1783  throw new UnsupportedOperationException("Not supported yet,"
1784  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1785  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1786  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1787  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1790 of file HeavyAIResultSet.java.

1791  { // logger.debug("Entered "+ sql );
1792  throw new UnsupportedOperationException("Not supported yet,"
1793  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1794  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1795  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1796  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( int  columnIndex,
Reader  x 
) throws SQLException
inline

Definition at line 1907 of file HeavyAIResultSet.java.

1908  { // logger.debug("Entered "+ sql );
1909  throw new UnsupportedOperationException("Not supported yet,"
1910  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1911  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1912  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1913  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 1916 of file HeavyAIResultSet.java.

1917  { // logger.debug("Entered "+ sql );
1918  throw new UnsupportedOperationException("Not supported yet,"
1919  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1920  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1921  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1922  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
NClob  nClob 
) throws SQLException
inline

Definition at line 1673 of file HeavyAIResultSet.java.

1674  { // logger.debug("Entered "+ sql );
1675  throw new UnsupportedOperationException("Not supported yet,"
1676  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1677  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1678  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1679  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
NClob  nClob 
) throws SQLException
inline

Definition at line 1682 of file HeavyAIResultSet.java.

1683  { // logger.debug("Entered "+ sql );
1684  throw new UnsupportedOperationException("Not supported yet,"
1685  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1686  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1687  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1688  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1889 of file HeavyAIResultSet.java.

1890  { // logger.debug("Entered "+ sql );
1891  throw new UnsupportedOperationException("Not supported yet,"
1892  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1893  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1894  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1895  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
Reader  reader,
long  length 
) throws SQLException
inline

Definition at line 1898 of file HeavyAIResultSet.java.

1899  { // logger.debug("Entered "+ sql );
1900  throw new UnsupportedOperationException("Not supported yet,"
1901  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1902  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1903  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1904  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( int  columnIndex,
Reader  reader 
) throws SQLException
inline

Definition at line 2015 of file HeavyAIResultSet.java.

2016  { // logger.debug("Entered "+ sql );
2017  throw new UnsupportedOperationException("Not supported yet,"
2018  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2019  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2020  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2021  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNClob ( String  columnLabel,
Reader  reader 
) throws SQLException
inline

Definition at line 2024 of file HeavyAIResultSet.java.

2025  { // logger.debug("Entered "+ sql );
2026  throw new UnsupportedOperationException("Not supported yet,"
2027  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2028  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2029  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2030  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNString ( int  columnIndex,
String  nString 
) throws SQLException
inline

Definition at line 1655 of file HeavyAIResultSet.java.

1656  { // logger.debug("Entered "+ sql );
1657  throw new UnsupportedOperationException("Not supported yet,"
1658  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1659  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1660  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1661  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNString ( String  columnLabel,
String  nString 
) throws SQLException
inline

Definition at line 1664 of file HeavyAIResultSet.java.

1665  { // logger.debug("Entered "+ sql );
1666  throw new UnsupportedOperationException("Not supported yet,"
1667  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1668  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1669  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1670  }
void ai.heavy.jdbc.HeavyAIResultSet.updateNull ( int  columnIndex) throws SQLException
inline

Definition at line 791 of file HeavyAIResultSet.java.

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

Definition at line 962 of file HeavyAIResultSet.java.

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

Definition at line 944 of file HeavyAIResultSet.java.

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

Definition at line 953 of file HeavyAIResultSet.java.

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

Definition at line 1115 of file HeavyAIResultSet.java.

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

Definition at line 1124 of file HeavyAIResultSet.java.

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

Definition at line 1534 of file HeavyAIResultSet.java.

1535  { // logger.debug("Entered "+ sql );
1536  throw new UnsupportedOperationException("Not supported yet,"
1537  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1538  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1539  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1540  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRef ( String  columnLabel,
Ref  x 
) throws SQLException
inline

Definition at line 1543 of file HeavyAIResultSet.java.

1544  { // logger.debug("Entered "+ sql );
1545  throw new UnsupportedOperationException("Not supported yet,"
1546  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1547  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1548  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1549  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRow ( ) throws SQLException
inline

Definition at line 1141 of file HeavyAIResultSet.java.

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

Definition at line 1624 of file HeavyAIResultSet.java.

1625  { // logger.debug("Entered "+ sql );
1626  throw new UnsupportedOperationException("Not supported yet,"
1627  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1628  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1629  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1630  }
void ai.heavy.jdbc.HeavyAIResultSet.updateRowId ( String  columnLabel,
RowId  x 
) throws SQLException
inline

Definition at line 1633 of file HeavyAIResultSet.java.

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

Definition at line 818 of file HeavyAIResultSet.java.

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

Definition at line 989 of file HeavyAIResultSet.java.

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

Definition at line 1727 of file HeavyAIResultSet.java.

1728  { // logger.debug("Entered "+ sql );
1729  throw new UnsupportedOperationException("Not supported yet,"
1730  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1731  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1732  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1733  }
void ai.heavy.jdbc.HeavyAIResultSet.updateSQLXML ( String  columnLabel,
SQLXML  xmlObject 
) throws SQLException
inline

Definition at line 1736 of file HeavyAIResultSet.java.

1737  { // logger.debug("Entered "+ sql );
1738  throw new UnsupportedOperationException("Not supported yet,"
1739  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1740  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1741  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1742  }
void ai.heavy.jdbc.HeavyAIResultSet.updateString ( int  columnIndex,
String  x 
) throws SQLException
inline

Definition at line 872 of file HeavyAIResultSet.java.

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

Definition at line 1043 of file HeavyAIResultSet.java.

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

Definition at line 899 of file HeavyAIResultSet.java.

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

Definition at line 1070 of file HeavyAIResultSet.java.

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

Definition at line 908 of file HeavyAIResultSet.java.

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

Definition at line 1079 of file HeavyAIResultSet.java.

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

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: