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