← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/ikvm/openjdk/sun/jdbc/odbc/JdbcOdbcCallableStatement.java

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/ikvm/openjdk/sun/jdbc/odbc/JdbcOdbcCallableStatement.java
 
1
/*
 
2
  Copyright (C) 2009, 2011 Volker Berlin (i-net software)
 
3
 
 
4
  This software is provided 'as-is', without any express or implied
 
5
  warranty.  In no event will the authors be held liable for any damages
 
6
  arising from the use of this software.
 
7
 
 
8
  Permission is granted to anyone to use this software for any purpose,
 
9
  including commercial applications, and to alter it and redistribute it
 
10
  freely, subject to the following restrictions:
 
11
 
 
12
  1. The origin of this software must not be misrepresented; you must not
 
13
     claim that you wrote the original software. If you use this software
 
14
     in a product, an acknowledgment in the product documentation would be
 
15
     appreciated but is not required.
 
16
  2. Altered source versions must be plainly marked as such, and must not be
 
17
     misrepresented as being the original software.
 
18
  3. This notice may not be removed or altered from any source distribution.
 
19
 
 
20
  Jeroen Frijters
 
21
  jeroen@frijters.net
 
22
  
 
23
 */
 
24
package sun.jdbc.odbc;
 
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.Map;
 
33
 
 
34
import cli.System.Data.*;
 
35
import cli.System.Data.Common.*;
 
36
import cli.System.Data.Odbc.*;
 
37
 
 
38
 
 
39
 
 
40
/**
 
41
 * @author Volker Berlin
 
42
 */
 
43
public class JdbcOdbcCallableStatement extends JdbcOdbcPreparedStatement implements CallableStatement{
 
44
 
 
45
    private final Parameters parameters = new Parameters();
 
46
    
 
47
    public JdbcOdbcCallableStatement(JdbcOdbcConnection jdbcConn, OdbcCommand command, String sql, int resultSetType, int resultSetConcurrency){
 
48
        super(jdbcConn, command, sql, resultSetType, resultSetConcurrency);
 
49
    }
 
50
 
 
51
 
 
52
    public final Array getArray(int parameterIndex){
 
53
        return parameters.getArray(parameterIndex);
 
54
    }
 
55
 
 
56
 
 
57
    public final Array getArray(String parameterName) throws SQLException{
 
58
        return parameters.getArray(parameterName);
 
59
    }
 
60
 
 
61
 
 
62
    public final BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException{
 
63
        return parameters.getBigDecimal(parameterIndex, scale);
 
64
    }
 
65
 
 
66
 
 
67
    public final BigDecimal getBigDecimal(int parameterIndex) throws SQLException{
 
68
        return parameters.getBigDecimal(parameterIndex);
 
69
    }
 
70
 
 
71
 
 
72
    public final BigDecimal getBigDecimal(String parameterName) throws SQLException{
 
73
        return parameters.getBigDecimal(parameterName);
 
74
    }
 
75
 
 
76
 
 
77
    public final Blob getBlob(int parameterIndex){
 
78
        return parameters.getBlob(parameterIndex);
 
79
    }
 
80
 
 
81
 
 
82
    public final Blob getBlob(String parameterName) throws SQLException{
 
83
        return parameters.getBlob(parameterName);
 
84
    }
 
85
 
 
86
 
 
87
    public final boolean getBoolean(int parameterIndex) throws SQLException{
 
88
        return parameters.getBoolean(parameterIndex);
 
89
    }
 
90
 
 
91
 
 
92
    public final boolean getBoolean(String parameterName) throws SQLException{
 
93
        return parameters.getBoolean(parameterName);
 
94
    }
 
95
 
 
96
 
 
97
    public final byte getByte(int parameterIndex) throws SQLException{
 
98
        return parameters.getByte(parameterIndex);
 
99
    }
 
100
 
 
101
 
 
102
    public final byte getByte(String parameterName) throws SQLException{
 
103
        return parameters.getByte(parameterName);
 
104
    }
 
105
 
 
106
 
 
107
    public final byte[] getBytes(int parameterIndex) throws SQLException{
 
108
        return parameters.getBytes(parameterIndex);
 
109
    }
 
110
 
 
111
 
 
112
    public final byte[] getBytes(String parameterName) throws SQLException{
 
113
        return parameters.getBytes(parameterName);
 
114
    }
 
115
 
 
116
 
 
117
    public final Reader getCharacterStream(int parameterIndex) throws SQLException{
 
118
        return parameters.getCharacterStream(parameterIndex);
 
119
    }
 
120
 
 
121
 
 
122
    public final Reader getCharacterStream(String parameterName) throws SQLException{
 
123
        return parameters.getCharacterStream(parameterName);
 
124
    }
 
125
 
 
126
 
 
127
    public final Clob getClob(int parameterIndex){
 
128
        return parameters.getClob(parameterIndex);
 
129
    }
 
130
 
 
131
 
 
132
    public final Clob getClob(String parameterName) throws SQLException{
 
133
        return parameters.getClob(parameterName);
 
134
    }
 
135
 
 
136
 
 
137
    public final Date getDate(int parameterIndex, Calendar cal) throws SQLException{
 
138
        return parameters.getDate(parameterIndex, cal);
 
139
    }
 
140
 
 
141
 
 
142
    public final Date getDate(int parameterIndex) throws SQLException{
 
143
        return parameters.getDate(parameterIndex);
 
144
    }
 
145
 
 
146
 
 
147
    public final Date getDate(String parameterName, Calendar cal) throws SQLException{
 
148
        return parameters.getDate(parameterName, cal);
 
149
    }
 
150
 
 
151
 
 
152
    public final Date getDate(String parameterName) throws SQLException{
 
153
        return parameters.getDate(parameterName);
 
154
    }
 
155
 
 
156
 
 
157
    public final double getDouble(int parameterIndex) throws SQLException{
 
158
        return parameters.getDouble(parameterIndex);
 
159
    }
 
160
 
 
161
 
 
162
    public final double getDouble(String parameterName) throws SQLException{
 
163
        return parameters.getDouble(parameterName);
 
164
    }
 
165
 
 
166
 
 
167
    public final float getFloat(int parameterIndex) throws SQLException{
 
168
        return parameters.getFloat(parameterIndex);
 
169
    }
 
170
 
 
171
 
 
172
    public final float getFloat(String parameterName) throws SQLException{
 
173
        return parameters.getFloat(parameterName);
 
174
    }
 
175
 
 
176
 
 
177
    public final int getInt(int parameterIndex) throws SQLException{
 
178
        return parameters.getInt(parameterIndex);
 
179
    }
 
180
 
 
181
 
 
182
    public final int getInt(String parameterName) throws SQLException{
 
183
        return parameters.getInt(parameterName);
 
184
    }
 
185
 
 
186
 
 
187
    public final long getLong(int parameterIndex) throws SQLException{
 
188
        return parameters.getLong(parameterIndex);
 
189
    }
 
190
 
 
191
 
 
192
    public final long getLong(String parameterName) throws SQLException{
 
193
        return parameters.getLong(parameterName);
 
194
    }
 
195
 
 
196
 
 
197
    public final Reader getNCharacterStream(int parameterIndex) throws SQLException{
 
198
        return parameters.getNCharacterStream(parameterIndex);
 
199
    }
 
200
 
 
201
 
 
202
    public final Reader getNCharacterStream(String parameterName) throws SQLException{
 
203
        return parameters.getNCharacterStream(parameterName);
 
204
    }
 
205
 
 
206
 
 
207
    public final NClob getNClob(int parameterIndex){
 
208
        return parameters.getNClob(parameterIndex);
 
209
    }
 
210
 
 
211
 
 
212
    public final NClob getNClob(String parameterName) throws SQLException{
 
213
        return parameters.getNClob(parameterName);
 
214
    }
 
215
 
 
216
 
 
217
    public final String getNString(int parameterIndex) throws SQLException{
 
218
        return parameters.getNString(parameterIndex);
 
219
    }
 
220
 
 
221
 
 
222
    public final String getNString(String parameterName) throws SQLException{
 
223
        return parameters.getNString(parameterName);
 
224
    }
 
225
 
 
226
 
 
227
    public final Object getObject(int parameterIndex, Map<String, Class<?>> map){
 
228
        return parameters.getObject(parameterIndex, map);
 
229
    }
 
230
 
 
231
 
 
232
    public final Object getObject(int parameterIndex) throws SQLException{
 
233
        return parameters.getObject(parameterIndex);
 
234
    }
 
235
 
 
236
 
 
237
    public final Object getObject(String parameterName, Map<String, Class<?>> map) throws SQLException{
 
238
        return parameters.getObject(parameterName, map);
 
239
    }
 
240
 
 
241
 
 
242
    public final Object getObject(String parameterName) throws SQLException{
 
243
        return parameters.getObject(parameterName);
 
244
    }
 
245
 
 
246
 
 
247
    public final Ref getRef(int parameterIndex){
 
248
        return parameters.getRef(parameterIndex);
 
249
    }
 
250
 
 
251
 
 
252
    public final Ref getRef(String parameterName) throws SQLException{
 
253
        return parameters.getRef(parameterName);
 
254
    }
 
255
 
 
256
 
 
257
    public final RowId getRowId(int parameterIndex){
 
258
        return parameters.getRowId(parameterIndex);
 
259
    }
 
260
 
 
261
 
 
262
    public final RowId getRowId(String parameterName) throws SQLException{
 
263
        return parameters.getRowId(parameterName);
 
264
    }
 
265
 
 
266
 
 
267
    public final short getShort(int parameterIndex) throws SQLException{
 
268
        return parameters.getShort(parameterIndex);
 
269
    }
 
270
 
 
271
 
 
272
    public final short getShort(String parameterName) throws SQLException{
 
273
        return parameters.getShort(parameterName);
 
274
    }
 
275
 
 
276
 
 
277
    public final SQLXML getSQLXML(int parameterIndex){
 
278
        return parameters.getSQLXML(parameterIndex);
 
279
    }
 
280
 
 
281
 
 
282
    public final SQLXML getSQLXML(String parameterName) throws SQLException{
 
283
        return parameters.getSQLXML(parameterName);
 
284
    }
 
285
 
 
286
 
 
287
    public final String getString(int parameterIndex) throws SQLException{
 
288
        return parameters.getString(parameterIndex);
 
289
    }
 
290
 
 
291
 
 
292
    public final String getString(String parameterName) throws SQLException{
 
293
        return parameters.getString(parameterName);
 
294
    }
 
295
 
 
296
 
 
297
    public final Time getTime(int parameterIndex, Calendar cal) throws SQLException{
 
298
        return parameters.getTime(parameterIndex, cal);
 
299
    }
 
300
 
 
301
 
 
302
    public final Time getTime(int parameterIndex) throws SQLException{
 
303
        return parameters.getTime(parameterIndex);
 
304
    }
 
305
 
 
306
 
 
307
    public final Time getTime(String parameterName, Calendar cal) throws SQLException{
 
308
        return parameters.getTime(parameterName, cal);
 
309
    }
 
310
 
 
311
 
 
312
    public final Time getTime(String parameterName) throws SQLException{
 
313
        return parameters.getTime(parameterName);
 
314
    }
 
315
 
 
316
 
 
317
    public final Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException{
 
318
        return parameters.getTimestamp(parameterIndex, cal);
 
319
    }
 
320
 
 
321
 
 
322
    public final Timestamp getTimestamp(int parameterIndex) throws SQLException{
 
323
        return parameters.getTimestamp(parameterIndex);
 
324
    }
 
325
 
 
326
 
 
327
    public final Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException{
 
328
        return parameters.getTimestamp(parameterName, cal);
 
329
    }
 
330
 
 
331
 
 
332
    public final Timestamp getTimestamp(String parameterName) throws SQLException{
 
333
        return parameters.getTimestamp(parameterName);
 
334
    }
 
335
 
 
336
 
 
337
    public final URL getURL(int parameterIndex) throws SQLException{
 
338
        return parameters.getURL(parameterIndex);
 
339
    }
 
340
 
 
341
 
 
342
    public final URL getURL(String parameterName) throws SQLException{
 
343
        return parameters.getURL(parameterName);
 
344
    }
 
345
 
 
346
 
 
347
    public final boolean wasNull(){
 
348
        return parameters.wasNull();
 
349
    }
 
350
 
 
351
 
 
352
    public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException{
 
353
        registerOutParameter(parameterIndex, sqlType, -1);
 
354
    }
 
355
 
 
356
 
 
357
    public void registerOutParameter(String parameterName, int sqlType) throws SQLException{
 
358
        registerOutParameter(parameters.findColumn(parameterName), sqlType);
 
359
    }
 
360
 
 
361
 
 
362
    public void registerOutParameter(int parameterIndex, int sqlType, int scaleOrLength) throws SQLException{
 
363
        DbParameter para = getPara(parameterIndex);
 
364
        int direction = para.get_Value() == null ? ParameterDirection.Output : ParameterDirection.InputOutput;
 
365
        para.set_Direction(ParameterDirection.wrap(direction));
 
366
 
 
367
        if(sqlType != Types.OTHER){
 
368
            para.set_DbType(DbType.wrap(JdbcOdbcUtils.convertJdbc2AdoNetType(sqlType)));
 
369
        }
 
370
        
 
371
        if(scaleOrLength >= 0){
 
372
            switch(sqlType){
 
373
                case Types.DECIMAL:
 
374
                case Types.NUMERIC:
 
375
                    para.set_Scale((byte)scaleOrLength);
 
376
            }
 
377
        }
 
378
    }
 
379
 
 
380
 
 
381
    public void registerOutParameter(int parameterIndex, int sqlType, String typeName){
 
382
        throw new UnsupportedOperationException();
 
383
    }
 
384
 
 
385
 
 
386
    public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException{
 
387
        registerOutParameter(parameters.findColumn(parameterName), sqlType, scale);
 
388
    }
 
389
 
 
390
 
 
391
    public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException{
 
392
        registerOutParameter(parameters.findColumn(parameterName), sqlType, typeName);
 
393
    }
 
394
 
 
395
 
 
396
    public void setAsciiStream(String parameterName, InputStream x) throws SQLException{
 
397
        setAsciiStream(parameters.findColumn(parameterName), x);
 
398
    }
 
399
 
 
400
 
 
401
    public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException{
 
402
        setAsciiStream(parameters.findColumn(parameterName), x, length);
 
403
    }
 
404
 
 
405
 
 
406
    public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException{
 
407
        setAsciiStream(parameters.findColumn(parameterName), x, length);
 
408
    }
 
409
 
 
410
 
 
411
    public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
 
412
        setBigDecimal(parameters.findColumn(parameterName), x);
 
413
    }
 
