Java > Open Source Codes > org > webdocwf > util > i18njdbc > I18nPreparedStatement


1 /**
2     Copyright (C) 2002-2003 Together
3
4     This library is free software; you can redistribute it and/or
5     modify it under the terms of the GNU Lesser General Public
6     License as published by the Free Software Foundation; either
7     version 2.1 of the License, or (at your option) any later version.
8
9     This library is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     Lesser General Public License for more details.
13
14     You should have received a copy of the GNU Lesser General Public
15     License along with this library; if not, write to the Free Software
16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18 */
19
20
21 package org.webdocwf.util.i18njdbc;
22
23 import java.io.File ;
24 import java.io.FileInputStream ;
25 import java.io.InputStream ;
26 import java.io.Reader ;
27 import java.math.BigDecimal ;
28 import java.net.URL ;
29 import java.sql.Array ;
30 import java.sql.Blob ;
31 import java.sql.Clob ;
32 import java.sql.Connection ;
33 import java.sql.Date ;
34 import java.sql.DriverManager ;
35 import java.sql.ParameterMetaData ;
36 import java.sql.PreparedStatement ;
37 import java.sql.Ref ;
38 import java.sql.ResultSet ;
39 import java.sql.ResultSetMetaData ;
40 import java.sql.SQLException ;
41 import java.sql.SQLWarning ;
42 import java.sql.Time ;
43 import java.sql.Timestamp ;
44 import java.util.ArrayList ;
45 import java.util.Calendar ;
46 import java.util.Enumeration ;
47 import java.util.Vector ;
48
49 /**
50  * This class implements the PreparedStatement interface for the I18nJdbc driver.
51  *
52  * @author Zoran Milakovic
53  * @author Zeljko Kovacevic
54  */
55 public class I18nPreparedStatement implements PreparedStatement {
56
57   private I18nConnection connection;
58   private Vector resultSets = new Vector ();
59   private String sqlForPrepare = "";
60   private String sqlPrepared = "";
61   private int paramCount = 0;
62   private ArrayList parameters = new ArrayList ();
63   private ArrayList binaryStreamParameters = new ArrayList ();
64 /** Name used for prepared statement parameters */
65   public static String PREPARE_SEPARATOR = "~@#NEXTPARAMETER#@~";
66   private String sql;
67
68   public I18nPreparedStatement(I18nConnection connection, String preparedSql) {
69     DriverManager.println("I18nJdbc - I18nStatement() - connection=" + connection);
70     this.sqlForPrepare = preparedSql;
71     this.sqlPrepared = preparedSql;
72     this.paramCount = countParameters(preparedSql);
73     for ( int i = 0; i < paramCount; i++ )
74       parameters.add(null);
75     this.connection = connection;
76   }
77
78   private int countParameters(String sql) {
79     int count = 0;
80     int index = sql.indexOf(PREPARE_SEPARATOR);
81     while( index != -1 ) {
82       count++;
83       sql = sql.substring(index+1);
84       index = sql.indexOf(PREPARE_SEPARATOR);
85     }
86     return count;
87   }
88
89   private boolean prepareSql() throws SQLException {
90     boolean retVal = true;
91     for (int i = 0; i < parameters.size(); i++) {
92       int index = sqlPrepared.indexOf(PREPARE_SEPARATOR);
93       String val;
94       if (index != -1) {
95         if( parameters.get(i) == null )
96           val = "null";
97         else
98           val = parameters.get(i).toString();
99         sqlPrepared = sqlPrepared.substring(0, index) +
100             val +
101             sqlPrepared.substring(index + PREPARE_SEPARATOR.length());
102       }
103     }
104     if (sqlPrepared.indexOf(PREPARE_SEPARATOR) != -1)
105       throw new SQLException (
106           "All ? in prepared query has to be replaced with values.");
107     else if (parameters.size() < this.paramCount)
108       throw new SQLException (
109           "Number of setted parameters is less than number of parameters in statement.");
110     else if (parameters.size() > this.paramCount)
111       throw new SQLException (
112           "Number of setted parameters is greater than number of parameters in statement.");
113     return retVal;
114   }
115
116   /**
117      *Sets the maxFieldSize attribute of the I18nStatement object
118      *
119      * @param p0 The new maxFieldSize value
120      * @exception SQLException Description of Exception
121      * @since
122      */
123     public void setMaxFieldSize(int p0) throws SQLException
124     {
125         throw new SQLException ("Not Supported !");
126     }
127
128
129     /**
130      *Sets the maxRows attribute of the I18nStatement object
131      *
132      * @param p0 The new maxRows value
133      * @exception SQLException Description of Exception
134      * @since
135      */
136     public void setMaxRows(int p0) throws SQLException
137     {
138         throw new SQLException ("Not Supported !");
139     }
140
141
142     /**
143      *Sets the escapeProcessing attribute of the I18nStatement object
144      *
145      * @param p0 The new escapeProcessing value
146      * @exception SQLException Description of Exception
147      * @since
148      */
149     public void setEscapeProcessing(boolean p0) throws SQLException
150     {
151         throw new SQLException ("Not Supported !");
152     }
153
154
155     /**
156      *Sets the queryTimeout attribute of the I18nStatement object
157      *
158      * @param p0 The new queryTimeout value
159      * @exception SQLException Description of Exception
160      * @since
161      */
162     public void setQueryTimeout(int p0) throws SQLException
163     {
164         throw new SQLException ("Not Supported !");
165     }
166
167
168     /**
169      *Sets the cursorName attribute of the I18nStatement object
170      *
171      * @param p0 The new cursorName value
172      * @exception SQLException Description of Exception
173      * @since
174      */
175     public void setCursorName(String p0) throws SQLException
176     {
177         throw new SQLException ("Not Supported !");
178     }
179
180
181     /**
182      *Sets the fetchDirection attribute of the I18nStatement object
183      *
184      * @param p0 The new fetchDirection value
185      * @exception SQLException Description of Exception
186      * @since
187      */
188     public void setFetchDirection(int p0) throws SQLException
189     {
190         throw new SQLException ("Not Supported !");
191     }
192
193
194     /**
195      *Sets the fetchSize attribute of the I18nStatement object
196      *
197      * @param p0 The new fetchSize value
198      * @exception SQLException Description of Exception
199      * @since
200      */
201     public void setFetchSize(int p0) throws SQLException
202     {
203         throw new SQLException ("Not Supported !");
204     }
205
206
207     /**
208      *Gets the maxFieldSize attribute of the I18nStatement object
209      *
210      * @return The maxFieldSize value
211      * @exception SQLException Description of Exception
212      * @since
213      */
214     public int getMaxFieldSize() throws SQLException
215     {
216         throw new SQLException ("Not Supported !");
217     }
218
219
220     /**
221      *Gets the maxRows attribute of the I18nStatement object
222      *
223      * @return The maxRows value
224      * @exception SQLException Description of Exception
225      * @since
226      */
227     public int getMaxRows() throws SQLException
228     {
229         throw new SQLException ("Not Supported !");
230     }
231
232
233     /**
234      *Gets the queryTimeout attribute of the I18nStatement object
235      *
236      * @return The queryTimeout value
237      * @exception SQLException Description of Exception
238      * @since
239      */
240     public int getQueryTimeout() throws SQLException
241     {
242         throw new SQLException ("Not Supported !");
243     }
244
245
246     /**
247      *Gets the warnings attribute of the I18nStatement object
248      *
249      * @return The warnings value
250      * @exception SQLException Description of Exception
251      * @since
252      */
253     public SQLWarning getWarnings() throws SQLException
254     {
255         throw new SQLException ("Not Supported !");
256     }
257
258
259     /**
260      *Gets the resultSet attribute of the I18nStatement object
261      *
262      * @return The resultSet value
263      * @exception SQLException Description of Exception
264      * @since
265      */
266     public ResultSet getResultSet() throws SQLException
267     {
268         throw new SQLException ("Not Supported !");
269     }
270
271
272     /**
273      *Gets the updateCount attribute of the I18nStatement object
274      *
275      * @return The updateCount value
276      * @exception SQLException Description of Exception
277      * @since
278      */
279     public int getUpdateCount() throws SQLException
280     {
281         throw new SQLException ("Not Supported !");
282     }
283
284
285     /**
286      *Gets the moreResults attribute of the I18nStatement object
287      *
288      * @return The moreResults value
289      * @exception SQLException Description of Exception
290      * @since
291      */
292     public boolean getMoreResults() throws SQLException
293     {
294         throw new SQLException ("Not Supported !");
295     }
296
297
298     /**
299      *Gets the fetchDirection attribute of the I18nStatement object
300      *
301      * @return The fetchDirection value
302      * @exception SQLException Description of Exception
303      * @since
304      */
305     public int getFetchDirection() throws SQLException
306     {
307         throw new SQLException ("Not Supported !");
308     }
309
310
311     /**
312      *Gets the fetchSize attribute of the I18nStatement object
313      *
314      * @return The fetchSize value
315      * @exception SQLException Description of Exception
316      * @since
317      */
318     public int getFetchSize() throws SQLException
319     {
320         throw new SQLException ("Not Supported !");
321     }
322
323
324     /**
325      *Gets the resultSetConcurrency attribute of the I18nStatement object
326      *
327      * @return The resultSetConcurrency value
328      * @exception SQLException Description of Exception
329      * @since
330      */
331     public int getResultSetConcurrency() throws SQLException
332     {
333         throw new SQLException ("Not Supported !");
334     }
335
336
337     /**
338      *Gets the resultSetType attribute of the I18nStatement object
339      *
340      * @return The resultSetType value
341      * @exception SQLException Description of Exception
342      * @since
343      */
344     public int getResultSetType() throws SQLException
345     {
346         throw new SQLException ("Not Supported !");
347     }
348
349
350     /**
351      *Gets the connection attribute of the I18nStatement object
352      *
353      * @return The connection value
354      * @exception SQLException Description of Exception
355      * @since
356      */
357     public Connection getConnection() throws SQLException
358     {
359         return connection;
360     }
361
362
363     /**
364      *Description of the Method
365      *
366      * @param sql Description of Parameter
367      * @return Description of the Returned Value
368      * @exception SQLException Description of Exception
369      * @since
370      */
371     public ResultSet executeQuery(String sql) throws SQLException
372     {
373         DriverManager.println("I18nJdbc - I18nStatement:executeQuery() - sql= " + sql);
374         I18nSqlParser parser = new I18nSqlParser();
375         this.sql = sql;
376         try
377             {
378                 parser.parse(this);
379             }
380         catch (Exception e)
381             {
382                 throw new SQLException ("Syntax Error. " + e.getMessage());
383             }
384
385     String fileName = connection.getPath() + parser.getTableName() + connection.getExtension();
386     File checkFile = new File (fileName);
387     if (!checkFile.exists())
388     {
389       throw new SQLException ("Cannot open data file '" + fileName + "' !");
390     }
391
392     if (!checkFile.canRead())
393     {
394       throw new SQLException ("Data file '" + fileName + "' not readable !");
395     }
396    
397     try
398     {
399
400                 String [] xxx = parser.getColumnNames();
401               String [] yyy = connection.getColumnNames();
402               boolean isOK = true;
403               for(int i=0; i< xxx.length; i++) {
404               if(!xxx[i].endsWith("*")) {
405                out:
406               for(int j=0; j< yyy.length; j++) {
407                  if(xxx[i].equalsIgnoreCase(yyy[j])) {
408                     isOK=true;
409                     break out;
410                   }
411                   else
412                     isOK=false;
413                 }
414                if(!isOK)
415                 throw new SQLException ("Column '" + xxx[i] + "' not found.");
416               }
417               }
418     }
419     catch (Exception e)
420     {
421         if( I18nDriver.DEBUG )
422             e.printStackTrace();
423       throw new SQLException ("Error reading data file. Message was: " + e);
424     }
425     
426     this.connection.setCurrentTableName(parser.getTableName());
427     
428     //load properties file
429 try {
430         if(connection.getAutoCommit()) {
431             connection.getProperties().load(new FileInputStream (checkFile));
432         }
433     } catch (Exception e) {
434         throw new SQLException ("Error while loading properties");
435     }
436
437         I18nResultSet resultSet = new I18nResultSet(this,
438                     parser.getTableName(), parser.getColumnNames(), parser.getWhereColumnNames(),
439                     parser.getWhereColumnValues());
440     resultSets.add(resultSet);
441     return resultSet;
442   }
443
444
445
446     /**
447      *Description of the Method
448      *
449      * @param sql Description of Parameter
450      * @return Description of the Returned Value
451      * @exception SQLException Description of Exception
452      * @since
453      */
454     public int executeUpdate(String sql) throws SQLException
455    {
456    int updated=0;
457    DriverManager.println("I18nJdbc - I18nStatement:executeUpdate() - sql= " + sql);
458    I18nSqlParser parser = new I18nSqlParser();
459    this.sql = sql;
460    try
461    {
462      parser.parse(this);
463    }
464    catch (Exception e)
465    {
466      throw new SQLException ("Syntax Error. " + e.getMessage());
467    }
468      if(parser.sqlType.equals(I18nSqlParser.SELECT))
469            throw new SQLException ("Not supported SELECT statement - use executeQuery method");
470      else if (parser.sqlType.equals(I18nSqlParser.CREATE_TABLE)) {
471                throw new SQLException ("Not supported CREATE TABLE statement - use execute method");
472      }
473      else if (parser.sqlType.equals(I18nSqlParser.INSERT)) {
474           String fileName = connection.getPath() + parser.getTableName() + connection.getExtension();
475            File checkFile = new File (fileName);
476
477            if (!checkFile.exists())
478            {
479            throw new SQLException ("Cannot open data file '" + fileName + "' !");
480            }
481
482            if (!checkFile.canWrite())
483            {
484            throw new SQLException ("Data file '" + fileName + "' is read only !");
485            }
486              try
487              {
488                String [] xxx = parser.getColumnNames();
489                                String [] yyy = connection.getColumnNames();
490                boolean isOK = true;
491                for(int i=0; i< xxx.length; i++) {
492                  if(!xxx[i].endsWith("*")) {
493                  out:
494                  for(int j=0; j< yyy.length; j++) {
495                    if(xxx[i].equalsIgnoreCase(yyy[j])) {
496                      isOK=true;
497                      break out;
498                    }
499                  else
500                    isOK=false;
501                  }
502                if(!isOK)
503                  throw new SQLException ("Column '" + xxx[i] + "' not found.");
504                }
505              }
506                 try {
507                            String [] colValues = parser.columnValues;
508                            String [] colNames = parser.columnNames;
509                            String keyColumn=connection.getNameColumn();
510                            String key;
511                            String value;
512                              if (colNames.length!=colValues.length){
513                                         throw new Exception ("Number of columns and number of values are different!");
514                              }
515                            if (colNames[0].equalsIgnoreCase(keyColumn)){
516                                key = colValues[0];
517                                value = colValues[1];
518                            }else{
519                              key = colValues[1];
520                              value = colValues[0];
521                            }
522                            
523                            connection.setCurrentTableName(parser.getTableName());
524                            
525                            if(connection.getAutoCommit()) {
526                                connection.getProperties().load(new FileInputStream (checkFile));
527                            }
528                            if (connection.getProperties().containsKey(key)==true){
529                                    throw new Exception ("Key already exist in the property file. Key must be unique!");
530                            }else{
531                                connection.getProperties().put(key,value);
532                                if(connection.getAutoCommit()) {
533                                    connection.getProperties().store(checkFile);
534                                }
535                                  updated++;
536                            }
537                             
538                        } catch (Exception e) {
539                           throw new SQLException ("Error writing data to property file."+e.getMessage());
540                        }
541            }
542            catch (Exception e)
543            {
544            throw new SQLException ("Error writing data file. Message was: " + e);
545            }
546
547      }
548     else if (parser.sqlType.equals(I18nSqlParser.UPDATE)) {
549
550                String fileName = connection.getPath() + parser.getTableName() + connection.getExtension();
551            File checkFile = new File (fileName);
552
553            if (!checkFile.exists())
554            {
555            throw new SQLException ("Cannot open data file '" + fileName + "' !");
556            }
557
558            if (!checkFile.canWrite())
559            {
560            throw new SQLException ("Data file '" + fileName + "' is read only !");
561            }
562
563            try
564            {
565                String [] xxx = parser.getColumnNames();
566                String [] yyy = connection.getColumnNames();
567                boolean isOK = true;
568                for(int i=0; i< xxx.length; i++) {
569                  if(!xxx[i].endsWith("*")) {
570                    out:
571                  for(int j=0; j< yyy.length; j++) {
572                    if(xxx[i].equalsIgnoreCase(yyy[j])) {
573                      isOK=true;
574                      break out;
575                    }
576                  else
577                    isOK=false;
578                }
579                if(!isOK)
580                  throw new SQLException ("Column '" + xxx[i] + "' not found.");
581                  }
582                }
583                
584                        try {
585                               String [] colValues = parser.columnValues;
586                               String [] colNames = parser.columnNames;
587                               String [] colWhereNames = parser.columnWhereNames;
588                               String [] colWhereValues = parser.columnWhereValues;
589                               String keyColumn=connection.getNameColumn();
590                                 String valueColumn=connection.getValueColumn();
591                               String key = "";
592                               String value = "";
593                               boolean paramsOK = true;
594                               //pick up values which will be updated.This block is used if firs column is
595 // key column
596 if (colNames[0].equalsIgnoreCase(keyColumn)){
597                                       if (colValues.length==1){
598                                        key = colValues[0];
599                                       }else if (colValues.length==2){
600                                            key = colValues[0];
601                                            value = colValues[1];
602                                       }
603                                //pick up values which will be updated.This block is used if first column is
604 //value column
605 }else if (colNames[0].equalsIgnoreCase(valueColumn)){
606                                            if (colValues.length==1){
607                                                value = colValues[0];
608                                            }else if (colValues.length==2){
609                                                value = colValues[0];
610                                                key = colValues[1];
611                                            }
612                                   }
613                                  
614                                   connection.setCurrentTableName(parser.getTableName());
615                                   
616                                   if(connection.getAutoCommit()) {
617                                       connection.getProperties().load(new FileInputStream (checkFile));
618                                   }
619                                     if (!(colWhereNames[0].equalsIgnoreCase(keyColumn) || colWhereNames[0].equalsIgnoreCase(valueColumn))){
620                                             throw new SQLException ("Error in sql statement. Wrong column name!");
621                                     }
622                                    if ((!key.equalsIgnoreCase("")) && (!value.equalsIgnoreCase(""))){
623                                        Enumeration en = connection.getProperties().keys();
624                                            while(en.hasMoreElements()){
625                                                    String oldKey = en.nextElement().toString();
626                                                    String oldValue = connection.getProperties().getProperty(oldKey);
627                                                    //update key and value if this key is equal with key from where claus and also column name from where claus is equal with key column
628 //or update key and value if this value is equal with value from where claus and also column name from where claus is equal with value column
629 if ((colWhereValues[0].equalsIgnoreCase(oldKey) && keyColumn.equals(colWhereNames[0]))
630                                                            ||(colWhereValues[0].equalsIgnoreCase(oldValue) && valueColumn.equals(colWhereNames[0]))){
631                                                        connection.getProperties().remove(oldKey);
632                                                        connection.getProperties().put(key, value);
633                                                        updated++;
634                                                }
635                                            }
636                                         
637                                        }else if (!value.equalsIgnoreCase("")){
638                                 
639                                            Enumeration en = connection.getProperties().keys();
640                                                while(en.hasMoreElements()){
641                                                    String oldKey = en.nextElement().toString();
642                                                    String oldValue = connection.getProperties().getProperty(oldKey);
643                                                    //update value if this key is equal with key from where claus and also column name from where claus is equal with key column
644 //or update value if this value is equal with value from where claus and also column name from where claus is equal with value column
645 if ((colWhereValues[0].equalsIgnoreCase(oldKey) && keyColumn.equals(colWhereNames[0]))
646                                                             ||(colWhereValues[0].equalsIgnoreCase(oldValue) && valueColumn.equals(colWhereNames[0]))){
647                                                            connection.getProperties().put(oldKey,value);
648                                                            updated++;
649                                                        }
650                                                }
651                                    }else if (!key.equalsIgnoreCase("")){
652                                         
653                                                Enumeration en = connection.getProperties().keys();
654                                                while(en.hasMoreElements()){
655                                                    String oldKey = en.nextElement().toString();
656                                                    String oldValue = connection.getProperties().getProperty(oldKey);
657                                                    //update key if this key is equal with key from where claus and also column name from where claus is equal with key column
658 //or update key if this value is equal with value from where claus and also column name from where claus is equal with value column
659 if ((colWhereValues[0].equalsIgnoreCase(oldKey) && keyColumn.equals(colWhereNames[0]))
660                                                                ||(colWhereValues[0].equalsIgnoreCase(oldValue) && valueColumn.equals(colWhereNames[0]))){
661                                                        connection.getProperties().remove(oldKey);
662                                                        connection.getProperties().put(key, oldValue);
663                                                        updated++;
664                                                    }
665                                                }
666                             
667                                    }
668                           if(connection.getAutoCommit()) {
669                               connection.getProperties().store(checkFile);
670                           }
671                            //}
672 } catch (Exception e) {
673                              throw new SQLException ("Error writing data to property file."+e.getMessage());
674                           }
675                                     
676            }
677            catch (Exception e)
678            {
679            throw new SQLException ("Error writing data file. Message was: " + e);
680            }
681
682        }else if (parser.sqlType.equals(I18nSqlParser.DELETE)){
683                     String fileName = connection.getPath() + parser.getTableName() + connection.getExtension();
684                     File checkFile = new File (fileName);
685             
686                     if (!checkFile.exists())
687                     {
688                     throw new SQLException ("Cannot open data file '" + fileName + "' !");
689                     }
690             
691                     if (!checkFile.canWrite())
692                     {
693                     throw new SQLException ("Data file '" + fileName + "' is read only !");
694                     }
695                        try
696                            {
697                              
698 //// try {
699 boolean deleteAll=false;
700                                String [] colWhereNames = parser.columnWhereNames;
701                                String [] colWhereValues = parser.columnWhereValues;
702                                String keyColumn=connection.getNameColumn();
703                                String valueColumn=connection.getValueColumn();
704                                
705                                connection.setCurrentTableName(parser.getTableName());
706                                
707                                if(connection.getAutoCommit()) {
708                                    connection.getProperties().load(new FileInputStream (checkFile));
709                                }
710                                  if (!(colWhereNames[0].equalsIgnoreCase(keyColumn) || colWhereNames[0].equalsIgnoreCase(valueColumn))){
711                                             throw new SQLException ("Error in sql statement. Wrong column name!");
712                                  }
713                                Enumeration en = connection.getProperties().keys();
714                                if (colWhereNames.length==0){
715                                    deleteAll=true;
716                                }
717                                if (!deleteAll){
718                                    while(en.hasMoreElements()){
719                                        String oldKey = en.nextElement().toString();
720                                        String oldValue = connection.getProperties().getProperty(oldKey);
721                                                             
722                                                if ((colWhereValues[0].equalsIgnoreCase(oldKey) && keyColumn.equals(colWhereNames[0]))
723                                                     ||(colWhereValues[0].equalsIgnoreCase(oldValue) && valueColumn.equals(colWhereNames[0]))){
724                                                    connection.getProperties().remove(oldKey);
725                                                    if(connection.getAutoCommit()) {
726                                                        connection.getProperties().store(checkFile);
727                                                    }
728                                                    updated++;
729                                                }
730                                             
731                                    }
732                                }else{
733                                    connection.getProperties().clear();
734                                    if(connection.getAutoCommit()) {
735                                        connection.getProperties().store(checkFile);
736                                    }
737                                }
738                           } catch (Exception e) {
739                              throw new SQLException ("Error deleting data from property file."+e.getMessage());
740                        }
741
742        }
743      return updated;
744
745  }
746
747
748     /**
749      * Releases this <code>Statement</code> object's database
750      * and JDBC resources immediately instead of waiting for
751      * this to happen when it is automatically closed.
752      * It is generally good practice to release resources as soon as
753      * you are finished with them to avoid tying up database
754      * resources.
755      * <P>
756      * Calling the method <code>close</code> on a <code>Statement</code>
757      * object that is already closed has no effect.
758      * <P>
759      * <B>Note:</B> A <code>Statement</code> object is automatically closed
760      * when it is garbage collected. When a <code>Statement</code> object is
761      * closed, its current <code>ResultSet</code> object, if one exists, is
762      * also closed.
763      *
764      * @exception SQLException if a database access error occurs
765      */
766     public void close() throws SQLException {
767       // close all result sets
768 for(Enumeration i = resultSets.elements(); i.hasMoreElements(); ) {
769         I18nResultSet resultSet = (I18nResultSet) i.nextElement();
770         resultSet.close();
771       }
772      
773     }
774
775     /**
776      *Description of the Method
777      *
778      * @exception SQLException Description of Exception
779      * @since
780      */
781     public void cancel() throws SQLException
782     {
783         throw new SQLException ("Not Supported !");
784     }
785
786
787     /**
788      *Description of the Method
789      *
790      * @exception SQLException Description of Exception
791      * @since
792      */
793     public void clearWarnings() throws SQLException
794     {
795         throw new SQLException ("Not Supported !");
796     }
797
798
799     /**
800      *Description of the Method
801      *
802      * @param sql Description of Parameter
803      * @return Description of the Returned Value
804      * @exception SQLException Description of Exception
805      * @since
806      */
807     public boolean execute(String sql) throws SQLException
808   {
809     I18nSqlParser parser = new I18nSqlParser();
810     if( binaryStreamParameters.size() != 0 )
811           parser.setBinaryStreamList( binaryStreamParameters );
812     this.sql = sql;
813     try
814     {
815       parser.parse(this);
816     }
817     catch (Exception e)
818     {
819       throw new SQLException ("Syntax Error. " + e.getMessage());
820     }
821       if(parser.sqlType.equals(I18nSqlParser.SELECT))
822               throw new SQLException ("Not supported SELECT statement - use executeQuery method");
823       else if (parser.sqlType.equals(I18nSqlParser.INSERT))
824               executeUpdate(sql);
825        else if (parser.sqlType.equals(I18nSqlParser.CREATE_TABLE)) {
826              String fileName = connection.getPath() + parser.getTableName() + connection.getExtension();
827             File checkFile = new File (fileName);
828
829             if (checkFile.exists())
830             {
831               throw new SQLException ("Data file '" + fileName + "'already exists !");
832             }
833            
834             try
835             {
836                             checkFile.createNewFile();
837             
838             }
839             catch (Exception e)
840             {
841               throw new SQLException ("Error reading data file. Message was: " + e);
842             }
843         }
844         return true;
845
846   }
847
848   /**
849    * Set String as parameter in sql statement.
850    * @param parameterIndex
851    * @param value
852    * @throws SQLException
853    */
854   public void setString(int parameterIndex, String value) throws SQLException {
855     if( value == null ) {
856       I18nDriver.log("value = null object");
857       parameters.set(parameterIndex - 1, value);
858     } else {
859       value = Utils.replaceAll(value, "'", I18nSqlParser.QUOTE_ESCAPE);
860         I18nDriver.log("value = " + value);
861       parameters.set(parameterIndex - 1, "'" + value + "'");
862     }
863   }
864
865
866   /**
867    *
868    * @param parameterIndex
869    * @param value
870    * @throws SQLException
871    */
872   public void setBytes(int parameterIndex, byte[] value) throws SQLException {
873     binaryStreamParameters.add(Utils.bytesToHexString(value));
874     String paramName = I18nSqlParser.BINARY_STREAM_OBJECT+""+binaryStreamParameters.size();
875     parameters.set(parameterIndex-1, paramName);
876   }
877
878     /**
879      *Adds a feature to the Batch attribute of the I18nStatement object
880      *
881      * @param p0 The feature to be added to the Batch attribute
882      * @exception SQLException Description of Exception
883      * @since
884      */
885     public void addBatch(String p0) throws SQLException
886     {
887         throw new SQLException ("Not Supported !");
888     }
889
890
891     /**
892      *Description of the Method
893      *
894      * @exception SQLException Description of Exception
895      * @since
896      */
897     public void clearBatch() throws SQLException
898     {
899         throw new SQLException ("Not Supported !");
900     }
901
902
903     /**
904      *Description of the Method
905      *
906      * @return Description of the Returned Value
907      * @exception SQLException Description of Exception
908      * @since
909      */
910     public int[] executeBatch() throws SQLException
911     {
912         throw new SQLException ("Not Supported !");
913     }
914
915     //---------------------------------------------------------------------
916 // JDBC 3.0
917 //---------------------------------------------------------------------
918
919     public boolean getMoreResults(int current) throws SQLException {
920         throw new UnsupportedOperationException ("Statement.getMoreResults(int) unsupported");
921     }
922
923     public ResultSet getGeneratedKeys() throws SQLException {
924         throw new UnsupportedOperationException ("Statement.getGeneratedKeys() unsupported");
925     }
926
927     public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
928         throw new UnsupportedOperationException ("Statement.executeUpdate(String,int) unsupported");
929     }
930
931     public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
932         throw new UnsupportedOperationException ("Statement.executeUpdate(String,int[]) unsupported");
933     }
934
935     public int executeUpdate(String sql, String [] columnNames) throws SQLException {
936         throw new UnsupportedOperationException ("Statement.executeUpdate(String,String[]) unsupported");
937     }
938
939     public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
940         throw new UnsupportedOperationException ("Statement.execute(String,int) unsupported");
941     }
942
943     public boolean execute(String sql, int[] columnIndexes) throws SQLException {
944         throw new UnsupportedOperationException ("Statement.execute(String,int[]) unsupported");
945     }
946
947     public boolean execute(String sql, String [] columnNames) throws SQLException {
948         throw new UnsupportedOperationException ("Statement.execute(String,String[]) unsupported");
949     }
950
951     public int getResultSetHoldability() throws SQLException {
952         throw new UnsupportedOperationException ("Statement.getResultSetHoldability() unsupported");
953     }
954
955
956
957   public ResultSet executeQuery() throws SQLException {
958     if( !prepareSql())
959         throw new SQLException ("Error with prepared statement !");
960     return executeQuery(this.sqlPrepared);
961
962   }
963   public int executeUpdate() throws SQLException {
964     if( !prepareSql())
965         throw new SQLException ("Error with prepared statement !");
966     executeUpdate(this.sqlPrepared);
967     return 0;
968   }
969
970
971
972
973
974   public void setNull(int parameterIndex, int sqlType) throws SQLException {
975     this.setString(parameterIndex, null );
976   }
977
978   public void setBoolean(int parameterIndex, boolean value) throws SQLException {
979     this.setString(parameterIndex, String.valueOf(value) );
980   }
981
982   public void setByte(int parameterIndex, byte value) throws SQLException {
983     this.setString(parameterIndex, String.valueOf(value) );
984   }
985
986   public void setShort(int parameterIndex, short value) throws SQLException {
987     this.setString(parameterIndex, String.valueOf(value) );
988   }
989
990   public void setInt(int parameterIndex, int value) throws SQLException {
991     this.setString(parameterIndex, String.valueOf(value) );
992   }
993
994   public void setLong(int parameterIndex, long value) throws SQLException {
995     this.setString(parameterIndex, String.valueOf(value) );
996   }
997
998   public void setFloat(int parameterIndex, float value) throws SQLException {
999     this.setString(parameterIndex, String.valueOf(value) );
1000  }
1001
1002  public void setDouble(int parameterIndex, double value) throws SQLException {
1003    this.setString(parameterIndex, String.valueOf(value) );
1004  }
1005
1006  public void setBigDecimal(int parameterIndex, BigDecimal value) throws SQLException {
1007      if(value == null) {
1008          this.setString( parameterIndex, value.toString() );
1009      } else {
1010          this.setString( parameterIndex, "" );
1011      }
1012  }
1013  
1014  public void setDate(int parameterIndex, Date value) throws SQLException {
1015      if(value == null) {
1016          this.setString( parameterIndex, value.toString() );
1017      } else {
1018          this.setString( parameterIndex, "" );
1019      }
1020  }
1021  
1022  public void setTime(int parameterIndex, Time value) throws SQLException {
1023      if(value == null) {
1024          this.setString( parameterIndex, value.toString() );
1025      } else {
1026          this.setString( parameterIndex, "" );
1027      }
1028  }
1029  
1030  public void setTimestamp(int parameterIndex, Timestamp value) throws SQLException {
1031      if(value == null) {
1032          this.setString( parameterIndex, value.toString() );
1033      } else {
1034          this.setString( parameterIndex, "" );
1035      }
1036  }
1037  
1038  public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
1039    /**@todo Implement this java.sql.PreparedStatement method*/
1040    throw new java.lang.UnsupportedOperationException ("Method setAsciiStream() not yet implemented.");
1041  }
1042  public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
1043    /**@todo Implement this java.sql.PreparedStatement method*/
1044    throw new java.lang.UnsupportedOperationException ("Method setUnicodeStream() not yet implemented.");
1045  }
1046
1047  public void clearParameters() throws SQLException {
1048    this.sqlPrepared = this.sqlForPrepare;
1049    for(int i = 0; i < parameters.size(); i++)
1050      parameters.set(i, null);
1051  }
1052  public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
1053    /**@todo Implement this java.sql.PreparedStatement method*/
1054    throw new java.lang.UnsupportedOperationException ("Method setObject() not yet implemented.");
1055  }
1056  public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
1057    /**@todo Implement this java.sql.PreparedStatement method*/
1058    throw new java.lang.UnsupportedOperationException ("Method setObject() not yet implemented.");
1059  }
1060  public void setObject(int parameterIndex, Object x) throws SQLException {
1061    if( x == null )
1062       x = new String ("null");
1063     setString( parameterIndex, x.toString() );
1064  }
1065  public boolean execute() throws SQLException {
1066    /**@todo Implement this java.sql.PreparedStatement method*/
1067    throw new java.lang.UnsupportedOperationException ("Method execute() not yet implemented.");
1068  }
1069  public void addBatch() throws SQLException {
1070    /**@todo Implement this java.sql.PreparedStatement method*/
1071    throw new java.lang.UnsupportedOperationException ("Method addBatch() not yet implemented.");
1072  }
1073  public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
1074    /**@todo Implement this java.sql.PreparedStatement method*/
1075    throw new java.lang.UnsupportedOperationException ("Method setCharacterStream() not yet implemented.");
1076  }
1077  public void setRef(int i, Ref x) throws SQLException {
1078    /**@todo Implement this java.sql.PreparedStatement method*/
1079    throw new java.lang.UnsupportedOperationException ("Method setRef() not yet implemented.");
1080  }
1081
1082  public void setClob(int i, Clob x) throws SQLException {
1083    /**@todo Implement this java.sql.PreparedStatement method*/
1084    throw new java.lang.UnsupportedOperationException ("Method setClob() not yet implemented.");
1085  }
1086  public void setArray(int i, Array x) throws SQLException {
1087    /**@todo Implement this java.sql.PreparedStatement method*/
1088    throw new java.lang.UnsupportedOperationException ("Method setArray() not yet implemented.");
1089  }
1090  public ResultSetMetaData getMetaData() throws SQLException {
1091    /**@todo Implement this java.sql.PreparedStatement method*/
1092    throw new java.lang.UnsupportedOperationException ("Method getMetaData() not yet implemented.");
1093  }
1094  public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
1095    /**@todo Implement this java.sql.PreparedStatement method*/
1096    throw new java.lang.UnsupportedOperationException ("Method setDate() not yet implemented.");
1097  }
1098  public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
1099    /**@todo Implement this java.sql.PreparedStatement method*/
1100    throw new java.lang.UnsupportedOperationException ("Method setTime() not yet implemented.");
1101  }
1102  public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
1103    /**@todo Implement this java.sql.PreparedStatement method*/
1104    throw new java.lang.UnsupportedOperationException ("Method setTimestamp() not yet implemented.");
1105  }
1106  public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
1107    this.setString(paramIndex, null );
1108  }
1109
1110  public void setURL(int parameterIndex, URL x) throws SQLException {
1111    /**@todo Implement this java.sql.PreparedStatement method*/
1112    throw new java.lang.UnsupportedOperationException (
1113        "Method setURL() not yet implemented.");
1114  }
1115
1116  public ParameterMetaData getParameterMetaData() throws SQLException {
1117    /**@todo Implement this java.sql.PreparedStatement method*/
1118    throw new java.lang.UnsupportedOperationException (
1119        "Method getParameterMetaData() not yet implemented.");
1120  }
1121
1122  public void setBinaryStream(int parameterIndex, InputStream value, int length) throws
1123      SQLException {
1124    /**@todo Implement this java.sql.PreparedStatement method*/
1125    throw new java.lang.UnsupportedOperationException (
1126        "Method setBinaryStream() not yet implemented.");
1127  }
1128
1129  public void setBlob(int parameterIndex, Blob value) throws SQLException {
1130    /**@todo Implement this java.sql.PreparedStatement method*/
1131    throw new java.lang.UnsupportedOperationException (
1132        "Method setBlob() not yet implemented.");
1133  }
1134
1135  public String getSqlStatement() {
1136      return sql;
1137    }
1138    
1139  public I18nProperties getProperties() {
1140       return connection.getProperties();
1141  }
1142
1143}

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags