KickJava   Java API By Example, From Geeks To Geeks.

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


1 /*
2     Copyright (C) 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 package org.webdocwf.util.xml;
20
21 import java.sql.*;
22 import java.io.File JavaDoc;
23 import java.io.RandomAccessFile JavaDoc;
24 import java.util.Enumeration JavaDoc;
25 //import java.util.Vector;
26
import java.util.ArrayList JavaDoc;
27
28 /**
29  * Class implements the JDBC Statement interface for the XmlJdbc driver.
30  *
31  * @author Zoran Milakovic
32  */

33
34 public class XmlStatement implements Statement
35 {
36   private XmlConnection connection;
37   private String JavaDoc fileName;
38
39
40   /**
41    *Constructor for the XmlStatement object
42    *
43    * @param connection Description of Parameter
44    * @since
45    */

46   protected XmlStatement(XmlConnection connection)
47   {
48     DriverManager.println("XmlJdbc - XmlStatement() - connection=" + connection);
49     this.connection = connection;
50     this.fileName = connection.getPath() + connection.getExtension();
51   }
52
53
54   /**
55    *Sets the maxFieldSize attribute of the SmlStatement object
56    *
57    * @param p0 The new maxFieldSize value
58    * @exception SQLException Description of Exception
59    * @since
60    */

61   public void setMaxFieldSize(int p0) throws SQLException
62   {
63     throw new SQLException("Not Supported !");
64   }
65
66
67   /**
68    *Sets the maxRows attribute of the XmlStatement object
69    *
70    * @param p0 The new maxRows value
71    * @exception SQLException Description of Exception
72    * @since
73    */

74   public void setMaxRows(int p0) throws SQLException
75   {
76     throw new SQLException("Not Supported !");
77   }
78
79
80   /**
81    *Sets the escapeProcessing attribute of the XmlStatement object
82    *
83    * @param p0 The new escapeProcessing value
84    * @exception SQLException Description of Exception
85    * @since
86    */

87   public void setEscapeProcessing(boolean p0) throws SQLException
88   {
89     throw new SQLException("Not Supported !");
90   }
91
92
93   /**
94    *Sets the queryTimeout attribute of the XmlStatement object
95    *
96    * @param p0 The new queryTimeout value
97    * @exception SQLException Description of Exception
98    * @since
99    */

100   public void setQueryTimeout(int p0) throws SQLException
101   {
102     throw new SQLException("Not Supported !");
103   }
104
105
106   /**
107    *Sets the cursorName attribute of the XmlStatement object
108    *
109    * @param p0 The new cursorName value
110    * @exception SQLException Description of Exception
111    * @since
112    */

113   public void setCursorName(String JavaDoc p0) throws SQLException
114   {
115     throw new SQLException("Not Supported !");
116   }
117
118
119   /**
120    *Sets the fetchDirection attribute of the XmlStatement object
121    *
122    * @param p0 The new fetchDirection value
123    * @exception SQLException Description of Exception
124    * @since
125    */

126   public void setFetchDirection(int p0) throws SQLException
127   {
128     throw new SQLException("Not Supported !");
129   }
130
131
132   /**
133    *Sets the fetchSize attribute of the XmlStatement object
134    *
135    * @param p0 The new fetchSize value
136    * @exception SQLException Description of Exception
137    * @since
138    */

139   public void setFetchSize(int p0) throws SQLException
140   {
141     throw new SQLException("Not Supported !");
142   }
143
144
145   /**
146    *Gets the maxFieldSize attribute of the XmlStatement object
147    *
148    * @return The maxFieldSize value
149    * @exception SQLException Description of Exception
150    * @since
151    */

152   public int getMaxFieldSize() throws SQLException
153   {
154     throw new SQLException("Not Supported !");
155   }
156
157
158   /**
159    *Gets the maxRows attribute of the XmlStatement object
160    *
161    * @return The maxRows value
162    * @exception SQLException Description of Exception
163    * @since
164    */

165   public int getMaxRows() throws SQLException
166   {
167     throw new SQLException("Not Supported !");
168   }
169
170
171   /**
172    *Gets the queryTimeout attribute of the XmlStatement object
173    *
174    * @return The queryTimeout value
175    * @exception SQLException Description of Exception
176    * @since
177    */

178   public int getQueryTimeout() throws SQLException
179   {
180     throw new SQLException("Not Supported !");
181   }
182
183
184   /**
185    *Gets the warnings attribute of the XmlStatement object
186    *
187    * @return The warnings value
188    * @exception SQLException Description of Exception
189    * @since
190    */

191   public SQLWarning getWarnings() throws SQLException
192   {
193     throw new SQLException("Not Supported !");
194   }
195
196
197   /**
198    *Gets the resultSet attribute of the XmlStatement object
199    *
200    * @return The resultSet value
201    * @exception SQLException Description of Exception
202    * @since
203    */

204   public ResultSet getResultSet() throws SQLException
205   {
206     throw new SQLException("Not Supported !");
207   }
208
209
210   /**
211    *Gets the updateCount attribute of the XmlStatement object
212    *
213    * @return The updateCount value
214    * @exception SQLException Description of Exception
215    * @since
216    */

217   public int getUpdateCount() throws SQLException
218   {
219     throw new SQLException("Not Supported !");
220   }
221
222
223   /**
224    *Gets the moreResults attribute of the XmlStatement object
225    *
226    * @return The moreResults value
227    * @exception SQLException Description of Exception
228    * @since
229    */

230   public boolean getMoreResults() throws SQLException
231   {
232     throw new SQLException("Not Supported !");
233   }
234
235
236   /**
237    *Gets the fetchDirection attribute of the XmlStatement object
238    *
239    * @return The fetchDirection value
240    * @exception SQLException Description of Exception
241    * @since
242    */

243   public int getFetchDirection() throws SQLException
244   {
245     throw new SQLException("Not Supported !");
246   }
247
248
249   /**
250    *Gets the fetchSize attribute of the XmlStatement object
251    *
252    * @return The fetchSize value
253    * @exception SQLException Description of Exception
254    * @since
255    */

256   public int getFetchSize() throws SQLException
257   {
258     throw new SQLException("Not Supported !");
259   }
260
261
262   /**
263    *Gets the resultSetConcurrency attribute of the XmlStatement object
264    *
265    * @return The resultSetConcurrency value
266    * @exception SQLException Description of Exception
267    * @since
268    */

269   public int getResultSetConcurrency() throws SQLException
270   {
271     throw new SQLException("Not Supported !");
272   }
273
274
275   /**
276    *Gets the resultSetType attribute of the XmlStatement object
277    *
278    * @return The resultSetType value
279    * @exception SQLException Description of Exception
280    * @since
281    */

282   public int getResultSetType() throws SQLException
283   {
284     throw new SQLException("Not Supported !");
285   }
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   {
297     return connection;
298   }
299
300
301   /**
302    *Description of the Method
303    *
304    * @param sql Sql statement
305    * @return ResultSet
306    * @exception SQLException
307    * @since
308    */

309   public ResultSet executeQuery(String JavaDoc sql) throws SQLException
310   {
311     DriverManager.println("XmlJdbc - XmlStatement:executeQuery() - sql= " + sql);
312     XmlWriter writer;
313     if( this.connection.getAutoCommit() )
314       writer = new XmlWriter(fileName,true);
315     else
316       writer = new XmlWriter(fileName,false);
317     XmlSqlParser parser = new XmlSqlParser( this.fileName, this.connection.getAutoCommit() );
318     try
319     {
320       parser.parse(sql);
321     }
322     catch (Exception JavaDoc e)
323     {
324       throw new SQLException("Syntax Error. " + e.getMessage());
325     }
326     if (parser.sqlType.equals(parser.DROP_TABLE)) {
327       execute(sql);
328       return null;
329     }
330     if (parser.sqlType.equals(parser.DELETE)) {
331       executeUpdate(sql);
332       return null;
333     }
334     if (parser.sqlType.equals(parser.UPDATE)) {
335       executeUpdate(sql);
336       return null;
337     }
338     else if (parser.sqlType.equals(parser.INSERT)) {
339       executeUpdate(sql);
340       return null;
341     }
342     else if (parser.sqlType.equals(parser.CREATE_TABLE)) {
343       execute( sql );
344       return null;
345     } else if(parser.sqlType.equals(parser.SELECT) ) {
346
347     String JavaDoc fileName = connection.getPath() + connection.getExtension();
348     File JavaDoc checkFile = new File JavaDoc(fileName);
349     XmlReader reader;
350     try
351     {
352       reader = new XmlReader(fileName);
353       String JavaDoc[] xxx = parser.getColumnNames();
354       String JavaDoc[] yyy = (String JavaDoc[])writer.getTableProperties( parser.getTableName() ).get(0);
355       boolean isOK = true;
356       for(int i=0; i< xxx.length; i++) {
357         out:
358       for(int j=0; j< yyy.length; j++) {
359         if(xxx[i].equalsIgnoreCase(yyy[j])) {
360           isOK=true;
361           break out;
362         }
363         else
364           isOK=false;
365       }
366       if(!isOK)
367         throw new SQLException("Column '" + xxx[i] + "' not found in table "+parser.getTableName());
368       }
369     }
370     catch (Exception JavaDoc e)
371     {
372       throw new SQLException("Error reading data file. Message was: " + e);
373     }
374     XmlResultSet resultSet = new XmlResultSet(this, reader,
375         parser.getTableName(), parser.getColumnNames() , parser.getWhereColumnNames() , parser.getWhereColumnValues());
376     resultSet.select();
377     return resultSet;
378     } else {
379       throw new SQLException("Syntax error.Not supported sql statement.");
380     }
381   }
382
383
384
385   /**
386    * Insert data into XML database
387    *
388    * @param sql Description of Parameter
389    * @return Description of the Returned Value
390    * @exception SQLException Description of Exception
391    * @since
392    */

393   public int executeUpdate(String JavaDoc sql) throws SQLException
394   {
395     DriverManager.println("XmlJdbc - XmlStatement:executeUpdate() - sql= " + sql);
396     XmlSqlParser parser = new XmlSqlParser();
397     try
398     {
399       parser.parse(sql);
400     }
401     catch (Exception JavaDoc e)
402     {
403       throw new SQLException("Syntax Error. " + e.getMessage());
404     }
405     if(parser.sqlType.equals(parser.SELECT))
406       throw new SQLException("Not supported SELECT statement - use executeQuery() method");
407     else if (parser.sqlType.equals(parser.CREATE_TABLE)) {
408       throw new SQLException("Not supported CREATE_TABLE statement - use execute() method");
409     }
410     else if (parser.sqlType.equals(parser.DROP_TABLE)) {
411       throw new SQLException("Not supported DROP_TABLE statement - use execute() method");
412     }
413     else if (parser.sqlType.equals(parser.INSERT)) {
414       String JavaDoc fileName = connection.getPath() + connection.getExtension();
415       XmlWriter writeXml;
416       try
417       {
418         if( this.connection.getAutoCommit() )
419           writeXml = new XmlWriter(fileName,true);
420         else
421           writeXml = new XmlWriter(fileName,false);
422         ArrayList JavaDoc properties = writeXml.getTableProperties( parser.tableName );
423         //check for existance of columns
424
String JavaDoc[] xxx = parser.getColumnNames();
425         String JavaDoc[] yyy = (String JavaDoc[])properties.get(0);
426         boolean isOK = true;
427         for(int i=0; i< xxx.length; i++) {
428           if(!xxx[i].endsWith("*")) {
429             out:
430         for(int j=0; j< yyy.length; j++) {
431           if(xxx[i].equalsIgnoreCase(yyy[j])) {
432             isOK=true;
433             break out;
434           }
435           else
436             isOK=false;
437         }
438         if(!isOK)
439           throw new SQLException("Column '" + xxx[i] + "' not found in table "+parser.getTableName());
440           }
441         }
442         //check if NOTNULL columns is set
443
if( !properties.get(1).toString().equalsIgnoreCase("NO CREATE TABLE") ) {
444           yyy = parser.getColumnNames();
445           xxx = (String JavaDoc[])writeXml.getTableProperties( parser.tableName ).get(2);
446           isOK = true;
447           for(int i=0; i< xxx.length; i++) {
448             out:
449           for(int j=0; j< yyy.length; j++) {
450             if(xxx[i].equalsIgnoreCase(yyy[j])) {
451               isOK=true;
452               break out;
453             }
454             else
455               isOK=false;
456           }
457           if(!isOK)
458             throw new SQLException("Column '" + xxx[i] + "' can not be NULL.");
459           }
460         }
461         writeXml.insert( parser.getTableName() , parser.getColumnNames() , parser.getColumnValues() );
462
463       }
464       catch (Exception JavaDoc e)
465       {
466         throw new SQLException("Error reading data file. Message was: " + e);
467       }
468
469     }
470     else if (parser.sqlType.equals(parser.UPDATE)) {
471       String JavaDoc fileName = connection.getPath() + connection.getExtension();
472       XmlWriter writeXml;
473       try
474       {
475         if( this.connection.getAutoCommit() )
476           writeXml = new XmlWriter(fileName,true);
477         else
478           writeXml = new XmlWriter(fileName,false);
479         String JavaDoc[] xxx = parser.getColumnNames();
480         String JavaDoc[] yyy = (String JavaDoc[])writeXml.getTableProperties( parser.tableName ).get(0);
481         boolean isOK = true;
482         for(int i=0; i< xxx.length; i++) {
483           if(!xxx[i].endsWith("*")) {
484             out:
485         for(int j=0; j< yyy.length; j++) {
486           if(xxx[i].equalsIgnoreCase(yyy[j])) {
487             isOK=true;
488             break out;
489           }
490           else
491             isOK=false;
492         }
493         if(!isOK)
494           throw new SQLException("Column '" + xxx[i] + "' not found in table "+parser.getTableName());
495           }
496         }
497         writeXml.update( parser.getTableName() , parser.getColumnNames() , parser.getColumnValues() , parser.getWhereColumnNames() , parser.getWhereColumnValues() );
498       }
499       catch (Exception JavaDoc e)
500       {
501         throw new SQLException("Error reading data file. Message was: " + e);
502       }
503
504     }
505     else if (parser.sqlType.equals(parser.DELETE)) {
506       String JavaDoc fileName = connection.getPath() + connection.getExtension();
507       XmlWriter writeXml;
508       try
509       {
510         if( this.connection.getAutoCommit() )
511           writeXml = new XmlWriter(fileName,true);
512         else
513           writeXml = new XmlWriter(fileName,false);
514         String JavaDoc[] xxx = parser.getWhereColumnNames();
515         String JavaDoc[] yyy = (String JavaDoc[])writeXml.getTableProperties( parser.tableName ).get(0);
516         boolean isOK = true;
517         for(int i=0; i< xxx.length; i++) {
518           if(!xxx[i].endsWith("*")) {
519             out:
520         for(int j=0; j< yyy.length; j++) {
521           if(xxx[i].equalsIgnoreCase(yyy[j])) {
522             isOK=true;
523             break out;
524           }
525           else
526             isOK=false;
527         }
528         if(!isOK)
529           throw new SQLException("Column '" + xxx[i] + "' not found in table "+parser.getTableName());
530           }
531         }
532         writeXml.delete( parser.getTableName() , parser.getWhereColumnNames() , parser.getWhereColumnValues() );
533       }
534       catch (Exception JavaDoc e)
535       {
536         throw new SQLException("Error reading data file. Message was: " + e);
537       }
538
539     }
540     else if (parser.sqlType.equals(parser.DROP_TABLE)) {
541     }
542     return 0;
543
544
545   }
546
547
548   /**
549    * Releases this <code>Statement</code> object's database
550    * and JDBC resources immediately instead of waiting for
551    * this to happen when it is automatically closed.
552    * It is generally good practice to release resources as soon as
553    * you are finished with them to avoid tying up database
554    * resources.
555    * <P>
556    * Calling the method <code>close</code> on a <code>Statement</code>
557    * object that is already closed has no effect.
558    * <P>
559    * <B>Note:</B> A <code>Statement</code> object is automatically closed
560    * when it is garbage collected. When a <code>Statement</code> object is
561    * closed, its current <code>ResultSet</code> object, if one exists, is
562    * also closed.
563    *
564    * @exception SQLException if a database access error occurs
565    */

566   public void close() throws SQLException {
567
568   }
569
570
571   /**
572    *Description of the Method
573    *
574    * @exception SQLException Description of Exception
575    * @since
576    */

577   public void cancel() throws SQLException
578   {
579     throw new SQLException("Not Supported !");
580   }
581
582
583   /**
584    *Description of the Method
585    *
586    * @exception SQLException Description of Exception
587    * @since
588    */

589   public void clearWarnings() throws SQLException
590   {
591     throw new SQLException("Not Supported !");
592   }
593
594
595   /**
596    *Description of the Method
597    *
598    * @param sql Description of Parameter
599    * @return Description of the Returned Value
600    * @exception SQLException Description of Exception
601    * @since
602    */

603   public boolean execute(String JavaDoc sql) throws SQLException
604   {
605     XmlWriter writeXml;
606     if( this.connection.getAutoCommit() )
607       writeXml = new XmlWriter(fileName,true);
608     else
609       writeXml = new XmlWriter(fileName,false);
610     XmlSqlParser parser = new XmlSqlParser( this.fileName, this.connection.getAutoCommit() );
611     try
612     {
613       parser.parse(sql);
614     }
615     catch (Exception JavaDoc e)
616     {
617       throw new SQLException("Syntax Error. " + e.getMessage());
618     }
619     if(parser.sqlType.equals(parser.SELECT))
620       throw new SQLException("Use executeQuery() for SELECT statement");
621     else if (parser.sqlType.equals(parser.UPDATE))
622       executeUpdate(sql);
623     else if (parser.sqlType.equals(parser.INSERT))
624       executeUpdate(sql);
625     else if (parser.sqlType.equals(parser.DELETE))
626       executeUpdate(sql);
627     else if (parser.sqlType.equals(parser.CREATE_TABLE)) {
628       String JavaDoc fileName = connection.getPath() + connection.getExtension();
629       try
630       {
631         writeXml.createTable( parser.getSqlStatement() , parser.getTableName() );
632       }
633       catch (Exception JavaDoc e)
634       {
635         throw new SQLException("Error reading data file. Message was: " + e);
636       }
637     } else if (parser.sqlType.equals(parser.DROP_TABLE)) {
638       String JavaDoc fileName = connection.getPath() + connection.getExtension();
639       try
640       {
641         writeXml.dropTable( parser.getTableName() );
642       }
643       catch (Exception JavaDoc e)
644       {
645         throw new SQLException("Error reading data file. Message was: " + e);
646       }
647     }
648     return true;
649
650   }
651
652
653
654   /**
655    *Adds a feature to the Batch attribute of the XmlStatement object
656    *
657    * @param p0 The feature to be added to the Batch attribute
658    * @exception SQLException Description of Exception
659    * @since
660    */

661   public void addBatch(String JavaDoc p0) throws SQLException
662   {
663     throw new SQLException("Not Supported !");
664   }
665
666
667   /**
668    *Description of the Method
669    *
670    * @exception SQLException Description of Exception
671    * @since
672    */

673   public void clearBatch() throws SQLException
674   {
675     throw new SQLException("Not Supported !");
676   }
677
678
679   /**
680    *Description of the Method
681    *
682    * @return Description of the Returned Value
683    * @exception SQLException Description of Exception
684    * @since
685    */

686   public int[] executeBatch() throws SQLException
687   {
688     throw new SQLException("Not Supported !");
689   }
690
691   //---------------------------------------------------------------------
692
// JDBC 3.0
693
//---------------------------------------------------------------------
694

695   public boolean getMoreResults(int current) throws SQLException {
696     throw new UnsupportedOperationException JavaDoc("Statement.getMoreResults(int) unsupported");
697   }
698
699   public ResultSet getGeneratedKeys() throws SQLException {
700     throw new UnsupportedOperationException JavaDoc("Statement.getGeneratedKeys() unsupported");
701   }
702
703   public int executeUpdate(String JavaDoc sql, int autoGeneratedKeys) throws SQLException {
704     throw new UnsupportedOperationException JavaDoc("Statement.executeUpdate(String,int) unsupported");
705   }
706
707   public int executeUpdate(String JavaDoc sql, int[] columnIndexes) throws SQLException {
708     throw new UnsupportedOperationException JavaDoc("Statement.executeUpdate(String,int[]) unsupported");
709   }
710
711   public int executeUpdate(String JavaDoc sql, String JavaDoc[] columnNames) throws SQLException {
712     throw new UnsupportedOperationException JavaDoc("Statement.executeUpdate(String,String[]) unsupported");
713   }
714
715   public boolean execute(String JavaDoc sql, int autoGeneratedKeys) throws SQLException {
716     throw new UnsupportedOperationException JavaDoc("Statement.execute(String,int) unsupported");
717   }
718
719   public boolean execute(String JavaDoc sql, int[] columnIndexes) throws SQLException {
720     throw new UnsupportedOperationException JavaDoc("Statement.execute(String,int[]) unsupported");
721   }
722
723   public boolean execute(String JavaDoc sql, String JavaDoc[] columnNames) throws SQLException {
724     throw new UnsupportedOperationException JavaDoc("Statement.execute(String,String[]) unsupported");
725   }
726
727   public int getResultSetHoldability() throws SQLException {
728     throw new UnsupportedOperationException JavaDoc("Statement.getResultSetHoldability() unsupported");
729   }
730
731 }
732
Popular Tags