414
 
 
415
 
 
416
    public void setBinaryStream(String parameterName, InputStream x) throws SQLException{
 
417
        setBinaryStream(parameters.findColumn(parameterName), x);
 
418
    }
 
419
 
 
420
 
 
421
    public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException{
 
422
        setBinaryStream(parameters.findColumn(parameterName), x, length);
 
423
    }
 
424
 
 
425
 
 
426
    public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException{
 
427
        setBinaryStream(parameters.findColumn(parameterName), x, length);
 
428
    }
 
429
 
 
430
 
 
431
    public void setBlob(String parameterName, Blob x) throws SQLException{
 
432
        setBlob(parameters.findColumn(parameterName), x);
 
433
    }
 
434
 
 
435
 
 
436
    public void setBlob(String parameterName, InputStream x) throws SQLException{
 
437
        setBlob(parameters.findColumn(parameterName), x);
 
438
    }
 
439
 
 
440
 
 
441
    public void setBlob(String parameterName, InputStream x, long length) throws SQLException{
 
442
        setBlob(parameters.findColumn(parameterName), x, length);
 
443
    }
 
444
 
 
445
 
 
446
    public void setBoolean(String parameterName, boolean x) throws SQLException{
 
447
        setBoolean(parameters.findColumn(parameterName), x);
 
448
    }
 
