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