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