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