I18nConnection


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.io.File  ;
23  import java.sql.CallableStatement  ;
24  import java.sql.Connection  ;
25  import java.sql.DatabaseMetaData  ;
26  import java.sql.PreparedStatement  ;
27  import java.sql.SQLException  ;
28  import java.sql.SQLWarning  ;
29  import java.sql.Savepoint  ;
30  import java.sql.Statement  ;
31  import java.util.Enumeration  ;
32  import java.util.Map  ;
33  import java.util.Properties  ;
34  import java.util.StringTokenizer  ;
35  import java.util.Vector  ;
36  
37  import org.webdocwf.util.i18njdbc.I18nDriver;
38  
39  
40  /**
41   * This class implements the Connection interface for the I18nJdbc driver.
42   *
43   * @author     Zoran Milakovic
44   * @author       Zeljko Kovacevic
45   */
46  public class I18nConnection
47      implements Connection   {
48  
49    /** Directory where the i18n files to use are located */
50    private String   path;
51  
52    /** File extension to use */
53  //  private String charset = I18nDriver.DEFAULT_CHARSET;
54    private String   nameColumn = I18nDriver.DEFAULT_NAMECOLUMN;
55    private String   valueColumn = I18nDriver.DEFAULT_VALUECOLUMN;
56    private boolean create = I18nDriver.DEFAULT_CREATE;
57    private String   extension = I18nDriver.DEFAULT_EXTENSION;
58    private I18nProperties prop;
59    private String   currentTableName = null;
60  
61    /** Collection of all created Statements */
62    private Vector   statements = new Vector  ();
63  
64    /** Charset that should be used to read the files */
65    //private String charset = null;
66  
67    /** Stores whether this Connection is closed or not */
68    private boolean closed;
69  
70    /** If value is true I18n file will be saved after each query.Default value is true in JDBC compliant drivers.*/
71    private boolean autoCommit=true;
72  
73  
74    /**
75     * Creates a new I18nConnection that takes the supplied path
76     * @param path directory where the i18n files are located
77     */
78    protected I18nConnection(String   path) throws SQLException   {
79        init(path);
80        this.prop = new I18nProperties();
81    }
82  
83  
84    /**
85     * Creates a new I18nConnection that takes the supplied path and properties
86     * @param path directory where the i18n files are located
87     * @param info set of properties containing custom options
88     */
89    protected I18nConnection(String   path, Properties   info) throws SQLException   {
90      
91      // check for properties
92      if (info != null) {
93        // set the file extension to be used
94        if (info.getProperty(I18nDriver.FILE_EXTENSION) != null) {
95          extension = info.getProperty(I18nDriver.FILE_EXTENSION);
96          if (!extension.startsWith("."))
97            this.extension = "." + extension;
98        }
99         //set the nameColumn
100       if (info.getProperty(I18nDriver.NAMECOLUMN) != null) {
101                 this.nameColumn = info.getProperty(I18nDriver.NAMECOLUMN);
102       }
103       // set the valueColumn
104       if (info.getProperty(I18nDriver.VALUECOLUMN) != null) {
105         this.valueColumn = info.getProperty(I18nDriver.VALUECOLUMN);
106       }
107       // default charset
108 //      if (info.getProperty(I18nDriver.CHARSET) != null) {
109 //        this.charset = info.getProperty(I18nDriver.CHARSET);
110 //      }
111       // set create
112       if (info.getProperty(I18nDriver.CREATE) != null) {
113         this.create = Boolean.valueOf(info.getProperty(
114             I18nDriver.CREATE)).booleanValue();
115       }
116     }
117     init(path);
118     this.prop = new I18nProperties();
119   }
120     /**
121      * This method set init parameters
122      * @param path
123      * @throws SQLException
124      */
125   protected void init(String   path) throws SQLException   {
126         if (path == null || path.length() == 0) {
127             throw new IllegalArgumentException  (
128                 "'path' argument may not be empty or null");
129           }
130           //check for properties
131           StringTokenizer   st = new StringTokenizer  (path, ";");
132           this.path = st.nextToken();
133           if (!this.path.endsWith(File.separator)) {
134             this.path += File.separator;
135           }
136           while (st.hasMoreTokens()) {
137             String   next = st.nextToken();
138             if (!this.setProperty(next)) {
139               throw new IllegalArgumentException  (
140                   "unknown property " + next);
141             }
142           }
143           File   filePath = new File  (this.path);
144     
145           if (!this.create && !filePath.exists()) {
146             throw new SQLException  (
147                 "Specified path '" + filePath.getAbsolutePath() +
148                 "' does not exist !");
149           }
150     
151           if (this.create && !filePath.exists())
152             filePath.mkdirs();
153   }
154   
155 /**
156  * This method set parameters from property string
157  * @param propString
158  * @return
159  */  
160   private boolean setProperty(String   propString) {
161     boolean retVal = true;
162     StringTokenizer   st = new StringTokenizer  (propString, "=");
163     String   name = st.nextToken();
164     String   value = st.nextToken();
165 
166     if (name.equals(I18nDriver.FILE_EXTENSION)) {
167       if (!value.startsWith("."))
168         value = "." + value;
169       this.extension = value;
170     }
171 //    else if (name.equals(I18nDriver.CHARSET)) {
172 //      this.charset = value;
173 //    }
174     else if (name.equals(I18nDriver.CREATE)) {
175       this.create = Boolean.valueOf(value).booleanValue();
176     }
177     else if (name.equals(I18nDriver.NAMECOLUMN)) {
178       this.nameColumn = value;
179     }
180     else if (name.equals(I18nDriver.VALUECOLUMN)) {
181       this.valueColumn = value;
182     }
183     else
184       retVal = false;
185     return retVal;
186   }
187 
188   /**
189    * Creates a <code>Statement</code> object for sending
190    * SQL statements to the database.
191    * SQL statements without parameters are normally
192    * executed using <code>Statement</code> objects. If the same SQL statement
193    * is executed many times, it may be more efficient to use a
194    * <code>PreparedStatement</code> object.
195    * <P>
196    * Result sets created using the returned <code>Statement</code>
197    * object will by default be type <code>TYPE_FORWARD_ONLY</code>
198    * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
199    *
200    * @return a new default <code>Statement</code> object
201    * @exception SQLException if a database access error occurs
202    */
203   public Statement   createStatement() throws SQLException   {
204     I18nStatement statement = new I18nStatement(this);
205     statements.add(statement);
206     return statement;
207   }
208 
209   /**
210    * Creates a <code>PreparedStatement</code> object for sending
211    * parameterized SQL statements to the database.
212    * <P>
213    * A SQL statement with or without IN parameters can be
214    * pre-compiled and stored in a <code>PreparedStatement</code> object. This
215    * object can then be used to efficiently execute this statement
216    * multiple times.
217    *
218    * <P><B>Note:</B> This method is optimized for handling
219    * parametric SQL statements that benefit from precompilation. If
220    * the driver supports precompilation,
221    * the method <code>prepareStatement</code> will send
222    * the statement to the database for precompilation. Some drivers
223    * may not support precompilation. In this case, the statement may
224    * not be sent to the database until the <code>PreparedStatement</code>
225    * object is executed.  This has no direct effect on users; however, it does
226    * affect which methods throw certain <code>SQLException</code> objects.
227    * <P>
228    * Result sets created using the returned <code>PreparedStatement</code>
229    * object will by default be type <code>TYPE_FORWARD_ONLY</code>
230    * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
231    *
232    * @param sql an SQL statement that may contain one or more '?' IN
233    * parameter placeholders
234    * @return a new default <code>PreparedStatement</code> object containing the
235    * pre-compiled SQL statement
236    * @exception SQLException if a database access error occurs
237    */
238   public PreparedStatement   prepareStatement(String   sql) throws SQLException   {
239     int index = sql.indexOf("?");
240     while (index != -1) {
241       sql = sql.substring(0, index) + I18nPreparedStatement.PREPARE_SEPARATOR + sql.substring(index + 1);
242       index = sql.indexOf("?");
243     }
244     I18nPreparedStatement statement = new I18nPreparedStatement(this, sql);
245     statements.add(statement);
246     return statement;
247             
248   }
249 
250   /**
251    * Creates a <code>CallableStatement</code> object for calling
252    * database stored procedures.
253    * The <code>CallableStatement</code> object provides
254    * methods for setting up its IN and OUT parameters, and
255    * methods for executing the call to a stored procedure.
256    *
257    * <P><B>Note:</B> This method is optimized for handling stored
258    * procedure call statements. Some drivers may send the call
259    * statement to the database when the method <code>prepareCall</code>
260    * is done; others
261    * may wait until the <code>CallableStatement</code> object
262    * is executed. This has no
263    * direct effect on users; however, it does affect which method
264    * throws certain SQLExceptions.
265    * <P>
266    * Result sets created using the returned <code>CallableStatement</code>
267    * object will by default be type <code>TYPE_FORWARD_ONLY</code>
268    * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
269    *
270    * @param sql an SQL statement that may contain one or more '?'
271    * parameter placeholders. Typically this  statement is a JDBC
272    * function call escape string.
273    * @return a new default <code>CallableStatement</code> object containing the
274    * pre-compiled SQL statement
275    * @exception SQLException if a database access error occurs
276    */
277   public CallableStatement   prepareCall(String   sql) throws SQLException   {
278     throw new UnsupportedOperationException  (
279         "Connection.prepareCall(String) unsupported");
280   }
281 
282   /**
283    * Converts the given SQL statement into the system's native SQL grammar.
284    * A driver may convert the JDBC SQL grammar into its system's
285    * native SQL grammar prior to sending it. This method returns the
286    * native form of the statement that the driver would have sent.
287    *
288    * @param sql an SQL statement that may contain one or more '?'
289    * parameter placeholders
290    * @return the native form of this statement
291    * @exception SQLException if a database access error occurs
292    */
293   public String   nativeSQL(String   sql) throws SQLException   {
294     throw new UnsupportedOperationException  (
295         "Connection.nativeSQL(String) unsupported");
296   }
297 
298   /**
299    * Sets this connection's auto-commit mode to the given state.
300    * If a connection is in auto-commit mode, then all its SQL
301    * statements will be executed and committed as individual
302    * transactions.  Otherwise, its SQL statements are grouped into
303    * transactions that are terminated by a call to either
304    * the method <code>commit</code> or the method <code>rollback</code>.
305    * By default, new connections are in auto-commit
306    * mode.
307    * <P>
308    * The commit occurs when the statement completes or the next
309    * execute occurs, whichever comes first. In the case of
310    * statements returning a <code>ResultSet</code> object,
311    * the statement completes when the last row of the
312    * <code>ResultSet</code> object has been retrieved or the
313    * <code>ResultSet</code> object has been closed. In advanced cases, a
314    * single statement may return multiple results as well as output
315    * parameter values. In these cases, the commit occurs when all results and
316    * output parameter values have been retrieved.
317    * <P>
318    * <B>NOTE:</B>  If this method is called during a transaction, the
319    * transaction is committed.
320    *
321    * @param autoCommit <code>true</code> to enable auto-commit mode;
322    *         <code>false</code> to disable it
323    * @exception SQLException if a database access error occurs
324    * @see #getAutoCommit
325    */
326   public void setAutoCommit(boolean autoCommit) throws SQLException   {
327     this.autoCommit = autoCommit;
328   }
329 
330   /**
331    * Retrieves the current auto-commit mode for this <code>Connection</code>
332    * object.
333    *
334    * @return the current state of this <code>Connection</code> object's
335    *         auto-commit mode
336    * @exception SQLException if a database access error occurs
337    * @see #setAutoCommit
338    */
339   public boolean getAutoCommit() throws SQLException   {
340     return this.autoCommit;
341   }
342 
343   /**
344    * Makes all changes made since the previous
345    * commit/rollback permanent and releases any database locks
346    * currently held by this <code>Connection</code> object.
347    * This method should be
348    * used only when auto-commit mode has been disabled.
349    *
350    * @exception SQLException if a database access error occurs or this
351    *            <code>Connection</code> object is in auto-commit mode
352    * @see #setAutoCommit
353    */
354   public void commit() throws SQLException   {
355     for (int i = 0; i < this.statements.size(); i++) {
356       ( (Statement  ) statements.get(i)).close();
357     }
358     try {
359         if(getCurrentTableName() != null) {
360             this.prop.store(new File  (getPath() + getCurrentTableName() + getExtension()));
361             this.prop = new I18nProperties();
362             this.currentTableName = null;
363         }
364     } catch (Exception   e) {
365         e.printStackTrace();
366         throw new SQLException  (e.getMessage());
367     }
368   }
369 
370   /**
371    * Undoes all changes made in the current transaction
372    * and releases any database locks currently held
373    * by this <code>Connection</code> object. This method should be
374    * used only when auto-commit mode has been disabled.
375    *
376    * @exception SQLException if a database access error occurs or this
377    *            <code>Connection</code> object is in auto-commit mode
378    * @see #setAutoCommit
379    */
380   public void rollback() throws SQLException   {
381     throw new UnsupportedOperationException  (
382         "Connection.rollback() unsupported");
383   }
384 
385   /**
386    * Releases this <code>Connection</code> object's database and JDBC
387    * resources immediately instead of waiting for them to be automatically
388    * released.
389    * <P>
390    * Calling the method <code>close</code> on a <code>Connection</code>
391    * object that is already closed is a no-op.
392    * <P>
393    * <B>Note:</B> A <code>Connection</code> object is automatically
394    * closed when it is garbage collected. Certain fatal errors also
395    * close a <code>Connection</code> object.
396    *
397    * @exception SQLException if a database access error occurs
398    */
399   public void close() throws SQLException   {
400     // close all created statements
401     for (Enumeration   i = statements.elements(); i.hasMoreElements(); ) {
402       Statement   statement = (Statement  ) i.nextElement();
403       statement.close();
404     }
405     // set this Connection as closed
406     closed = true;
407   }
408 
409   /**
410    * Retrieves whether this <code>Connection</code> object has been
411    * closed.  A connection is closed if the method <code>close</code>
412    * has been called on it or if certain fatal errors have occurred.
413    * This method is guaranteed to return <code>true</code> only when
414    * it is called after the method <code>Connection.close</code> has
415    * been called.
416    * <P>
417    * This method generally cannot be called to determine whether a
418    * connection to a database is valid or invalid.  A typical client
419    * can determine that a connection is invalid by catching any
420    * exceptions that might be thrown when an operation is attempted.
421    *
422    * @return <code>true</code> if this <code>Connection</code> object
423    *         is closed; <code>false</code> if it is still open
424    * @exception SQLException if a database access error occurs
425    */
426   public boolean isClosed() throws SQLException   {
427     return closed;
428   }
429 
430   /**
431    * Retrieves a <code>DatabaseMetaData</code> object that contains
432    * metadata about the database to which this
433    * <code>Connection</code> object represents a connection.
434    * The metadata includes information about the database's
435    * tables, its supported SQL grammar, its stored
436    * procedures, the capabilities of this connection, and so on.
437    *
438    * @return a <code>DatabaseMetaData</code> object for this
439    *         <code>Connection</code> object
440    * @exception SQLException if a database access error occurs
441    */
442   public DatabaseMetaData   getMetaData() throws SQLException   {
443     throw new UnsupportedOperationException  (
444         "Connection.getMetaData() unsupported");
445   }
446 
447   /**
448    * Puts this connection in read-only mode as a hint to the driver to enable
449    * database optimizations.
450    *
451    * <P><B>Note:</B> This method cannot be called during a transaction.
452    *
453    * @param readOnly <code>true</code> enables read-only mode;
454    *        <code>false</code> disables it
455    * @exception SQLException if a database access error occurs or this
456    *            method is called during a transaction
457    */
458   public void setReadOnly(boolean readOnly) throws SQLException   {
459     throw new UnsupportedOperationException  (
460         "Connection.setReadOnly(boolean) unsupported");
461   }
462 
463   /**
464    * Retrieves whether this <code>Connection</code>
465    * object is in read-only mode.
466    *
467    * @return <code>true</code> if this <code>Connection</code> object
468    *         is read-only; <code>false</code> otherwise
469    * @exception SQLException if a database access error occurs
470    */
471   public boolean isReadOnly() throws SQLException   {
472     return true;
473   }
474 
475   /**
476    * Sets the given catalog name in order to select
477    * a subspace of this <code>Connection</code> object's database
478    * in which to work.
479    * <P>
480    * If the driver does not support catalogs, it will
481    * silently ignore this request.
482    *
483    * @param catalog the name of a catalog (subspace in this
484    *        <code>Connection</code> object's database) in which to work
485    * @exception SQLException if a database access error occurs
486    * @see #getCatalog
487    */
488   public void setCatalog(String   catalog) throws SQLException   {
489     // silently ignore this request
490   }
491 
492   /**
493    * Retrieves this <code>Connection</code> object's current catalog name.
494    *
495    * @return the current catalog name or <code>null</code> if there is none
496    * @exception SQLException if a database access error occurs
497    * @see #setCatalog
498    */
499   public String   getCatalog() throws SQLException   {
500     return null;
501   }
502 
503   /**
504    * Attempts to change the transaction isolation level for this
505    * <code>Connection</code> object to the one given.
506    * The constants defined in the interface <code>Connection</code>
507    * are the possible transaction isolation levels.
508    * <P>
509    * <B>Note:</B> If this method is called during a transaction, the result
510    * is implementation-defined.
511    *
512    * @param level one of the following <code>Connection</code> constants:
513    *        <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
514    *        <code>Connection.TRANSACTION_READ_COMMITTED</code>,
515    *        <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
516    *        <code>Connection.TRANSACTION_SERIALIZABLE</code>.
517    *        (Note that <code>Connection.TRANSACTION_NONE</code> cannot be used
518    *        because it specifies that transactions are not supported.)
519    * @exception SQLException if a database access error occurs
520        *            or the given parameter is not one of the <code>Connection</code>
521    *            constants
522    * @see DatabaseMetaData#supportsTransactionIsolationLevel
523    * @see #getTransactionIsolation
524    */
525   public void setTransactionIsolation(int level) throws SQLException   {
526     throw new UnsupportedOperationException  (
527         "Connection.setTransactionIsolation(int) unsupported");
528   }
529 
530   /**
531    * Retrieves this <code>Connection</code> object's current
532    * transaction isolation level.
533    *
534    * @return the current transaction isolation level, which will be one
535    *         of the following constants:
536    *        <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
537    *        <code>Connection.TRANSACTION_READ_COMMITTED</code>,
538    *        <code>Connection.TRANSACTION_REPEATABLE_READ</code>,
539    *        <code>Connection.TRANSACTION_SERIALIZABLE</code>, or
540    *        <code>Connection.TRANSACTION_NONE</code>.
541    * @exception SQLException if a database access error occurs
542    * @see #setTransactionIsolation
543    */
544   public int getTransactionIsolation() throws SQLException   {
545     return Connection.TRANSACTION_NONE;
546   }
547 
548   /**
549    * Retrieves the first warning reported by calls on this
550    * <code>Connection</code> object.  If there is more than one
551    * warning, subsequent warnings will be chained to the first one
552    * and can be retrieved by calling the method
553    * <code>SQLWarning.getNextWarning</code> on the warning
554    * that was retrieved previously.
555    * <P>
556    * This method may not be
557    * called on a closed connection; doing so will cause an
558    * <code>SQLException</code> to be thrown.
559    *
560    * <P><B>Note:</B> Subsequent warnings will be chained to this
561    * SQLWarning.
562    *
563    * @return the first <code>SQLWarning</code> object or <code>null</code>
564    *         if there are none
565    * @exception SQLException if a database access error occurs or
566    *            this method is called on a closed connection
567    * @see SQLWarning
568    */
569   public SQLWarning   getWarnings() throws SQLException   {
570     throw new UnsupportedOperationException  (
571         "Connection.getWarnings() unsupported");
572   }
573 
574   /**
575    * Clears all warnings reported for this <code>Connection</code> object.
576    * After a call to this method, the method <code>getWarnings</code>
577    * returns <code>null</code> until a new warning is
578    * reported for this <code>Connection</code> object.
579    *
580    * @exception SQLException if a database access error occurs
581    */
582   public void clearWarnings() throws SQLException   {
583     throw new UnsupportedOperationException  (
584         "Connection.getWarnings() unsupported");
585   }
586 
587   //--------------------------JDBC 2.0-----------------------------
588 
589   /**
590    * Creates a <code>Statement</code> object that will generate
591    * <code>ResultSet</code> objects with the given type and concurrency.
592    * This method is the same as the <code>createStatement</code> method
593    * above, but it allows the default result set
594    * type and concurrency to be overridden.
595    *
596    * @param resultSetType a result set type; one of
597    *        <code>ResultSet.TYPE_FORWARD_ONLY</code>,
598    *        <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
599    *        <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
600    * @param resultSetConcurrency a concurrency type; one of
601    *        <code>ResultSet.CONCUR_READ_ONLY</code> or
602    *        <code>ResultSet.CONCUR_UPDATABLE</code>
603    * @return a new <code>Statement</code> object that will generate
604    *         <code>ResultSet</code> objects with the given type and
605    *         concurrency
606    * @exception SQLException if a database access error occurs
607    *         or the given parameters are not <code>ResultSet</code>
608    *         constants indicating type and concurrency
609    */
610   public Statement   createStatement(int resultSetType, int resultSetConcurrency) throws
611       SQLException   {
612     throw new UnsupportedOperationException  (
613         "Connection.createStatement(int, int) unsupported");
614   }
615 
616   /**
617    * Creates a <code>PreparedStatement</code> object that will generate
618    * <code>ResultSet</code> objects with the given type and concurrency.
619    * This method is the same as the <code>prepareStatement</code> method
620    * above, but it allows the default result set
621    * type and concurrency to be overridden.
622    *
623    * @param sql a <code>String</code> object that is the SQL statement to
624    *            be sent to the database; may contain one or more ? IN
625    *            parameters
626    * @param resultSetType a result set type; one of
627    *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,
628    *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
629    *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
630    * @param resultSetConcurrency a concurrency type; one of
631    *         <code>ResultSet.CONCUR_READ_ONLY</code> or
632    *         <code>ResultSet.CONCUR_UPDATABLE</code>
633    * @return a new PreparedStatement object containing the
634    * pre-compiled SQL statement that will produce <code>ResultSet</code>
635    * objects with the given type and concurrency
636    * @exception SQLException if a database access error occurs
637    *         or the given parameters are not <code>ResultSet</code>
638    *         constants indicating type and concurrency
639    */
640   public PreparedStatement   prepareStatement(String   sql, int resultSetType,
641                                             int resultSetConcurrency) throws
642       SQLException   {
643     throw new UnsupportedOperationException  (
644         "Connection.prepareStatement(String, int, int) unsupported");
645   }
646 
647   /**
648    * Creates a <code>CallableStatement</code> object that will generate
649    * <code>ResultSet</code> objects with the given type and concurrency.
650    * This method is the same as the <code>prepareCall</code> method
651    * above, but it allows the default result set
652    * type and concurrency to be overridden.
653    *
654    * @param sql a <code>String</code> object that is the SQL statement to
655    *            be sent to the database; may contain on or more ? parameters
656    * @param resultSetType a result set type; one of
657    *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,
658    *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
659    *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
660    * @param resultSetConcurrency a concurrency type; one of
661    *         <code>ResultSet.CONCUR_READ_ONLY</code> or
662    *         <code>ResultSet.CONCUR_UPDATABLE</code>
663    * @return a new <code>CallableStatement</code> object containing the
664    * pre-compiled SQL statement that will produce <code>ResultSet</code>
665    * objects with the given type and concurrency
666    * @exception SQLException if a database access error occurs
667    *         or the given parameters are not <code>ResultSet</code>
668    *         constants indicating type and concurrency
669    */
670   public CallableStatement   prepareCall(String   sql, int resultSetType,
671                                        int resultSetConcurrency) throws
672       SQLException   {
673     throw new UnsupportedOperationException  (
674         "Connection.prepareCall(String, int, int) unsupported");
675   }
676 
677   /**
678    * Retrieves the <code>Map</code> object associated with this
679    * <code>Connection</code> object.
680    * Unless the application has added an entry, the type map returned
681    * will be empty.
682    *
683    * @return the <code>java.util.Map</code> object associated
684    *         with this <code>Connection</code> object
685    * @exception SQLException if a database access error occurs
686    * @see #setTypeMap
687    */
688   public Map   getTypeMap() throws SQLException   {
689     throw new UnsupportedOperationException  (
690         "Connection.getTypeMap() unsupported");
691   }
692 
693   /**
694    * Installs the given <code>TypeMap</code> object as the type map for
695    * this <code>Connection</code> object.  The type map will be used for the
696    * custom mapping of SQL structured types and distinct types.
697    *
698    * @param map the <code>java.util.Map</code> object to install
699    *        as the replacement for this <code>Connection</code>
700    *        object's default type map
701    * @exception SQLException if a database access error occurs or
702    *        the given parameter is not a <code>java.util.Map</code>
703    *        object
704    * @see #getTypeMap
705    */
706   public void setTypeMap(Map   map) throws SQLException   {
707     throw new UnsupportedOperationException  (
708         "Connection.setTypeMap(Map) unsupported");
709   }
710 
711   //--------------------------JDBC 3.0-----------------------------
712   /**
713    * Changes the holdability of <code>ResultSet</code> objects
714    * created using this <code>Connection</code> object to the given
715    * holdability.
716    *
717    * @param holdability a <code>ResultSet</code> holdability constant; one of
718    *        <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
719    *        <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
720    * @throws SQLException if a database access occurs, the given parameter
721    *         is not a <code>ResultSet</code> constant indicating holdability,
722    *         or the given holdability is not supported
723    * @since 1.4
724    * @see #getHoldability
725    * @see java.sql.ResultSet
726    */
727   public void setHoldability(int holdability) throws SQLException   {
728     throw new UnsupportedOperationException  (
729         "Connection.setHoldability(int) unsupported");
730   }
731 
732   /**
733    * Retrieves the current holdability of ResultSet objects created
734    * using this Connection object.
735    *
736    * @return the holdability, one of <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
737    * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
738    * @throws SQLException if a database access occurs
739    * @since 1.4
740    * @see #setHoldability
741    * @see java.sql.ResultSet
742    */
743   public int getHoldability() throws SQLException   {
744     throw new UnsupportedOperationException  (
745         "Connection.getHoldability() unsupported");
746   }
747 
748 //     Removed since this only builds under JDK 1.4
749   public Savepoint   setSavepoint() throws SQLException   {
750     throw new UnsupportedOperationException  (
751         "Connection.setSavepoint() unsupported");
752   }
753 
754   public Savepoint   setSavepoint(String   name) throws SQLException   {
755     throw new UnsupportedOperationException  (
756         "Connection.setSavepoint(String) unsupported");
757   }
758 
759   public void rollback(Savepoint   savepoint) throws SQLException   {
760     throw new UnsupportedOperationException  (
761         "Connection.rollback(Savepoint) unsupported");
762   }
763 
764   public void releaseSavepoint(Savepoint   savepoint) throws SQLException   {
765     throw new UnsupportedOperationException  (
766         "Connection.releaseSavepoint(Savepoint) unsupported");
767   }
768 
769   public Statement   createStatement(int resultSetType,
770                                    int resultSetConcurrency,
771                                    int resultSetHoldability) throws
772       SQLException   {
773     throw new UnsupportedOperationException  (
774         "Connection.createStatement(int,int,int) unsupported");
775   }
776 
777   public PreparedStatement   prepareStatement(String   sql,
778                                             int resultSetType,
779                                             int resultSetConcurrency,
780                                             int resultSetHoldability) throws
781       SQLException   {
782     throw new UnsupportedOperationException  (
783         "Connection.prepareStatement(String,int,int,int) unsupported");
784   }
785 
786   public CallableStatement   prepareCall(String   sql,
787                                        int resultSetType,
788                                        int resultSetConcurrency,
789                                        int resultSetHoldability) throws
790       SQLException   {
791     throw new UnsupportedOperationException  (
792         "Connection.prepareCall(String,int,int,int) unsupported");
793   }
794 
795   public PreparedStatement   prepareStatement(String   sql, int autoGeneratedKeys) throws
796       SQLException   {
797     throw new UnsupportedOperationException  (
798         "Connection.prepareStatement(String,int) unsupported");
799   }
800 
801   public PreparedStatement   prepareStatement(String   sql, int[] columnIndexes) throws
802       SQLException   {
803     throw new UnsupportedOperationException  (
804         "Connection.prepareStatement(String,int[]) unsupported");
805   }
806 
807   public PreparedStatement   prepareStatement(String   sql, String  [] columnNames) throws
808       SQLException   {
809     throw new UnsupportedOperationException  (
810         "Connection.prepareStatement(String,String[]) unsupported");
811   }
812 
813   //---------------------------------------------------------------------
814   // Properties
815   //---------------------------------------------------------------------
816 
817   /**
818    * Accessor method for the path property
819    * @return current value for the path property
820    */
821   protected String   getPath() {
822     return path;
823   }
824 
825   /**
826    * Accessor method for the extension property
827    * @return current value for the extension property
828    */
829   protected String   getExtension() {
830     return extension;
831   }
832 
833 
834   /**
835    * Accessor method for the charset property
836    * @return current value for the suppressHeaders property
837    */
838 //  protected String getCharset() {
839 //    return charset;
840 //  }
841 
842     //  protected long getMaxFileSize() {
843     //    return maxFileSize;
844     //  }
845     //
846     //  protected String getLineBreakEscape() {
847     //    return lineBrakesEscape;
848     //  }
849     //
850     //  protected String getCarriageReturnEscape() {
851     //      return carriageReturnEscape;
852     //  }
853     
854     //  protected String getDoubleQuotesEscape() {
855     //    return doubleQuotesEscape;
856     //  }
857     
858     /**
859      * @return String which represents nameColumn
860      */
861     protected String   getNameColumn() {
862         return this.nameColumn;
863     }
864     
865     /**
866      * @return String which represents valueColumn
867      */
868     protected String   getValueColumn() {
869         return this.valueColumn;
870     }
871     
872     /**
873      * @return String[] which represents valueColumn
874      */
875     protected String  [] getColumnNames() {
876         String  [] retString = new String  [2];
877         retString[0] = this.nameColumn;
878         retString[1] = this.valueColumn;
879         return retString;
880     }
881 
882     public I18nProperties getProperties() {
883         return prop;
884     }
885     
886     public void setProperties(I18nProperties prop) {
887         this.prop = prop;
888     }
889     
890     public String   getCurrentTableName() {
891         return currentTableName;
892     }
893     
894     public void setCurrentTableName(String   currentFileName) throws SQLException   {   
895         if( !this.getAutoCommit() && (this.currentTableName != null) && !this.currentTableName.equals(currentFileName) ) {
896             this.commit();
897         }
898         this.currentTableName = currentFileName;
899     }
900 }
901
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags