KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > rmijdbc > RJPreparedStatementServer


1  
2 /**
3  * RmiJdbc client/server JDBC Driver
4  * (C) GIE Dyade (Groupe BULL / INRIA Research Center) 1997
5  *
6  * @version 1.0
7  * @author Pierre-Yves Gibello (pierreyves.gibello@experlog.com)
8  */
9
10 package org.objectweb.rmijdbc;
11
12 import java.sql.*;
13
14 import java.rmi.*;
15 import java.rmi.server.Unreferenced JavaDoc;
16
17 import java.util.Calendar JavaDoc;
18
19 // TBD: WARNING This file contains a hack for InputStream class...
20 // InputStream is not serializable, of course !
21 // The right way would be to encapsulate InputStream in a RMI remote object
22 // (hope I'll find time to do that)
23
24 /**
25  * <P>A SQL statement is pre-compiled and stored in a
26  * PreparedStatement object. This object can then be used to
27  * efficiently execute this statement multiple times.
28  *
29  * <P><B>Note:</B> The setXXX methods for setting IN parameter values
30  * must specify types that are compatible with the defined SQL type of
31  * the input parameter. For instance, if the IN parameter has SQL type
32  * Integer then setInt should be used.
33  *
34  * <p>If arbitrary parameter type conversions are required then the
35  * setObject method should be used with a target SQL type.
36  *
37  * @see Connection#prepareStatement
38  * @see ResultSet
39  */
40
41 public class RJPreparedStatementServer
42 extends RJStatementServer
43 implements RJPreparedStatementInterface, Unreferenced JavaDoc {
44
45   java.sql.PreparedStatement JavaDoc jdbcPrepStmt_;
46
47   public RJPreparedStatementServer(java.sql.PreparedStatement JavaDoc p)
48   throws RemoteException {
49     super(p);
50     jdbcPrepStmt_ = p;
51   }
52
53   public void unreferenced() { Runtime.getRuntime().gc(); }
54
55   /**
56    * A prepared SQL query is executed and its ResultSet is returned.
57    *
58    * @return a ResultSet that contains the data produced by the
59    * query; never null
60    */
61   public RJResultSetInterface executeQuery()
62   throws RemoteException, SQLException {
63     return new RJResultSetServer(jdbcPrepStmt_.executeQuery());
64   }
65
66     /**
67      * Execute a SQL INSERT, UPDATE or DELETE statement. In addition,
68      * SQL statements that return nothing such as SQL DDL statements
69      * can be executed.
70      *
71      * @return either the row count for INSERT, UPDATE or DELETE; or 0
72      * for SQL statements that return nothing
73      */
74   public int executeUpdate() throws RemoteException, SQLException {
75     return jdbcPrepStmt_.executeUpdate();
76   }
77
78     /**
79      * Set a parameter to SQL NULL.
80      *
81      * <P><B>Note:</B> You must specify the parameter's SQL type.
82      *
83      * @param parameterIndex the first parameter is 1, the second is 2, ...
84      * @param sqlType SQL type code defined by java.sql.Types
85      */
86   public void setNull(int parameterIndex, int sqlType)
87   throws RemoteException, SQLException {
88       jdbcPrepStmt_.setNull(parameterIndex, sqlType);
89   }
90
91     /**
92      * Set a parameter to a Java boolean value. The driver converts this
93      * to a SQL BIT value when it sends it to the database.
94      *
95      * @param parameterIndex the first parameter is 1, the second is 2, ...
96      * @param x the parameter value
97      */
98   public void setBoolean(int parameterIndex, boolean x)
99   throws RemoteException, SQLException {
100     jdbcPrepStmt_.setBoolean(parameterIndex, x);
101   }
102
103     /**
104      * Set a parameter to a Java byte value. The driver converts this
105      * to a SQL TINYINT value when it sends it to the database.
106      *
107      * @param parameterIndex the first parameter is 1, the second is 2, ...
108      * @param x the parameter value
109      */
110   public void setByte(int parameterIndex, byte x)
111   throws RemoteException, SQLException {
112     jdbcPrepStmt_.setByte(parameterIndex, x);
113   }
114
115     /**
116      * Set a parameter to a Java short value. The driver converts this
117      * to a SQL SMALLINT value when it sends it to the database.
118      *
119      * @param parameterIndex the first parameter is 1, the second is 2, ...
120      * @param x the parameter value
121      */
122   public void setShort(int parameterIndex, short x)
123   throws RemoteException, SQLException {
124     jdbcPrepStmt_.setShort(parameterIndex, x);
125   }
126
127     /**
128      * Set a parameter to a Java int value. The driver converts this
129      * to a SQL INTEGER value when it sends it to the database.
130      *
131      * @param parameterIndex the first parameter is 1, the second is 2, ...
132      * @param x the parameter value
133      */
134   public void setInt(int parameterIndex, int x)
135   throws RemoteException, SQLException {
136     jdbcPrepStmt_.setInt(parameterIndex, x);
137   }
138
139     /**
140      * Set a parameter to a Java long value. The driver converts this
141      * to a SQL BIGINT value when it sends it to the database.
142      *
143      * @param parameterIndex the first parameter is 1, the second is 2, ...
144      * @param x the parameter value
145      */
146   public void setLong(int parameterIndex, long x)
147   throws RemoteException, SQLException {
148     jdbcPrepStmt_.setLong(parameterIndex, x);
149   }
150
151     /**
152      * Set a parameter to a Java float value. The driver converts this
153      * to a SQL FLOAT value when it sends it to the database.
154      *
155      * @param parameterIndex the first parameter is 1, the second is 2, ...
156      * @param x the parameter value
157      */
158   public void setFloat(int parameterIndex, float x)
159   throws RemoteException, SQLException {
160     jdbcPrepStmt_.setFloat(parameterIndex, x);
161   }
162
163     /**
164      * Set a parameter to a Java double value. The driver converts this
165      * to a SQL DOUBLE value when it sends it to the database.
166      *
167      * @param parameterIndex the first parameter is 1, the second is 2, ...
168      * @param x the parameter value
169      */
170   public void setDouble(int parameterIndex, double x)
171   throws RemoteException, SQLException {
172     jdbcPrepStmt_.setDouble(parameterIndex, x);
173   }
174
175     /**
176      * Set a parameter to a java.lang.BigDecimal value. The driver converts
177      * this to a SQL NUMERIC value when it sends it to the database.
178      *
179      * @param parameterIndex the first parameter is 1, the second is 2, ...
180      * @param x the parameter value
181      */
182   public void setBigDecimal(int parameterIndex, java.math.BigDecimal JavaDoc x)
183   throws RemoteException, SQLException {
184     jdbcPrepStmt_.setBigDecimal(parameterIndex, x);
185   }
186
187     /**
188      * Set a parameter to a Java String value. The driver converts this
189      * to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments
190      * size relative to the driver's limits on VARCHARs) when it sends
191      * it to the database.
192      *
193      * @param parameterIndex the first parameter is 1, the second is 2, ...
194      * @param x the parameter value
195      */
196   public void setString(int parameterIndex, String JavaDoc x)
197   throws RemoteException, SQLException {
198     jdbcPrepStmt_.setString(parameterIndex, x);
199   }
200
201     /**
202      * Set a parameter to a Java array of bytes. The driver converts
203      * this to a SQL VARBINARY or LONGVARBINARY (depending on the
204      * argument's size relative to the driver's limits on VARBINARYs)
205      * when it sends it to the database.
206      *
207      * @param parameterIndex the first parameter is 1, the second is 2, ...
208      * @param x the parameter value
209      */
210   public void setBytes(int parameterIndex, byte x[])
211   throws RemoteException, SQLException {
212     jdbcPrepStmt_.setBytes(parameterIndex, x);
213   }
214
215     /**
216      * Set a parameter to a java.sql.Date value. The driver converts this
217      * to a SQL DATE value when it sends it to the database.
218      *
219      * @param parameterIndex the first parameter is 1, the second is 2, ...
220      * @param x the parameter value
221      */
222   public void setDate(int parameterIndex, java.sql.Date JavaDoc x)
223   throws RemoteException, SQLException {
224     jdbcPrepStmt_.setDate(parameterIndex, x);
225   }
226
227     /**
228      * Set a parameter to a java.sql.Time value. The driver converts this
229      * to a SQL TIME value when it sends it to the database.
230      *
231      * @param parameterIndex the first parameter is 1, the second is 2, ...
232      * @param x the parameter value
233      */
234   public void setTime(int parameterIndex, java.sql.Time JavaDoc x)
235   throws RemoteException, SQLException {
236     jdbcPrepStmt_.setTime(parameterIndex, x);
237   }
238
239     /**
240      * Set a parameter to a java.sql.Timestamp value. The driver
241      * converts this to a SQL TIMESTAMP value when it sends it to the
242      * database.
243      *
244      * @param parameterIndex the first parameter is 1, the second is 2, ...
245      * @param x the parameter value
246      */
247   public void setTimestamp(int parameterIndex, java.sql.Timestamp JavaDoc x)
248   throws RemoteException, SQLException {
249     jdbcPrepStmt_.setTimestamp(parameterIndex, x);
250   }
251
252     /**
253      * When a very large ASCII value is input to a LONGVARCHAR
254      * parameter, it may be more practical to send it via a
255      * java.io.InputStream. JDBC will read the data from the stream
256      * as needed, until it reaches end-of-file. The JDBC driver will
257      * do any necessary conversion from ASCII to the database char format.
258      *
259      * <P><B>Note:</B> This stream object can either be a standard
260      * Java stream object or your own subclass that implements the
261      * standard interface.
262      *
263      * @param parameterIndex the first parameter is 1, the second is 2, ...
264      * @param x the java input stream which contains the ASCII parameter value
265      * @param length the number of bytes in the stream
266      */
267 //TBD This is a hack (InputStream not serializable)
268 // public void setAsciiStream(int parameterIndex, java.io.InputStream x,
269 public void setAsciiStream(int parameterIndex, byte[] x,
270   int length) throws RemoteException, SQLException {
271 // jdbcPrepStmt_.setAsciiStream(parameterIndex, x, length);
272 jdbcPrepStmt_.setAsciiStream(parameterIndex,
273       new java.io.ByteArrayInputStream JavaDoc(x), length);
274   }
275
276     /**
277      * When a very large UNICODE value is input to a LONGVARCHAR
278      * parameter, it may be more practical to send it via a
279      * java.io.InputStream. JDBC will read the data from the stream
280      * as needed, until it reaches end-of-file. The JDBC driver will
281      * do any necessary conversion from UNICODE to the database char format.
282      *
283      * <P><B>Note:</B> This stream object can either be a standard
284      * Java stream object or your own subclass that implements the
285      * standard interface.
286      *
287      * @param parameterIndex the first parameter is 1, the second is 2, ...
288      * @param x the java input stream which contains the
289      * UNICODE parameter value
290      * @param length the number of bytes in the stream
291      */
292 //TBD This is a hack (InputStream not serializable)
293 // public void setUnicodeStream(int parameterIndex, java.io.InputStream x,
294 public void setUnicodeStream(int parameterIndex, byte[] x,
295   int length) throws RemoteException, SQLException {
296 // jdbcPrepStmt_.setUnicodeStream(parameterIndex, x, length);
297 jdbcPrepStmt_.setUnicodeStream(parameterIndex,
298       new java.io.ByteArrayInputStream JavaDoc(x), length);
299   }
300
301     /**
302      * When a very large binary value is input to a LONGVARBINARY
303      * parameter, it may be more practical to send it via a
304      * java.io.InputStream. JDBC will read the data from the stream
305      * as needed, until it reaches end-of-file.
306      *
307      * <P><B>Note:</B> This stream object can either be a standard
308      * Java stream object or your own subclass that implements the
309      * standard interface.
310      *
311      * @param parameterIndex the first parameter is 1, the second is 2, ...
312      * @param x the java input stream which contains the binary parameter value
313      * @param length the number of bytes in the stream
314      */
315 //TBD This is a hack (InputStream not serializable)
316 // public void setBinaryStream(int parameterIndex, java.io.InputStream x,
317 public void setBinaryStream(int parameterIndex, byte[] x,
318   int length) throws RemoteException, SQLException {
319 // jdbcPrepStmt_.setBinaryStream(parameterIndex, x, length);
320 jdbcPrepStmt_.setBinaryStream(parameterIndex,
321       new java.io.ByteArrayInputStream JavaDoc(x), length);
322   }
323
324     /**
325      * <P>In general, parameter values remain in force for repeated use of a
326      * Statement. Setting a parameter value automatically clears its
327      * previous value. However, in some cases it is useful to immediately
328      * release the resources used by the current parameter values; this can
329      * be done by calling clearParameters.
330      */
331   public void clearParameters() throws RemoteException, SQLException {
332     jdbcPrepStmt_.clearParameters();
333   }
334
335     //----------------------------------------------------------------------
336 // Advanced features:
337
338     /**
339      * <p>Set the value of a parameter using an object; use the
340      * java.lang equivalent objects for integral values.
341      *
342      * <p>The given Java object will be converted to the targetSqlType
343      * before being sent to the database.
344      *
345      * <p>Note that this method may be used to pass datatabase-
346      * specific abstract data types. This is done by using a Driver-
347      * specific Java type and using a targetSqlType of
348      * java.sql.types.OTHER.
349      *
350      * @param parameterIndex The first parameter is 1, the second is 2, ...
351      * @param x The object containing the input parameter value
352      * @param targetSqlType The SQL type (as defined in java.sql.Types) to be
353      * sent to the database. The scale argument may further qualify this type.
354      * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
355      * this is the number of digits after the decimal. For all other
356      * types this value will be ignored,
357      * @see Types
358      */
359   public void setObject(int parameterIndex, Object JavaDoc x, int targetSqlType,
360   int scale) throws RemoteException, SQLException {
361     jdbcPrepStmt_.setObject(parameterIndex, x, targetSqlType, scale);
362   }
363
364     /**
365       * This method is like setObject above, but assumes a scale of zero.
366       */
367   public void setObject(int parameterIndex, Object JavaDoc x, int targetSqlType)
368   throws RemoteException, SQLException {
369     jdbcPrepStmt_.setObject(parameterIndex, x, targetSqlType);
370   }
371
372     /**
373      * <p>Set the value of a parameter using an object; use the
374      * java.lang equivalent objects for integral values.
375      *
376      * <p>The JDBC specification specifies a standard mapping from
377      * Java Object types to SQL types. The given argument java object
378      * will be converted to the corresponding SQL type before being
379      * sent to the database.
380      *
381      * <p>Note that this method may be used to pass datatabase
382      * specific abstract data types, by using a Driver specific Java
383      * type.
384      *
385      * @param parameterIndex The first parameter is 1, the second is 2, ...
386      * @param x The object containing the input parameter value
387      */
388   public void setObject(int parameterIndex, Object JavaDoc x)
389   throws RemoteException, SQLException {
390     jdbcPrepStmt_.setObject(parameterIndex, x);
391   }
392
393     /**
394      * Some prepared statements return multiple results; the execute
395      * method handles these complex statements as well as the simpler
396      * form of statements handled by executeQuery and executeUpdate.
397      *
398      * @see Statement#execute
399      */
400   public boolean execute() throws RemoteException, SQLException {
401     return jdbcPrepStmt_.execute();
402   }
403
404     //--------------------------JDBC 2.0-----------------------------
405 // Added Aug 2000, Peter Hearty, peter.hearty@lutris.com.
406
407     /**
408      * JDBC 2.0
409      *
410      * Adds a set of parameters to the batch.
411      *
412      * @exception SQLException if a database access error occurs
413      * @see Statement#addBatch
414      */
415     public void addBatch() throws RemoteException, SQLException {
416       jdbcPrepStmt_.addBatch();
417     }
418
419     /**
420      * JDBC 2.0
421      *
422      * Sets the designated parameter to the given <code>Reader</code>
423      * object, which is the given number of characters long.
424      * When a very large UNICODE value is input to a LONGVARCHAR
425      * parameter, it may be more practical to send it via a
426      * java.io.Reader. JDBC will read the data from the stream
427      * as needed, until it reaches end-of-file. The JDBC driver will
428      * do any necessary conversion from UNICODE to the database char format.
429      *
430      * <P><B>Note:</B> This stream object can either be a standard
431      * Java stream object or your own subclass that implements the
432      * standard interface.
433      *
434      * @param parameterIndex the first parameter is 1, the second is 2, ...
435      * @param x the java reader which contains the UNICODE data
436      * @param length the number of characters in the stream
437      * @exception SQLException if a database access error occurs
438      */
439     // TBD This method is called by the one below...
440 public void setCharacterStream(int parameterIndex,
441                   java.io.Reader JavaDoc reader,
442                   int length) throws RemoteException, SQLException {
443       jdbcPrepStmt_.setCharacterStream(parameterIndex,reader,length);
444     }
445     public void setCharacterStream(int parameterIndex,
446                   char buf[], int length) throws RemoteException, SQLException {
447       try {
448         setCharacterStream(parameterIndex,
449          RJSerializer.toReader(buf),length);
450       } catch(Exception JavaDoc e) {
451         throw new SQLException(e.getMessage());
452       }
453     }
454
455     /**
456      * JDBC 2.0
457      *
458      * Sets a REF(&lt;structured-type&gt;) parameter.
459      *
460      * @param i the first parameter is 1, the second is 2, ...
461      * @param x an object representing data of an SQL REF Type
462      * @exception SQLException if a database access error occurs
463      */
464     public void setRef (int i, Ref x) throws RemoteException, SQLException {
465       jdbcPrepStmt_.setRef (i, x);
466     }
467
468     /**
469      * JDBC 2.0
470      *
471      * Sets a BLOB parameter.
472      *
473      * @param i the first parameter is 1, the second is 2, ...
474      * @param x an object representing a BLOB
475      * @exception SQLException if a database access error occurs
476      */
477     public void setBlob (int i, Blob x) throws RemoteException, SQLException {
478       jdbcPrepStmt_.setBlob (i, x);
479     }
480
481     /**
482      * JDBC 2.0
483      *
484      * Sets a CLOB parameter.
485      *
486      * @param i the first parameter is 1, the second is 2, ...
487      * @param x an object representing a CLOB
488      * @exception SQLException if a database access error occurs
489      */
490     public void setClob (int i, Clob x) throws RemoteException, SQLException {
491       jdbcPrepStmt_.setClob (i, x);
492     }
493
494     /**
495      * JDBC 2.0
496      *
497      * Sets an Array parameter.
498      *
499      * @param i the first parameter is 1, the second is 2, ...
500      * @param x an object representing an SQL array
501      * @exception SQLException if a database access error occurs
502      */
503     public void setArray (int i, Array x) throws RemoteException, SQLException {
504       jdbcPrepStmt_.setArray (i, x);
505     }
506
507     /**
508      * JDBC 2.0
509      *
510      * Gets the number, types and properties of a ResultSet's columns.
511      *
512      * @return the description of a ResultSet's columns
513      * @exception SQLException if a database access error occurs
514      */
515     public RJResultSetMetaDataInterface getMetaData()
516     throws RemoteException, SQLException {
517       return new RJResultSetMetaDataServer(jdbcPrepStmt_.getMetaData());
518     }
519
520     /**
521      * JDBC 2.0
522      *
523      * Sets the designated parameter to a java.sql.Date value,
524      * using the given <code>Calendar</code> object. The driver uses
525      * the <code>Calendar</code> object to construct an SQL DATE,
526      * which the driver then sends to the database. With a
527      * a <code>Calendar</code> object, the driver can calculate the date
528      * taking into account a custom timezone and locale. If no
529      * <code>Calendar</code> object is specified, the driver uses the default
530      * timezone and locale.
531      *
532      * @param parameterIndex the first parameter is 1, the second is 2, ...
533      * @param x the parameter value
534      * @param cal the <code>Calendar</code> object the driver will use
535      * to construct the date
536      * @exception SQLException if a database access error occurs
537      */
538     public void setDate(int parameterIndex, java.sql.Date JavaDoc x, Calendar JavaDoc cal)
539         throws RemoteException, SQLException {
540       jdbcPrepStmt_.setDate(parameterIndex, x, cal);
541     }
542
543     /**
544      * JDBC 2.0
545      *
546      * Sets the designated parameter to a java.sql.Time value,
547      * using the given <code>Calendar</code> object. The driver uses
548      * the <code>Calendar</code> object to construct an SQL TIME,
549      * which the driver then sends to the database. With a
550      * a <code>Calendar</code> object, the driver can calculate the time
551      * taking into account a custom timezone and locale. If no
552      * <code>Calendar</code> object is specified, the driver uses the default
553      * timezone and locale.
554      *
555      * @param parameterIndex the first parameter is 1, the second is 2, ...
556      * @param x the parameter value
557      * @param cal the <code>Calendar</code> object the driver will use
558      * to construct the time
559      * @exception SQLException if a database access error occurs
560      */
561     public void setTime(int parameterIndex, java.sql.Time JavaDoc x, Calendar JavaDoc cal)
562         throws RemoteException, SQLException {
563       jdbcPrepStmt_.setTime(parameterIndex, x, cal) ;
564     }
565
566     /**
567      * JDBC 2.0
568      *
569      * Sets the designated parameter to a java.sql.Timestamp value,
570      * using the given <code>Calendar</code> object. The driver uses
571      * the <code>Calendar</code> object to construct an SQL TIMESTAMP,
572      * which the driver then sends to the database. With a
573      * a <code>Calendar</code> object, the driver can calculate the timestamp
574      * taking into account a custom timezone and locale. If no
575      * <code>Calendar</code> object is specified, the driver uses the default
576      * timezone and locale.
577      *
578      * @param parameterIndex the first parameter is 1, the second is 2, ...
579      * @param x the parameter value
580      * @param cal the <code>Calendar</code> object the driver will use
581      * to construct the timestamp
582      * @exception SQLException if a database access error occurs
583      */
584     public void setTimestamp(int parameterIndex, java.sql.Timestamp JavaDoc x, Calendar JavaDoc cal)
585         throws RemoteException, SQLException {
586       jdbcPrepStmt_.setTimestamp(parameterIndex, x, cal);
587     }
588
589     /**
590      * JDBC 2.0
591      *
592      * Sets the designated parameter to SQL NULL. This version of setNull should
593      * be used for user-named types and REF type parameters. Examples
594      * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
595      * named array types.
596      *
597      * <P><B>Note:</B> To be portable, applications must give the
598      * SQL type code and the fully-qualified SQL type name when specifying
599      * a NULL user-defined or REF parameter. In the case of a user-named type
600      * the name is the type name of the parameter itself. For a REF
601      * parameter the name is the type name of the referenced type. If
602      * a JDBC driver does not need the type code or type name information,
603      * it may ignore it.
604      *
605      * Although it is intended for user-named and Ref parameters,
606      * this method may be used to set a null parameter of any JDBC type.
607      * If the parameter does not have a user-named or REF type, the given
608      * typeName is ignored.
609      *
610      *
611      * @param parameterIndex the first parameter is 1, the second is 2, ...
612      * @param sqlType a value from java.sql.Types
613      * @param typeName the fully-qualified name of an SQL user-named type,
614      * ignored if the parameter is not a user-named type or REF
615      * @exception SQLException if a database access error occurs
616      */
617   public void setNull (int paramIndex, int sqlType, String JavaDoc typeName)
618       throws RemoteException, SQLException {
619       jdbcPrepStmt_.setNull (paramIndex, sqlType, typeName);
620     }
621
622     //------------------------- JDBC 3.0 -----------------------------------
623
624     /**
625      * Sets the designated parameter to the given <code>java.net.URL</code> value.
626      * The driver converts this to an SQL <code>DATALINK</code> value
627      * when it sends it to the database.
628      *
629      * @param parameterIndex the first parameter is 1, the second is 2, ...
630      * @param x the <code>java.net.URL</code> object to be set
631      * @exception SQLException if a database access error occurs
632      * @since 1.4
633      */
634     public void setURL(int parameterIndex, java.net.URL JavaDoc x)
635     throws java.rmi.RemoteException JavaDoc, SQLException {
636       jdbcPrepStmt_.setURL(parameterIndex, x);
637     }
638
639     /**
640      * Retrieves the number, types and properties of this
641      * <code>PreparedStatement</code> object's parameters.
642      *
643      * @return a <code>ParameterMetaData</code> object that contains information
644      * about the number, types and properties of this
645      * <code>PreparedStatement</code> object's parameters
646      * @exception SQLException if a database access error occurs
647      * @see ParameterMetaData
648      * @since 1.4
649      */
650   public RJParameterMetaDataInterface getParameterMetaData()
651   throws java.rmi.RemoteException JavaDoc, SQLException {
652     return new RJParameterMetaDataServer(jdbcPrepStmt_.getParameterMetaData());
653   }
654   
655 };
656
657
Popular Tags