1 //
2 // Copyright 1998, 1999 CDS Networks, Inc., Medford Oregon
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are met:
8 // 1. Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // 2. Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // 3. All advertising materials mentioning features or use of this software
14 // must display the following acknowledgement:
15 // This product includes software developed by CDS Networks, Inc.
16 // 4. The name of CDS Networks, Inc. may not be used to endorse or promote
17 // products derived from this software without specific prior
18 // written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY CDS NETWORKS, INC. ``AS IS'' AND
21 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 // ARE DISCLAIMED. IN NO EVENT SHALL CDS NETWORKS, INC. BE LIABLE
24 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 // SUCH DAMAGE.
31 //
32
33
34 package com.internetcds.jdbc.tds;
35
36 import java.sql.*;
37 import java.math.BigDecimal;
38 import java.util.Calendar;
39
40
41 /***
42 * <P>CallableStatement is used to execute SQL stored procedures.
43 *
44 * <P>JDBC provides a stored procedure SQL escape that allows stored
45 * procedures to be called in a standard way for all RDBMS's. This
46 * escape syntax has one form that includes a result parameter and one
47 * that does not. If used, the result parameter must be registered as
48 * an OUT parameter. The other parameters may be used for input,
49 * output or both. Parameters are refered to sequentially, by
50 * number. The first parameter is 1.
51 *
52 * <P><CODE>
53 * {?= call <procedure-name>[<arg1>,<arg2>, ...]}<BR>
54 * {call <procedure-name>[<arg1>,<arg2>, ...]}
55 * </CODE>
56 *
57 * <P>IN parameter values are set using the set methods inherited from
58 * PreparedStatement. The type of all OUT parameters must be
59 * registered prior to executing the stored procedure; their values
60 * are retrieved after execution via the get methods provided here.
61 *
62 * <P>A Callable statement may return a ResultSet or multiple
63 * ResultSets. Multiple ResultSets are handled using operations
64 * inherited from Statement.
65 *
66 * <P>For maximum portability, a call's ResultSets and update counts
67 * should be processed prior to getting the values of output
68 * parameters.
69 *
70 * @see Connection#prepareCall
71 * @see ResultSet
72 */
73 public class CallableStatement_base
74 extends com.internetcds.jdbc.tds.PreparedStatement_base
75 {
76 public static final String cvsVersion = "$Id: CallableStatement_base.html,v 1.1 2003/05/12 16:19:42 sinisa Exp $";
77
78
79 private String procedureName = null;
80
81
82 public CallableStatement_base(
83 java.sql.Connection conn_,
84 Tds tds_,
85 String sql)
86 throws SQLException
87 {
88 super(conn_, tds_, sql);
89 int i;
90 procedureName = "";
91 i = 0;
92 while(i<sql.length()
93 && (!
94 (Character.isLetterOrDigit(sql.charAt(i))
95 || sql.charAt(i) == '#')))
96 {
97 i++;
98 }
99
100 while(i<sql.length()
101 && (Character.isLetterOrDigit(sql.charAt(i))
102 || sql.charAt(i) == '#'
103 || sql.charAt(i) == '_'))
104 {
105 procedureName = procedureName + sql.charAt(i);
106 i++;
107 }
108
109 if (procedureName.length() == 0)
110 {
111 throw new SQLException("Did not find name in sql string");
112 }
113 }
114
115
116
117
118 /***
119 * Get the value of a NUMERIC parameter as a java.math.BigDecimal object.
120 *
121 * @param parameterIndex the first parameter is 1, the second is 2, ...
122 *
123 * @param scale a value greater than or equal to zero representing the
124 * desired number of digits to the right of the decimal point
125 *
126 * @return the parameter value; if the value is SQL NULL, the result is
127 * null
128 * @exception SQLException if a database-access error occurs.
129 */
130 public BigDecimal getBigDecimal(int parameterIndex, int scale)
131 throws SQLException
132 {
133 throw new SQLException("Not implemented");
134 }
135
136
137 /***
138 * Get the value of a BIT parameter as a Java boolean.
139 *
140 * @param parameterIndex the first parameter is 1, the second is 2, ...
141 * @return the parameter value; if the value is SQL NULL, the result is false
142 * @exception SQLException if a database-access error occurs.
143 */
144 public boolean getBoolean(int parameterIndex) throws SQLException
145 {
146 throw new SQLException("Not implemented");
147 }
148
149
150 /***
151 * Get the value of a TINYINT parameter as a Java byte.
152 *
153 * @param parameterIndex the first parameter is 1, the second is 2, ...
154 * @return the parameter value; if the value is SQL NULL, the result is 0
155 * @exception SQLException if a database-access error occurs.
156 */
157 public byte getByte(int parameterIndex) throws SQLException
158 {
159 throw new SQLException("Not implemented");
160 }
161
162
163 /***
164 * Get the value of a SQL BINARY or VARBINARY parameter as a Java byte[]
165 *
166 * @param parameterIndex the first parameter is 1, the second is 2, ...
167 * @return the parameter value; if the value is SQL NULL, the result is null
168 * @exception SQLException if a database-access error occurs.
169 */
170 public byte[] getBytes(int parameterIndex) throws SQLException
171 {
172 throw new SQLException("Not implemented");
173 }
174
175
176 /***
177 * Get the value of a SQL DATE parameter as a java.sql.Date object
178 *
179 * @param parameterIndex the first parameter is 1, the second is 2, ...
180 * @return the parameter value; if the value is SQL NULL, the result is null
181 * @exception SQLException if a database-access error occurs.
182 */
183 public java.sql.Date getDate(int parameterIndex) throws SQLException
184 {
185 throw new SQLException("Not implemented");
186 }
187
188
189 /***
190 * Get the value of a DOUBLE parameter as a Java double.
191 *
192 * @param parameterIndex the first parameter is 1, the second is 2, ...
193 * @return the parameter value; if the value is SQL NULL, the result is 0
194 * @exception SQLException if a database-access error occurs.
195 */
196 public double getDouble(int parameterIndex) throws SQLException
197 {
198 throw new SQLException("Not implemented");
199 }
200
201
202 /***
203 * Get the value of a FLOAT parameter as a Java float.
204 *
205 * @param parameterIndex the first parameter is 1, the second is 2, ...
206 * @return the parameter value; if the value is SQL NULL, the result is 0
207 * @exception SQLException if a database-access error occurs.
208 */
209 public float getFloat(int parameterIndex) throws SQLException
210 {
211 throw new SQLException("Not implemented");
212 }
213
214
215 /***
216 * Get the value of an INTEGER parameter as a Java int.
217 *
218 * @param parameterIndex the first parameter is 1, the second is 2, ...
219 * @return the parameter value; if the value is SQL NULL, the result is 0
220 * @exception SQLException if a database-access error occurs.
221 */
222 public int getInt(int parameterIndex) throws SQLException
223 {
224 throw new SQLException("Not implemented");
225 }
226
227
228 /***
229 * Get the value of a BIGINT parameter as a Java long.
230 *
231 * @param parameterIndex the first parameter is 1, the second is 2, ...
232 * @return the parameter value; if the value is SQL NULL, the result is 0
233 * @exception SQLException if a database-access error occurs.
234 */
235 public long getLong(int parameterIndex) throws SQLException
236 {
237 throw new SQLException("Not implemented");
238 }
239
240
241 //----------------------------------------------------------------------
242 // Advanced features:
243
244
245 /***
246 * Get the value of a parameter as a Java object.
247 *
248 * <p>This method returns a Java object whose type coresponds to the SQL
249 * type that was registered for this parameter using registerOutParameter.
250 *
251 * <p>Note that this method may be used to read
252 * datatabase-specific, abstract data types. This is done by
253 * specifying a targetSqlType of java.sql.types.OTHER, which
254 * allows the driver to return a database-specific Java type.
255 *
256 * @param parameterIndex The first parameter is 1, the second is 2, ...
257 * @return A java.lang.Object holding the OUT parameter value.
258 * @exception SQLException if a database-access error occurs.
259 * @see Types
260 */
261 public Object getObject(int parameterIndex) throws SQLException
262 {
263 throw new SQLException("Not implemented");
264 }
265
266
267 /***
268 * Get the value of a SMALLINT parameter as a Java short.
269 *
270 * @param parameterIndex the first parameter is 1, the second is 2, ...
271 * @return the parameter value; if the value is SQL NULL, the result is 0
272 * @exception SQLException if a database-access error occurs.
273 */
274 public short getShort(int parameterIndex) throws SQLException
275 {
276 throw new SQLException("Not implemented");
277 }
278
279
280 /***
281 * Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a Java String.
282 *
283 * @param parameterIndex the first parameter is 1, the second is 2, ...
284 * @return the parameter value; if the value is SQL NULL, the result is null
285 * @exception SQLException if a database-access error occurs.
286 */
287 public String getString(int parameterIndex) throws SQLException
288 {
289 throw new SQLException("Not implemented");
290 }
291
292
293 /***
294 * Get the value of a SQL TIME parameter as a java.sql.Time object.
295 *
296 * @param parameterIndex the first parameter is 1, the second is 2, ...
297 * @return the parameter value; if the value is SQL NULL, the result is null
298 * @exception SQLException if a database-access error occurs.
299 */
300 public java.sql.Time getTime(int parameterIndex) throws SQLException
301 {
302 throw new SQLException("Not implemented");
303 }
304
305
306 /***
307 * Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object.
308 *
309 * @param parameterIndex the first parameter is 1, the second is 2, ...
310 * @return the parameter value; if the value is SQL NULL, the result is null
311 * @exception SQLException if a database-access error occurs.
312 */
313 public java.sql.Timestamp getTimestamp(int parameterIndex)
314 throws SQLException
315 {
316 throw new SQLException("Not implemented");
317 }
318
319
320 /***
321 * Before executing a stored procedure call, you must explicitly
322 * call registerOutParameter to register the java.sql.Type of each
323 * out parameter.
324 *
325 * <P><B>Note:</B> When reading the value of an out parameter, you
326 * must use the getXXX method whose Java type XXX corresponds to the
327 * parameter's registered SQL type.
328 *
329 * @param parameterIndex the first parameter is 1, the second is 2,...
330 * @param sqlType SQL type code defined by java.sql.Types;
331 * for parameters of type Numeric or Decimal use the version of
332 * registerOutParameter that accepts a scale value
333 * @exception SQLException if a database-access error occurs.
334 * @see Type
335 */
336 public void registerOutParameter(int parameterIndex, int sqlType)
337 throws SQLException
338 {
339 throw new SQLException("Not implemented");
340 }
341
342
343 /***
344 * Use this version of registerOutParameter for registering
345 * Numeric or Decimal out parameters.
346 *
347 * <P><B>Note:</B> When reading the value of an out parameter, you
348 * must use the getXXX method whose Java type XXX corresponds to the
349 * parameter's registered SQL type.
350 *
351 * @param parameterIndex the first parameter is 1, the second is 2, ...
352 * @param sqlType use either java.sql.Type.NUMERIC or java.sql.Type.DECIMAL
353 * @param scale a value greater than or equal to zero representing the
354 * desired number of digits to the right of the decimal point
355 * @exception SQLException if a database-access error occurs.
356 * @see Type
357 */
358 public void registerOutParameter(int parameterIndex, int sqlType, int scale)
359 throws SQLException
360 {
361 throw new SQLException("Not implemented");
362 }
363
364
365 /***
366 * An OUT parameter may have the value of SQL NULL; wasNull reports
367 * whether the last value read has this special value.
368 *
369 * <P><B>Note:</B> You must first call getXXX on a parameter to
370 * read its value and then call wasNull() to see if the value was
371 * SQL NULL.
372 *
373 * @return true if the last parameter read was SQL NULL
374 * @exception SQLException if a database-access error occurs.
375 */
376 public boolean wasNull() throws SQLException
377 {
378 throw new SQLException("Not implemented");
379 }
380
381 public boolean execute()
382 throws SQLException
383 {
384 boolean result;
385
386 closeResults();
387 updateCount = -2;
388
389 // First make sure the caller has filled in all the parameters.
390 ParameterUtils.verifyThatParametersAreSet(parameterList);
391
392 // execute the stored procedure
393 result = executeCall(procedureName,
394 parameterList,
395 parameterList);
396
397 return result;
398 }
399
400
401
402 //--------------------------JDBC 2.0-----------------------------
403
404 /***
405 * JDBC 2.0
406 *
407 * Gets the value of a JDBC <code>NUMERIC</code> parameter as a
408 * <code>java.math.BigDecimal</code> object with as many digits to the
409 * right of the decimal point as the value contains.
410 * @param parameterIndex the first parameter is 1, the second is 2,
411 * and so on
412 * @return the parameter value in full precision. If the value is
413 * SQL NULL, the result is <code>null</code>.
414 * @exception SQLException if a database access error occurs
415 */
416 public BigDecimal getBigDecimal(int parameterIndex) throws SQLException
417 {
418 NotImplemented();
419 return null;
420 }
421
422
423
424 /***
425 * Gets the value of a JDBC <code>DATE</code> parameter as a
426 * <code>java.sql.Date</code> object, using
427 * the given <code>Calendar</code> object
428 * to construct the date.
429 * With a <code>Calendar</code> object, the driver
430 * can calculate the date taking into account a custom timezone and locale.
431 * If no <code>Calendar</code> object is specified, the driver uses the
432 * default timezone and locale.
433 *
434 * @param parameterIndex the first parameter is 1, the second is 2,
435 * and so on
436 * @param cal the <code>Calendar</code> object the driver will use
437 * to construct the date
438 * @return the parameter value. If the value is SQL NULL, the result is
439 * <code>null</code>.
440 * @exception SQLException if a database access error occurs
441 */
442 public java.sql.Date getDate(int parameterIndex, Calendar cal)
443 throws SQLException
444 {
445 NotImplemented();
446 return null;
447 }
448
449
450 /***
451 * Gets the value of a JDBC <code>TIME</code> parameter as a
452 * <code>java.sql.Time</code> object, using
453 * the given <code>Calendar</code> object
454 * to construct the time.
455 * With a <code>Calendar</code> object, the driver
456 * can calculate the time taking into account a custom timezone and locale.
457 * If no <code>Calendar</code> object is specified, the driver uses the
458 * default timezone and locale.
459 *
460 * @param parameterIndex the first parameter is 1, the second is 2,
461 * and so on
462 * @param cal the <code>Calendar</code> object the driver will use
463 * to construct the time
464 * @return the parameter value; if the value is SQL NULL, the result is
465 * <code>null</code>.
466 * @exception SQLException if a database access error occurs
467 */
468 public java.sql.Time getTime(int parameterIndex, Calendar cal)
469 throws SQLException
470 {
471 NotImplemented();
472 return null;
473 }
474
475
476 /***
477 * Gets the value of a JDBC <code>TIMESTAMP</code> parameter as a
478 * <code>java.sql.Timestamp</code> object, using
479 * the given <code>Calendar</code> object to construct
480 * the <code>Timestamp</code> object.
481 * With a <code>Calendar</code> object, the driver
482 * can calculate the timestamp taking into account a custom timezone and locale.
483 * If no <code>Calendar</code> object is specified, the driver uses the
484 * default timezone and locale.
485 *
486 *
487 * @param parameterIndex the first parameter is 1, the second is 2,
488 * and so on
489 * @param cal the <code>Calendar</code> object the driver will use
490 * to construct the timestamp
491 * @return the parameter value. If the value is SQL NULL, the result is
492 * <code>null</code>.
493 * @exception SQLException if a database access error occurs
494 */
495 public java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal)
496 throws SQLException
497 {
498 NotImplemented();
499 return null;
500 }
501
502
503
504 /***
505 * JDBC 2.0
506 *
507 * Registers the designated output parameter. This version of
508 * the method <code>registerOutParameter</code>
509 * should be used for a user-named or REF output parameter. Examples
510 * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
511 * named array types.
512 *
513 * Before executing a stored procedure call, you must explicitly
514 * call <code>registerOutParameter</code> to register the type from
515 * <code>java.sql.Types</code> for each
516 * OUT parameter. For a user-named parameter the fully-qualified SQL
517 * type name of the parameter should also be given, while a REF
518 * parameter requires that the fully-qualified type name of the
519 * referenced type be given. A JDBC driver that does not need the
520 * type code and type name information may ignore it. To be portable,
521 * however, applications should always provide these values for
522 * user-named and REF parameters.
523 *
524 * Although it is intended for user-named and REF parameters,
525 * this method may be used to register a parameter of any JDBC type.
526 * If the parameter does not have a user-named or REF type, the
527 * typeName parameter is ignored.
528 *
529 * <P><B>Note:</B> When reading the value of an out parameter, you
530 * must use the <code>getXXX</code> method whose Java type XXX corresponds to the
531 * parameter's registered SQL type.
532 *
533 * @param parameterIndex the first parameter is 1, the second is 2,...
534 * @param sqlType a value from {@link java.sql.Types}
535 * @param typeName the fully-qualified name of an SQL structured type
536 * @exception SQLException if a database-access error occurs
537 * @see Types
538 */
539 public void registerOutParameter (int paramIndex, int sqlType, String typeName)
540 throws SQLException
541 {
542 NotImplemented();
543 }
544
545
546
547
548 static public void main(String args[])
549 throws java.lang.ClassNotFoundException,
550 java.lang.IllegalAccessException,
551 java.lang.InstantiationException
552 {
553 try
554 {
555 String url = url = ""
556 + "jdbc:freetds:"
557 + "//"
558 + "kap"
559 + "/"
560 + "pubs";
561
562 Class.forName("com.internetcds.jdbc.tds.Driver").newInstance();
563 java.sql.Connection connection;
564 connection = DriverManager.getConnection(url,
565 "testuser",
566 "password");
567
568 java.sql.CallableStatement call = connection.prepareCall(
569 "sp_tables ?");
570 call.setString(1, "%");
571 java.sql.ResultSet rs = call.executeQuery();
572
573 while(rs.next())
574 {
575 String qualifier = rs.getString("TABLE_QUALIFIER");
576 String owner = rs.getString("TABLE_OWNER");
577 String name = rs.getString("TABLE_NAME");
578 String type = rs.getString("TABLE_TYPE");
579 String remarks = rs.getString("REMARKS");
580
581 System.out.println("qualifier: " + qualifier);
582 System.out.println("owner: " + owner);
583 System.out.println("name: " + name);
584 System.out.println("type: " + type);
585 System.out.println("remarks: " + remarks);
586 System.out.println("");
587 }
588 }
589 catch(SQLException e)
590 {
591 e.printStackTrace();
592 System.out.println(e.getMessage());
593 }
594 }
595 }
This page automatically generated by Maven