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