OmniSciDB  4201147b46
 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 
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 LINESTRING:
165  case POLYGON:
166  case MULTIPOLYGON:
167  return (String) getObject(columnIndex);
168  default:
169  throw new AssertionError(type.name());
170  }
171  }
172 
173  @Override
174  public boolean getBoolean(int columnIndex)
175  throws SQLException { // logger.debug("Entered "+ sql );
176  checkClosed();
177  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
178  wasNull = true;
179  return false;
180  } else {
181  // assume column is str already for now
182  wasNull = false;
183  if (rowSet.columns.get(columnIndex - 1).data.int_col.get(offset) == 0) {
184  return false;
185  } else {
186  return true;
187  }
188  }
189  }
190 
191  @Override
192  public byte getByte(int columnIndex)
193  throws SQLException { // logger.debug("Entered "+ sql );
194  throw new UnsupportedOperationException("Not supported yet,"
195  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
196  + " class:" + new Throwable().getStackTrace()[0].getClassName()
197  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
198  }
199 
200  @Override
201  public short getShort(int columnIndex)
202  throws SQLException { // logger.debug("Entered "+ sql );
203  checkClosed();
204  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
205  wasNull = true;
206  return 0;
207  } else {
208  // assume column is str already for now
209  wasNull = false;
210  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
211  return lObj.shortValue();
212  }
213  }
214 
215  @Override
216  public int getInt(int columnIndex)
217  throws SQLException { // logger.debug("Entered "+ sql );
218  checkClosed();
219  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
220  wasNull = true;
221  return 0;
222  } else {
223  // assume column is str already for now
224  wasNull = false;
225  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
226  return lObj.intValue();
227  }
228  }
229 
230  @Override
231  public long getLong(int columnIndex)
232  throws SQLException { // logger.debug("Entered "+ sql );
233  checkClosed();
234  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
235  wasNull = true;
236  return 0;
237  } else {
238  // assume column is str already for now
239  wasNull = false;
240  return rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
241  }
242  }
243 
244  @Override
245  public float getFloat(int columnIndex)
246  throws SQLException { // logger.debug("Entered "+ sql );
247  checkClosed();
248  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
249  wasNull = true;
250  return 0;
251  } else {
252  // assume column is str already for now
253  wasNull = false;
254  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset).floatValue();
255  }
256  }
257 
258  @Override
259  public double getDouble(int columnIndex)
260  throws SQLException { // logger.debug("Entered "+ sql );
261  checkClosed();
262  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
263  wasNull = true;
264  return 0;
265  } else {
266  // assume column is str already for now
267  wasNull = false;
268  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
269 
270  if (type == TDatumType.DOUBLE) {
271  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
272  } else {
273  return getDoubleInternal(columnIndex);
274  }
275  }
276  }
277 
278  private double getDoubleInternal(int columnIndex) throws SQLException {
279  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
280  switch (type) {
281  case TINYINT:
282  case SMALLINT:
283  case INT:
284  return (double) getInt(columnIndex);
285  case BIGINT:
286  return (double) getLong(columnIndex);
287  case FLOAT:
288  return (double) getFloat(columnIndex);
289  case DECIMAL:
290  return (double) getFloat(columnIndex);
291  case DOUBLE:
292  return getDouble(columnIndex);
293  case STR:
294  return Double.valueOf(getString(columnIndex));
295  case TIME:
296  return (double) getTime(columnIndex).getTime();
297  case TIMESTAMP:
298  return (double) getTimestamp(columnIndex).getTime();
299  case DATE:
300  return (double) getDate(columnIndex).getTime();
301  case BOOL:
302  return (double) (getBoolean(columnIndex) ? 1 : 0);
303  default:
304  throw new AssertionError(type.name());
305  }
306  }
307 
308  @Override
309  public BigDecimal getBigDecimal(int columnIndex, int scale)
310  throws SQLException { // logger.debug("Entered "+ sql );
311  checkClosed();
312  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
313  wasNull = true;
314  return null;
315  } else {
316  // assume column is str already for now
317  wasNull = false;
318  return BigDecimal.valueOf(
319  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
320  }
321  }
322 
323  @Override
324  public byte[] getBytes(int columnIndex)
325  throws SQLException { // logger.debug("Entered "+ sql );
326  throw new UnsupportedOperationException("Not supported yet,"
327  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
328  + " class:" + new Throwable().getStackTrace()[0].getClassName()
329  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
330  }
331 
332  @Override
333  public Date getDate(int columnIndex)
334  throws SQLException { // logger.debug("Entered "+ sql );
335  return getDate(columnIndex, null);
336  }
337 
338  @Override
339  public Time getTime(int columnIndex)
340  throws SQLException { // logger.debug("Entered "+ sql );
341  return getTime(columnIndex, null);
342  }
343 
344  @Override
345  public Timestamp getTimestamp(int columnIndex)
346  throws SQLException { // logger.debug("Entered "+ sql );
347  return getTimestamp(columnIndex, null);
348  }
349 
350  private Timestamp extract_complex_time(long val, int precision) {
351  long scale = (long) Math.pow(10, precision);
352  double nano_part = Math.abs(val) % scale;
353  if (val < 0) nano_part = -nano_part;
354  nano_part = (int) ((nano_part + scale) % scale) * (long) Math.pow(10, 9 - precision);
355  long micro_sec_value = (long) (val / scale);
356  // Round value
357  micro_sec_value = micro_sec_value - ((micro_sec_value < 0 && nano_part > 0) ? 1 : 0);
358  Timestamp tm = new Timestamp(
359  micro_sec_value * 1000); // convert to milli seconds and make a time
360  tm.setNanos((int) (nano_part));
361  return tm;
362  }
363 
364  private Timestamp adjust_precision(long val, int precision) {
365  switch (precision) {
366  case 0:
367  return new Timestamp(val * 1000);
368  case 3:
369  return new Timestamp(val);
370  case 6:
371  case 9:
372  return extract_complex_time(val, precision);
373  default:
374  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
375  + "] returned. Valid values 0,3,6,9");
376  }
377  }
378 
379  @Override
380  public InputStream getAsciiStream(int columnIndex)
381  throws SQLException { // logger.debug("Entered "+ sql );
382  throw new UnsupportedOperationException("Not supported yet,"
383  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
384  + " class:" + new Throwable().getStackTrace()[0].getClassName()
385  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
386  }
387 
388  @Override
389  public InputStream getUnicodeStream(int columnIndex)
390  throws SQLException { // logger.debug("Entered "+ sql );
391  throw new UnsupportedOperationException("Not supported yet,"
392  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
393  + " class:" + new Throwable().getStackTrace()[0].getClassName()
394  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
395  }
396 
397  @Override
398  public InputStream getBinaryStream(int columnIndex)
399  throws SQLException { // logger.debug("Entered "+ sql );
400  throw new UnsupportedOperationException("Not supported yet,"
401  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
402  + " class:" + new Throwable().getStackTrace()[0].getClassName()
403  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
404  }
405 
406  @Override
407  public String getString(String columnLabel)
408  throws SQLException { // logger.debug("Entered "+ sql );
409  return getString(findColumnByName(columnLabel));
410  }
411 
412  @Override
413  public boolean getBoolean(String columnLabel)
414  throws SQLException { // logger.debug("Entered "+ sql );
415  return getBoolean(findColumnByName(columnLabel));
416  }
417 
418  @Override
419  public byte getByte(String columnLabel)
420  throws SQLException { // logger.debug("Entered "+ sql );
421  throw new UnsupportedOperationException("Not supported yet,"
422  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
423  + " class:" + new Throwable().getStackTrace()[0].getClassName()
424  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
425  }
426 
427  @Override
428  public short getShort(String columnLabel)
429  throws SQLException { // logger.debug("Entered "+ sql );
430  return getShort(findColumnByName(columnLabel));
431  }
432 
433  @Override
434  public int getInt(String columnLabel)
435  throws SQLException { // logger.debug("Entered "+ sql );
436  return getInt(findColumnByName(columnLabel));
437  }
438 
439  @Override
440  public long getLong(String columnLabel)
441  throws SQLException { // logger.debug("Entered "+ sql );
442  return getLong(findColumnByName(columnLabel));
443  }
444 
445  @Override
446  public float getFloat(String columnLabel)
447  throws SQLException { // logger.debug("Entered "+ sql );
448  return getFloat(findColumnByName(columnLabel));
449  }
450 
451  @Override
452  public double getDouble(String columnLabel)
453  throws SQLException { // logger.debug("Entered "+ sql );
454  return getDouble(findColumnByName(columnLabel));
455  }
456 
457  @Override
458  public BigDecimal getBigDecimal(String columnLabel, int scale)
459  throws SQLException { // logger.debug("Entered "+ sql );
460  return getBigDecimal(findColumnByName(columnLabel));
461  }
462 
463  @Override
464  public byte[] getBytes(String columnLabel)
465  throws SQLException { // logger.debug("Entered "+ sql );
466  throw new UnsupportedOperationException("Not supported yet,"
467  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
468  + " class:" + new Throwable().getStackTrace()[0].getClassName()
469  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
470  }
471 
472  @Override
473  public Date getDate(String columnLabel)
474  throws SQLException { // logger.debug("Entered "+ sql );
475  return getDate(columnLabel, null);
476  }
477 
478  @Override
479  public Time getTime(String columnLabel)
480  throws SQLException { // logger.debug("Entered "+ sql );
481  return getTime(columnLabel, null);
482  }
483 
484  @Override
485  public Timestamp getTimestamp(String columnLabel)
486  throws SQLException { // logger.debug("Entered "+ sql );
487  return getTimestamp(columnLabel, null);
488  }
489 
490  @Override
491  public InputStream getAsciiStream(String columnLabel)
492  throws SQLException { // logger.debug("Entered "+ sql );
493  throw new UnsupportedOperationException("Not supported yet,"
494  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
495  + " class:" + new Throwable().getStackTrace()[0].getClassName()
496  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
497  }
498 
499  @Override
500  public InputStream getUnicodeStream(String columnLabel)
501  throws SQLException { // logger.debug("Entered "+ sql );
502  throw new UnsupportedOperationException("Not supported yet,"
503  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
504  + " class:" + new Throwable().getStackTrace()[0].getClassName()
505  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
506  }
507 
508  @Override
509  public InputStream getBinaryStream(String columnLabel)
510  throws SQLException { // logger.debug("Entered "+ sql );
511  throw new UnsupportedOperationException("Not supported yet,"
512  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
513  + " class:" + new Throwable().getStackTrace()[0].getClassName()
514  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
515  }
516 
517  @Override
518  public SQLWarning getWarnings() throws SQLException { // logger.debug("Entered "+ sql );
519  return warnings;
520  }
521 
522  @Override
523  public void clearWarnings() throws SQLException { // logger.debug("Entered "+ sql );
524  warnings = null;
525  }
526 
527  @Override
528  public String getCursorName() throws SQLException { // logger.debug("Entered "+ sql );
529  throw new UnsupportedOperationException("Not supported yet,"
530  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
531  + " class:" + new Throwable().getStackTrace()[0].getClassName()
532  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
533  }
534 
535  @Override
536  public ResultSetMetaData getMetaData()
537  throws SQLException { // logger.debug("Entered "+ sql );
538  checkClosed();
540  }
541 
542  @Override
543  public Object getObject(int columnIndex)
544  throws SQLException { // logger.debug("Entered "+ sql );
545  checkClosed();
546  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
547  wasNull = true;
548  return null;
549  } else {
550  wasNull = false;
551  if (rowDesc.get(columnIndex - 1).col_type.is_array) {
552  return getArray(columnIndex);
553  }
554 
555  switch (rowDesc.get(columnIndex - 1).col_type.type) {
556  case TINYINT:
557  case SMALLINT:
558  case INT:
559  case BIGINT:
560  case BOOL:
561  case TIME:
562  case TIMESTAMP:
563  case DATE:
564  return this.rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
565  case FLOAT:
566  case DECIMAL:
567  case DOUBLE:
568  return this.rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
569  case STR:
570  case POINT:
571  case LINESTRING:
572  case POLYGON:
573  case MULTIPOLYGON:
574  return this.rowSet.columns.get(columnIndex - 1).data.str_col.get(offset);
575  default:
576  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
577  }
578  }
579  }
580 
581  @Override
582  public Object getObject(String columnLabel)
583  throws SQLException { // logger.debug("Entered "+ sql );
584  return getObject(columnMap.get(columnLabel));
585  }
586 
587  @Override
588  public int findColumn(String columnLabel)
589  throws SQLException { // logger.debug("Entered "+ sql );
590  throw new UnsupportedOperationException("Not supported yet,"
591  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
592  + " class:" + new Throwable().getStackTrace()[0].getClassName()
593  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
594  }
595 
596  @Override
597  public Reader getCharacterStream(int columnIndex)
598  throws SQLException { // logger.debug("Entered "+ sql );
599  throw new UnsupportedOperationException("Not supported yet,"
600  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
601  + " class:" + new Throwable().getStackTrace()[0].getClassName()
602  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
603  }
604 
605  @Override
606  public Reader getCharacterStream(String columnLabel)
607  throws SQLException { // logger.debug("Entered "+ sql );
608  throw new UnsupportedOperationException("Not supported yet,"
609  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
610  + " class:" + new Throwable().getStackTrace()[0].getClassName()
611  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
612  }
613 
614  @Override
615  public BigDecimal getBigDecimal(int columnIndex)
616  throws SQLException { // logger.debug("Entered "+ sql );
617  checkClosed();
618  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
619  wasNull = true;
620  return null;
621  } else {
622  // assume column is str already for now
623  wasNull = false;
624  return BigDecimal.valueOf(
625  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
626  }
627  }
628 
629  @Override
630  public BigDecimal getBigDecimal(String columnLabel)
631  throws SQLException { // logger.debug("Entered "+ sql );
632  return getBigDecimal(columnMap.get(columnLabel));
633  }
634 
635  @Override
636  public boolean isBeforeFirst() throws SQLException { // logger.debug("Entered "+ sql );
637  return offset == -1;
638  }
639 
640  @Override
641  public boolean isAfterLast() throws SQLException { // logger.debug("Entered "+ sql );
642  return offset == numOfRecords;
643  }
644 
645  @Override
646  public boolean isFirst() throws SQLException { // logger.debug("Entered "+ sql );
647  return offset == 0;
648  }
649 
650  @Override
651  public boolean isLast() throws SQLException { // logger.debug("Entered "+ sql );
652  return offset == numOfRecords - 1;
653  }
654 
655  @Override
656  public void beforeFirst() throws SQLException { // logger.debug("Entered "+ sql );
657  throw new UnsupportedOperationException("Not supported yet,"
658  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
659  + " class:" + new Throwable().getStackTrace()[0].getClassName()
660  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
661  }
662 
663  @Override
664  public void afterLast() throws SQLException { // logger.debug("Entered "+ sql );
665  throw new UnsupportedOperationException("Not supported yet,"
666  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
667  + " class:" + new Throwable().getStackTrace()[0].getClassName()
668  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
669  }
670 
671  @Override
672  public boolean first() throws SQLException { // logger.debug("Entered "+ sql );
673  throw new UnsupportedOperationException("Not supported yet,"
674  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
675  + " class:" + new Throwable().getStackTrace()[0].getClassName()
676  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
677  }
678 
679  @Override
680  public boolean last() throws SQLException { // logger.debug("Entered "+ sql );
681  throw new UnsupportedOperationException("Not supported yet,"
682  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
683  + " class:" + new Throwable().getStackTrace()[0].getClassName()
684  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
685  }
686 
687  @Override
688  public int getRow() throws SQLException { // logger.debug("Entered "+ sql );
689  throw new UnsupportedOperationException("Not supported yet,"
690  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
691  + " class:" + new Throwable().getStackTrace()[0].getClassName()
692  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
693  }
694 
695  @Override
696  public boolean absolute(int row)
697  throws SQLException { // logger.debug("Entered "+ sql );
698  throw new UnsupportedOperationException("Not supported yet,"
699  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
700  + " class:" + new Throwable().getStackTrace()[0].getClassName()
701  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
702  }
703 
704  @Override
705  public boolean relative(int rows)
706  throws SQLException { // logger.debug("Entered "+ sql );
707  throw new UnsupportedOperationException("Not supported yet,"
708  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
709  + " class:" + new Throwable().getStackTrace()[0].getClassName()
710  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
711  }
712 
713  @Override
714  public boolean previous() throws SQLException { // logger.debug("Entered "+ sql );
715  throw new UnsupportedOperationException("Not supported yet,"
716  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
717  + " class:" + new Throwable().getStackTrace()[0].getClassName()
718  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
719  }
720 
721  @Override
722  public void setFetchDirection(int direction)
723  throws SQLException { // logger.debug("Entered "+ sql );
724  throw new UnsupportedOperationException("Not supported yet,"
725  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
726  + " class:" + new Throwable().getStackTrace()[0].getClassName()
727  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
728  }
729 
730  @Override
731  public int getFetchDirection() throws SQLException { // logger.debug("Entered "+ sql );
732  return FETCH_FORWARD;
733  }
734 
735  @Override
736  public void setFetchSize(int rows)
737  throws SQLException { // logger.debug("Entered "+ sql );
738  fetchSize = rows;
739  }
740 
741  @Override
742  public int getFetchSize() throws SQLException { // logger.debug("Entered "+ sql );
743  throw new UnsupportedOperationException("Not supported yet,"
744  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
745  + " class:" + new Throwable().getStackTrace()[0].getClassName()
746  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
747  }
748 
749  @Override
750  public int getType() throws SQLException { // logger.debug("Entered "+ sql );
751  return TYPE_FORWARD_ONLY;
752  }
753 
754  @Override
755  public int getConcurrency() throws SQLException { // logger.debug("Entered "+ sql );
756  throw new UnsupportedOperationException("Not supported yet,"
757  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
758  + " class:" + new Throwable().getStackTrace()[0].getClassName()
759  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
760  }
761 
762  @Override
763  public boolean rowUpdated() throws SQLException { // logger.debug("Entered "+ sql );
764  throw new UnsupportedOperationException("Not supported yet,"
765  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
766  + " class:" + new Throwable().getStackTrace()[0].getClassName()
767  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
768  }
769 
770  @Override
771  public boolean rowInserted() throws SQLException { // logger.debug("Entered "+ sql );
772  throw new UnsupportedOperationException("Not supported yet,"
773  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
774  + " class:" + new Throwable().getStackTrace()[0].getClassName()
775  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
776  }
777 
778  @Override
779  public boolean rowDeleted() throws SQLException { // logger.debug("Entered "+ sql );
780  throw new UnsupportedOperationException("Not supported yet,"
781  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
782  + " class:" + new Throwable().getStackTrace()[0].getClassName()
783  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
784  }
785 
786  @Override
787  public void updateNull(int columnIndex)
788  throws SQLException { // logger.debug("Entered "+ sql );
789  throw new UnsupportedOperationException("Not supported yet,"
790  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
791  + " class:" + new Throwable().getStackTrace()[0].getClassName()
792  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
793  }
794 
795  @Override
796  public void updateBoolean(int columnIndex, boolean x)
797  throws SQLException { // logger.debug("Entered "+ sql );
798  throw new UnsupportedOperationException("Not supported yet,"
799  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
800  + " class:" + new Throwable().getStackTrace()[0].getClassName()
801  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
802  }
803 
804  @Override
805  public void updateByte(int columnIndex, byte x)
806  throws SQLException { // logger.debug("Entered "+ sql );
807  throw new UnsupportedOperationException("Not supported yet,"
808  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
809  + " class:" + new Throwable().getStackTrace()[0].getClassName()
810  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
811  }
812 
813  @Override
814  public void updateShort(int columnIndex, short x)
815  throws SQLException { // logger.debug("Entered "+ sql );
816  throw new UnsupportedOperationException("Not supported yet,"
817  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
818  + " class:" + new Throwable().getStackTrace()[0].getClassName()
819  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
820  }
821 
822  @Override
823  public void updateInt(int columnIndex, int x)
824  throws SQLException { // logger.debug("Entered "+ sql );
825  throw new UnsupportedOperationException("Not supported yet,"
826  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
827  + " class:" + new Throwable().getStackTrace()[0].getClassName()
828  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
829  }
830 
831  @Override
832  public void updateLong(int columnIndex, long x)
833  throws SQLException { // logger.debug("Entered "+ sql );
834  throw new UnsupportedOperationException("Not supported yet,"
835  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
836  + " class:" + new Throwable().getStackTrace()[0].getClassName()
837  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
838  }
839 
840  @Override
841  public void updateFloat(int columnIndex, float x)
842  throws SQLException { // logger.debug("Entered "+ sql );
843  throw new UnsupportedOperationException("Not supported yet,"
844  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
845  + " class:" + new Throwable().getStackTrace()[0].getClassName()
846  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
847  }
848 
849  @Override
850  public void updateDouble(int columnIndex, double x)
851  throws SQLException { // logger.debug("Entered "+ sql );
852  throw new UnsupportedOperationException("Not supported yet,"
853  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
854  + " class:" + new Throwable().getStackTrace()[0].getClassName()
855  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
856  }
857 
858  @Override
859  public void updateBigDecimal(int columnIndex, BigDecimal x)
860  throws SQLException { // logger.debug("Entered "+ sql );
861  throw new UnsupportedOperationException("Not supported yet,"
862  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
863  + " class:" + new Throwable().getStackTrace()[0].getClassName()
864  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
865  }
866 
867  @Override
868  public void updateString(int columnIndex, String x)
869  throws SQLException { // logger.debug("Entered "+ sql );
870  throw new UnsupportedOperationException("Not supported yet,"
871  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
872  + " class:" + new Throwable().getStackTrace()[0].getClassName()
873  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
874  }
875 
876  @Override
877  public void updateBytes(int columnIndex, byte[] x)
878  throws SQLException { // logger.debug("Entered "+ sql );
879  throw new UnsupportedOperationException("Not supported yet,"
880  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
881  + " class:" + new Throwable().getStackTrace()[0].getClassName()
882  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
883  }
884 
885  @Override
886  public void updateDate(int columnIndex, Date x)
887  throws SQLException { // logger.debug("Entered "+ sql );
888  throw new UnsupportedOperationException("Not supported yet,"
889  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
890  + " class:" + new Throwable().getStackTrace()[0].getClassName()
891  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
892  }
893 
894  @Override
895  public void updateTime(int columnIndex, Time x)
896  throws SQLException { // logger.debug("Entered "+ sql );
897  throw new UnsupportedOperationException("Not supported yet,"
898  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
899  + " class:" + new Throwable().getStackTrace()[0].getClassName()
900  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
901  }
902 
903  @Override
904  public void updateTimestamp(int columnIndex, Timestamp x)
905  throws SQLException { // logger.debug("Entered "+ sql );
906  throw new UnsupportedOperationException("Not supported yet,"
907  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
908  + " class:" + new Throwable().getStackTrace()[0].getClassName()
909  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
910  }
911 
912  @Override
913  public void updateAsciiStream(int columnIndex, InputStream x, int length)
914  throws SQLException { // logger.debug("Entered "+ sql );
915  throw new UnsupportedOperationException("Not supported yet,"
916  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
917  + " class:" + new Throwable().getStackTrace()[0].getClassName()
918  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
919  }
920 
921  @Override
922  public void updateBinaryStream(int columnIndex, InputStream x, int length)
923  throws SQLException { // logger.debug("Entered "+ sql );
924  throw new UnsupportedOperationException("Not supported yet,"
925  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
926  + " class:" + new Throwable().getStackTrace()[0].getClassName()
927  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
928  }
929 
930  @Override
931  public void updateCharacterStream(int columnIndex, Reader x, int length)
932  throws SQLException { // logger.debug("Entered "+ sql );
933  throw new UnsupportedOperationException("Not supported yet,"
934  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
935  + " class:" + new Throwable().getStackTrace()[0].getClassName()
936  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
937  }
938 
939  @Override
940  public void updateObject(int columnIndex, Object x, int scaleOrLength)
941  throws SQLException { // logger.debug("Entered "+ sql );
942  throw new UnsupportedOperationException("Not supported yet,"
943  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
944  + " class:" + new Throwable().getStackTrace()[0].getClassName()
945  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
946  }
947 
948  @Override
949  public void updateObject(int columnIndex, Object x)
950  throws SQLException { // logger.debug("Entered "+ sql );
951  throw new UnsupportedOperationException("Not supported yet,"
952  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
953  + " class:" + new Throwable().getStackTrace()[0].getClassName()
954  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
955  }
956 
957  @Override
958  public void updateNull(String columnLabel)
959  throws SQLException { // logger.debug("Entered "+ sql );
960  throw new UnsupportedOperationException("Not supported yet,"
961  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
962  + " class:" + new Throwable().getStackTrace()[0].getClassName()
963  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
964  }
965 
966  @Override
967  public void updateBoolean(String columnLabel, boolean x)
968  throws SQLException { // logger.debug("Entered "+ sql );
969  throw new UnsupportedOperationException("Not supported yet,"
970  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
971  + " class:" + new Throwable().getStackTrace()[0].getClassName()
972  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
973  }
974 
975  @Override
976  public void updateByte(String columnLabel, byte x)
977  throws SQLException { // logger.debug("Entered "+ sql );
978  throw new UnsupportedOperationException("Not supported yet,"
979  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
980  + " class:" + new Throwable().getStackTrace()[0].getClassName()
981  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
982  }
983 
984  @Override
985  public void updateShort(String columnLabel, short x)
986  throws SQLException { // logger.debug("Entered "+ sql );
987  throw new UnsupportedOperationException("Not supported yet,"
988  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
989  + " class:" + new Throwable().getStackTrace()[0].getClassName()
990  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
991  }
992 
993  @Override
994  public void updateInt(String columnLabel, int x)
995  throws SQLException { // logger.debug("Entered "+ sql );
996  throw new UnsupportedOperationException("Not supported yet,"
997  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
998  + " class:" + new Throwable().getStackTrace()[0].getClassName()
999  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1000  }
1001 
1002  @Override
1003  public void updateLong(String columnLabel, long x)
1004  throws SQLException { // logger.debug("Entered "+ sql );
1005  throw new UnsupportedOperationException("Not supported yet,"
1006  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1007  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1008  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1009  }
1010 
1011  @Override
1012  public void updateFloat(String columnLabel, float x)
1013  throws SQLException { // logger.debug("Entered "+ sql );
1014  throw new UnsupportedOperationException("Not supported yet,"
1015  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1016  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1017  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1018  }
1019 
1020  @Override
1021  public void updateDouble(String columnLabel, double x)
1022  throws SQLException { // logger.debug("Entered "+ sql );
1023  throw new UnsupportedOperationException("Not supported yet,"
1024  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1025  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1026  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1027  }
1028 
1029  @Override
1030  public void updateBigDecimal(String columnLabel, BigDecimal x)
1031  throws SQLException { // logger.debug("Entered "+ sql );
1032  throw new UnsupportedOperationException("Not supported yet,"
1033  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1034  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1035  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1036  }
1037 
1038  @Override
1039  public void updateString(String columnLabel, String x)
1040  throws SQLException { // logger.debug("Entered "+ sql );
1041  throw new UnsupportedOperationException("Not supported yet,"
1042  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1043  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1044  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1045  }
1046 
1047  @Override
1048  public void updateBytes(String columnLabel, byte[] x)
1049  throws SQLException { // logger.debug("Entered "+ sql );
1050  throw new UnsupportedOperationException("Not supported yet,"
1051  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1052  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1053  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1054  }
1055 
1056  @Override
1057  public void updateDate(String columnLabel, Date x)
1058  throws SQLException { // logger.debug("Entered "+ sql );
1059  throw new UnsupportedOperationException("Not supported yet,"
1060  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1061  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1062  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1063  }
1064 
1065  @Override
1066  public void updateTime(String columnLabel, Time x)
1067  throws SQLException { // logger.debug("Entered "+ sql );
1068  throw new UnsupportedOperationException("Not supported yet,"
1069  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1070  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1071  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1072  }
1073 
1074  @Override
1075  public void updateTimestamp(String columnLabel, Timestamp x)
1076  throws SQLException { // logger.debug("Entered "+ sql );
1077  throw new UnsupportedOperationException("Not supported yet,"
1078  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1079  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1080  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1081  }
1082 
1083  @Override
1084  public void updateAsciiStream(String columnLabel, InputStream x, int length)
1085  throws SQLException { // logger.debug("Entered "+ sql );
1086  throw new UnsupportedOperationException("Not supported yet,"
1087  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1088  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1089  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1090  }
1091 
1092  @Override
1093  public void updateBinaryStream(String columnLabel, InputStream x, int length)
1094  throws SQLException { // logger.debug("Entered "+ sql );
1095  throw new UnsupportedOperationException("Not supported yet,"
1096  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1097  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1098  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1099  }
1100 
1101  @Override
1102  public void updateCharacterStream(String columnLabel, Reader reader, int length)
1103  throws SQLException { // logger.debug("Entered "+ sql );
1104  throw new UnsupportedOperationException("Not supported yet,"
1105  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1106  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1107  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1108  }
1109 
1110  @Override
1111  public void updateObject(String columnLabel, Object x, int scaleOrLength)
1112  throws SQLException { // logger.debug("Entered "+ sql );
1113  throw new UnsupportedOperationException("Not supported yet,"
1114  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1115  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1116  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1117  }
1118 
1119  @Override
1120  public void updateObject(String columnLabel, Object x)
1121  throws SQLException { // logger.debug("Entered "+ sql );
1122  throw new UnsupportedOperationException("Not supported yet,"
1123  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1124  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1125  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1126  }
1127 
1128  @Override
1129  public void insertRow() throws SQLException { // logger.debug("Entered "+ sql );
1130  throw new UnsupportedOperationException("Not supported yet,"
1131  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1132  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1133  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1134  }
1135 
1136  @Override
1137  public void updateRow() throws SQLException { // logger.debug("Entered "+ sql );
1138  throw new UnsupportedOperationException("Not supported yet,"
1139  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1140  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1141  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1142  }
1143 
1144  @Override
1145  public void deleteRow() throws SQLException { // logger.debug("Entered "+ sql );
1146  throw new UnsupportedOperationException("Not supported yet,"
1147  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1148  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1149  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1150  }
1151 
1152  @Override
1153  public void refreshRow() throws SQLException { // logger.debug("Entered "+ sql );
1154  throw new UnsupportedOperationException("Not supported yet,"
1155  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1156  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1157  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1158  }
1159 
1160  @Override
1161  public void cancelRowUpdates() throws SQLException { // logger.debug("Entered "+ sql );
1162  throw new UnsupportedOperationException("Not supported yet,"
1163  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1164  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1165  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1166  }
1167 
1168  @Override
1169  public void moveToInsertRow() throws SQLException { // logger.debug("Entered "+ sql );
1170  throw new UnsupportedOperationException("Not supported yet,"
1171  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1172  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1173  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1174  }
1175 
1176  @Override
1177  public void moveToCurrentRow() throws SQLException { // logger.debug("Entered "+ sql );
1178  throw new UnsupportedOperationException("Not supported yet,"
1179  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1180  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1181  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1182  }
1183 
1184  @Override
1185  public Statement getStatement() throws SQLException { // logger.debug("Entered "+ sql );
1186  throw new UnsupportedOperationException("Not supported yet,"
1187  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1188  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1189  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1190  }
1191 
1192  @Override
1193  public Object getObject(int columnIndex, Map<String, Class<?>> map)
1194  throws SQLException { // logger.debug("Entered "+ sql );
1195  throw new UnsupportedOperationException("Not supported yet,"
1196  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1197  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1198  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1199  }
1200 
1201  @Override
1202  public Ref getRef(int columnIndex)
1203  throws SQLException { // logger.debug("Entered "+ sql );
1204  throw new UnsupportedOperationException("Not supported yet,"
1205  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1206  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1207  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1208  }
1209 
1210  @Override
1211  public Blob getBlob(int columnIndex)
1212  throws SQLException { // logger.debug("Entered "+ sql );
1213  throw new UnsupportedOperationException("Not supported yet,"
1214  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1215  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1216  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1217  }
1218 
1219  @Override
1220  public Clob getClob(int columnIndex)
1221  throws SQLException { // logger.debug("Entered "+ sql );
1222  throw new UnsupportedOperationException("Not supported yet,"
1223  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1224  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1225  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1226  }
1227 
1228  @Override
1229  public Array getArray(int columnIndex)
1230  throws SQLException { // logger.debug("Entered "+ sql );
1231  checkClosed();
1232  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1233  wasNull = true;
1234  return null;
1235  } else {
1236  wasNull = false;
1237  if (!rowDesc.get(columnIndex - 1).col_type.is_array) {
1238  throw new SQLException(
1239  "Column " + rowDesc.get(columnIndex - 1).col_name + " is not an array");
1240  }
1241 
1242  Object[] elements;
1243  int size =
1244  rowSet.columns.get(columnIndex - 1).data.arr_col.get(offset).nulls.size();
1245  switch (rowDesc.get(columnIndex - 1).col_type.type) {
1246  case TINYINT:
1247  elements = new Byte[size];
1248  for (int i = 0; i < size; ++i) {
1249  elements[i] = rowSet.columns.get(columnIndex - 1)
1250  .data.arr_col.get(offset)
1251  .data.int_col.get(i)
1252  .byteValue();
1253  }
1254  break;
1255  case SMALLINT:
1256  elements = new Short[size];
1257  for (int i = 0; i < size; ++i) {
1258  elements[i] = rowSet.columns.get(columnIndex - 1)
1259  .data.arr_col.get(offset)
1260  .data.int_col.get(i)
1261  .shortValue();
1262  }
1263  break;
1264  case INT:
1265  elements = new Integer[size];
1266  for (int i = 0; i < size; ++i) {
1267  elements[i] = rowSet.columns.get(columnIndex - 1)
1268  .data.arr_col.get(offset)
1269  .data.int_col.get(i)
1270  .intValue();
1271  }
1272  break;
1273  case BIGINT:
1274  elements = new Long[size];
1275  for (int i = 0; i < size; ++i) {
1276  elements[i] = rowSet.columns.get(columnIndex - 1)
1277  .data.arr_col.get(offset)
1278  .data.int_col.get(i);
1279  }
1280  break;
1281  case BOOL:
1282  elements = new Boolean[size];
1283  for (int i = 0; i < size; ++i) {
1284  elements[i] = rowSet.columns.get(columnIndex - 1)
1285  .data.arr_col.get(offset)
1286  .data.int_col.get(i)
1287  == 0;
1288  }
1289  break;
1290  case TIME:
1291  elements = new Time[size];
1292  for (int i = 0; i < size; ++i) {
1293  elements[i] = new Time(rowSet.columns.get(columnIndex - 1)
1294  .data.arr_col.get(offset)
1295  .data.int_col.get(i)
1296  * 1000);
1297  }
1298  break;
1299  case TIMESTAMP:
1300  elements = new Timestamp[size];
1301  for (int i = 0; i < size; ++i) {
1302  elements[i] = adjust_precision(rowSet.columns.get(columnIndex - 1)
1303  .data.arr_col.get(offset)
1304  .data.int_col.get(i),
1305  rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision());
1306  }
1307  break;
1308  case DATE:
1309  elements = new Date[size];
1310  for (int i = 0; i < size; ++i) {
1311  elements[i] = new Date(rowSet.columns.get(columnIndex - 1)
1312  .data.arr_col.get(offset)
1313  .data.int_col.get(i)
1314  * 1000);
1315  }
1316  break;
1317  case FLOAT:
1318  elements = new Float[size];
1319  for (int i = 0; i < size; ++i) {
1320  elements[i] = rowSet.columns.get(columnIndex - 1)
1321  .data.arr_col.get(offset)
1322  .data.real_col.get(i)
1323  .floatValue();
1324  }
1325  break;
1326  case DECIMAL:
1327  elements = new BigDecimal[size];
1328  for (int i = 0; i < size; ++i) {
1329  elements[i] = BigDecimal.valueOf(rowSet.columns.get(columnIndex - 1)
1330  .data.arr_col.get(offset)
1331  .data.real_col.get(i));
1332  }
1333  break;
1334  case DOUBLE:
1335  elements = new Double[size];
1336  for (int i = 0; i < size; ++i) {
1337  elements[i] = rowSet.columns.get(columnIndex - 1)
1338  .data.arr_col.get(offset)
1339  .data.real_col.get(i);
1340  }
1341  break;
1342  case STR:
1343  case POINT:
1344  case LINESTRING:
1345  case POLYGON:
1346  case MULTIPOLYGON:
1347  elements = new String[size];
1348  for (int i = 0; i < size; ++i) {
1349  elements[i] = rowSet.columns.get(columnIndex - 1)
1350  .data.arr_col.get(offset)
1351  .data.str_col.get(i);
1352  }
1353  break;
1354  default:
1355  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
1356  }
1357 
1358  for (int i = 0; i < size; ++i) {
1359  if (this.rowSet.columns.get(columnIndex - 1)
1360  .data.arr_col.get(offset)
1361  .nulls.get(i)) {
1362  elements[i] = null;
1363  }
1364  }
1365 
1366  return new HeavyAIArray(rowDesc.get(columnIndex - 1).col_type.type, elements);
1367  }
1368  }
1369 
1370  @Override
1371  public Object getObject(String columnLabel, Map<String, Class<?>> map)
1372  throws SQLException { // logger.debug("Entered "+ sql );
1373  throw new UnsupportedOperationException("Not supported yet,"
1374  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1375  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1376  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1377  }
1378 
1379  @Override
1380  public Ref getRef(String columnLabel)
1381  throws SQLException { // logger.debug("Entered "+ sql );
1382  throw new UnsupportedOperationException("Not supported yet,"
1383  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1384  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1385  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1386  }
1387 
1388  @Override
1389  public Blob getBlob(String columnLabel)
1390  throws SQLException { // logger.debug("Entered "+ sql );
1391  throw new UnsupportedOperationException("Not supported yet,"
1392  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1393  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1394  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1395  }
1396 
1397  @Override
1398  public Clob getClob(String columnLabel)
1399  throws SQLException { // logger.debug("Entered "+ sql );
1400  throw new UnsupportedOperationException("Not supported yet,"
1401  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1402  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1403  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1404  }
1405 
1406  @Override
1407  public Array getArray(String columnLabel)
1408  throws SQLException { // logger.debug("Entered "+ sql );
1409  return getArray(findColumnByName(columnLabel));
1410  }
1411 
1412  // this method is used to add a TZ from Calendar; is TimeZone in the calendar
1413  // isn't
1414  // specified it uses the local TZ
1415  private long getOffsetFromTZ(long actualmillis, Calendar cal, int precision) {
1416  long offset;
1417  if (cal.getTimeZone() != null) {
1418  offset = cal.getTimeZone().getOffset(actualmillis);
1419  } else {
1420  offset = Calendar.getInstance().getTimeZone().getOffset(actualmillis);
1421  }
1422  switch (precision) {
1423  case 0:
1424  return offset / 1000;
1425  case 3:
1426  return offset;
1427  case 6:
1428  return offset * 1000;
1429  case 9:
1430  return offset * 1000000;
1431  default:
1432  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
1433  + "] returned. Valid values 0,3,6,9");
1434  }
1435  }
1436 
1437  @Override
1438  public Date getDate(int columnIndex, Calendar cal) throws SQLException {
1439  checkClosed();
1440  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1441  wasNull = true;
1442  return null;
1443  } else {
1444  // assume column is str already for now
1445  wasNull = false;
1446  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1447  if (cal != null) {
1448  val += getOffsetFromTZ(val, cal, 0);
1449  }
1450  Date d = new Date(val * 1000);
1451  return d;
1452  }
1453  }
1454 
1455  @Override
1456  public Date getDate(String columnLabel, Calendar cal) throws SQLException {
1457  return getDate(findColumnByName(columnLabel), cal);
1458  }
1459 
1460  @Override
1461  public Time getTime(int columnIndex, Calendar cal)
1462  throws SQLException { // logger.debug("Entered "+ sql );
1463  checkClosed();
1464  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1465  wasNull = true;
1466  return null;
1467  } else {
1468  // assume column is str already for now
1469  wasNull = false;
1470  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1471  if (cal != null) {
1472  val += getOffsetFromTZ(val, cal, 0);
1473  }
1474  return new Time(val * 1000);
1475  }
1476  }
1477 
1478  @Override
1479  public Time getTime(String columnLabel, Calendar cal)
1480  throws SQLException { // logger.debug("Entered "+ sql );
1481  return getTime(findColumnByName(columnLabel), cal);
1482  }
1483 
1484  @Override
1485  public Timestamp getTimestamp(int columnIndex, Calendar cal)
1486  throws SQLException { // logger.debug("Entered "+ sql );
1487  checkClosed();
1488  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1489  wasNull = true;
1490  return null;
1491  } else {
1492  // assume column is str already for now
1493  wasNull = false;
1494  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1495  int precision = rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision();
1496  if (cal != null) {
1497  val += getOffsetFromTZ(val, cal, precision);
1498  }
1499  return adjust_precision(val, precision);
1500  }
1501  }
1502 
1503  @Override
1504  public Timestamp getTimestamp(String columnLabel, Calendar cal)
1505  throws SQLException { // logger.debug("Entered "+ sql );
1506  return getTimestamp(findColumnByName(columnLabel), cal);
1507  }
1508 
1509  @Override
1510  public URL getURL(int columnIndex)
1511  throws SQLException { // logger.debug("Entered "+ sql );
1512  throw new UnsupportedOperationException("Not supported yet,"
1513  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1514  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1515  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1516  }
1517 
1518  @Override
1519  public URL getURL(String columnLabel)
1520  throws SQLException { // logger.debug("Entered "+ sql );
1521  throw new UnsupportedOperationException("Not supported yet,"
1522  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1523  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1524  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1525  }
1526 
1527  @Override
1528  public void updateRef(int columnIndex, Ref x)
1529  throws SQLException { // logger.debug("Entered "+ sql );
1530  throw new UnsupportedOperationException("Not supported yet,"
1531  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1532  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1533  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1534  }
1535 
1536  @Override
1537  public void updateRef(String columnLabel, Ref x)
1538  throws SQLException { // logger.debug("Entered "+ sql );
1539  throw new UnsupportedOperationException("Not supported yet,"
1540  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1541  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1542  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1543  }
1544 
1545  @Override
1546  public void updateBlob(int columnIndex, Blob x)
1547  throws SQLException { // logger.debug("Entered "+ sql );
1548  throw new UnsupportedOperationException("Not supported yet,"
1549  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1550  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1551  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1552  }
1553 
1554  @Override
1555  public void updateBlob(String columnLabel, Blob x)
1556  throws SQLException { // logger.debug("Entered "+ sql );
1557  throw new UnsupportedOperationException("Not supported yet,"
1558  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1559  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1560  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1561  }
1562 
1563  @Override
1564  public void updateClob(int columnIndex, Clob x)
1565  throws SQLException { // logger.debug("Entered "+ sql );
1566  throw new UnsupportedOperationException("Not supported yet,"
1567  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1568  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1569  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1570  }
1571 
1572  @Override
1573  public void updateClob(String columnLabel, Clob x)
1574  throws SQLException { // logger.debug("Entered "+ sql );
1575  throw new UnsupportedOperationException("Not supported yet,"
1576  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1577  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1578  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1579  }
1580 
1581  @Override
1582  public void updateArray(int columnIndex, Array x)
1583  throws SQLException { // logger.debug("Entered "+ sql );
1584  throw new UnsupportedOperationException("Not supported yet,"
1585  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1586  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1587  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1588  }
1589 
1590  @Override
1591  public void updateArray(String columnLabel, Array x)
1592  throws SQLException { // logger.debug("Entered "+ sql );
1593  throw new UnsupportedOperationException("Not supported yet,"
1594  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1595  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1596  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1597  }
1598 
1599  @Override
1600  public RowId getRowId(int columnIndex)
1601  throws SQLException { // logger.debug("Entered "+ sql );
1602  throw new UnsupportedOperationException("Not supported yet,"
1603  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1604  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1605  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1606  }
1607 
1608  @Override
1609  public RowId getRowId(String columnLabel)
1610  throws SQLException { // logger.debug("Entered "+ sql );
1611  throw new UnsupportedOperationException("Not supported yet,"
1612  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1613  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1614  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1615  }
1616 
1617  @Override
1618  public void updateRowId(int columnIndex, RowId x)
1619  throws SQLException { // logger.debug("Entered "+ sql );
1620  throw new UnsupportedOperationException("Not supported yet,"
1621  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1622  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1623  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1624  }
1625 
1626  @Override
1627  public void updateRowId(String columnLabel, RowId x)
1628  throws SQLException { // logger.debug("Entered "+ sql );
1629  throw new UnsupportedOperationException("Not supported yet,"
1630  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1631  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1632  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1633  }
1634 
1635  @Override
1636  public int getHoldability() throws SQLException { // logger.debug("Entered "+ sql );
1637  throw new UnsupportedOperationException("Not supported yet,"
1638  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1639  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1640  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1641  }
1642 
1643  @Override
1644  public boolean isClosed() throws SQLException { // logger.debug("Entered "+ sql );
1645  return isClosed;
1646  }
1647 
1648  @Override
1649  public void updateNString(int columnIndex, String nString)
1650  throws SQLException { // logger.debug("Entered "+ sql );
1651  throw new UnsupportedOperationException("Not supported yet,"
1652  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1653  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1654  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1655  }
1656 
1657  @Override
1658  public void updateNString(String columnLabel, String nString)
1659  throws SQLException { // logger.debug("Entered "+ sql );
1660  throw new UnsupportedOperationException("Not supported yet,"
1661  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1662  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1663  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1664  }
1665 
1666  @Override
1667  public void updateNClob(int columnIndex, NClob nClob)
1668  throws SQLException { // logger.debug("Entered "+ sql );
1669  throw new UnsupportedOperationException("Not supported yet,"
1670  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1671  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1672  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1673  }
1674 
1675  @Override
1676  public void updateNClob(String columnLabel, NClob nClob)
1677  throws SQLException { // logger.debug("Entered "+ sql );
1678  throw new UnsupportedOperationException("Not supported yet,"
1679  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1680  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1681  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1682  }
1683 
1684  @Override
1685  public NClob getNClob(int columnIndex)
1686  throws SQLException { // logger.debug("Entered "+ sql );
1687  throw new UnsupportedOperationException("Not supported yet,"
1688  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1689  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1690  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1691  }
1692 
1693  @Override
1694  public NClob getNClob(String columnLabel)
1695  throws SQLException { // logger.debug("Entered "+ sql );
1696  throw new UnsupportedOperationException("Not supported yet,"
1697  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1698  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1699  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1700  }
1701 
1702  @Override
1703  public SQLXML getSQLXML(int columnIndex)
1704  throws SQLException { // logger.debug("Entered "+ sql );
1705  throw new UnsupportedOperationException("Not supported yet,"
1706  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1707  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1708  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1709  }
1710 
1711  @Override
1712  public SQLXML getSQLXML(String columnLabel)
1713  throws SQLException { // logger.debug("Entered "+ sql );
1714  throw new UnsupportedOperationException("Not supported yet,"
1715  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1716  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1717  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1718  }
1719 
1720  @Override
1721  public void updateSQLXML(int columnIndex, SQLXML xmlObject)
1722  throws SQLException { // logger.debug("Entered "+ sql );
1723  throw new UnsupportedOperationException("Not supported yet,"
1724  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1725  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1726  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1727  }
1728 
1729  @Override
1730  public void updateSQLXML(String columnLabel, SQLXML xmlObject)
1731  throws SQLException { // logger.debug("Entered "+ sql );
1732  throw new UnsupportedOperationException("Not supported yet,"
1733  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1734  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1735  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1736  }
1737 
1738  @Override
1739  public String getNString(int columnIndex)
1740  throws SQLException { // logger.debug("Entered "+ sql );
1741  throw new UnsupportedOperationException("Not supported yet,"
1742  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1743  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1744  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1745  }
1746 
1747  @Override
1748  public String getNString(String columnLabel)
1749  throws SQLException { // logger.debug("Entered "+ sql );
1750  throw new UnsupportedOperationException("Not supported yet,"
1751  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1752  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1753  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1754  }
1755 
1756  @Override
1757  public Reader getNCharacterStream(int columnIndex)
1758  throws SQLException { // logger.debug("Entered "+ sql );
1759  throw new UnsupportedOperationException("Not supported yet,"
1760  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1761  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1762  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1763  }
1764 
1765  @Override
1766  public Reader getNCharacterStream(String columnLabel)
1767  throws SQLException { // logger.debug("Entered "+ sql );
1768  throw new UnsupportedOperationException("Not supported yet,"
1769  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1770  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1771  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1772  }
1773 
1774  @Override
1775  public void updateNCharacterStream(int columnIndex, Reader x, long length)
1776  throws SQLException { // logger.debug("Entered "+ sql );
1777  throw new UnsupportedOperationException("Not supported yet,"
1778  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1779  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1780  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1781  }
1782 
1783  @Override
1784  public void updateNCharacterStream(String columnLabel, Reader reader, long length)
1785  throws SQLException { // logger.debug("Entered "+ sql );
1786  throw new UnsupportedOperationException("Not supported yet,"
1787  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1788  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1789  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1790  }
1791 
1792  @Override
1793  public void updateAsciiStream(int columnIndex, InputStream x, long length)
1794  throws SQLException { // logger.debug("Entered "+ sql );
1795  throw new UnsupportedOperationException("Not supported yet,"
1796  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1797  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1798  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1799  }
1800 
1801  @Override
1802  public void updateBinaryStream(int columnIndex, InputStream x, long length)
1803  throws SQLException { // logger.debug("Entered "+ sql );
1804  throw new UnsupportedOperationException("Not supported yet,"
1805  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1806  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1807  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1808  }
1809 
1810  @Override
1811  public void updateCharacterStream(int columnIndex, Reader x, long length)
1812  throws SQLException { // logger.debug("Entered "+ sql );
1813  throw new UnsupportedOperationException("Not supported yet,"
1814  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1815  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1816  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1817  }
1818 
1819  @Override
1820  public void updateAsciiStream(String columnLabel, InputStream x, long length)
1821  throws SQLException { // logger.debug("Entered "+ sql );
1822  throw new UnsupportedOperationException("Not supported yet,"
1823  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1824  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1825  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1826  }
1827 
1828  @Override
1829  public void updateBinaryStream(String columnLabel, InputStream x, long length)
1830  throws SQLException { // logger.debug("Entered "+ sql );
1831  throw new UnsupportedOperationException("Not supported yet,"
1832  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1833  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1834  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1835  }
1836 
1837  @Override
1838  public void updateCharacterStream(String columnLabel, Reader reader, long length)
1839  throws SQLException { // logger.debug("Entered "+ sql );
1840  throw new UnsupportedOperationException("Not supported yet,"
1841  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1842  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1843  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1844  }
1845 
1846  @Override
1847  public void updateBlob(int columnIndex, InputStream inputStream, long length)
1848  throws SQLException { // logger.debug("Entered "+ sql );
1849  throw new UnsupportedOperationException("Not supported yet,"
1850  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1851  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1852  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1853  }
1854 
1855  @Override
1856  public void updateBlob(String columnLabel, InputStream inputStream, long length)
1857  throws SQLException { // logger.debug("Entered "+ sql );
1858  throw new UnsupportedOperationException("Not supported yet,"
1859  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1860  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1861  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1862  }
1863 
1864  @Override
1865  public void updateClob(int columnIndex, Reader reader, long length)
1866  throws SQLException { // logger.debug("Entered "+ sql );
1867  throw new UnsupportedOperationException("Not supported yet,"
1868  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1869  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1870  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1871  }
1872 
1873  @Override
1874  public void updateClob(String columnLabel, Reader reader, long length)
1875  throws SQLException { // logger.debug("Entered "+ sql );
1876  throw new UnsupportedOperationException("Not supported yet,"
1877  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1878  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1879  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1880  }
1881 
1882  @Override
1883  public void updateNClob(int columnIndex, Reader reader, long length)
1884  throws SQLException { // logger.debug("Entered "+ sql );
1885  throw new UnsupportedOperationException("Not supported yet,"
1886  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1887  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1888  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1889  }
1890 
1891  @Override
1892  public void updateNClob(String columnLabel, Reader reader, long length)
1893  throws SQLException { // logger.debug("Entered "+ sql );
1894  throw new UnsupportedOperationException("Not supported yet,"
1895  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1896  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1897  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1898  }
1899 
1900  @Override
1901  public void updateNCharacterStream(int columnIndex, Reader x)
1902  throws SQLException { // logger.debug("Entered "+ sql );
1903  throw new UnsupportedOperationException("Not supported yet,"
1904  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1905  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1906  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1907  }
1908 
1909  @Override
1910  public void updateNCharacterStream(String columnLabel, Reader reader)
1911  throws SQLException { // logger.debug("Entered "+ sql );
1912  throw new UnsupportedOperationException("Not supported yet,"
1913  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1914  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1915  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1916  }
1917 
1918  @Override
1919  public void updateAsciiStream(int columnIndex, InputStream x)
1920  throws SQLException { // logger.debug("Entered "+ sql );
1921  throw new UnsupportedOperationException("Not supported yet,"
1922  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1923  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1924  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1925  }
1926 
1927  @Override
1928  public void updateBinaryStream(int columnIndex, InputStream x)
1929  throws SQLException { // logger.debug("Entered "+ sql );
1930  throw new UnsupportedOperationException("Not supported yet,"
1931  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1932  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1933  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1934  }
1935 
1936  @Override
1937  public void updateCharacterStream(int columnIndex, Reader x)
1938  throws SQLException { // logger.debug("Entered "+ sql );
1939  throw new UnsupportedOperationException("Not supported yet,"
1940  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1941  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1942  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1943  }
1944 
1945  @Override
1946  public void updateAsciiStream(String columnLabel, InputStream x)
1947  throws SQLException { // logger.debug("Entered "+ sql );
1948  throw new UnsupportedOperationException("Not supported yet,"
1949  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1950  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1951  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1952  }
1953 
1954  @Override
1955  public void updateBinaryStream(String columnLabel, InputStream x)
1956  throws SQLException { // logger.debug("Entered "+ sql );
1957  throw new UnsupportedOperationException("Not supported yet,"
1958  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1959  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1960  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1961  }
1962 
1963  @Override
1964  public void updateCharacterStream(String columnLabel, Reader reader)
1965  throws SQLException { // logger.debug("Entered "+ sql );
1966  throw new UnsupportedOperationException("Not supported yet,"
1967  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1968  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1969  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1970  }
1971 
1972  @Override
1973  public void updateBlob(int columnIndex, InputStream inputStream)
1974  throws SQLException { // logger.debug("Entered "+ sql );
1975  throw new UnsupportedOperationException("Not supported yet,"
1976  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1977  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1978  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1979  }
1980 
1981  @Override
1982  public void updateBlob(String columnLabel, InputStream inputStream)
1983  throws SQLException { // logger.debug("Entered "+ sql );
1984  throw new UnsupportedOperationException("Not supported yet,"
1985  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1986  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1987  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1988  }
1989 
1990  @Override
1991  public void updateClob(int columnIndex, Reader reader)
1992  throws SQLException { // logger.debug("Entered "+ sql );
1993  throw new UnsupportedOperationException("Not supported yet,"
1994  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1995  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1996  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1997  }
1998 
1999  @Override
2000  public void updateClob(String columnLabel, Reader reader)
2001  throws SQLException { // logger.debug("Entered "+ sql );
2002  throw new UnsupportedOperationException("Not supported yet,"
2003  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2004  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2005  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2006  }
2007 
2008  @Override
2009  public void updateNClob(int columnIndex, Reader reader)
2010  throws SQLException { // logger.debug("Entered "+ sql );
2011  throw new UnsupportedOperationException("Not supported yet,"
2012  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2013  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2014  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2015  }
2016 
2017  @Override
2018  public void updateNClob(String columnLabel, Reader reader)
2019  throws SQLException { // logger.debug("Entered "+ sql );
2020  throw new UnsupportedOperationException("Not supported yet,"
2021  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2022  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2023  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2024  }
2025 
2026  @Override
2027  public <T> T getObject(int columnIndex, Class<T> type)
2028  throws SQLException { // logger.debug("Entered "+ sql );
2029  throw new UnsupportedOperationException("Not supported yet,"
2030  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2031  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2032  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2033  }
2034 
2035  @Override
2036  public <T> T getObject(String columnLabel, Class<T> type)
2037  throws SQLException { // logger.debug("Entered "+ sql );
2038  throw new UnsupportedOperationException("Not supported yet,"
2039  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2040  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2041  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2042  }
2043 
2044  @Override
2045  public <T> T unwrap(Class<T> iface)
2046  throws SQLException { // logger.debug("Entered "+ sql );
2047  throw new UnsupportedOperationException("Not supported yet,"
2048  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2049  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2050  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2051  }
2052 
2053  @Override
2054  public boolean isWrapperFor(Class<?> iface)
2055  throws SQLException { // logger.debug("Entered "+ sql );
2056  throw new UnsupportedOperationException("Not supported yet,"
2057  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2058  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2059  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2060  }
2061 
2062  private Integer findColumnByName(String name) throws SQLException {
2063  Integer colNum = columnMap.get(name);
2064  if (colNum == null) {
2065  throw new SQLException("Could not find the column " + name);
2066  }
2067  return colNum;
2068  }
2069 
2070  private void checkClosed() throws SQLException {
2071  if (isClosed) {
2072  throw new SQLException("ResultSet is closed.");
2073  }
2074  }
2075 }
void updateClob(int columnIndex, Reader reader)
boolean getBoolean(String columnLabel)
void updateAsciiStream(String columnLabel, InputStream x, int length)
void updateNClob(String columnLabel, Reader reader, long length)
void updateShort(String columnLabel, short x)
void updateNClob(String columnLabel, Reader reader)
void updateTimestamp(int columnIndex, Timestamp x)
void updateLong(int columnIndex, long x)
void updateCharacterStream(String columnLabel, Reader reader, int length)
Reader getCharacterStream(int columnIndex)
void updateBigDecimal(String columnLabel, BigDecimal x)
Timestamp adjust_precision(long val, int precision)
Array getArray(String columnLabel)
SQLXML getSQLXML(String columnLabel)
void updateNClob(String columnLabel, NClob nClob)
InputStream getAsciiStream(String columnLabel)
void updateAsciiStream(int columnIndex, InputStream x)
void updateString(int columnIndex, String x)
int getInt(String columnLabel)
void updateTime(String columnLabel, Time x)
void updateRowId(int columnIndex, RowId x)
void updateClob(String columnLabel, Reader reader)
void updateInt(String columnLabel, int x)
void updateClob(int columnIndex, Clob x)
Timestamp getTimestamp(String columnLabel)
void updateTimestamp(String columnLabel, Timestamp x)
long getOffsetFromTZ(long actualmillis, Calendar cal, int precision)
void updateClob(int columnIndex, Reader reader, long length)
String getStringInternal(int columnIndex)
HeavyAIResultSet(TQueryResult tsqlResult, String sql)
void updateBlob(int columnIndex, Blob x)
void updateDate(String columnLabel, Date x)
InputStream getUnicodeStream(int columnIndex)
byte[] getBytes(int columnIndex)
void updateBytes(String columnLabel, byte[] x)
void updateBinaryStream(int columnIndex, InputStream x)
void updateBlob(int columnIndex, InputStream inputStream, long length)
double getDouble(int columnIndex)
Clob getClob(String columnLabel)
void setFetchDirection(int direction)
Object getObject(int columnIndex)
void updateCharacterStream(int columnIndex, Reader x)
void updateClob(String columnLabel, Clob x)
Blob getBlob(String columnLabel)
void updateAsciiStream(int columnIndex, InputStream x, long length)
void updateNCharacterStream(int columnIndex, Reader x)
void updateBinaryStream(int columnIndex, InputStream x, int length)
Timestamp extract_complex_time(long val, int precision)
BigDecimal getBigDecimal(String columnLabel)
void updateBlob(String columnLabel, InputStream inputStream, long length)
void updateBytes(int columnIndex, byte[] x)
Time getTime(int columnIndex, Calendar cal)
String getString(int columnIndex)
void updateNCharacterStream(String columnLabel, Reader reader)
Object getObject(String columnLabel)
public< T > T unwrap(Class< T > iface)
URL getURL(String columnLabel)
Date getDate(int columnIndex, Calendar cal)
void updateObject(String columnLabel, Object x, int scaleOrLength)
RowId getRowId(String columnLabel)
Integer findColumnByName(String name)
float getFloat(String columnLabel)
void updateBlob(int columnIndex, InputStream inputStream)
String getNString(int columnIndex)
InputStream getBinaryStream(String columnLabel)
Reader getNCharacterStream(int columnIndex)
void updateBlob(String columnLabel, Blob x)
void updateRowId(String columnLabel, RowId x)
void updateByte(String columnLabel, byte x)
void updateSQLXML(int columnIndex, SQLXML xmlObject)
void updateInt(int columnIndex, int x)
void updateShort(int columnIndex, short x)
void updateCharacterStream(int columnIndex, Reader x, int length)
SQLXML getSQLXML(int columnIndex)
Time getTime(String columnLabel)
Object getObject(String columnLabel, Map< String, Class<?>> map)
byte[] getBytes(String columnLabel)
BigDecimal getBigDecimal(int columnIndex)
void updateNString(String columnLabel, String nString)
void updateFloat(String columnLabel, float x)
InputStream getAsciiStream(int columnIndex)
void updateNClob(int columnIndex, Reader reader, long length)
void updateCharacterStream(String columnLabel, Reader reader)
BigDecimal getBigDecimal(String columnLabel, int scale)
void updateBoolean(String columnLabel, boolean x)
void updateLong(String columnLabel, long x)
void updateNCharacterStream(String columnLabel, Reader reader, long length)
Timestamp getTimestamp(int columnIndex, Calendar cal)
void updateDouble(int columnIndex, double x)
long getLong(String columnLabel)
void updateAsciiStream(String columnLabel, InputStream x, long length)
void updateAsciiStream(String columnLabel, InputStream x)
void updateRef(int columnIndex, Ref x)
void updateNString(int columnIndex, String nString)
double getDouble(String columnLabel)
void updateBinaryStream(String columnLabel, InputStream x, int length)
void updateBinaryStream(String columnLabel, InputStream x)
void updateBigDecimal(int columnIndex, BigDecimal x)
InputStream getUnicodeStream(String columnLabel)
void updateNClob(int columnIndex, Reader reader)
int findColumn(String columnLabel)
short getShort(String columnLabel)
Reader getCharacterStream(String columnLabel)
void updateBinaryStream(String columnLabel, InputStream x, long length)
void updateDouble(String columnLabel, double x)
void updateBlob(String columnLabel, InputStream inputStream)
Date getDate(String columnLabel, Calendar cal)
void updateObject(int columnIndex, Object x, int scaleOrLength)
public< T > T getObject(String columnLabel, Class< T > type)
void updateSQLXML(String columnLabel, SQLXML xmlObject)
Timestamp getTimestamp(String columnLabel, Calendar cal)
void updateFloat(int columnIndex, float x)
void updateBoolean(int columnIndex, boolean x)
String getString(String columnLabel)
void updateArray(String columnLabel, Array x)
Date getDate(String columnLabel)
void updateRef(String columnLabel, Ref x)
Reader getNCharacterStream(String columnLabel)
void updateString(String columnLabel, String x)
void updateObject(String columnLabel, Object x)
void updateBinaryStream(int columnIndex, InputStream x, long length)
void updateArray(int columnIndex, Array x)
public< T > T getObject(int columnIndex, Class< T > type)
float getFloat(int columnIndex)
Ref getRef(String columnLabel)
NClob getNClob(String columnLabel)
string name
Definition: setup.in.py:72
void updateNClob(int columnIndex, NClob nClob)
Object getObject(int columnIndex, Map< String, Class<?>> map)
void updateByte(int columnIndex, byte x)
void updateTime(int columnIndex, Time x)
Timestamp getTimestamp(int columnIndex)
double getDoubleInternal(int columnIndex)
void updateCharacterStream(int columnIndex, Reader x, long length)
void updateObject(int columnIndex, Object x)
InputStream getBinaryStream(int columnIndex)
void updateCharacterStream(String columnLabel, Reader reader, long length)
void updateClob(String columnLabel, Reader reader, long length)
BigDecimal getBigDecimal(int columnIndex, int scale)
void updateNull(int columnIndex)
void updateDate(int columnIndex, Date x)
Map< String, Integer > columnMap
byte getByte(String columnLabel)
boolean getBoolean(int columnIndex)
void updateNCharacterStream(int columnIndex, Reader x, long length)
void updateAsciiStream(int columnIndex, InputStream x, int length)
Time getTime(String columnLabel, Calendar cal)
short getShort(int columnIndex)
void updateNull(String columnLabel)
boolean isWrapperFor(Class<?> iface)
String getNString(String columnLabel)