OmniSciDB  06b3bd477c
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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.omnisci.thrift.server.TColumnType;
19 import com.omnisci.thrift.server.TDatumType;
20 import com.omnisci.thrift.server.TQueryResult;
21 import com.omnisci.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 
53 // Useful debug string
54 // System.out.println("Entered " + " line:" + new
55 // Throwable().getStackTrace()[0].getLineNumber() + " class:" + new
56 // Throwable().getStackTrace()[0].getClassName() + " method:" + new
57 // Throwable().getStackTrace()[0].getMethodName());
58 class OmniSciResultSet implements java.sql.ResultSet {
59  final static Logger logger = LoggerFactory.getLogger(OmniSciResultSet.class);
60  private TQueryResult sqlResult = null;
61  private int offset = -1;
62  private int numOfRecords = 0;
63  private String sql;
64  private TRowSet rowSet = null;
65  private List<TColumnType> rowDesc;
66  private boolean wasNull = false;
67  private Map<String, Integer> columnMap;
68  private int fetchSize = 0;
69  private SQLWarning warnings = null;
70 
71  public OmniSciResultSet(TQueryResult tsqlResult, String sql)
72  throws SQLException { // logger.debug("Entered "+ sql );
73  sqlResult = tsqlResult;
74  offset = -1;
75  this.sql = sql;
76  rowSet = sqlResult.getRow_set();
77  rowDesc = rowSet.getRow_desc();
78 
79  // in the case of a create (maybe insert) nothing is returned in these field
80  if (rowDesc.isEmpty()) {
81  numOfRecords = 0;
82  return;
83  }
84 
85  rowDesc.get(0).getCol_name();
86 
87  columnMap = new HashMap();
88  int current = 1;
89  for (final TColumnType colType : rowDesc) {
90  columnMap.put(colType.getCol_name(), current);
91  current++;
92  }
93  if (rowSet.columns.isEmpty()) {
94  numOfRecords = 0;
95  } else {
96  numOfRecords = rowSet.getColumns().get(0).getNullsSize();
97  }
98 
99  logger.debug("number of records is " + numOfRecords);
100  // logger.debug("Record is "+ sqlResult.toString());
101  }
102 
104  numOfRecords = 0;
105  }
106 
107  @Override
108  public boolean next() throws SQLException { // logger.debug("Entered "+ sql );
109 
110  // do real work
111  offset++;
112  if (offset < numOfRecords) {
113  return true;
114  }
115  return false;
116  }
117 
118  @Override
119  public void close() throws SQLException { // logger.debug("Entered "+ sql );
120  // clean up the result object
121  this.rowDesc = null;
122  this.rowSet = null;
123  this.sqlResult = null;
124  }
125 
126  @Override
127  public boolean wasNull() throws SQLException { // logger.debug("Entered "+ sql );
128  return wasNull;
129  }
130 
131  @Override
132  public String getString(int columnIndex) throws SQLException {
133  // System.out.println("Entered " + " line:" + new
134  // Throwable().getStackTrace()[0].getLineNumber() + " class:" + new
135  // Throwable().getStackTrace()[0].getClassName() + " method:" + new
136  // Throwable().getStackTrace()[0].getMethodName()); logger.info("Dump result columns
137  // "+rowSet.columns.toString()); logger.info("Dump column:offset "+ columnIndex + ":"
138  // +offset);
139  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
140  wasNull = true;
141  return null;
142  } else {
143  wasNull = false;
144  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
145 
146  if (type == TDatumType.STR
147  && !sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.is_array) {
148  return rowSet.columns.get(columnIndex - 1).data.str_col.get(offset);
149  } else {
150  return getStringInternal(columnIndex);
151  }
152  }
153  }
154 
155  private String getStringInternal(int columnIndex) throws SQLException {
156  if (sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.is_array) {
157  return getArray(columnIndex).toString();
158  }
159 
160  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
161  switch (type) {
162  case TINYINT:
163  case SMALLINT:
164  case INT:
165  return String.valueOf(getInt(columnIndex));
166  case BIGINT:
167  return String.valueOf(getLong(columnIndex));
168  case FLOAT:
169  return String.valueOf(getFloat(columnIndex));
170  case DECIMAL:
171  return String.valueOf(getFloat(columnIndex));
172  case DOUBLE:
173  return String.valueOf(getDouble(columnIndex));
174  case STR:
175  return getString(columnIndex);
176  case TIME:
177  return getTime(columnIndex).toString();
178  case TIMESTAMP:
179  return getTimestamp(columnIndex).toString();
180  case DATE:
181  return getDate(columnIndex).toString();
182  case BOOL:
183  return getBoolean(columnIndex) ? "1" : "0";
184  case POINT:
185  case LINESTRING:
186  case POLYGON:
187  case MULTIPOLYGON:
188  return (String) getObject(columnIndex);
189  default:
190  throw new AssertionError(type.name());
191  }
192  }
193 
194  @Override
195  public boolean getBoolean(int columnIndex)
196  throws SQLException { // logger.debug("Entered "+ sql );
197  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
198  wasNull = true;
199  return false;
200  } else {
201  // assume column is str already for now
202  wasNull = false;
203  if (rowSet.columns.get(columnIndex - 1).data.int_col.get(offset) == 0) {
204  return false;
205  } else {
206  return true;
207  }
208  }
209  }
210 
211  @Override
212  public byte getByte(int columnIndex)
213  throws SQLException { // logger.debug("Entered "+ sql );
214  throw new UnsupportedOperationException("Not supported yet,"
215  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
216  + " class:" + new Throwable().getStackTrace()[0].getClassName()
217  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
218  }
219 
220  @Override
221  public short getShort(int columnIndex)
222  throws SQLException { // logger.debug("Entered "+ sql );
223  // logger.info("Dump result columns "+rowSet.columns.toString());
224  // logger.info("Dump column:offset "+ columnIndex + ":" +offset);
225  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
226  wasNull = true;
227  return 0;
228  } else {
229  // assume column is str already for now
230  wasNull = false;
231  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
232  return lObj.shortValue();
233  }
234  }
235 
236  @Override
237  public int getInt(int columnIndex)
238  throws SQLException { // logger.debug("Entered "+ sql );
239  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
240  wasNull = true;
241  return 0;
242  } else {
243  // assume column is str already for now
244  wasNull = false;
245  Long lObj = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
246  return lObj.intValue();
247  }
248  }
249 
250  @Override
251  public long getLong(int columnIndex)
252  throws SQLException { // logger.debug("Entered "+ sql );
253  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
254  wasNull = true;
255  return 0;
256  } else {
257  // assume column is str already for now
258  wasNull = false;
259  return rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
260  }
261  }
262 
263  @Override
264  public float getFloat(int columnIndex)
265  throws SQLException { // logger.debug("Entered "+ sql );
266  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
267  wasNull = true;
268  return 0;
269  } else {
270  // assume column is str already for now
271  wasNull = false;
272  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset).floatValue();
273  }
274  }
275 
276  @Override
277  public double getDouble(int columnIndex)
278  throws SQLException { // logger.debug("Entered "+ sql );
279  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
280  wasNull = true;
281  return 0;
282  } else {
283  // assume column is str already for now
284  wasNull = false;
285  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
286 
287  if (type == TDatumType.DOUBLE) {
288  return rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
289  } else {
290  return getDoubleInternal(columnIndex);
291  }
292  }
293  }
294 
295  private double getDoubleInternal(int columnIndex) throws SQLException {
296  TDatumType type = sqlResult.row_set.row_desc.get(columnIndex - 1).col_type.type;
297 
298  switch (type) {
299  case TINYINT:
300  case SMALLINT:
301  case INT:
302  return (double) getInt(columnIndex);
303  case BIGINT:
304  return (double) getLong(columnIndex);
305  case FLOAT:
306  return (double) getFloat(columnIndex);
307  case DECIMAL:
308  return (double) getFloat(columnIndex);
309  case DOUBLE:
310  return getDouble(columnIndex);
311  case STR:
312  return Double.valueOf(getString(columnIndex));
313  case TIME:
314  return (double) getTime(columnIndex).getTime();
315  case TIMESTAMP:
316  return (double) getTimestamp(columnIndex).getTime();
317  case DATE:
318  return (double) getDate(columnIndex).getTime();
319  case BOOL:
320  return (double) (getBoolean(columnIndex) ? 1 : 0);
321  default:
322  throw new AssertionError(type.name());
323  }
324  }
325 
326  @Override
327  public BigDecimal getBigDecimal(int columnIndex, int scale)
328  throws SQLException { // logger.debug("Entered "+ sql );
329  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
330  wasNull = true;
331  return null;
332  } else {
333  // assume column is str already for now
334  wasNull = false;
335  return BigDecimal.valueOf(
336  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
337  }
338  }
339 
340  @Override
341  public byte[] getBytes(int columnIndex)
342  throws SQLException { // logger.debug("Entered "+ sql );
343  throw new UnsupportedOperationException("Not supported yet,"
344  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
345  + " class:" + new Throwable().getStackTrace()[0].getClassName()
346  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
347  }
348 
349  @Override
350  public Date getDate(int columnIndex)
351  throws SQLException { // logger.debug("Entered "+ sql );
352  return getDate(columnIndex, null);
353  }
354 
355  @Override
356  public Time getTime(int columnIndex)
357  throws SQLException { // logger.debug("Entered "+ sql );
358  return getTime(columnIndex, null);
359  }
360 
361  @Override
362  public Timestamp getTimestamp(int columnIndex)
363  throws SQLException { // logger.debug("Entered "+ sql );
364  return getTimestamp(columnIndex, null);
365  }
366 
367  private Timestamp extract_complex_time(long val, int precision) {
368  long scale = (long) Math.pow(10, precision);
369  double nano_part = Math.abs(val) % scale;
370  if (val < 0) nano_part = -nano_part;
371  nano_part = (int) ((nano_part + scale) % scale) * (long) Math.pow(10, 9 - precision);
372  long micro_sec_value = (long) (val / scale);
373  // Round value
374  micro_sec_value = micro_sec_value - ((micro_sec_value < 0 && nano_part > 0) ? 1 : 0);
375  Timestamp tm = new Timestamp(
376  micro_sec_value * 1000); // convert to milli seconds and make a time
377  tm.setNanos((int) (nano_part));
378  return tm;
379  }
380 
381  private Timestamp adjust_precision(long val, int precision) {
382  switch (precision) {
383  case 0:
384  return new Timestamp(val * 1000);
385  case 3:
386  return new Timestamp(val);
387  case 6:
388  case 9:
389  return extract_complex_time(val, precision);
390  default:
391  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
392  + "] returned. Valid values 0,3,6,9");
393  }
394  }
395 
396  @Override
397  public InputStream getAsciiStream(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 InputStream getUnicodeStream(int columnIndex)
407  throws SQLException { // logger.debug("Entered "+ sql );
408  throw new UnsupportedOperationException("Not supported yet,"
409  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
410  + " class:" + new Throwable().getStackTrace()[0].getClassName()
411  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
412  }
413 
414  @Override
415  public InputStream getBinaryStream(int columnIndex)
416  throws SQLException { // logger.debug("Entered "+ sql );
417  throw new UnsupportedOperationException("Not supported yet,"
418  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
419  + " class:" + new Throwable().getStackTrace()[0].getClassName()
420  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
421  }
422 
423  @Override
424  public String getString(String columnLabel)
425  throws SQLException { // logger.debug("Entered "+ sql );
426  return getString(findColumnByName(columnLabel));
427  }
428 
429  @Override
430  public boolean getBoolean(String columnLabel)
431  throws SQLException { // logger.debug("Entered "+ sql );
432  return getBoolean(findColumnByName(columnLabel));
433  }
434 
435  @Override
436  public byte getByte(String columnLabel)
437  throws SQLException { // logger.debug("Entered "+ sql );
438  throw new UnsupportedOperationException("Not supported yet,"
439  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
440  + " class:" + new Throwable().getStackTrace()[0].getClassName()
441  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
442  }
443 
444  @Override
445  public short getShort(String columnLabel)
446  throws SQLException { // logger.debug("Entered "+ sql );
447  return getShort(findColumnByName(columnLabel));
448  }
449 
450  @Override
451  public int getInt(String columnLabel)
452  throws SQLException { // logger.debug("Entered "+ sql );
453  return getInt(findColumnByName(columnLabel));
454  }
455 
456  @Override
457  public long getLong(String columnLabel)
458  throws SQLException { // logger.debug("Entered "+ sql );
459  return getLong(findColumnByName(columnLabel));
460  }
461 
462  @Override
463  public float getFloat(String columnLabel)
464  throws SQLException { // logger.debug("Entered "+ sql );
465  return getFloat(findColumnByName(columnLabel));
466  }
467 
468  @Override
469  public double getDouble(String columnLabel)
470  throws SQLException { // logger.debug("Entered "+ sql );
471  return getDouble(findColumnByName(columnLabel));
472  }
473 
474  @Override
475  public BigDecimal getBigDecimal(String columnLabel, int scale)
476  throws SQLException { // logger.debug("Entered "+ sql );
477  return getBigDecimal(findColumnByName(columnLabel));
478  }
479 
480  @Override
481  public byte[] getBytes(String columnLabel)
482  throws SQLException { // logger.debug("Entered "+ sql );
483  throw new UnsupportedOperationException("Not supported yet,"
484  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
485  + " class:" + new Throwable().getStackTrace()[0].getClassName()
486  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
487  }
488 
489  @Override
490  public Date getDate(String columnLabel)
491  throws SQLException { // logger.debug("Entered "+ sql );
492  return getDate(columnLabel, null);
493  }
494 
495  @Override
496  public Time getTime(String columnLabel)
497  throws SQLException { // logger.debug("Entered "+ sql );
498  return getTime(columnLabel, null);
499  }
500 
501  @Override
502  public Timestamp getTimestamp(String columnLabel)
503  throws SQLException { // logger.debug("Entered "+ sql );
504  return getTimestamp(columnLabel, null);
505  }
506 
507  @Override
508  public InputStream getAsciiStream(String columnLabel)
509  throws SQLException { // logger.debug("Entered "+ sql );
510  throw new UnsupportedOperationException("Not supported yet,"
511  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
512  + " class:" + new Throwable().getStackTrace()[0].getClassName()
513  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
514  }
515 
516  @Override
517  public InputStream getUnicodeStream(String columnLabel)
518  throws SQLException { // logger.debug("Entered "+ sql );
519  throw new UnsupportedOperationException("Not supported yet,"
520  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
521  + " class:" + new Throwable().getStackTrace()[0].getClassName()
522  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
523  }
524 
525  @Override
526  public InputStream getBinaryStream(String columnLabel)
527  throws SQLException { // logger.debug("Entered "+ sql );
528  throw new UnsupportedOperationException("Not supported yet,"
529  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
530  + " class:" + new Throwable().getStackTrace()[0].getClassName()
531  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
532  }
533 
534  @Override
535  public SQLWarning getWarnings() throws SQLException { // logger.debug("Entered "+ sql );
536  return warnings;
537  }
538 
539  @Override
540  public void clearWarnings() throws SQLException { // logger.debug("Entered "+ sql );
541  warnings = null;
542  }
543 
544  @Override
545  public String getCursorName() throws SQLException { // logger.debug("Entered "+ sql );
546  throw new UnsupportedOperationException("Not supported yet,"
547  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
548  + " class:" + new Throwable().getStackTrace()[0].getClassName()
549  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
550  }
551 
552  @Override
553  public ResultSetMetaData getMetaData()
554  throws SQLException { // logger.debug("Entered "+ sql );
556  }
557 
558  @Override
559  public Object getObject(int columnIndex)
560  throws SQLException { // logger.debug("Entered "+ sql );
561  // logger.info("Dump result column "+rowSet.columns.get(columnIndex-1));
562  // logger.info("Dump column:offset "+ columnIndex + ":" +offset);
563  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
564  wasNull = true;
565  return null;
566  } else {
567  wasNull = false;
568  if (rowDesc.get(columnIndex - 1).col_type.is_array) {
569  return getArray(columnIndex);
570  }
571 
572  switch (rowDesc.get(columnIndex - 1).col_type.type) {
573  case TINYINT:
574  case SMALLINT:
575  case INT:
576  case BIGINT:
577  case BOOL:
578  case TIME:
579  case TIMESTAMP:
580  case DATE:
581  return this.rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
582  case FLOAT:
583  case DECIMAL:
584  case DOUBLE:
585  return this.rowSet.columns.get(columnIndex - 1).data.real_col.get(offset);
586  case STR:
587  case POINT:
588  case LINESTRING:
589  case POLYGON:
590  case MULTIPOLYGON:
591  return this.rowSet.columns.get(columnIndex - 1).data.str_col.get(offset);
592  default:
593  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
594  }
595  }
596  }
597 
598  @Override
599  public Object getObject(String columnLabel)
600  throws SQLException { // logger.debug("Entered "+ sql );
601  return getObject(columnMap.get(columnLabel));
602  }
603 
604  @Override
605  public int findColumn(String columnLabel)
606  throws SQLException { // logger.debug("Entered "+ sql );
607  throw new UnsupportedOperationException("Not supported yet,"
608  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
609  + " class:" + new Throwable().getStackTrace()[0].getClassName()
610  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
611  }
612 
613  @Override
614  public Reader getCharacterStream(int columnIndex)
615  throws SQLException { // logger.debug("Entered "+ sql );
616  throw new UnsupportedOperationException("Not supported yet,"
617  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
618  + " class:" + new Throwable().getStackTrace()[0].getClassName()
619  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
620  }
621 
622  @Override
623  public Reader getCharacterStream(String columnLabel)
624  throws SQLException { // logger.debug("Entered "+ sql );
625  throw new UnsupportedOperationException("Not supported yet,"
626  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
627  + " class:" + new Throwable().getStackTrace()[0].getClassName()
628  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
629  }
630 
631  @Override
632  public BigDecimal getBigDecimal(int columnIndex)
633  throws SQLException { // logger.debug("Entered "+ sql );
634  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
635  wasNull = true;
636  return null;
637  } else {
638  // assume column is str already for now
639  wasNull = false;
640  return BigDecimal.valueOf(
641  rowSet.columns.get(columnIndex - 1).data.real_col.get(offset));
642  }
643  }
644 
645  @Override
646  public BigDecimal getBigDecimal(String columnLabel)
647  throws SQLException { // logger.debug("Entered "+ sql );
648  return getBigDecimal(columnMap.get(columnLabel));
649  }
650 
651  @Override
652  public boolean isBeforeFirst() throws SQLException { // logger.debug("Entered "+ sql );
653  throw new UnsupportedOperationException("Not supported yet,"
654  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
655  + " class:" + new Throwable().getStackTrace()[0].getClassName()
656  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
657  }
658 
659  @Override
660  public boolean isAfterLast() throws SQLException { // logger.debug("Entered "+ sql );
661  throw new UnsupportedOperationException("Not supported yet,"
662  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
663  + " class:" + new Throwable().getStackTrace()[0].getClassName()
664  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
665  }
666 
667  @Override
668  public boolean isFirst() throws SQLException { // logger.debug("Entered "+ sql );
669  throw new UnsupportedOperationException("Not supported yet,"
670  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
671  + " class:" + new Throwable().getStackTrace()[0].getClassName()
672  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
673  }
674 
675  @Override
676  public boolean isLast() throws SQLException { // logger.debug("Entered "+ sql );
677  throw new UnsupportedOperationException("Not supported yet,"
678  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
679  + " class:" + new Throwable().getStackTrace()[0].getClassName()
680  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
681  }
682 
683  @Override
684  public void beforeFirst() throws SQLException { // logger.debug("Entered "+ sql );
685  throw new UnsupportedOperationException("Not supported yet,"
686  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
687  + " class:" + new Throwable().getStackTrace()[0].getClassName()
688  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
689  }
690 
691  @Override
692  public void afterLast() throws SQLException { // logger.debug("Entered "+ sql );
693  throw new UnsupportedOperationException("Not supported yet,"
694  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
695  + " class:" + new Throwable().getStackTrace()[0].getClassName()
696  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
697  }
698 
699  @Override
700  public boolean first() throws SQLException { // logger.debug("Entered "+ sql );
701  throw new UnsupportedOperationException("Not supported yet,"
702  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
703  + " class:" + new Throwable().getStackTrace()[0].getClassName()
704  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
705  }
706 
707  @Override
708  public boolean last() throws SQLException { // logger.debug("Entered "+ sql );
709  throw new UnsupportedOperationException("Not supported yet,"
710  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
711  + " class:" + new Throwable().getStackTrace()[0].getClassName()
712  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
713  }
714 
715  @Override
716  public int getRow() throws SQLException { // logger.debug("Entered "+ sql );
717  throw new UnsupportedOperationException("Not supported yet,"
718  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
719  + " class:" + new Throwable().getStackTrace()[0].getClassName()
720  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
721  }
722 
723  @Override
724  public boolean absolute(int row)
725  throws SQLException { // logger.debug("Entered "+ sql );
726  throw new UnsupportedOperationException("Not supported yet,"
727  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
728  + " class:" + new Throwable().getStackTrace()[0].getClassName()
729  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
730  }
731 
732  @Override
733  public boolean relative(int rows)
734  throws SQLException { // logger.debug("Entered "+ sql );
735  throw new UnsupportedOperationException("Not supported yet,"
736  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
737  + " class:" + new Throwable().getStackTrace()[0].getClassName()
738  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
739  }
740 
741  @Override
742  public boolean previous() throws SQLException { // logger.debug("Entered "+ sql );
743  throw new UnsupportedOperationException("Not supported yet,"
744  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
745  + " class:" + new Throwable().getStackTrace()[0].getClassName()
746  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
747  }
748 
749  @Override
750  public void setFetchDirection(int direction)
751  throws SQLException { // logger.debug("Entered "+ sql );
752  throw new UnsupportedOperationException("Not supported yet,"
753  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
754  + " class:" + new Throwable().getStackTrace()[0].getClassName()
755  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
756  }
757 
758  @Override
759  public int getFetchDirection() throws SQLException { // logger.debug("Entered "+ sql );
760  throw new UnsupportedOperationException("Not supported yet,"
761  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
762  + " class:" + new Throwable().getStackTrace()[0].getClassName()
763  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
764  }
765 
766  @Override
767  public void setFetchSize(int rows)
768  throws SQLException { // logger.debug("Entered "+ sql );
769  fetchSize = rows;
770  }
771 
772  @Override
773  public int getFetchSize() throws SQLException { // logger.debug("Entered "+ sql );
774  throw new UnsupportedOperationException("Not supported yet,"
775  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
776  + " class:" + new Throwable().getStackTrace()[0].getClassName()
777  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
778  }
779 
780  @Override
781  public int getType() throws SQLException { // logger.debug("Entered "+ sql );
782  throw new UnsupportedOperationException("Not supported yet,"
783  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
784  + " class:" + new Throwable().getStackTrace()[0].getClassName()
785  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
786  }
787 
788  @Override
789  public int getConcurrency() throws SQLException { // logger.debug("Entered "+ sql );
790  throw new UnsupportedOperationException("Not supported yet,"
791  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
792  + " class:" + new Throwable().getStackTrace()[0].getClassName()
793  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
794  }
795 
796  @Override
797  public boolean rowUpdated() throws SQLException { // logger.debug("Entered "+ sql );
798  throw new UnsupportedOperationException("Not supported yet,"
799  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
800  + " class:" + new Throwable().getStackTrace()[0].getClassName()
801  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
802  }
803 
804  @Override
805  public boolean rowInserted() throws SQLException { // logger.debug("Entered "+ sql );
806  throw new UnsupportedOperationException("Not supported yet,"
807  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
808  + " class:" + new Throwable().getStackTrace()[0].getClassName()
809  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
810  }
811 
812  @Override
813  public boolean rowDeleted() throws SQLException { // logger.debug("Entered "+ sql );
814  throw new UnsupportedOperationException("Not supported yet,"
815  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
816  + " class:" + new Throwable().getStackTrace()[0].getClassName()
817  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
818  }
819 
820  @Override
821  public void updateNull(int columnIndex)
822  throws SQLException { // logger.debug("Entered "+ sql );
823  throw new UnsupportedOperationException("Not supported yet,"
824  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
825  + " class:" + new Throwable().getStackTrace()[0].getClassName()
826  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
827  }
828 
829  @Override
830  public void updateBoolean(int columnIndex, boolean x)
831  throws SQLException { // logger.debug("Entered "+ sql );
832  throw new UnsupportedOperationException("Not supported yet,"
833  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
834  + " class:" + new Throwable().getStackTrace()[0].getClassName()
835  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
836  }
837 
838  @Override
839  public void updateByte(int columnIndex, byte x)
840  throws SQLException { // logger.debug("Entered "+ sql );
841  throw new UnsupportedOperationException("Not supported yet,"
842  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
843  + " class:" + new Throwable().getStackTrace()[0].getClassName()
844  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
845  }
846 
847  @Override
848  public void updateShort(int columnIndex, short x)
849  throws SQLException { // logger.debug("Entered "+ sql );
850  throw new UnsupportedOperationException("Not supported yet,"
851  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
852  + " class:" + new Throwable().getStackTrace()[0].getClassName()
853  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
854  }
855 
856  @Override
857  public void updateInt(int columnIndex, int x)
858  throws SQLException { // logger.debug("Entered "+ sql );
859  throw new UnsupportedOperationException("Not supported yet,"
860  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
861  + " class:" + new Throwable().getStackTrace()[0].getClassName()
862  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
863  }
864 
865  @Override
866  public void updateLong(int columnIndex, long x)
867  throws SQLException { // logger.debug("Entered "+ sql );
868  throw new UnsupportedOperationException("Not supported yet,"
869  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
870  + " class:" + new Throwable().getStackTrace()[0].getClassName()
871  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
872  }
873 
874  @Override
875  public void updateFloat(int columnIndex, float x)
876  throws SQLException { // logger.debug("Entered "+ sql );
877  throw new UnsupportedOperationException("Not supported yet,"
878  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
879  + " class:" + new Throwable().getStackTrace()[0].getClassName()
880  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
881  }
882 
883  @Override
884  public void updateDouble(int columnIndex, double x)
885  throws SQLException { // logger.debug("Entered "+ sql );
886  throw new UnsupportedOperationException("Not supported yet,"
887  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
888  + " class:" + new Throwable().getStackTrace()[0].getClassName()
889  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
890  }
891 
892  @Override
893  public void updateBigDecimal(int columnIndex, BigDecimal x)
894  throws SQLException { // logger.debug("Entered "+ sql );
895  throw new UnsupportedOperationException("Not supported yet,"
896  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
897  + " class:" + new Throwable().getStackTrace()[0].getClassName()
898  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
899  }
900 
901  @Override
902  public void updateString(int columnIndex, String x)
903  throws SQLException { // logger.debug("Entered "+ sql );
904  throw new UnsupportedOperationException("Not supported yet,"
905  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
906  + " class:" + new Throwable().getStackTrace()[0].getClassName()
907  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
908  }
909 
910  @Override
911  public void updateBytes(int columnIndex, byte[] x)
912  throws SQLException { // logger.debug("Entered "+ sql );
913  throw new UnsupportedOperationException("Not supported yet,"
914  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
915  + " class:" + new Throwable().getStackTrace()[0].getClassName()
916  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
917  }
918 
919  @Override
920  public void updateDate(int columnIndex, Date x)
921  throws SQLException { // logger.debug("Entered "+ sql );
922  throw new UnsupportedOperationException("Not supported yet,"
923  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
924  + " class:" + new Throwable().getStackTrace()[0].getClassName()
925  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
926  }
927 
928  @Override
929  public void updateTime(int columnIndex, Time x)
930  throws SQLException { // logger.debug("Entered "+ sql );
931  throw new UnsupportedOperationException("Not supported yet,"
932  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
933  + " class:" + new Throwable().getStackTrace()[0].getClassName()
934  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
935  }
936 
937  @Override
938  public void updateTimestamp(int columnIndex, Timestamp x)
939  throws SQLException { // logger.debug("Entered "+ sql );
940  throw new UnsupportedOperationException("Not supported yet,"
941  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
942  + " class:" + new Throwable().getStackTrace()[0].getClassName()
943  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
944  }
945 
946  @Override
947  public void updateAsciiStream(int columnIndex, InputStream x, int length)
948  throws SQLException { // logger.debug("Entered "+ sql );
949  throw new UnsupportedOperationException("Not supported yet,"
950  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
951  + " class:" + new Throwable().getStackTrace()[0].getClassName()
952  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
953  }
954 
955  @Override
956  public void updateBinaryStream(int columnIndex, InputStream x, int length)
957  throws SQLException { // logger.debug("Entered "+ sql );
958  throw new UnsupportedOperationException("Not supported yet,"
959  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
960  + " class:" + new Throwable().getStackTrace()[0].getClassName()
961  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
962  }
963 
964  @Override
965  public void updateCharacterStream(int columnIndex, Reader x, int length)
966  throws SQLException { // logger.debug("Entered "+ sql );
967  throw new UnsupportedOperationException("Not supported yet,"
968  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
969  + " class:" + new Throwable().getStackTrace()[0].getClassName()
970  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
971  }
972 
973  @Override
974  public void updateObject(int columnIndex, Object x, int scaleOrLength)
975  throws SQLException { // logger.debug("Entered "+ sql );
976  throw new UnsupportedOperationException("Not supported yet,"
977  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
978  + " class:" + new Throwable().getStackTrace()[0].getClassName()
979  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
980  }
981 
982  @Override
983  public void updateObject(int columnIndex, Object x)
984  throws SQLException { // logger.debug("Entered "+ sql );
985  throw new UnsupportedOperationException("Not supported yet,"
986  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
987  + " class:" + new Throwable().getStackTrace()[0].getClassName()
988  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
989  }
990 
991  @Override
992  public void updateNull(String columnLabel)
993  throws SQLException { // logger.debug("Entered "+ sql );
994  throw new UnsupportedOperationException("Not supported yet,"
995  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
996  + " class:" + new Throwable().getStackTrace()[0].getClassName()
997  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
998  }
999 
1000  @Override
1001  public void updateBoolean(String columnLabel, boolean x)
1002  throws SQLException { // logger.debug("Entered "+ sql );
1003  throw new UnsupportedOperationException("Not supported yet,"
1004  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1005  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1006  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1007  }
1008 
1009  @Override
1010  public void updateByte(String columnLabel, byte x)
1011  throws SQLException { // logger.debug("Entered "+ sql );
1012  throw new UnsupportedOperationException("Not supported yet,"
1013  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1014  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1015  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1016  }
1017 
1018  @Override
1019  public void updateShort(String columnLabel, short x)
1020  throws SQLException { // logger.debug("Entered "+ sql );
1021  throw new UnsupportedOperationException("Not supported yet,"
1022  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1023  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1024  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1025  }
1026 
1027  @Override
1028  public void updateInt(String columnLabel, int x)
1029  throws SQLException { // logger.debug("Entered "+ sql );
1030  throw new UnsupportedOperationException("Not supported yet,"
1031  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1032  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1033  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1034  }
1035 
1036  @Override
1037  public void updateLong(String columnLabel, long x)
1038  throws SQLException { // logger.debug("Entered "+ sql );
1039  throw new UnsupportedOperationException("Not supported yet,"
1040  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1041  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1042  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1043  }
1044 
1045  @Override
1046  public void updateFloat(String columnLabel, float x)
1047  throws SQLException { // logger.debug("Entered "+ sql );
1048  throw new UnsupportedOperationException("Not supported yet,"
1049  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1050  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1051  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1052  }
1053 
1054  @Override
1055  public void updateDouble(String columnLabel, double x)
1056  throws SQLException { // logger.debug("Entered "+ sql );
1057  throw new UnsupportedOperationException("Not supported yet,"
1058  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1059  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1060  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1061  }
1062 
1063  @Override
1064  public void updateBigDecimal(String columnLabel, BigDecimal x)
1065  throws SQLException { // logger.debug("Entered "+ sql );
1066  throw new UnsupportedOperationException("Not supported yet,"
1067  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1068  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1069  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1070  }
1071 
1072  @Override
1073  public void updateString(String columnLabel, String x)
1074  throws SQLException { // logger.debug("Entered "+ sql );
1075  throw new UnsupportedOperationException("Not supported yet,"
1076  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1077  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1078  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1079  }
1080 
1081  @Override
1082  public void updateBytes(String columnLabel, byte[] x)
1083  throws SQLException { // logger.debug("Entered "+ sql );
1084  throw new UnsupportedOperationException("Not supported yet,"
1085  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1086  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1087  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1088  }
1089 
1090  @Override
1091  public void updateDate(String columnLabel, Date x)
1092  throws SQLException { // logger.debug("Entered "+ sql );
1093  throw new UnsupportedOperationException("Not supported yet,"
1094  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1095  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1096  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1097  }
1098 
1099  @Override
1100  public void updateTime(String columnLabel, Time x)
1101  throws SQLException { // logger.debug("Entered "+ sql );
1102  throw new UnsupportedOperationException("Not supported yet,"
1103  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1104  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1105  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1106  }
1107 
1108  @Override
1109  public void updateTimestamp(String columnLabel, Timestamp x)
1110  throws SQLException { // logger.debug("Entered "+ sql );
1111  throw new UnsupportedOperationException("Not supported yet,"
1112  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1113  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1114  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1115  }
1116 
1117  @Override
1118  public void updateAsciiStream(String columnLabel, InputStream x, int length)
1119  throws SQLException { // logger.debug("Entered "+ sql );
1120  throw new UnsupportedOperationException("Not supported yet,"
1121  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1122  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1123  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1124  }
1125 
1126  @Override
1127  public void updateBinaryStream(String columnLabel, InputStream x, int length)
1128  throws SQLException { // logger.debug("Entered "+ sql );
1129  throw new UnsupportedOperationException("Not supported yet,"
1130  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1131  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1132  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1133  }
1134 
1135  @Override
1136  public void updateCharacterStream(String columnLabel, Reader reader, int length)
1137  throws SQLException { // logger.debug("Entered "+ sql );
1138  throw new UnsupportedOperationException("Not supported yet,"
1139  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1140  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1141  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1142  }
1143 
1144  @Override
1145  public void updateObject(String columnLabel, Object x, int scaleOrLength)
1146  throws SQLException { // logger.debug("Entered "+ sql );
1147  throw new UnsupportedOperationException("Not supported yet,"
1148  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1149  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1150  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1151  }
1152 
1153  @Override
1154  public void updateObject(String columnLabel, Object x)
1155  throws SQLException { // logger.debug("Entered "+ sql );
1156  throw new UnsupportedOperationException("Not supported yet,"
1157  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1158  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1159  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1160  }
1161 
1162  @Override
1163  public void insertRow() throws SQLException { // logger.debug("Entered "+ sql );
1164  throw new UnsupportedOperationException("Not supported yet,"
1165  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1166  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1167  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1168  }
1169 
1170  @Override
1171  public void updateRow() throws SQLException { // logger.debug("Entered "+ sql );
1172  throw new UnsupportedOperationException("Not supported yet,"
1173  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1174  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1175  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1176  }
1177 
1178  @Override
1179  public void deleteRow() throws SQLException { // logger.debug("Entered "+ sql );
1180  throw new UnsupportedOperationException("Not supported yet,"
1181  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1182  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1183  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1184  }
1185 
1186  @Override
1187  public void refreshRow() throws SQLException { // logger.debug("Entered "+ sql );
1188  throw new UnsupportedOperationException("Not supported yet,"
1189  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1190  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1191  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1192  }
1193 
1194  @Override
1195  public void cancelRowUpdates() throws SQLException { // logger.debug("Entered "+ sql );
1196  throw new UnsupportedOperationException("Not supported yet,"
1197  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1198  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1199  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1200  }
1201 
1202  @Override
1203  public void moveToInsertRow() throws SQLException { // logger.debug("Entered "+ sql );
1204  throw new UnsupportedOperationException("Not supported yet,"
1205  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1206  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1207  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1208  }
1209 
1210  @Override
1211  public void moveToCurrentRow() throws SQLException { // logger.debug("Entered "+ sql );
1212  throw new UnsupportedOperationException("Not supported yet,"
1213  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1214  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1215  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1216  }
1217 
1218  @Override
1219  public Statement getStatement() throws SQLException { // logger.debug("Entered "+ sql );
1220  throw new UnsupportedOperationException("Not supported yet,"
1221  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1222  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1223  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1224  }
1225 
1226  @Override
1227  public Object getObject(int columnIndex, Map<String, Class<?>> map)
1228  throws SQLException { // logger.debug("Entered "+ sql );
1229  throw new UnsupportedOperationException("Not supported yet,"
1230  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1231  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1232  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1233  }
1234 
1235  @Override
1236  public Ref getRef(int columnIndex)
1237  throws SQLException { // logger.debug("Entered "+ sql );
1238  throw new UnsupportedOperationException("Not supported yet,"
1239  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1240  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1241  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1242  }
1243 
1244  @Override
1245  public Blob getBlob(int columnIndex)
1246  throws SQLException { // logger.debug("Entered "+ sql );
1247  throw new UnsupportedOperationException("Not supported yet,"
1248  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1249  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1250  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1251  }
1252 
1253  @Override
1254  public Clob getClob(int columnIndex)
1255  throws SQLException { // logger.debug("Entered "+ sql );
1256  throw new UnsupportedOperationException("Not supported yet,"
1257  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1258  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1259  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1260  }
1261 
1262  @Override
1263  public Array getArray(int columnIndex)
1264  throws SQLException { // logger.debug("Entered "+ sql );
1265  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1266  wasNull = true;
1267  return null;
1268  } else {
1269  wasNull = false;
1270  if (!rowDesc.get(columnIndex - 1).col_type.is_array) {
1271  throw new SQLException(
1272  "Column " + rowDesc.get(columnIndex - 1).col_name + " is not an array");
1273  }
1274 
1275  Object[] elements;
1276  int size =
1277  rowSet.columns.get(columnIndex - 1).data.arr_col.get(offset).nulls.size();
1278  switch (rowDesc.get(columnIndex - 1).col_type.type) {
1279  case TINYINT:
1280  elements = new Byte[size];
1281  for (int i = 0; i < size; ++i) {
1282  elements[i] = rowSet.columns.get(columnIndex - 1)
1283  .data.arr_col.get(offset)
1284  .data.int_col.get(i)
1285  .byteValue();
1286  }
1287  break;
1288  case SMALLINT:
1289  elements = new Short[size];
1290  for (int i = 0; i < size; ++i) {
1291  elements[i] = rowSet.columns.get(columnIndex - 1)
1292  .data.arr_col.get(offset)
1293  .data.int_col.get(i)
1294  .shortValue();
1295  }
1296  break;
1297  case INT:
1298  elements = new Integer[size];
1299  for (int i = 0; i < size; ++i) {
1300  elements[i] = rowSet.columns.get(columnIndex - 1)
1301  .data.arr_col.get(offset)
1302  .data.int_col.get(i)
1303  .intValue();
1304  }
1305  break;
1306  case BIGINT:
1307  elements = new Long[size];
1308  for (int i = 0; i < size; ++i) {
1309  elements[i] = rowSet.columns.get(columnIndex - 1)
1310  .data.arr_col.get(offset)
1311  .data.int_col.get(i);
1312  }
1313  break;
1314  case BOOL:
1315  elements = new Boolean[size];
1316  for (int i = 0; i < size; ++i) {
1317  elements[i] = rowSet.columns.get(columnIndex - 1)
1318  .data.arr_col.get(offset)
1319  .data.int_col.get(i)
1320  == 0;
1321  }
1322  break;
1323  case TIME:
1324  elements = new Time[size];
1325  for (int i = 0; i < size; ++i) {
1326  elements[i] = new Time(rowSet.columns.get(columnIndex - 1)
1327  .data.arr_col.get(offset)
1328  .data.int_col.get(i)
1329  * 1000);
1330  }
1331  break;
1332  case TIMESTAMP:
1333  elements = new Timestamp[size];
1334  for (int i = 0; i < size; ++i) {
1335  elements[i] = adjust_precision(rowSet.columns.get(columnIndex - 1)
1336  .data.arr_col.get(offset)
1337  .data.int_col.get(i),
1338  rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision());
1339  }
1340  break;
1341  case DATE:
1342  elements = new Date[size];
1343  for (int i = 0; i < size; ++i) {
1344  elements[i] = new Date(rowSet.columns.get(columnIndex - 1)
1345  .data.arr_col.get(offset)
1346  .data.int_col.get(i)
1347  * 1000);
1348  }
1349  break;
1350  case FLOAT:
1351  elements = new Float[size];
1352  for (int i = 0; i < size; ++i) {
1353  elements[i] = rowSet.columns.get(columnIndex - 1)
1354  .data.arr_col.get(offset)
1355  .data.real_col.get(i)
1356  .floatValue();
1357  }
1358  break;
1359  case DECIMAL:
1360  elements = new BigDecimal[size];
1361  for (int i = 0; i < size; ++i) {
1362  elements[i] = BigDecimal.valueOf(rowSet.columns.get(columnIndex - 1)
1363  .data.arr_col.get(offset)
1364  .data.real_col.get(i));
1365  }
1366  break;
1367  case DOUBLE:
1368  elements = new Double[size];
1369  for (int i = 0; i < size; ++i) {
1370  elements[i] = rowSet.columns.get(columnIndex - 1)
1371  .data.arr_col.get(offset)
1372  .data.real_col.get(i);
1373  }
1374  break;
1375  case STR:
1376  case POINT:
1377  case LINESTRING:
1378  case POLYGON:
1379  case MULTIPOLYGON:
1380  elements = new String[size];
1381  for (int i = 0; i < size; ++i) {
1382  elements[i] = rowSet.columns.get(columnIndex - 1)
1383  .data.arr_col.get(offset)
1384  .data.str_col.get(i);
1385  }
1386  break;
1387  default:
1388  throw new AssertionError(rowDesc.get(columnIndex - 1).col_type.type.name());
1389  }
1390 
1391  for (int i = 0; i < size; ++i) {
1392  if (this.rowSet.columns.get(columnIndex - 1)
1393  .data.arr_col.get(offset)
1394  .nulls.get(i)) {
1395  elements[i] = null;
1396  }
1397  }
1398 
1399  return new OmniSciArray(rowDesc.get(columnIndex - 1).col_type.type, elements);
1400  }
1401  }
1402 
1403  @Override
1404  public Object getObject(String columnLabel, Map<String, Class<?>> map)
1405  throws SQLException { // logger.debug("Entered "+ sql );
1406  throw new UnsupportedOperationException("Not supported yet,"
1407  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1408  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1409  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1410  }
1411 
1412  @Override
1413  public Ref getRef(String columnLabel)
1414  throws SQLException { // logger.debug("Entered "+ sql );
1415  throw new UnsupportedOperationException("Not supported yet,"
1416  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1417  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1418  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1419  }
1420 
1421  @Override
1422  public Blob getBlob(String columnLabel)
1423  throws SQLException { // logger.debug("Entered "+ sql );
1424  throw new UnsupportedOperationException("Not supported yet,"
1425  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1426  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1427  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1428  }
1429 
1430  @Override
1431  public Clob getClob(String columnLabel)
1432  throws SQLException { // logger.debug("Entered "+ sql );
1433  throw new UnsupportedOperationException("Not supported yet,"
1434  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1435  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1436  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1437  }
1438 
1439  @Override
1440  public Array getArray(String columnLabel)
1441  throws SQLException { // logger.debug("Entered "+ sql );
1442  return getArray(findColumnByName(columnLabel));
1443  }
1444 
1445  // this method is used to add a TZ from Calendar; is TimeZone in the calendar isn't
1446  // specified it uses the local TZ
1447  private long getOffsetFromTZ(long actualmillis, Calendar cal, int precision) {
1448  long offset;
1449  if (cal.getTimeZone() != null) {
1450  offset = cal.getTimeZone().getOffset(actualmillis);
1451  } else {
1452  offset = Calendar.getInstance().getTimeZone().getOffset(actualmillis);
1453  }
1454  switch (precision) {
1455  case 0:
1456  return offset / 1000;
1457  case 3:
1458  return offset;
1459  case 6:
1460  return offset * 1000;
1461  case 9:
1462  return offset * 1000000;
1463  default:
1464  throw new RuntimeException("Invalid precision [" + Integer.toString(precision)
1465  + "] returned. Valid values 0,3,6,9");
1466  }
1467  }
1468 
1469  @Override
1470  public Date getDate(int columnIndex, Calendar cal) throws SQLException {
1471  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1472  wasNull = true;
1473  return null;
1474  } else {
1475  // assume column is str already for now
1476  wasNull = false;
1477  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1478  if (cal != null) {
1479  val += getOffsetFromTZ(val, cal, 0);
1480  }
1481  Date d = new Date(val * 1000);
1482  return d;
1483  }
1484  }
1485 
1486  @Override
1487  public Date getDate(String columnLabel, Calendar cal) throws SQLException {
1488  return getDate(findColumnByName(columnLabel), cal);
1489  }
1490 
1491  @Override
1492  public Time getTime(int columnIndex, Calendar cal)
1493  throws SQLException { // logger.debug("Entered "+ sql );
1494  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1495  wasNull = true;
1496  return null;
1497  } else {
1498  // assume column is str already for now
1499  wasNull = false;
1500  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1501  if (cal != null) {
1502  val += getOffsetFromTZ(val, cal, 0);
1503  }
1504  return new Time(val * 1000);
1505  }
1506  }
1507 
1508  @Override
1509  public Time getTime(String columnLabel, Calendar cal)
1510  throws SQLException { // logger.debug("Entered "+ sql );
1511  return getTime(findColumnByName(columnLabel), cal);
1512  }
1513 
1514  @Override
1515  public Timestamp getTimestamp(int columnIndex, Calendar cal)
1516  throws SQLException { // logger.debug("Entered "+ sql );
1517  if (rowSet.columns.get(columnIndex - 1).nulls.get(offset)) {
1518  wasNull = true;
1519  return null;
1520  } else {
1521  // assume column is str already for now
1522  wasNull = false;
1523  long val = rowSet.columns.get(columnIndex - 1).data.int_col.get(offset);
1524  int precision = rowSet.row_desc.get(columnIndex - 1).col_type.getPrecision();
1525  if (cal != null) {
1526  val += getOffsetFromTZ(val, cal, precision);
1527  }
1528  return adjust_precision(val, precision);
1529  }
1530  }
1531 
1532  @Override
1533  public Timestamp getTimestamp(String columnLabel, Calendar cal)
1534  throws SQLException { // logger.debug("Entered "+ sql );
1535  return getTimestamp(findColumnByName(columnLabel), cal);
1536  }
1537 
1538  @Override
1539  public URL getURL(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 URL getURL(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 updateRef(int columnIndex, Ref 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 updateRef(String columnLabel, Ref 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 void updateBlob(int columnIndex, Blob x)
1576  throws SQLException { // logger.debug("Entered "+ sql );
1577  throw new UnsupportedOperationException("Not supported yet,"
1578  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1579  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1580  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1581  }
1582 
1583  @Override
1584  public void updateBlob(String columnLabel, Blob x)
1585  throws SQLException { // logger.debug("Entered "+ sql );
1586  throw new UnsupportedOperationException("Not supported yet,"
1587  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1588  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1589  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1590  }
1591 
1592  @Override
1593  public void updateClob(int columnIndex, Clob x)
1594  throws SQLException { // logger.debug("Entered "+ sql );
1595  throw new UnsupportedOperationException("Not supported yet,"
1596  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1597  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1598  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1599  }
1600 
1601  @Override
1602  public void updateClob(String columnLabel, Clob x)
1603  throws SQLException { // logger.debug("Entered "+ sql );
1604  throw new UnsupportedOperationException("Not supported yet,"
1605  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1606  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1607  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1608  }
1609 
1610  @Override
1611  public void updateArray(int columnIndex, Array x)
1612  throws SQLException { // logger.debug("Entered "+ sql );
1613  throw new UnsupportedOperationException("Not supported yet,"
1614  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1615  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1616  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1617  }
1618 
1619  @Override
1620  public void updateArray(String columnLabel, Array x)
1621  throws SQLException { // logger.debug("Entered "+ sql );
1622  throw new UnsupportedOperationException("Not supported yet,"
1623  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1624  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1625  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1626  }
1627 
1628  @Override
1629  public RowId getRowId(int columnIndex)
1630  throws SQLException { // logger.debug("Entered "+ sql );
1631  throw new UnsupportedOperationException("Not supported yet,"
1632  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1633  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1634  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1635  }
1636 
1637  @Override
1638  public RowId getRowId(String columnLabel)
1639  throws SQLException { // logger.debug("Entered "+ sql );
1640  throw new UnsupportedOperationException("Not supported yet,"
1641  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1642  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1643  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1644  }
1645 
1646  @Override
1647  public void updateRowId(int columnIndex, RowId x)
1648  throws SQLException { // logger.debug("Entered "+ sql );
1649  throw new UnsupportedOperationException("Not supported yet,"
1650  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1651  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1652  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1653  }
1654 
1655  @Override
1656  public void updateRowId(String columnLabel, RowId x)
1657  throws SQLException { // logger.debug("Entered "+ sql );
1658  throw new UnsupportedOperationException("Not supported yet,"
1659  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1660  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1661  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1662  }
1663 
1664  @Override
1665  public int getHoldability() throws SQLException { // logger.debug("Entered "+ sql );
1666  throw new UnsupportedOperationException("Not supported yet,"
1667  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
1668  + " class:" + new Throwable().getStackTrace()[0].getClassName()
1669  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
1670  }
1671 
1672  @Override
1673  public boolean isClosed() 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 void updateNString(int columnIndex, String nString)
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 void updateNString(String columnLabel, String nString)
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 void updateNClob(int columnIndex, NClob nClob)
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 void updateNClob(String columnLabel, NClob nClob)
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 NClob getNClob(int columnIndex)
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 NClob getNClob(String columnLabel)
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 SQLXML getSQLXML(int columnIndex)
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 SQLXML getSQLXML(String columnLabel)
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 updateSQLXML(int columnIndex, SQLXML xmlObject)
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 updateSQLXML(String columnLabel, SQLXML xmlObject)
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 String getNString(int columnIndex)
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 String getNString(String columnLabel)
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 Reader getNCharacterStream(int columnIndex)
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 Reader getNCharacterStream(String columnLabel)
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 updateNCharacterStream(int columnIndex, Reader x, 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 updateNCharacterStream(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 updateAsciiStream(int columnIndex, InputStream x, 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 updateBinaryStream(int columnIndex, InputStream x, 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 updateCharacterStream(int columnIndex, Reader x, long length)
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 updateAsciiStream(String columnLabel, InputStream x, long length)
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 updateBinaryStream(String columnLabel, InputStream x, long length)
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 updateCharacterStream(String columnLabel, Reader reader, long length)
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 updateBlob(int columnIndex, InputStream inputStream, long length)
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 updateBlob(String columnLabel, InputStream inputStream, long length)
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 updateClob(int columnIndex, Reader reader, long length)
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 updateClob(String columnLabel, Reader reader, long length)
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 updateNClob(int columnIndex, Reader reader, long length)
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 updateNClob(String columnLabel, Reader reader, long length)
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 updateNCharacterStream(int columnIndex, Reader x)
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 updateNCharacterStream(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 updateAsciiStream(int columnIndex, InputStream x)
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 updateBinaryStream(int columnIndex, InputStream x)
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 void updateCharacterStream(int columnIndex, Reader x)
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 void updateAsciiStream(String columnLabel, InputStream x)
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 void updateBinaryStream(String columnLabel, InputStream x)
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 void updateCharacterStream(String columnLabel, Reader reader)
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 
2004  @Override
2005  public void updateBlob(int columnIndex, InputStream inputStream)
2006  throws SQLException { // logger.debug("Entered "+ sql );
2007  throw new UnsupportedOperationException("Not supported yet,"
2008  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2009  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2010  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2011  }
2012 
2013  @Override
2014  public void updateBlob(String columnLabel, InputStream inputStream)
2015  throws SQLException { // logger.debug("Entered "+ sql );
2016  throw new UnsupportedOperationException("Not supported yet,"
2017  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2018  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2019  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2020  }
2021 
2022  @Override
2023  public void updateClob(int columnIndex, Reader reader)
2024  throws SQLException { // logger.debug("Entered "+ sql );
2025  throw new UnsupportedOperationException("Not supported yet,"
2026  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2027  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2028  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2029  }
2030 
2031  @Override
2032  public void updateClob(String columnLabel, Reader reader)
2033  throws SQLException { // logger.debug("Entered "+ sql );
2034  throw new UnsupportedOperationException("Not supported yet,"
2035  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2036  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2037  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2038  }
2039 
2040  @Override
2041  public void updateNClob(int columnIndex, Reader reader)
2042  throws SQLException { // logger.debug("Entered "+ sql );
2043  throw new UnsupportedOperationException("Not supported yet,"
2044  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2045  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2046  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2047  }
2048 
2049  @Override
2050  public void updateNClob(String columnLabel, Reader reader)
2051  throws SQLException { // logger.debug("Entered "+ sql );
2052  throw new UnsupportedOperationException("Not supported yet,"
2053  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2054  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2055  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2056  }
2057 
2058  @Override
2059  public <T> T getObject(int columnIndex, Class<T> type)
2060  throws SQLException { // logger.debug("Entered "+ sql );
2061  throw new UnsupportedOperationException("Not supported yet,"
2062  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2063  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2064  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2065  }
2066 
2067  @Override
2068  public <T> T getObject(String columnLabel, Class<T> type)
2069  throws SQLException { // logger.debug("Entered "+ sql );
2070  throw new UnsupportedOperationException("Not supported yet,"
2071  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2072  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2073  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2074  }
2075 
2076  @Override
2077  public <T> T unwrap(Class<T> iface)
2078  throws SQLException { // logger.debug("Entered "+ sql );
2079  throw new UnsupportedOperationException("Not supported yet,"
2080  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2081  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2082  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2083  }
2084 
2085  @Override
2086  public boolean isWrapperFor(Class<?> iface)
2087  throws SQLException { // logger.debug("Entered "+ sql );
2088  throw new UnsupportedOperationException("Not supported yet,"
2089  + " line:" + new Throwable().getStackTrace()[0].getLineNumber()
2090  + " class:" + new Throwable().getStackTrace()[0].getClassName()
2091  + " method:" + new Throwable().getStackTrace()[0].getMethodName());
2092  }
2093 
2094  private Integer findColumnByName(String name) throws SQLException {
2095  Integer colNum = columnMap.get(name);
2096  if (colNum == null) {
2097  throw new SQLException("Could not find the column " + name);
2098  }
2099  return colNum;
2100  }
2101 }
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 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)
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)
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)
Timestamp adjust_precision(long val, int precision)
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)