001    package railo.runtime.db.driver;
002    
003    import java.io.InputStream;
004    import java.io.Reader;
005    import java.lang.reflect.InvocationTargetException;
006    import java.math.BigDecimal;
007    import java.net.URL;
008    import java.sql.Array;
009    import java.sql.Blob;
010    import java.sql.CallableStatement;
011    import java.sql.Clob;
012    import java.sql.Date;
013    import java.sql.NClob;
014    import java.sql.Ref;
015    import java.sql.RowId;
016    import java.sql.SQLException;
017    import java.sql.SQLXML;
018    import java.sql.Time;
019    import java.sql.Timestamp;
020    import java.util.Calendar;
021    import java.util.Map;
022    
023    import railo.runtime.exp.PageRuntimeException;
024    import railo.runtime.op.Caster;
025    
026    public class CallableStatementProxy extends PreparedStatementProxy implements CallableStatement {
027    
028            protected CallableStatement stat;
029    
030            public CallableStatementProxy(ConnectionProxy conn, CallableStatement prepareCall, String sql) {
031                    super(conn,prepareCall,sql);
032                    this.stat=prepareCall; 
033            }
034    
035            @Override
036            public Array getArray(int parameterIndex) throws SQLException {
037                    return stat.getArray(parameterIndex);
038            }
039    
040            @Override
041            public Array getArray(String parameterName) throws SQLException {
042                    return stat.getArray(parameterName);
043            }
044    
045            @Override
046            public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
047                    return stat.getBigDecimal(parameterIndex);
048            }
049    
050            @Override
051            public BigDecimal getBigDecimal(String parameterName) throws SQLException {
052                    return stat.getBigDecimal(parameterName);
053            }
054    
055            @Override
056            public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException {
057                    return stat.getBigDecimal(parameterIndex, scale);
058            }
059    
060            @Override
061            public Blob getBlob(int parameterIndex) throws SQLException {
062                    return stat.getBlob(parameterIndex);
063            }
064    
065            @Override
066            public Blob getBlob(String parameterName) throws SQLException {
067                    return stat.getBlob(parameterName);
068            }
069    
070            @Override
071            public boolean getBoolean(int parameterIndex) throws SQLException {
072                    return stat.getBoolean(parameterIndex);
073            }
074    
075            @Override
076            public boolean getBoolean(String parameterName) throws SQLException {
077                    return stat.getBoolean(parameterName);
078            }
079    
080            @Override
081            public byte getByte(int parameterIndex) throws SQLException {
082                    return stat.getByte(parameterIndex);
083            }
084    
085            @Override
086            public byte getByte(String parameterName) throws SQLException {
087                    return stat.getByte(parameterName);
088            }
089    
090            @Override
091            public byte[] getBytes(int parameterIndex) throws SQLException {
092                    return stat.getBytes(parameterIndex);
093            }
094    
095            @Override
096            public byte[] getBytes(String parameterName) throws SQLException {
097                    return stat.getBytes(parameterName);
098            }
099    
100            @Override
101            public Reader getCharacterStream(int parameterIndex) throws SQLException {
102                    return stat.getCharacterStream(parameterIndex);
103            }
104    
105            @Override
106            public Reader getCharacterStream(String parameterName) throws SQLException {
107                    return stat.getCharacterStream(parameterName);
108            }
109    
110            @Override
111            public Clob getClob(int parameterIndex) throws SQLException {
112                    return stat.getClob(parameterIndex);
113            }
114    
115            @Override
116            public Clob getClob(String parameterName) throws SQLException {
117                    return stat.getClob(parameterName);
118            }
119    
120            @Override
121            public Date getDate(int parameterIndex) throws SQLException {
122                    return stat.getDate(parameterIndex);
123            }
124    
125            @Override
126            public Date getDate(String parameterName) throws SQLException {
127                    return stat.getDate(parameterName);
128            }
129    
130            @Override
131            public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
132                    return stat.getDate(parameterIndex, cal);
133            }
134    
135            @Override
136            public Date getDate(String parameterName, Calendar cal) throws SQLException {
137                    return stat.getDate(parameterName, cal);
138            }
139    
140            @Override
141            public double getDouble(int parameterIndex) throws SQLException {
142                    return stat.getDouble(parameterIndex);
143            }
144    
145            @Override
146            public double getDouble(String parameterName) throws SQLException {
147                    return stat.getDouble(parameterName);
148            }
149    
150            @Override
151            public float getFloat(int parameterIndex) throws SQLException {
152                    return stat.getFloat(parameterIndex);
153            }
154    
155            @Override
156            public float getFloat(String parameterName) throws SQLException {
157                    return stat.getFloat(parameterName);
158            }
159    
160            @Override
161            public int getInt(int parameterIndex) throws SQLException {
162                    return stat.getInt(parameterIndex);
163            }
164    
165            @Override
166            public int getInt(String parameterName) throws SQLException {
167                    return stat.getInt(parameterName);
168            }
169    
170            @Override
171            public long getLong(int parameterIndex) throws SQLException {
172                    return stat.getLong(parameterIndex);
173            }
174    
175            @Override
176            public long getLong(String parameterName) throws SQLException {
177                    return stat.getLong(parameterName);
178            }
179    
180            @Override
181            public Reader getNCharacterStream(int parameterIndex) throws SQLException {
182                    return stat.getNCharacterStream(parameterIndex);
183            }
184    
185            @Override
186            public Reader getNCharacterStream(String parameterName) throws SQLException {
187                    return stat.getNCharacterStream(parameterName);
188            }
189    
190            @Override
191            public NClob getNClob(int parameterIndex) throws SQLException {
192                    return stat.getNClob(parameterIndex);
193            }
194    
195            @Override
196            public NClob getNClob(String parameterName) throws SQLException {
197                    return stat.getNClob(parameterName);
198            }
199    
200            @Override
201            public String getNString(int parameterIndex) throws SQLException {
202                    return stat.getNString(parameterIndex);
203            }
204    
205            @Override
206            public String getNString(String parameterName) throws SQLException {
207                    return stat.getNString(parameterName);
208            }
209    
210            @Override
211            public Object getObject(int parameterIndex) throws SQLException {
212                    return stat.getObject(parameterIndex);
213            }
214    
215            @Override
216            public Object getObject(String parameterName) throws SQLException {
217                    return stat.getObject(parameterName);
218            }
219    
220            @Override
221            public Object getObject(int parameterIndex, Map<String, Class<?>> map) throws SQLException {
222                    return stat.getObject(parameterIndex, map);
223            }
224    
225            @Override
226            public Object getObject(String parameterName, Map<String, Class<?>> map) throws SQLException {
227                    return stat.getObject(parameterName, map);
228            }
229    
230            @Override
231            public Ref getRef(int parameterIndex) throws SQLException {
232                    return stat.getRef(parameterIndex);
233            }
234    
235            @Override
236            public Ref getRef(String parameterName) throws SQLException {
237                    return stat.getRef(parameterName);
238            }
239    
240            @Override
241            public RowId getRowId(int parameterIndex) throws SQLException {
242                    return stat.getRowId(parameterIndex);
243            }
244    
245            @Override
246            public RowId getRowId(String parameterName) throws SQLException {
247                    return stat.getRowId(parameterName);
248            }
249    
250            @Override
251            public SQLXML getSQLXML(int parameterIndex) throws SQLException {
252                    return stat.getSQLXML(parameterIndex);
253            }
254    
255            @Override
256            public SQLXML getSQLXML(String parameterName) throws SQLException {
257                    return stat.getSQLXML(parameterName);
258            }
259    
260            @Override
261            public short getShort(int parameterIndex) throws SQLException {
262                    return stat.getShort(parameterIndex);
263            }
264    
265            @Override
266            public short getShort(String parameterName) throws SQLException {
267                    return stat.getShort(parameterName);
268            }
269    
270            @Override
271            public String getString(int parameterIndex) throws SQLException {
272                    return stat.getString(parameterIndex);
273            }
274    
275            @Override
276            public String getString(String parameterName) throws SQLException {
277                    return stat.getString(parameterName);
278            }
279    
280            @Override
281            public Time getTime(int parameterIndex) throws SQLException {
282                    return stat.getTime(parameterIndex);
283            }
284    
285            @Override
286            public Time getTime(String parameterName) throws SQLException {
287                    return stat.getTime(parameterName);
288            }
289    
290            @Override
291            public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
292                    return stat.getTime(parameterIndex, cal);
293            }
294    
295            @Override
296            public Time getTime(String parameterName, Calendar cal) throws SQLException {
297                    return stat.getTime(parameterName, cal);
298            }
299    
300            @Override
301            public Timestamp getTimestamp(int parameterIndex) throws SQLException {
302                    return stat.getTimestamp(parameterIndex);
303            }
304    
305            @Override
306            public Timestamp getTimestamp(String parameterName) throws SQLException {
307                    return stat.getTimestamp(parameterName);
308            }
309    
310            @Override
311            public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException {
312                    return stat.getTimestamp(parameterIndex, cal);
313            }
314    
315            @Override
316            public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException {
317                    return stat.getTimestamp(parameterName, cal);
318            }
319    
320            @Override
321            public URL getURL(int parameterIndex) throws SQLException {
322                    return stat.getURL(parameterIndex);
323            }
324    
325            @Override
326            public URL getURL(String parameterName) throws SQLException {
327                    return stat.getURL(parameterName);
328            }
329    
330            @Override
331            public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException {
332                    stat.registerOutParameter(parameterIndex, sqlType);
333            }
334    
335            @Override
336            public void registerOutParameter(String parameterName, int sqlType) throws SQLException {
337                    stat.registerOutParameter(parameterName, sqlType);
338            }
339    
340            @Override
341            public void registerOutParameter(int parameterIndex, int sqlType, int typeName) throws SQLException {
342                    stat.registerOutParameter(parameterIndex, sqlType, typeName);
343            }
344    
345            @Override
346            public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException {
347                    stat.registerOutParameter(parameterIndex, sqlType, typeName);
348            }
349    
350            @Override
351            public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException {
352                    stat.registerOutParameter(parameterName, sqlType, scale);
353            }
354    
355            @Override
356            public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException {
357                    stat.registerOutParameter(parameterName, sqlType, typeName);
358            }
359    
360            @Override
361            public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
362                    stat.setAsciiStream(parameterName, x);
363            }
364    
365            @Override
366            public void setAsciiStream(String parameterName, InputStream x, int length)throws SQLException {
367                    stat.setAsciiStream(parameterName, x, length);
368            }
369    
370            @Override
371            public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
372                    stat.setAsciiStream(parameterName, x, length);
373            }
374    
375            @Override
376            public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
377                    stat.setBigDecimal(parameterName, x);
378            }
379    
380            @Override
381            public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
382                    stat.setBinaryStream(parameterName, x);
383            }
384    
385            @Override
386            public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
387                    stat.setBinaryStream(parameterName, x, length);
388            }
389    
390            @Override
391            public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
392                    stat.setBinaryStream(parameterName, x, length);
393            }
394    
395            @Override
396            public void setBlob(String parameterName, Blob x) throws SQLException {
397                    stat.setBlob(parameterName, x);
398            }
399    
400            @Override
401            public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
402                    stat.setBlob(parameterName, inputStream);
403            }
404    
405            @Override
406            public void setBlob(String parameterName, InputStream is, long length) throws SQLException {
407                    stat.setBlob(parameterName, is, length);
408            }
409    
410            @Override
411            public void setBoolean(String parameterName, boolean x) throws SQLException {
412                    stat.setBoolean(parameterName, x);
413            }
414    
415            @Override
416            public void setByte(String parameterName, byte x) throws SQLException {
417                    stat.setByte(parameterName, x);
418            }
419    
420            @Override
421            public void setBytes(String parameterName, byte[] x) throws SQLException {
422                    stat.setBytes(parameterName, x);
423            }
424    
425            @Override
426            public void setCharacterStream(String parameterName, Reader reader)
427                            throws SQLException {
428                    stat.setCharacterStream(parameterName, reader);
429            }
430    
431            @Override
432            public void setCharacterStream(String parameterName, Reader reader, int length)
433                            throws SQLException {
434                    stat.setCharacterStream(parameterName, reader, length);
435            }
436    
437            @Override
438            public void setCharacterStream(String parameterName, Reader reader, long length)
439                            throws SQLException {
440                    stat.setCharacterStream(parameterName, reader, length);
441            }
442    
443            @Override
444            public void setClob(String parameterName, Clob x) throws SQLException {
445                    stat.setClob(parameterName, x);
446            }
447    
448            @Override
449            public void setClob(String parameterName, Reader reader) throws SQLException {
450                    stat.setClob(parameterName, reader);
451            }
452    
453            @Override
454            public void setClob(String parameterName, Reader reader, long length)
455                            throws SQLException {
456                    stat.setClob(parameterName, reader, length);
457            }
458    
459            @Override
460            public void setDate(String parameterName, Date x) throws SQLException {
461                    stat.setDate(parameterName, x);
462            }
463    
464            @Override
465            public void setDate(String parameterName, Date x, Calendar cal)
466                            throws SQLException {
467                    stat.setDate(parameterName, x, cal);
468            }
469    
470            @Override
471            public void setDouble(String parameterName, double x) throws SQLException {
472                    stat.setDouble(parameterName, x);
473            }
474    
475            @Override
476            public void setFloat(String parameterName, float x) throws SQLException {
477                    stat.setFloat(parameterName, x);
478            }
479    
480            @Override
481            public void setInt(String parameterName, int x) throws SQLException {
482                    stat.setInt(parameterName, x);
483            }
484    
485            @Override
486            public void setLong(String parameterName, long x) throws SQLException {
487                    stat.setLong(parameterName, x);
488            }
489    
490            @Override
491            public void setNCharacterStream(String parameterName, Reader value)
492                            throws SQLException {
493                    stat.setNCharacterStream(parameterName, value);
494            }
495    
496            @Override
497            public void setNCharacterStream(String parameterName, Reader value, long length)
498                            throws SQLException {
499                    stat.setNCharacterStream(parameterName, value, length);
500            }
501    
502            @Override
503            public void setNClob(String parameterName, NClob value) throws SQLException {
504                    stat.setNClob(parameterName, value);
505            }
506    
507            @Override
508            public void setNClob(String parameterName, Reader reader) throws SQLException {
509                    stat.setNClob(parameterName, reader);
510            }
511    
512            @Override
513            public void setNClob(String parameterName, Reader reader, long length)
514                            throws SQLException {
515                    stat.setNClob(parameterName, reader, length);
516            }
517    
518            @Override
519            public void setNString(String parameterName, String value) throws SQLException {
520                    stat.setNString(parameterName, value);
521            }
522    
523            @Override
524            public void setNull(String parameterName, int sqlType) throws SQLException {
525                    stat.setNull(parameterName, sqlType);
526            }
527    
528            @Override
529            public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
530                    stat.setNull(parameterName, sqlType, typeName);
531            }
532    
533            @Override
534            public void setObject(String parameterName, Object x) throws SQLException {
535                    stat.setObject(parameterName, x);
536            }
537    
538            @Override
539            public void setObject(String parameterName, Object x, int targetSqlType)
540                            throws SQLException {
541                    stat.setObject(parameterName, x, targetSqlType);
542            }
543    
544            @Override
545            public void setObject(String parameterName, Object x, int targetSqlType, int scale)
546                            throws SQLException {
547                    stat.setObject(parameterName, x, targetSqlType, scale);
548            }
549    
550            @Override
551            public void setRowId(String parameterName, RowId x) throws SQLException {
552                    stat.setRowId(parameterName, x);
553            }
554    
555            @Override
556            public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
557                    stat.setSQLXML(parameterName, xmlObject);
558            }
559    
560            @Override
561            public void setShort(String parameterName, short x) throws SQLException {
562                    stat.setShort(parameterName, x);
563            }
564    
565            @Override
566            public void setString(String parameterName, String x) throws SQLException {
567                    stat.setString(parameterName, x);
568            }
569    
570            @Override
571            public void setTime(String parameterName, Time x) throws SQLException {
572                    stat.setTime(parameterName, x);
573            }
574    
575            @Override
576            public void setTime(String parameterName, Time x, Calendar cal)
577                            throws SQLException {
578                    stat.setTime(parameterName, x, cal);
579            }
580    
581            @Override
582            public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
583                    stat.setTimestamp(parameterName, x);
584            }
585    
586            @Override
587            public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
588                            throws SQLException {
589                    stat.setTimestamp(parameterName, x, cal);
590            }
591    
592            @Override
593            public void setURL(String parameterName, URL val) throws SQLException {
594                    stat.setURL(parameterName, val);
595            }
596    
597            @Override
598            public boolean wasNull() throws SQLException {
599                    return stat.wasNull();
600            }
601    
602            public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
603                    // used reflection to make sure this work with Java 5 and 6
604                    try {
605                            return (T) stat.getClass().getMethod("getObject", new Class[]{int.class,Class.class}).invoke(stat, new Object[]{parameterIndex,type});
606                    }
607                    catch (Throwable t) {
608                            if(t instanceof InvocationTargetException && ((InvocationTargetException)t).getTargetException() instanceof SQLException)
609                                    throw (SQLException)((InvocationTargetException)t).getTargetException();
610                            throw new PageRuntimeException(Caster.toPageException(t));
611                    }
612            }
613    
614            public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
615                    // used reflection to make sure this work with Java 5 and 6
616                    try {
617                            return (T) stat.getClass().getMethod("getObject", new Class[]{String.class,Class.class}).invoke(stat, new Object[]{parameterName,type});
618                    }
619                    catch (Throwable t) {
620                            if(t instanceof InvocationTargetException && ((InvocationTargetException)t).getTargetException() instanceof SQLException)
621                                    throw (SQLException)((InvocationTargetException)t).getTargetException();
622                            throw new PageRuntimeException(Caster.toPageException(t));
623                    }
624            }
625    }