449
 
 
450
 
 
451
    public void setByte(String parameterName, byte x) throws SQLException{
 
452
        setByte(parameters.findColumn(parameterName), x);
 
453
    }
 
454
 
 
455
 
 
456
    public void setBytes(String parameterName, byte[] x) throws SQLException{
 
457
        setBytes(parameters.findColumn(parameterName), x);
 
458
    }
 
459
 
 
460
 
 
461
    public void setCharacterStream(String parameterName, Reader x) throws SQLException{
 
462
        setCharacterStream(parameters.findColumn(parameterName), x);
 
463
    }
 
464
 
 
465
 
 
466
    public void setCharacterStream(String parameterName, Reader x, int length) throws SQLException{
 
467
        setCharacterStream(parameters.findColumn(parameterName), x, length);
 
468
    }
 
469
 
 
470
 
 
471
    public void setCharacterStream(String parameterName, Reader x, long length) throws SQLException{
 
472
        setCharacterStream(parameters.findColumn(parameterName), x, length);
 
473
    }
 
474
 
 
475
 
 
476
    public void setClob(String parameterName, Clob x) throws SQLException{
 
477
        setClob(parameters.findColumn(parameterName), x);
 
478
    }
 
479
 
 
480
 
 
481
    public void setClob(String parameterName, Reader x) throws SQLException{
 
482
        setClob(parameters.findColumn(parameterName), x);
 
483
    }
 
