View Javadoc
1 2 package org.webdocwf.util.xml; 3 4 import java.sql.CallableStatement; 5 import java.sql.Connection; 6 import java.sql.DatabaseMetaData; 7 import java.sql.PreparedStatement; 8 import java.sql.SQLException; 9 import java.sql.SQLWarning; 10 import java.sql.Savepoint; 11 import java.sql.Statement; 12 import java.util.Enumeration; 13 import java.util.Hashtable; 14 import java.util.Map; 15 import java.util.Properties; 16 //import java.util.Vector; 17 import java.util.ArrayList; 18 19 20 public class XmlConnection implements Connection { 21 22 /*** Directory where the XML files to use are located */ 23 private String path; 24 25 /*** File extension to use */ 26 private String extension = XmlDriver.DEFAULT_EXTENSION; 27 28 29 /*** Collection of all created Statements */ 30 private ArrayList statements = new ArrayList(); 31 32 /*** Charset that should be used to read the files */ 33 private String charset = null; 34 35 /*** Stores whether this Connection is closed or not */ 36 private boolean closed; 37 38 /*** 39 * Creates a new XmlConnection that takes the supplied path 40 * @param path directory where the XML files are located 41 */ 42 protected XmlConnection(String path) { 43 // validate argument(s) 44 if(path == null || path.length() == 0) { 45 throw new IllegalArgumentException( 46 "'path' argument may not be empty or null"); 47 } 48 this.path = path; 49 } 50 51 /*** 52 * Creates a new XmlConnection that takes the supplied path and properties 53 * @param path directory where the XML files are located 54 * @param info set of properties containing custom options 55 */ 56 protected XmlConnection(String path, Properties info) { 57 this(path); 58 // check for properties 59 if(info != null) { 60 // set the file extension to be used 61 if(info.getProperty(XmlDriver.FILE_EXTENSION) != null) { 62 extension = info.getProperty(XmlDriver.FILE_EXTENSION); 63 } 64 65 } 66 } 67 68 /*** 69 * Creates a <code>Statement</code> object for sending 70 * SQL statements to the database. 71 * SQL statements without parameters are normally 72 * executed using <code>Statement</code> objects. If the same SQL statement 73 * is executed many times, it may be more efficient to use a 74 * <code>PreparedStatement</code> object. 75 * <P> 76 * Result sets created using the returned <code>Statement</code> 77 * object will by default be type <code>TYPE_FORWARD_ONLY</code> 78 * and have a concurrency level of <code>CONCUR_READ_ONLY</code>. 79 * 80 * @return a new default <code>Statement</code> object 81 * @exception SQLException if a database access error occurs 82 */ 83 public Statement createStatement() throws SQLException { 84 XmlStatement statement = new XmlStatement(this); 85 statements.add(statement); 86 return statement; 87 } 88 89 /*** 90 * Creates a <code>PreparedStatement</code> object for sending 91 * parameterized SQL statements to the database. 92 * <P> 93 * A SQL statement with or without IN parameters can be 94 * pre-compiled and stored in a <code>PreparedStatement</code> object. This 95 * object can then be used to efficiently execute this statement 96 * multiple times. 97 * 98 * <P><B>Note:</B> This method is optimized for handling 99 * parametric SQL statements that benefit from precompilation. If 100 * the driver supports precompilation, 101 * the method <code>prepareStatement</code> will send 102 * the statement to the database for precompilation. Some drivers 103 * may not support precompilation. In this case, the statement may 104 * not be sent to the database until the <code>PreparedStatement</code> 105 * object is executed. This has no direct effect on users; however, it does 106 * affect which methods throw certain <code>SQLException</code> objects. 107 * <P> 108 * Result sets created using the returned <code>PreparedStatement</code> 109 * object will by default be type <code>TYPE_FORWARD_ONLY</code> 110 * and have a concurrency level of <code>CONCUR_READ_ONLY</code>. 111 * 112 * @param sql an SQL statement that may contain one or more '?' IN 113 * parameter placeholders 114 * @return a new default <code>PreparedStatement</code> object containing the 115 * pre-compiled SQL statement 116 * @exception SQLException if a database access error occurs 117 */ 118 public PreparedStatement prepareStatement(String sql) throws SQLException { 119 throw new UnsupportedOperationException( 120 "Connection.prepareStatement(String) unsupported"); 121 } 122 123 /*** 124 * Creates a <code>CallableStatement</code> object for calling 125 * database stored procedures. 126 * The <code>CallableStatement</code> object provides 127 * methods for setting up its IN and OUT parameters, and 128 * methods for executing the call to a stored procedure. 129 * 130 * <P><B>Note:</B> This method is optimized for handling stored 131 * procedure call statements. Some drivers may send the call 132 * statement to the database when the method <code>prepareCall</code> 133 * is done; others 134 * may wait until the <code>CallableStatement</code> object 135 * is executed. This has no 136 * direct effect on users; however, it does affect which method 137 * throws certain SQLExceptions. 138 * <P> 139 * Result sets created using the returned <code>CallableStatement</code> 140 * object will by default be type <code>TYPE_FORWARD_ONLY</code> 141 * and have a concurrency level of <code>CONCUR_READ_ONLY</code>. 142 * 143 * @param sql an SQL statement that may contain one or more '?' 144 * parameter placeholders. Typically this statement is a JDBC 145 * function call escape string. 146 * @return a new default <code>CallableStatement</code> object containing the 147 * pre-compiled SQL statement 148 * @exception SQLException if a database access error occurs 149 */ 150 public CallableStatement prepareCall(String sql) throws SQLException { 151 throw new UnsupportedOperationException( 152 "Connection.prepareCall(String) unsupported"); 153 } 154 155 /*** 156 * Converts the given SQL statement into the system's native SQL grammar. 157 * A driver may convert the JDBC SQL grammar into its system's 158 * native SQL grammar prior to sending it. This method returns the 159 * native form of the statement that the driver would have sent. 160 * 161 * @param sql an SQL statement that may contain one or more '?' 162 * parameter placeholders 163 * @return the native form of this statement 164 * @exception SQLException if a database access error occurs 165 */ 166 public String nativeSQL(String sql) throws SQLException { 167 throw new UnsupportedOperationException( 168 "Connection.nativeSQL(String) unsupported"); 169 } 170 171 /*** 172 * Sets this connection's auto-commit mode to the given state. 173 * If a connection is in auto-commit mode, then all its SQL 174 * statements will be executed and committed as individual 175 * transactions. Otherwise, its SQL statements are grouped into 176 * transactions that are terminated by a call to either 177 * the method <code>commit</code> or the method <code>rollback</code>. 178 * By default, new connections are in auto-commit 179 * mode. 180 * <P> 181 * The commit occurs when the statement completes or the next 182 * execute occurs, whichever comes first. In the case of 183 * statements returning a <code>ResultSet</code> object, 184 * the statement completes when the last row of the 185 * <code>ResultSet</code> object has been retrieved or the 186 * <code>ResultSet</code> object has been closed. In advanced cases, a 187 * single statement may return multiple results as well as output 188 * parameter values. In these cases, the commit occurs when all results and 189 * output parameter values have been retrieved. 190 * <P> 191 * <B>NOTE:</B> If this method is called during a transaction, the 192 * transaction is committed. 193 * 194 * @param autoCommit <code>true</code> to enable auto-commit mode; 195 * <code>false</code> to disable it 196 * @exception SQLException if a database access error occurs 197 * @see #getAutoCommit 198 */ 199 public void setAutoCommit(boolean autoCommit) throws SQLException { 200 // throw new UnsupportedOperationException( 201 // "Connection.setAutoCommit(boolean) unsupported"); 202 } 203 204 /*** 205 * Retrieves the current auto-commit mode for this <code>Connection</code> 206 * object. 207 * 208 * @return the current state of this <code>Connection</code> object's 209 * auto-commit mode 210 * @exception SQLException if a database access error occurs 211 * @see #setAutoCommit 212 */ 213 public boolean getAutoCommit() throws SQLException { 214 // throw new UnsupportedOperationException( 215 // "Connection.getAutoCommit() unsupported"); 216 return true; 217 } 218 219 /*** 220 * Makes all changes made since the previous 221 * commit/rollback permanent and releases any database locks 222 * currently held by this <code>Connection</code> object. 223 * This method should be 224 * used only when auto-commit mode has been disabled. 225 * 226 * @exception SQLException if a database access error occurs or this 227 * <code>Connection</code> object is in auto-commit mode 228 * @see #setAutoCommit 229 */ 230 public void commit() throws SQLException { 231 // throw new UnsupportedOperationException( 232 // "Connection.commit() unsupported"); 233 } 234 235 /*** 236 * Undoes all changes made in the current transaction 237 * and releases any database locks currently held 238 * by this <code>Connection</code> object. This method should be 239 * used only when auto-commit mode has been disabled. 240 * 241 * @exception SQLException if a database access error occurs or this 242 * <code>Connection</code> object is in auto-commit mode 243 * @see #setAutoCommit 244 */ 245 public void rollback() throws SQLException { 246 throw new UnsupportedOperationException( 247 "Connection.rollback() unsupported"); 248 } 249 250 /*** 251 * Releases this <code>Connection</code> object's database and JDBC 252 * resources immediately instead of waiting for them to be automatically 253 * released. 254 * <P> 255 * Calling the method <code>close</code> on a <code>Connection</code> 256 * object that is already closed is a no-op. 257 * <P> 258 * <B>Note:</B> A <code>Connection</code> object is automatically 259 * closed when it is garbage collected. Certain fatal errors also 260 * close a <code>Connection</code> object. 261 * 262 * @exception SQLException if a database access error occurs 263 */ 264 public void close() throws SQLException { 265 // close all created statements 266 // for(Enumeration i = statements.elements(); i.hasMoreElements(); ) { 267 // XmlStatement statement = (XmlStatement)i.nextElement(); 268 // statement.close(); 269 // } 270 // set this Connection as closed 271 closed = true; 272 } 273 274 /*** 275 * Retrieves whether this <code>Connection</code> object has been 276 * closed. A connection is closed if the method <code>close</code> 277 * has been called on it or if certain fatal errors have occurred. 278 * This method is guaranteed to return <code>true</code> only when 279 * it is called after the method <code>Connection.close</code> has 280 * been called. 281 * <P> 282 * This method generally cannot be called to determine whether a 283 * connection to a database is valid or invalid. A typical client 284 * can determine that a connection is invalid by catching any 285 * exceptions that might be thrown when an operation is attempted. 286 * 287 * @return <code>true</code> if this <code>Connection</code> object 288 * is closed; <code>false</code> if it is still open 289 * @exception SQLException if a database access error occurs 290 */ 291 public boolean isClosed() throws SQLException { 292 return closed; 293 } 294 295 /*** 296 * Retrieves a <code>DatabaseMetaData</code> object that contains 297 * metadata about the database to which this 298 * <code>Connection</code> object represents a connection. 299 * The metadata includes information about the database's 300 * tables, its supported SQL grammar, its stored 301 * procedures, the capabilities of this connection, and so on. 302 * 303 * @return a <code>DatabaseMetaData</code> object for this 304 * <code>Connection</code> object 305 * @exception SQLException if a database access error occurs 306 */ 307 public DatabaseMetaData getMetaData() throws SQLException { 308 throw new UnsupportedOperationException( 309 "Connection.getMetaData() unsupported"); 310 } 311 312 /*** 313 * Puts this connection in read-only mode as a hint to the driver to enable 314 * database optimizations. 315 * 316 * <P><B>Note:</B> This method cannot be called during a transaction. 317 * 318 * @param readOnly <code>true</code> enables read-only mode; 319 * <code>false</code> disables it 320 * @exception SQLException if a database access error occurs or this 321 * method is called during a transaction 322 */ 323 public void setReadOnly(boolean readOnly) throws SQLException { 324 throw new UnsupportedOperationException( 325 "Connection.setReadOnly(boolean) unsupported"); 326 } 327 328 /*** 329 * Retrieves whether this <code>Connection</code> 330 * object is in read-only mode. 331 * 332 * @return <code>true</code> if this <code>Connection</code> object 333 * is read-only; <code>false</code> otherwise 334 * @exception SQLException if a database access error occurs 335 */ 336 public boolean isReadOnly() throws SQLException { 337 return false; 338 } 339 340 /*** 341 * Sets the given catalog name in order to select 342 * a subspace of this <code>Connection</code> object's database 343 * in which to work. 344 * <P> 345 * If the driver does not support catalogs, it will 346 * silently ignore this request. 347 * 348 * @param catalog the name of a catalog (subspace in this 349 * <code>Connection</code> object's database) in which to work 350 * @exception SQLException if a database access error occurs 351 * @see #getCatalog 352 */ 353 public void setCatalog(String catalog) throws SQLException { 354 // silently ignore this request 355 } 356 357 /*** 358 * Retrieves this <code>Connection</code> object's current catalog name. 359 * 360 * @return the current catalog name or <code>null</code> if there is none 361 * @exception SQLException if a database access error occurs 362 * @see #setCatalog 363 */ 364 public String getCatalog() throws SQLException { 365 return null; 366 } 367 368 /*** 369 * Attempts to change the transaction isolation level for this 370 * <code>Connection</code> object to the one given. 371 * The constants defined in the interface <code>Connection</code> 372 * are the possible transaction isolation levels. 373 * <P> 374 * <B>Note:</B> If this method is called during a transaction, the result 375 * is implementation-defined. 376 * 377 * @param level one of the following <code>Connection</code> constants: 378 * <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>, 379 * <code>Connection.TRANSACTION_READ_COMMITTED</code>, 380 * <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or 381 * <code>Connection.TRANSACTION_SERIALIZABLE</code>. 382 * (Note that <code>Connection.TRANSACTION_NONE</code> cannot be used 383 * because it specifies that transactions are not supported.) 384 * @exception SQLException if a database access error occurs 385 * or the given parameter is not one of the <code>Connection</code> 386 * constants 387 * @see DatabaseMetaData#supportsTransactionIsolationLevel 388 * @see #getTransactionIsolation 389 */ 390 public void setTransactionIsolation(int level) throws SQLException { 391 throw new UnsupportedOperationException( 392 "Connection.setTransactionIsolation(int) unsupported"); 393 } 394 395 /*** 396 * Retrieves this <code>Connection</code> object's current 397 * transaction isolation level. 398 * 399 * @return the current transaction isolation level, which will be one 400 * of the following constants: 401 * <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>, 402 * <code>Connection.TRANSACTION_READ_COMMITTED</code>, 403 * <code>Connection.TRANSACTION_REPEATABLE_READ</code>, 404 * <code>Connection.TRANSACTION_SERIALIZABLE</code>, or 405 * <code>Connection.TRANSACTION_NONE</code>. 406 * @exception SQLException if a database access error occurs 407 * @see #setTransactionIsolation 408 */ 409 public int getTransactionIsolation() throws SQLException { 410 return Connection.TRANSACTION_NONE; 411 } 412 413 /*** 414 * Retrieves the first warning reported by calls on this 415 * <code>Connection</code> object. If there is more than one 416 * warning, subsequent warnings will be chained to the first one 417 * and can be retrieved by calling the method 418 * <code>SQLWarning.getNextWarning</code> on the warning 419 * that was retrieved previously. 420 * <P> 421 * This method may not be 422 * called on a closed connection; doing so will cause an 423 * <code>SQLException</code> to be thrown. 424 * 425 * <P><B>Note:</B> Subsequent warnings will be chained to this 426 * SQLWarning. 427 * 428 * @return the first <code>SQLWarning</code> object or <code>null</code> 429 * if there are none 430 * @exception SQLException if a database access error occurs or 431 * this method is called on a closed connection 432 * @see SQLWarning 433 */ 434 public SQLWarning getWarnings() throws SQLException { 435 throw new UnsupportedOperationException( 436 "Connection.getWarnings() unsupported"); 437 } 438 439 /*** 440 * Clears all warnings reported for this <code>Connection</code> object. 441 * After a call to this method, the method <code>getWarnings</code> 442 * returns <code>null</code> until a new warning is 443 * reported for this <code>Connection</code> object. 444 * 445 * @exception SQLException if a database access error occurs 446 */ 447 public void clearWarnings() throws SQLException { 448 throw new UnsupportedOperationException( 449 "Connection.getWarnings() unsupported"); 450 } 451 452 //--------------------------JDBC 2.0----------------------------- 453 454 /*** 455 * Creates a <code>Statement</code> object that will generate 456 * <code>ResultSet</code> objects with the given type and concurrency. 457 * This method is the same as the <code>createStatement</code> method 458 * above, but it allows the default result set 459 * type and concurrency to be overridden. 460 * 461 * @param resultSetType a result set type; one of 462 * <code>ResultSet.TYPE_FORWARD_ONLY</code>, 463 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or 464 * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 465 * @param resultSetConcurrency a concurrency type; one of 466 * <code>ResultSet.CONCUR_READ_ONLY</code> or 467 * <code>ResultSet.CONCUR_UPDATABLE</code> 468 * @return a new <code>Statement</code> object that will generate 469 * <code>ResultSet</code> objects with the given type and 470 * concurrency 471 * @exception SQLException if a database access error occurs 472 * or the given parameters are not <code>ResultSet</code> 473 * constants indicating type and concurrency 474 */ 475 public Statement createStatement(int resultSetType, int resultSetConcurrency) 476 throws SQLException { 477 throw new UnsupportedOperationException( 478 "Connection.createStatement(int, int) unsupported"); 479 } 480 481 /*** 482 * Creates a <code>PreparedStatement</code> object that will generate 483 * <code>ResultSet</code> objects with the given type and concurrency. 484 * This method is the same as the <code>prepareStatement</code> method 485 * above, but it allows the default result set 486 * type and concurrency to be overridden. 487 * 488 * @param sql a <code>String</code> object that is the SQL statement to 489 * be sent to the database; may contain one or more ? IN 490 * parameters 491 * @param resultSetType a result set type; one of 492 * <code>ResultSet.TYPE_FORWARD_ONLY</code>, 493 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or 494 * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 495 * @param resultSetConcurrency a concurrency type; one of 496 * <code>ResultSet.CONCUR_READ_ONLY</code> or 497 * <code>ResultSet.CONCUR_UPDATABLE</code> 498 * @return a new PreparedStatement object containing the 499 * pre-compiled SQL statement that will produce <code>ResultSet</code> 500 * objects with the given type and concurrency 501 * @exception SQLException if a database access error occurs 502 * or the given parameters are not <code>ResultSet</code> 503 * constants indicating type and concurrency 504 */ 505 public PreparedStatement prepareStatement(String sql, int resultSetType, 506 int resultSetConcurrency) throws SQLException { 507 throw new UnsupportedOperationException( 508 "Connection.prepareStatement(String, int, int) unsupported"); 509 } 510 511 /*** 512 * Creates a <code>CallableStatement</code> object that will generate 513 * <code>ResultSet</code> objects with the given type and concurrency. 514 * This method is the same as the <code>prepareCall</code> method 515 * above, but it allows the default result set 516 * type and concurrency to be overridden. 517 * 518 * @param sql a <code>String</code> object that is the SQL statement to 519 * be sent to the database; may contain on or more ? parameters 520 * @param resultSetType a result set type; one of 521 * <code>ResultSet.TYPE_FORWARD_ONLY</code>, 522 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or 523 * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 524 * @param resultSetConcurrency a concurrency type; one of 525 * <code>ResultSet.CONCUR_READ_ONLY</code> or 526 * <code>ResultSet.CONCUR_UPDATABLE</code> 527 * @return a new <code>CallableStatement</code> object containing the 528 * pre-compiled SQL statement that will produce <code>ResultSet</code> 529 * objects with the given type and concurrency 530 * @exception SQLException if a database access error occurs 531 * or the given parameters are not <code>ResultSet</code> 532 * constants indicating type and concurrency 533 */ 534 public CallableStatement prepareCall(String sql, int resultSetType, 535 int resultSetConcurrency) throws SQLException { 536 throw new UnsupportedOperationException( 537 "Connection.prepareCall(String, int, int) unsupported"); 538 } 539 540 /*** 541 * Retrieves the <code>Map</code> object associated with this 542 * <code>Connection</code> object. 543 * Unless the application has added an entry, the type map returned 544 * will be empty. 545 * 546 * @return the <code>java.util.Map</code> object associated 547 * with this <code>Connection</code> object 548 * @exception SQLException if a database access error occurs 549 * @see #setTypeMap 550 */ 551 public Map getTypeMap() throws SQLException { 552 throw new UnsupportedOperationException( 553 "Connection.getTypeMap() unsupported"); 554 } 555 556 /*** 557 * Installs the given <code>TypeMap</code> object as the type map for 558 * this <code>Connection</code> object. The type map will be used for the 559 * custom mapping of SQL structured types and distinct types. 560 * 561 * @param map the <code>java.util.Map</code> object to install 562 * as the replacement for this <code>Connection</code> 563 * object's default type map 564 * @exception SQLException if a database access error occurs or 565 * the given parameter is not a <code>java.util.Map</code> 566 * object 567 * @see #getTypeMap 568 */ 569 public void setTypeMap(Map map) throws SQLException { 570 throw new UnsupportedOperationException( 571 "Connection.setTypeMap(Map) unsupported"); 572 } 573 574 //--------------------------JDBC 3.0----------------------------- 575 /*** 576 * Changes the holdability of <code>ResultSet</code> objects 577 * created using this <code>Connection</code> object to the given 578 * holdability. 579 * 580 * @param holdability a <code>ResultSet</code> holdability constant; one of 581 * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or 582 * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code> 583 * @throws SQLException if a database access occurs, the given parameter 584 * is not a <code>ResultSet</code> constant indicating holdability, 585 * or the given holdability is not supported 586 * @since 1.4 587 * @see #getHoldability 588 * @see java.sql.ResultSet 589 */ 590 public void setHoldability(int holdability) throws SQLException { 591 throw new UnsupportedOperationException("Connection.setHoldability(int) unsupported"); 592 } 593 594 /*** 595 * Retrieves the current holdability of ResultSet objects created 596 * using this Connection object. 597 * 598 * @return the holdability, one of <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or 599 * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code> 600 * @throws SQLException if a database access occurs 601 * @since 1.4 602 * @see #setHoldability 603 * @see java.sql.ResultSet 604 */ 605 public int getHoldability() throws SQLException { 606 throw new UnsupportedOperationException("Connection.getHoldability() unsupported"); 607 } 608 609 // Removed since this only builds under JDK 1.4 610 public Savepoint setSavepoint() throws SQLException { 611 throw new UnsupportedOperationException("Connection.setSavepoint() unsupported"); 612 } 613 614 public Savepoint setSavepoint(String name) throws SQLException { 615 throw new UnsupportedOperationException("Connection.setSavepoint(String) unsupported"); 616 } 617 618 public void rollback(Savepoint savepoint) throws SQLException { 619 throw new UnsupportedOperationException("Connection.rollback(Savepoint) unsupported"); 620 } 621 622 public void releaseSavepoint(Savepoint savepoint) throws SQLException { 623 throw new UnsupportedOperationException("Connection.releaseSavepoint(Savepoint) unsupported"); 624 } 625 626 627 public Statement createStatement(int resultSetType, 628 int resultSetConcurrency, 629 int resultSetHoldability) throws SQLException { 630 throw new UnsupportedOperationException("Connection.createStatement(int,int,int) unsupported"); 631 } 632 633 public PreparedStatement prepareStatement(String sql, 634 int resultSetType, 635 int resultSetConcurrency, 636 int resultSetHoldability) throws SQLException { 637 throw new UnsupportedOperationException("Connection.prepareStatement(String,int,int,int) unsupported"); 638 } 639 640 public CallableStatement prepareCall(String sql, 641 int resultSetType, 642 int resultSetConcurrency, 643 int resultSetHoldability) throws SQLException { 644 throw new UnsupportedOperationException("Connection.prepareCall(String,int,int,int) unsupported"); 645 } 646 647 public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { 648 throw new UnsupportedOperationException("Connection.prepareStatement(String,int) unsupported"); 649 } 650 651 public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { 652 throw new UnsupportedOperationException("Connection.prepareStatement(String,int[]) unsupported"); 653 } 654 655 public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { 656 throw new UnsupportedOperationException("Connection.prepareStatement(String,String[]) unsupported"); 657 } 658 659 //--------------------------------------------------------------------- 660 // Properties 661 //--------------------------------------------------------------------- 662 663 /*** 664 * Accessor method for the path property 665 * @return current value for the path property 666 */ 667 protected String getPath() { 668 return path; 669 } 670 671 /*** 672 * Accessor method for the extension property 673 * @return current value for the extension property 674 */ 675 protected String getExtension() { 676 return extension; 677 } 678 679 680 /*** 681 * Accessor method for the charset property 682 * @return current value for the suppressHeaders property 683 */ 684 protected String getCharset() { 685 return charset; 686 } 687 688 }

This page automatically generated by Maven