OmniSciDB  a5dc49c757
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HeavyAIResultSet.java
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package ai.heavy.jdbc;
17 
18 import org.slf4j.Logger;
19 import org.slf4j.LoggerFactory;
20 
21 import java.io.InputStream;
22 import java.io.Reader;
23 import java.math.BigDecimal;
24 import java.net.URL;
25 import java.sql.*;
26 import java.util.Calendar;
27 import java.util.HashMap;
28 import java.util.List;
29 import java.util.Map;
30 
31 import ai.heavy.thrift.server.TColumnType;
32 import ai.heavy.thrift.server.TDatumType;
33 import ai.heavy.thrift.server.TQueryResult;
34 import ai.heavy.thrift.server.TRowSet;
35 
36 // Useful debug string
37 // System.out.println("Entered " + " line:" + new
38 // Throwable().getStackTrace()[0].getLineNumber() + " class:" + new
39 // Throwable().getStackTrace()[0].getClassName() + " method:" + new
40 // Throwable().getStackTrace()[0].getMethodName());
41 class HeavyAIResultSet implements java.sql.ResultSet {
42  final static Logger logger = LoggerFactory.getLogger(HeavyAIResultSet.class);
43  private TQueryResult sqlResult = null;
44  private int offset = -1;
45  private int numOfRecords = 0;
46  private String sql;
47  private TRowSet rowSet = null;
48  private List<TColumnType> rowDesc;
49  private boolean wasNull = false;
50  private Map<String, Integer> columnMap;
51  private int fetchSize = 0;
52  private SQLWarning warnings = null;
53  private boolean isClosed = false;
54 
55  public HeavyAIResultSet(TQueryResult tsqlResult, String sql)
56  throws SQLException { // 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  }
86 
87  HeavyAIResultSet() {
88  numOfRecords = 0;
89  }
90 
91  @Override
92  public boolean next() throws SQLException { // logger.debug("Entered "+ sql );
93  checkClosed();
94  // do real work
95  offset++;
96  if (offset < numOfRecords) {
97  return true;
98  }
99  return false;
100  }
101 
102  @Override
103  public void close() throws SQLException { // logger.debug("Entered "+ sql );
104  rowDesc = null;
105  rowSet = null;
106  sqlResult = null;
107  isClosed = true;
108  }
109 
110  @Override
111  public boolean wasNull() throws SQLException { // logger.debug("Entered "+ sql );
112  return wasNull;
113  }
114 
115  @Override
116  public String getString(int columnIndex) throws SQLException {
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  }
133 
134  private String getStringInternal(int columnIndex) throws SQLException {
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  }
174 
175  @Override
176  public boolean getBoolean(int columnIndex)
177  throws SQLException { // 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  }
192 
193  @Override
194  public byte getByte(int columnIndex)
195  throws SQLException { // 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  }
201 
202  @Override
203  public short getShort(int columnIndex)
204  throws SQLException { // 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  }
216 
217  @Override
218  public int getInt(int columnIndex)
219  throws SQLException { // 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  }
231 
232  @Override
233  public long getLong(int columnIndex)
234  throws SQLException { // 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  }
245 
246  @Override
247  public float getFloat(int columnIndex)
248  throws SQLException { // 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  }
259 
260  @Override
261  public double getDouble(int columnIndex)
262  throws SQLException { // 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  }
279 
280  private double getDoubleInternal(int columnIndex) throws SQLException {
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  }
309 
310  @Override
311  public BigDecimal getBigDecimal(int columnIndex, int scale)
312  throws SQLException { // 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  }
324 
325  @Override
326  public byte[] getBytes(int columnIndex)
327  throws SQLException { // 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  }
333 
334  @Override
335  public Date getDate(int columnIndex)
336  throws SQLException { // logger.debug("Entered "+ sql );
337  return getDate(columnIndex, null);
338  }
339 
340  @Override
341  public Time getTime(int columnIndex)
342  throws SQLException { // logger.debug("Entered "+ sql );
343  return getTime(columnIndex, null);
344  }
345 
346  @Override
347  public Timestamp getTimestamp(int columnIndex)
348  throws SQLException { // logger.debug("Entered "+ sql );
349  return getTimestamp(columnIndex, null);
350  }
351 
352  private Timestamp extract_complex_time(long val, int precision) {
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  }
365 
366  private Timestamp adjust_precision(long val, int precision) {
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  }
380 
381  @Override
382  public InputStream getAsciiStream(int columnIndex)
383  throws SQLException { // 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  }
389 
390  @Override
391  public InputStream getUnicodeStream(int columnIndex)
392  throws SQLException { // 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  }
398 
399  @Override
400  public InputStream getBinaryStream(int columnIndex)
401  throws SQLException { // 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  }
407 
408  @Override
409  public String getString(String columnLabel)
410  throws SQLException { // logger.debug("Entered "+ sql );
411  return getString(findColumnByName(columnLabel));
412  }
413 
414  @Override
415  public boolean getBoolean(String columnLabel)
416  throws SQLException { // logger.debug("Entered "+ sql );
417  return getBoolean(findColumnByName(columnLabel));
418  }
419 
420  @Override
421  public byte getByte(String columnLabel)
422  throws SQLException { // 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  }
428 
429  @Override
430  public short getShort(String columnLabel)
431  throws SQLException { // logger.debug("Entered "+ sql );
432  return getShort(findColumnByName(columnLabel));
433  }
434 
435  @Override
436  public int getInt(String columnLabel)
437  throws SQLException { // logger.debug("Entered "+ sql );
438  return getInt(findColumnByName(columnLabel));
439  }
440 
441  @Override
442  public long getLong(String columnLabel)
443  throws SQLException { // logger.debug("Entered "+ sql );
444  return getLong(findColumnByName(columnLabel));
445  }
446 
447  @Override
448  public float getFloat(String columnLabel)
449  throws SQLException { // logger.debug("Entered "+ sql );
450  return getFloat(findColumnByName(columnLabel));
451  }
452 
453  @Override
454  public double getDouble(String columnLabel)
455  throws SQLException { // logger.debug("Entered "+ sql );
456  return getDouble(findColumnByName(columnLabel));
457  }
458 
459  @Override
460  public BigDecimal getBigDecimal(String columnLabel, int scale)
461  throws SQLException { // logger.debug("Entered "+ sql );
462  return getBigDecimal(findColumnByName(columnLabel));
463  }
464 
465  @Override
466  public byte[] getBytes(String columnLabel)
467  throws SQLException { // 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  }
473 
474  @Override
475  public Date getDate(String columnLabel)
476  throws SQLException { // logger.debug("Entered "+ sql );
477  return getDate(columnLabel, null);
478  }
479 
480  @Override
481  public Time getTime(String columnLabel)
482  throws SQLException { // logger.debug("Entered "+ sql );
483  return getTime(columnLabel, null);
484  }
485 
486  @Override
487  public Timestamp getTimestamp(String columnLabel)
488  throws SQLException { // logger.debug("Entered "+ sql );
489  return getTimestamp(columnLabel, null);
490  }
491 
492  @Override
493  public InputStream getAsciiStream(String columnLabel)
494  throws SQLException { // 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  }
500 
501  @Override
502  public InputStream getUnicodeStream(String columnLabel)
503  throws SQLException { // 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  }
509 
510  @Override
511  public InputStream getBinaryStream(String columnLabel)
512  throws SQLException { // 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  }
518 
519  @Override
520  public SQLWarning getWarnings() throws SQLException { // logger.debug("Entered "+ sql );
521  return warnings;
522  }
523 
524  @Override
525  public void clearWarnings() throws SQLException { // logger.debug("Entered "+ sql );
526  warnings = null;
527  }
528 
529  @Override
530  public String getCursorName() throws SQLException { // 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  }
536 
537  @Override
538  public ResultSetMetaData getMetaData()
539  throws SQLException { // logger.debug("Entered "+ sql );
540  checkClosed();
541  return new HeavyAIResultSetMetaData(sqlResult, sql);
542  }
543 
544  @Override
545  public Object getObject(int columnIndex)
546  throws SQLException { // 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  }
584 
585  @Override
586  public Object getObject(String columnLabel)
587  throws SQLException { // logger.debug("Entered "+ sql );
588  return getObject(columnMap.get(columnLabel));
589  }
590 
591  @Override
592  public int findColumn(String columnLabel)
593  throws SQLException { // 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  }
599 
600  @Override
601  public Reader getCharacterStream(int columnIndex)
602  throws SQLException { // 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  }
608 
609  @Override
610  public Reader getCharacterStream(String columnLabel)
611  throws SQLException { // 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  }
617 
618  @Override
619  public BigDecimal getBigDecimal(int columnIndex)
620  throws SQLException { // 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  }
632 
633  @Override
634  public BigDecimal getBigDecimal(String columnLabel)
635  throws SQLException { // logger.debug("Entered "+ sql );
636  return getBigDecimal(columnMap.get(columnLabel));
637  }
638 
639  @Override
640  public boolean isBeforeFirst() throws SQLException { // logger.debug("Entered "+ sql );
641  return offset == -1;
642  }
643 
644  @Override
645  public boolean isAfterLast() throws SQLException { // logger.debug("Entered "+ sql );
646  return offset == numOfRecords;
647  }
648 
649  @Override
650  public boolean isFirst() throws SQLException { // logger.debug("Entered "+ sql );
651  return offset == 0;
652  }
653 
654  @Override
655  public boolean isLast() throws SQLException { // logger.debug("Entered "+ sql );
656  return offset == numOfRecords - 1;
657  }
658 
659  @Override
660  public void beforeFirst() throws SQLException { // 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  }
666 
667  @Override
668  public void afterLast() throws SQLException { // 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  }
674 
675  @Override
676  public boolean first() throws SQLException { // 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  }
682 
683  @Override
684  public boolean last() throws SQLException { // 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  }
690 
691  @Override
692  public int getRow() throws SQLException { // 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  }
698 
699  @Override
700  public boolean absolute(int row)
701  throws SQLException { // 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  }
707 
708  @Override
709  public boolean relative(int rows)
710  throws SQLException { // 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  }
716 
717  @Override
718  public boolean previous() throws SQLException { // 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  }
724 
725  @Override
726  public void setFetchDirection(int direction)
727  throws SQLException { // 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  }
733 
734  @Override
735  public int getFetchDirection() throws SQLException { // logger.debug("Entered "+ sql );
736  return FETCH_FORWARD;
737  }
738 
739  @Override
740  public void setFetchSize(int rows)
741  throws SQLException { // logger.debug("Entered "+ sql );
742  fetchSize = rows;
743  }
744 
745  @Override
746  public int getFetchSize() throws SQLException { // 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  }
752 
753  @Override
754  public int getType() throws SQLException { // logger.debug("Entered "+ sql );
755  return TYPE_FORWARD_ONLY;
756  }
757 
758  @Override
759  public int getConcurrency() throws SQLException { // 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  }
765 
766  @Override
767  public boolean rowUpdated() throws SQLException { // 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  }
773 
774  @Override
775  public boolean rowInserted() throws SQLException { // 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  }
781 
782  @Override
783  public boolean rowDeleted() throws SQLException { // 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  }
789 
790  @Override
791  public void updateNull(int columnIndex)
792  throws SQLException { // 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  }
798 
799  @Override
800  public void updateBoolean(int columnIndex, boolean x)
801  throws SQLException { // 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  }
807 
808  @Override
809  public void updateByte(int columnIndex, byte x)
810  throws SQLException { // 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  }
816 
817  @Override
818  public void updateShort(int columnIndex, short x)
819  throws SQLException { // 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  }
825 
826  @Override
827  public void updateInt(int columnIndex, int x)
828  throws SQLException { // 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  }
834 
835  @Override
836  public void updateLong(int columnIndex, long x)
837  throws SQLException { // 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  }
843 
844  @Override
845  public void updateFloat(int columnIndex, float x)
846  throws SQLException { // 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  }
852 
853  @Override
854  public void updateDouble(int columnIndex, double x)
855  throws SQLException { // 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  }
861 
862  @Override
863  public void updateBigDecimal(int columnIndex, BigDecimal x)
864  throws SQLException { // 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  }
870 
871  @Override
872  public void updateString(int columnIndex, String x)
873  throws SQLException { // 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  }
879 
880  @Override
881  public void updateBytes(int columnIndex, byte[] x)
882  throws SQLException { // 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  }
888 
889  @Override
890  public void updateDate(int columnIndex, Date x)
891  throws SQLException { // 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  }
897 
898  @Override
899  public void updateTime(int columnIndex, Time x)
900  throws SQLException { // 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  }
906 
907  @Override
908  public void updateTimestamp(int columnIndex, Timestamp x)
909  throws SQLException { // 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  }
915 
916  @Override
917  public void updateAsciiStream(int columnIndex, InputStream x, int length)
918  throws SQLException { // 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  }
924 
925  @Override
926  public void updateBinaryStream(int columnIndex, InputStream x, int length)
927  throws SQLException { // 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  }
933 
934  @Override
935  public void updateCharacterStream(int columnIndex, Reader x, int length)
936  throws SQLException { // 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  }
942 
943  @Override
944  public void updateObject(int columnIndex, Object x, int scaleOrLength)
945  throws SQLException { // 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  }
951 
952  @Override
953  public void updateObject(int columnIndex, Object x)
954  throws SQLException { // 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  }
960 
961  @Override
962  public void updateNull(String columnLabel)
963  throws SQLException { // 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  }
969 
970  @Override
971  public void updateBoolean(String columnLabel, boolean x)
972  throws SQLException { // 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  }
978 
979  @Override
980  public void updateByte(String columnLabel, byte x)
981  throws SQLException { // 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  }
987 
988  @Override
989  public void updateShort(String columnLabel, short x)
990  throws SQLException { // 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  }
996 
997  @Override
998  public void updateInt(String columnLabel, int x)
999  throws SQLException { // 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  }
1005 
1006  @Override
1007  public void updateLong(String columnLabel, long x)
1008  throws SQLException { // 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  }
1014 
1015  @Override
1016  public void updateFloat(String columnLabel, float x)
1017  throws SQLException { // 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  }
1023 
1024  @Override
1025  public void updateDouble(String columnLabel, double x)
1026  throws SQLException { // 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  }
1032 
1033  @Override
1034  public void updateBigDecimal(String columnLabel, BigDecimal x)
1035  throws SQLException { // 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  }
1041 
1042  @Override
1043  public void updateString(String columnLabel, String x)
1044  throws SQLException { // 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  }
1050 
1051  @Override
1052  public void updateBytes(String columnLabel, byte[] x)
1053  throws SQLException { // 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  }
1059 
1060  @Override
1061  public void updateDate(String columnLabel, Date x)
1062  throws SQLException { // 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  }
1068 
1069  @Override
1070  public void updateTime(String columnLabel, Time x)
1071  throws SQLException { // 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  }
1077 
1078  @Override
1079  public void updateTimestamp(String columnLabel, Timestamp x)
1080  throws SQLException { // 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  }
1086 
1087  @Override
1088  public void updateAsciiStream(String columnLabel, InputStream x, int length)
1089  throws SQLException { // 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  }
1095 
1096  @Override
1097  public void updateBinaryStream(String columnLabel, InputStream x, int length)
1098  throws SQLException { // 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  }
1104 
1105  @Override
1106  public void updateCharacterStream(String columnLabel, Reader reader, int length)
1107  throws SQLException { // 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  }
1113 
1114  @Override
1115  public void updateObject(String columnLabel, Object x, int scaleOrLength)
1116  throws SQLException { // 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  }
1122 
1123  @Override
1124  public void updateObject(String columnLabel, Object x)
1125  throws SQLException { // 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  }
1131 
1132  @Override
1133  public void insertRow() throws SQLException { // 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  }
1139 
1140  @Override
1141  public void updateRow() throws SQLException { // 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  }
1147 
1148  @Override
1149  public void deleteRow() throws SQLException { // 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  }
1155 
1156  @Override
1157  public void refreshRow() throws SQLException { // 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  }
1163 
1164  @Override
1165  public void cancelRowUpdates() throws SQLException { // 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  }
1171 
1172  @Override
1173  public void moveToInsertRow() throws SQLException { // 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  }
1179 
1180  @Override
1181  public void moveToCurrentRow() throws SQLException { // 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  }
1187 
1188  @Override
1189  public Statement getStatement() throws SQLException { // 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  }
1195 
1196  @Override
1197  public Object getObject(int columnIndex, Map<String, Class<?>> map)
1198  throws SQLException { // 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  }
1204 
1205  @Override
1206  public Ref getRef(int columnIndex)
1207  throws SQLException { // 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  }
1213 
1214  @Override
1215  public Blob getBlob(int columnIndex)
1216  throws SQLException { // 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  }
1222 
1223  @Override
1224  public Clob getClob(int columnIndex)
1225  throws SQLException { // 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  }
1231 
1232  @Override
1233  public Array getArray(int columnIndex)
1234  throws SQLException { // 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  }
1375 
1376  @Override
1377  public Object getObject(String columnLabel, Map<String, Class<?>> map)
1378  throws SQLException { // 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  }
1384 
1385  @Override
1386  public Ref getRef(String columnLabel)
1387  throws SQLException { // 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  }
1393 
1394  @Override
1395  public Blob getBlob(String columnLabel)
1396  throws SQLException { // 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  }
1402 
1403  @Override
1404  public Clob getClob(String columnLabel)
1405  throws SQLException { // 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  }
1411 
1412  @Override
1413  public Array getArray(String columnLabel)
1414  throws SQLException { // logger.debug("Entered "+ sql );
1415  return getArray(findColumnByName(columnLabel));
1416  }
1417 
1418  // this method is used to add a TZ from Calendar; is TimeZone in the calendar
1419  // isn't
1420  // specified it uses the local TZ
1421  private long getOffsetFromTZ(long actualmillis, Calendar cal, int precision) {
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  }
1442 
1443  @Override
1444  public Date getDate(int columnIndex, Calendar cal) throws SQLException {
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  }
1460 
1461  @Override
1462  public Date getDate(String columnLabel, Calendar cal) throws SQLException {
1463  return getDate(findColumnByName(columnLabel), cal);
1464  }
1465 
1466  @Override
1467  public Time getTime(int columnIndex, Calendar cal)
1468  throws SQLException { // 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  }
1483 
1484  @Override
1485  public Time getTime(String columnLabel, Calendar cal)
1486  throws SQLException { // logger.debug("Entered "+ sql );
1487  return getTime(findColumnByName(columnLabel), cal);
1488  }
1489 
1490  @Override
1491  public Timestamp getTimestamp(int columnIndex, Calendar cal)
1492  throws SQLException { // 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  }
1508 
1509  @Override
1510  public Timestamp getTimestamp(String columnLabel, Calendar cal)
1511  throws SQLException { // logger.debug("Entered "+ sql );
1512  return getTimestamp(findColumnByName(columnLabel), cal);
1513  }
1514 
1515  @Override
1516  public URL getURL(int columnIndex)
1517  throws SQLException { // 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  }
1523 
1524  @Override
1525  public URL getURL(String columnLabel)
1526  throws SQLException { // 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  }
1532 
1533  @Override
1534  public void updateRef(int columnIndex, Ref x)
1535  throws SQLException { // 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  }
1541 
1542  @Override
1543  public void updateRef(String columnLabel, Ref x)
1544  throws SQLException { // 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  }
1550 
1551  @Override
1552  public void updateBlob(int columnIndex, Blob x)
1553  throws SQLException { // 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  }
1559 
1560  @Override
1561  public void updateBlob(String columnLabel, Blob x)
1562  throws SQLException { // 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  }
1568 
1569  @Override
1570  public void updateClob(int columnIndex, Clob x)
1571  throws SQLException { // 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  }
1577 
1578  @Override
1579  public void updateClob(String columnLabel, Clob x)
1580  throws SQLException { // 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  }
1586 
1587  @Override
1588  public void updateArray(int columnIndex, Array x)
1589  throws SQLException { // 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  }
1595 
1596  @Override
1597  public void updateArray(String columnLabel, Array x)
1598  throws SQLException { // 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  }
1604 
1605  @Override
1606  public RowId getRowId(int columnIndex)
1607  throws SQLException { // 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  }
1613 
1614  @Override
1615  public RowId getRowId(String columnLabel)
1616  throws SQLException { // 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  }
1622 
1623  @Override
1624  public void updateRowId(int columnIndex, RowId x)
1625  throws SQLException { // 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  }
1631 
1632  @Override
1633  public void updateRowId(String columnLabel, RowId x)
1634  throws SQLException { // 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  }
1640 
1641  @Override
1642  public int getHoldability() throws SQLException { // 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  }
1648 
1649  @Override
1650  public boolean isClosed() throws SQLException { // logger.debug("Entered "+ sql );
1651  return isClosed;
1652  }
1653 
1654  @Override
1655  public void updateNString(int columnIndex, String nString)
1656  throws SQLException { // 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  }
1662 
1663  @Override
1664  public void updateNString(String columnLabel, String nString)
1665  throws SQLException { // 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  }
1671 
1672  @Override
1673  public void updateNClob(int columnIndex, NClob nClob)
1674  throws SQLException { // 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  }
1680 
1681  @Override
1682  public void updateNClob(String columnLabel, NClob nClob)
1683  throws SQLException { // 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  }
1689 
1690  @Override
1691  public NClob getNClob(int columnIndex)
1692  throws SQLException { // 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  }
1698 
1699  @Override
1700  public NClob getNClob(String columnLabel)
1701  throws SQLException { // 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  }
1707 
1708  @Override
1709  public SQLXML getSQLXML(int columnIndex)
1710  throws SQLException { // 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  }
1716 
1717  @Override
1718  public SQLXML getSQLXML(String columnLabel)
1719  throws SQLException { // 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  }
1725 
1726  @Override
1727  public void updateSQLXML(int columnIndex, SQLXML xmlObject)
1728  throws SQLException { // 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  }
1734 
1735  @Override
1736  public void updateSQLXML(String columnLabel, SQLXML xmlObject)
1737  throws SQLException { // 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  }
1743 
1744  @Override
1745  public String getNString(int columnIndex)
1746  throws SQLException { // 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  }
1752 
1753  @Override
1754  public String getNString(String columnLabel)
1755  throws SQLException { // 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  }
1761 
1762  @Override
1763  public Reader getNCharacterStream(int columnIndex)
1764  throws SQLException { // 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  }
1770 
1771  @Override
1772  public Reader getNCharacterStream(String columnLabel)
1773  throws SQLException { // 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  }
1779 
1780  @Override
1781  public void updateNCharacterStream(int columnIndex, Reader x, long length)
1782  throws SQLException { // 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  }
1788 
1789  @Override
1790  public void updateNCharacterStream(String columnLabel, Reader reader, long length)
1791  throws SQLException { // 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  }
1797 
1798  @Override
1799  public void updateAsciiStream(int columnIndex, InputStream x, long length)
1800  throws SQLException { // 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  }
1806 
1807  @Override
1808  public void updateBinaryStream(int columnIndex, InputStream x, long length)
1809  throws SQLException { // 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  }
1815 
1816  @Override
1817  public void updateCharacterStream(int columnIndex, Reader x, long length)
1818  throws SQLException { // 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  }
1824 
1825  @Override
1826  public void updateAsciiStream(String columnLabel, InputStream x, long length)
1827  throws SQLException { // 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  }
1833 
1834  @Override
1835  public void updateBinaryStream(String columnLabel, InputStream x, long length)
1836  throws SQLException { // 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  }
1842 
1843  @Override
1844  public void updateCharacterStream(String columnLabel, Reader reader, long length)
1845  throws SQLException { // 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  }
1851 
1852  @Override
1853  public void updateBlob(int columnIndex, InputStream inputStream, long length)
1854  throws SQLException { // 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  }
1860 
1861  @Override
1862  public void updateBlob(String columnLabel, InputStream inputStream, long length)
1863  throws SQLException { // 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  }
1869 
1870  @Override
1871  public void updateClob(int columnIndex, Reader reader, long length)
1872  throws SQLException { // 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  }
1878 
1879  @Override
1880  public void updateClob(String columnLabel, Reader reader, long length)
1881  throws SQLException { // 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  }
1887 
1888  @Override
1889  public void updateNClob(int columnIndex, Reader reader, long length)
1890  throws SQLException { // 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  }
1896 
1897  @Override
1898  public void updateNClob(String columnLabel, Reader reader, long length)
1899  throws SQLException { // 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  }
1905 
1906  @Override
1907  public void updateNCharacterStream(int columnIndex, Reader x)
1908  throws SQLException { // 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  }
1914 
1915  @Override
1916  public void updateNCharacterStream(String columnLabel, Reader reader)
1917  throws SQLException { // 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  }
1923 
1924  @Override
1925  public void updateAsciiStream(int columnIndex, InputStream x)
1926  throws SQLException { // 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  }
1932 
1933  @Override
1934  public void updateBinaryStream(int columnIndex, InputStream x)
1935  throws SQLException { // 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  }
1941 
1942  @Override
1943  public void updateCharacterStream(int columnIndex, Reader x)
1944  throws SQLException { // 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  }
1950 
1951  @Override
1952  public void updateAsciiStream(String columnLabel, InputStream x)
1953  throws SQLException { // 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  }
1959 
1960  @Override
1961  public void updateBinaryStream(String columnLabel, InputStream x)
1962  throws SQLException { // 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  }
1968 
1969  @Override
1970  public void updateCharacterStream(String columnLabel, Reader reader)
1971  throws SQLException { // 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  }
1977 
1978  @Override
1979  public void updateBlob(int columnIndex, InputStream inputStream)
1980  throws SQLException { // 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  }
1986 
1987  @Override
1988  public void updateBlob(String columnLabel, InputStream inputStream)
1989  throws SQLException { // 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  }
1995 
1996  @Override
1997  public void updateClob(int columnIndex, Reader reader)
1998  throws SQLException { // 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  }
2004 
2005  @Override
2006  public void updateClob(String columnLabel, Reader reader)
2007  throws SQLException { // 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  }
2013 
2014  @Override
2015  public void updateNClob(int columnIndex, Reader reader)
2016  throws SQLException { // 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  }
2022 
2023  @Override
2024  public void updateNClob(String columnLabel, Reader reader)
2025  throws SQLException { // 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  }
2031 
2032  @Override
2033  public <T> T getObject(int columnIndex, Class<T> type)
2034  throws SQLException { // 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  }
2040 
2041  @Override
2042  public <T> T getObject(String columnLabel, Class<T> type)
2043  throws SQLException { // 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  }
2049 
2050  @Override
2051  public <T> T unwrap(Class<T> iface)
2052  throws SQLException { // 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  }
2058 
2059  @Override
2060  public boolean isWrapperFor(Class<?> iface)
2061  throws SQLException { // 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  }
2067 
2068  private Integer findColumnByName(String name) throws SQLException {
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  }
2075 
2076  private void checkClosed() throws SQLException {
2077  if (isClosed) {
2078  throw new SQLException("ResultSet is closed.");
2079  }
2080  }
2081 }
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(int columnIndex, Reader reader)
Definition: HeavyAIResultSet.java:1997
ai.heavy.jdbc.HeavyAIResultSet.getBoolean
boolean getBoolean(String columnLabel)
Definition: HeavyAIResultSet.java:415
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(String columnLabel, InputStream x, int length)
Definition: HeavyAIResultSet.java:1088
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(String columnLabel, Reader reader, long length)
Definition: HeavyAIResultSet.java:1898
ai.heavy.jdbc.HeavyAIResultSet.updateShort
void updateShort(String columnLabel, short x)
Definition: HeavyAIResultSet.java:989
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(String columnLabel, Reader reader)
Definition: HeavyAIResultSet.java:2024
ai.heavy.jdbc.HeavyAIResultSet.updateTimestamp
void updateTimestamp(int columnIndex, Timestamp x)
Definition: HeavyAIResultSet.java:908
ai.heavy.jdbc.HeavyAIResultSet.updateLong
void updateLong(int columnIndex, long x)
Definition: HeavyAIResultSet.java:836
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(String columnLabel, Reader reader, int length)
Definition: HeavyAIResultSet.java:1106
ai.heavy.jdbc.HeavyAIResultSet.getCharacterStream
Reader getCharacterStream(int columnIndex)
Definition: HeavyAIResultSet.java:601
ai.heavy.jdbc.HeavyAIResultSet.updateBigDecimal
void updateBigDecimal(String columnLabel, BigDecimal x)
Definition: HeavyAIResultSet.java:1034
ai.heavy.jdbc.HeavyAIResultSet.adjust_precision
Timestamp adjust_precision(long val, int precision)
Definition: HeavyAIResultSet.java:366
ai.heavy.jdbc.HeavyAIResultSet.getArray
Array getArray(String columnLabel)
Definition: HeavyAIResultSet.java:1413
ai.heavy.jdbc.HeavyAIResultSet.getSQLXML
SQLXML getSQLXML(String columnLabel)
Definition: HeavyAIResultSet.java:1718
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(String columnLabel, NClob nClob)
Definition: HeavyAIResultSet.java:1682
ai.heavy.jdbc.HeavyAIResultSet.getAsciiStream
InputStream getAsciiStream(String columnLabel)
Definition: HeavyAIResultSet.java:493
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(int columnIndex, InputStream x)
Definition: HeavyAIResultSet.java:1925
ai.heavy.jdbc.HeavyAIResultSet.updateString
void updateString(int columnIndex, String x)
Definition: HeavyAIResultSet.java:872
ai.heavy.jdbc.HeavyAIResultSet.getInt
int getInt(String columnLabel)
Definition: HeavyAIResultSet.java:436
ai.heavy.jdbc.HeavyAIResultSet.updateTime
void updateTime(String columnLabel, Time x)
Definition: HeavyAIResultSet.java:1070
ai.heavy.jdbc.HeavyAIResultSet.updateRowId
void updateRowId(int columnIndex, RowId x)
Definition: HeavyAIResultSet.java:1624
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(String columnLabel, Reader reader)
Definition: HeavyAIResultSet.java:2006
ai.heavy.jdbc.HeavyAIResultSet.updateInt
void updateInt(String columnLabel, int x)
Definition: HeavyAIResultSet.java:998
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(int columnIndex, Clob x)
Definition: HeavyAIResultSet.java:1570
ai.heavy.jdbc.HeavyAIResultSet.getTimestamp
Timestamp getTimestamp(String columnLabel)
Definition: HeavyAIResultSet.java:487
ai.heavy.jdbc.HeavyAIResultSet.updateTimestamp
void updateTimestamp(String columnLabel, Timestamp x)
Definition: HeavyAIResultSet.java:1079
ai.heavy.jdbc.HeavyAIResultSet.getOffsetFromTZ
long getOffsetFromTZ(long actualmillis, Calendar cal, int precision)
Definition: HeavyAIResultSet.java:1421
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(int columnIndex, Reader reader, long length)
Definition: HeavyAIResultSet.java:1871
ai.heavy.jdbc.HeavyAIResultSet.getStringInternal
String getStringInternal(int columnIndex)
Definition: HeavyAIResultSet.java:134
ai.heavy.jdbc.HeavyAIResultSet.HeavyAIResultSet
HeavyAIResultSet(TQueryResult tsqlResult, String sql)
Definition: HeavyAIResultSet.java:55
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(int columnIndex, Blob x)
Definition: HeavyAIResultSet.java:1552
ai.heavy.jdbc.HeavyAIResultSet.updateDate
void updateDate(String columnLabel, Date x)
Definition: HeavyAIResultSet.java:1061
ai.heavy.jdbc.HeavyAIResultSet.getUnicodeStream
InputStream getUnicodeStream(int columnIndex)
Definition: HeavyAIResultSet.java:391
ai.heavy.jdbc.HeavyAIResultSet.getBytes
byte[] getBytes(int columnIndex)
Definition: HeavyAIResultSet.java:326
ai.heavy.jdbc.HeavyAIResultSet.updateBytes
void updateBytes(String columnLabel, byte[] x)
Definition: HeavyAIResultSet.java:1052
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(int columnIndex, InputStream x)
Definition: HeavyAIResultSet.java:1934
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(int columnIndex, InputStream inputStream, long length)
Definition: HeavyAIResultSet.java:1853
ai.heavy.jdbc.HeavyAIResultSet.getDouble
double getDouble(int columnIndex)
Definition: HeavyAIResultSet.java:261
ai.heavy.jdbc.HeavyAIResultSet.getClob
Clob getClob(String columnLabel)
Definition: HeavyAIResultSet.java:1404
ai.heavy.jdbc.HeavyAIResultSet.setFetchDirection
void setFetchDirection(int direction)
Definition: HeavyAIResultSet.java:726
ai.heavy.jdbc.HeavyAIResultSet.getObject
Object getObject(int columnIndex)
Definition: HeavyAIResultSet.java:545
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(int columnIndex, Reader x)
Definition: HeavyAIResultSet.java:1943
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(String columnLabel, Clob x)
Definition: HeavyAIResultSet.java:1579
ai.heavy.jdbc.HeavyAIResultSet.getBlob
Blob getBlob(String columnLabel)
Definition: HeavyAIResultSet.java:1395
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(int columnIndex, InputStream x, long length)
Definition: HeavyAIResultSet.java:1799
ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream
void updateNCharacterStream(int columnIndex, Reader x)
Definition: HeavyAIResultSet.java:1907
Double
Definition: HashJoinRuntime.h:120
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(int columnIndex, InputStream x, int length)
Definition: HeavyAIResultSet.java:926
ai.heavy.jdbc.HeavyAIResultSet.extract_complex_time
Timestamp extract_complex_time(long val, int precision)
Definition: HeavyAIResultSet.java:352
ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal
BigDecimal getBigDecimal(String columnLabel)
Definition: HeavyAIResultSet.java:634
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(String columnLabel, InputStream inputStream, long length)
Definition: HeavyAIResultSet.java:1862
ai.heavy.jdbc.HeavyAIResultSet.updateBytes
void updateBytes(int columnIndex, byte[] x)
Definition: HeavyAIResultSet.java:881
report.rows
tuple rows
Definition: report.py:114
ai.heavy.jdbc.HeavyAIResultSet.getTime
Time getTime(int columnIndex, Calendar cal)
Definition: HeavyAIResultSet.java:1467
ai.heavy.jdbc.HeavyAIResultSet.getString
String getString(int columnIndex)
Definition: HeavyAIResultSet.java:116
ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream
void updateNCharacterStream(String columnLabel, Reader reader)
Definition: HeavyAIResultSet.java:1916
ai.heavy.jdbc.HeavyAIResultSet.getObject
Object getObject(String columnLabel)
Definition: HeavyAIResultSet.java:586
ai.heavy.jdbc.HeavyAIResultSet.unwrap
public< T > T unwrap(Class< T > iface)
Definition: HeavyAIResultSet.java:2051
ai.heavy.jdbc.HeavyAIResultSet.getURL
URL getURL(String columnLabel)
Definition: HeavyAIResultSet.java:1525
ai.heavy.jdbc.HeavyAIResultSet.getDate
Date getDate(int columnIndex, Calendar cal)
Definition: HeavyAIResultSet.java:1444
ai.heavy.jdbc.HeavyAIResultSet.updateObject
void updateObject(String columnLabel, Object x, int scaleOrLength)
Definition: HeavyAIResultSet.java:1115
ai.heavy.jdbc.HeavyAIResultSet.getRowId
RowId getRowId(String columnLabel)
Definition: HeavyAIResultSet.java:1615
ai.heavy.jdbc.HeavyAIResultSet.findColumnByName
Integer findColumnByName(String name)
Definition: HeavyAIResultSet.java:2068
ai.heavy.jdbc.HeavyAIResultSet.getFloat
float getFloat(String columnLabel)
Definition: HeavyAIResultSet.java:448
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(int columnIndex, InputStream inputStream)
Definition: HeavyAIResultSet.java:1979
ai.heavy.jdbc.HeavyAIResultSet.getNString
String getNString(int columnIndex)
Definition: HeavyAIResultSet.java:1745
ai.heavy.jdbc.HeavyAIResultSet.getBinaryStream
InputStream getBinaryStream(String columnLabel)
Definition: HeavyAIResultSet.java:511
ai.heavy.jdbc.HeavyAIResultSet.getNCharacterStream
Reader getNCharacterStream(int columnIndex)
Definition: HeavyAIResultSet.java:1763
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(String columnLabel, Blob x)
Definition: HeavyAIResultSet.java:1561
ai.heavy.jdbc.HeavyAIResultSet.updateRowId
void updateRowId(String columnLabel, RowId x)
Definition: HeavyAIResultSet.java:1633
ai.heavy.jdbc.HeavyAIResultSet.updateByte
void updateByte(String columnLabel, byte x)
Definition: HeavyAIResultSet.java:980
ai.heavy.jdbc.HeavyAIResultSet.updateSQLXML
void updateSQLXML(int columnIndex, SQLXML xmlObject)
Definition: HeavyAIResultSet.java:1727
ai.heavy.jdbc.HeavyAIResultSet.updateInt
void updateInt(int columnIndex, int x)
Definition: HeavyAIResultSet.java:827
ai.heavy.jdbc.HeavyAIResultSet.updateShort
void updateShort(int columnIndex, short x)
Definition: HeavyAIResultSet.java:818
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(int columnIndex, Reader x, int length)
Definition: HeavyAIResultSet.java:935
ai.heavy.jdbc.HeavyAIResultSet.getSQLXML
SQLXML getSQLXML(int columnIndex)
Definition: HeavyAIResultSet.java:1709
ai.heavy.jdbc.HeavyAIResultSet.getTime
Time getTime(String columnLabel)
Definition: HeavyAIResultSet.java:481
ai.heavy.jdbc.HeavyAIResultSet.getObject
Object getObject(String columnLabel, Map< String, Class<?>> map)
Definition: HeavyAIResultSet.java:1377
ai.heavy.jdbc.HeavyAIResultSet.getBytes
byte[] getBytes(String columnLabel)
Definition: HeavyAIResultSet.java:466
ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal
BigDecimal getBigDecimal(int columnIndex)
Definition: HeavyAIResultSet.java:619
ai.heavy.jdbc.HeavyAIResultSet.updateNString
void updateNString(String columnLabel, String nString)
Definition: HeavyAIResultSet.java:1664
ai.heavy.jdbc.HeavyAIResultSet.updateFloat
void updateFloat(String columnLabel, float x)
Definition: HeavyAIResultSet.java:1016
ai.heavy.jdbc.HeavyAIResultSet.getAsciiStream
InputStream getAsciiStream(int columnIndex)
Definition: HeavyAIResultSet.java:382
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(int columnIndex, Reader reader, long length)
Definition: HeavyAIResultSet.java:1889
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(String columnLabel, Reader reader)
Definition: HeavyAIResultSet.java:1970
ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal
BigDecimal getBigDecimal(String columnLabel, int scale)
Definition: HeavyAIResultSet.java:460
ai.heavy.jdbc.HeavyAIResultSet.updateBoolean
void updateBoolean(String columnLabel, boolean x)
Definition: HeavyAIResultSet.java:971
ai.heavy.jdbc.HeavyAIResultSet.updateLong
void updateLong(String columnLabel, long x)
Definition: HeavyAIResultSet.java:1007
ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream
void updateNCharacterStream(String columnLabel, Reader reader, long length)
Definition: HeavyAIResultSet.java:1790
ai.heavy.jdbc.HeavyAIResultSet.getTimestamp
Timestamp getTimestamp(int columnIndex, Calendar cal)
Definition: HeavyAIResultSet.java:1491
ai.heavy.jdbc.HeavyAIResultSet.updateDouble
void updateDouble(int columnIndex, double x)
Definition: HeavyAIResultSet.java:854
ai.heavy.jdbc.HeavyAIResultSet.getLong
long getLong(String columnLabel)
Definition: HeavyAIResultSet.java:442
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(String columnLabel, InputStream x, long length)
Definition: HeavyAIResultSet.java:1826
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(String columnLabel, InputStream x)
Definition: HeavyAIResultSet.java:1952
ai.heavy.jdbc.HeavyAIResultSet.updateRef
void updateRef(int columnIndex, Ref x)
Definition: HeavyAIResultSet.java:1534
ai.heavy.jdbc.HeavyAIResultSet.updateNString
void updateNString(int columnIndex, String nString)
Definition: HeavyAIResultSet.java:1655
ai.heavy.jdbc.HeavyAIResultSet.getDouble
double getDouble(String columnLabel)
Definition: HeavyAIResultSet.java:454
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(String columnLabel, InputStream x, int length)
Definition: HeavyAIResultSet.java:1097
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(String columnLabel, InputStream x)
Definition: HeavyAIResultSet.java:1961
ai.heavy.jdbc.HeavyAIResultSet.updateBigDecimal
void updateBigDecimal(int columnIndex, BigDecimal x)
Definition: HeavyAIResultSet.java:863
ai.heavy.jdbc.HeavyAIResultSet.getUnicodeStream
InputStream getUnicodeStream(String columnLabel)
Definition: HeavyAIResultSet.java:502
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(int columnIndex, Reader reader)
Definition: HeavyAIResultSet.java:2015
ai.heavy.jdbc.HeavyAIResultSet.findColumn
int findColumn(String columnLabel)
Definition: HeavyAIResultSet.java:592
ai.heavy.jdbc.HeavyAIResultSet.getShort
short getShort(String columnLabel)
Definition: HeavyAIResultSet.java:430
ai.heavy.jdbc.HeavyAIResultSet.getCharacterStream
Reader getCharacterStream(String columnLabel)
Definition: HeavyAIResultSet.java:610
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(String columnLabel, InputStream x, long length)
Definition: HeavyAIResultSet.java:1835
ai.heavy.jdbc.HeavyAIResultSet.updateDouble
void updateDouble(String columnLabel, double x)
Definition: HeavyAIResultSet.java:1025
ai.heavy.jdbc.HeavyAIResultSet.updateBlob
void updateBlob(String columnLabel, InputStream inputStream)
Definition: HeavyAIResultSet.java:1988
ai.heavy.jdbc.HeavyAIResultSet.getDate
Date getDate(String columnLabel, Calendar cal)
Definition: HeavyAIResultSet.java:1462
ai.heavy.jdbc.HeavyAIResultSet.updateObject
void updateObject(int columnIndex, Object x, int scaleOrLength)
Definition: HeavyAIResultSet.java:944
ai.heavy.jdbc.HeavyAIResultSet.getObject
public< T > T getObject(String columnLabel, Class< T > type)
Definition: HeavyAIResultSet.java:2042
ai.heavy.jdbc.HeavyAIResultSet.updateSQLXML
void updateSQLXML(String columnLabel, SQLXML xmlObject)
Definition: HeavyAIResultSet.java:1736
ai.heavy.jdbc.HeavyAIResultSet.getTimestamp
Timestamp getTimestamp(String columnLabel, Calendar cal)
Definition: HeavyAIResultSet.java:1510
ai.heavy.jdbc.HeavyAIResultSet.updateFloat
void updateFloat(int columnIndex, float x)
Definition: HeavyAIResultSet.java:845
ai.heavy.jdbc.HeavyAIResultSet.updateBoolean
void updateBoolean(int columnIndex, boolean x)
Definition: HeavyAIResultSet.java:800
ai.heavy.jdbc.HeavyAIResultSet.getString
String getString(String columnLabel)
Definition: HeavyAIResultSet.java:409
ai.heavy.jdbc.HeavyAIResultSet.updateArray
void updateArray(String columnLabel, Array x)
Definition: HeavyAIResultSet.java:1597
ai.heavy.jdbc.HeavyAIResultSet.getDate
Date getDate(String columnLabel)
Definition: HeavyAIResultSet.java:475
ai.heavy.jdbc.HeavyAIResultSet.updateRef
void updateRef(String columnLabel, Ref x)
Definition: HeavyAIResultSet.java:1543
ai.heavy.jdbc.HeavyAIResultSet.getNCharacterStream
Reader getNCharacterStream(String columnLabel)
Definition: HeavyAIResultSet.java:1772
ai.heavy.jdbc.HeavyAIResultSet.updateString
void updateString(String columnLabel, String x)
Definition: HeavyAIResultSet.java:1043
ai.heavy.jdbc.HeavyAIResultSet.updateObject
void updateObject(String columnLabel, Object x)
Definition: HeavyAIResultSet.java:1124
ai.heavy.jdbc.HeavyAIResultSet.updateBinaryStream
void updateBinaryStream(int columnIndex, InputStream x, long length)
Definition: HeavyAIResultSet.java:1808
ExpressionRangeType::Integer
ai.heavy.jdbc.HeavyAIResultSet.updateArray
void updateArray(int columnIndex, Array x)
Definition: HeavyAIResultSet.java:1588
ai.heavy.jdbc.HeavyAIResultSet.getObject
public< T > T getObject(int columnIndex, Class< T > type)
Definition: HeavyAIResultSet.java:2033
ai.heavy.jdbc.HeavyAIResultSet.getFloat
float getFloat(int columnIndex)
Definition: HeavyAIResultSet.java:247
ai.heavy.jdbc.HeavyAIResultSet.getRef
Ref getRef(String columnLabel)
Definition: HeavyAIResultSet.java:1386
ai.heavy.jdbc.HeavyAIResultSet.getNClob
NClob getNClob(String columnLabel)
Definition: HeavyAIResultSet.java:1700
setup.name
string name
Definition: setup.in.py:72
ai.heavy.jdbc.HeavyAIResultSet.updateNClob
void updateNClob(int columnIndex, NClob nClob)
Definition: HeavyAIResultSet.java:1673
ai.heavy.jdbc.HeavyAIResultSet.getObject
Object getObject(int columnIndex, Map< String, Class<?>> map)
Definition: HeavyAIResultSet.java:1197
ai.heavy.jdbc.HeavyAIResultSet.updateByte
void updateByte(int columnIndex, byte x)
Definition: HeavyAIResultSet.java:809
ai.heavy.jdbc.HeavyAIResultSet.updateTime
void updateTime(int columnIndex, Time x)
Definition: HeavyAIResultSet.java:899
ai.heavy.jdbc.HeavyAIResultSet.getTimestamp
Timestamp getTimestamp(int columnIndex)
Definition: HeavyAIResultSet.java:347
ai.heavy.jdbc.HeavyAIResultSet.getDoubleInternal
double getDoubleInternal(int columnIndex)
Definition: HeavyAIResultSet.java:280
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(int columnIndex, Reader x, long length)
Definition: HeavyAIResultSet.java:1817
ExpressionRangeType::Float
ai.heavy.jdbc.HeavyAIResultSet.updateObject
void updateObject(int columnIndex, Object x)
Definition: HeavyAIResultSet.java:953
ai.heavy.jdbc.HeavyAIResultSet.getBinaryStream
InputStream getBinaryStream(int columnIndex)
Definition: HeavyAIResultSet.java:400
ai.heavy.jdbc.HeavyAIResultSet.updateCharacterStream
void updateCharacterStream(String columnLabel, Reader reader, long length)
Definition: HeavyAIResultSet.java:1844
ai.heavy.jdbc.HeavyAIResultSet.updateClob
void updateClob(String columnLabel, Reader reader, long length)
Definition: HeavyAIResultSet.java:1880
ai.heavy.jdbc.HeavyAIResultSet.getBigDecimal
BigDecimal getBigDecimal(int columnIndex, int scale)
Definition: HeavyAIResultSet.java:311
ai.heavy.jdbc.HeavyAIResultSet.updateNull
void updateNull(int columnIndex)
Definition: HeavyAIResultSet.java:791
ai.heavy.jdbc.HeavyAIResultSet.updateDate
void updateDate(int columnIndex, Date x)
Definition: HeavyAIResultSet.java:890
ai.heavy.jdbc.HeavyAIResultSet.columnMap
Map< String, Integer > columnMap
Definition: HeavyAIResultSet.java:50
ai.heavy.jdbc.HeavyAIResultSet.getByte
byte getByte(String columnLabel)
Definition: HeavyAIResultSet.java:421
ai.heavy.jdbc.HeavyAIResultSet.getBoolean
boolean getBoolean(int columnIndex)
Definition: HeavyAIResultSet.java:176
ai.heavy.jdbc.HeavyAIResultSet.updateNCharacterStream
void updateNCharacterStream(int columnIndex, Reader x, long length)
Definition: HeavyAIResultSet.java:1781
ai.heavy.jdbc.HeavyAIResultSet.updateAsciiStream
void updateAsciiStream(int columnIndex, InputStream x, int length)
Definition: HeavyAIResultSet.java:917
ai.heavy.jdbc.HeavyAIResultSet.getTime
Time getTime(String columnLabel, Calendar cal)
Definition: HeavyAIResultSet.java:1485
ai.heavy.jdbc.HeavyAIResultSet.getShort
short getShort(int columnIndex)
Definition: HeavyAIResultSet.java:203
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89
ai.heavy.jdbc.HeavyAIResultSet.updateNull
void updateNull(String columnLabel)
Definition: HeavyAIResultSet.java:962
ai.heavy.jdbc.HeavyAIResultSet.isWrapperFor
boolean isWrapperFor(Class<?> iface)
Definition: HeavyAIResultSet.java:2060
ai.heavy.jdbc.HeavyAIResultSet.getNString
String getNString(String columnLabel)
Definition: HeavyAIResultSet.java:1754