484
 
 
485
 
 
486
    public void setClob(String parameterName, Reader x, long length) throws SQLException{
 
487
        setClob(parameters.findColumn(parameterName), x, length);
 
488
    }
 
489
 
 
490
 
 
491
    public void setDate(String parameterName, Date x) throws SQLException{
 
492
        setDate(parameters.findColumn(parameterName), x);
 
493
    }
 
494
 
 
495
 
 
496
    public void setDate(String parameterName, Date x, Calendar cal) throws SQLException{
 
497
        setDate(parameters.findColumn(parameterName), x, cal);
 
498
    }
 
499
 
 
500
 
 
501
    public void setDouble(String parameterName, double x) throws SQLException{
 
502
        setDouble(parameters.findColumn(parameterName), x);
 
503
    }
 
504
 
 
505
 
 
506
    public void setFloat(String parameterName, float x) throws SQLException{
 
507
        setFloat(parameters.findColumn(parameterName), x);
 
508
    }
 
509
 
 
510
 
 
511
    public void setInt(String parameterName, int x) throws SQLException{
 
512
        setInt(parameters.findColumn(parameterName), x);
 
513
    }
 
514
 
 
515
 
 
516
    public void setLong(String parameterName, long x) throws SQLException{
 
517
        setLong(parameters.findColumn(parameterName), x);
 
518
    }
 
519
 
 
520
 
 
521
    public void setNCharacterStream(String parameterName, Reader x) throws SQLException{
 
522
        setNCharacterStream(parameters.findColumn(parameterName), x);
 
523
    }
 
524
 
 
525
 
 
526
    public void setNCharacterStream(String parameterName, Reader x, long length) throws SQLException{
 
527
        setNCharacterStream(parameters.findColumn(parameterName), x, length);
 
528
    }
 
529
 
 
530
 
 
531
    public void setNClob(String parameterName, NClob x) throws SQLException{
 
532
        setNClob(parameters.findColumn(parameterName), x);
 
533
    }
 
534
 
 
535
 
 
536
    public void setNClob(String parameterName, Reader x) throws SQLException{
 
537
        setNClob(parameters.findColumn(parameterName), x);
 
538
    }
 
539
 
 
540
 
 
541
    public void setNClob(String parameterName, Reader x, long length) throws SQLException{
 
542
        setNClob(parameters.findColumn(parameterName), x, length);
 
543
    }
 
544
 
 
545
 
 
546
    public void setNString(String parameterName, String x) throws SQLException{
 
547
        setNString(parameters.findColumn(parameterName), x);
 
548
    }
 
549
 
 
550
 
 
551
    public void setNull(String parameterName, int sqlType) throws SQLException{
 
552
        setNull(parameters.findColumn(parameterName), sqlType);
 
553
    }
 
