Java > Open Source Codes > org > webdocwf > util > xml > XmlPreparedStatement


1 package org.webdocwf.util.xml;
2
3 import java.sql.PreparedStatement ;
4 import java.sql.ResultSet ;
5 import java.sql.SQLException ;
6 import java.math.BigDecimal ;
7 import java.sql.Date ;
8 import java.sql.Time ;
9 import java.sql.Timestamp ;
10 import java.io.InputStream ;
11 import java.io.Reader ;
12 import java.sql.Ref ;
13 import java.sql.Blob ;
14 import java.sql.Clob ;
15 import java.sql.Array ;
16 import java.sql.ResultSetMetaData ;
17 import java.util.Calendar ;
18 import java.net.URL ;
19 import java.sql.ParameterMetaData ;
20 import java.sql.SQLWarning ;
21 import java.sql.Connection ;
22 import java.sql.DriverManager ;
23 import java.io.File ;
24 import java.util.*;
25
26 /**
27  * Class implements the JDBC PreparedStatement interface for the XmlJdbc driver.
28  *
29  * @author Zoran Milakovic
30  */
31
32 public class XmlPreparedStatement implements PreparedStatement {
33
34   private XmlConnection connection;
35   private Vector resultSets = new Vector();
36   private String sqlForPrepare = "";
37   private String sqlPrepared = "";
38   private int paramCount = 0;
39   private ArrayList parameters = new ArrayList();
40   private ArrayList binaryStreamParameters = new ArrayList();
41   private String fileName;
42   public static String PREPARE_SEPARATOR = "~@#NEXTPARAMETER#@~";
43
44   public XmlPreparedStatement(XmlConnection connection, String preparedSql) {
45     DriverManager.println("XmlJdbc - XmlStatement() - connection=" + connection);
46     this.sqlForPrepare = preparedSql;
47     this.sqlPrepared = preparedSql;
48     this.paramCount = countParameters(preparedSql);
49     for(int i = 0; i < paramCount; i++)
50       parameters.add("null");
51     this.connection = connection;
52     this.fileName = connection.getPath() + connection.getExtension();
53   }
54
55   private int countParameters(String sql) {
56     int count = 0;
57     int index = sql.indexOf(PREPARE_SEPARATOR);
58     while(index != -1) {
59       count++;
60       sql = sql.substring(index + 1);
61       index = sql.indexOf(PREPARE_SEPARATOR);
62     }
63     return count;
64   }
65
66   private boolean prepareSql() throws SQLException {
67     boolean retVal = true;
68
69     for(int i = 0; i < parameters.size(); i++) {
70       int index = sqlPrepared.indexOf(PREPARE_SEPARATOR);
71       if(index != -1) {
72         sqlPrepared = sqlPrepared.substring(0, index) +
73                       parameters.get(i) +
74                       sqlPrepared.substring(index + PREPARE_SEPARATOR.length());
75       }
76     }
77
78     if(sqlPrepared.indexOf(PREPARE_SEPARATOR) != -1)
79       throw new SQLException ("All ? in prepared query has to be replaced with values.");
80     else if(parameters.size() < this.paramCount)
81       throw new SQLException (
82           "Number of setted parameters is less than number of parameters in statement.");
83     else if(parameters.size() > this.paramCount)
84       throw new SQLException (
85           "Number of setted parameters is greater than number of parameters in statement.");
86
87     return retVal;
88   }
89
90   /**
91    * Sets the maxFieldSize attribute of the XmlStatement object
92    *
93    * @param p0 The new maxFieldSize value
94    * @exception SQLException Description of Exception
95    * @since
96    */
97   public void setMaxFieldSize(int p0) throws SQLException {
98     throw new SQLException ("Not Supported !");
99   }
100
101   /**
102    *Sets the maxRows attribute of the XmlStatement object
103    *
104    * @param p0 The new maxRows value
105    * @exception SQLException Description of Exception
106    * @since
107    */
108   public void setMaxRows(int p0) throws SQLException {
109     throw new SQLException ("Not Supported !");
110   }
111
112   /**
113    *Sets the escapeProcessing attribute of the XmlStatement object
114    *
115    * @param p0 The new escapeProcessing value
116    * @exception SQLException Description of Exception
117    * @since
118    */
119   public void setEscapeProcessing(boolean p0) throws SQLException {
120     throw new SQLException ("Not Supported !");
121   }
122
123   /**
124    *Sets the queryTimeout attribute of the XmlStatement object
125    *
126    * @param p0 The new queryTimeout value
127    * @exception SQLException Description of Exception
128    * @since
129    */
130   public void setQueryTimeout(int p0) throws SQLException {
131     throw new SQLException ("Not Supported !");
132   }
133
134   /**
135    *Sets the cursorName attribute of the XmlStatement object
136    *
137    * @param p0 The new cursorName value
138    * @exception SQLException Description of Exception
139    * @since
140    */
141   public void setCursorName(String p0) throws SQLException {
142     throw new SQLException ("Not Supported !");
143   }
144
145   /**
146    *Sets the fetchDirection attribute of the XmlStatement object
147    *
148    * @param p0 The new fetchDirection value
149    * @exception SQLException Description of Exception
150    * @since
151    */
152   public void setFetchDirection(int p0) throws SQLException {
153     throw new SQLException ("Not Supported !");
154   }
155
156   /**
157    *Sets the fetchSize attribute of the XmlStatement object
158    *
159    * @param p0 The new fetchSize value
160    * @exception SQLException Description of Exception
161    * @since
162    */
163   public void setFetchSize(int p0) throws SQLException {
164     throw new SQLException ("Not Supported !");
165   }
166
167   /**
168    *Gets the maxFieldSize attribute of the XmlStatement object
169    *
170    * @return The maxFieldSize value
171    * @exception SQLException Description of Exception
172    * @since
173    */
174   public int getMaxFieldSize() throws SQLException {
175     throw new SQLException ("Not Supported !");
176   }
177
178   /**
179    *Gets the maxRows attribute of the XmlStatement object
180    *
181    * @return The maxRows value
182    * @exception SQLException Description of Exception
183    * @since
184    */
185   public int getMaxRows() throws SQLException {
186     throw new SQLException ("Not Supported !");
187   }
188
189   /**
190    *Gets the queryTimeout attribute of the XmlStatement object
191    *
192    * @return The queryTimeout value
193    * @exception SQLException Description of Exception
194    * @since
195    */
196   public int getQueryTimeout() throws SQLException {
197     throw new SQLException ("Not Supported !");
198   }
199
200   /**
201    *Gets the warnings attribute of the XmlStatement object
202    *
203    * @return The warnings value
204    * @exception SQLException Description of Exception
205    * @since
206    */
207   public SQLWarning getWarnings() throws SQLException {
208     throw new SQLException ("Not Supported !");
209   }
210
211   /**
212    *Gets the resultSet attribute of the XmlStatement object
213    *
214    * @return The resultSet value
215    * @exception SQLException Description of Exception
216    * @since
217    */
218   public ResultSet getResultSet() throws SQLException {
219     throw new SQLException ("Not Supported !");
220   }
221
222   /**
223    *Gets the updateCount attribute of the XmlStatement object
224    *
225    * @return The updateCount value
226    * @exception SQLException Description of Exception
227    * @since
228    */
229   public int getUpdateCount() throws SQLException {
230     throw new SQLException ("Not Supported !");
231   }
232
233   /**
234    *Gets the moreResults attribute of the XmlStatement object
235    *
236    * @return The moreResults value
237    * @exception SQLException Description of Exception
238    * @since
239    */
240   public boolean getMoreResults() throws SQLException {
241     throw new SQLException ("Not Supported !");
242   }
243
244   /**
245    *Gets the fetchDirection attribute of the XmlStatement object
246    *
247    * @return The fetchDirection value
248    * @exception SQLException Description of Exception
249    * @since
250    */
251   public int getFetchDirection() throws SQLException {
252     throw new SQLException ("Not Supported !");
253   }
254
255   /**
256    *Gets the fetchSize attribute of the XmlStatement object
257    *
258    * @return The fetchSize value
259    * @exception SQLException Description of Exception
260    * @since
261    */
262   public int getFetchSize() throws SQLException {
263     throw new SQLException ("Not Supported !");
264   }
265
266   /**
267    *Gets the resultSetConcurrency attribute of the XmlStatement object
268    *
269    * @return The resultSetConcurrency value
270    * @exception SQLException Description of Exception
271    * @since
272    */
273   public int getResultSetConcurrency() throws SQLException {
274     throw new SQLException ("Not Supported !");
275   }
276
277   /**
278    *Gets the resultSetType attribute of the XmlStatement object
279    *
280    * @return The resultSetType value
281    * @exception SQLException Description of Exception
282    * @since
283    */
284   public int getResultSetType() throws SQLException {
285     throw new SQLException ("Not Supported !");
286   }
287
288   /**
289    *Gets the connection attribute of the XmlStatement object
290    *
291    * @return The connection value
292    * @exception SQLException Description of Exception
293    * @since
294    */
295   public Connection getConnection() throws SQLException {
296     return connection;
297   }
298
299   public ResultSet executeQuery(String sql) throws SQLException {
300     DriverManager.println("XmlJdbc - XmlStatement:executeQuery() - sql= " + sql);
301     XmlWriter writer;
302     if(this.connection.getAutoCommit())
303       writer = new XmlWriter(fileName,true);
304     else
305       writer = new XmlWriter(fileName, false);
306     XmlSqlParser parser = new XmlSqlParser(this.fileName, this.connection.getAutoCommit() );
307     if( binaryStreamParameters.size() != 0 )
308           parser.setBinaryStreamList( binaryStreamParameters );
309     try {
310       parser.parse(sql);
311     }
312     catch(Exception e) {
313       throw new SQLException ("Syntax Error. " + e.getMessage());
314     }
315     if(parser.sqlType.equals(parser.DROP_TABLE)) {
316       execute(sql);
317       return null;
318     }
319     if(parser.sqlType.equals(parser.DELETE)) {
320       executeUpdate(sql);
321       return null;
322     }
323     if(parser.sqlType.equals(parser.UPDATE)) {
324       executeUpdate(sql);
325       return null;
326     } else if(parser.sqlType.equals(parser.INSERT)) {
327       executeUpdate(sql);
328       return null;
329     } else if(parser.sqlType.equals(parser.CREATE_TABLE)) {
330       execute(sql);
331       return null;
332     } else if(parser.sqlType.equals(parser.SELECT)) {
333
334       String fileName = connection.getPath() + connection.getExtension();
335       File checkFile = new File (fileName);
336       XmlReader reader;
337       try {
338         reader = new XmlReader(fileName);
339         String [] xxx = parser.getColumnNames();
340         String [] yyy = (String []) writer.getTableProperties(parser.getTableName()).get(0);
341         boolean isOK = true;
342         for(int i = 0; i < xxx.length; i++) {
343           out:
344               for(int j = 0; j < yyy.length; j++) {
345             if(xxx[i].equalsIgnoreCase(yyy[j])) {
346               isOK = true;
347               break out;
348             } else
349               isOK = false;
350           }
351           if(!isOK)
352             throw new SQLException ("Column '" + xxx[i] + "' not found in table " +
353                 parser.getTableName());
354         }
355       }
356       catch(Exception e) {
357         throw new SQLException ("Error reading data file. Message was: " + e);
358       }
359       XmlResultSet resultSet = new XmlResultSet(this, reader,
360                                parser.getTableName(), parser.getColumnNames(),
361                                parser.getWhereColumnNames(), parser.getWhereColumnValues());
362       resultSet.select();
363       return resultSet;
364     } else {
365       throw new SQLException ("Syntax error.Not supported sql statement.");
366     }
367   }
368
369   /**
370    * Insert data into XML database
371    *
372    * @param sql Description of Parameter
373    * @return Description of the Returned Value
374    * @exception SQLException Description of Exception
375    * @since
376    */
377   public int executeUpdate(String sql) throws SQLException {
378     DriverManager.println("XmlJdbc - XmlStatement:executeUpdate() - sql= " + sql);
379     XmlSqlParser parser = new XmlSqlParser();
380     if( binaryStreamParameters.size() != 0 )
381           parser.setBinaryStreamList( binaryStreamParameters );
382     try {
383       parser.parse(sql);
384     }
385     catch(Exception e) {
386       throw new SQLException ("Syntax Error. " + e.getMessage());
387     }
388     if(parser.sqlType.equals(parser.SELECT))
389       throw new SQLException ("Not supported SELECT statement - use executeQuery() method");
390     else if(parser.sqlType.equals(parser.CREATE_TABLE)) {
391       throw new SQLException ("Not supported CREATE_TABLE statement - use execute() method");
392     } else if(parser.sqlType.equals(parser.DROP_TABLE)) {
393       throw new SQLException ("Not supported DROP_TABLE statement - use execute() method");
394     } else if(parser.sqlType.equals(parser.INSERT)) {
395       String fileName = connection.getPath() + connection.getExtension();
396       XmlWriter writeXml;
397       try {
398         if(this.connection.getAutoCommit())
399           writeXml = new XmlWriter(fileName,true);
400         else
401           writeXml = new XmlWriter(fileName, false);
402         ArrayList properties = writeXml.getTableProperties(parser.tableName);
403         //check for existance of columns
404 String [] xxx = parser.getColumnNames();
405         String [] yyy = (String []) properties.get(0);
406         boolean isOK = true;
407         for(int i = 0; i < xxx.length; i++) {
408           if(!xxx[i].endsWith("*")) {
409             out:
410                 for(int j = 0; j < yyy.length; j++) {
411               if(xxx[i].equalsIgnoreCase(yyy[j])) {
412                 isOK = true;
413                 break out;
414               } else
415                 isOK = false;
416             }
417             if(!isOK)
418               throw new SQLException ("Column '" + xxx[i] + "' not found in table " +
419                   parser.getTableName());
420           }
421         }
422         //check if NOTNULL columns is set
423 if(!properties.get(1).toString().equalsIgnoreCase("NO CREATE TABLE")) {
424           yyy = parser.getColumnNames();
425           xxx = (String []) writeXml.getTableProperties(parser.tableName).get(2);
426           isOK = true;
427           for(int i = 0; i < xxx.length; i++) {
428             out:
429                 for(int j = 0; j < yyy.length; j++) {
430               if(xxx[i].equalsIgnoreCase(yyy[j])) {
431                 isOK = true;
432                 break out;
433               } else
434                 isOK = false;
435             }
436             if(!isOK)
437               throw new SQLException ("Column '" + xxx[i] + "' can not be NULL.");
438           }
439         }
440         writeXml.insert(parser.getTableName(), parser.getColumnNames(), parser.getColumnValues());
441       }
442       catch(Exception e) {
443         throw new SQLException ("Error reading data file. Message was: " + e);
444       }
445
446     } else if(parser.sqlType.equals(parser.UPDATE)) {
447       String fileName = connection.getPath() + connection.getExtension();
448       XmlWriter writeXml;
449       try {
450         if(this.connection.getAutoCommit())
451           writeXml = new XmlWriter(fileName,true);
452         else
453           writeXml = new XmlWriter(fileName, false);
454         String [] xxx = parser.getColumnNames();
455         String [] yyy = (String []) writeXml.getTableProperties(parser.tableName).get(0);
456         boolean isOK = true;
457         for(int i = 0; i < xxx.length; i++) {
458           if(!xxx[i].endsWith("*")) {
459             out:
460                 for(int j = 0; j < yyy.length; j++) {
461               if(xxx[i].equalsIgnoreCase(yyy[j])) {
462                 isOK = true;
463                 break out;
464               } else
465                 isOK = false;
466             }
467             if(!isOK)
468               throw new SQLException ("Column '" + xxx[i] + "' not found in table " +
469                   parser.getTableName());
470           }
471         }
472         writeXml.update(parser.getTableName(), parser.getColumnNames(), parser.getColumnValues(),
473             parser.getWhereColumnNames(), parser.getWhereColumnValues());
474       }
475       catch(Exception e) {
476         throw new SQLException ("Error reading data file. Message was: " + e);
477       }
478
479     } else if(parser.sqlType.equals(parser.DELETE)) {
480       String fileName = connection.getPath() + connection.getExtension();
481       XmlWriter writeXml;
482       try {
483         if(this.connection.getAutoCommit())
484           writeXml = new XmlWriter(fileName,true);
485         else
486           writeXml = new XmlWriter(fileName, false);
487         String [] xxx = parser.getWhereColumnNames();
488         String [] yyy = (String []) writeXml.getTableProperties(parser.tableName).get(0);
489         boolean isOK = true;
490         for(int i = 0; i < xxx.length; i++) {
491           if(!xxx[i].endsWith("*")) {
492             out:
493                 for(int j = 0; j < yyy.length; j++) {
494               if(xxx[i].equalsIgnoreCase(yyy[j])) {
495                 isOK = true;
496                 break out;
497               } else
498                 isOK = false;
499             }
500             if(!isOK)
501               throw new SQLException ("Column '" + xxx[i] + "' not found in table " +
502                   parser.getTableName());
503           }
504         }
505         writeXml.delete(parser.getTableName(), parser.getWhereColumnNames(),
506             parser.getWhereColumnValues());
507       }
508       catch(Exception e) {
509         throw new SQLException ("Error reading data file. Message was: " + e);
510       }
511
512     } else if(parser.sqlType.equals(parser.DROP_TABLE)) {
513     }
514     return 0;
515
516   }
517
518   /**
519    * Releases this <code>Statement</code> object's database
520    * and JDBC resources immediately instead of waiting for
521    * this to happen when it is automatically closed.
522    * It is generally good practice to release resources as soon as
523    * you are finished with them to avoid tying up database
524    * resources.
525    * <P>
526    * Calling the method <code>close</code> on a <code>Statement</code>
527    * object that is already closed has no effect.
528    * <P>
529    * <B>Note:</B> A <code>Statement</code> object is automatically closed
530    * when it is garbage collected. When a <code>Statement</code> object is
531    * closed, its current <code>ResultSet</code> object, if one exists, is
532    * also closed.
533    *
534    * @exception SQLException if a database access error occurs
535    */
536   public void close() throws SQLException {
537   // close all result sets
538 }
539
540   /**
541    *Description of the Method
542    *
543    * @exception SQLException Description of Exception
544    * @since
545    */
546   public void cancel() throws SQLException {
547     throw new SQLException ("Not Supported !");
548   }
549
550   /**
551    *Description of the Method
552    *
553    * @exception SQLException Description of Exception
554    * @since
555    */
556   public void clearWarnings() throws SQLException {
557     throw new SQLException ("Not Supported !");
558   }
559
560   /**
561    *Description of the Method
562    *
563    * @param sql Description of Parameter
564    * @return Description of the Returned Value
565    * @exception SQLException Description of Exception
566    * @since
567    */
568   public boolean execute(String sql) throws SQLException {
569     XmlWriter writeXml;
570     if(this.connection.getAutoCommit())
571       writeXml = new XmlWriter(fileName,true);
572     else
573       writeXml = new XmlWriter(fileName, false);
574     XmlSqlParser parser = new XmlSqlParser(this.fileName, this.connection.getAutoCommit() );
575     if( binaryStreamParameters.size() != 0 )
576           parser.setBinaryStreamList( binaryStreamParameters );
577     try {
578       parser.parse(sql);
579     }
580     catch(Exception e) {
581       throw new SQLException ("Syntax Error. " + e.getMessage());
582     }
583     if(parser.sqlType.equals(parser.SELECT))
584       throw new SQLException ("Use executeQuery() for SELECT statement");
585     else if(parser.sqlType.equals(parser.UPDATE))
586       executeUpdate(sql);
587     else if(parser.sqlType.equals(parser.INSERT))
588       executeUpdate(sql);
589     else if(parser.sqlType.equals(parser.DELETE))
590       executeUpdate(sql);
591     else if(parser.sqlType.equals(parser.CREATE_TABLE)) {
592       String fileName = connection.getPath() + connection.getExtension();
593       try {
594         writeXml.createTable(parser.getSqlStatement(), parser.getTableName());
595       }
596       catch(Exception e) {
597         throw new SQLException ("Error reading data file. Message was: " + e);
598       }
599     } else if(parser.sqlType.equals(parser.DROP_TABLE)) {
600       String fileName = connection.getPath() + connection.getExtension();
601       try {
602         writeXml.dropTable(parser.getTableName());
603       }
604       catch(Exception e) {
605         throw new SQLException ("Error reading data file. Message was: " + e);
606       }
607     }
608     return true;
609
610   }
611
612   /**
613    * Set String as parameter in sql statement.
614    * @param parameterIndex
615    * @param value
616    * @throws SQLException
617    */
618   public void setString(int parameterIndex, String value) throws SQLException {
619     if( value == null )
620       value = "null";
621     value = Utils.replaceAll( value, "'", XmlSqlParser.quoteEscape);
622
623 XmlDriver.log("XmlPreparedStatement.setString(), value = "+value);
624
625     parameters.set(parameterIndex - 1, "'" + value + "'");
626   }
627
628   /**
629    *
630    * @param parameterIndex
631    * @param value
632    * @throws SQLException
633    */
634   public void setBinaryStream(int parameterIndex, InputStream value,
635       int length) throws SQLException {
636     throw new SQLException ("Not Supported !");
637   }
638
639   /**
640    *
641    * @param parameterIndex
642    * @param value
643    * @throws SQLException
644    */
645   public void setBytes(int parameterIndex, byte[] value) throws SQLException {
646     binaryStreamParameters.add(Utils.bytesToHexString(value));
647     String paramName = XmlSqlParser.BINARY_STREAM_OBJECT+binaryStreamParameters.size();
648     parameters.set(parameterIndex-1, paramName);
649   }
650
651
652   /**
653    *
654    * @param parameterIndex
655    * @param value
656    * @throws SQLException
657    */
658   public void setBlob(int parameterIndex, Blob value) throws SQLException {
659     throw new SQLException ("Not Supported !");
660   }
661
662   /**
663    * Adds a feature to the Batch attribute of the XmlStatement object
664    *
665    * @param p0 The feature to be added to the Batch attribute
666    * @exception SQLException Description of Exception
667    * @since
668    */
669   public void addBatch(String p0) throws SQLException {
670     throw new SQLException ("Not Supported !");
671   }
672
673   /**
674    *Description of the Method
675    *
676    * @exception SQLException Description of Exception
677    * @since
678    */
679   public void clearBatch() throws SQLException {
680     throw new SQLException ("Not Supported !");
681   }
682
683   /**
684    *Description of the Method
685    *
686    * @return Description of the Returned Value
687    * @exception SQLException Description of Exception
688    * @since
689    */
690   public int[] executeBatch() throws SQLException {
691     throw new SQLException ("Not Supported !");
692   }
693
694   //---------------------------------------------------------------------
695 // JDBC 3.0
696 //---------------------------------------------------------------------
697
698   public boolean getMoreResults(int current) throws SQLException {
699     throw new UnsupportedOperationException ("Statement.getMoreResults(int) unsupported");
700   }
701
702   public ResultSet getGeneratedKeys() throws SQLException {
703     throw new UnsupportedOperationException ("Statement.getGeneratedKeys() unsupported");
704   }
705
706   public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
707     throw new UnsupportedOperationException ("Statement.executeUpdate(String,int) unsupported");
708   }
709
710   public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
711     throw new UnsupportedOperationException ("Statement.executeUpdate(String,int[]) unsupported");
712   }
713
714   public int executeUpdate(String sql, String [] columnNames) throws SQLException {
715     throw new UnsupportedOperationException ("Statement.executeUpdate(String,String[]) unsupported");
716   }
717
718   public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
719     throw new UnsupportedOperationException ("Statement.execute(String,int) unsupported");
720   }
721
722   public boolean execute(String sql, int[] columnIndexes) throws SQLException {
723     throw new UnsupportedOperationException ("Statement.execute(String,int[]) unsupported");
724   }
725
726   public boolean execute(String sql, String [] columnNames) throws SQLException {
727     throw new UnsupportedOperationException ("Statement.execute(String,String[]) unsupported");
728   }
729
730   public int getResultSetHoldability() throws SQLException {
731     throw new UnsupportedOperationException ("Statement.getResultSetHoldability() unsupported");
732   }
733
734   public ResultSet executeQuery() throws SQLException {
735     if(!prepareSql())
736       throw new SQLException ("Error with prepared statement !");
737     return executeQuery(this.sqlPrepared);
738
739   }
740
741   public int executeUpdate() throws SQLException {
742     if(!prepareSql())
743       throw new SQLException ("Error with prepared statement !");
744     executeUpdate(this.sqlPrepared);
745     return 0;
746   }
747
748   public void setNull(int parameterIndex, int sqlType) throws SQLException {
749     this.setString(parameterIndex, "null" );
750   }
751
752   public void setBoolean(int parameterIndex, boolean value) throws SQLException {
753     this.setString(parameterIndex, String.valueOf(value) );
754   }
755
756   public void setByte(int parameterIndex, byte value) throws SQLException {
757     this.setString(parameterIndex, String.valueOf(value) );
758   }
759
760   public void setShort(int parameterIndex, short value) throws SQLException {
761     this.setString(parameterIndex, String.valueOf(value) );
762   }
763
764   public void setInt(int parameterIndex, int value) throws SQLException {
765     this.setString(parameterIndex, String.valueOf(value) );
766   }
767
768   public void setLong(int parameterIndex, long value) throws SQLException {
769     this.setString(parameterIndex, String.valueOf(value) );
770   }
771
772   public void setFloat(int parameterIndex, float value) throws SQLException {
773     this.setString(parameterIndex, String.valueOf(value) );
774   }
775
776   public void setDouble(int parameterIndex, double value) throws SQLException {
777     this.setString(parameterIndex, String.valueOf(value) );
778   }
779
780   public void setBigDecimal(int parameterIndex, BigDecimal value) throws SQLException {
781       if(value == null) {
782           this.setString( parameterIndex, value.toString() );
783       } else {
784           this.setString( parameterIndex, "" );
785       }
786   }
787
788   public void setDate(int parameterIndex, Date value) throws SQLException {
789       if(value == null) {
790           this.setString( parameterIndex, value.toString() );
791       } else {
792           this.setString( parameterIndex, "" );
793       }
794   }
795   
796   public void setTime(int parameterIndex, Time value) throws SQLException {
797       if(value == null) {
798           this.setString( parameterIndex, value.toString() );
799       } else {
800           this.setString( parameterIndex, "" );
801       }
802   }
803   
804   public void setTimestamp(int parameterIndex, Timestamp value) throws SQLException {
805       if(value == null) {
806           this.setString( parameterIndex, value.toString() );
807       } else {
808           this.setString( parameterIndex, "" );
809       }
810   }
811
812   public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
813     /**@todo Implement this java.sql.PreparedStatement method*/
814     throw new java.lang.UnsupportedOperationException (
815         "Method setAsciiStream() not yet implemented.");
816   }
817
818   public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
819     /**@todo Implement this java.sql.PreparedStatement method*/
820     throw new java.lang.UnsupportedOperationException (
821         "Method setUnicodeStream() not yet implemented.");
822   }
823
824   public void clearParameters() throws SQLException {
825     this.sqlPrepared = this.sqlForPrepare;
826 // this.parameters.clear();
827 for(int i = 0; i < parameters.size(); i++)
828       parameters.set(i, null);
829     this.binaryStreamParameters.clear();
830   }
831
832   public void setObject(int parameterIndex, Object x, int targetSqlType,
833       int scale) throws SQLException {
834     /**@todo Implement this java.sql.PreparedStatement method*/
835     throw new java.lang.UnsupportedOperationException ("Method setObject() not yet implemented.");
836   }
837
838   public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
839     /**@todo Implement this java.sql.PreparedStatement method*/
840     throw new java.lang.UnsupportedOperationException ("Method setObject() not yet implemented.");
841   }
842
843   public void setObject(int parameterIndex, Object x) throws SQLException {
844     if(x == null)
845       x = new String ("null");
846     setString(parameterIndex, x.toString());
847   }
848
849   public boolean execute() throws SQLException {
850     /**@todo Implement this java.sql.PreparedStatement method*/
851     throw new java.lang.UnsupportedOperationException ("Method execute() not yet implemented.");
852   }
853
854   public void addBatch() throws SQLException {
855     /**@todo Implement this java.sql.PreparedStatement method*/
856     throw new java.lang.UnsupportedOperationException ("Method addBatch() not yet implemented.");
857   }
858
859   public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
860     /**@todo Implement this java.sql.PreparedStatement method*/
861     throw new java.lang.UnsupportedOperationException (
862         "Method setCharacterStream() not yet implemented.");
863   }
864
865   public void setRef(int i, Ref x) throws SQLException {
866     /**@todo Implement this java.sql.PreparedStatement method*/
867     throw new java.lang.UnsupportedOperationException ("Method setRef() not yet implemented.");
868   }
869
870   public void setClob(int i, Clob x) throws SQLException {
871     /**@todo Implement this java.sql.PreparedStatement method*/
872     throw new java.lang.UnsupportedOperationException ("Method setClob() not yet implemented.");
873   }
874
875   public void setArray(int i, Array x) throws SQLException {
876     /**@todo Implement this java.sql.PreparedStatement method*/
877     throw new java.lang.UnsupportedOperationException ("Method setArray() not yet implemented.");
878   }
879
880   public ResultSetMetaData getMetaData() throws SQLException {
881     /**@todo Implement this java.sql.PreparedStatement method*/
882     throw new java.lang.UnsupportedOperationException ("Method getMetaData() not yet implemented.");
883   }
884
885   public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
886     /**@todo Implement this java.sql.PreparedStatement method*/
887     throw new java.lang.UnsupportedOperationException ("Method setDate() not yet implemented.");
888   }
889
890   public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
891     /**@todo Implement this java.sql.PreparedStatement method*/
892     throw new java.lang.UnsupportedOperationException ("Method setTime() not yet implemented.");
893   }
894
895   public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
896     /**@todo Implement this java.sql.PreparedStatement method*/
897     throw new java.lang.UnsupportedOperationException ("Method setTimestamp() not yet implemented.");
898   }
899
900   public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
901     this.setString(paramIndex, "null" );
902   }
903
904   public void setURL(int parameterIndex, URL x) throws SQLException {
905     /**@todo Implement this java.sql.PreparedStatement method*/
906     throw new java.lang.UnsupportedOperationException ("Method setURL() not yet implemented.");
907   }
908
909   public ParameterMetaData getParameterMetaData() throws SQLException {
910     /**@todo Implement this java.sql.PreparedStatement method*/
911     throw new java.lang.UnsupportedOperationException (
912         "Method getParameterMetaData() not yet implemented.");
913   }
914
915 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags