View Javadoc
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