554
 
 
555
 
 
556
    public void setNull(String parameterName, int sqlType, String typeName) throws SQLException{
 
557
        setNull(parameters.findColumn(parameterName), sqlType, typeName);
 
558
    }
 
559
 
 
560
 
 
561
    public void setObject(String parameterName, Object x) throws SQLException{
 
562
        setObject(parameters.findColumn(parameterName), x);
 
563
    }
 
564
 
 
565
 
 
566
    public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException{
 
567
        setObject(parameters.findColumn(parameterName), x, targetSqlType);
 
568
    }
 
569
 
 
570
 
 
571
    public void setObject(String parameterName, Object x, int targetSqlType, int scaleOrLength) throws SQLException{
 
572
        setObject(parameters.findColumn(parameterName), x, targetSqlType, scaleOrLength);
 
573
    }
 
574
 
 
575
 
 
576
    public void setRowId(String parameterName, RowId x) throws SQLException{
 
577
        setRowId(parameters.findColumn(parameterName), x);
 
578
    }
 
579
 
 
580
 
 
581
    public void setSQLXML(String parameterName, SQLXML x) throws SQLException{
 
582
        setSQLXML(parameters.findColumn(parameterName), x);
 
583
    }
 
584
 
 
585
 
 
586
    public void setShort(String parameterName, short x) throws SQLException{
 
587
        setShort(parameters.findColumn(parameterName), x);
 
588
    }
 
589
 
 
590
 
 
591
    public void setString(String parameterName, String x) throws SQLException{
 
592
        setString(parameters.findColumn(parameterName), x);
 
593
    }
 
594
 
 
595
 
 
596
    public void setTime(String parameterName, Time x) throws SQLException{
 
597
        setTime(parameters.findColumn(parameterName), x);
 
598
    }
 
599
 
 
600
 
 
601
    public void setTime(String parameterName, Time x, Calendar cal) throws SQLException{
 
602
        setTime(parameters.findColumn(parameterName), x, cal);
 
603
    }
 
604
 
 
605
 
 
606
    public void setTimestamp(String parameterName, Timestamp x) throws SQLException{
 
607
        setTimestamp(parameters.findColumn(parameterName), x);
 
608
    }
 
609
 
 
610
 
 
611
    public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException{
 
612
        setTimestamp(parameters.findColumn(parameterName), x, cal);
 
613
    }
 
614
 
 
615
 
 
616
    public void setURL(String parameterName, URL x) throws SQLException{
 
617
        setURL(parameters.findColumn(parameterName), x);
 
618
    }
 
619
 
 
620
    private class Parameters extends JdbcOdbcObject{
 
621
 
 
622
        @Override
 
623
        public int findColumn(String parameterName) throws SQLException{
 
624
            try{
 
625
                DbParameterCollection params = command.get_Parameters();
 
626
                for(int i=0; i<params.get_Count();i++){
 
627
                    DbParameter param = params.get_Item(i);
 
628
                    if(parameterName.equalsIgnoreCase(param.get_ParameterName())){
 
629
                        return i+1;
 
630
                    }
 
631
                }
 
632
                throw new SQLException( "Parameter '"+parameterName+"' not found.", "S0022");
 
633
            }catch(Throwable th){
 
634
                throw JdbcOdbcUtils.createSQLException(th);
 
635
            }
 
636
        }
 
637
 
 
638
        @Override
 
639
        protected Object getObjectImpl(int parameterIndex) throws SQLException{
 
640
            return getPara(parameterIndex).get_Value();
 
641
        }
 
642
        
 
643
    }
 
644
 
 
645
 
 
646
    /**
 
647
     * {@inheritDoc}
 
648
     */
 
649
        public <T> T getObject(int parameterIndex, Class<T> type)
 
650
                        throws SQLException {
 
651
                throw new SQLFeatureNotSupportedException();
 
652
        }
 
653
 
 
654
 
 
655
    /**
 
656
     * {@inheritDoc}
 
657
     */
 
658
        public <T> T getObject(String parameterName, Class<T> type)
 
659
                        throws SQLException {
 
660
                throw new SQLFeatureNotSupportedException();
 
661
        }
 
662
}