diff options
Diffstat (limited to 'sql/src/main/java')
69 files changed, 21622 insertions, 0 deletions
diff --git a/sql/src/main/java/SQLite/Authorizer.java b/sql/src/main/java/SQLite/Authorizer.java new file mode 100644 index 0000000..cdc321d --- /dev/null +++ b/sql/src/main/java/SQLite/Authorizer.java @@ -0,0 +1,25 @@ +package SQLite; + +/** + * Callback interface for SQLite's authorizer function. + */ + +public interface Authorizer { + + /** + * Callback to authorize access. + * + * @param what integer indicating type of access + * @param arg1 first argument (table, view, index, or trigger name) + * @param arg2 second argument (file, table, or column name) + * @param arg3 third argument (database name) + * @param arg4 third argument (trigger name) + * @return Constants.SQLITE_OK for success, Constants.SQLITE_IGNORE + * for don't allow access but don't raise an error, Constants.SQLITE_DENY + * for abort SQL statement with error. + */ + + public int authorize(int what, String arg1, String arg2, String arg3, + String arg4); +} + diff --git a/sql/src/main/java/SQLite/Blob.java b/sql/src/main/java/SQLite/Blob.java new file mode 100644 index 0000000..3de9f8a --- /dev/null +++ b/sql/src/main/java/SQLite/Blob.java @@ -0,0 +1,323 @@ +package SQLite; + +import java.io.*; + +/** + * Internal class implementing java.io.InputStream on + * SQLite 3.4.0 incremental blob I/O interface. + */ + +class BlobR extends InputStream { + + /** + * Blob instance + */ + + private Blob blob; + + /** + * Read position, file pointer. + */ + + private int pos; + + /** + * Contruct InputStream from blob instance. + */ + + BlobR(Blob blob) { + this.blob = blob; + this.pos = 0; + } + + /** + * Return number of available bytes for reading. + * @return available input bytes + */ + + public int available() throws IOException { + int ret = blob.size - pos; + return (ret < 0) ? 0 : ret; + } + + /** + * Mark method; dummy to satisfy InputStream class. + */ + + public void mark(int limit) { + } + + /** + * Reset method; dummy to satisfy InputStream class. + */ + + public void reset() throws IOException { + } + + /** + * Mark support; not for this class. + * @return always false + */ + + public boolean markSupported() { + return false; + } + + /** + * Close this blob InputStream. + */ + + public void close() throws IOException { + blob.close(); + blob = null; + pos = 0; + } + + /** + * Skip over blob data. + */ + + public long skip(long n) throws IOException { + long ret = pos + n; + if (ret < 0) { + ret = 0; + pos = 0; + } else if (ret > blob.size) { + ret = blob.size; + pos = blob.size; + } else { + pos = (int) ret; + } + return ret; + } + + /** + * Read single byte from blob. + * @return byte read + */ + + public int read() throws IOException { + byte b[] = new byte[1]; + int n = blob.read(b, 0, pos, b.length); + if (n > 0) { + pos += n; + return b[0]; + } + return -1; + } + + /** + * Read byte array from blob. + * @param b byte array to be filled + * @return number of bytes read + */ + + public int read(byte b[]) throws IOException { + int n = blob.read(b, 0, pos, b.length); + if (n > 0) { + pos += n; + return n; + } + return -1; + } + + /** + * Read slice of byte array from blob. + * @param b byte array to be filled + * @param off offset into byte array + * @param len length to be read + * @return number of bytes read + */ + + public int read(byte b[], int off, int len) throws IOException { + if (off + len > b.length) { + len = b.length - off; + } + if (len < 0) { + return -1; + } + if (len == 0) { + return 0; + } + int n = blob.read(b, off, pos, len); + if (n > 0) { + pos += n; + return n; + } + return -1; + } +} + +/** + * Internal class implementing java.io.OutputStream on + * SQLite 3.4.0 incremental blob I/O interface. + */ + +class BlobW extends OutputStream { + + /** + * Blob instance + */ + + private Blob blob; + + /** + * Read position, file pointer. + */ + + private int pos; + + /** + * Contruct OutputStream from blob instance. + */ + + BlobW(Blob blob) { + this.blob = blob; + this.pos = 0; + } + + /** + * Flush blob; dummy to satisfy OutputStream class. + */ + + public void flush() throws IOException { + } + + /** + * Close this blob OutputStream. + */ + + public void close() throws IOException { + blob.close(); + blob = null; + pos = 0; + } + + /** + * Write blob data. + * @param v byte to be written at current position. + */ + + public void write(int v) throws IOException { + byte b[] = new byte[1]; + b[0] = (byte) v; + pos += blob.write(b, 0, pos, 1); + } + + /** + * Write blob data. + * @param b byte array to be written at current position. + */ + + public void write(byte[] b) throws IOException { + if (b != null && b.length > 0) { + pos += blob.write(b, 0, pos, b.length); + } + } + + /** + * Write blob data. + * @param b byte array to be written. + * @param off offset within byte array + * @param len length of data to be written + */ + + public void write(byte[] b, int off, int len) throws IOException { + if (b != null) { + if (off + len > b.length) { + len = b.length - off; + } + if (len <= 0) { + return; + } + pos += blob.write(b, off, pos, len); + } + } +} + +/** + * Class to represent SQLite3 3.4.0 incremental blob I/O interface. + * + * Note, that all native methods of this class are + * not synchronized, i.e. it is up to the caller + * to ensure that only one thread is in these + * methods at any one time. + */ + +public class Blob { + + /** + * Internal handle for the SQLite3 blob. + */ + + private long handle = 0; + + /** + * Cached size of blob, setup right after blob + * has been opened. + */ + + protected int size = 0; + + /** + * Return InputStream for this blob + * @return InputStream + */ + + public InputStream getInputStream() { + return (InputStream) new BlobR(this); + } + + /** + * Return OutputStream for this blob + * @return OutputStream + */ + + public OutputStream getOutputStream() { + return (OutputStream) new BlobW(this); + } + + /** + * Close blob. + */ + + public native void close(); + + /** + * Internal blob write method. + * @param b byte array to be written + * @param off offset into byte array + * @param pos offset into blob + * @param len length to be written + * @return number of bytes written to blob + */ + + native int write(byte[] b, int off, int pos, int len) throws IOException; + + /** + * Internal blob read method. + * @param b byte array to be written + * @param off offset into byte array + * @param pos offset into blob + * @param len length to be written + * @return number of bytes written to blob + */ + + native int read(byte[] b, int off, int pos, int len) throws IOException; + + /** + * Destructor for object. + */ + + protected native void finalize(); + + /** + * Internal native initializer. + */ + + private static native void internal_init(); + + static { + internal_init(); + } +} diff --git a/sql/src/main/java/SQLite/BusyHandler.java b/sql/src/main/java/SQLite/BusyHandler.java new file mode 100644 index 0000000..c39b39d --- /dev/null +++ b/sql/src/main/java/SQLite/BusyHandler.java @@ -0,0 +1,20 @@ +package SQLite; + +/** + * Callback interface for SQLite's user defined busy handler. + */ + +public interface BusyHandler { + + /** + * Invoked when a table is locked by another process + * or thread. The method should return true for waiting + * until the table becomes unlocked, or false in order + * to abandon the action.<BR><BR> + * + * @param table the name of the locked table + * @param count number of times the table was locked + */ + + public boolean busy(String table, int count); +} diff --git a/sql/src/main/java/SQLite/Callback.java b/sql/src/main/java/SQLite/Callback.java new file mode 100644 index 0000000..3eeb605 --- /dev/null +++ b/sql/src/main/java/SQLite/Callback.java @@ -0,0 +1,68 @@ +package SQLite; + +/** + * Callback interface for SQLite's query results. + * <BR><BR> + * Example:<BR> + * + * <PRE> + * class TableFmt implements SQLite.Callback { + * public void columns(String cols[]) { + * System.out.println("<TH><TR>"); + * for (int i = 0; i < cols.length; i++) { + * System.out.println("<TD>" + cols[i] + "</TD>"); + * } + * System.out.println("</TR></TH>"); + * } + * public boolean newrow(String cols[]) { + * System.out.println("<TR>"); + * for (int i = 0; i < cols.length; i++) { + * System.out.println("<TD>" + cols[i] + "</TD>"); + * } + * System.out.println("</TR>"); + * return false; + * } + * } + * ... + * SQLite.Database db = new SQLite.Database(); + * db.open("db", 0); + * System.out.println("<TABLE>"); + * db.exec("select * from TEST", new TableFmt()); + * System.out.println("</TABLE>"); + * ... + * </PRE> + */ + +public interface Callback { + + /** + * Reports column names of the query result. + * This method is invoked first (and once) when + * the SQLite engine returns the result set.<BR><BR> + * + * @param coldata string array holding the column names + */ + + public void columns(String coldata[]); + + /** + * Reports type names of the columns of the query result. + * This is available from SQLite 2.6.0 on and needs + * the PRAGMA show_datatypes to be turned on.<BR><BR> + * + * @param types string array holding column types + */ + + public void types(String types[]); + + /** + * Reports row data of the query result. + * This method is invoked for each row of the + * result set. If true is returned the running + * SQLite query is aborted.<BR><BR> + * + * @param rowdata string array holding the column values of the row + */ + + public boolean newrow(String rowdata[]); +} diff --git a/sql/src/main/java/SQLite/Constants.java b/sql/src/main/java/SQLite/Constants.java new file mode 100644 index 0000000..4e636b9 --- /dev/null +++ b/sql/src/main/java/SQLite/Constants.java @@ -0,0 +1,157 @@ +/* DO NOT EDIT */ + +package SQLite; + +/** + * Container for SQLite constants. + */ + +public final class Constants { + /* + * Error code: 0 + */ + public static final int SQLITE_OK = 0; + /* + * Error code: 1 + */ + public static final int SQLITE_ERROR = 1; + /* + * Error code: 2 + */ + public static final int SQLITE_INTERNAL = 2; + /* + * Error code: 3 + */ + public static final int SQLITE_PERM = 3; + /* + * Error code: 4 + */ + public static final int SQLITE_ABORT = 4; + /* + * Error code: 5 + */ + public static final int SQLITE_BUSY = 5; + /* + * Error code: 6 + */ + public static final int SQLITE_LOCKED = 6; + /* + * Error code: 7 + */ + public static final int SQLITE_NOMEM = 7; + /* + * Error code: 8 + */ + public static final int SQLITE_READONLY = 8; + /* + * Error code: 9 + */ + public static final int SQLITE_INTERRUPT = 9; + /* + * Error code: 10 + */ + public static final int SQLITE_IOERR = 10; + /* + * Error code: 11 + */ + public static final int SQLITE_CORRUPT = 11; + /* + * Error code: 12 + */ + public static final int SQLITE_NOTFOUND = 12; + /* + * Error code: 13 + */ + public static final int SQLITE_FULL = 13; + /* + * Error code: 14 + */ + public static final int SQLITE_CANTOPEN = 14; + /* + * Error code: 15 + */ + public static final int SQLITE_PROTOCOL = 15; + /* + * Error code: 16 + */ + public static final int SQLITE_EMPTY = 16; + /* + * Error code: 17 + */ + public static final int SQLITE_SCHEMA = 17; + /* + * Error code: 18 + */ + public static final int SQLITE_TOOBIG = 18; + /* + * Error code: 19 + */ + public static final int SQLITE_CONSTRAINT = 19; + /* + * Error code: 20 + */ + public static final int SQLITE_MISMATCH = 20; + /* + * Error code: 21 + */ + public static final int SQLITE_MISUSE = 21; + /* + * Error code: 22 + */ + public static final int SQLITE_NOLFS = 22; + /* + * Error code: 23 + */ + public static final int SQLITE_AUTH = 23; + /* + * Error code: 24 + */ + public static final int SQLITE_FORMAT = 24; + /* + * Error code: 25 + */ + public static final int SQLITE_RANGE = 25; + /* + * Error code: 26 + */ + public static final int SQLITE_NOTADB = 26; + public static final int SQLITE_ROW = 100; + public static final int SQLITE_DONE = 101; + public static final int SQLITE_INTEGER = 1; + public static final int SQLITE_FLOAT = 2; + public static final int SQLITE_BLOB = 4; + public static final int SQLITE_NULL = 5; + public static final int SQLITE3_TEXT = 3; + public static final int SQLITE_NUMERIC = -1; + public static final int SQLITE_TEXT = 3; + public static final int SQLITE2_TEXT = -2; + public static final int SQLITE_ARGS = -3; + public static final int SQLITE_COPY = 0; + public static final int SQLITE_CREATE_INDEX = 1; + public static final int SQLITE_CREATE_TABLE = 2; + public static final int SQLITE_CREATE_TEMP_INDEX = 3; + public static final int SQLITE_CREATE_TEMP_TABLE = 4; + public static final int SQLITE_CREATE_TEMP_TRIGGER = 5; + public static final int SQLITE_CREATE_TEMP_VIEW = 6; + public static final int SQLITE_CREATE_TRIGGER = 7; + public static final int SQLITE_CREATE_VIEW = 8; + public static final int SQLITE_DELETE = 9; + public static final int SQLITE_DROP_INDEX = 10; + public static final int SQLITE_DROP_TABLE = 11; + public static final int SQLITE_DROP_TEMP_INDEX = 12; + public static final int SQLITE_DROP_TEMP_TABLE = 13; + public static final int SQLITE_DROP_TEMP_TRIGGER = 14; + public static final int SQLITE_DROP_TEMP_VIEW = 15; + public static final int SQLITE_DROP_TRIGGER = 16; + public static final int SQLITE_DROP_VIEW = 17; + public static final int SQLITE_INSERT = 18; + public static final int SQLITE_PRAGMA = 19; + public static final int SQLITE_READ = 20; + public static final int SQLITE_SELECT = 21; + public static final int SQLITE_TRANSACTION = 22; + public static final int SQLITE_UPDATE = 23; + public static final int SQLITE_ATTACH = 24; + public static final int SQLITE_DETACH = 25; + public static final int SQLITE_DENY = 1; + public static final int SQLITE_IGNORE = 2; +} diff --git a/sql/src/main/java/SQLite/Database.java b/sql/src/main/java/SQLite/Database.java new file mode 100644 index 0000000..dcaaf9d --- /dev/null +++ b/sql/src/main/java/SQLite/Database.java @@ -0,0 +1,615 @@ +package SQLite; + +/** + * Main class wrapping an SQLite database. + */ + +public class Database { + + /** + * Internal handle for the native SQLite API. + */ + + protected long handle = 0; + + /** + * Internal last error code for exec() methods. + */ + + protected int error_code = 0; + + /** + * Open an SQLite database file. + * + * @param filename the name of the database file + * @param mode open mode, currently ignored + */ + + public void open(String filename, int mode) throws SQLite.Exception { + synchronized(this) { + _open(filename, mode); + } + } + + private native void _open(String filename, int mode) + throws SQLite.Exception; + + /** + * Open SQLite auxiliary database file for temporary + * tables. + * + * @param filename the name of the auxiliary file or null + */ + + public void open_aux_file(String filename) throws SQLite.Exception { + synchronized(this) { + _open_aux_file(filename); + } + } + + private native void _open_aux_file(String filename) + throws SQLite.Exception; + + /** + * Destructor for object. + */ + + protected void finalize() { + synchronized(this) { + _finalize(); + } + } + + private native void _finalize(); + + /** + * Close the underlying SQLite database file. + */ + + public void close() throws SQLite.Exception { + synchronized(this) { + _close(); + } + } + + private native void _close() + throws SQLite.Exception; + + /** + * Execute an SQL statement and invoke callback methods + * for each row of the result set.<P> + * + * It the method fails, an SQLite.Exception is thrown and + * an error code is set, which later can be retrieved by + * the last_error() method. + * + * @param sql the SQL statement to be executed + * @param cb the object implementing the callback methods + */ + + public void exec(String sql, SQLite.Callback cb) throws SQLite.Exception { + synchronized(this) { + _exec(sql, cb); + } + } + + private native void _exec(String sql, SQLite.Callback cb) + throws SQLite.Exception; + + /** + * Execute an SQL statement and invoke callback methods + * for each row of the result set. Each '%q' or %Q in the + * statement string is substituted by its corresponding + * element in the argument vector. + * <BR><BR> + * Example:<BR> + * <PRE> + * String args[] = new String[1]; + * args[0] = "tab%"; + * db.exec("select * from sqlite_master where type like '%q'", + * null, args); + * </PRE> + * + * It the method fails, an SQLite.Exception is thrown and + * an error code is set, which later can be retrieved by + * the last_error() method. + * + * @param sql the SQL statement to be executed + * @param cb the object implementing the callback methods + * @param args arguments for the SQL statement, '%q' substitution + */ + + public void exec(String sql, SQLite.Callback cb, + String args[]) throws SQLite.Exception { + synchronized(this) { + _exec(sql, cb, args); + } + } + + private native void _exec(String sql, SQLite.Callback cb, String args[]) + throws SQLite.Exception; + + /** + * Return the row identifier of the last inserted + * row. + */ + + public long last_insert_rowid() { + synchronized(this) { + return _last_insert_rowid(); + } + } + + private native long _last_insert_rowid(); + + /** + * Abort the current SQLite operation. + */ + + public void interrupt() { + synchronized(this) { + _interrupt(); + } + } + + private native void _interrupt(); + + /** + * Return the number of changed rows for the last statement. + */ + + public long changes() { + synchronized(this) { + return _changes(); + } + } + + private native long _changes(); + + /** + * Establish a busy callback method which gets called when + * an SQLite table is locked. + * + * @param bh the object implementing the busy callback method + */ + + public void busy_handler(SQLite.BusyHandler bh) { + synchronized(this) { + _busy_handler(bh); + } + } + + private native void _busy_handler(SQLite.BusyHandler bh); + + /** + * Set the timeout for waiting for an SQLite table to become + * unlocked. + * + * @param ms number of millisecond to wait + */ + + public void busy_timeout(int ms) { + synchronized(this) { + _busy_timeout(ms); + } + } + + private native void _busy_timeout(int ms); + + /** + * Convenience method to retrieve an entire result + * set into memory. + * + * @param sql the SQL statement to be executed + * @return result set + */ + + public TableResult get_table(String sql) throws SQLite.Exception { + TableResult ret = new TableResult(); + if (!is3()) { + exec(sql, ret); + } else { + synchronized(this) { + /* only one statement !!! */ + Vm vm = compile(sql); + set_last_error(vm.error_code); + while (vm.step(ret)) { + set_last_error(vm.error_code); + } + vm.finalize(); + } + } + return ret; + } + + /** + * Convenience method to retrieve an entire result + * set into memory. + * + * @param sql the SQL statement to be executed + * @param args arguments for the SQL statement, '%q' substitution + * @return result set + */ + + public TableResult get_table(String sql, String args[]) + throws SQLite.Exception { + TableResult ret = new TableResult(); + if (!is3()) { + exec(sql, ret, args); + } else { + synchronized(this) { + /* only one statement !!! */ + Vm vm = compile(sql, args); + set_last_error(vm.error_code); + while (vm.step(ret)) { + set_last_error(vm.error_code); + } + vm.finalize(); + } + } + return ret; + } + + /** + * Convenience method to retrieve an entire result + * set into memory. + * + * @param sql the SQL statement to be executed + * @param args arguments for the SQL statement, '%q' substitution + * @param tbl TableResult to receive result set + * @return result set + */ + + public void get_table(String sql, String args[], TableResult tbl) + throws SQLite.Exception { + tbl.clear(); + if (!is3()) { + exec(sql, tbl, args); + } else { + synchronized(this) { + /* only one statement !!! */ + Vm vm = compile(sql, args); + while (vm.step(tbl)) { + } + vm.finalize(); + } + } + } + + /** + * See if an SQL statement is complete. + * Returns true if the input string comprises + * one or more complete SQL statements. + * + * @param sql the SQL statement to be checked + */ + + public synchronized static boolean complete(String sql) { + return _complete(sql); + } + + private native static boolean _complete(String sql); + + /** + * Return SQLite version number as string. + * Don't rely on this when both SQLite 2 and 3 are compiled + * into the native part. Use the class method in this case. + */ + + public native static String version(); + + /** + * Return SQLite version number as string. + * If the database is not open, <tt>unknown</tt> is returned. + */ + + public native String dbversion(); + + /** + * Create regular function. + * + * @param name the name of the new function + * @param nargs number of arguments to function + * @param f interface of function + */ + + public void create_function(String name, int nargs, Function f) { + synchronized(this) { + _create_function(name, nargs, f); + } + } + + private native void _create_function(String name, int nargs, Function f); + + /** + * Create aggregate function. + * + * @param name the name of the new function + * @param nargs number of arguments to function + * @param f interface of function + */ + + public void create_aggregate(String name, int nargs, Function f) { + synchronized(this) { + _create_aggregate(name, nargs, f); + } + } + + private native void _create_aggregate(String name, int nargs, Function f); + + /** + * Set function return type. Only available in SQLite 2.6.0 and + * above, otherwise a no-op. + * + * @param name the name of the function whose return type is to be set + * @param type return type code, e.g. SQLite.Constants.SQLITE_NUMERIC + */ + + public void function_type(String name, int type) { + synchronized(this) { + _function_type(name, type); + } + } + + private native void _function_type(String name, int type); + + /** + * Return the code of the last error occured in + * any of the exec() methods. The value is valid + * after an Exception has been reported by one of + * these methods. See the <A HREF="Constants.html">Constants</A> + * class for possible values. + * + * @return SQLite error code + */ + + public int last_error() { + return error_code; + } + + /** + * Internal: set error code. + * @param error_code new error code + */ + + protected void set_last_error(int error_code) { + this.error_code = error_code; + } + + /** + * Return last error message of SQLite3 engine. + * + * @return error string or null + */ + + public String error_message() { + synchronized(this) { + return _errmsg(); + } + } + + private native String _errmsg(); + + /** + * Return error string given SQLite error code (SQLite2). + * + * @param error_code the error code + * @return error string + */ + + public static native String error_string(int error_code); + + /** + * Set character encoding. + * @param enc name of encoding + */ + + public void set_encoding(String enc) throws SQLite.Exception { + synchronized(this) { + _set_encoding(enc); + } + } + + private native void _set_encoding(String enc) + throws SQLite.Exception; + + /** + * Set authorizer function. Only available in SQLite 2.7.6 and + * above, otherwise a no-op. + * + * @param auth the authorizer function + */ + + public void set_authorizer(Authorizer auth) { + synchronized(this) { + _set_authorizer(auth); + } + } + + private native void _set_authorizer(Authorizer auth); + + /** + * Set trace function. Only available in SQLite 2.7.6 and above, + * otherwise a no-op. + * + * @param tr the trace function + */ + + public void trace(Trace tr) { + synchronized(this) { + _trace(tr); + } + } + + private native void _trace(Trace tr); + + /** + * Compile and return SQLite VM for SQL statement. Only available + * in SQLite 2.8.0 and above, otherwise a no-op. + * + * @param sql SQL statement to be compiled + * @return a Vm object + */ + + public Vm compile(String sql) throws SQLite.Exception { + synchronized(this) { + Vm vm = new Vm(); + vm_compile(sql, vm); + return vm; + } + } + + /** + * Compile and return SQLite VM for SQL statement. Only available + * in SQLite 3.0 and above, otherwise a no-op. + * + * @param sql SQL statement to be compiled + * @param args arguments for the SQL statement, '%q' substitution + * @return a Vm object + */ + + public Vm compile(String sql, String args[]) throws SQLite.Exception { + synchronized(this) { + Vm vm = new Vm(); + vm_compile_args(sql, vm, args); + return vm; + } + } + + /** + * Prepare and return SQLite3 statement for SQL. Only available + * in SQLite 3.0 and above, otherwise a no-op. + * + * @param sql SQL statement to be prepared + * @return a Stmt object + */ + + public Stmt prepare(String sql) throws SQLite.Exception { + synchronized(this) { + Stmt stmt = new Stmt(); + stmt_prepare(sql, stmt); + return stmt; + } + } + + /** + * Open an SQLite3 blob. Only available in SQLite 3.4.0 and above. + * @param db database name + * @param table table name + * @param column column name + * @param row row identifier + * @param rw if true, open for read-write, else read-only + * @return a Blob object + */ + + public Blob open_blob(String db, String table, String column, + long row, boolean rw) throws SQLite.Exception { + synchronized(this) { + Blob blob = new Blob(); + _open_blob(db, table, column, row, rw, blob); + return blob; + } + } + + /** + * Check type of open database. + * @return true if SQLite3 database + */ + + public native boolean is3(); + + /** + * Internal compile method. + * @param sql SQL statement + * @param vm Vm object + */ + + private native void vm_compile(String sql, Vm vm) + throws SQLite.Exception; + + /** + * Internal compile method, SQLite 3.0 only. + * @param sql SQL statement + * @param args arguments for the SQL statement, '%q' substitution + * @param vm Vm object + */ + + private native void vm_compile_args(String sql, Vm vm, String args[]) + throws SQLite.Exception; + + /** + * Internal SQLite3 prepare method. + * @param sql SQL statement + * @param stmt Stmt object + */ + + private native void stmt_prepare(String sql, Stmt stmt) + throws SQLite.Exception; + + /** + * Internal SQLite open blob method. + * @param db database name + * @param table table name + * @param column column name + * @param row row identifier + * @param rw if true, open for read-write, else read-only + * @param blob Blob object + */ + + private native void _open_blob(String db, String table, String column, + long row, boolean rw, Blob blob) + throws SQLite.Exception; + + /** + * Establish a progress callback method which gets called after + * N SQLite VM opcodes. + * + * @param n number of SQLite VM opcodes until callback is invoked + * @param p the object implementing the progress callback method + */ + + public void progress_handler(int n, SQLite.ProgressHandler p) { + synchronized(this) { + _progress_handler(n, p); + } + } + + private native void _progress_handler(int n, SQLite.ProgressHandler p); + + /** + * Internal native initializer. + */ + + private static native void internal_init(); + + /** + * Static initializer to load the native part. + */ + + static { + try { +// String path = System.getProperty("SQLite.library.path"); +// if (path == null || path.length() == 0){ +// System.loadLibrary("sqlite_jni"); +// } else { +// try { +// java.lang.reflect.Method mapLibraryName; +// Class param[] = new Class[1]; +// param[0] = String.class; +// mapLibraryName = System.class.getMethod("mapLibraryName", +// param); +// Object args[] = new Object[1]; +// args[0] = "sqlite_jni"; +// String mapped = (String) mapLibraryName.invoke(null, args); +// System.load(path + java.io.File.separator + mapped); +// } catch (Throwable t) { +// System.loadLibrary("sqlite_jni"); +// } +// } + internal_init(); + } catch (Throwable t) { + System.err.println("Unable to load sqlite: " + t); + } + } +} + diff --git a/sql/src/main/java/SQLite/Exception.java b/sql/src/main/java/SQLite/Exception.java new file mode 100644 index 0000000..cc26b99 --- /dev/null +++ b/sql/src/main/java/SQLite/Exception.java @@ -0,0 +1,18 @@ +package SQLite; + +/** + * Class for SQLite related exceptions. + */ + +public class Exception extends java.lang.Exception { + + /** + * Construct a new SQLite exception. + * + * @param string error message + */ + + public Exception(String string) { + super(string); + } +} diff --git a/sql/src/main/java/SQLite/Function.java b/sql/src/main/java/SQLite/Function.java new file mode 100644 index 0000000..5aa5e33 --- /dev/null +++ b/sql/src/main/java/SQLite/Function.java @@ -0,0 +1,59 @@ +package SQLite; + +/** + * Callback interface for SQLite's user defined functions. + * Each callback method receives a + * <A HREF="FunctionContext.html">FunctionContext</A> object + * which is used to set the function result or error code. + * <BR><BR> + * Example:<BR> + * + * <PRE> + * class SinFunc implements SQLite.Function { + * public void function(SQLite.FunctionContext fc, String args[]) { + * try { + * Double d = new Double(args[0]); + * fc.set_result(Math.sin(d.doubleValue())); + * } catch (Exception e) { + * fc.set_error("sin(" + args[0] + "):" + e); + * } + * } + * ... + * } + * SQLite.Database db = new SQLite.Database(); + * db.open("db", 0); + * db.create_function("sin", 1, SinFunc); + * ... + * db.exec("select sin(1.0) from test", null); + * </PRE> + */ + +public interface Function { + + /** + * Callback for regular function. + * + * @param fc function's context for reporting result + * @param args String array of arguments + */ + + public void function(FunctionContext fc, String args[]); + + /** + * Callback for one step in aggregate function. + * + * @param fc function's context for reporting result + * @param args String array of arguments + */ + + public void step(FunctionContext fc, String args[]); + + /** + * Callback for final step in aggregate function. + * + * @param fc function's context for reporting result + */ + + public void last_step(FunctionContext fc); + +} diff --git a/sql/src/main/java/SQLite/FunctionContext.java b/sql/src/main/java/SQLite/FunctionContext.java new file mode 100644 index 0000000..d0b5182 --- /dev/null +++ b/sql/src/main/java/SQLite/FunctionContext.java @@ -0,0 +1,82 @@ +package SQLite; + +/** + * Context for execution of SQLite's user defined functions. + * A reference to an instance of this class is passed to + * user defined functions. + */ + +public class FunctionContext { + + /** + * Internal handle for the native SQLite API. + */ + + private long handle = 0; + + /** + * Set function result from string. + * + * @param r result string + */ + + public native void set_result(String r); + + /** + * Set function result from integer. + * + * @param r result integer + */ + + public native void set_result(int r); + + /** + * Set function result from double. + * + * @param r result double + */ + + public native void set_result(double r); + + /** + * Set function result from error message. + * + * @param r result string (error message) + */ + + public native void set_error(String r); + + /** + * Set function result from byte array. + * Only provided by SQLite3 databases. + * + * @param r result byte array + */ + + public native void set_result(byte[] r); + + /** + * Set function result as empty blob given size. + * Only provided by SQLite3 databases. + * + * @param n size for empty blob + */ + + public native void set_result_zeroblob(int n); + + /** + * Retrieve number of rows for aggregate function. + */ + + public native int count(); + + /** + * Internal native initializer. + */ + + private static native void internal_init(); + + static { + internal_init(); + } +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCConnection.java b/sql/src/main/java/SQLite/JDBC2y/JDBCConnection.java new file mode 100644 index 0000000..20c98e3 --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCConnection.java @@ -0,0 +1,452 @@ +package SQLite.JDBC2y; + +import java.sql.*; +import java.util.*; + +public class JDBCConnection + implements java.sql.Connection, SQLite.BusyHandler { + + /** + * Open database. + */ + protected DatabaseX db; + + /** + * Database URL. + */ + protected String url; + + /** + * Character encoding. + */ + protected String enc; + + /** + * Autocommit flag, true means autocommit. + */ + protected boolean autocommit = true; + + /** + * In-transaction flag. + * Can be true only when autocommit false. + */ + protected boolean intrans = false; + + /** + * Timeout for Database.exec() + */ + protected int timeout = 1000000; + + /** + * File name of database. + */ + private String dbfile = null; + + /** + * Reference to meta data or null. + */ + private JDBCDatabaseMetaData meta = null; + + /** + * Base time value for timeout handling. + */ + private long t0; + + /** + * Database in readonly mode. + */ + private boolean readonly = false; + + + private boolean busy0(DatabaseX db, int count) { + if (count <= 1) { + t0 = System.currentTimeMillis(); + } + if (db != null) { + long t1 = System.currentTimeMillis(); + if (t1 - t0 > timeout) { + return false; + } + db.wait(100); + return true; + } + return false; + } + + public boolean busy(String table, int count) { + return busy0(db, count); + } + + protected boolean busy3(DatabaseX db, int count) { + if (count <= 1) { + t0 = System.currentTimeMillis(); + } + if (db != null) { + long t1 = System.currentTimeMillis(); + if (t1 - t0 > timeout) { + return false; + } + return true; + } + return false; + } + + private DatabaseX open(boolean readonly) throws SQLException { + DatabaseX db = null; + try { + db = new DatabaseX(); + db.open(dbfile, readonly ? 0444 : 0644); + db.set_encoding(enc); + } catch (SQLite.Exception e) { + throw new SQLException(e.toString()); + } + int loop = 0; + while (true) { + try { + db.exec("PRAGMA short_column_names = off;", null); + db.exec("PRAGMA full_column_names = on;", null); + db.exec("PRAGMA empty_result_callbacks = on;", null); + if (SQLite.Database.version().compareTo("2.6.0") >= 0) { + db.exec("PRAGMA show_datatypes = on;", null); + } + } catch (SQLite.Exception e) { + if (db.last_error() != SQLite.Constants.SQLITE_BUSY || + !busy0(db, ++loop)) { + try { + db.close(); + } catch (SQLite.Exception ee) { + } + throw new SQLException(e.toString()); + } + continue; + } + break; + } + return db; + } + + public JDBCConnection(String url, String enc) throws SQLException { + if (url.startsWith("sqlite:/")) { + dbfile = url.substring(8); + } else if (url.startsWith("jdbc:sqlite:/")) { + dbfile = url.substring(13); + } else { + throw new SQLException("unsupported url"); + } + this.url = url; + this.enc = enc; + try { + db = open(readonly); + db.busy_handler(this); + } catch (SQLException e) { + if (db != null) { + try { + db.close(); + } catch (SQLite.Exception ee) { + } + } + throw e; + } + } + + /* non-standard */ + public SQLite.Database getSQLiteDatabase() { + return (SQLite.Database) db; + } + + public Statement createStatement() { + JDBCStatement s = new JDBCStatement(this); + return s; + } + + public Statement createStatement(int resultSetType, + int resultSetConcurrency) + throws SQLException { + JDBCStatement s = new JDBCStatement(this); + return s; + } + + public DatabaseMetaData getMetaData() throws SQLException { + if (meta == null) { + meta = new JDBCDatabaseMetaData(this); + } + return meta; + } + + public void close() throws SQLException { + try { + rollback(); + } catch (SQLException e) { + /* ignored */ + } + intrans = false; + if (db != null) { + try { + db.close(); + db = null; + } catch (SQLite.Exception e) { + throw new SQLException(e.toString()); + } + } + } + + public boolean isClosed() throws SQLException { + return db == null; + } + + public boolean isReadOnly() throws SQLException { + return readonly; + } + + public void clearWarnings() throws SQLException { + } + + public void commit() throws SQLException { + if (db == null) { + throw new SQLException("stale connection"); + } + if (!intrans) { + return; + } + try { + db.exec("COMMIT", null); + intrans = false; + } catch (SQLite.Exception e) { + throw new SQLException(e.toString()); + } + } + + public boolean getAutoCommit() throws SQLException { + return autocommit; + } + + public String getCatalog() throws SQLException { + return null; + } + + public int getTransactionIsolation() throws SQLException { + return TRANSACTION_SERIALIZABLE; + } + + public SQLWarning getWarnings() throws SQLException { + return null; + } + + public String nativeSQL(String sql) throws SQLException { + throw new SQLException("not supported"); + } + + public CallableStatement prepareCall(String sql) throws SQLException { + throw new SQLException("not supported"); + } + + public CallableStatement prepareCall(String sql, int x, int y) + throws SQLException { + throw new SQLException("not supported"); + } + + public PreparedStatement prepareStatement(String sql) throws SQLException { + JDBCPreparedStatement s = new JDBCPreparedStatement(this, sql); + return s; + } + + public PreparedStatement prepareStatement(String sql, int resultSetType, + int resultSetConcurrency) + throws SQLException { + JDBCPreparedStatement s = new JDBCPreparedStatement(this, sql); + return s; + } + + public void rollback() throws SQLException { + if (db == null) { + throw new SQLException("stale connection"); + } + if (!intrans) { + return; + } + try { + db.exec("ROLLBACK", null); + intrans = false; + } catch (SQLite.Exception e) { + throw new SQLException(e.toString()); + } + } + + public void setAutoCommit(boolean ac) throws SQLException { + if (ac && intrans && db != null) { + try { + db.exec("ROLLBACK", null); + } catch (SQLite.Exception e) { + throw new SQLException(e.toString()); + } + } + intrans = false; + autocommit = ac; + } + + public void setCatalog(String catalog) throws SQLException { + } + + public void setReadOnly(boolean ro) throws SQLException { + if (intrans) { + throw new SQLException("incomplete transaction"); + } + if (ro != readonly) { + DatabaseX db = null; + try { + db = open(ro); + this.db.close(); + this.db = db; + db = null; + readonly = ro; + } catch (SQLException e) { + throw e; + } catch (SQLite.Exception ee) { + if (db != null) { + try { + db.close(); + } catch (SQLite.Exception eee) { + } + } + throw new SQLException(ee.toString()); + } + } + } + + public void setTransactionIsolation(int level) throws SQLException { + if (level != TRANSACTION_SERIALIZABLE) { + throw new SQLException("not supported"); + } + } + + public java.util.Map<String, Class<?>> getTypeMap() throws SQLException { + throw new SQLException("not supported"); + } + + public void setTypeMap(java.util.Map map) throws SQLException { + throw new SQLException("not supported"); + } + + public int getHoldability() throws SQLException { + return ResultSet.HOLD_CURSORS_OVER_COMMIT; + } + + public void setHoldability(int holdability) throws SQLException { + if (holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT) { + return; + } + throw new SQLException("not supported"); + } + + public Savepoint setSavepoint() throws SQLException { + throw new SQLException("not supported"); + } + + public Savepoint setSavepoint(String name) throws SQLException { + throw new SQLException("not supported"); + } + + public void rollback(Savepoint x) throws SQLException { + throw new SQLException("not supported"); + } + + public void releaseSavepoint(Savepoint x) throws SQLException { + throw new SQLException("not supported"); + } + + public Statement createStatement(int resultSetType, + int resultSetConcurrency, + int resultSetHoldability) + throws SQLException { + if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT) { + throw new SQLException("not supported"); + } + return createStatement(resultSetType, resultSetConcurrency); + } + + public PreparedStatement prepareStatement(String sql, int resultSetType, + int resultSetConcurrency, + int resultSetHoldability) + throws SQLException { + if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT) { + throw new SQLException("not supported"); + } + return prepareStatement(sql, resultSetType, resultSetConcurrency); + } + + public CallableStatement prepareCall(String sql, int x, int y, int z) + throws SQLException { + throw new SQLException("not supported"); + } + + public PreparedStatement prepareStatement(String sql, int autokeys) + throws SQLException { + if (autokeys != Statement.NO_GENERATED_KEYS) { + throw new SQLException("not supported"); + } + return prepareStatement(sql); + } + + public PreparedStatement prepareStatement(String sql, int colIndexes[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public PreparedStatement prepareStatement(String sql, String columns[]) + throws SQLException { + throw new SQLException("not supported"); + } + +} + +class DatabaseX extends SQLite.Database { + + static Object lock = new Object(); + + public DatabaseX() { + super(); + } + + void wait(int ms) { + try { + synchronized (lock) { + lock.wait(ms); + } + } catch (java.lang.Exception e) { + } + } + + public void exec(String sql, SQLite.Callback cb) + throws SQLite.Exception { + super.exec(sql, cb); + synchronized (lock) { + lock.notifyAll(); + } + } + + public void exec(String sql, SQLite.Callback cb, String args[]) + throws SQLite.Exception { + super.exec(sql, cb, args); + synchronized (lock) { + lock.notifyAll(); + } + } + + public SQLite.TableResult get_table(String sql, String args[]) + throws SQLite.Exception { + SQLite.TableResult ret = super.get_table(sql, args); + synchronized (lock) { + lock.notifyAll(); + } + return ret; + } + + public void get_table(String sql, String args[], SQLite.TableResult tbl) + throws SQLite.Exception { + super.get_table(sql, args, tbl); + synchronized (lock) { + lock.notifyAll(); + } + } + +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCDatabaseMetaData.java b/sql/src/main/java/SQLite/JDBC2y/JDBCDatabaseMetaData.java new file mode 100644 index 0000000..8c14d1d --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCDatabaseMetaData.java @@ -0,0 +1,1578 @@ +package SQLite.JDBC2y; + +import java.sql.*; +import java.util.Hashtable; + +public class JDBCDatabaseMetaData implements DatabaseMetaData { + + private JDBCConnection conn; + + public JDBCDatabaseMetaData(JDBCConnection conn) { + this.conn = conn; + } + + public boolean allProceduresAreCallable() throws SQLException { + return false; + } + + public boolean allTablesAreSelectable() throws SQLException { + return true; + } + + public String getURL() throws SQLException { + return conn.url; + } + + public String getUserName() throws SQLException { + return ""; + } + + public boolean isReadOnly() throws SQLException { + return false; + } + + public boolean nullsAreSortedHigh() throws SQLException { + return false; + } + + public boolean nullsAreSortedLow() throws SQLException { + return false; + } + + public boolean nullsAreSortedAtStart() throws SQLException { + return false; + } + + public boolean nullsAreSortedAtEnd() throws SQLException { + return false; + } + + public String getDatabaseProductName() throws SQLException { + return "SQLite"; + } + + public String getDatabaseProductVersion() throws SQLException { + return SQLite.Database.version(); + } + + public String getDriverName() throws SQLException { + return "SQLite/JDBC"; + } + + public String getDriverVersion() throws SQLException { + return "" + SQLite.JDBCDriver.MAJORVERSION + "." + + SQLite.JDBCDriver.MINORVERSION; + } + + public int getDriverMajorVersion() { + return SQLite.JDBCDriver.MAJORVERSION; + } + + public int getDriverMinorVersion() { + return SQLite.JDBCDriver.MINORVERSION; + } + + public boolean usesLocalFiles() throws SQLException { + return true; + } + + public boolean usesLocalFilePerTable() throws SQLException { + return false; + } + + public boolean supportsMixedCaseIdentifiers() throws SQLException { + return false; + } + + public boolean storesUpperCaseIdentifiers() throws SQLException { + return false; + } + + public boolean storesLowerCaseIdentifiers() throws SQLException { + return false; + } + + public boolean storesMixedCaseIdentifiers() throws SQLException { + return true; + } + + public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException { + return false; + } + + public boolean storesUpperCaseQuotedIdentifiers() throws SQLException { + return false; + } + + public boolean storesLowerCaseQuotedIdentifiers() throws SQLException { + return false; + } + + public boolean storesMixedCaseQuotedIdentifiers() throws SQLException { + return true; + } + + public String getIdentifierQuoteString() throws SQLException { + return "\""; + } + + public String getSQLKeywords() throws SQLException { + return "SELECT,UPDATE,CREATE,TABLE,VIEW,DELETE,FROM,WHERE" + + ",COMMIT,ROLLBACK,TRIGGER"; + } + + public String getNumericFunctions() throws SQLException { + return ""; + } + + public String getStringFunctions() throws SQLException { + return ""; + } + + public String getSystemFunctions() throws SQLException { + return ""; + } + + public String getTimeDateFunctions() throws SQLException { + return ""; + } + + public String getSearchStringEscape() throws SQLException { + return "\\"; + } + + public String getExtraNameCharacters() throws SQLException { + return ""; + } + + public boolean supportsAlterTableWithAddColumn() throws SQLException { + return false; + } + + public boolean supportsAlterTableWithDropColumn() throws SQLException { + return false; + } + + public boolean supportsColumnAliasing() throws SQLException { + return true; + } + + public boolean nullPlusNonNullIsNull() throws SQLException { + return false; + } + + public boolean supportsConvert() throws SQLException { + return false; + } + + public boolean supportsConvert(int fromType, int toType) + throws SQLException { + return false; + } + + public boolean supportsTableCorrelationNames() throws SQLException { + return true; + } + + public boolean supportsDifferentTableCorrelationNames() + throws SQLException { + return false; + } + + public boolean supportsExpressionsInOrderBy() throws SQLException { + return true; + } + + public boolean supportsOrderByUnrelated() throws SQLException { + return true; + } + + public boolean supportsGroupBy() throws SQLException { + return true; + } + + public boolean supportsGroupByUnrelated() throws SQLException { + return true; + } + + public boolean supportsGroupByBeyondSelect() throws SQLException { + return false; + } + + public boolean supportsLikeEscapeClause() throws SQLException { + return false; + } + + public boolean supportsMultipleResultSets() throws SQLException { + return false; + } + + public boolean supportsMultipleTransactions() throws SQLException { + return false; + } + + public boolean supportsNonNullableColumns() throws SQLException { + return true; + } + + public boolean supportsMinimumSQLGrammar() throws SQLException { + return true; + } + + public boolean supportsCoreSQLGrammar() throws SQLException { + return false; + } + + public boolean supportsExtendedSQLGrammar() throws SQLException { + return false; + } + + public boolean supportsANSI92EntryLevelSQL() throws SQLException { + return true; + } + + public boolean supportsANSI92IntermediateSQL() throws SQLException { + return false; + } + + public boolean supportsANSI92FullSQL() throws SQLException { + return false; + } + + public boolean supportsIntegrityEnhancementFacility() + throws SQLException { + return false; + } + + public boolean supportsOuterJoins() throws SQLException { + return false; + } + + public boolean supportsFullOuterJoins() throws SQLException { + return false; + } + + public boolean supportsLimitedOuterJoins() throws SQLException { + return false; + } + + public String getSchemaTerm() throws SQLException { + return ""; + } + + public String getProcedureTerm() throws SQLException { + return ""; + } + + public String getCatalogTerm() throws SQLException { + return ""; + } + + public boolean isCatalogAtStart() throws SQLException { + return false; + } + + public String getCatalogSeparator() throws SQLException { + return ""; + } + + public boolean supportsSchemasInDataManipulation() throws SQLException { + return false; + } + + public boolean supportsSchemasInProcedureCalls() throws SQLException { + return false; + } + + public boolean supportsSchemasInTableDefinitions() throws SQLException { + return false; + } + + public boolean supportsSchemasInIndexDefinitions() throws SQLException { + return false; + } + + public boolean supportsSchemasInPrivilegeDefinitions() + throws SQLException { + return false; + } + + public boolean supportsCatalogsInDataManipulation() throws SQLException { + return false; + } + + public boolean supportsCatalogsInProcedureCalls() throws SQLException { + return false; + } + + public boolean supportsCatalogsInTableDefinitions() throws SQLException { + return false; + } + + public boolean supportsCatalogsInIndexDefinitions() throws SQLException { + return false; + } + + public boolean supportsCatalogsInPrivilegeDefinitions() + throws SQLException { + return false; + } + + public boolean supportsPositionedDelete() throws SQLException { + return false; + } + + public boolean supportsPositionedUpdate() throws SQLException { + return false; + } + + public boolean supportsSelectForUpdate() throws SQLException { + return true; + } + + public boolean supportsStoredProcedures() throws SQLException { + return false; + } + + public boolean supportsSubqueriesInComparisons() throws SQLException { + return true; + } + + public boolean supportsSubqueriesInExists() throws SQLException { + return true; + } + + public boolean supportsSubqueriesInIns() throws SQLException { + return true; + } + + public boolean supportsSubqueriesInQuantifieds() throws SQLException { + return false; + } + + public boolean supportsCorrelatedSubqueries() throws SQLException { + return false; + } + + public boolean supportsUnion() throws SQLException { + return false; + } + + public boolean supportsUnionAll() throws SQLException { + return false; + } + + public boolean supportsOpenCursorsAcrossCommit() throws SQLException { + return false; + } + + public boolean supportsOpenCursorsAcrossRollback() throws SQLException { + return false; + } + + public boolean supportsOpenStatementsAcrossCommit() throws SQLException { + return false; + } + + public boolean supportsOpenStatementsAcrossRollback() throws SQLException { + return false; + } + + public int getMaxBinaryLiteralLength() throws SQLException { + return 0; + } + + public int getMaxCharLiteralLength() throws SQLException { + return 0; + } + + public int getMaxColumnNameLength() throws SQLException { + return 0; + } + + public int getMaxColumnsInGroupBy() throws SQLException { + return 0; + } + + public int getMaxColumnsInIndex() throws SQLException { + return 0; + } + + public int getMaxColumnsInOrderBy() throws SQLException { + return 0; + } + + public int getMaxColumnsInSelect() throws SQLException { + return 0; + } + + public int getMaxColumnsInTable() throws SQLException { + return 0; + } + + public int getMaxConnections() throws SQLException { + return 0; + } + + public int getMaxCursorNameLength() throws SQLException { + return 8; + } + + public int getMaxIndexLength() throws SQLException { + return 0; + } + + public int getMaxSchemaNameLength() throws SQLException { + return 0; + } + + public int getMaxProcedureNameLength() throws SQLException { + return 0; + } + + public int getMaxCatalogNameLength() throws SQLException { + return 0; + } + + public int getMaxRowSize() throws SQLException { + return 0; + } + + public boolean doesMaxRowSizeIncludeBlobs() throws SQLException { + return true; + } + + public int getMaxStatementLength() throws SQLException { + return 0; + } + + public int getMaxStatements() throws SQLException { + return 0; + } + + public int getMaxTableNameLength() throws SQLException { + return 0; + } + + public int getMaxTablesInSelect() throws SQLException { + return 0; + } + + public int getMaxUserNameLength() throws SQLException { + return 0; + } + + public int getDefaultTransactionIsolation() throws SQLException { + return Connection.TRANSACTION_SERIALIZABLE; + } + + public boolean supportsTransactions() throws SQLException { + return true; + } + + public boolean supportsTransactionIsolationLevel(int level) + throws SQLException { + return level == Connection.TRANSACTION_SERIALIZABLE; + } + + public boolean supportsDataDefinitionAndDataManipulationTransactions() + throws SQLException { + return true; + } + + public boolean supportsDataManipulationTransactionsOnly() + throws SQLException { + return false; + } + + public boolean dataDefinitionCausesTransactionCommit() + throws SQLException { + return false; + } + + public boolean dataDefinitionIgnoredInTransactions() throws SQLException { + return false; + } + + public ResultSet getProcedures(String catalog, String schemaPattern, + String procedureNamePattern) + throws SQLException { + return null; + } + + public ResultSet getProcedureColumns(String catalog, + String schemaPattern, + String procedureNamePattern, + String columnNamePattern) + throws SQLException { + return null; + } + + public ResultSet getTables(String catalog, String schemaPattern, + String tableNamePattern, String types[]) + throws SQLException { + JDBCStatement s = new JDBCStatement(conn); + StringBuffer sb = new StringBuffer(); + sb.append("SELECT '' AS 'TABLE_CAT', " + + "'' AS 'TABLE_SCHEM', " + + "tbl_name AS 'TABLE_NAME', " + + "upper(type) AS 'TABLE_TYPE', " + + "'' AS REMARKS FROM sqlite_master " + + "WHERE tbl_name like "); + if (tableNamePattern != null) { + sb.append(SQLite.Shell.sql_quote(tableNamePattern)); + } else { + sb.append("'%'"); + } + sb.append(" AND "); + if (types == null || types.length == 0) { + sb.append("(type = 'table' or type = 'view')"); + } else { + sb.append("("); + String sep = ""; + for (int i = 0; i < types.length; i++) { + sb.append(sep); + sb.append("type = "); + sb.append(SQLite.Shell.sql_quote(types[i].toLowerCase())); + sep = " or "; + } + sb.append(")"); + } + ResultSet rs = null; + try { + rs = s.executeQuery(sb.toString()); + s.close(); + } catch (SQLException e) { + throw e; + } finally { + s.close(); + } + return rs; + } + + public ResultSet getSchemas() throws SQLException { + String cols[] = { "TABLE_SCHEM" }; + SQLite.TableResult tr = new SQLite.TableResult(); + tr.columns(cols); + String row[] = { "" }; + tr.newrow(row); + JDBCResultSet rs = new JDBCResultSet(tr, null); + return (ResultSet) rs; + } + + public ResultSet getCatalogs() throws SQLException { + String cols[] = { "TABLE_CAT" }; + SQLite.TableResult tr = new SQLite.TableResult(); + tr.columns(cols); + String row[] = { "" }; + tr.newrow(row); + JDBCResultSet rs = new JDBCResultSet(tr, null); + return (ResultSet) rs; + } + + public ResultSet getTableTypes() throws SQLException { + String cols[] = { "TABLE_TYPE" }; + SQLite.TableResult tr = new SQLite.TableResult(); + tr.columns(cols); + String row[] = new String[1]; + row[0] = "TABLE"; + tr.newrow(row); + row = new String[1]; + row[0] = "VIEW"; + tr.newrow(row); + JDBCResultSet rs = new JDBCResultSet(tr, null); + return (ResultSet) rs; + } + + public ResultSet getColumns(String catalog, String schemaPattern, + String tableNamePattern, + String columnNamePattern) + throws SQLException { + JDBCStatement s = new JDBCStatement(conn); + JDBCResultSet rs0 = null; + try { + rs0 = (JDBCResultSet) + (s.executeQuery("PRAGMA table_info(" + + SQLite.Shell.sql_quote(tableNamePattern) + + ")")); + s.close(); + } catch (SQLException e) { + throw e; + } finally { + s.close(); + } + String cols[] = { + "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", + "COLUMN_NAME", "DATA_TYPE", "TYPE_NAME", + "COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_POINTS", + "NUM_PREC_RADIX", "NULLABLE", "REMARKS", + "COLUMN_DEF", "SQL_DATA_TYPE", "SQL_DATETIME_SUB", + "CHAR_OCTET_LENGTH", "ORDINAL_POSITION", "IS_NULLABLE" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.SMALLINT, Types.VARCHAR, + Types.INTEGER, Types.INTEGER, Types.INTEGER, + Types.INTEGER, Types.INTEGER, Types.VARCHAR, + Types.VARCHAR, Types.INTEGER, Types.INTEGER, + Types.INTEGER, Types.INTEGER, Types.VARCHAR + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + Hashtable<String, Integer> h = new Hashtable<String, Integer>(); + for (int i = 0; i < rs0.tr.ncolumns; i++) { + h.put(rs0.tr.column[i], new Integer(i)); + } + if (columnNamePattern != null && + columnNamePattern.charAt(0) == '%') { + columnNamePattern = null; + } + for (int i = 0; i < rs0.tr.nrows; i++) { + String r0[] = (String [])(rs0.tr.rows.elementAt(i)); + int col = ((Integer) h.get("name")).intValue(); + if (columnNamePattern != null) { + if (r0[col].compareTo(columnNamePattern) != 0) { + continue; + } + } + String row[] = new String[cols.length]; + row[0] = ""; + row[1] = ""; + row[2] = tableNamePattern; + row[3] = r0[col]; + col = ((Integer) h.get("type")).intValue(); + String typeStr = r0[col]; + int type = mapSqlType(typeStr); + row[4] = "" + type; + row[5] = mapTypeName(type); + row[6] = "" + getD(typeStr, type); + row[7] = "" + getM(typeStr, type); + row[8] = "10"; + row[9] = "0"; + row[11] = null; + col = ((Integer) h.get("dflt_value")).intValue(); + row[12] = r0[col]; + row[13] = "0"; + row[14] = "0"; + row[15] = "65536"; + col = ((Integer) h.get("cid")).intValue(); + Integer cid = new Integer(r0[col]); + row[16] = "" + (cid.intValue() + 1); + col = ((Integer) h.get("notnull")).intValue(); + row[17] = (r0[col].charAt(0) == '0') ? "YES" : "NO"; + row[10] = (r0[col].charAt(0) == '0') ? "" + columnNullable : + "" + columnNoNulls; + tr.newrow(row); + } + } + return rs; + } + + public ResultSet getColumnPrivileges(String catalog, String schema, + String table, + String columnNamePattern) + throws SQLException { + String cols[] = { + "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", + "COLUMN_NAME", "GRANTOR", "GRANTEE", + "PRIVILEGE", "IS_GRANTABLE" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + return rs; + } + + public ResultSet getTablePrivileges(String catalog, String schemaPattern, + String tableNamePattern) + throws SQLException { + String cols[] = { + "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", + "COLUMN_NAME", "GRANTOR", "GRANTEE", + "PRIVILEGE", "IS_GRANTABLE" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + return rs; + } + + public ResultSet getBestRowIdentifier(String catalog, String schema, + String table, int scope, + boolean nullable) + throws SQLException { + JDBCStatement s0 = new JDBCStatement(conn); + JDBCResultSet rs0 = null; + JDBCStatement s1 = new JDBCStatement(conn); + JDBCResultSet rs1 = null; + try { + rs0 = (JDBCResultSet) + (s0.executeQuery("PRAGMA index_list(" + + SQLite.Shell.sql_quote(table) + ")")); + rs1 = (JDBCResultSet) + (s1.executeQuery("PRAGMA table_info(" + + SQLite.Shell.sql_quote(table) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s0.close(); + s1.close(); + } + String cols[] = { + "SCOPE", "COLUMN_NAME", "DATA_TYPE", + "TYPE_NAME", "COLUMN_SIZE", "BUFFER_LENGTH", + "DECIMAL_DIGITS", "PSEUDO_COLUMN" + }; + int types[] = { + Types.SMALLINT, Types.VARCHAR, Types.SMALLINT, + Types.VARCHAR, Types.INTEGER, Types.INTEGER, + Types.SMALLINT, Types.SMALLINT + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0 && + rs1 != null && rs1.tr != null && rs1.tr.nrows > 0) { + Hashtable<String, Integer> h0 = new Hashtable<String, Integer>(); + for (int i = 0; i < rs0.tr.ncolumns; i++) { + h0.put(rs0.tr.column[i], new Integer(i)); + } + Hashtable<String, Integer> h1 = new Hashtable<String, Integer>(); + for (int i = 0; i < rs1.tr.ncolumns; i++) { + h1.put(rs1.tr.column[i], new Integer(i)); + } + for (int i = 0; i < rs0.tr.nrows; i++) { + String r0[] = (String [])(rs0.tr.rows.elementAt(i)); + int col = ((Integer) h0.get("unique")).intValue(); + String uniq = r0[col]; + col = ((Integer) h0.get("name")).intValue(); + String iname = r0[col]; + if (uniq.charAt(0) == '0') { + continue; + } + JDBCStatement s2 = new JDBCStatement(conn); + JDBCResultSet rs2 = null; + try { + rs2 = (JDBCResultSet) + (s2.executeQuery("PRAGMA index_info(" + + SQLite.Shell.sql_quote(iname) + ")")); + } catch (SQLException e) { + } finally { + s2.close(); + } + if (rs2 == null || rs2.tr == null || rs2.tr.nrows <= 0) { + continue; + } + Hashtable<String, Integer> h2 = + new Hashtable<String, Integer>(); + for (int k = 0; k < rs2.tr.ncolumns; k++) { + h2.put(rs2.tr.column[k], new Integer(k)); + } + for (int k = 0; k < rs2.tr.nrows; k++) { + String r2[] = (String [])(rs2.tr.rows.elementAt(k)); + col = ((Integer) h2.get("name")).intValue(); + String cname = r2[col]; + for (int m = 0; m < rs1.tr.nrows; m++) { + String r1[] = (String [])(rs1.tr.rows.elementAt(m)); + col = ((Integer) h1.get("name")).intValue(); + if (cname.compareTo(r1[col]) == 0) { + String row[] = new String[cols.length]; + row[0] = "" + scope; + row[1] = cname; + row[2] = "" + Types.VARCHAR; + row[3] = "VARCHAR"; + row[4] = "65536"; + row[5] = "0"; + row[6] = "0"; + row[7] = "" + bestRowNotPseudo; + tr.newrow(row); + } + } + } + } + } + if (tr.nrows <= 0) { + String row[] = new String[cols.length]; + row[0] = "" + scope; + row[1] = "_ROWID_"; + row[2] = "" + Types.INTEGER; + row[3] = "INTEGER"; + row[4] = "10"; + row[5] = "0"; + row[6] = "0"; + row[7] = "" + bestRowPseudo; + tr.newrow(row); + } + return rs; + } + + public ResultSet getVersionColumns(String catalog, String schema, + String table) throws SQLException { + String cols[] = { + "SCOPE", "COLUMN_NAME", "DATA_TYPE", + "TYPE_NAME", "COLUMN_SIZE", "BUFFER_LENGTH", + "DECIMAL_DIGITS", "PSEUDO_COLUMN" + }; + int types[] = { + Types.SMALLINT, Types.VARCHAR, Types.SMALLINT, + Types.VARCHAR, Types.INTEGER, Types.INTEGER, + Types.SMALLINT, Types.SMALLINT + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + return rs; + } + + public ResultSet getPrimaryKeys(String catalog, String schema, + String table) throws SQLException { + JDBCStatement s0 = new JDBCStatement(conn); + JDBCResultSet rs0 = null; + try { + rs0 = (JDBCResultSet) + (s0.executeQuery("PRAGMA index_list(" + + SQLite.Shell.sql_quote(table) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s0.close(); + } + String cols[] = { + "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", + "COLUMN_NAME", "KEY_SEQ", "PK_NAME" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.SMALLINT, Types.VARCHAR + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + Hashtable<String, Integer> h0 = new Hashtable<String, Integer>(); + for (int i = 0; i < rs0.tr.ncolumns; i++) { + h0.put(rs0.tr.column[i], new Integer(i)); + } + for (int i = 0; i < rs0.tr.nrows; i++) { + String r0[] = (String [])(rs0.tr.rows.elementAt(i)); + int col = ((Integer) h0.get("unique")).intValue(); + String uniq = r0[col]; + col = ((Integer) h0.get("name")).intValue(); + String iname = r0[col]; + if (uniq.charAt(0) == '0') { + continue; + } + JDBCStatement s1 = new JDBCStatement(conn); + JDBCResultSet rs1 = null; + try { + rs1 = (JDBCResultSet) + (s1.executeQuery("PRAGMA index_info(" + + SQLite.Shell.sql_quote(iname) + ")")); + } catch (SQLException e) { + } finally { + s1.close(); + } + if (rs1 == null || rs1.tr == null || rs1.tr.nrows <= 0) { + continue; + } + Hashtable<String, Integer> h1 = + new Hashtable<String, Integer>(); + for (int k = 0; k < rs1.tr.ncolumns; k++) { + h1.put(rs1.tr.column[k], new Integer(k)); + } + for (int k = 0; k < rs1.tr.nrows; k++) { + String r1[] = (String [])(rs1.tr.rows.elementAt(k)); + String row[] = new String[cols.length]; + row[0] = ""; + row[1] = ""; + row[2] = table; + col = ((Integer) h1.get("name")).intValue(); + row[3] = r1[col]; + col = ((Integer) h1.get("seqno")).intValue(); +// BEGIN android-changed + row[4] = "" + (Integer.parseInt(r1[col]) + 1); +// END android-changed + row[5] = iname; + tr.newrow(row); + } + } + } + JDBCStatement s1 = new JDBCStatement(conn); + try { + rs0 = (JDBCResultSet) + (s1.executeQuery("PRAGMA table_info(" + + SQLite.Shell.sql_quote(table) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s1.close(); + } + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + Hashtable<String, Integer> h0 = new Hashtable<String, Integer>(); + for (int i = 0; i < rs0.tr.ncolumns; i++) { + h0.put(rs0.tr.column[i], new Integer(i)); + } + for (int i = 0; i < rs0.tr.nrows; i++) { + String r0[] = (String [])(rs0.tr.rows.elementAt(i)); + int col = ((Integer) h0.get("type")).intValue(); + String type = r0[col]; + if (!type.equalsIgnoreCase("integer")) { + continue; + } + col = ((Integer) h0.get("pk")).intValue(); + String pk = r0[col]; + if (pk.charAt(0) == '0') { + continue; + } + String row[] = new String[cols.length]; + row[0] = ""; + row[1] = ""; + row[2] = table; + col = ((Integer) h0.get("name")).intValue(); + row[3] = r0[col]; + col = ((Integer) h0.get("cid")).intValue(); +// BEGIN android-changed + row[4] = "" + (Integer.parseInt(r0[col]) + 1); +// END android-changed + row[5] = ""; + tr.newrow(row); + } + } + return rs; + } + + private void internalImportedKeys(String table, String pktable, + JDBCResultSet in, TableResultX out) { + Hashtable<String, Integer> h0 = new Hashtable<String, Integer>(); + for (int i = 0; i < in.tr.ncolumns; i++) { + h0.put(in.tr.column[i], new Integer(i)); + } + for (int i = 0; i < in.tr.nrows; i++) { + String r0[] = (String [])(in.tr.rows.elementAt(i)); + int col = ((Integer) h0.get("table")).intValue(); + String pktab = r0[col]; + if (pktable != null && !pktable.equalsIgnoreCase(pktab)) { + continue; + } + col = ((Integer) h0.get("from")).intValue(); + String pkcol = r0[col]; + col = ((Integer) h0.get("to")).intValue(); + String fkcol = r0[col]; + col = ((Integer) h0.get("seq")).intValue(); + String seq = r0[col]; + String row[] = new String[out.ncolumns]; + row[0] = ""; + row[1] = ""; + row[2] = pktab; + row[3] = pkcol; + row[4] = ""; + row[5] = ""; + row[6] = table; + row[7] = fkcol == null ? pkcol : fkcol; +// BEGIN android-changed + row[8] = "" + ((Integer.parseInt(seq)) + 1); +// END android-changed + row[9] = + "" + java.sql.DatabaseMetaData.importedKeyNoAction; + row[10] = + "" + java.sql.DatabaseMetaData.importedKeyNoAction; + row[11] = null; + row[12] = null; + row[13] = + "" + java.sql.DatabaseMetaData.importedKeyNotDeferrable; + out.newrow(row); + } + } + + public ResultSet getImportedKeys(String catalog, String schema, + String table) throws SQLException { + JDBCStatement s0 = new JDBCStatement(conn); + JDBCResultSet rs0 = null; + try { + rs0 = (JDBCResultSet) + (s0.executeQuery("PRAGMA foreign_key_list(" + + SQLite.Shell.sql_quote(table) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s0.close(); + } + String cols[] = { + "PKTABLE_CAT", "PKTABLE_SCHEM", "PKTABLE_NAME", + "PKCOLUMN_NAME", "FKTABLE_CAT", "FKTABLE_SCHEM", + "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ", + "UPDATE_RULE", "DELETE_RULE", "FK_NAME", + "PK_NAME", "DEFERRABILITY" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, + Types.SMALLINT, Types.SMALLINT, Types.VARCHAR, + Types.VARCHAR, Types.SMALLINT + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet((SQLite.TableResult) tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + internalImportedKeys(table, null, rs0, tr); + } + return rs; + } + + public ResultSet getExportedKeys(String catalog, String schema, + String table) throws SQLException { + String cols[] = { + "PKTABLE_CAT", "PKTABLE_SCHEM", "PKTABLE_NAME", + "PKCOLUMN_NAME", "FKTABLE_CAT", "FKTABLE_SCHEM", + "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ", + "UPDATE_RULE", "DELETE_RULE", "FK_NAME", + "PK_NAME", "DEFERRABILITY" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, + Types.SMALLINT, Types.SMALLINT, Types.VARCHAR, + Types.VARCHAR, Types.SMALLINT + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet(tr, null); + return rs; + } + + public ResultSet getCrossReference(String primaryCatalog, + String primarySchema, + String primaryTable, + String foreignCatalog, + String foreignSchema, + String foreignTable) + throws SQLException { + JDBCResultSet rs0 = null; + if (foreignTable != null && foreignTable.charAt(0) != '%') { + JDBCStatement s0 = new JDBCStatement(conn); + try { + rs0 = (JDBCResultSet) + (s0.executeQuery("PRAGMA foreign_key_list(" + + SQLite.Shell.sql_quote(foreignTable) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s0.close(); + } + } + String cols[] = { + "PKTABLE_CAT", "PKTABLE_SCHEM", "PKTABLE_NAME", + "PKCOLUMN_NAME", "FKTABLE_CAT", "FKTABLE_SCHEM", + "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ", + "UPDATE_RULE", "DELETE_RULE", "FK_NAME", + "PK_NAME", "DEFERRABILITY" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, + Types.SMALLINT, Types.SMALLINT, Types.VARCHAR, + Types.VARCHAR, Types.SMALLINT + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet(tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + String pktable = null; + if (primaryTable != null && primaryTable.charAt(0) != '%') { + pktable = primaryTable; + } + internalImportedKeys(foreignTable, pktable, rs0, tr); + } + return rs; + } + + public ResultSet getTypeInfo() throws SQLException { + String cols[] = { + "TYPE_NAME", "DATA_TYPE", "PRECISION", + "LITERAL_PREFIX", "LITERAL_SUFFIX", "CREATE_PARAMS", + "NULLABLE", "CASE_SENSITIVE", "SEARCHABLE", + "UNSIGNED_ATTRIBUTE", "FIXED_PREC_SCALE", "AUTO_INCREMENT", + "LOCAL_TYPE_NAME", "MINIMUM_SCALE", "MAXIMUM_SCALE", + "SQL_DATA_TYPE", "SQL_DATETIME_SUB", "NUM_PREC_RADIX" + }; + int types[] = { + Types.VARCHAR, Types.SMALLINT, Types.INTEGER, + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.SMALLINT, Types.BIT, Types.SMALLINT, + Types.BIT, Types.BIT, Types.BIT, + Types.VARCHAR, Types.SMALLINT, Types.SMALLINT, + Types.INTEGER, Types.INTEGER, Types.INTEGER + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet(tr, null); + String row1[] = { + "VARCHAR", "" + Types.VARCHAR, "65536", + "'", "'", null, + "" + typeNullable, "1", "" + typeSearchable, + "0", "0", "0", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row1); + String row2[] = { + "INTEGER", "" + Types.INTEGER, "32", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "2" + }; + tr.newrow(row2); + String row3[] = { + "DOUBLE", "" + Types.DOUBLE, "16", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "10" + }; + tr.newrow(row3); + String row4[] = { + "FLOAT", "" + Types.FLOAT, "7", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "10" + }; + tr.newrow(row4); + String row5[] = { + "SMALLINT", "" + Types.SMALLINT, "16", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "2" + }; + tr.newrow(row5); + String row6[] = { + "BIT", "" + Types.BIT, "1", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "2" + }; + tr.newrow(row6); + String row7[] = { + "TIMESTAMP", "" + Types.TIMESTAMP, "30", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row7); + String row8[] = { + "DATE", "" + Types.DATE, "10", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row8); + String row9[] = { + "TIME", "" + Types.TIME, "8", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row9); + String row10[] = { + "BINARY", "" + Types.BINARY, "65536", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row10); + String row11[] = { + "VARBINARY", "" + Types.VARBINARY, "65536", + null, null, null, + "" + typeNullable, "0", "" + typeSearchable, + "0", "0", "1", + null, "0", "0", + "0", "0", "0" + }; + tr.newrow(row11); + return rs; + } + + public ResultSet getIndexInfo(String catalog, String schema, String table, + boolean unique, boolean approximate) + throws SQLException { + JDBCStatement s0 = new JDBCStatement(conn); + JDBCResultSet rs0 = null; + try { + rs0 = (JDBCResultSet) + (s0.executeQuery("PRAGMA index_list(" + + SQLite.Shell.sql_quote(table) + ")")); + } catch (SQLException e) { + throw e; + } finally { + s0.close(); + } + String cols[] = { + "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", + "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME", + "TYPE", "ORDINAL_POSITION", "COLUMN_NAME", + "ASC_OR_DESC", "CARDINALITY", "PAGES", + "FILTER_CONDITION" + }; + int types[] = { + Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, + Types.BIT, Types.VARCHAR, Types.VARCHAR, + Types.SMALLINT, Types.SMALLINT, Types.VARCHAR, + Types.VARCHAR, Types.INTEGER, Types.INTEGER, + Types.VARCHAR + }; + TableResultX tr = new TableResultX(); + tr.columns(cols); + tr.sql_types(types); + JDBCResultSet rs = new JDBCResultSet(tr, null); + if (rs0 != null && rs0.tr != null && rs0.tr.nrows > 0) { + Hashtable<String, Integer> h0 = new Hashtable<String, Integer>(); + for (int i = 0; i < rs0.tr.ncolumns; i++) { + h0.put(rs0.tr.column[i], new Integer(i)); + } + for (int i = 0; i < rs0.tr.nrows; i++) { + String r0[] = (String [])(rs0.tr.rows.elementAt(i)); + int col = ((Integer) h0.get("unique")).intValue(); + String uniq = r0[col]; + col = ((Integer) h0.get("name")).intValue(); + String iname = r0[col]; + if (unique && uniq.charAt(0) == '0') { + continue; + } + JDBCStatement s1 = new JDBCStatement(conn); + JDBCResultSet rs1 = null; + try { + rs1 = (JDBCResultSet) + (s1.executeQuery("PRAGMA index_info(" + + SQLite.Shell.sql_quote(iname) + ")")); + } catch (SQLException e) { + } finally { + s1.close(); + } + if (rs1 == null || rs1.tr == null || rs1.tr.nrows <= 0) { + continue; + } + Hashtable<String, Integer> h1 = + new Hashtable<String, Integer>(); + for (int k = 0; k < rs1.tr.ncolumns; k++) { + h1.put(rs1.tr.column[k], new Integer(k)); + } + for (int k = 0; k < rs1.tr.nrows; k++) { + String r1[] = (String [])(rs1.tr.rows.elementAt(k)); + String row[] = new String[cols.length]; + row[0] = ""; + row[1] = ""; + row[2] = table; + row[3] = (uniq.charAt(0) != '0' || + (iname.charAt(0) == '(' && + iname.indexOf(" autoindex ") > 0)) ? "0" : "1"; + row[4] = ""; + row[5] = iname; + row[6] = "" + tableIndexOther; + col = ((Integer) h1.get("seqno")).intValue(); +// BEGIN android-changed + row[7] = "" + (Integer.parseInt(r1[col]) + 1); +// END android-changed + col = ((Integer) h1.get("name")).intValue(); + row[8] = r1[col]; + row[9] = "A"; + row[10] = "0"; + row[11] = "0"; + row[12] = null; + tr.newrow(row); + } + } + } + return rs; + } + + public boolean supportsResultSetType(int type) throws SQLException { + return type == ResultSet.CONCUR_READ_ONLY; + } + + public boolean supportsResultSetConcurrency(int type, int concurrency) + throws SQLException { + return false; + } + + public boolean ownUpdatesAreVisible(int type) throws SQLException { + return false; + } + + public boolean ownDeletesAreVisible(int type) throws SQLException { + return false; + } + + public boolean ownInsertsAreVisible(int type) throws SQLException { + return false; + } + + public boolean othersUpdatesAreVisible(int type) throws SQLException { + return false; + } + + public boolean othersDeletesAreVisible(int type) throws SQLException { + return false; + } + + public boolean othersInsertsAreVisible(int type) throws SQLException { + return false; + } + + public boolean updatesAreDetected(int type) throws SQLException { + return false; + } + + public boolean deletesAreDetected(int type) throws SQLException { + return false; + } + + public boolean insertsAreDetected(int type) throws SQLException { + return false; + } + + public boolean supportsBatchUpdates() throws SQLException { + return false; + } + + public ResultSet getUDTs(String catalog, String schemaPattern, + String typeNamePattern, int[] types) + throws SQLException { + return null; + } + + public Connection getConnection() throws SQLException { + return conn; + } + + static String mapTypeName(int type) { + switch (type) { + case Types.INTEGER: return "integer"; + case Types.SMALLINT: return "smallint"; + case Types.FLOAT: return "float"; + case Types.DOUBLE: return "double"; + case Types.TIMESTAMP: return "timestamp"; + case Types.DATE: return "date"; + case Types.TIME: return "time"; + case Types.BINARY: return "binary"; + case Types.VARBINARY: return "varbinary"; + } + return "varchar"; + } + + static int mapSqlType(String type) { + if (type == null) { + return Types.VARCHAR; + } + type = type.toLowerCase(); + if (type.startsWith("inter")) { + return Types.VARCHAR; + } + if (type.startsWith("numeric") || + type.startsWith("int")) { + return Types.INTEGER; + } + if (type.startsWith("tinyint") || + type.startsWith("smallint")) { + return Types.SMALLINT; + } + if (type.startsWith("float")) { + return Types.FLOAT; + } + if (type.startsWith("double")) { + return Types.DOUBLE; + } + if (type.startsWith("datetime") || + type.startsWith("timestamp")) { + return Types.TIMESTAMP; + } + if (type.startsWith("date")) { + return Types.DATE; + } + if (type.startsWith("time")) { + return Types.TIME; + } + if (type.startsWith("blob")) { + return Types.BINARY; + } + if (type.startsWith("binary")) { + return Types.BINARY; + } + if (type.startsWith("varbinary")) { + return Types.VARBINARY; + } + return Types.VARCHAR; + } + + static int getM(String typeStr, int type) { + int m = 65536; + switch (type) { + case Types.INTEGER: m = 11; break; + case Types.SMALLINT: m = 6; break; + case Types.FLOAT: m = 25; break; + case Types.DOUBLE: m = 54; break; + case Types.TIMESTAMP: return 30; + case Types.DATE: return 10; + case Types.TIME: return 8; + } + typeStr = typeStr.toLowerCase(); + int i1 = typeStr.indexOf('('); + if (i1 > 0) { + ++i1; + int i2 = typeStr.indexOf(',', i1); + if (i2 < 0) { + i2 = typeStr.indexOf(')', i1); + } + if (i2 - i1 > 0) { + String num = typeStr.substring(i1, i2); + try { + m = java.lang.Integer.parseInt(num, 10); + } catch (NumberFormatException e) { + } + } + } + return m; + } + + static int getD(String typeStr, int type) { + int d = 0; + switch (type) { + case Types.INTEGER: d = 10; break; + case Types.SMALLINT: d = 5; break; + case Types.FLOAT: d = 24; break; + case Types.DOUBLE: d = 53; break; + default: return getM(typeStr, type); + } + typeStr = typeStr.toLowerCase(); + int i1 = typeStr.indexOf('('); + if (i1 > 0) { + ++i1; + int i2 = typeStr.indexOf(',', i1); + if (i2 < 0) { + return getM(typeStr, type); + } + i1 = i2; + i2 = typeStr.indexOf(')', i1); + if (i2 - i1 > 0) { + String num = typeStr.substring(i1, i2); + try { + d = java.lang.Integer.parseInt(num, 10); + } catch (NumberFormatException e) { + } + } + } + return d; + } + + public boolean supportsSavepoints() { + return false; + } + + public boolean supportsNamedParameters() { + return false; + } + + public boolean supportsMultipleOpenResults() { + return false; + } + + public boolean supportsGetGeneratedKeys() { + return false; + } + + public boolean supportsResultSetHoldability(int x) { + return false; + } + + public boolean supportsStatementPooling() { + return false; + } + + public boolean locatorsUpdateCopy() throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSet getSuperTypes(String catalog, String schemaPattern, + String typeNamePattern) + throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSet getSuperTables(String catalog, String schemaPattern, + String tableNamePattern) + throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSet getAttributes(String catalog, String schemaPattern, + String typeNamePattern, + String attributeNamePattern) + throws SQLException { + throw new SQLException("not supported"); + } + + public int getResultSetHoldability() throws SQLException { + return ResultSet.HOLD_CURSORS_OVER_COMMIT; + } + + public int getDatabaseMajorVersion() { + return SQLite.JDBCDriver.MAJORVERSION; + } + + public int getDatabaseMinorVersion() { + return SQLite.JDBCDriver.MINORVERSION; + } + + public int getJDBCMajorVersion() { + return 1; + } + + public int getJDBCMinorVersion() { + return 0; + } + + public int getSQLStateType() throws SQLException { + return sqlStateXOpen; + } + +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCPreparedStatement.java b/sql/src/main/java/SQLite/JDBC2y/JDBCPreparedStatement.java new file mode 100644 index 0000000..ab81867 --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCPreparedStatement.java @@ -0,0 +1,752 @@ +package SQLite.JDBC2y; + +import java.sql.*; +import java.math.BigDecimal; +import java.util.*; + +class BatchArg { + String arg; + boolean blob; + + BatchArg(String arg, boolean blob) { + if (arg == null) { + this.arg = null; + } else { + this.arg = new String(arg); + } + this.blob = blob; + } +} + +public class JDBCPreparedStatement extends JDBCStatement + implements java.sql.PreparedStatement { + + private String sql; + private String args[]; + private boolean blobs[]; + private ArrayList<BatchArg> batch; + private static final boolean nullrepl = + SQLite.Database.version().compareTo("2.5.0") < 0; + + public JDBCPreparedStatement(JDBCConnection conn, String sql) { + super(conn); + this.args = null; + this.blobs = null; + this.batch = null; + this.sql = fixup(sql); + } + + private String fixup(String sql) { + StringBuffer sb = new StringBuffer(); + boolean inq = false; + int nparm = 0; + for (int i = 0; i < sql.length(); i++) { + char c = sql.charAt(i); + if (c == '\'') { + if (inq) { + char nextChar = 0; + if(i + 1 < sql.length()) { + nextChar = sql.charAt(i + 1); + } + if (nextChar == '\'') { + sb.append(c); + sb.append(nextChar); + i++; + } else { + inq = false; + sb.append(c); + } + } else { + inq = true; + sb.append(c); + } + } else if (c == '?') { + if (inq) { + sb.append(c); + } else { + ++nparm; + sb.append(nullrepl ? "'%q'" : "%Q"); + } + } else if (c == ';') { + if (!inq) { + break; + } + sb.append(c); + } else if (c == '%') { + sb.append("%%"); + } else { + sb.append(c); + } + } + args = new String[nparm]; + blobs = new boolean[nparm]; + try { + clearParameters(); + } catch (SQLException e) { + } + return sb.toString(); + } + + private String fixup2(String sql) { + if (!conn.db.is3()) { + return sql; + } + StringBuffer sb = new StringBuffer(); + int parm = -1; + for (int i = 0; i < sql.length(); i++) { + char c = sql.charAt(i); + if (c == '%') { + sb.append(c); + ++i; + c = sql.charAt(i); + if (c == 'Q') { + parm++; + if (blobs[parm]) { + c = 's'; + } + } + } + sb.append(c); + } + return sb.toString(); + } + + public ResultSet executeQuery() throws SQLException { + return executeQuery(fixup2(sql), args, false); + } + + public int executeUpdate() throws SQLException { + executeQuery(fixup2(sql), args, true); + return updcnt; + } + + public void setNull(int parameterIndex, int sqlType) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = nullrepl ? "" : null; + blobs[parameterIndex - 1] = false; + } + + public void setBoolean(int parameterIndex, boolean x) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = x ? "1" : "0"; + blobs[parameterIndex - 1] = false; + } + + public void setByte(int parameterIndex, byte x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setShort(int parameterIndex, short x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setInt(int parameterIndex, int x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setLong(int parameterIndex, long x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setFloat(int parameterIndex, float x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setDouble(int parameterIndex, double x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + args[parameterIndex - 1] = "" + x; + blobs[parameterIndex - 1] = false; + } + + public void setBigDecimal(int parameterIndex, BigDecimal x) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + args[parameterIndex - 1] = "" + x; + } + blobs[parameterIndex - 1] = false; + } + + public void setString(int parameterIndex, String x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + args[parameterIndex - 1] = x; + } + blobs[parameterIndex - 1] = false; + } + + public void setBytes(int parameterIndex, byte x[]) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + blobs[parameterIndex - 1] = false; + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + if (conn.db.is3()) { + args[parameterIndex - 1] = SQLite.StringEncoder.encodeX(x); + blobs[parameterIndex - 1] = true; + } else { + args[parameterIndex - 1] = SQLite.StringEncoder.encode(x); + } + } + } + + public void setDate(int parameterIndex, java.sql.Date x) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + args[parameterIndex - 1] = x.toString(); + } + blobs[parameterIndex - 1] = false; + } + + public void setTime(int parameterIndex, java.sql.Time x) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + args[parameterIndex - 1] = x.toString(); + } + blobs[parameterIndex - 1] = false; + } + + public void setTimestamp(int parameterIndex, java.sql.Timestamp x) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + args[parameterIndex - 1] = x.toString(); + } + blobs[parameterIndex - 1] = false; + } + + public void setAsciiStream(int parameterIndex, java.io.InputStream x, + int length) throws SQLException { + throw new SQLException("not supported"); + } + + @Deprecated + public void setUnicodeStream(int parameterIndex, java.io.InputStream x, + int length) throws SQLException { + throw new SQLException("not supported"); + } + + public void setBinaryStream(int parameterIndex, java.io.InputStream x, + int length) throws SQLException { + throw new SQLException("not supported"); + } + + public void clearParameters() throws SQLException { + for (int i = 0; i < args.length; i++) { + args[i] = nullrepl ? "" : null; + blobs[i] = false; + } + } + + public void setObject(int parameterIndex, Object x, int targetSqlType, + int scale) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + if (x instanceof byte[]) { + byte[] bx = (byte[]) x; + if (conn.db.is3()) { + args[parameterIndex - 1] = + SQLite.StringEncoder.encodeX(bx); + blobs[parameterIndex - 1] = true; + return; + } + args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx); + } else { + args[parameterIndex - 1] = x.toString(); + } + } + blobs[parameterIndex - 1] = false; + } + + public void setObject(int parameterIndex, Object x, int targetSqlType) + throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + if (x instanceof byte[]) { + byte[] bx = (byte[]) x; + if (conn.db.is3()) { + args[parameterIndex - 1] = + SQLite.StringEncoder.encodeX(bx); + blobs[parameterIndex - 1] = true; + return; + } + args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx); + } else { + args[parameterIndex - 1] = x.toString(); + } + } + blobs[parameterIndex - 1] = false; + } + + public void setObject(int parameterIndex, Object x) throws SQLException { + if (parameterIndex < 1 || parameterIndex > args.length) { + throw new SQLException("bad parameter index"); + } + if (x == null) { + args[parameterIndex - 1] = nullrepl ? "" : null; + } else { + if (x instanceof byte[]) { + byte[] bx = (byte[]) x; + if (conn.db.is3()) { + args[parameterIndex - 1] = + SQLite.StringEncoder.encodeX(bx); + blobs[parameterIndex - 1] = true; + return; + } + args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx); + } else { + args[parameterIndex - 1] = x.toString(); + } + } + blobs[parameterIndex - 1] = false; + } + + public boolean execute() throws SQLException { + return executeQuery(fixup2(sql), args, false) != null; + } + + public void addBatch() throws SQLException { + if (batch == null) { + batch = new ArrayList<BatchArg>(args.length); + } + for (int i = 0; i < args.length; i++) { + batch.add(new BatchArg(args[i], blobs[i])); + } + } + + public int[] executeBatch() throws SQLException { + if (batch == null) { + return new int[0]; + } + int[] ret = new int[batch.size() / args.length]; + for (int i = 0; i < ret.length; i++) { + ret[i] = EXECUTE_FAILED; + } + int errs = 0; + int index = 0; + for (int i = 0; i < ret.length; i++) { + for (int k = 0; k < args.length; k++) { + BatchArg b = (BatchArg) batch.get(index++); + + args[i] = b.arg; + blobs[i] = b.blob; + } + try { + ret[i] = executeUpdate(); + } catch (SQLException e) { + ++errs; + } + } + if (errs > 0) { + throw new BatchUpdateException("batch failed", ret); + } + return ret; + } + + public void clearBatch() throws SQLException { + if (batch != null) { + batch.clear(); + batch = null; + } + } + + public void setCharacterStream(int parameterIndex, + java.io.Reader reader, + int length) throws SQLException { + throw new SQLException("not supported"); + } + + public void setRef(int i, Ref x) throws SQLException { + throw new SQLException("not supported"); + } + + public void setBlob(int i, Blob x) throws SQLException { + throw new SQLException("not supported"); + } + + public void setClob(int i, Clob x) throws SQLException { + throw new SQLException("not supported"); + } + + public void setArray(int i, Array x) throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSetMetaData getMetaData() throws SQLException { + return rs.getMetaData(); + } + + public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) + throws SQLException { + setDate(parameterIndex, x); + } + + public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) + throws SQLException { + setTime(parameterIndex, x); + } + + public void setTimestamp(int parameterIndex, java.sql.Timestamp x, + Calendar cal) throws SQLException { + setTimestamp(parameterIndex, x); + } + + public void setNull(int parameterIndex, int sqlType, String typeName) + throws SQLException { + setNull(parameterIndex, sqlType); + } + + public ParameterMetaData getParameterMetaData() throws SQLException { + throw new SQLException("not supported"); + } + + public void registerOutputParameter(String parameterName, int sqlType) + throws SQLException { + throw new SQLException("not supported"); + } + + public void registerOutputParameter(String parameterName, int sqlType, + int scale) + throws SQLException { + throw new SQLException("not supported"); + } + + public void registerOutputParameter(String parameterName, int sqlType, + String typeName) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.net.URL getURL(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public void setURL(int parameterIndex, java.net.URL url) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setNull(String parameterName, int sqlType) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setBoolean(String parameterName, boolean val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setByte(String parameterName, byte val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setShort(String parameterName, short val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setInt(String parameterName, int val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setLong(String parameterName, long val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setFloat(String parameterName, float val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setDouble(String parameterName, double val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setBigDecimal(String parameterName, BigDecimal val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setString(String parameterName, String val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setBytes(String parameterName, byte val[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setDate(String parameterName, java.sql.Date val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setTime(String parameterName, java.sql.Time val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setTimestamp(String parameterName, java.sql.Timestamp val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setAsciiStream(String parameterName, + java.io.InputStream s, int length) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setBinaryStream(String parameterName, + java.io.InputStream s, int length) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setObject(String parameterName, Object val, int targetSqlType, + int scale) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setObject(String parameterName, Object val, int targetSqlType) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setObject(String parameterName, Object val) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setCharacterStream(String parameterName, + java.io.Reader r, int length) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setDate(String parameterName, java.sql.Date val, + Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setTime(String parameterName, java.sql.Time val, + Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setTimestamp(String parameterName, java.sql.Timestamp val, + Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public void setNull(String parameterName, int sqlType, String typeName) + throws SQLException { + throw new SQLException("not supported"); + } + + public String getString(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public boolean getBoolean(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public byte getByte(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public short getShort(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public int getInt(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public long getLong(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public float getFloat(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public double getDouble(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public byte[] getBytes(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Date getDate(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Time getTime(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Timestamp getTimestamp(String parameterName) + throws SQLException { + throw new SQLException("not supported"); + } + + public Object getObject(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Object getObject(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public BigDecimal getBigDecimal(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Object getObject(String parameterName, Map map) + throws SQLException { + throw new SQLException("not supported"); + } + + public Object getObject(int parameterIndex, Map map) + throws SQLException { + throw new SQLException("not supported"); + } + + public Ref getRef(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public Ref getRef(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Blob getBlob(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Blob getBlob(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public Clob getClob(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Clob getClob(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public Array getArray(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + + public Array getArray(int parameterIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Date getDate(String parameterName, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Date getDate(int parameterIndex, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Time getTime(String parameterName, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Time getTime(int parameterIndex, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Timestamp getTimestamp(String parameterName, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.net.URL getURL(String parameterName) throws SQLException { + throw new SQLException("not supported"); + } + +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCResultSet.java b/sql/src/main/java/SQLite/JDBC2y/JDBCResultSet.java new file mode 100644 index 0000000..06384eb --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCResultSet.java @@ -0,0 +1,932 @@ +package SQLite.JDBC2y; + +import java.sql.*; +import java.math.BigDecimal; + +public class JDBCResultSet implements java.sql.ResultSet { + + /** + * Current row to be retrieved. + */ + private int row; + + /** + * Table returned by Database.get_table() + */ + protected SQLite.TableResult tr; + + /** + * Statement from which result set was produced. + */ + private JDBCStatement s; + + /** + * Meta data for result set or null. + */ + private JDBCResultSetMetaData m; + + /** + * Last result cell retrieved or null. + */ + private String lastg; + + + public JDBCResultSet(SQLite.TableResult tr, JDBCStatement s) { + this.tr = tr; + this.s = s; + this.m = null; + this.lastg = null; + this.row = -1; + } + + public boolean next() throws SQLException { + if (tr == null) { + return false; + } + row++; + return row < tr.nrows; + } + + public int findColumn(String columnName) throws SQLException { + JDBCResultSetMetaData m = (JDBCResultSetMetaData) getMetaData(); + return m.findColByName(columnName); + } + + public int getRow() throws SQLException { + if (tr == null) { + throw new SQLException("no rows"); + } + return row + 1; + } + + public boolean previous() throws SQLException { + if (tr == null) { + return false; + } + if (row >= 0) { + row--; + } + return row >= 0; + } + + public boolean absolute(int row) throws SQLException { + if (tr == null) { + return false; + } + if (row < 0) { + row = tr.nrows + 1 + row; + } + row--; + if (row < 0 || row > tr.nrows) { + return false; + } + this.row = row; + return true; + } + + public boolean relative(int row) throws SQLException { + if (tr == null) { + return false; + } + if (this.row + row < 0 || this.row + row >= tr.nrows) { + return false; + } + this.row += row; + return true; + } + + public void setFetchDirection(int dir) throws SQLException { + throw new SQLException("not supported"); + } + + public int getFetchDirection() throws SQLException { + throw new SQLException("not supported"); + } + + public void setFetchSize(int fsize) throws SQLException { + throw new SQLException("not supported"); + } + + public int getFetchSize() throws SQLException { + throw new SQLException("not supported"); + } + + public String getString(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + return lastg; + } + + public String getString(String columnName) throws SQLException { + int col = findColumn(columnName); + return getString(col); + } + + public int getInt(int columnIndex) throws SQLException { + Integer i = internalGetInt(columnIndex); + if (i != null) { + return i.intValue(); + } + return 0; + } + + private Integer internalGetInt(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return Integer.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public int getInt(String columnName) throws SQLException { + int col = findColumn(columnName); + return getInt(col); + } + + public boolean getBoolean(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public boolean getBoolean(String columnName) throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSetMetaData getMetaData() throws SQLException { + if (m == null) { + m = new JDBCResultSetMetaData(this); + } + return m; + } + + public short getShort(int columnIndex) throws SQLException { + Short s = internalGetShort(columnIndex); + if (s != null) { + return s.shortValue(); + } + return 0; + } + + private Short internalGetShort(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return Short.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public short getShort(String columnName) throws SQLException { + int col = findColumn(columnName); + return getShort(col); + } + + public java.sql.Time getTime(int columnIndex) throws SQLException { + return internalGetTime(columnIndex, null); + } + + private java.sql.Time internalGetTime(int columnIndex, + java.util.Calendar cal) + throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return java.sql.Time.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public java.sql.Time getTime(String columnName) throws SQLException { + int col = findColumn(columnName); + return getTime(col); + } + + public java.sql.Time getTime(int columnIndex, java.util.Calendar cal) + throws SQLException { + return internalGetTime(columnIndex, cal); + } + + public java.sql.Time getTime(String columnName, java.util.Calendar cal) + throws SQLException{ + int col = findColumn(columnName); + return getTime(col, cal); + } + + public java.sql.Timestamp getTimestamp(int columnIndex) + throws SQLException{ + return internalGetTimestamp(columnIndex, null); + } + + private java.sql.Timestamp internalGetTimestamp(int columnIndex, + java.util.Calendar cal) + throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return java.sql.Timestamp.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public java.sql.Timestamp getTimestamp(String columnName) + throws SQLException{ + int col = findColumn(columnName); + return getTimestamp(col); + } + + public java.sql.Timestamp getTimestamp(int columnIndex, + java.util.Calendar cal) + throws SQLException { + return internalGetTimestamp(columnIndex, cal); + } + + public java.sql.Timestamp getTimestamp(String columnName, + java.util.Calendar cal) + throws SQLException { + int col = findColumn(columnName); + return getTimestamp(col, cal); + } + + public java.sql.Date getDate(int columnIndex) throws SQLException { + return internalGetDate(columnIndex, null); + } + + private java.sql.Date internalGetDate(int columnIndex, + java.util.Calendar cal) + throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return java.sql.Date.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public java.sql.Date getDate(String columnName) throws SQLException { + int col = findColumn(columnName); + return getDate(col); + } + + public java.sql.Date getDate(int columnIndex, java.util.Calendar cal) + throws SQLException{ + return internalGetDate(columnIndex, cal); + } + + public java.sql.Date getDate(String columnName, java.util.Calendar cal) + throws SQLException{ + int col = findColumn(columnName); + return getDate(col, cal); + } + + public double getDouble(int columnIndex) throws SQLException { + Double d = internalGetDouble(columnIndex); + if (d != null) { + return d.doubleValue(); + } + return 0; + } + + private Double internalGetDouble(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return Double.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public double getDouble(String columnName) throws SQLException { + int col = findColumn(columnName); + return getDouble(col); + } + + public float getFloat(int columnIndex) throws SQLException { + Float f = internalGetFloat(columnIndex); + if (f != null) { + return f.floatValue(); + } + return 0; + } + + private Float internalGetFloat(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return Float.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public float getFloat(String columnName) throws SQLException { + int col = findColumn(columnName); + return getFloat(col); + } + + public long getLong(int columnIndex) throws SQLException { + Long l = internalGetLong(columnIndex); + if (l != null) { + return l.longValue(); + } + return 0; + } + + private Long internalGetLong(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + try { + return Long.valueOf(lastg); + } catch (java.lang.Exception e) { + lastg = null; + } + return null; + } + + public long getLong(String columnName) throws SQLException { + int col = findColumn(columnName); + return getLong(col); + } + + @Deprecated + public java.io.InputStream getUnicodeStream(int columnIndex) + throws SQLException { + throw new SQLException("not supported"); + } + + @Deprecated + public java.io.InputStream getUnicodeStream(String columnName) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.InputStream getAsciiStream(String columnName) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.InputStream getAsciiStream(int columnIndex) + throws SQLException { + throw new SQLException("not supported"); + } + + public BigDecimal getBigDecimal(String columnName) + throws SQLException { + throw new SQLException("not supported"); + } + + @Deprecated + public BigDecimal getBigDecimal(String columnName, int scale) + throws SQLException { + throw new SQLException("not supported"); + } + + public BigDecimal getBigDecimal(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + @Deprecated + public BigDecimal getBigDecimal(int columnIndex, int scale) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.InputStream getBinaryStream(int columnIndex) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.InputStream getBinaryStream(String columnName) + throws SQLException { + throw new SQLException("not supported"); + } + + public byte getByte(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public byte getByte(String columnName) throws SQLException { + throw new SQLException("not supported"); + } + + public byte[] getBytes(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + byte ret[] = null; + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + if (lastg != null) { + ret = SQLite.StringEncoder.decode(lastg); + } + return ret; + } + + public byte[] getBytes(String columnName) throws SQLException { + int col = findColumn(columnName); + return getBytes(col); + } + + public String getCursorName() throws SQLException { + return null; + } + + public Object getObject(int columnIndex) throws SQLException { + if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { + throw new SQLException("column " + columnIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[columnIndex - 1]; + Object ret = lastg; + if (tr instanceof TableResultX) { + switch (((TableResultX) tr).sql_type[columnIndex - 1]) { + case Types.SMALLINT: + ret = internalGetShort(columnIndex); + break; + case Types.INTEGER: + ret = internalGetInt(columnIndex); + break; + case Types.DOUBLE: + ret = internalGetDouble(columnIndex); + break; + case Types.FLOAT: + ret = internalGetFloat(columnIndex); + break; + case Types.BIGINT: + ret = internalGetLong(columnIndex); + break; + case Types.BINARY: + case Types.VARBINARY: + case Types.LONGVARBINARY: + ret = getBytes(columnIndex); + break; + case Types.NULL: + ret = null; + break; + /* defaults to String below */ + } + } + return ret; + } + + public Object getObject(String columnName) throws SQLException { + int col = findColumn(columnName); + return getObject(col); + } + + public Object getObject(int columnIndex, java.util.Map map) + throws SQLException { + throw new SQLException("not supported"); + } + + public Object getObject(String columnIndex, java.util.Map map) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Ref getRef(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Ref getRef(String columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Blob getBlob(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Blob getBlob(String columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Clob getClob(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Clob getClob(String columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Array getArray(int columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.sql.Array getArray(String columnIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.Reader getCharacterStream(int columnIndex) + throws SQLException { + throw new SQLException("not supported"); + } + + public java.io.Reader getCharacterStream(String columnName) + throws SQLException { + throw new SQLException("not supported"); + } + + public SQLWarning getWarnings() throws SQLException { + throw new SQLException("not supported"); + } + + public boolean wasNull() throws SQLException { + return lastg == null; + } + + public void clearWarnings() throws SQLException { + throw new SQLException("not supported"); + } + + public boolean isFirst() throws SQLException { + if (tr == null) { + return true; + } + return row == 0; + } + + public boolean isBeforeFirst() throws SQLException { + if (tr == null || tr.nrows <= 0) { + return false; + } + return row < 0; + } + + public void beforeFirst() throws SQLException { + if (tr == null) { + return; + } + row = -1; + } + + public boolean first() throws SQLException { + if (tr == null || tr.nrows <= 0) { + return false; + } + row = 0; + return true; + } + + public boolean isAfterLast() throws SQLException { + if (tr == null || tr.nrows <= 0) { + return false; + } + return row >= tr.nrows; + } + + public void afterLast() throws SQLException { + if (tr == null) { + return; + } + row = tr.nrows; + } + + public boolean isLast() throws SQLException { + if (tr == null) { + return true; + } + return row == tr.nrows - 1; + } + + public boolean last() throws SQLException { + if (tr == null || tr.nrows <= 0) { + return false; + } + row = tr.nrows -1; + return true; + } + + public int getType() throws SQLException { + return TYPE_SCROLL_INSENSITIVE; + } + + public int getConcurrency() throws SQLException { + return CONCUR_READ_ONLY; + } + + public boolean rowUpdated() throws SQLException { + throw new SQLException("not supported"); + } + + public boolean rowInserted() throws SQLException { + throw new SQLException("not supported"); + } + + public boolean rowDeleted() throws SQLException { + throw new SQLException("not supported"); + } + + public void insertRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void updateRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void deleteRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void refreshRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void cancelRowUpdates() throws SQLException { + throw new SQLException("not supported"); + } + + public void moveToInsertRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void moveToCurrentRow() throws SQLException { + throw new SQLException("not supported"); + } + + public void updateNull(int colIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBoolean(int colIndex, boolean b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateByte(int colIndex, byte b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateShort(int colIndex, short b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateInt(int colIndex, int b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateLong(int colIndex, long b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateFloat(int colIndex, float f) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateDouble(int colIndex, double f) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBigDecimal(int colIndex, BigDecimal f) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateString(int colIndex, String s) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBytes(int colIndex, byte[] s) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateDate(int colIndex, java.sql.Date d) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateTime(int colIndex, java.sql.Time t) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateTimestamp(int colIndex, java.sql.Timestamp t) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateAsciiStream(int colIndex, java.io.InputStream in, int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBinaryStream(int colIndex, java.io.InputStream in, int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateCharacterStream(int colIndex, java.io.Reader in, int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateObject(int colIndex, Object obj) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateObject(int colIndex, Object obj, int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateNull(String colIndex) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBoolean(String colIndex, boolean b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateByte(String colIndex, byte b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateShort(String colIndex, short b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateInt(String colIndex, int b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateLong(String colIndex, long b) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateFloat(String colIndex, float f) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateDouble(String colIndex, double f) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBigDecimal(String colIndex, BigDecimal f) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateString(String colIndex, String s) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBytes(String colIndex, byte[] s) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateDate(String colIndex, java.sql.Date d) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateTime(String colIndex, java.sql.Time t) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateTimestamp(String colIndex, java.sql.Timestamp t) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateAsciiStream(String colIndex, java.io.InputStream in, + int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBinaryStream(String colIndex, java.io.InputStream in, + int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateCharacterStream(String colIndex, java.io.Reader in, + int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateObject(String colIndex, Object obj) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateObject(String colIndex, Object obj, int s) + throws SQLException { + throw new SQLException("not supported"); + } + + public Statement getStatement() throws SQLException { + if (s == null) { + throw new SQLException("stale result set"); + } + return s; + } + + public void close() throws SQLException { + s = null; + tr = null; + lastg = null; + row = -1; + } + + public java.net.URL getURL(int colIndex) throws SQLException { + if (tr == null || colIndex < 1 || colIndex > tr.ncolumns) { + throw new SQLException("column " + colIndex + " not found"); + } + String rd[] = (String []) tr.rows.elementAt(row); + lastg = rd[colIndex - 1]; + java.net.URL url = null; + if (lastg == null) { + return url; + } + try { + url = new java.net.URL(lastg); + } catch (java.lang.Exception e) { + url = null; + } + return url; + } + + public java.net.URL getURL(String colIndex) throws SQLException { + int col = findColumn(colIndex); + return getURL(col); + } + + public void updateRef(int colIndex, java.sql.Ref x) throws SQLException { + throw new SQLException("not supported"); + } + + public void updateRef(String colIndex, java.sql.Ref x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBlob(int colIndex, java.sql.Blob x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateBlob(String colIndex, java.sql.Blob x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateClob(int colIndex, java.sql.Clob x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateClob(String colIndex, java.sql.Clob x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateArray(int colIndex, java.sql.Array x) + throws SQLException { + throw new SQLException("not supported"); + } + + public void updateArray(String colIndex, java.sql.Array x) + throws SQLException { + throw new SQLException("not supported"); + } + +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCResultSetMetaData.java b/sql/src/main/java/SQLite/JDBC2y/JDBCResultSetMetaData.java new file mode 100644 index 0000000..934ca78 --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCResultSetMetaData.java @@ -0,0 +1,212 @@ +package SQLite.JDBC2y; + +import java.sql.*; + +public class JDBCResultSetMetaData implements java.sql.ResultSetMetaData { + + private JDBCResultSet r; + + public JDBCResultSetMetaData(JDBCResultSet r) { + this.r = r; + } + + public String getCatalogName(int column) throws java.sql.SQLException { + return null; + } + + public String getColumnClassName(int column) throws java.sql.SQLException { + column--; + if (r != null && r.tr != null) { + if (column < 0 || column >= r.tr.ncolumns) { + return null; + } + if (r.tr instanceof TableResultX) { + switch (((TableResultX) r.tr).sql_type[column]) { + case Types.SMALLINT: return "java.lang.Short"; + case Types.INTEGER: return "java.lang.Integer"; + case Types.DOUBLE: return "java.lang.Double"; + case Types.FLOAT: return "java.lang.Float"; + case Types.BIGINT: return "java.lang.Long"; + case Types.DATE: return "java.sql.Date"; + case Types.TIME: return "java.sql.Time"; + case Types.TIMESTAMP: return "java.sql.Timestamp"; + case Types.BINARY: + case Types.VARBINARY: return "[B"; + /* defaults to varchar below */ + } + } + return "java.lang.String"; + } + return null; + } + + public int getColumnCount() throws java.sql.SQLException { + if (r != null && r.tr != null) { + return r.tr.ncolumns; + } + return 0; + } + + public int getColumnDisplaySize(int column) throws java.sql.SQLException { + return 0; + } + + public String getColumnLabel(int column) throws java.sql.SQLException { + column--; + String c = null; + if (r != null && r.tr != null) { + if (column < 0 || column >= r.tr.ncolumns) { + return c; + } + c = r.tr.column[column]; + } + return c; + } + + public String getColumnName(int column) throws java.sql.SQLException { + column--; + String c = null; + if (r != null && r.tr != null) { + if (column < 0 || column >= r.tr.ncolumns) { + return c; + } + c = r.tr.column[column]; + if (c != null) { + int i = c.indexOf('.'); + if (i > 0) { + return c.substring(i + 1); + } + } + } + return c; + } + + public int getColumnType(int column) throws java.sql.SQLException { + column--; + if (r != null && r.tr != null) { + if (column >= 0 && column < r.tr.ncolumns) { + if (r.tr instanceof TableResultX) { + return ((TableResultX) r.tr).sql_type[column]; + } + return Types.VARCHAR; + } + } + throw new SQLException("bad column index"); + } + + public String getColumnTypeName(int column) throws java.sql.SQLException { + column--; + if (r != null && r.tr != null) { + if (column >= 0 && column < r.tr.ncolumns) { + if (r.tr instanceof TableResultX) { + switch (((TableResultX) r.tr).sql_type[column]) { + case Types.SMALLINT: return "smallint"; + case Types.INTEGER: return "integer"; + case Types.DOUBLE: return "double"; + case Types.FLOAT: return "float"; + case Types.BIGINT: return "bigint"; + case Types.DATE: return "date"; + case Types.TIME: return "time"; + case Types.TIMESTAMP: return "timestamp"; + case Types.BINARY: return "binary"; + case Types.VARBINARY: return "varbinary"; + /* defaults to varchar below */ + } + } + return "varchar"; + } + } + throw new SQLException("bad column index"); + } + + public int getPrecision(int column) throws java.sql.SQLException { + return 0; + } + + public int getScale(int column) throws java.sql.SQLException { + return 0; + } + + public String getSchemaName(int column) throws java.sql.SQLException { + return null; + } + + public String getTableName(int column) throws java.sql.SQLException { + column--; + String c = null; + if (r != null && r.tr != null) { + if (column < 0 || column >= r.tr.ncolumns) { + return c; + } + c = r.tr.column[column]; + if (c != null) { + int i = c.indexOf('.'); + if (i > 0) { + return c.substring(0, i); + } + c = null; + } + } + return c; + } + + public boolean isAutoIncrement(int column) throws java.sql.SQLException { + return false; + } + + public boolean isCaseSensitive(int column) throws java.sql.SQLException { + return false; + } + + public boolean isCurrency(int column) throws java.sql.SQLException { + return false; + } + + public boolean isDefinitelyWritable(int column) + throws java.sql.SQLException { + return true; + } + + public int isNullable(int column) throws java.sql.SQLException { + return columnNullableUnknown; + } + + public boolean isReadOnly(int column) throws java.sql.SQLException { + return false; + } + + public boolean isSearchable(int column) throws java.sql.SQLException { + return true; + } + + public boolean isSigned(int column) throws java.sql.SQLException { + return false; + } + + public boolean isWritable(int column) throws java.sql.SQLException { + return true; + } + + int findColByName(String columnName) throws java.sql.SQLException { + String c = null; + if (r != null && r.tr != null) { + for (int i = 0; i < r.tr.ncolumns; i++) { + c = r.tr.column[i]; + if (c != null) { + if (c.compareToIgnoreCase(columnName) == 0) { + return i + 1; + } + int k = c.indexOf('.'); + if (k > 0) { + c = c.substring(k + 1); + if (c.compareToIgnoreCase(columnName) == 0) { + return i + 1; + } + } + } + c = null; + } + } + throw new SQLException("column " + columnName + " not found"); + } +} diff --git a/sql/src/main/java/SQLite/JDBC2y/JDBCStatement.java b/sql/src/main/java/SQLite/JDBC2y/JDBCStatement.java new file mode 100644 index 0000000..99d12d3 --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/JDBCStatement.java @@ -0,0 +1,287 @@ +package SQLite.JDBC2y; + +import java.sql.*; +import java.util.*; + +public class JDBCStatement implements java.sql.Statement { + + protected JDBCConnection conn; + protected JDBCResultSet rs; + protected int updcnt; + private ArrayList<String> batch; + + public JDBCStatement(JDBCConnection conn) { + this.conn = conn; + this.updcnt = 0; + this.rs = null; + this.batch = null; + } + + public void setFetchSize(int fetchSize) throws SQLException { + throw new SQLException("not supported"); + } + + public int getFetchSize() throws SQLException { + return 1; + } + + public int getMaxRows() throws SQLException { + return 0; + } + + public void setMaxRows(int max) throws SQLException { + throw new SQLException("not supported"); + } + + public void setFetchDirection(int fetchDirection) throws SQLException { + throw new SQLException("not supported"); + } + + public int getFetchDirection() throws SQLException { + return ResultSet.FETCH_UNKNOWN; + } + + public int getResultSetConcurrency() throws SQLException { + return ResultSet.CONCUR_READ_ONLY; + } + + public int getResultSetType() throws SQLException { + return ResultSet.TYPE_SCROLL_INSENSITIVE; + } + + public void setQueryTimeout(int seconds) throws SQLException { + conn.timeout = seconds * 1000; + if (conn.timeout < 0) { + conn.timeout = 120000; + } else if (conn.timeout < 1000) { + conn.timeout = 5000; + } + } + + public int getQueryTimeout() throws SQLException { + return conn.timeout; + } + + public ResultSet getResultSet() throws SQLException { + return rs; + } + + ResultSet executeQuery(String sql, String args[], boolean updonly) + throws SQLException { + SQLite.TableResult tr = null; + if (rs != null) { + rs.close(); + rs = null; + } + updcnt = -1; + if (conn == null || conn.db == null) { + throw new SQLException("stale connection"); + } + int busy = 0; + boolean starttrans = !conn.autocommit && !conn.intrans; + while (true) { + try { + if (starttrans) { + conn.db.exec("BEGIN TRANSACTION", null); + conn.intrans = true; + } + if (args == null) { + if (updonly) { + conn.db.exec(sql, null); + } else { + tr = conn.db.get_table(sql); + } + } else { + if (updonly) { + conn.db.exec(sql, null, args); + } else { + tr = conn.db.get_table(sql, args); + } + } + updcnt = (int) conn.db.changes(); + } catch (SQLite.Exception e) { + if (conn.db.is3() && + conn.db.last_error() == SQLite.Constants.SQLITE_BUSY && + conn.busy3(conn.db, ++busy)) { + try { + if (starttrans && conn.intrans) { + conn.db.exec("ROLLBACK", null); + conn.intrans = false; + } + } catch (SQLite.Exception ee) { + } + try { + int ms = 20 + busy * 10; + if (ms > 1000) { + ms = 1000; + } + synchronized (this) { + this.wait(ms); + } + } catch (java.lang.Exception eee) { + } + continue; + } + throw new SQLException(e.toString()); + } + break; + } + if (!updonly && tr == null) { + throw new SQLException("no result set produced"); + } + if (!updonly && tr != null) { + rs = new JDBCResultSet(new TableResultX(tr), this); + } + return rs; + } + + public ResultSet executeQuery(String sql) throws SQLException { + return executeQuery(sql, null, false); + } + + public boolean execute(String sql) throws SQLException { + return executeQuery(sql) != null; + } + + public void cancel() throws SQLException { + if (conn == null || conn.db == null) { + throw new SQLException("stale connection"); + } + conn.db.interrupt(); + } + + public void clearWarnings() throws SQLException { + } + + public Connection getConnection() throws SQLException { + return conn; + } + + public void addBatch(String sql) throws SQLException { + if (batch == null) { + batch = new ArrayList<String>(1); + } + batch.add(sql); + } + + public int[] executeBatch() throws SQLException { + if (batch == null) { + return new int[0]; + } + int[] ret = new int[batch.size()]; + for (int i = 0; i < ret.length; i++) { + ret[i] = EXECUTE_FAILED; + } + int errs = 0; + for (int i = 0; i < ret.length; i++) { + try { + execute((String) batch.get(i)); + ret[i] = updcnt; + } catch (SQLException e) { + ++errs; + } + } + if (errs > 0) { + throw new BatchUpdateException("batch failed", ret); + } + return ret; + } + + public void clearBatch() throws SQLException { + if (batch != null) { + batch.clear(); + batch = null; + } + } + + public void close() throws SQLException { + clearBatch(); + conn = null; + } + + public int executeUpdate(String sql) throws SQLException { + executeQuery(sql, null, true); + return updcnt; + } + + public int getMaxFieldSize() throws SQLException { + return 0; + } + + public boolean getMoreResults() throws SQLException { + if (rs != null) { + rs.close(); + rs = null; + } + return false; + } + + public int getUpdateCount() throws SQLException { + return updcnt; + } + + public SQLWarning getWarnings() throws SQLException { + return null; + } + + public void setCursorName(String name) throws SQLException { + throw new SQLException("not supported"); + } + + public void setEscapeProcessing(boolean enable) throws SQLException { + throw new SQLException("not supported"); + } + + public void setMaxFieldSize(int max) throws SQLException { + throw new SQLException("not supported"); + } + + public boolean getMoreResults(int x) throws SQLException { + throw new SQLException("not supported"); + } + + public ResultSet getGeneratedKeys() throws SQLException { + throw new SQLException("not supported"); + } + + public int executeUpdate(String sql, int autokeys) + throws SQLException { + if (autokeys != Statement.NO_GENERATED_KEYS) { + throw new SQLException("not supported"); + } + return executeUpdate(sql); + } + + public int executeUpdate(String sql, int colIndexes[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public int executeUpdate(String sql, String colIndexes[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public boolean execute(String sql, int autokeys) + throws SQLException { + if (autokeys != Statement.NO_GENERATED_KEYS) { + throw new SQLException("not supported"); + } + return execute(sql); + } + + public boolean execute(String sql, int colIndexes[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public boolean execute(String sql, String colIndexes[]) + throws SQLException { + throw new SQLException("not supported"); + } + + public int getResultSetHoldability() throws SQLException { + return ResultSet.HOLD_CURSORS_OVER_COMMIT; + } + +} diff --git a/sql/src/main/java/SQLite/JDBC2y/TableResultX.java b/sql/src/main/java/SQLite/JDBC2y/TableResultX.java new file mode 100644 index 0000000..205372f --- /dev/null +++ b/sql/src/main/java/SQLite/JDBC2y/TableResultX.java @@ -0,0 +1,37 @@ +package SQLite.JDBC2y; + +import java.sql.Types; +import java.util.Vector; + +public class TableResultX extends SQLite.TableResult { + public int sql_type[]; + + public TableResultX() { + super(); + sql_type = new int[this.ncolumns]; + for (int i = 0; i < this.ncolumns; i++) { + sql_type[i] = Types.VARCHAR; + } + } + + public TableResultX(SQLite.TableResult tr) { + this.column = tr.column; + this.rows = tr.rows; + this.ncolumns = tr.ncolumns; + this.nrows = tr.nrows; + this.types = tr.types; + sql_type = new int[tr.ncolumns]; + for (int i = 0; i < this.ncolumns; i++) { + sql_type[i] = Types.VARCHAR; + } + if (tr.types != null) { + for (int i = 0; i < tr.types.length; i++) { + sql_type[i] = JDBCDatabaseMetaData.mapSqlType(tr.types[i]); + } + } + } + + void sql_types(int types[]) { + sql_type = types; + } +} diff --git a/sql/src/main/java/SQLite/JDBCDriver.java b/sql/src/main/java/SQLite/JDBCDriver.java new file mode 100644 index 0000000..63b95ee --- /dev/null +++ b/sql/src/main/java/SQLite/JDBCDriver.java @@ -0,0 +1,109 @@ +package SQLite; + +import java.sql.*; +import java.util.Properties; + +public class JDBCDriver implements java.sql.Driver { + + public static final int MAJORVERSION = 1; + public static final int MINORVERSION = 2; + + private static java.lang.reflect.Constructor makeConn = null; + + protected Connection conn; + + static { + try { + Class connClass = null; + Class args[] = new Class[2]; + args[0] = Class.forName("java.lang.String"); + args[1] = args[0]; + String jvers = java.lang.System.getProperty("java.version"); + String cvers; + if (jvers == null || jvers.startsWith("1.0")) { + throw new java.lang.Exception("unsupported java version"); + } else if (jvers.startsWith("1.1")) { + cvers = "SQLite.JDBC1.JDBCConnection"; + } else if (jvers.startsWith("1.2") || jvers.startsWith("1.3")) { + cvers = "SQLite.JDBC2.JDBCConnection"; + } else if (jvers.startsWith("1.4")) { + cvers = "SQLite.JDBC2x.JDBCConnection"; + } else if (jvers.startsWith("1.5")) { + cvers = "SQLite.JDBC2y.JDBCConnection"; + try { + Class.forName(cvers); + } catch (java.lang.Exception e) { + cvers = "SQLite.JDBC2x.JDBCConnection"; + } + } else { + cvers = "SQLite.JDBC2z.JDBCConnection"; + try { + Class.forName(cvers); + } catch (java.lang.Exception e) { + cvers = "SQLite.JDBC2y.JDBCConnection"; + try { + Class.forName(cvers); + } catch (java.lang.Exception ee) { + cvers = "SQLite.JDBC2x.JDBCConnection"; + } + } + } + connClass = Class.forName(cvers); + makeConn = connClass.getConstructor(args); + java.sql.DriverManager.registerDriver(new JDBCDriver()); + } catch (java.lang.Exception e) { + System.err.println(e); + } + } + + public JDBCDriver() { + } + + public boolean acceptsURL(String url) throws SQLException { + return url.startsWith("sqlite:/") || + url.startsWith("jdbc:sqlite:/"); + } + + public Connection connect(String url, Properties info) + throws SQLException { + if (!acceptsURL(url)) { + return null; + } + Object args[] = new Object[2]; + args[0] = url; + if (info != null) { + args[1] = info.getProperty("encoding"); + } + if (args[1] == null) { + args[1] = java.lang.System.getProperty("SQLite.encoding"); + } + try { + conn = (Connection) makeConn.newInstance(args); + } catch (java.lang.reflect.InvocationTargetException ie) { + throw new SQLException(ie.getTargetException().toString()); + } catch (java.lang.Exception e) { + throw new SQLException(e.toString()); + } + return conn; + } + + public int getMajorVersion() { + return MAJORVERSION; + } + + public int getMinorVersion() { + return MINORVERSION; + } + + public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) + throws SQLException { + DriverPropertyInfo p[] = new DriverPropertyInfo[1]; + DriverPropertyInfo pp = new DriverPropertyInfo("encoding", ""); + p[0] = pp; + return p; + } + + public boolean jdbcCompliant() { + return false; + } +} diff --git a/sql/src/main/java/SQLite/ProgressHandler.java b/sql/src/main/java/SQLite/ProgressHandler.java new file mode 100644 index 0000000..b2ec7c0 --- /dev/null +++ b/sql/src/main/java/SQLite/ProgressHandler.java @@ -0,0 +1,17 @@ +package SQLite; + +/** + * Callback interface for SQLite's user defined progress handler. + */ + +public interface ProgressHandler { + + /** + * Invoked for N SQLite VM opcodes. + * The method should return true to continue the + * current query, or false in order + * to abandon the action.<BR><BR> + */ + + public boolean progress(); +} diff --git a/sql/src/main/java/SQLite/Shell.java b/sql/src/main/java/SQLite/Shell.java new file mode 100644 index 0000000..78d37a1 --- /dev/null +++ b/sql/src/main/java/SQLite/Shell.java @@ -0,0 +1,669 @@ +package SQLite; + +import SQLite.*; +import java.io.*; +import java.util.*; + +/** + * SQLite command line shell. This is a partial reimplementaion + * of sqlite/src/shell.c and can be invoked by:<P> + * + * <verb> + * java SQLite.Shell [OPTIONS] database [SHELLCMD] + * or + * java -jar sqlite.jar [OPTIONS] database [SHELLCMD] + * </verb> + */ + +public class Shell implements Callback { + Database db; + boolean echo; + int count; + int mode; + boolean showHeader; + String tableName; + String sep; + String cols[]; + int colwidth[]; + String destTable; + PrintWriter pw; + PrintWriter err; + + static final int MODE_Line = 0; + static final int MODE_Column = 1; + static final int MODE_List = 2; + static final int MODE_Semi = 3; + static final int MODE_Html = 4; + static final int MODE_Insert = 5; + static final int MODE_Insert2 = 6; + + public Shell(PrintWriter pw, PrintWriter err) { + this.pw = pw; + this.err = err; + } + + public Shell(PrintStream ps, PrintStream errs) { + pw = new PrintWriter(ps); + err = new PrintWriter(errs); + } + + protected Object clone() { + Shell s = new Shell(this.pw, this.err); + s.db = db; + s.echo = echo; + s.mode = mode; + s.count = 0; + s.showHeader = showHeader; + s.tableName = tableName; + s.sep = sep; + s.colwidth = colwidth; + return s; + } + + static public String sql_quote_dbl(String str) { + if (str == null) { + return "NULL"; + } + int i, single = 0, dbl = 0; + for (i = 0; i < str.length(); i++) { + if (str.charAt(i) == '\'') { + single++; + } else if (str.charAt(i) == '"') { + dbl++; + } + } + if (dbl == 0) { + return "\"" + str + "\""; + } + StringBuffer sb = new StringBuffer("\""); + for (i = 0; i < str.length(); i++) { + char c = str.charAt(i); + if (c == '"') { + sb.append("\"\""); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + static public String sql_quote(String str) { + if (str == null) { + return "NULL"; + } + int i, single = 0, dbl = 0; + for (i = 0; i < str.length(); i++) { + if (str.charAt(i) == '\'') { + single++; + } else if (str.charAt(i) == '"') { + dbl++; + } + } + if (single == 0) { + return "'" + str + "'"; + } + if (dbl == 0) { + return "\"" + str + "\""; + } + StringBuffer sb = new StringBuffer("'"); + for (i = 0; i < str.length(); i++) { + char c = str.charAt(i); + if (c == '\'') { + sb.append("''"); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + static String html_quote(String str) { + if (str == null) { + return "NULL"; + } + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < str.length(); i++) { + char c = str.charAt(i); + if (c == '<') { + sb.append("<"); + } else if (c == '>') { + sb.append(">"); + } else if (c == '&') { + sb.append("&"); + } else { + int x = c; + if (x < 32 || x > 127) { + sb.append("&#" + x + ";"); + } else { + sb.append(c); + } + } + } + return sb.toString(); + } + + static boolean is_numeric(String str) { + try { + Double d = Double.valueOf(str); + } catch (java.lang.Exception e) { + return false; + } + return true; + } + + void set_table_name(String str) { + if (str == null) { + tableName = ""; + return; + } + tableName = Shell.sql_quote(str); + } + + public void columns(String args[]) { + cols = args; + } + + public void types(String args[]) { + /* Empty body to satisfy SQLite.Callback interface. */ + } + + public boolean newrow(String args[]) { + int i; + String tname; + switch (mode) { + case Shell.MODE_Line: + if (args.length == 0) { + break; + } + if (count++ > 0) { + pw.println(""); + } + for (i = 0; i < args.length; i++) { + pw.println(cols[i] + " = " + + args[i] == null ? "NULL" : args[i]); + } + break; + case Shell.MODE_Column: + String csep = ""; + if (count++ == 0) { + colwidth = new int[args.length]; + for (i = 0; i < args.length; i++) { + int w, n; + w = cols[i].length(); + if (w < 10) { + w = 10; + } + colwidth[i] = w; + if (showHeader) { + pw.print(csep + cols[i]); + csep = " "; + } + } + if (showHeader) { + pw.println(""); + } + } + if (args.length == 0) { + break; + } + csep = ""; + for (i = 0; i < args.length; i++) { + pw.print(csep + (args[i] == null ? "NULL" : args[i])); + csep = " "; + } + pw.println(""); + break; + case Shell.MODE_Semi: + case Shell.MODE_List: + if (count++ == 0 && showHeader) { + for (i = 0; i < args.length; i++) { + pw.print(cols[i] + + (i == args.length - 1 ? "\n" : sep)); + } + } + if (args.length == 0) { + break; + } + for (i = 0; i < args.length; i++) { + pw.print(args[i] == null ? "NULL" : args[i]); + if (mode == Shell.MODE_Semi) { + pw.print(";"); + } else if (i < args.length - 1) { + pw.print(sep); + } + } + pw.println(""); + break; + case MODE_Html: + if (count++ == 0 && showHeader) { + pw.print("<TR>"); + for (i = 0; i < args.length; i++) { + pw.print("<TH>" + html_quote(cols[i]) + "</TH>"); + } + pw.println("</TR>"); + } + if (args.length == 0) { + break; + } + pw.print("<TR>"); + for (i = 0; i < args.length; i++) { + pw.print("<TD>" + html_quote(args[i]) + "</TD>"); + } + pw.println("</TR>"); + break; + case MODE_Insert: + if (args.length == 0) { + break; + } + tname = tableName; + if (destTable != null) { + tname = destTable; + } + pw.print("INSERT INTO " + tname + " VALUES("); + for (i = 0; i < args.length; i++) { + String tsep = i > 0 ? "," : ""; + if (args[i] == null) { + pw.print(tsep + "NULL"); + } else if (is_numeric(args[i])) { + pw.print(tsep + args[i]); + } else { + pw.print(tsep + sql_quote(args[i])); + } + } + pw.println(");"); + break; + case MODE_Insert2: + if (args.length == 0) { + break; + } + tname = tableName; + if (destTable != null) { + tname = destTable; + } + pw.print("INSERT INTO " + tname + " VALUES("); + for (i = 0; i < args.length; i++) { + String tsep = i > 0 ? "," : ""; + pw.print(tsep + args[i]); + } + pw.println(");"); + break; + } + return false; + } + + void do_meta(String line) { + StringTokenizer st = new StringTokenizer(line.toLowerCase()); + int n = st.countTokens(); + if (n <= 0) { + return; + } + String cmd = st.nextToken(); + String args[] = new String[n - 1]; + int i = 0; + while (st.hasMoreTokens()) { + args[i] = st.nextToken(); + ++i; + } + if (cmd.compareTo(".dump") == 0) { + new DBDump(this, args); + return; + } + if (cmd.compareTo(".echo") == 0) { + if (args.length > 0 && + (args[0].startsWith("y") || args[0].startsWith("on"))) { + echo = true; + } + return; + } + if (cmd.compareTo(".exit") == 0) { + try { + db.close(); + } catch (Exception e) { + } + System.exit(0); + } + if (cmd.compareTo(".header") == 0) { + if (args.length > 0 && + (args[0].startsWith("y") || args[0].startsWith("on"))) { + showHeader = true; + } + return; + } + if (cmd.compareTo(".help") == 0) { + pw.println(".dump ?TABLE? ... Dump database in text fmt"); + pw.println(".echo ON|OFF Command echo on or off"); + pw.println(".enc ?NAME? Change encoding"); + pw.println(".exit Exit program"); + pw.println(".header ON|OFF Display headers on or off"); + pw.println(".help This message"); + pw.println(".mode MODE Set output mode to\n" + + " line, column, insert\n" + + " list, or html"); + pw.println(".mode insert TABLE Generate SQL insert stmts"); + pw.println(".schema ?PATTERN? List table schema"); + pw.println(".separator STRING Set separator string"); + pw.println(".tables ?PATTERN? List table names"); + return; + } + if (cmd.compareTo(".mode") == 0) { + if (args.length > 0) { + if (args[0].compareTo("line") == 0) { + mode = Shell.MODE_Line; + } else if (args[0].compareTo("column") == 0) { + mode = Shell.MODE_Column; + } else if (args[0].compareTo("list") == 0) { + mode = Shell.MODE_List; + } else if (args[0].compareTo("html") == 0) { + mode = Shell.MODE_Html; + } else if (args[0].compareTo("insert") == 0) { + mode = Shell.MODE_Insert; + if (args.length > 1) { + destTable = args[1]; + } + } + } + return; + } + if (cmd.compareTo(".separator") == 0) { + if (args.length > 0) { + sep = args[0]; + } + return; + } + if (cmd.compareTo(".tables") == 0) { + TableResult t = null; + if (args.length > 0) { + try { + String qarg[] = new String[1]; + qarg[0] = args[0]; + t = db.get_table("SELECT name FROM sqlite_master " + + "WHERE type='table' AND " + + "name LIKE '%%%q%%' " + + "ORDER BY name", qarg); + } catch (Exception e) { + err.println("SQL Error: " + e); + err.flush(); + } + } else { + try { + t = db.get_table("SELECT name FROM sqlite_master " + + "WHERE type='table' ORDER BY name"); + } catch (Exception e) { + err.println("SQL Error: " + e); + err.flush(); + } + } + if (t != null) { + for (i = 0; i < t.nrows; i++) { + String tab = ((String[]) t.rows.elementAt(i))[0]; + if (tab != null) { + pw.println(tab); + } + } + } + return; + } + if (cmd.compareTo(".schema") == 0) { + if (args.length > 0) { + try { + String qarg[] = new String[1]; + qarg[0] = args[0]; + db.exec("SELECT sql FROM sqlite_master " + + "WHERE type!='meta' AND " + + "name LIKE '%%%q%%' AND " + + "sql NOTNULL " + + "ORDER BY type DESC, name", + this, qarg); + } catch (Exception e) { + err.println("SQL Error: " + e); + err.flush(); + } + } else { + try { + db.exec("SELECT sql FROM sqlite_master " + + "WHERE type!='meta' AND " + + "sql NOTNULL " + + "ORDER BY tbl_name, type DESC, name", + this); + } catch (Exception e) { + err.println("SQL Error: " + e); + err.flush(); + } + } + return; + } + if (cmd.compareTo(".enc") == 0) { + try { + db.set_encoding(args.length > 0 ? args[0] : null); + } catch (Exception e) { + err.println("" + e); + err.flush(); + } + return; + } + err.println("Unknown command '" + cmd + "'"); + err.flush(); + } + + String read_line(BufferedReader is, String prompt) { + try { + if (prompt != null) { + pw.print(prompt); + pw.flush(); + } + String line = is.readLine(); + return line; + } catch (IOException e) { + return null; + } + } + + void do_input(BufferedReader is) { + String line, sql = null; + String prompt = "SQLITE> "; + while ((line = read_line(is, prompt)) != null) { + if (echo) { + pw.println(line); + } + if (line.length() > 0 && line.charAt(0) == '.') { + do_meta(line); + } else { + if (sql == null) { + sql = line; + } else { + sql = sql + " " + line; + } + if (Database.complete(sql)) { + try { + db.exec(sql, this); + } catch (Exception e) { + if (!echo) { + err.println(sql); + } + err.println("SQL Error: " + e); + err.flush(); + } + sql = null; + prompt = "SQLITE> "; + } else { + prompt = "SQLITE? "; + } + } + pw.flush(); + } + if (sql != null) { + err.println("Incomplete SQL: " + sql); + err.flush(); + } + } + + void do_cmd(String sql) { + if (db == null) { + return; + } + if (sql.length() > 0 && sql.charAt(0) == '.') { + do_meta(sql); + } else { + try { + db.exec(sql, this); + } catch (Exception e) { + err.println("SQL Error: " + e); + err.flush(); + } + } + } + + public static void main(String args[]) { + Shell s = new Shell(System.out, System.err); + s.mode = Shell.MODE_List; + s.sep = "|"; + s.showHeader = false; + s.db = new Database(); + String dbname = null, sql = null; + for (int i = 0; i < args.length; i++) { + if(args[i].compareTo("-html") ==0) { + s.mode = Shell.MODE_Html; + } else if (args[i].compareTo("-list") == 0) { + s.mode = Shell.MODE_List; + } else if (args[i].compareTo("-line") == 0) { + s.mode = Shell.MODE_Line; + } else if (i < args.length - 1 && + args[i].compareTo("-separator") == 0) { + ++i; + s.sep = args[i]; + } else if (args[i].compareTo("-header") == 0) { + s.showHeader = true; + } else if (args[i].compareTo("-noheader") == 0) { + s.showHeader = false; + } else if (args[i].compareTo("-echo") == 0) { + s.echo = true; + } else if (dbname == null) { + dbname = args[i]; + } else if (sql == null) { + sql = args[i]; + } else { + System.err.println("Arguments: ?OPTIONS? FILENAME ?SQL?"); + System.exit(1); + } + } + if (dbname == null) { + System.err.println("No database file given"); + System.exit(1); + } + try { + s.db.open(dbname, 0); + } catch (Exception e) { + System.err.println("Unable to open database: " + e); + System.exit(1); + } + if (sql != null) { + s.do_cmd(sql); + } else { + // BEGIN android-modified + BufferedReader is = + new BufferedReader(new InputStreamReader(System.in), 8192); + // END android-modified + s.do_input(is); + } + try { + s.db.close(); + } catch (Exception ee) { + } + } +} + +/** + * Internal class for dumping an entire database. + * It contains a special callback interface to traverse the + * tables of the current database and output create SQL statements + * and for the data insert SQL statements. + */ + +class DBDump implements Callback { + Shell s; + + DBDump(Shell s, String tables[]) { + this.s = s; + s.pw.println("BEGIN TRANSACTION;"); + if (tables == null || tables.length == 0) { + try { + s.db.exec("SELECT name, type, sql FROM sqlite_master " + + "WHERE type!='meta' AND sql NOT NULL " + + "ORDER BY substr(type,2,1), name", this); + } catch (Exception e) { + s.err.println("SQL Error: " + e); + s.err.flush(); + } + } else { + String arg[] = new String[1]; + for (int i = 0; i < tables.length; i++) { + arg[0] = tables[i]; + try { + s.db.exec("SELECT name, type, sql FROM sqlite_master " + + "WHERE tbl_name LIKE '%q' AND type!='meta' " + + " AND sql NOT NULL " + + " ORDER BY substr(type,2,1), name", + this, arg); + } catch (Exception e) { + s.err.println("SQL Error: " + e); + s.err.flush(); + } + } + } + s.pw.println("COMMIT;"); + } + + public void columns(String col[]) { + /* Empty body to satisfy SQLite.Callback interface. */ + } + + public void types(String args[]) { + /* Empty body to satisfy SQLite.Callback interface. */ + } + + public boolean newrow(String args[]) { + if (args.length != 3) { + return true; + } + s.pw.println(args[2] + ";"); + if (args[1].compareTo("table") == 0) { + Shell s2 = (Shell) s.clone(); + s2.mode = Shell.MODE_Insert; + s2.set_table_name(args[0]); + String qargs[] = new String[1]; + qargs[0] = args[0]; + try { + if (s2.db.is3()) { + TableResult t = null; + t = s2.db.get_table("PRAGMA table_info('%q')", qargs); + String query; + if (t != null) { + StringBuffer sb = new StringBuffer(); + String sep = ""; + + sb.append("SELECT "); + for (int i = 0; i < t.nrows; i++) { + String col = ((String[]) t.rows.elementAt(i))[1]; + sb.append(sep + "quote(" + + Shell.sql_quote_dbl(col) + ")"); + sep = ","; + } + sb.append(" from '%q'"); + query = sb.toString(); + s2.mode = Shell.MODE_Insert2; + } else { + query = "SELECT * from '%q'"; + } + s2.db.exec(query, s2, qargs); + } else { + s2.db.exec("SELECT * from '%q'", s2, qargs); + } + } catch (Exception e) { + s.err.println("SQL Error: " + e); + s.err.flush(); + return true; + } + } + return false; + } +} diff --git a/sql/src/main/java/SQLite/Stmt.java b/sql/src/main/java/SQLite/Stmt.java new file mode 100644 index 0000000..c4f72ed --- /dev/null +++ b/sql/src/main/java/SQLite/Stmt.java @@ -0,0 +1,288 @@ +package SQLite; + +/** + * Class to represent compiled SQLite3 statement. + * + * Note, that all native methods of this class are + * not synchronized, i.e. it is up to the caller + * to ensure that only one thread is in these + * methods at any one time. + */ + +public class Stmt { + + /** + * Internal handle for the SQLite3 statement. + */ + + private long handle = 0; + + /** + * Internal last error code for prepare()/step() methods. + */ + + protected int error_code = 0; + + /** + * Prepare the next SQL statement for the Stmt instance. + * @return true when the next piece of the SQL statement sequence + * has been prepared, false on end of statement sequence. + */ + + public native boolean prepare() throws SQLite.Exception; + + /** + * Perform one step of compiled SQLite3 statement. + * + * Example:<BR> + * <PRE> + * ... + * try { + * Stmt s = db.prepare("select * from x; select * from y;"); + * s.bind(...); + * ... + * s.bind(...); + * while (s.step(cb)) { + * Object o = s.value(...); + * ... + * } + * // s.reset() for re-execution or + * // s.prepare() for the next piece of SQL + * while (s.prepare()) { + * s.bind(...); + * ... + * s.bind(...); + * while (s.step(cb)) { + * Object o = s.value(...); + * ... + * } + * } + * } catch (SQLite.Exception e) { + * s.close(); + * } + * </PRE> + * + * @return true when row data is available, false on end + * of result set. + */ + + public native boolean step() throws SQLite.Exception; + + /** + * Close the compiled SQLite3 statement. + */ + + public native void close() throws SQLite.Exception; + + /** + * Reset the compiled SQLite3 statement without + * clearing parameter bindings. + */ + + public native void reset() throws SQLite.Exception; + + /** + * Clear all bound parameters of the compiled SQLite3 statement. + */ + + public native void clear_bindings() throws SQLite.Exception; + + /** + * Bind positional integer value to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param value value of parameter + */ + + public native void bind(int pos, int value) throws SQLite.Exception; + + /** + * Bind positional long value to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param value value of parameter + */ + + public native void bind(int pos, long value) throws SQLite.Exception; + + /** + * Bind positional double value to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param value value of parameter + */ + + public native void bind(int pos, double value) throws SQLite.Exception; + + /** + * Bind positional byte array to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param value value of parameter, may be null + */ + + public native void bind(int pos, byte[] value) throws SQLite.Exception; + + /** + * Bind positional String to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param value value of parameter, may be null + */ + + public native void bind(int pos, String value) throws SQLite.Exception; + + /** + * Bind positional SQL null to compiled SQLite3 statement. + * @param pos parameter index, 1-based + */ + + public native void bind(int pos) throws SQLite.Exception; + + /** + * Bind positional zero'ed blob to compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @param length byte size of zero blob + */ + + public native void bind_zeroblob(int pos, int length) + throws SQLite.Exception; + + /** + * Return number of parameters in compiled SQLite3 statement. + * @return int number of parameters + */ + + public native int bind_parameter_count() throws SQLite.Exception; + + /** + * Return name of parameter in compiled SQLite3 statement. + * @param pos parameter index, 1-based + * @return String parameter name + */ + + public native String bind_parameter_name(int pos) throws SQLite.Exception; + + /** + * Return index of named parameter in compiled SQLite3 statement. + * @param name of parameter + * @return int index of parameter, 1-based + */ + + public native int bind_parameter_index(String name) + throws SQLite.Exception; + + + /** + * Retrieve integer column from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return int column value + */ + + public native int column_int(int col) throws SQLite.Exception; + + /** + * Retrieve long column from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return long column value + */ + public native long column_long(int col) throws SQLite.Exception; + + /** + * Retrieve double column from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return double column value + */ + public native double column_double(int col) throws SQLite.Exception; + + /** + * Retrieve blob column from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return byte[] column value + */ + public native byte[] column_bytes(int col) throws SQLite.Exception; + + /** + * Retrieve string column from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return String column value + */ + public native String column_string(int col) throws SQLite.Exception; + + /** + * Retrieve column type from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return column type code, e.g. SQLite.Constants.SQLITE_INTEGER + */ + public native int column_type(int col) throws SQLite.Exception; + + /** + * Retrieve number of columns of exec'ed SQLite3 statement. + * @return int number of columns + */ + + public native int column_count() throws SQLite.Exception; + + /** + * Retrieve column data as object from exec'ed SQLite3 statement. + * @param col column number, 0-based + * @return Object or null + */ + + public Object column(int col) throws SQLite.Exception { + switch (column_type(col)) { + case Constants.SQLITE_INTEGER: + return new Long(column_long(col)); + case Constants.SQLITE_FLOAT: + return new Double(column_double(col)); + case Constants.SQLITE_BLOB: + return column_bytes(col); + case Constants.SQLITE3_TEXT: + return column_string(col); + } + return null; + } + + /** + * Return table name of column of SQLite3 statement. + * @param col column number, 0-based + * @return String or null + */ + + public native String column_table_name(int col) throws SQLite.Exception; + + /** + * Return database name of column of SQLite3 statement. + * @param col column number, 0-based + * @return String or null + */ + + public native String column_database_name(int col) throws SQLite.Exception; + + /** + * Return declared column type of SQLite3 statement. + * @param col column number, 0-based + * @return String or null + */ + + public native String column_decltype(int col) throws SQLite.Exception; + + /** + * Return origin column name of column of SQLite3 statement. + * @param col column number, 0-based + * @return String or null + */ + + public native String column_origin_name(int col) throws SQLite.Exception; + + /** + * Destructor for object. + */ + + protected native void finalize(); + + /** + * Internal native initializer. + */ + + private static native void internal_init(); + + static { + internal_init(); + } +} diff --git a/sql/src/main/java/SQLite/StringEncoder.java b/sql/src/main/java/SQLite/StringEncoder.java new file mode 100644 index 0000000..c2f20ad --- /dev/null +++ b/sql/src/main/java/SQLite/StringEncoder.java @@ -0,0 +1,201 @@ +package SQLite; + +/** + * String encoder/decoder for SQLite. + * + * This module was kindly donated by Eric van der Maarel of Nedap N.V. + * + * This encoder was implemented based on an original idea from an anonymous + * author in the source code of the SQLite distribution. + * I feel obliged to provide a quote from the original C-source code: + * + * "The author disclaims copyright to this source code. In place of + * a legal notice, here is a blessing: + * + * May you do good and not evil. + * May you find forgiveness for yourself and forgive others. + * May you share freely, never taking more than you give." + * + */ + +public class StringEncoder { + + /** + * Encodes the given byte array into a string that can be used by + * the SQLite database. The database cannot handle null (0x00) and + * the character '\'' (0x27). The encoding consists of escaping + * these characters with a reserved character (0x01). The escaping + * is applied after determining and applying a shift that minimizes + * the number of escapes required. + * With this encoding the data of original size n is increased to a + * maximum of 1+(n*257)/254. + * For sufficiently large n the overhead is thus less than 1.2%. + * @param a the byte array to be encoded. A null reference is handled as + * an empty array. + * @return the encoded bytes as a string. When an empty array is + * provided a string of length 1 is returned, the value of + * which is bogus. + * When decoded with this class' <code>decode</code> method + * a string of size 1 will return an empty byte array. + */ + + public static String encode(byte[] a) { + // check input + if (a == null || a.length == 0) { + // bogus shift, no data + return "x"; + } + // determine count + int[] cnt = new int[256]; + for (int i = 0 ; i < a.length; i++) { + cnt[a[i] & 0xff]++; + } + // determine shift for minimum number of escapes + int shift = 1; + int nEscapes = a.length; + for (int i = 1; i < 256; i++) { + if (i == '\'') { + continue; + } + int sum = cnt[i] + cnt[(i + 1) & 0xff] + cnt[(i + '\'') & 0xff]; + if (sum < nEscapes) { + nEscapes = sum; + shift = i; + if (nEscapes == 0) { + // cannot become smaller + break; + } + } + } + // construct encoded output + int outLen = a.length + nEscapes + 1; + StringBuffer out = new StringBuffer(outLen); + out.append((char)shift); + for (int i = 0; i < a.length; i++) { + // apply shift + char c = (char)((a[i] - shift)&0xff); + // insert escapes + if (c == 0) { // forbidden + out.append((char)1); + out.append((char)1); + } else if (c == 1) { // escape character + out.append((char)1); + out.append((char)2); + } else if (c == '\'') { // forbidden + out.append((char)1); + out.append((char)3); + } else { + out.append(c); + } + } + return out.toString(); + } + + /** + * Decodes the given string that is assumed to be a valid encoding + * of a byte array. Typically the given string is generated by + * this class' <code>encode</code> method. + * @param s the given string encoding. + * @return the byte array obtained from the decoding. + * @throws IllegalArgumentException when the string given is not + * a valid encoded string for this encoder. + */ + + public static byte[] decode(String s) { + char[] a = s.toCharArray(); + if (a.length > 2 && a[0] == 'X' && + a[1] == '\'' && a[a.length-1] == '\'') { + // SQLite3 BLOB syntax + byte[] result = new byte[(a.length-3)/2]; + for (int i = 2, k = 0; i < a.length - 1; i += 2, k++) { + byte tmp = (byte) (a[i] - '0'); + if (tmp > 15) { + tmp -= 0x20; + } + result[k] = (byte) (tmp << 4); + tmp = (byte) (a[i+1] - '0'); + if (tmp > 15) { + tmp -= 0x20; + } + result[k] |= tmp; + } + return result; + } + // first element is the shift + byte[] result = new byte[a.length-1]; + int i = 0; + int shift = s.charAt(i++); + int j = 0; + while (i < s.length()) { + int c; + if ((c = s.charAt(i++)) == 1) { // escape character found + if ((c = s.charAt(i++)) == 1) { + c = 0; + } else if (c == 2) { + c = 1; + } else if (c == 3) { + c = '\''; + } else { + throw new IllegalArgumentException( + "invalid string passed to decoder: " + j); + } + } + // do shift + result[j++] = (byte)((c + shift) & 0xff); + } + int outLen = j; + // provide array of correct length + if (result.length != outLen) { + result = byteCopy(result, 0, outLen, new byte[outLen]); + } + return result; + } + + /** + * Copies count elements from source, starting at element with + * index offset, to the given target. + * @param source the source. + * @param offset the offset. + * @param count the number of elements to be copied. + * @param target the target to be returned. + * @return the target being copied to. + */ + + private static byte[] byteCopy(byte[] source, int offset, + int count, byte[] target) { + for (int i = offset, j = 0; i < offset + count; i++, j++) { + target[j] = source[i]; + } + return target; + } + + + static final char[] xdigits = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' + }; + + /** + * Encodes the given byte array into SQLite3 blob notation, ie X'..' + * @param a the byte array to be encoded. A null reference is handled as + * an empty array. + * @return the encoded bytes as a string. + */ + + public static String encodeX(byte[] a) { + // check input + if (a == null || a.length == 0) { + return "X''"; + } + int outLen = a.length + 3; + StringBuffer out = new StringBuffer(outLen); + out.append('X'); + out.append('\''); + for (int i = 0; i < a.length; i++) { + out.append(xdigits[a[i] >> 4]); + out.append(xdigits[a[i] & 0x0F]); + } + out.append('\''); + return out.toString(); + } +} diff --git a/sql/src/main/java/SQLite/TableResult.java b/sql/src/main/java/SQLite/TableResult.java new file mode 100644 index 0000000..1a7fb57 --- /dev/null +++ b/sql/src/main/java/SQLite/TableResult.java @@ -0,0 +1,133 @@ +package SQLite; + +import java.util.Vector; + +/** + * Class representing an SQLite result set as + * returned by the + * <A HREF="Database.html#get_table(java.lang.String)">Database.get_table</A> + * convenience method. + * <BR><BR> + * Example:<BR> + * + * <PRE> + * ... + * SQLite.Database db = new SQLite.Database(); + * db.open("db", 0); + * System.out.print(db.get_table("select * from TEST")); + * ... + * </PRE> + * Example output:<BR> + * + * <PRE> + * id|firstname|lastname| + * 0|John|Doe| + * 1|Speedy|Gonzales| + * ... + * </PRE> + */ + +public class TableResult implements Callback { + + /** + * Number of columns in the result set. + */ + + public int ncolumns; + + /** + * Number of rows in the result set. + */ + + public int nrows; + + /** + * Column names of the result set. + */ + + public String column[]; + + /** + * Types of columns of the result set or null. + */ + + public String types[]; + + /** + * Rows of the result set. Each row is stored as a String array. + */ + + public Vector rows; + + /** + * Create an empty result set. + */ + + public TableResult() { + clear(); + } + + /** + * Clear result set. + */ + + public void clear() { + column = new String[0]; + types = null; + rows = new Vector(); + ncolumns = nrows = 0; + } + + /** + * Callback method used while the query is executed. + */ + + public void columns(String coldata[]) { + column = coldata; + ncolumns = column.length; + } + + /** + * Callback method used while the query is executed. + */ + + public void types(String types[]) { + this.types = types; + } + + /** + * Callback method used while the query is executed. + */ + + public boolean newrow(String rowdata[]) { + if (rowdata != null) { + rows.addElement(rowdata); + nrows++; + } + return false; + } + + /** + * Make String representation of result set. + */ + + public String toString() { + StringBuffer sb = new StringBuffer(); + int i; + for (i = 0; i < ncolumns; i++) { + sb.append(column[i] == null ? "NULL" : column[i]); + sb.append('|'); + } + sb.append('\n'); + for (i = 0; i < nrows; i++) { + int k; + String row[] = (String[]) rows.elementAt(i); + for (k = 0; k < ncolumns; k++) { + sb.append(row[k] == null ? "NULL" : row[k]); + sb.append('|'); + } + sb.append('\n'); + } + return sb.toString(); + } +} diff --git a/sql/src/main/java/SQLite/Trace.java b/sql/src/main/java/SQLite/Trace.java new file mode 100644 index 0000000..19ed2a1 --- /dev/null +++ b/sql/src/main/java/SQLite/Trace.java @@ -0,0 +1,17 @@ +package SQLite; + +/** + * Callback interface for SQLite's trace function. + */ + +public interface Trace { + + /** + * Callback to trace (ie log) one SQL statement. + * + * @param stmt SQL statement string + */ + + public void trace(String stmt); +} + diff --git a/sql/src/main/java/SQLite/Vm.java b/sql/src/main/java/SQLite/Vm.java new file mode 100644 index 0000000..9856ed0 --- /dev/null +++ b/sql/src/main/java/SQLite/Vm.java @@ -0,0 +1,78 @@ +package SQLite; + +/** + * Class to represent compiled SQLite VM. + */ + +public class Vm { + + /** + * Internal handle for the compiled SQLite VM. + */ + + private long handle = 0; + + /** + * Internal last error code for compile()/step() methods. + */ + + protected int error_code = 0; + + /** + * Perform one step on compiled SQLite VM. + * The result row is passed to the given callback interface.<BR><BR> + * + * Example:<BR> + * <PRE> + * ... + * try { + * Vm vm = db.compile("select * from x; select * from y;"); + * while (vm.step(cb)) { + * ... + * } + * while (vm.compile()) { + * while (vm.step(cb)) { + * ... + * } + * } + * } catch (SQLite.Exception e) { + * } + * </PRE> + * + * @param cb the object implementing the callback methods. + * @return true as long as more row data can be retrieved, + * false, otherwise. + */ + + public native boolean step(Callback cb) throws SQLite.Exception; + + /** + * Compile the next SQL statement for the SQLite VM instance. + * @return true when SQL statement has been compiled, false + * on end of statement sequence. + */ + + public native boolean compile() throws SQLite.Exception; + + /** + * Abort the compiled SQLite VM. + */ + + public native void stop() throws SQLite.Exception; + + /** + * Destructor for object. + */ + + protected native void finalize(); + + /** + * Internal native initializer. + */ + + private static native void internal_init(); + + static { + internal_init(); + } +} diff --git a/sql/src/main/java/java/sql/Array.java b/sql/src/main/java/java/sql/Array.java new file mode 100644 index 0000000..e1d903e --- /dev/null +++ b/sql/src/main/java/java/sql/Array.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Map; + +/** + * A Java representation of the SQL ARRAY type. + */ +public interface Array { + + /** + * Retrieves the contents of the SQL ARRAY value as a Java array object. + * + * @return A Java array containing the elements of this Array + * @throws SQLException + */ + public Object getArray() throws SQLException; + + /** + * Returns part of the SQL ARRAY associated with this Array, starting at a + * particular index and comprising up to count successive elements of the + * SQL array. + * + * @param index + * @param count + * @return A Java array containing the subportion of elements of this Array + * @throws SQLException + */ + public Object getArray(long index, int count) throws SQLException; + + /** + * Returns part of the SQL ARRAY associated with this Array, starting at a + * particular index and comprising up to count successive elements of the + * SQL array. + * + * @param index + * @param count + * @param map + * @return A Java array containing the subportion of elements of this Array + * @throws SQLException + */ + public Object getArray(long index, int count, Map<String, Class<?>> map) + throws SQLException; + + /** + * Returns the SQL ARRAY associated with this Array. + * + * @param map + * @return A Java array containing the elements of this Array + * @throws SQLException + */ + public Object getArray(Map<String, Class<?>> map) throws SQLException; + + /** + * Returns the JDBC type of the entries in this Array's associated array. + * + * @return An integer constant from the java.sql.Types class + * @throws SQLException + */ + public int getBaseType() throws SQLException; + + /** + * Returns the SQL type name of the entries in the array associated with + * this Array. + * + * @return The database specific name or a fully-qualified SQL type name. + * @throws SQLException + */ + public String getBaseTypeName() throws SQLException; + + /** + * Returns a ResultSet object which holds the entries of the SQL ARRAY + * associated with this Array. + * + * @return the ResultSet + * @throws SQLException + */ + public ResultSet getResultSet() throws SQLException; + + /** + * Returns a ResultSet object that holds the entries of a subarray, + * beginning at a particular index and comprising up to count successive + * entries. + * + * @param index + * @param count + * @return the ResultSet + * @throws SQLException + */ + public ResultSet getResultSet(long index, int count) throws SQLException; + + /** + * Returns a ResultSet object that holds the entries of a subarray, + * beginning at a particular index and comprising up to count successive + * entries. + * + * @param index + * @param count + * @param map + * @return the ResultSet + * @throws SQLException + */ + public ResultSet getResultSet(long index, int count, + Map<String, Class<?>> map) throws SQLException; + + /** + * Returns a ResultSet object which holds the entries of the SQL ARRAY + * associated with this Array. + * + * @param map + * @return the ResultSet + * @throws SQLException + */ + public ResultSet getResultSet(Map<String, Class<?>> map) + throws SQLException; + +} diff --git a/sql/src/main/java/java/sql/BatchUpdateException.java b/sql/src/main/java/java/sql/BatchUpdateException.java new file mode 100644 index 0000000..f39dc5e --- /dev/null +++ b/sql/src/main/java/java/sql/BatchUpdateException.java @@ -0,0 +1,147 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.Serializable; + +/** + * An exception thrown if a problem occurs during a batch update operation. + * <p> + * A BatchUpdateException provides additional information about the problem that + * occurred, compared with a standard SQLException. It supplies update counts + * for successful commands that executed within the batch update, but before the + * exception was encountered. + * <p> + * The element order in the array of update counts matches the order that the + * commands were added to the batch operation. + * <p> + * Once a batch update command fails and a BatchUpdateException is thrown, the + * JDBC driver may continue processing the remaining commands in the batch. If + * the driver does process more commands after the problem occurs, the array + * returned by BatchUpdateException.getUpdateCounts has an element for every + * command in the batch, not only those that executed successfully. In this + * case, the array element for any command which encountered a problem is set to + * Statement.EXECUTE_FAILED. + */ +public class BatchUpdateException extends SQLException implements Serializable { + + private static final long serialVersionUID = 5977529877145521757L; + + private int[] updateCounts = null; + + /** + * Creates a BatchUpdateException with the Reason, SQLState, and Update + * Counts set to null and a Vendor Code of 0. + */ + public BatchUpdateException() { + super(); + } + + /** + * Creates a BatchUpdateException with the Update Counts set to the supplied + * value and the Reason, SQLState set to null and a Vendor Code of 0. + * + * @param updateCounts + * the array of Update Counts to use in initialization + */ + public BatchUpdateException(int[] updateCounts) { + super(); + this.updateCounts = updateCounts; + } + + /** + * Creates a BatchUpdateException with the Update Counts set to the supplied + * value, the Reason set to the supplied value and SQLState set to null and + * a Vendor Code of 0. + * + * @param reason + * the initialization value for Reason + * @param updateCounts + * the array of Update Counts to set + */ + public BatchUpdateException(String reason, int[] updateCounts) { + super(reason); + this.updateCounts = updateCounts; + } + + /** + * Creates a BatchUpdateException with the Update Counts set to the supplied + * value, the Reason set to the supplied value, the SQLState initialized to + * the supplied value and the Vendor Code initialized to 0. + * + * @param reason + * the value to use for the Reason + * @param SQLState + * the X/OPEN value to use for the SQLState + * @param updateCounts + * the array of Update Counts to set + */ + public BatchUpdateException(String reason, String SQLState, + int[] updateCounts) { + super(reason, SQLState); + this.updateCounts = updateCounts; + } + + /** + * Creates a BatchUpdateException with the Update Counts set to the supplied + * value, the Reason set to the supplied value, the SQLState initialized to + * the supplied value and the Vendor Code set to the supplied value. + * + * @param reason + * the value to use for the Reason + * @param SQLState + * the X/OPEN value to use for the SQLState + * @param vendorCode + * the value to use for the vendor error code + * @param updateCounts + * the array of Update Counts to set + */ + public BatchUpdateException(String reason, String SQLState, int vendorCode, + int[] updateCounts) { + super(reason, SQLState, vendorCode); + this.updateCounts = updateCounts; + } + + /** + * Gets the Update Counts array. + * <p> + * If a batch update command fails and a BatchUpdateException is thrown, the + * JDBC driver may continue processing the remaining commands in the batch. + * If the driver does process more commands after the problem occurs, the + * array returned by <code>BatchUpdateException.getUpdateCounts</code> has + * an element for every command in the batch, not only those that executed + * successfully. In this case, the array element for any command which + * encountered a problem is set to Statement.EXECUTE_FAILED. + * + * @return an array that contains the successful update counts, before this + * exception. Alternatively, if the driver continues to process + * commands following an error, one of these listed items for every + * command the batch contains: + * <ol> + * <li>an count of the updates</li> + * <li><code>Statement.SUCCESS_NO_INFO</code> indicating that the + * command completed successfully, but the amount of altered rows is + * not known.</li> + * <li><code>Statement.EXECUTE_FAILED</code> indicating that the + * command was unsuccessful. + * </ol> + */ + public int[] getUpdateCounts() { + return updateCounts; + } +} diff --git a/sql/src/main/java/java/sql/Blob.java b/sql/src/main/java/java/sql/Blob.java new file mode 100644 index 0000000..2b3cff5 --- /dev/null +++ b/sql/src/main/java/java/sql/Blob.java @@ -0,0 +1,160 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.OutputStream; +import java.io.InputStream; + +/** + * A Java interface mapping for the SQL BLOB type. + * <p> + * An SQL CLOB type stores a large array of bytes (binary data) as the value in + * a column of a database. + * <p> + * The java.sql.Blob interface provides methods for setting and retrieving data + * in the Blob, for querying Clob data length, for searching for data within the + * Blob. + */ +public interface Blob { + + /** + * Retrieves this Blob object as a binary stream. + * + * @return a binary InputStream giving access to the Blob data + * @throws SQLException + * if an error occurs accessing the Blob + */ + public InputStream getBinaryStream() throws SQLException; + + /** + * Gets a portion of the value of this Blob as an array of bytes. + * + * @param pos + * the position of the first byte in the Blob to get, where the + * first byte in the Blob has position = 1 + * @param length + * the number of bytes to get + * @return a byte array containing the data from the Blob, starting at pos + * and of length up to <code>length</code> bytes long + * @throws SQLException + * if an error occurs accessing the Blob + */ + public byte[] getBytes(long pos, int length) throws SQLException; + + /** + * Gets the number of bytes in this Blob object. + * + * @return an long value with the length of the Blob in bytes + * @throws SQLException + * if an error occurs accessing the Blob + */ + public long length() throws SQLException; + + /** + * Search for the position in this Blob at which a specified pattern begins, + * starting at a specified position within the Blob. + * + * @param pattern + * a Blob containing the pattern of data to search for in this + * Blob + * @param start + * the position within this Blob to start the search, where the + * first position in the Blob is 1 + * @return a long value with the position at which the pattern begins. -1 if + * the pattern is not found in this Blob. + * @throws SQLException + * if an error occurs accessing the Blob + */ + public long position(Blob pattern, long start) throws SQLException; + + /** + * Search for the position in this Blob at which the specified pattern + * begins, starting at a specified position within the Blob. + * + * @param pattern + * a byte array containing the pattern of data to search for in + * this Blob + * @param start + * the position within this Blob to start the search, where the + * first position in the Blob is 1 + * @return a long value with the position at which the pattern begins. -1 if + * the pattern is not found in this Blob. + * @throws SQLException + * if an error occurs accessing the Blob + */ + public long position(byte[] pattern, long start) throws SQLException; + + /** + * Gets a stream that can be used to write binary data to this Blob. + * + * @param pos + * the position within this Blob at which to start writing, where + * the first position in the Blob is 1 + * @return a binary InputStream which can be used to write data into the + * Blob starting at the specified position. + * @throws SQLException + * if an error occurs accessing the Blob + */ + public OutputStream setBinaryStream(long pos) throws SQLException; + + /** + * Writes a specified array of bytes to this Blob. object, starting at a + * specified position. Returns the number of bytes written. + * + * @param pos + * the position within this Blob at which to start writing, where + * the first position in the Blob is 1 + * @param theBytes + * an array of bytes to write into the Blob + * @return an integer containing the number of bytes written to the Blob + * @throws SQLException + * if an error occurs accessing the Blob + */ + public int setBytes(long pos, byte[] theBytes) throws SQLException; + + /** + * Writes a portion of a specified byte array to this Blob. Returns the + * number of bytes written. + * + * @param pos + * the position within this Blob at which to start writing, where + * the first position in the Blob is 1 + * @param theBytes + * an array of bytes to write into the Blob + * @param offset + * the offset into the byte array from which to start writing + * data - the first byte in the array has offset 0. + * @param len + * the length of data to write, as the number of bytes + * @return an integer containing the number of bytes written to the Blob + * @throws SQLException + * if an error occurs accessing the Blob + */ + public int setBytes(long pos, byte[] theBytes, int offset, int len) + throws SQLException; + + /** + * Truncate the value of this Blob object to a specified length in bytes. + * + * @param len + * the length of data in bytes to truncate the value of this Blob + * @throws SQLException + * if an error occurs accessing the Blob + */ + public void truncate(long len) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/CallableStatement.java b/sql/src/main/java/java/sql/CallableStatement.java new file mode 100644 index 0000000..2097277 --- /dev/null +++ b/sql/src/main/java/java/sql/CallableStatement.java @@ -0,0 +1,1302 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.math.BigDecimal; +import java.util.Calendar; +import java.util.Map; +import java.net.URL; +import java.io.InputStream; +import java.io.Reader; + +/** + * An interface used to call Stored Procedures. + * <p> + * The JDBC API provides an SQL escape syntax allowing Stored Procedures to be + * called in a standard way for all databases. The JDBC escape syntax has two + * forms. One form includes a result parameter. The second form does not include + * a result parameter. Where the result parameter is used, it must be declared + * as an OUT parameter. Other parameters can be declared as IN, OUT or INOUT. + * Parameters are referenced either by name or by a numerical index, with the + * first parameter being 1, the second 1 and so on. Here are examples of the two + * forms of the escape syntax: <code> + * + * { ?= call <.procedurename>.[([parameter1,parameter2,...])]} + * + * {call <.procedurename>.[([parameter1,parameter2,...])]} + * </code> + * <p> + * IN parameters are set before calling the procedure, using the setter methods + * which are inherited from <code>PreparedStatement</code>. For OUT + * parameters, their Type must be registered before executing the stored + * procedure, and the value is retrieved using the getter methods defined in the + * CallableStatement interface. + * <p> + * CallableStatements can return one or more ResultSets. Where multiple + * ResultSets are returned they are accessed using the methods inherited from + * the <code>Statement</code> interface. + */ +public interface CallableStatement extends PreparedStatement { + + /** + * Gets the value of a specified JDBC <code>ARRAY</code> parameter as a + * java.sql.Array. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Array containing the parameter value + * @throws SQLException + * if a database error happens + */ + public Array getArray(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC ARRAY parameter as a java.sql.Array. + * + * @param parameterName + * the parameter of interest's name + * @return a <code>java.sql.Array</code> containing the parameter value + * @throws SQLException + * if there is a problem accessing the database + */ + public Array getArray(String parameterName) throws SQLException; + + /** + * Returns a new {@link BigDecimal} representation of the JDBC + * <code>NUMERIC</code> parameter specified by the input index. + * + * @param parameterIndex + * the parameter number index (starts from 1) + * @return a <code>java.math.BigDecimal</code> with the value of the + * specified parameter. The value <code>null</code> is returned if + * the parameter in question is an SQL <code>NULL</code> + * @throws SQLException + * if there is a problem accessing the database + */ + public BigDecimal getBigDecimal(int parameterIndex) throws SQLException; + + /** + * Returns a new {@link BigDecimal} representation of the JDBC + * <code>NUMERIC</code> parameter specified by the input index. The number + * of digits after the decimal point is specified by <code>scale</code>. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param scale + * the number of digits after the decimal point to get + * @return a <code>java.math.BigDecimal</code> with the value of the + * specified parameter. The value <code>null</code> is returned if + * the parameter in question is an SQL <code>NULL</code> + * @throws SQLException + * if there is a problem accessing the database + * @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} + */ + @Deprecated + public BigDecimal getBigDecimal(int parameterIndex, int scale) + throws SQLException; + + /** + * Returns a new {@link BigDecimal} representation of the JDBC + * <code>NUMERIC</code> parameter specified by the input name. + * + * @param parameterName + * the name of the parameter + * @return a java.math.BigDecimal with the value of the specified parameter. + * null if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public BigDecimal getBigDecimal(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC BLOB parameter as a java.sql.Blob + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Blob with the value. null if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Blob getBlob(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC BLOB parameter as a java.sql.Blob + * + * @param parameterName + * the name of the parameter + * @return a java.sql.Blob with the value. null if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Blob getBlob(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC BIT parameter as a boolean + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a boolean representing the parameter value. false if the value is + * SQL NULL + * @throws SQLException + * if a database error happens + */ + public boolean getBoolean(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC <code>BIT</code> parameter as a + * boolean + * + * @param parameterName + * the parameter of interest's name + * @return a <code>boolean</code> representation of the value of the + * parameter. <code>false</code> is returned if the SQL value is + * <code>NULL</code>. + * @throws SQLException + * if there is a problem accessing the database + */ + public boolean getBoolean(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC TINYINT parameter as a byte + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a byte with the value of the parameter. 0 if the value is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public byte getByte(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC <code>TINYINT</code> parameter as a + * Java <code>byte</code>. + * + * @param parameterName + * the parameter of interest's name + * @return a <code>byte</code> representation of the value of the + * parameter. <code>0</code> is returned if the SQL value is + * <code>NULL</code>. + * @throws SQLException + * if there is a problem accessing the database + */ + public byte getByte(String parameterName) throws SQLException; + + /** + * Returns a byte array representation of the indexed JDBC + * <code>BINARY</code> or <code>VARBINARY</code> parameter. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return an array of bytes with the value of the parameter. null if the + * value is SQL NULL. + * @throws SQLException + * if there is a problem accessing the database + */ + public byte[] getBytes(int parameterIndex) throws SQLException; + + /** + * Returns a byte array representation of the named JDBC <code>BINARY</code> + * or <code>VARBINARY</code> parameter. + * + * @param parameterName + * the name of the parameter + * @return an array of bytes with the value of the parameter. null if the + * value is SQL NULL. + * @throws SQLException + * if there is a problem accessing the database + */ + public byte[] getBytes(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC CLOB parameter as a java.sql.Clob + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Clob with the value of the parameter. null if the + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Clob getClob(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC CLOB parameter as a java.sql.Clob + * + * @param parameterName + * the name of the parameter + * @return a java.sql.Clob with the value of the parameter. null if the + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Clob getClob(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC DATE parameter as a java.sql.Date. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return the java.sql.Date with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC DATE parameter as a java.sql.Date., + * using a specified Calendar to construct the date. + * <p> + * The JDBC driver uses the Calendar to create the Date using a particular + * timezone and locale. Default behaviour of the driver is to use the Java + * virtual machine default settings. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param cal + * the Calendar to use to construct the Date + * @return the java.sql.Date with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(int parameterIndex, Calendar cal) throws SQLException; + + /** + * Gets the value of a specified JDBC DATE parameter as a java.sql.Date. + * + * @param parameterName + * the name of the parameter + * @return the java.sql.Date with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC DATE parameter as a java.sql.Date., + * using a specified Calendar to construct the date. + * <p> + * The JDBC driver uses the Calendar to create the Date using a particular + * timezone and locale. Default behaviour of the driver is to use the Java + * virtual machine default settings. + * + * @param parameterName + * the parameter name + * @param cal + * used for creating the returned <code>Date</code> + * @return the java.sql.Date with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(String parameterName, Calendar cal) throws SQLException; + + /** + * Gets the value of a specified JDBC DOUBLE parameter as a double + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return the double with the parameter value. 0.0 if the value is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public double getDouble(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC DOUBLE parameter as a double + * + * @param parameterName + * the parameter name + * @return the parameter value as represented in a Java <code>double</code>. + * An SQL value of <code>NULL</code> gets represented as + * <code>0</code> (zero). + * @throws SQLException + * if there is a problem accessing the database + */ + public double getDouble(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC FLOAT parameter as a float + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return the float with the parameter value. 0.0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public float getFloat(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC <code>FLOAT</code> parameter as a + * Java <code>float</code>. + * + * @param parameterName + * the parameter name + * @return the parameter value as represented in a Java <code>float</code>. + * An SQL value of <code>NULL</code> gets represented as + * <code>0</code> (zero). + * @throws SQLException + * if there is a problem accessing the database + */ + public float getFloat(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC INTEGER parameter as an int + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return the int with the parameter value. 0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public int getInt(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC INTEGER parameter as an int + * + * @param parameterName + * the name of the parameter + * @return the int with the parameter value. 0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public int getInt(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC BIGINT parameter as a long + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return the long with the parameter value. 0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public long getLong(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC BIGINT parameter as a long + * + * @param parameterName + * the name of the parameter + * @return the long with the parameter value. 0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public long getLong(String parameterName) throws SQLException; + + /** + * Gets the value of a specified parameter as a Java <code>Object</code>. + * <p> + * The object type returned is the JDBC type registered for the parameter + * with a <code>registerOutParameter</code> call. If a parameter was + * registered as a <code>java.sql.Types.OTHER</code> then it may hold + * abstract types that are particular to the connected database. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return an Object holding the value of the parameter. + * @throws SQLException + * if there is a problem accessing the database + */ + public Object getObject(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified parameter as an Object. A Map is supplied + * to provide custom mapping of the parameter value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param map + * the Map holing the mapping from SQL types to Java classes + * @return an Object holding the value of the parameter. + * @throws SQLException + * if a database error happens + */ + public Object getObject(int parameterIndex, Map<String, Class<?>> map) + throws SQLException; + + /** + * Gets the value of a specified parameter as an Object. + * <p> + * The object type returned is the JDBC type registered for the parameter + * with a <code>registerOutParameter</code> call. If a parameter was + * registered as a <code>java.sql.Types.OTHER</code> then it may hold + * abstract types that are particular to the connected database. + * + * @param parameterName + * the parameter name + * @return the Java <code>Object</code> representation of the value of the + * parameter. + * @throws SQLException + * if there is a problem accessing the database + */ + public Object getObject(String parameterName) throws SQLException; + + /** + * Gets the value of a specified parameter as an Object. A Map is supplied + * to provide custom mapping of the parameter value. + * + * @param parameterName + * the parameter name + * @param map + * the <code>Map</code> of SQL types to their Java counterparts + * @return an <code>Object</code> holding the value of the parameter. + * @throws SQLException + * if there is a problem accessing the database + */ + public Object getObject(String parameterName, Map<String, Class<?>> map) + throws SQLException; + + /** + * Gets the value of a specified JDBC REF(<structured type>) parameter as a + * java.sql.Ref + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Ref with the parameter value. null if the value is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public Ref getRef(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC REF(<structured type>) parameter as a + * java.sql.Ref + * + * @param parameterName + * the parameter name + * @return the target parameter's value in the form of a + * <code>java.sql.Ref</code>. A <code>null</code> reference is + * returned for a parameter value of SQL <code>NULL</code>. + * @throws SQLException + * if there is a problem accessing the database + */ + public Ref getRef(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC SMALLINT parameter as a short + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a short with the parameter value. 0 if the value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public short getShort(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC <code>SMALLINT</code> parameter as a + * short + * + * @param parameterName + * the parameter name + * @return the value of the target parameter as a Java <code>short</code>. + * If the value is an SQL <code>NULL</code> then <code>0</code> + * (zero) is returned. + * @throws SQLException + * if there is a problem accessing the database + */ + public short getShort(String parameterName) throws SQLException; + + /** + * Returns the indexed parameter's value as a string. The parameter value + * must be one of the JDBC types <code>CHAR</code>, <code>VARCHAR</code> + * or <code>LONGVARCHAR</code>. + * <p> + * The string corresponding to a <code>CHAR</code> of fixed length will be + * of identical length to the value in the database inclusive of padding + * characters. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a String with the parameter value. null if the value is SQL NULL. + * @throws SQLException + * if there is a problem accessing the database + */ + public String getString(int parameterIndex) throws SQLException; + + /** + * Returns the named parameter's value as a string. The parameter value must + * be one of the JDBC types <code>CHAR</code>, <code>VARCHAR</code> or + * <code>LONGVARCHAR</code>. + * <p> + * The string corresponding to a <code>CHAR</code> of fixed length will be + * of identical length to the value in the database inclusive of padding + * characters. + * + * @param parameterName + * the parameter name + * @return a String with the parameter value. null if the value is SQL NULL. + * @throws SQLException + * if there is a problem accessing the database + */ + public String getString(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC TIME parameter as a java.sql.Time. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Time with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(int parameterIndex) throws SQLException; + + /** + * Gets the value of a specified JDBC TIME parameter as a java.sql.Time, + * using the supplied Calendar to construct the time. The JDBC driver uses + * the Calendar to handle specific timezones and locales when creating the + * Time. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param cal + * the Calendar to use in constructing the Time. + * @return a java.sql.Time with the parameter value. null if the value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(int parameterIndex, Calendar cal) throws SQLException; + + /** + * Gets the value of a specified JDBC <code>TIME</code> parameter as a + * <code>java.sql.Time</code> + * + * @param parameterName + * the parameter name + * @return a new <code>java.sql.Time</code> with the parameter value. A + * <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Time getTime(String parameterName) throws SQLException; + + /** + * Gets the value of a specified JDBC TIME parameter as a java.sql.Time, + * using the supplied Calendar to construct the time. The JDBC driver uses + * the Calendar to handle specific timezones and locales when creating the + * Time. + * + * @param parameterName + * the parameter name + * @param cal + * used for creating the returned <code>Time</code> + * @return a <code>java.sql.Time</code> with the parameter value. A + * <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Time getTime(String parameterName, Calendar cal) throws SQLException; + + /** + * Returns the indexed parameter's <code>TIMESTAMP</code> value as a + * <code>java.sql.Timestamp</code>. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a new <code>java.sql.Timestamp</code> with the parameter value. + * A <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(int parameterIndex) throws SQLException; + + /** + * Returns the indexed parameter's <code>TIMESTAMP</code> value as a + * <code>java.sql.Timestamp</code>. The JDBC driver uses the supplied + * <code>Calendar</code> to handle specific timezones and locales when + * creating the result. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param cal + * used for creating the returned <code>Timestamp</code> + * @return a new <code>java.sql.Timestamp</code> with the parameter value. + * A <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(int parameterIndex, Calendar cal) + throws SQLException; + + /** + * Returns the named parameter's <code>TIMESTAMP</code> value as a + * <code>java.sql.Timestamp</code>. + * + * @param parameterName + * the parameter name + * @return a new <code>java.sql.Timestamp</code> with the parameter value. + * A <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(String parameterName) throws SQLException; + + /** + * Returns the indexed parameter's <code>TIMESTAMP</code> value as a + * <code>java.sql.Timestamp</code>. The JDBC driver uses the supplied + * <code>Calendar</code> to handle specific timezones and locales when + * creating the result. + * + * @param parameterName + * the parameter name + * @param cal + * used for creating the returned <code>Timestamp</code> + * @return a new <code>java.sql.Timestamp</code> with the parameter value. + * A <code>null</code> reference is returned for an SQL value of + * <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(String parameterName, Calendar cal) + throws SQLException; + + /** + * Gets the value of a specified JDBC DATALINK parameter as a java.net.URL. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @return a java.sql.Datalink with the parameter value. null if the value + * is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public URL getURL(int parameterIndex) throws SQLException; + + /** + * Returns the named parameter's JDBC <code>DATALINK</code> value in a new + * Java <code>java.net.URL</code>. + * + * @param parameterName + * the parameter name + * @return a new <code>java.net.URL</code> encapsulating the parameter + * value. A <code>null</code> reference is returned for an SQL + * value of <code>NULL</code> + * @throws SQLException + * if a database error happens + */ + public URL getURL(String parameterName) throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. All OUT parameters must + * have their Type defined before a stored procedure is executed. + * <p> + * The Type defined by this method fixes the Java type that must be + * retrieved using the getter methods of CallableStatement. If a database + * specific type is expected for a parameter, the Type java.sql.Types.OTHER + * should be used. Note that there is another variant of this method for + * User Defined Types or a REF type. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param sqlType + * the JDBC type as defined by java.sql.Types. The JDBC types + * NUMERIC and DECIMAL should be defined using the version of + * <code>registerOutParameter</code> that takes a + * <code>scale</code> parameter. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(int parameterIndex, int sqlType) + throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. All OUT parameters must + * have their Type defined before a stored procedure is executed. This + * version of the registerOutParameter method, which has a scale parameter, + * should be used for the JDBC types NUMERIC and DECIMAL, where there is a + * need to specify the number of digits expected after the decimal point. + * <p> + * The Type defined by this method fixes the Java type that must be + * retrieved using the getter methods of CallableStatement. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param sqlType + * the JDBC type as defined by java.sql.Types. + * @param scale + * the number of digits after the decimal point. Must be greater + * than or equal to 0. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(int parameterIndex, int sqlType, int scale) + throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. This variant of the method + * is designed for use with parameters that are User Defined Types (UDT) or + * a REF type, although it can be used for any type. + * + * @param paramIndex + * the parameter number index, where the first parameter has + * index 1 + * @param sqlType + * a JDBC type expressed as a constant from {@link Types} + * @param typeName + * an SQL type name. For a REF type, this name should be the + * fully qualified name of the referenced type. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(int paramIndex, int sqlType, + String typeName) throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. All OUT parameters must + * have their Type defined before a stored procedure is executed. + * <p> + * The Type defined by this method fixes the Java type that must be + * retrieved using the getter methods of CallableStatement. If a database + * specific type is expected for a parameter, the Type java.sql.Types.OTHER + * should be used. Note that there is another variant of this method for + * User Defined Types or a REF type. + * + * @param parameterName + * the parameter name + * @param sqlType + * a JDBC type expressed as a constant from {@link Types}. Types + * NUMERIC and DECIMAL should be defined using the variant of + * this method that takes a <code>scale</code> parameter. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(String parameterName, int sqlType) + throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. All OUT parameters must + * have their Type defined before a stored procedure is executed. This + * version of the registerOutParameter method, which has a scale parameter, + * should be used for the JDBC types NUMERIC and DECIMAL, where there is a + * need to specify the number of digits expected after the decimal point. + * <p> + * The Type defined by this method fixes the Java type that must be + * retrieved using the getter methods of CallableStatement. + * + * @param parameterName + * the parameter name + * @param sqlType + * a JDBC type expressed as a constant from {@link Types} + * @param scale + * the number of digits after the decimal point. Must be greater + * than or equal to 0. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(String parameterName, int sqlType, + int scale) throws SQLException; + + /** + * Defines the Type of a specified OUT parameter. This variant of the method + * is designed for use with parameters that are User Defined Types (UDT) or + * a REF type, although it can be used for any type.Registers the designated + * output parameter. + * + * @param parameterName + * the parameter name + * @param sqlType + * a JDBC type expressed as a constant from {@link Types} + * @param typeName + * the fully qualified name of an SQL structured type. For a REF + * type, this name should be the fully qualified name of the + * referenced type. + * @throws SQLException + * if a database error happens + */ + public void registerOutParameter(String parameterName, int sqlType, + String typeName) throws SQLException; + + /** + * Sets the value of a specified parameter to the content of a supplied + * InputStream, which has a specified number of bytes. + * <p> + * This is a good method for setting an SQL LONVARCHAR parameter where the + * length of the data is large. Data is read from the InputStream until + * end-of-file is reached or the specified number of bytes is copied. + * + * @param parameterName + * the parameter name + * @param theInputStream + * the ASCII InputStream carrying the data to update the + * parameter with + * @param length + * the number of bytes in the InputStream to copy to the + * parameter + * @throws SQLException + * if a database error happens + */ + public void setAsciiStream(String parameterName, + InputStream theInputStream, int length) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied + * java.math.BigDecimal value. + * + * @param parameterName + * the name of the parameter + * @param theBigDecimal + * the java.math.BigInteger value to set + * @throws SQLException + * if a database error happens + */ + public void setBigDecimal(String parameterName, BigDecimal theBigDecimal) + throws SQLException; + + /** + * Sets the value of a specified parameter to the content of a supplied + * binary InputStream, which has a specified number of bytes. + * <p> + * Use this method when a large amount of data needs to be set into a + * LONGVARBINARY parameter. + * + * @param parameterName + * the name of the parameter + * @param theInputStream + * the binary InputStream carrying the data to update the + * parameter + * @param length + * the number of bytes in the InputStream to copy to the + * parameter + * @throws SQLException + * if a database error happens + */ + public void setBinaryStream(String parameterName, + InputStream theInputStream, int length) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied boolean value. + * + * @param parameterName + * the parameter name + * @param theBoolean + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setBoolean(String parameterName, boolean theBoolean) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied byte value. + * + * @param parameterName + * the parameter name + * @param theByte + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setByte(String parameterName, byte theByte) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied array of bytes. The + * array is mapped to <code>VARBINARY</code> or else + * <code>LONGVARBINARY</code> in the connected database. + * + * @param parameterName + * the parameter name + * @param theBytes + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setBytes(String parameterName, byte[] theBytes) + throws SQLException; + + /** + * Sets the value of a specified parameter to the character content of a + * Reader object, with the specified length of character data. + * + * @param parameterName + * the parameter name + * @param reader + * the new value with which to update the parameter + * @param length + * a count of the characters contained in <code>reader</code> + * @throws SQLException + * if a database error happens + */ + public void setCharacterStream(String parameterName, Reader reader, + int length) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Date + * value. + * + * @param parameterName + * the parameter name + * @param theDate + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setDate(String parameterName, Date theDate) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Date + * value, using a supplied Calendar to map the Date. The Calendar allows the + * application to control the timezone used to compute the SQL DATE in the + * database - without the supplied Calendar, the driver uses the default + * timezone of the Java virtual machine. + * + * @param parameterName + * the parameter name + * @param theDate + * the new value with which to update the parameter + * @param cal + * a Calendar to use to construct the SQL DATE value + * @throws SQLException + * if a database error happens + */ + public void setDate(String parameterName, Date theDate, Calendar cal) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied double value. + * + * @param parameterName + * the parameter name + * @param theDouble + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setDouble(String parameterName, double theDouble) + throws SQLException; + + /** + * Sets the value of a specified parameter to to a supplied float value. + * + * @param parameterName + * the parameter name + * @param theFloat + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setFloat(String parameterName, float theFloat) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied int value. + * + * @param parameterName + * the parameter name + * @param theInt + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setInt(String parameterName, int theInt) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied long value. + * + * @param parameterName + * the parameter name + * @param theLong + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setLong(String parameterName, long theLong) throws SQLException; + + /** + * Sets the value of a specified parameter to SQL NULL. Don't use this + * version of setNull for User Defined Types or for REF type parameters. + * + * @param parameterName + * the parameter name + * @param sqlType + * a JDBC type expressed as a constant from {@link Types} + * @throws SQLException + * if a database error happens + */ + public void setNull(String parameterName, int sqlType) throws SQLException; + + /** + * Sets the value of a specified parameter to be SQL NULL where the + * parameter type is either <code>REF</code> or user defined (e.g. + * <code>STRUCT</code>, <code>JAVA_OBJECT</code> etc). + * <p> + * For reasons of portability, the caller is expected to supply both the SQL + * Type code and Type name (which is just the parameter name if the type is + * user defined, or the name of the type being referenced if a REF). + * + * @param parameterName + * the parameter name + * @param sqlType + * a JDBC type expressed as a constant from {@link Types} + * @param typeName + * if the target parameter is a user defined type then this + * should contain the full type name + * + * the fully qualified name of a UDT or REF type - ignored if the parameter + * is not a UDT. + * @throws SQLException + * if a database error happens + */ + public void setNull(String parameterName, int sqlType, String typeName) + throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. Prior to + * issuing this request to the connected database <code>theObject</code> + * is transformed to the corresponding SQL type according to the normal Java + * to SQL mapping rules. + * <p> + * If the object's class implements the interface SQLData, the JDBC driver + * calls <code>SQLData.writeSQL</code> to write it to the SQL data stream. + * If <code>theObject</code> implements any of the following interfaces + * then it is the role of the driver to flow the value to the connected + * database using the appropriate SQL type : + * <ul> + * <li>{@link Ref} + * <li>{@link Struct} + * <li>{@link Array} + * <li>{@link Clob} + * <li>{@link Blob} + * </ul> + * + * @param parameterName + * the parameter name + * @param theObject + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setObject(String parameterName, Object theObject) + throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. + * <p> + * The Object is converted to the given targetSqlType before it is sent to + * the database. If the object has a custom mapping (its class implements + * the interface SQLData), the JDBC driver will call the method + * SQLData.writeSQL to write it to the SQL data stream. If + * <code>theObject</code> implements any of the following interfaces then + * it is the role of the driver to flow the value to the connected database + * using the appropriate SQL type : + * <ul> + * <li>{@link Ref} + * <li>{@link Struct} + * <li>{@link Array} + * <li>{@link Clob} + * <li>{@link Blob} + * </ul> + * + * @param parameterName + * the parameter name + * @param theObject + * the new value with which to update the parameter + * @param targetSqlType + * a JDBC type expressed as a constant from {@link Types} + * @throws SQLException + * if a database error happens + */ + public void setObject(String parameterName, Object theObject, + int targetSqlType) throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. + * <p> + * The Object is converted to the given targetSqlType before it is sent to + * the database. If the object has a custom mapping (its class implements + * the interface SQLData), the JDBC driver will call the method + * SQLData.writeSQL to write it to the SQL data stream. If + * <code>theObject</code> implements any of the following interfaces then + * it is the role of the driver to flow the value to the connected database + * using the appropriate SQL type : + * <ul> + * <li>{@link Ref} + * <li>{@link Struct} + * <li>{@link Array} + * <li>{@link Clob} + * <li>{@link Blob} + * </ul> + * + * @param parameterName + * the parameter name + * @param theObject + * the new value with which to update the parameter + * @param targetSqlType + * a JDBC type expressed as a constant from {@link Types} + * @param scale + * where applicable, the number of digits after the decimal + * point. + * @throws SQLException + * if a database error happens + */ + public void setObject(String parameterName, Object theObject, + int targetSqlType, int scale) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied short value. + * + * @param parameterName + * the name of the parameter + * @param theShort + * a short value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setShort(String parameterName, short theShort) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied String. + * + * @param parameterName + * the name of the parameter + * @param theString + * a String value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setString(String parameterName, String theString) + throws SQLException; + + /** + * Sets the value of the parameter named <code>parameterName</code> to the + * value of the supplied <code>java.sql.Time</code>. + * + * @param parameterName + * the parameter name + * @param theTime + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setTime(String parameterName, Time theTime) throws SQLException; + + /** + * Sets the value of the parameter named <code>parameterName</code> to the + * value of the supplied <code>java.sql.Time</code> using the supplied + * Calendar. + * <p> + * The driver uses the supplied Calendar to create the SQL TIME value, which + * allows it to use a custom timezone - otherwise the driver uses the + * default timezone of the Java virtual machine. + * + * @param parameterName + * the parameter name + * @param theTime + * the new value with which to update the parameter + * @param cal + * used for creating the new SQL <code>TIME</code> value + * @throws SQLException + * if a database error happens + */ + public void setTime(String parameterName, Time theTime, Calendar cal) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Timestamp + * value. + * + * @param parameterName + * the parameter name + * @param theTimestamp + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setTimestamp(String parameterName, Timestamp theTimestamp) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Timestamp + * value, using the supplied Calendar. + * <p> + * The driver uses the supplied Calendar to create the SQL TIMESTAMP value, + * which allows it to use a custom timezone - otherwise the driver uses the + * default timezone of the Java virtual machine. + * + * @param parameterName + * the parameter name + * @param theTimestamp + * the new value with which to update the parameter + * @param cal + * used for creating the new SQL <code>TIME</code> value + * @throws SQLException + * if a database error happens + */ + public void setTimestamp(String parameterName, Timestamp theTimestamp, + Calendar cal) throws SQLException; + + /** + * Sets the value of a specified parameter to the supplied java.net.URL. + * + * @param parameterName + * the parameter name + * @param theURL + * the new value with which to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setURL(String parameterName, URL theURL) throws SQLException; + + /** + * Gets whether the value of the last OUT parameter read was SQL NULL. + * + * @return true if the last parameter was SQL NULL, false otherwise. + * @throws SQLException + * if a database error happens + */ + public boolean wasNull() throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Clob.java b/sql/src/main/java/java/sql/Clob.java new file mode 100644 index 0000000..e97b3b1 --- /dev/null +++ b/sql/src/main/java/java/sql/Clob.java @@ -0,0 +1,174 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.InputStream; +import java.io.Reader; +import java.io.OutputStream; +import java.io.Writer; + +/** + * A Java interface mapping for the SQL CLOB type. + * <p> + * An SQL CLOB type stores a large array of characters as the value in a column + * of a database. + * <p> + * The java.sql.Clob interface provides methods for setting and retrieving data + * in the Clob, for querying Clob data length, for searching for data within the + * Clob. + */ +public interface Clob { + + /** + * Gets the value of this Clob object as an ASCII stream. + * + * @return an ASCII InputStream giving access to the Clob data + * @throws SQLException + * if an error occurs accessing the Clob + */ + public InputStream getAsciiStream() throws SQLException; + + /** + * Gets the value of this Clob object as a java.io.Reader. + * + * @return a character stream Reader object giving access to the Clob data + * @throws SQLException + * if an error occurs accessing the Clob + */ + public Reader getCharacterStream() throws SQLException; + + /** + * Gets a copy of a specified substring in this Clob. + * + * @param pos + * the index of the start of the substring in the Clob + * @param length + * the length of the data to retrieve + * @return A String containing the requested data + * @throws SQLException + * if an error occurs accessing the Clob + */ + public String getSubString(long pos, int length) throws SQLException; + + /** + * Retrieves the number of characters in this Clob object. + * + * @return a long value with the number of character in this Clob. + * @throws SQLException + * if an error occurs accessing the Clob + */ + public long length() throws SQLException; + + /** + * Retrieves the character position at which a specified Clob object appears + * in this Clob object. + * + * @param searchstr + * the specified Clob to search for + * @param start + * the position within this Clob to start the search + * @return a long value with the position at which the specified Clob occurs + * within this Clob. + * @throws SQLException + * if an error occurs accessing the Clob + */ + public long position(Clob searchstr, long start) throws SQLException; + + /** + * Retrieves the character position at which a specified substring appears + * in this Clob object. + * + * @param searchstr + * th String to search for + * @param start + * the position at which to start the search within this Clob. + * @return a long value with the position at which the specified String + * occurs within this Clob. + * @throws SQLException + * if an error occurs accessing the Clob + */ + public long position(String searchstr, long start) throws SQLException; + + /** + * Retrieves a stream which can be used to write Ascii characters to this + * Clob object, starting at specified position. + * + * @param pos + * the position at which to start the writing + * @return an OutputStream which can be used to write ASCII characters to + * this Clob. + * @throws SQLException + * if an error occurs accessing the Clob + */ + public OutputStream setAsciiStream(long pos) throws SQLException; + + /** + * Retrieves a stream which can be used to write a stream of Unicode + * characters to this Clob object, at a specified position. + * + * @param pos + * the position at which to start the writing + * @return a Writer which can be used to write Unicode characters to this + * Clob. + * @throws SQLException + * if an error occurs accessing the Clob + */ + public Writer setCharacterStream(long pos) throws SQLException; + + /** + * Writes a given Java String to this Clob object at a specified position. + * + * @param pos + * the position at which to start the writing + * @param str + * the String to write + * @return the number of characters written + * @throws SQLException + * if an error occurs accessing the Clob + */ + public int setString(long pos, String str) throws SQLException; + + /** + * Writes len characters of String, starting at a specified character + * offset, to this Clob. + * + * @param pos + * the position at which to start the writing + * @param str + * the String to write + * @param offset + * the offset within str to start writing from + * @param len + * the number of characters to write + * @return the number of characters written + * @throws SQLException + * if an error occurs accessing the Clob + */ + public int setString(long pos, String str, int offset, int len) + throws SQLException; + + /** + * Truncates this Clob to have a specified length of characters. + * + * @param len + * the length in characters to truncate this Clob + * @throws SQLException + * if an error occurs accessing the Clob + */ + public void truncate(long len) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Connection.java b/sql/src/main/java/java/sql/Connection.java new file mode 100644 index 0000000..4683299 --- /dev/null +++ b/sql/src/main/java/java/sql/Connection.java @@ -0,0 +1,759 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Map; + +/** + * A Connection represents a link from a Java application to a database. All SQL + * statements and results are returned within the context of a connection. + * + */ +public interface Connection { + + /** + * A constant indicating that transactions are not supported. + */ + public static final int TRANSACTION_NONE = 0; + + /** + * No dirty reads are permitted. Transactions may not read a row containing + * changes that have not yet been committed. + */ + public static final int TRANSACTION_READ_COMMITTED = 2; + + /** + * Dirty reads (reading from table rows containing changes that have not yet + * been committed), non-repeatable reads (reading table rows more than once + * in a transaction but getting back different data because other + * transactions may have altered rows between reads), and phantom reads + * (retrieving additional "phantom" rows in the course of repeated table + * reads because other transactions may have inserted additional rows that + * satisfy an SQL <code>WHERE</code> clause) are <b>all permitted</b>. + */ + public static final int TRANSACTION_READ_UNCOMMITTED = 1; + + /** + * A constant indicating that dirty reads and non-repeatable reads are + * prevented; phantom reads can occur. + */ + public static final int TRANSACTION_REPEATABLE_READ = 4; + + /** + * Dirty reads (reading from table rows containing changes that have not yet + * been committed), non-repeatable reads (reading table rows more than once + * in a transaction but getting back different data because other + * transactions may have altered rows between reads), and phantom reads + * (retrieving additional "phantom" rows in the course of repeated table + * reads because other transactions may have inserted additional rows that + * satisfy an SQL <code>WHERE</code> clause) are <b>all prevented</b>. + */ + public static final int TRANSACTION_SERIALIZABLE = 8; + + /** + * Throws away any warnings that may have arisen for this connection. + * Subsequent calls to {@link #getWarnings()} will return <code>null</code> + * up until a brand new warning condition occurs. + * + * @throws SQLException + * if there is a problem accessing the database + */ + public void clearWarnings() throws SQLException; + + /** + * Causes the instant release of all database and driver connection + * resources associated with this object. Any subsequent invocations of this + * method will have no effect. + * <p> + * It is strongly recommended that all Connections are closed before they + * are dereferenced by the application ready for garbage collection. While + * the finalize method of the Connection will close the Connection before + * garbage collection takes place, it is not advisable to leave the close + * operation to take place in this way. Unpredictable performance may result + * from closing Connections in the finalizer. + * + * @throws SQLException + * if there is a problem accessing the database + */ + public void close() throws SQLException; + + /** + * Commits all of the changes made subsequent to the last commit or rollback + * of the associated transaction. All locks in the database held by this + * connection are also relinquished. Calling this operation on connection + * objects in auto-commit mode is an error. + * + * @throws SQLException + * if there is a problem accessing the database or if the target + * connection instance is in auto-commit mode. + */ + public void commit() throws SQLException; + + /** + * Returns a new instance of <code>Statement</code> for issuing SQL + * commands to the remote database. + * <p> + * ResultSets generated by the returned Statement will default to type + * <code>TYPE_FORWARD_ONLY</code> and concurrency level + * <code>CONCUR_READ_ONLY</code>. + * + * @return a <code>Statement</code> object with default settings. + * @throws SQLException + * if there is a problem accessing the database + */ + public Statement createStatement() throws SQLException; + + /** + * Returns a new instance of <code>Statement</code> whose associated + * <code>ResultSet</code>s will have the characteristics specified in the + * type, concurrency and holdability arguments. + * + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * </ul> + * @return a new instance of <code>Statement</code> capable of + * manufacturing <code>ResultSet</code>s that satisfy the + * specified <code>resultSetType</code> and + * <code>resultSetConcurrency</code> values. + * @throws SQLException + * if there is a problem accessing the database + */ + public Statement createStatement(int resultSetType, int resultSetConcurrency) + throws SQLException; + + /** + * Returns a new instance of <code>Statement</code> whose associated + * <code>ResultSet</code>s will have the characteristics specified in the + * type, concurrency and holdability arguments. + * + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * </ul> + * @param resultSetHoldability + * one of : + * <ul> + * <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT} + * <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT} + * </ul> + * @return a new instance of <code>Statement</code> capable of + * manufacturing <code>ResultSet</code>s that satisfy the + * specified <code>resultSetType</code>, + * <code>resultSetConcurrency</code> and + * <code>resultSetHoldability</code> values. + * @throws SQLException + * if there is a problem accessing the database + */ + public Statement createStatement(int resultSetType, + int resultSetConcurrency, int resultSetHoldability) + throws SQLException; + + /** + * Returns a boolean indication of whether or not this connection is in the + * auto-commit operating mode. + * + * @return <code>true</code> if auto-commit is on, otherwise + * <code>false</code> + * @throws SQLException + * if there is a problem accessing the database + */ + public boolean getAutoCommit() throws SQLException; + + /** + * Gets this Connection object's current catalog name. + * + * @return the catalog name. <code>null</code> if there is no catalog + * name. + * @throws SQLException + * if there is a problem accessing the database + */ + public String getCatalog() throws SQLException; + + /** + * Returns the kind of holdability that any <code>ResultSet</code>s made + * from this instance will have. + * + * @return one of : + * <ul> + * <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT} + * <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT} + * </ul> + * @throws SQLException + * if there is a problem accessing the a database + */ + public int getHoldability() throws SQLException; + + /** + * Gets the metadata about the database referenced by this connection. The + * returned <code>DatabaseMetaData</code> describes the database + * topography, available stored procedures, SQL syntax and so on. + * + * @return a <code>DatabaseMetaData</code> object containing the database + * description + * @throws SQLException + * if there is a problem accessing the a database + */ + public DatabaseMetaData getMetaData() throws SQLException; + + /** + * Returns the present value of transaction isolation for this Connection + * instance. + * + * @return the transaction isolation value + * @throws SQLException + * if there is a problem accessing the database + * @see #TRANSACTION_NONE + * @see #TRANSACTION_READ_COMMITTED + * @see #TRANSACTION_READ_UNCOMMITTED + * @see #TRANSACTION_REPEATABLE_READ + * @see #TRANSACTION_SERIALIZABLE + */ + public int getTransactionIsolation() throws SQLException; + + /** + * Returns the Type Map associated with this Connection object. The type map + * will be empty unless the application has added at least one entry. + * + * @return the Type Map as a <code>java.util.Map</code> + * @throws SQLException + * if there is a problem accessing the database + */ + public Map<String, Class<?>> getTypeMap() throws SQLException; + + /** + * Gets the first instance of any <code>SQLWarning</code> objects that may + * have been created in the use of this connection. If at least one warning + * has occurred then this operation returns the first one reported. A + * <code>null</code> indicates that no warnings have occurred. + * <p> + * By invoking the {@link SQLWarning#getNextWarning()} method of the + * returned <code>SQLWarning</code> object it is possible to obtain all + * warning objects. + * + * @return the first warning as an SQLWarning object (may be + * <code>null</code>) + * @throws SQLException + * if there is a problem accessing the database or if the call + * has been made on a connection which has been previously + * closed. + */ + public SQLWarning getWarnings() throws SQLException; + + /** + * Returns a boolean indication of whether or not this connection is in the + * closed state. The closed state may be entered into as a consequence of a + * successful invocation of the {@link #close()} method or else if an error + * has occurred that prevents the connection from functioning normally. + * + * @return <code>true</code> if closed, otherwise <code>false</code> + * @throws SQLException + * if there is a problem accessing the database + */ + public boolean isClosed() throws SQLException; + + /** + * Returns a boolean indication of whether or not this connection is + * currently in read-only state. + * + * @return <code>true</code> if in read-only state, otherwise + * <code>false</code>. + * @throws SQLException + * if there is a problem accessing the database + */ + public boolean isReadOnly() throws SQLException; + + /** + * Returns a string representation of the input SQL statement + * <code>sql</code> expressed in the underlying system's native SQL + * syntax. + * + * @param sql + * the JDBC form of an SQL statement. + * @return the SQL statement in native database format. + * @throws SQLException + * if there is a problem accessing the database + */ + public String nativeSQL(String sql) throws SQLException; + + /** + * Returns a new instance of <code>CallableStatement</code> that may be + * used for making stored procedure calls to the database. + * + * @param sql + * the SQL statement that calls the stored function + * @return a new instance of <code>CallableStatement</code> representing + * the SQL statement. <code>ResultSet</code>s emitted from this + * <code>CallableStatement</code> will default to type + * {@link ResultSet#TYPE_FORWARD_ONLY} and concurrency + * {@link ResultSet#CONCUR_READ_ONLY}. + * @throws SQLException + * if a problem occurs accessing the database + */ + public CallableStatement prepareCall(String sql) throws SQLException; + + /** + * Returns a new instance of <code>CallableStatement</code> that may be + * used for making stored procedure calls to the database. + * <code>ResultSet</code>s emitted from this + * <code>CallableStatement</code> will satisfy the specified + * <code>resultSetType</code> and <code>resultSetConcurrency</code> + * values. + * + * @param sql + * the SQL statement + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * </ul> + * @return a new instance of <code>CallableStatement</code> representing + * the precompiled SQL statement. <code>ResultSet</code>s emitted + * from this <code>CallableStatement</code> will satisfy the + * specified <code>resultSetType</code> and + * <code>resultSetConcurrency</code> values. + * @throws SQLException + * if a problem occurs accessing the database + */ + public CallableStatement prepareCall(String sql, int resultSetType, + int resultSetConcurrency) throws SQLException; + + /** + * Returns a new instance of <code>CallableStatement</code> that may be + * used for making stored procedure calls to the database. ResultSets + * created from this <code>CallableStatement</code> will have + * characteristics determined by the specified type, concurrency and + * holdability arguments. + * + * @param sql + * the SQL statement + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * </ul> + * @param resultSetHoldability + * one of : + * <ul> + * <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT} + * <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT} + * </ul> + * @return a new instance of <code>CallableStatement</code> representing + * the precompiled SQL statement. <code>ResultSet</code>s emitted + * from this <code>CallableStatement</code> will satisfy the + * specified <code>resultSetType</code>, + * <code>resultSetConcurrency</code> and + * <code>resultSetHoldability</code> values. + * @throws SQLException + * if a problem occurs accessing the database + */ + public CallableStatement prepareCall(String sql, int resultSetType, + int resultSetConcurrency, int resultSetHoldability) + throws SQLException; + + /** + * Returns a new instance of <code>PreparedStatement</code> that may be + * used any number of times to execute parameterized requests on the + * database server. + * <p> + * Subject to JDBC driver support, this operation will attempt to send the + * precompiled version of the statement to the database. Alternatively, if + * the driver is not capable of flowing precompiled statements, the + * statement will not reach the database server until it is executed. This + * will have a bearing on precisely when <code>SQLException</code> + * instances get raised. + * <p> + * By default, ResultSets from the returned object will be + * {@link ResultSet#TYPE_FORWARD_ONLY} type with a + * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency. + * + * @param sql + * the SQL statement. + * @return the PreparedStatement containing the supplied SQL statement + * @throws SQLException + * if there is a problem accessing the database + */ + public PreparedStatement prepareStatement(String sql) throws SQLException; + + /** + * Creates a default PreparedStatement that can retrieve automatically + * generated keys. Parameter <code>autoGeneratedKeys</code> may be used to + * specify to the driver if such keys should be made accessible. This is + * only the case when <code>sql</code> is an insert statement. + * <p> + * An SQL statement which may have IN parameters can be stored and + * precompiled in a PreparedStatement. The PreparedStatement can then be + * used to execute the statement multiple times in an efficient way. + * <p> + * Subject to JDBC driver support, this operation will attempt to send the + * precompiled version of the statement to the database. Alternatively, if + * the driver is not capable of flowing precompiled statements, the + * statement will not reach the database server until it is executed. This + * will have a bearing on precisely when <code>SQLException</code> + * instances get raised. + * <p> + * By default, ResultSets from the returned object will be + * {@link ResultSet#TYPE_FORWARD_ONLY} type with a + * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency. + * + * @param sql + * the SQL statement. + * @param autoGeneratedKeys + * one of : + * <ul> + * <li>{@link Statement#RETURN_GENERATED_KEYS} + * <li>{@link Statement#NO_GENERATED_KEYS} + * </ul> + * @return a new <code>PreparedStatement</code> instance representing the + * input SQL statement. + * @throws SQLException + * if there is a problem accessing the database + */ + public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) + throws SQLException; + + /** + * Creates a default PreparedStatement that can retrieve the auto-generated + * keys designated by a supplied array. If <code>sql</code> is an SQL + * <code>INSERT</code> statement, parameter <code>columnIndexes</code> + * is expected to hold the index values for each column in the statement's + * intended database table containing the autogenerated-keys of interest. + * Otherwise <code>columnIndexes</code> is ignored. + * <p> + * Subject to JDBC driver support, this operation will attempt to send the + * precompiled version of the statement to the database. Alternatively, if + * the driver is not capable of flowing precompiled statements, the + * statement will not reach the database server until it is executed. This + * will have a bearing on precisely when <code>SQLException</code> + * instances get raised. + * <p> + * By default, ResultSets from the returned object will be + * {@link ResultSet#TYPE_FORWARD_ONLY} type with a + * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency. + * + * @param sql + * the SQL statement. + * @param columnIndexes + * the indexes of the columns for which auto-generated keys + * should be made available. + * @return the PreparedStatement containing the supplied SQL statement + * @throws SQLException + * if a problem occurs accessing the database + */ + public PreparedStatement prepareStatement(String sql, int[] columnIndexes) + throws SQLException; + + /** + * Creates a PreparedStatement that generates ResultSets with the specified + * values of <code>resultSetType</code> and + * <code>resultSetConcurrency</code>. + * + * @param sql + * the SQL statement. It can contain one or more '?' IN parameter + * placeholders + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * </ul> + * @return a new instance of <code>PreparedStatement</code> containing the + * SQL statement <code>sql</code>. <code>ResultSet</code>s + * emitted from this <code>PreparedStatement</code> will satisfy + * the specified <code>resultSetType</code> and + * <code>resultSetConcurrency</code> values. + * @throws SQLException + * if a problem occurs accessing the database + */ + public PreparedStatement prepareStatement(String sql, int resultSetType, + int resultSetConcurrency) throws SQLException; + + /** + * Creates a PreparedStatement that generates ResultSets with the specified + * type, concurrency and holdability + * + * @param sql + * the SQL statement. It can contain one or more '?' IN parameter + * placeholders + * @param resultSetType + * one of : + * <ul> + * <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} + * <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE} + * <li>{@link ResultSet#TYPE_FORWARD_ONLY} + * </ul> + * @param resultSetConcurrency + * one of : + * <ul> + * <li>{@link ResultSet#CONCUR_READ_ONLY} + * <li>{@link ResultSet#CONCUR_UPDATABLE} + * </ul> + * @param resultSetHoldability + * one of : + * <ul> + * <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT} + * <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT} + * </ul> + * + * @return a new instance of <code>PreparedStatement</code> containing the + * SQL statement <code>sql</code>. <code>ResultSet</code>s + * emitted from this <code>PreparedStatement</code> will satisfy + * the specified <code>resultSetType</code>, + * <code>resultSetConcurrency</code> and + * <code>resultSetHoldability</code> values. + * @throws SQLException + * if a problem occurs accessing the database + */ + public PreparedStatement prepareStatement(String sql, int resultSetType, + int resultSetConcurrency, int resultSetHoldability) + throws SQLException; + + /** + * Creates a default PreparedStatement that can retrieve the auto-generated + * keys designated by a supplied array. If <code>sql</code> is an SQL + * <code>INSERT</code> statement, <code>columnNames</code> is expected + * to hold the names of each column in the statement's associated database + * table containing the autogenerated-keys of interest. Otherwise + * <code>columnNames</code> is ignored. + * <p> + * Subject to JDBC driver support, this operation will attempt to send the + * precompiled version of the statement to the database. Alternatively, if + * the driver is not capable of flowing precompiled statements, the + * statement will not reach the database server until it is executed. This + * will have a bearing on precisely when <code>SQLException</code> + * instances get raised. + * <p> + * By default, ResultSets from the returned object will be + * {@link ResultSet#TYPE_FORWARD_ONLY} type with a + * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency. + * + * @param sql + * the SQL statement. + * @param columnNames + * the names of the columns for which auto-generated keys should + * be made available. + * @return the PreparedStatement containing the supplied SQL statement + * @throws SQLException + * if a problem occurs accessing the database + */ + public PreparedStatement prepareStatement(String sql, String[] columnNames) + throws SQLException; + + /** + * Releases <code>savepoint</code> from the present transaction. Once + * removed, the <code>Savepoint</code> is considered invalid and should + * not be referenced further. + * + * @param savepoint + * the object targeted for removal + * @throws SQLException + * if there is a problem with accessing the database or if + * <code>savepoint</code> is considered not valid in this + * transaction. + */ + public void releaseSavepoint(Savepoint savepoint) throws SQLException; + + /** + * Rolls back all updates made so far in this transaction as well as + * relinquishing all acquired database locks. It is an error to invoke this + * operation when in auto-commit mode. + * + * @throws SQLException + * if there is a problem with the database or if the method is + * called while in auto-commit mode of operation. + */ + public void rollback() throws SQLException; + + /** + * Undoes all changes made after the supplied Savepoint object was set. This + * method should only be used when auto-commit mode is disabled. + * + * @param savepoint + * the Savepoint to roll back to + * @throws SQLException + * if there is a problem accessing the database + */ + public void rollback(Savepoint savepoint) throws SQLException; + + /** + * Sets this connection's auto-commit mode on or off. + * <p> + * Putting a Connection into auto-commit mode means that all associated SQL + * statements will be run and committed in their own separate transactions. + * Alternatively, auto-commit set to off means that associated SQL + * statements get grouped into transactions that need to be completed by + * explicit calls to either the {@link #commit()} or {@link #rollback()} + * methods. + * <p> + * Auto-commit is the default mode for new connection instances. + * <p> + * When in this mode, commits will automatically occur upon successful SQL + * statement completion or upon successful completion of an execute. + * Statements are not considered successfully complete until all associated + * <code>ResultSet</code>s and output parameters have been obtained or + * closed. + * <p> + * Calling this operation during an uncommitted transaction will result in + * it being committed. + * + * @param autoCommit + * boolean indication of whether to put the target connection + * into auto-commit mode (<code>true</code>) or not (<code>false</code>) + * + * @throws SQLException + * if there is a problem accessing the database + */ + public void setAutoCommit(boolean autoCommit) throws SQLException; + + /** + * Sets the catalog name for this connection. This is used to select a + * subspace of the database for future work. If the driver does not support + * catalog names, this method is ignored. + * + * @param catalog + * the catalog name to use. + * @throws SQLException + * if there is a problem accessing the database + */ + public void setCatalog(String catalog) throws SQLException; + + /** + * Sets the holdability of ResultSets created by this Connection. + * + * @param holdability + * one of : + * <ul> + * <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT} + * <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT} + * <li> + * </ul> + * @throws SQLException + * if there is a problem accessing the database + */ + public void setHoldability(int holdability) throws SQLException; + + /** + * Sets this connection to read-only mode. + * <p> + * This serves as a hint to the driver, which can enable database + * optimizations. + * + * @param readOnly + * true to set the Connection to read only mode. false disables + * read-only mode + * @throws SQLException + * if there is a problem accessing the database + */ + public void setReadOnly(boolean readOnly) throws SQLException; + + /** + * Creates an unnamed Savepoint in the current transaction. + * + * @return a Savepoint object for this savepoint. + * @throws SQLException + * if there is a problem accessing the database + */ + public Savepoint setSavepoint() throws SQLException; + + /** + * Creates a named Savepoint in the current transaction. + * + * @param name + * the name to use for the new Savepoint. + * @return a Savepoint object for this savepoint. + * @throws SQLException + * if there is a problem accessing the database + */ + public Savepoint setSavepoint(String name) throws SQLException; + + /** + * Sets the transaction isolation level for this Connection. + * <p> + * If this method is called during a transaction, the results are + * implementation defined. + * + * @param level + * the new transaction isolation level to use from the following + * list of possible values : + * <ul> + * <li>{@link #TRANSACTION_READ_COMMITTED} + * <li>{@link #TRANSACTION_READ_UNCOMMITTED} + * <li>{@link #TRANSACTION_REPEATABLE_READ} + * <li>{@link #TRANSACTION_SERIALIZABLE} + * </ul> + * @throws SQLException + * if there is a problem with the database or if the value of + * <code>level</code> is not one of the expected constant + * values. + */ + public void setTransactionIsolation(int level) throws SQLException; + + /** + * Sets the <code>TypeMap</code> for this connection. The input + * <code>map</code> should contain mappings between complex Java and SQL + * types. + * + * @param map + * the new type map + * @throws SQLException + * if there is a problem accessing the database or if + * <code>map</code> is not an instance of {@link Map}. + */ + public void setTypeMap(Map<String, Class<?>> map) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/DataTruncation.java b/sql/src/main/java/java/sql/DataTruncation.java new file mode 100644 index 0000000..7150ec7 --- /dev/null +++ b/sql/src/main/java/java/sql/DataTruncation.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.Serializable; + +/** + * An exception which is thrown when a JDBC driver unexpectedly truncates a data + * value either when reading or when writing data. + * + * The SQLState value for a <code>DataTruncation</code> is <code>01004</code>. + */ +public class DataTruncation extends SQLWarning implements Serializable { + + private static final long serialVersionUID = 6464298989504059473L; + + private int index = 0; + + private boolean parameter = false; + + private boolean read = false; + + private int dataSize = 0; + + private int transferSize = 0; + + private static final String THE_REASON = "Data truncation"; //$NON-NLS-1$ + + private static final String THE_SQLSTATE = "01004"; //$NON-NLS-1$ + + private static final int THE_ERROR_CODE = 0; + + /** + * Creates a DataTruncation. The Reason is set to "Data truncation", the + * ErrorCode is set to the SQLException default value and other fields are + * set to the values supplied on this method. + * + * @param index + * the Index value of the column value or parameter that was + * truncated + * @param parameter + * true if it was a Parameter value that was truncated, false + * otherwise + * @param read + * true if the truncation occurred on a read operation, false + * otherwise + * @param dataSize + * the original size of the truncated data + * @param transferSize + * the size of the data after truncation + */ + public DataTruncation(int index, boolean parameter, boolean read, + int dataSize, int transferSize) { + super(THE_REASON, THE_SQLSTATE, THE_ERROR_CODE); + this.index = index; + this.parameter = parameter; + this.read = read; + this.dataSize = dataSize; + this.transferSize = transferSize; + } + + /** + * Gets the number of bytes of data that should have been read/written. + * + * @return the number of bytes that should have been read or written. The + * value may be set to -1 if the size is unknown. + */ + public int getDataSize() { + return dataSize; + } + + /** + * Gets the index of the column or of the parameter that was truncated. + * + * @return the index number of the column or of the parameter. + */ + public int getIndex() { + return index; + } + + /** + * Gets whether the value truncated was a parameter value or a column value. + * + * @return true if the value truncated was a Parameter value, false if it + * was a column value + */ + public boolean getParameter() { + return parameter; + } + + /** + * Gets whether the value was truncated on a read operation or a write + * operation + * + * @return true if the value was truncated on a read operation, false + * otherwise. + */ + public boolean getRead() { + return read; + } + + /** + * Gets the number of bytes of data that was actually read or written + * + * @return the number of bytes actually read/written. The value may be set + * to -1 if the size is unknown. + */ + public int getTransferSize() { + return transferSize; + } +} diff --git a/sql/src/main/java/java/sql/DatabaseMetaData.java b/sql/src/main/java/java/sql/DatabaseMetaData.java new file mode 100644 index 0000000..8c0f17c --- /dev/null +++ b/sql/src/main/java/java/sql/DatabaseMetaData.java @@ -0,0 +1,3081 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * An interface which provides comprehensive information about the database. + * <p> + * This interface is implemented by JDBC driver writers in order to provide + * information about the underlying Database capabilities and the JDBC driver + * capabilities taken together. + * <p> + * Some of the methods in this interface take String parameters which are + * Patterns. Within these string Patterns, '%' and '_' characters have special + * meanings. '%' means "match any substring of 0 or more characters". '_' means + * "match any one character". Only metadata entries that match the pattern are + * returned. If such a search pattern string is set to <code>null</code>, + * that argument's criteria are dropped from the search. + * + */ +public interface DatabaseMetaData { + + /** + * States that it may not be permitted to store <code>NULL</code> values. + */ + public static final short attributeNoNulls = 0; + + /** + * States that <code>NULL</code> values are definitely permitted. + */ + public static final short attributeNullable = 1; + + /** + * States that whether <code>NULL</code> values are permitted is unknown. + */ + public static final short attributeNullableUnknown = 2; + + /** + * States the best row identifier is <em>NOT</em> a pseudo column. + */ + public static final int bestRowNotPseudo = 1; + + /** + * States that the best row identifier is a pseudo column. + */ + public static final int bestRowPseudo = 2; + + /** + * States that the remainder of the current session is used as the scope for + * the best row identifier. + */ + public static final int bestRowSession = 2; + + /** + * States that best row identifier scope lasts only while the row is being + * used. + */ + public static final int bestRowTemporary = 0; + + /** + * States that the remainder of the current transaction is used as the scope + * for the best row identifier. + */ + public static final int bestRowTransaction = 1; + + /** + * States that the best row identifier may or may not be a pseudo column. + */ + public static final int bestRowUnknown = 0; + + /** + * States that the column might not allow <code>NULL</code> values. + */ + public static final int columnNoNulls = 0; + + /** + * States that the column definitely allows <code>NULL</code> values. + */ + public static final int columnNullable = 1; + + /** + * States that it is unknown whether the columns may be nulled. + */ + public static final int columnNullableUnknown = 2; + + /** + * For the column UPDATE_RULE, States that when the primary key is updated, + * the foreign key (imported key) is changed to agree with it. + */ + public static final int importedKeyCascade = 0; + + /** + * States deferrability. + */ + public static final int importedKeyInitiallyDeferred = 5; + + /** + * States defer-ability. + */ + public static final int importedKeyInitiallyImmediate = 6; + + /** + * For the columns UPDATE_RULE and DELETE_RULE, States that if the primary + * key has been imported, it cannot be updated or deleted. + */ + public static final int importedKeyNoAction = 3; + + /** + * States defer-ability. + */ + public static final int importedKeyNotDeferrable = 7; + + /** + * States that a primary key must not be updated when imported as a foreign + * key by some other table. Used for the column UPDATE_RULE. + */ + public static final int importedKeyRestrict = 1; + + /** + * States that when the primary key is modified (updated or deleted) the + * foreign (imported) key is changed to its default value. Applies to the + * UPDATE_RULE and DELETE_RULE columns. + */ + public static final int importedKeySetDefault = 4; + + /** + * States that when the primary key is modified (updated or deleted) the + * foreign (imported) key is changed to <code>NULL</code>. Applies to the + * UPDATE_RULE and DELETE_RULE columns. + */ + public static final int importedKeySetNull = 2; + + /** + * States that this column stores IN type parameters. + */ + public static final int procedureColumnIn = 1; + + /** + * States that this column stores INOUT type parameters. + */ + public static final int procedureColumnInOut = 2; + + /** + * States that this column stores OUT type parameters. + */ + public static final int procedureColumnOut = 4; + + /** + * States that the column stores results + */ + public static final int procedureColumnResult = 3; + + /** + * States that the column stores return values. + */ + public static final int procedureColumnReturn = 5; + + /** + * States that type of the column is unknown. + */ + public static final int procedureColumnUnknown = 0; + + /** + * States that <code>NULL</code> values are not permitted. + */ + public static final int procedureNoNulls = 0; + + /** + * States that the procedure does not return a result. + */ + public static final int procedureNoResult = 1; + + /** + * States that <code>NULL</code> values are permitted. + */ + public static final int procedureNullable = 1; + + /** + * States that whether <code>NULL</code> values are permitted is unknown. + */ + public static final int procedureNullableUnknown = 2; + + /** + * States that it is unknown whether or not the procedure returns a result. + */ + public static final int procedureResultUnknown = 0; + + /** + * States that the procedure returns a result. + */ + public static final int procedureReturnsResult = 2; + + /** + * States that the value is an SQL99 SQLSTATE value. + */ + public static final int sqlStateSQL99 = 2; + + /** + * States that the value is an SQL CLI SQLSTATE value as defined by X/Open + * (who are now know as Open Group) . + */ + public static final int sqlStateXOpen = 1; + + /** + * States that this table index is a clustered index. + */ + public static final short tableIndexClustered = 1; + + /** + * States that this table index is a hashed index. + */ + public static final short tableIndexHashed = 2; + + /** + * States this table's index is neither a clustered index, not a hashed + * index, and not a table statistics index; i.e. it is something else. + */ + public static final short tableIndexOther = 3; + + /** + * States this column has the table's statistics, and that it is returned in + * conjunction with the table's index description. + */ + public static final short tableIndexStatistic = 0; + + /** + * States that a <code>NULL</code> value is <em>NOT</em> permitted for + * this data type. + */ + public static final int typeNoNulls = 0; + + /** + * States that a <code>NULL</code> value is permitted for this data type. + */ + public static final int typeNullable = 1; + + /** + * States that it is unknown if a <code>NULL</code> value is permitted for + * this data type. + */ + public static final int typeNullableUnknown = 2; + + /** + * States that one can base all WHERE search clauses except WHERE . + */ + public static final int typePredBasic = 2; + + /** + * States that <code>WHERE</code> is the only WHERE search clause that may + * be based on this type. + */ + public static final int typePredChar = 1; + + /** + * States that this type does not support <code>WHERE</code> search + * clauses. + */ + public static final int typePredNone = 0; + + /** + * States that all WHERE search clauses may be based on this type. + */ + public static final int typeSearchable = 3; + + /** + * States that the version column is known to be not a pseudo column. + */ + public static final int versionColumnNotPseudo = 1; + + /** + * States that this version column is known to be a pseudo column. + */ + public static final int versionColumnPseudo = 2; + + /** + * States that the version column may be a pseudo column or not. + */ + public static final int versionColumnUnknown = 0; + + /** + * Returns whether all procedures returned by <code>getProcedures</code> + * can be called by the current user. + * + * @return <code>true</code> if all procedures can be called by the + * current user, <code>false</code> otherwise. + * @throws SQLException + * if there is a database error + */ + public boolean allProceduresAreCallable() throws SQLException; + + /** + * Returns whether all the tables returned by <code>getTables</code> can + * be used by the current user in a SELECT statement. + * + * @return <code>true</code> if all the tables can be used,<code>false</code> + * otherwise + * @throws SQLException + * if there is a database error + */ + public boolean allTablesAreSelectable() throws SQLException; + + /** + * Returns if a data definition statement in a transaction forces a commit + * of the transaction. + * + * @return <code>true</code> if the statement forces a commit, + * <code>false</code> otherwise + * @throws SQLException + * if there is a database error + */ + public boolean dataDefinitionCausesTransactionCommit() throws SQLException; + + /** + * Returns whether the database ignores data definition statements within a + * transaction. + * + * @return <code>true</code> if the database ignores a data definition + * statement, <code>false</code> otherwise + * @throws SQLException + * if there is a database error + */ + public boolean dataDefinitionIgnoredInTransactions() throws SQLException; + + /** + * Returns whether a visible row delete can be detected by calling + * <code>ResultSet.rowDeleted</code>. + * + * @param type + * the type of the ResultSet involved: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if the visible row delete can be detected, + * <code>false</code> otherwise + * @throws SQLException + * if there is a database error + */ + public boolean deletesAreDetected(int type) throws SQLException; + + /** + * Returns whether the return value of <code>getMaxRowSize</code> includes + * the SQL data types <code>LONGVARCHAR</code> and + * <code>LONGVARBINARY</code>. + * + * @return <code>true</code> if the return value includes + * <code>LONGVARBINARY</code> and <code>LONGVARCHAR</code>, + * otherwise <code>false</code>. + * @throws SQLException + * if there is a database error + */ + public boolean doesMaxRowSizeIncludeBlobs() throws SQLException; + + /** + * Returns a description of the specified attribute of the specified type + * for an SQL User Defined Type (UDT) for a specified schema and catalog. + * The descriptions returned are ordered by <code>TYPE_SCHEM</code>, + * <code>TYPE_NAME</code> and ORDINAL_POSITION. The descriptions do not + * contain inherited attributes. + * <p> + * The returned ResultSet object has rows with the following column names + * and meanings: + * <ol> + * <li><code>TYPE_CAT</code> - String - the Type Catalog name (possibly + * <code>null</code>)</li> + * <li><code>TYPE_SCHEM</code> - String - the Type Schema name (possibly + * <code>null</code>)</li> + * <li><code>TYPE_NAME</code> - String - the Type name</li> + * <li><code>ATTR_NAME</code> - String - the Attribute name</li> + * <li><code>DATA_TYPE</code> - int - the Attribute type as defined in + * <code>java.sql.Types</code></li> + * <li><code>ATTR_TYPE_NAME</code> - String - the Attribute type name. + * This depends on the data source. For a <code>UDT</code> the name is + * fully qualified. For a <code>REF</code> it is both fully qualified and + * represents the target type of the reference.</li> + * <li><code>ATTR_SIZE</code> - int - the Column size. When referring to + * char and date types this value is the maximum number of characters. When + * referring to numeric types is is the precision.</li> + * <li><code>DECIMAL_DIGITS</code> - int - how many fractional digits are + * supported</li> + * <li><code>NUM_PREC_RADIX</code> - int - numeric values radix</li> + * <li><code>NULLABLE</code> - int - whether <code>NULL</code> is + * permitted: + * <ul> + * <li>DatabaseMetaData.attributeNoNulls - might not allow + * <code>NULL</code>s</li> + * <li>DatabaseMetaData.attributeNullable - <code>NULL</code>s + * definitely permitted</li> + * <li>DatabaseMetaData.attributeNullableUnknown - unknown</li> + * </ul> + * </li> + * <li><code>REMARKS</code> - String - A comment describing the attribute + * (possibly <code>null</code>)</li> + * <li>ATTR_DEF - String - Default value for the attribute (possibly + * <code>null</code>)</li> + * <li><code>SQL_DATA_TYPE</code> - int - not used</li> + * <li>SQL_DATETIME_SUB - int - not used</li> + * <li>CHAR_OCTET_LENGTH - int - For <code>CHAR</code> types, the max + * number of bytes in the column</li> + * <li>ORDINAL_POSITION - int - The Index of the column in the Table (based + * on 1)</li> + * <li>IS_NULLABLE - String - "NO" = column does not allow + * <code>NULL</code>s, "YES" = column allows <code>NULL</code>s "" = + * <code>NULL</code> status unknown</li> + * <li><code>SCOPE_CATALOG</code> - String - Catalog for table, + * <code>SCOPE</code> of Reference attribute. NULL if + * <code>DATA_TYPE</code> is not REF.</li> + * <li><code>SCOPE_SCHEMA</code> - String - Schema for table, + * <code>SCOPE</code> of Reference attribute. NULL if + * <code>DATA_TYPE</code> is not REF.</li> + * <li><code>SCOPE_TABLE</code> - String - Table name for + * <code>SCOPE</code> of Reference attribute. <code>NULL</code> if + * <code>DATA_TYPE</code> is not REF.</li> + * <li><code>SOURCE_DATA_TYPE</code> - String - The source type for user + * generated REF type or for a Distinct type. (<code>NULL</code> if + * <code>DATA_TYPE</code> is not DISTINCT or user generated REF)</li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param typeNamePattern + * a Type name. This pattern must match the type name stored in + * the database. + * @param attributeNamePattern + * an Attribute name. Must match the attribute name as stored in + * the database. + * @return a ResultSet, where each Row is an attribute description + * @throws SQLException + * if there is a database error + */ + public ResultSet getAttributes(String catalog, String schemaPattern, + String typeNamePattern, String attributeNamePattern) + throws SQLException; + + /** + * Returns a list of a table's optimal set of columns that uniquely + * identifies a row. The results are ordered by <code>SCOPE</code> (see + * below). + * <p> + * The results are returned as a table, with one entry for each column, as + * follows: + * <ol> + * <li><code>SCOPE</code> - short - the <code>SCOPE</code> of the + * result, as follows: + * <ul> + * <li>DatabaseMetaData.bestRowTemporary - very temporary, while using row + * </li> + * <li>DatabaseMetaData.bestRowTransaction - good for remainder of current + * transaction </li> + * <li>DatabaseMetaData.bestRowSession - good for remainder of database + * session </li> + * </ul> + * </li> + * <li><code>COLUMN_NAME</code> - String - the column name </li> + * <li><code>DATA_TYPE</code> - int - the Type of the data, as defined in + * <code>java.sql.Types</code> </li> + * <li><code>TYPE_NAME</code> - String - Name of the type - database + * dependent. For UDT types the name is fully qualified </li> + * <li><code>COLUMN_SIZE</code> - int - The precision of the data in the + * column </li> + * <li><code>BUFFER_LENGTH</code> - int - not used </li> + * <li><code>DECIMAL_DIGITS</code> - short - number of fractional digits + * </li> + * <li><code>PSEUDO_COLUMN</code> - short - whether this is a pseudo + * column eg. and Oracle ROWID: + * <ul> + * <li>DatabaseMetaData.bestRowUnknown - don't know whether this is a + * pseudo column</li> + * <li>DatabaseMetaData.bestRowNotPseudo - column is not pseudo</li> + * <li>DatabaseMetaData.bestRowPseudo - column is a pseudo column</li> + * </ul> + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param table + * the table name. This must match the name of the table as + * declared in the database. + * @param scope + * the <code>SCOPE</code> of interest, values as defined above + * @param nullable + * <code>true</code> = include columns that are nullable, + * <code>false</code> = do not include + * @return a ResultSet where each row is a description of a column and the + * complete set of rows is the optimal set for this table. + * @throws SQLException + * if there is a database error + */ + public ResultSet getBestRowIdentifier(String catalog, String schema, + String table, int scope, boolean nullable) throws SQLException; + + /** + * Returns the set of catalog names available in this database. The set is + * returned ordered by catalog name. + * + * @return a ResultSet containing the Catalog names, with each row + * containing one Catalog name contained as a String in the single + * column named <code>TABLE_CAT</code>. + * @throws SQLException + * if there is a database error + */ + public ResultSet getCatalogs() throws SQLException; + + /** + * Returns the separator that this database uses between a catalog name and + * table name. + * + * @return a String containing the separator + * @throws SQLException + * if there is a database error + */ + public String getCatalogSeparator() throws SQLException; + + /** + * Returns the term that the database vendor prefers term for "catalog". + * + * @return a String with the vendor's term for "catalog" + * @throws SQLException + * if there is a database error + */ + public String getCatalogTerm() throws SQLException; + + /** + * Returns a description of access rights for a table's columns. Only access + * rights matching the criteria for the column name are returned. + * <p> + * The description is returned as a ResultSet with rows of data for each + * access right, with columns as follows: + * <ol> + * <li><code>TABLE_CAT</code> - String - Catalog name (possibly + * <code>null</code>)</li> + * <li><code>TABLE_SCHEM</code> - String - Schema name (possibly + * <code>null</code>) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>COLUMN_NAME</code> - String - The Column name</li> + * <li><code>GRANTOR</code> - String - The grantor of access (possibly + * <code>null</code>)</li> + * <li><code>PRIVILEGE</code> - String - Access right - one of SELECT, + * INSERT, UPDATE, REFERENCES,...</li> + * <li><code>IS_GRANTABLE</code> - String - "YES" implies that the + * receiver can grant access to others, "NO" if the receiver cannot grant + * access to others, <code>null</code> if unknown.</li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param table + * the table name. This must match the name of the table as + * declared in the database. + * @param columnNamePattern + * the column name. This must match the name of a column in the + * table in the database. + * @return a ResultSet containing the access rights, one row for each + * privilege description + * @throws SQLException + * if there is a database error + */ + public ResultSet getColumnPrivileges(String catalog, String schema, + String table, String columnNamePattern) throws SQLException; + + /** + * Returns a description of table columns available in a specified catalog. + * Only descriptions meeting the specified Catalog, Schema, Table and Column + * names are returned. + * <p> + * The descriptions are returned as a ResultSet conforming to the following + * data layout, with one row per table column: + * <ol> + * <li><code>TABLE_CAT</code> - String - Catalog name (possibly + * <code>null</code>)</li> + * <li><code>TABLE_SCHEM</code> - String - Schema name (possibly + * <code>null</code>) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>COLUMN_NAME</code> - String - The Column name</li> + * <li><code>DATA_TYPE</code> - int - The SQL type as specified in + * <code>java.sql.Types</code></li> + * <li><code>TYPE_NAME</code> - String - Name for the data type, depends + * on database, UDT names are fully qualified</li> + * <li><code>COLUMN_SIZE</code> - int - Column size - the precision for + * numeric types, max characters for char and date types</li> + * <li><code>BUFFER_LENGTH</code> - int - Not used </li> + * <li><code>DECIMAL_DIGITS</code> - int - maximum number of fractional + * digits </li> + * <li><code>NUM_PREC_RADIX</code> - int - the Radix </li> + * <li><code>NULLABLE</code> - int - does the column allow + * <code>null</code>s: + * <ul> + * <li>DatabaseMetaData.columnNoNulls = may not allow <code>NULL</code>s</li> + * <li>DatabaseMetaData.columnNullable = does allow <code>NULL</code>s</li> + * <li>DatabaseMetaData.columnNullableUnknown = unknown <code>NULL</code> + * status</li> + * </ul> + * </li> + * <li><code>REMARKS</code> - String - A description of the column + * (possibly <code>null</code>) </li> + * <li><code>COLUMN_DEF</code> - String - Default value for the column + * (possibly <code>null</code>)</li> + * <li><code>SQL_DATA_TYPE</code> - int - not used </li> + * <li><code>SQL_DATETIME_SUB</code> - int - not used </li> + * <li><code>CHAR_OCTET_LENGTH</code> - int - maximum number of bytes in + * the char type columns </li> + * <li><code>ORDINAL_POSITION</code> - int - Column index in the table (1 + * based) </li> + * <li><code>IS_NULLABLE</code> - String - "NO" = column does not allow + * NULLs, "YES" = column allows NULLs "" = <code>NULL</code> status + * unknown</li> + * <li><code>SCOPE</code>_CATALOG - String - Catalog for table, + * <code>SCOPE</code> of Reference attribute. NULL if + * <code>DATA_TYPE</code> is not REF.</li> + * <li><code>SCOPE_SCHEMA</code> - String - Schema for table, scope of + * Reference attribute. <code>NULL</code> if <code>DATA_TYPE</code> is + * not REF.</li> + * <li><code>SCOPE_TABLE</code> - String - Table name for scope of + * Reference attribute. <code>NULL</code> if <code>DATA_TYPE</code> is + * not REF.</li> + * <li><code>SOURCE_DATA_TYPE</code> - String - The source type for user + * generated REF type or for a Distinct type. (<code>NULL</code> if + * <code>DATA_TYPE</code> is not DISTINCT or user generated REF)</li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param tableNamePattern + * the table name. This must match the name of the table as + * declared in the database. + * @param columnNamePattern + * the column name. This must match the name of a column in the + * table in the database. + * @return the descriptions as a ResultSet with rows in the form defined + * above + * @throws SQLException + * if there is a database error + */ + public ResultSet getColumns(String catalog, String schemaPattern, + String tableNamePattern, String columnNamePattern) + throws SQLException; + + /** + * Returns the database connection that created this metadata. + * + * @return the connection + * @throws SQLException + * if there is a database error + */ + public Connection getConnection() throws SQLException; + + /** + * Returns a list of foreign key columns in a given foreign key table that + * reference the primary key columns of a supplied primary key table. This + * describes how one table imports the key of another table. It would be + * expected to return a single foreign key - primary key pair in most cases. + * <p> + * The descriptions are returned as a ResultSet with one row for each + * Foreign key, with the following layout: + * <ol> + * <li><code>PKTABLE_CAT</code> - String - from the primary key table : + * Catalog (possibly <code>null</code>)</li> + * <li><code>PKTABLE_SCHEM</code> - String - from the primary key table : + * Schema (possibly <code>null</code>) </li> + * <li><code>PKTABLE_NAME</code> - String - primary key table : name + * </li> + * <li><code>PKCOLUMN_NAME</code> - String - primary key column : name</li> + * <li><code>FKTABLE_CAT</code> - String - from the foreign key table : + * the catalog name being exported (possibly <code>null</code>)</li> + * <li><code>FKTABLE_SCHEM</code> - String - foreign key table : Schema + * name being exported (possibly <code>null</code>) </li> + * <li><code>FKTABLE_NAME</code> - String - foreign key table : the name + * being exported</li> + * <li><code>FKCOLUMN_NAME</code> - String - foreign key column : the + * name being exported</li> + * <li><code>KEY_SEQ</code> - short - sequence number (in the foreign + * key)</li> + * <li><code>UPDATE_RULE</code> - short - how to treat foreign key when + * primary key is updated: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - change imported key to match + * the primary key update</li> + * <li>DatabaseMetaData.importedKeySetNull - set the imported key to + * <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to + * default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li><code>DELETE_RULE</code> - short - how to treat foreign key when + * primary key is deleted: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - delete those rows that import + * a deleted key</li> + * <li>DatabaseMetaData.importedKeySetNull - set the imported key to + * <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to + * default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li> + * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li> + * <li>DEFERRABILITY - short - can foreign key constraints be deferred + * until commit (see SQL92 specification for definitions)?: + * <ul> + * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li> + * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li> + * <li>DatabaseMetaData.importedKeyNotDeferrable</li> + * </ul> + * </li> + * </ol> + * + * @param primaryCatalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param primarySchema + * a Schema Name. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param primaryTable + * the name of the table which exports the key. It must match the + * name of the table in the database + * @param foreignCatalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param foreignSchema + * a Schema Name. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param foreignTable + * the name of the table importing the key. It must match the + * name of the table in the database + * @return a ResultSet containing rows with the descriptions of the foreign + * keys laid out according to the format defined above. + * @throws SQLException + * if there is a database error + */ + public ResultSet getCrossReference(String primaryCatalog, + String primarySchema, String primaryTable, String foreignCatalog, + String foreignSchema, String foreignTable) throws SQLException; + + /** + * Returns the major version number of the database software. + * + * @return the Major version number of the database software. + * @throws SQLException + * a database error occurred + */ + public int getDatabaseMajorVersion() throws SQLException; + + /** + * Returns the minor version number of the database software. + * + * @return the Minor version number of the database software. + * @throws SQLException + * a database error occurred + */ + public int getDatabaseMinorVersion() throws SQLException; + + /** + * Returns the name of the database software. + * + * @return a String with the name of the database software. + * @throws SQLException + * a database error occurred + */ + public String getDatabaseProductName() throws SQLException; + + /** + * Returns the version number of this database software. + * + * @return a String with the version number of the database software. + * @throws SQLException + * a database error occurred + */ + public String getDatabaseProductVersion() throws SQLException; + + /** + * Returns the default transaction isolation level for this database. + * + * @return the default transaction isolation level. One of + * <code>TRANSACTION_NONE</code>, + * <code>TRANSACTION_READ_COMMITTED</code>, + * <code>TRANSACTION_READ_UNCOMMITTED</code>, + * <code>TRANSACTION_REPEATABLE_READ</code> or + * <code>TRANSACTION_SERIALIZABLE</code>. + * @throws SQLException + * a database error occurred + */ + public int getDefaultTransactionIsolation() throws SQLException; + + /** + * Returns the JDBC driver's major version number. + * + * @return the driver's major version number + */ + public int getDriverMajorVersion(); + + /** + * Returns the JDBC driver's minor version number. + * + * @return the driver's minor version number + */ + public int getDriverMinorVersion(); + + /** + * Returns the name of this JDBC driver. + * + * @return a String containing the name of the JDBC driver + * @throws SQLException + * a database error occurred + */ + public String getDriverName() throws SQLException; + + /** + * Returns the version number of this JDBC driver. + * + * @return a String containing the complete version number of the JDBC + * driver + * @throws SQLException + * a database error occurred + */ + public String getDriverVersion() throws SQLException; + + /** + * Returns a list of the foreign key columns that reference the primary key + * columns of a specified table (the foreign keys exported by a table). + * <p> + * The list is returned as a ResultSet with a row for each of the foreign + * key columns, ordered by <code>FKTABLE_CAT</code>, + * <code>FKTABLE_SCHEM</code>, <code>FKTABLE_NAME</code>, and + * <code>KEY_SEQ</code>, with the format for each row being: + * <ol> + * <li><code>PKTABLE_CAT</code> - String - primary key table : Catalog + * (possibly <code>null</code>)</li> + * <li><code>PKTABLE_SCHEM</code> - String - primary key table : Schema + * (possibly <code>null</code>) </li> + * <li><code>PKTABLE_NAME</code> - String - primary key table : name + * </li> + * <li><code>PKCOLUMN_NAME</code> - String - primary key column : name</li> + * <li><code>FKTABLE_CAT</code> - String - foreign key table : Catalog + * name being exported (possibly <code>null</code>)</li> + * <li><code>FKTABLE_SCHEM</code> - String - foreign key table : Schema + * name being exported (possibly <code>null</code>) </li> + * <li><code>FKTABLE_NAME</code> - String - foreign key table : name + * being exported</li> + * <li><code>FKCOLUMN_NAME</code> - String - foreign key column : name + * being exported</li> + * <li>KEY_SEQ - short - sequence number in the foreign key</li> + * <li>UPDATE_RULE - short - how to treat foreign key when primary key is + * updated: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - change imported key to match + * the primary key update</li> + * <li>DatabaseMetaData.importedKeySetNull - set the imported key to + * <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to + * default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li>DELETE_RULE - short - how to treat foreign key when primary key is + * deleted: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - the deletion should also + * delete rows that import a deleted key</li> + * <li>DatabaseMetaData.importedKeySetNull - it should set the imported key + * to <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - deletion sets the imported + * key to default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li> + * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li> + * <li>DEFERRABILITY - short - defines whether foreign key constraints can + * be deferred until commit (see SQL92 specification for definitions): + * <ul> + * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li> + * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li> + * <li>DatabaseMetaData.importedKeyNotDeferrable</li> + * </ul> + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param table + * a table name, which must match the name of a table in the + * database + * @return a ResultSet containing a row for each of the foreign key columns, + * as defined above + * @throws SQLException + * a database error occurred + */ + public ResultSet getExportedKeys(String catalog, String schema, String table) + throws SQLException; + + /** + * Returns a string of characters that may be used in unquoted identifier + * names. The characters a-z, A-Z, 0-9 and _ are always permitted. + * + * @return a String containing all the extra characters + * @throws SQLException + * a database error occurred + */ + public String getExtraNameCharacters() throws SQLException; + + /** + * Returns the string used to quote SQL identifiers. Returns " " (space) if + * identifier quoting not supported. + * + * @return the String used to quote SQL identifiers. + * @throws SQLException + * a database error occurred + */ + public String getIdentifierQuoteString() throws SQLException; + + /** + * Returns a list columns in a table that are both primary keys and + * referenced by the table's foreign key columns (that is, the primary keys + * imported by a table). + * <p> + * The list returned is a <code>ResultSet</code> with a row entry for each + * primary key column, ordered by <code>PKTABLE_CAT</code>, + * <code>PKTABLE_SCHEM</code>, <code>PKTABLE_NAME</code>, and + * <code>KEY_SEQ</code>, with the following format: + * <ol> + * <li><code>PKTABLE_CAT</code> - String - primary key Catalog name being + * imported (possibly <code>null</code>)</li> + * <li><code>PKTABLE_SCHEM</code> - String - primary key Schema name + * being imported (possibly <code>null</code>) </li> + * <li><code>PKTABLE_NAME</code> - String - primary key Table name being + * imported </li> + * <li><code>PKCOLUMN_NAME</code> - String - primary key column name + * being imported</li> + * <li><code>FKTABLE_CAT</code> - String - foreign key table catalog name + * (possibly <code>null</code>)</li> + * <li><code>FKTABLE_SCHEM</code> - String - foreign key table Schema + * name (possibly <code>null</code>) </li> + * <li><code>FKTABLE_NAME</code> - String - foreign key table name</li> + * <li><code>FKCOLUMN_NAME</code> - String - foreign key column name</li> + * <li>KEY_SEQ - short - sequence number in the foreign key</li> + * <li>UPDATE_RULE - short - how to treat foreign key when primary key is + * updated: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - change imported key to match + * the primary key update</li> + * <li>DatabaseMetaData.importedKeySetNull - set the imported key to + * <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to + * default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li>DELETE_RULE - short - how to treat foreign key when primary key is + * deleted: + * <ul> + * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary + * key if imported</li> + * <li>DatabaseMetaData.importedKeyCascade - delete those rows that import + * a deleted key</li> + * <li>DatabaseMetaData.importedKeySetNull - set the imported key to + * <code>null</code></li> + * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to + * default values</li> + * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li> + * </ul> + * </li> + * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li> + * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li> + * <li>DEFERRABILITY - short - defines whether foreign key constraints can + * be deferred until commit (see SQL92 specification for definitions): + * <ul> + * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li> + * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li> + * <li>DatabaseMetaData.importedKeyNotDeferrable</li> + * </ul> + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param table + * a table name, which must match the name of a table in the + * database + * @return a ResultSet containing the list of primary key columns as rows in + * the format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getImportedKeys(String catalog, String schema, String table) + throws SQLException; + + /** + * Returns a list of indices and statistics for a specified table. + * <p> + * The list is returned as a ResultSet, with one row for each index or + * statistic. The list is ordered by NON_UNIQUE, TYPE, INDEX_NAME, and + * ORDINAL_POSITION. Each row has the following format: + * <ol> + * <li><code>TABLE_CAT</code> - String - table catalog name (possibly + * <code>null</code>)</li> + * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly + * <code>null</code>) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>NON_UNIQUE</code> - boolean - <code>true</code> when index + * values can be non-unique. Must be <code>false</code> when TYPE is + * tableIndexStatistic</li> + * <li><code>INDEX_QUALIFIER</code> - String : index catalog name. + * <code>null</code> when TYPE is 'tableIndexStatistic'</li> + * <li><code>INDEX_NAME</code> - String : index name. <code>null</code> + * when TYPE is 'tableIndexStatistic'</li> + * <li>TYPE - short - the index type. One of: + * <ul> + * <li>DatabaseMetaData.tableIndexStatistic - table statistics returned + * with Index descriptions</li> + * <li>DatabaseMetaData.tableIndexClustered - a clustered Index</li> + * <li>DatabaseMetaData.tableIndexHashed - a hashed Index</li> + * <li>DatabaseMetaData.tableIndexOther - other style of Index</li> + * </ul> + * </li> + * <li>ORDINAL_POSITION - short - column sequence within Index. 0 when TYPE + * is tableIndexStatistic </li> + * <li><code>COLUMN_NAME</code> - String - the column name. + * <code>null</code> when TYPE is tableIndexStatistic</li> + * <li>ASC_OR_DESC - String - column sort sequence. <code>null</code> if + * sequencing not supported or TYPE is tableIndexStatistic; otherwise "A" + * means sort ascending and "D" means sort descending. </li> + * <li>CARDINALITY - int - Number of unique values in the Index. If TYPE is + * tableIndexStatistic, this is number of rows in the table.</li> + * <li>PAGES - int - Number of pages for current Index. If TYPE is + * tableIndexStatistic, this is number of pages used for the table.</li> + * <li>FILTER_CONDITION - String - Filter condition. (possibly null) </li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schema + * a Schema Name. null is used to imply no narrowing of the + * search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param table + * a table name, which must match the name of a table in the + * database + * @param unique + * <code>true</code> means only return indices for unique + * values, <code>false</code> implies that they can be returned + * even if not unique. + * @param approximate + * <code>true</code> implies that the list can contain + * approximate or "out of data" values, <code>false</code> + * implies that all values must be precisely accurate + * @return a ResultSet containing the list of indices and statistics for the + * table, in the format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getIndexInfo(String catalog, String schema, String table, + boolean unique, boolean approximate) throws SQLException; + + /** + * Returns this driver's major JDBC version number. + * + * @return the major JDBC version number + * @throws SQLException + * a database error occurred + */ + public int getJDBCMajorVersion() throws SQLException; + + /** + * Returns the minor JDBC version number for this driver. + * + * @return the Minor JDBC Version Number + * @throws SQLException + * a database error occurred + */ + public int getJDBCMinorVersion() throws SQLException; + + /** + * Get the maximum number of hex characters in an in-line binary literal for + * this database. + * + * @return the maximum number of hex characters in an in-line binary + * literal. If the number is unlimited then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxBinaryLiteralLength() throws SQLException; + + /** + * Returns the maximum size of a Catalog name in this database. + * + * @return the maximum size in characters for a Catalog name. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxCatalogNameLength() throws SQLException; + + /** + * Returns the maximum size for a character literal in this database. + * + * @return the maximum size in characters for a character literal. If the + * limit is unknown, or the value is unlimited, then the result is + * zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxCharLiteralLength() throws SQLException; + + /** + * Returns the maximum size for a Column name for this database. + * + * @return the maximum number of characters for a Column name. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnNameLength() throws SQLException; + + /** + * Get the maximum number of columns in a GROUP BY clause for this database. + * + * @return the maximum number of columns in a GROUP BY clause. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnsInGroupBy() throws SQLException; + + /** + * Returns the maximum number of columns in an Index for this database. + * + * @return the maximum number of columns in an Index. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnsInIndex() throws SQLException; + + /** + * Returns the maximum number of columns in an ORDER BY clause for this + * database. + * + * @return the maximum number of columns in an ORDER BY clause. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnsInOrderBy() throws SQLException; + + /** + * Returns the maximum number of columns in a SELECT list for this database. + * + * @return the maximum number of columns in a SELECT list. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnsInSelect() throws SQLException; + + /** + * Returns the maximum number of columns in a table for this database. + * + * @return the maximum number of columns in a table. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxColumnsInTable() throws SQLException; + + /** + * Returns the database's maximum number of concurrent connections. + * + * @return the maximum number of connections. If the limit is unknown, or + * the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxConnections() throws SQLException; + + /** + * Returns the maximum length of a cursor name for this database. + * + * @return the maximum number of characters in a cursor name. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxCursorNameLength() throws SQLException; + + /** + * Returns the maximum length in bytes for an Index for this database. This + * covers all the parts of a composite index. + * + * @return the maximum length in bytes for an Index. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxIndexLength() throws SQLException; + + /** + * Returns the maximum number of characters for a procedure name in this + * database. + * + * @return the maximum number of character for a procedure name. If the + * limit is unknown, or the value is unlimited, then the result is + * zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxProcedureNameLength() throws SQLException; + + /** + * Returns the maximum number of bytes within a single row for this + * database. + * + * @return the maximum number of bytes for a single row. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxRowSize() throws SQLException; + + /** + * Returns the maximum number of characters in a schema name for this + * database. + * + * @return the maximum number of characters in a Schema name. If the limit + * is unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxSchemaNameLength() throws SQLException; + + /** + * Returns the maximum number of characters in an SQL statement for this + * database. + * + * @return the maximum number of characters in an SQL statement. If the + * limit is unknown, or the value is unlimited, then the result is + * zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxStatementLength() throws SQLException; + + /** + * Get the maximum number of simultaneously open active statements for this + * database. + * + * @return the maximum number of open active statements. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxStatements() throws SQLException; + + /** + * Returns the maximum size for a table name in the database. + * + * @return the maximum size in characters for a table name. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxTableNameLength() throws SQLException; + + /** + * Returns the maximum number of tables permitted in a SELECT statement for + * the database. + * + * @return the maximum number of tables permitted in a SELECT statement. If + * the limit is unknown, or the value is unlimited, then the result + * is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxTablesInSelect() throws SQLException; + + /** + * Returns the maximum number of characters in a user name for the database. + * + * @return the maximum number of characters in a user name. If the limit is + * unknown, or the value is unlimited, then the result is zero. + * @throws SQLException + * a database error occurred + */ + public int getMaxUserNameLength() throws SQLException; + + /** + * Returns a list of the math functions available with this database. These + * are used in the JDBC function escape clause and are the Open Group CLI + * math function names. + * + * @return a String which contains the list of Math functions as a comma + * separated list. + * @throws SQLException + * a database error occurred + */ + public String getNumericFunctions() throws SQLException; + + /** + * Returns a list of the primary key columns of a specified table. + * <p> + * The list is returned as a ResultSet with one row for each primary key + * column, ordered by <code>COLUMN_NAME</code>, with each row having the + * structure as follows: + * <ol> + * <li><code>TABLE_CAT</code> - String - table catalog name (possibly + * null)</li> + * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly + * null) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>COLUMN_NAME</code> - String - The Column name </li> + * <li><code>KEY_SEQ</code> - short - the sequence number for this column + * in the primary key</li> + * <li><code>PK_NAME</code> - String - the primary key name (possibly + * null)</li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with the + * empty string used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with the empty + * string used to retrieve those without a Schema name. + * @param table + * the name of a table, which must match the name of a table in + * the database + * @return a ResultSet containing the list of keys in the format defined + * above + * @throws SQLException + * a database error occurred + */ + public ResultSet getPrimaryKeys(String catalog, String schema, String table) + throws SQLException; + + /** + * Returns a list of parameter and result columns for the stored procedures + * belonging to a specified Catalog. + * <p> + * The list is returned as a ResultSet with one row for each parameter or + * result column. The data is ordered by PROCEDURE_SCHEM and PROCEDURE_NAME, + * while for each procedure, the return value (if any) is first, followed by + * the parameters in the order they appear in the stored procedure call, + * followed by ResultSet columns in column number order. Each row has the + * following structure: + * <ol> + * <li>PROCEDURE_CAT - String - the procedure catalog name</li> + * <li>PROCEDURE_SCHEM - String - the procedure schema name (possibly null) + * </li> + * <li>PROCEDURE_NAME - String - the procedure name</li> + * <li><code>COLUMN_NAME</code> - String - the name of the column</li> + * <li>COLUMN_TYPE - short - the kind of column or parameter, as follows: + * <ul> + * <li>DatabaseMetaData.procedureColumnUnknown - type unknown</li> + * <li>DatabaseMetaData.procedureColumnIn - an IN parameter</li> + * <li>DatabaseMetaData.procedureColumnInOut - an INOUT parameter</li> + * <li>DatabaseMetaData.procedureColumnOut - an OUT parameter</li> + * <li>DatabaseMetaData.procedureColumnReturn - a return value</li> + * <li>DatabaseMetaData.procedureReturnsResult - a result column in a + * result set</li> + * </ul> + * </li> + * <li><code>DATA_TYPE</code> - int - the SQL type of the data, as in + * <code>java.sql.Types</code> </li> + * <li><code>TYPE_NAME</code> - String - the SQL type name, for a UDT it + * is fully qualified</li> + * <li>PRECISION - int - the precision</li> + * <li>LENGTH - int - the length of the data in bytes </li> + * <li>SCALE - short - the scale for numeric types</li> + * <li>RADIX - short - the Radix for numeric data (typically 2 or 10) </li> + * <li>NULLABLE - short - can the data contain null: + * <ul> + * <li>DatabaseMetaData.procedureNoNulls - <code>NULL</code>s not + * permitted</li> + * <li>DatabaseMetaData.procedureNullable - <code>NULL</code>s are + * permitted </li> + * <li>DatabaseMetaData.procedureNullableUnknown - <code>NULL</code> + * status unknown </li> + * </ul> + * </li> + * <li><code>REMARKS</code> - String - an explanatory comment about the + * data item </li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. null is used to imply no narrowing of + * the search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param procedureNamePattern + * a pattern that must match the name of the procedure stored in + * the database + * @param columnNamePattern + * a column name pattern. The name must match the column name + * stored in the database. + * @return a ResultSet with the list of parameter and result columns in the + * format defined above + * @throws SQLException + * a database error occurred + */ + public ResultSet getProcedureColumns(String catalog, String schemaPattern, + String procedureNamePattern, String columnNamePattern) + throws SQLException; + + /** + * Returns a list of the stored procedures available in a specified catalog. + * <p> + * The list is returned as a ResultSet with one row for each stored + * procedure, ordered by PROCEDURE_SCHEME and PROCEDURE_NAME, with the data + * in each row as follows: + * <ol> + * <li><code>PROCEDURE_CAT</code> - String : the procedure catalog name</li> + * <li><code>PROCEDURE_SCHEM</code> - String : the procedure schema name + * (possibly <code>null</code>) </li> + * <li><code>PROCEDURE_NAME</code> - String : the procedure name</li> + * <li><code>Reserved</code></li> + * <li><code>Reserved</code></li> + * <li><code>Reserved</code></li> + * <li><code>REMARKS</code> - String - information about the procedure</li> + * <li><code>PROCEDURE_TYPE</code> - short : one of: + * <ul> + * <li>DatabaseMetaData.procedureResultUnknown - procedure may return a + * result </li> + * <li>DatabaseMetaData.procedureNoResult - procedure does not return a + * result</li> + * <li>DatabaseMetaData.procedureReturnsResult - procedure definitely + * returns a result</li> + * </ul> + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. null is used to imply no narrowing of + * the search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param procedureNamePattern + * a procedure name pattern, which must match the procedure name + * stored in the database + * @return a ResultSet where each row is a description of a stored procedure + * in the format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getProcedures(String catalog, String schemaPattern, + String procedureNamePattern) throws SQLException; + + /** + * Returns the database vendor's preferred name for "procedure". + * + * @return a String with the vendor's preferred name for "procedure" + * @throws SQLException + * a database error occurred + */ + public String getProcedureTerm() throws SQLException; + + /** + * Returns the result set's default hold-ability. + * + * @return one of <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or + * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code> + * @throws SQLException + * a database error occurred + */ + public int getResultSetHoldability() throws SQLException; + + /** + * Returns a list of the schema names in the database. The list is returned + * as a ResultSet, ordered by the Schema name, with one row per Schema in + * the following format: + * <ol> + * <li><code>TABLE_SCHEM</code> - String - the Schema name</li> + * <li><code>TABLE_CAT</code>ALOG - String - the Catalog name (possibly + * null) </li> + * </ol> + * + * @return a ResultSet with one row for each schema in the format defined + * above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getSchemas() throws SQLException; + + /** + * Returns the database vendor's preferred term for "schema". + * + * @return a String which is the vendor's preferred term for schema + * @throws SQLException + * a database error occurred + */ + public String getSchemaTerm() throws SQLException; + + /** + * Returns the string that is used to escape wildcard characters. This + * string is used to escape the '_' and '%' wildcard characters in catalog + * search strings which are a pattern and so which use the wildcard + * characters. '_' is used to represent any single character wile '%' is + * used for a sequence of zero or more characters. + * + * @return a String used to escape the wildcard characters + * @throws SQLException + * a database error occurred + */ + public String getSearchStringEscape() throws SQLException; + + /** + * Returns a list of all the SQL keywords that are NOT also SQL92 keywords + * for the database. + * + * @return a String containing the list of SQL keywords in a comma separated + * format. + * @throws SQLException + * a database error occurred + */ + public String getSQLKeywords() throws SQLException; + + /** + * States the type of SQLState value returned by SQLException.getSQLState. + * This can either be the X/Open (now known as Open Group) SQL CLI form or + * the SQL99 form. + * + * @return an integer, which is either DatabaseMetaData.sqlStateSQL99 or + * DatabaseMetaData.sqlStateXOpen. + * @throws SQLException + * a database error occurred + */ + public int getSQLStateType() throws SQLException; + + /** + * Returns a list of string functions available with the database. These + * functions are used in JDBC function escape clause and follow the Open + * Group CLI string function names definition. + * + * @return a String containing the list of string functions in comma + * separated format. + * @throws SQLException + * a database error occurred + */ + public String getStringFunctions() throws SQLException; + + /** + * Returns a listing of the hierarchies of tables in a specified schema in + * the database. + * <p> + * The listing only contains entries for tables that have a super table. + * Super and sub tables must be defined in the same Catalog and Schema. The + * list is returned as a ResultSet, with one row for each table that has a + * super table, in the following format: + * <ol> + * <li><code>TABLE_CAT</code> - String - table catalog name (possibly + * null)</li> + * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly + * null) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li>SUPER<code>TABLE_NAME</code> - String - The Super Table name + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. null is used to imply no narrowing of + * the search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param tableNamePattern + * a Table Name, which should match the Table name as stored in + * the database. it may be a fully qualified name. If it is fully + * qualified the Catalog Name and Schema Name parameters are + * ignored. + * @return a ResultSet with one row for each table which has a super table, + * in the format defined above. An empty ResultSet is returned if + * the database does not support table hierarchies. + * @throws SQLException + * a database error occurred + */ + public ResultSet getSuperTables(String catalog, String schemaPattern, + String tableNamePattern) throws SQLException; + + /** + * Returns the User Defined Type (UDT) hierarchies for a given schema. Only + * the immediate parent/child relationship is described. If a UDT does not + * have a direct supertype, it is not listed. + * <p> + * The listing is returned as a ResultSet where there is one row for a + * specific UDT which describes its supertype, with the data organized in + * columns as follows: + * <ol> + * <li><code>TYPE_CAT</code> - String - the UDT Catalog name (possibly + * null)</li> + * <li><code>TYPE_SCHEM</code> - String - the UDT Schema name (possibly + * null) </li> + * <li><code>TYPE_NAME</code> - String - the UDT type name </li> + * <li>SUPER<code>TYPE_CAT</code> - String - direct supertype's Catalog + * name (possibly null)</li> + * <li>SUPER<code>TYPE_SCHEM</code> - String - direct supertype's Schema + * name (possibly null) </li> + * <li>SUPER<code>TYPE_NAME</code> - String - direct supertype's name + * </li> + * </ol> + * + * @param catalog + * the Catalog name. "" means get the UDTs without a catalog. + * null means don't use the catalog name to restrict the search. + * @param schemaPattern + * the Schema pattern name. "" means get the UDT's without a + * schema. + * @param typeNamePattern + * the UDT name pattern. This may be a fully qualified name. When + * a fully qualified name is specified, the Catalog name and + * Schema name parameters are ignored. + * @return a ResultSet in which each row gives information about a + * particular UDT in the format defined above. An empty ResultSet is + * returned for a database that does not support type hierarchies. + * @throws SQLException + * a database error occurred + */ + public ResultSet getSuperTypes(String catalog, String schemaPattern, + String typeNamePattern) throws SQLException; + + /** + * Returns a list of system functions available with the database. These are + * names used in the JDBC function escape clause and are Open Group CLI + * function names. + * + * @return a String containing the list of system functions in a comma + * separated format + * @throws SQLException + * a database error occurred + */ + public String getSystemFunctions() throws SQLException; + + /** + * Returns a description of access rights for each table present in a + * catalog. Table privileges can apply to one or more columns in the table - + * but are not guaranteed to apply to all columns. + * <p> + * The privileges are returned as a ResultSet, with one row for each + * privilege, ordered by <code>TABLE_SCHEM</code>, + * <code>TABLE_NAME</code>, PRIVILEGE, and each row has data as defined + * in the following column definitions: + * <ol> + * <li><code>TABLE_CAT</code> - String - table catalog name (possibly + * null)</li> + * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly + * null) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li>GRANTOR - String - who granted the access</li> + * <li>GRANTEE - String - who received the access grant </li> + * <li>PRIVILEGE - String - the type of access granted - one of SELECT, + * INSERT, UPDATE, REFERENCES,... </li> + * <li>IS_GRANTABLE - String - "YES" implies the grantee can grant access + * to others, "NO" implies guarantee cannot grant access to others, null + * means this status is unknown</li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. null is used to imply no narrowing of + * the search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param tableNamePattern + * a Table Name, which should match the Table name as stored in + * the database. + * @return a ResultSet containing a list with one row for each table in the + * format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getTablePrivileges(String catalog, String schemaPattern, + String tableNamePattern) throws SQLException; + + /** + * Returns a description of the tables in a specified catalog. + * <p> + * The descriptions are returned as rows in a ResultSet, one row for each + * Table. The ResultSet is ordered by <code>TABLE_TYPE</code>, + * <code>TABLE_SCHEM</code> and <code>TABLE_NAME</code>. Each row in + * the ResultSet consists of a series of columns as follows: + * <ol> + * <li><code>TABLE_CAT</code> - String - table catalog name (possibly + * null)</li> + * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly + * null) </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>TABLE_TYPE</code> - String - Typical names include "TABLE", + * "VIEW", "SYSTEM TABLE", "ALIAS", "SYNONYM", "GLOBAL TEMPORARY"</li> + * <li><code>REMARKS</code> - String - A comment describing the table + * </li> + * <li><code>TYPE_CAT</code> - String - the 'Types' catalog(possibly + * null)</li> + * <li><code>TYPE_SCHEM</code> - String - the 'Types' schema(possibly + * null) </li> + * <li><code>TYPE_NAME</code> - String - the 'Types' name (possibly null) + * </li> + * <li><code>SELF_REFERENCING_COL_NAME</code> - String - the name of a + * designated identifier column in a typed table (possibly null) </li> + * <li>REF_GENERATION - String - one of the following values : "SYSTEM" | + * "USER" | "DERIVED" - specifies how values in the + * <code>SELF_REFERENCING_COL_NAME</code> are created (possibly null) + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. null is used to imply no narrowing of + * the search using Schema Name. Otherwise, the name must match a + * Schema name in the database, with "" used to retrieve those + * without a Schema name. + * @param tableNamePattern + * a Table Name, which should match the Table name as stored in + * the database. + * @param types + * a list of table types to include in the list. null implies + * list all types. + * @return a ResultSet with one row per table in the format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getTables(String catalog, String schemaPattern, + String tableNamePattern, String[] types) throws SQLException; + + /** + * Returns a list of table types supported by the database. + * <p> + * The list is returned as a ResultSet with one row per table type, ordered + * by the table type. The information in the ResultSet is structured into a + * single column per row, as follows: + * <ol> + * <li><code>TABLE_TYPE</code> - String - the Table Type. Typical names + * include "TABLE", "VIEW", "SYSTEM TABLE", "ALIAS", "SYNONYM", "GLOBAL + * TEMPORARY" </li> + * </ol> + * + * @return a ResultSet with one row per table type in the format defined + * above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getTableTypes() throws SQLException; + + /** + * Returns a list of time and date functions available for the database. + * + * @return a String contain a comma separated list of the time and date + * functions. + * @throws SQLException + * a database error occurred + */ + public String getTimeDateFunctions() throws SQLException; + + /** + * Get a list of the standard SQL Types supported by this database. The list + * is returned as a ResultSet, with one row for each type, ordered by the + * <code>DATA_TYPE</code> value, where the data in each row is structured + * into the following columns: + * <ol> + * <li><code>TYPE_NAMR</code> - String : the Type name</li> + * <li><code>DATA_TYPE</code> - int : the SQL data type value as defined + * in <code>java.sql.Types</code></li> + * <li><code>PRECISION</code> - int - the maximum precision of the type</li> + * <li><code>LITERAL_PREFIX</code> - String : the prefix to be used when + * quoting a literal value (possibly <code>null</code>)</li> + * <li><code>LITERAL_SUFFIX</code> - String : the suffix to be used when + * quoting a literal value (possibly <code>null</code>)</li> + * <li><code>CREATE_PARAMS</code> - String : params used when creating + * the type (possibly <code>null</code>)</li> + * <li><code>NULLABLE</code> - short : shows if the value is null-able: + * <ul> + * <li>DatabaseMetaData.typeNoNulls : <code>NULL</code>s not permitted</li> + * <li>DatabaseMetaData.typeNullable : <code>NULL</code>s are permitted + * </li> + * <li>DatabaseMetaData.typeNullableUnknown : <code>NULL</code> status + * unknown </li> + * </ul> + * </li> + * <li>CASE_SENSITIVE - boolean : true if the type is case sensitive</li> + * <li>SEARCHABLE - short : how this type can be used with WHERE clauses: + * <ul> + * <li>DatabaseMetaData.typePredNone - cannot be used </li> + * <li>DatabaseMetaData.typePredChar - support for WHERE...LIKE only</li> + * <li>DatabaseMetaData.typePredBasic - support except for WHERE...LIKE</li> + * <li>DatabaseMetaData.typeSearchable - support for all WHERE clauses</li> + * </ul> + * </li> + * <li>UNSIGNED_ATTRIBUTE - boolean - the type is unsigned or not </li> + * <li>FIXED_PREC_SCALE - boolean - fixed precision = it can be used as a + * money value </li> + * <li>AUTO_INCREMENT - boolean - can be used as an auto-increment value + * </li> + * <li>LOCAL_<code>TYPE_NAME</code> - String - a localized version of + * the type name (possibly null)</li> + * <li>MINIMUM_SCALE - short - the minimum scale supported </li> + * <li>MAXIMUM_SCALE - short - the maximum scale supported </li> + * <li>SQL_<code>DATA_TYPE</code> - int - not used </li> + * <li>SQL_DATETIME_SUB - int - not used </li> + * <li>NUM_PREC_RADIX - int - number radix (typically 2 or 10) </li> + * </ol> + * + * @return a ResultSet which is structured as described above + * @throws SQLException + * a database error occurred + */ + public ResultSet getTypeInfo() throws SQLException; + + /** + * Returns a description of the User Defined Types (UDTs) defined in a given + * schema, which includes the types DISTINCT, STRUCT and JAVA_OBJECT. + * <p> + * The types matching the supplied the specified Catalog, Schema, Type Name + * and Type are returned as rows in a ResultSet with columns of information + * as follows: + * <ol> + * <li><code>TABLE_CAT</code> - String - Catalog name (possibly null)</li> + * <li><code>TABLE_SCHEM</code> - String - Schema name (possibly null) + * </li> + * <li><code>TABLE_NAME</code> - String - The Table name </li> + * <li><code>CLASS_NAME</code> - String - The Java class name</li> + * <li><code>DATA_TYPE</code> - int - The SQL type as specified in + * <code>java.sql.Types</code>. One of DISTINCT, STRUCT and JAVA_OBJECT</li> + * <li><code>REMARKS</code> - String - A comment which describes the type + * </li> + * <li><code>BASE_TYPE</code> - short - A type code. For a DISTINCT type, + * the source type. For a structured type this is the type that implements + * the user generated reference type of the + * <code>SELF_REFERENCING_COLUMN</code>. This is defined in + * <code>java.sql.Types</code>, and will be <code>null</code> if the + * <code>DATA_TYPE</code> does not match these criteria.</li> + * </ol> + * If the driver does not support UDTs, the ResultSet will be empty. + * + * @param catalog + * a Catalog Name. null is used to imply no narrowing of the + * search using Catalog Name. Otherwise, the name must match a + * Catalog Name held in the database, with "" used to retrieve + * those without a Catalog Name. + * @param schemaPattern + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param typeNamePattern + * a Type Name, which should match a Type name as stored in the + * database. It may be fully qualified. + * @param types + * a list of the UDT types to include in the list - one of + * DISTINCT, STRUCT or JAVA_OBJECT. + * @return a ResultSet in the format described above + * @throws SQLException + * a database error occurred + */ + public ResultSet getUDTs(String catalog, String schemaPattern, + String typeNamePattern, int[] types) throws SQLException; + + /** + * Returns the URL for this database. + * + * @return the URL for the database. <code>null</code> if it cannot be + * generated. + * @throws SQLException + * a database error occurred + */ + public String getURL() throws SQLException; + + /** + * Determine the user name as known by the database. + * + * @return the user name + * @throws SQLException + * a database error occurred + */ + public String getUserName() throws SQLException; + + /** + * Returns which of a table's columns are automatically updated when any + * value in a row is updated. + * <p> + * The result is laid-out in the following columns: + * <ol> + * <li><code>SCOPE</code> - short - not used </li> + * <li><code>COLUMN_NAME</code> - String - Column name</li> + * <li><code>DATA_TYPE</code> - int - The SQL data type, as defined in + * <code>java.sql.Types</code> </li> + * <li><code>TYPE_NAME</code> - String - The SQL type name, data source + * dependent </li> + * <li><code>COLUMN_SIZE</code> - int - Precision for numeric types </li> + * <li><code>BUFFER_LENGTH</code> - int - Length of a column value in + * bytes </li> + * <li><code>DECIMAL_DIGITS</code> - short - Number of digits after the + * decimal point </li> + * <li><code>PSEUDO_COLUMN</code> - short - If this is a pseudo-column + * (for example, an Oracle ROWID): + * <ul> + * <li>DatabaseMetaData.bestRowUnknown - don't know whether this is a + * pseudo column</li> + * <li>DatabaseMetaData.bestRowNotPseudo - column is not pseudo</li> + * <li>DatabaseMetaData.bestRowPseudo - column is a pseudo column</li> + * </ul> + * </li> + * </ol> + * + * @param catalog + * a Catalog Name. <code>null</code> is used to imply no + * narrowing of the search using Catalog Name. Otherwise, the + * name must match a Catalog Name held in the database, with "" + * used to retrieve those without a Catalog Name. + * @param schema + * a Schema Name Pattern. <code>null</code> is used to imply no + * narrowing of the search using Schema Name. Otherwise, the name + * must match a Schema name in the database, with "" used to + * retrieve those without a Schema name. + * @param table + * a table name. It must match the name of a table in the + * database. + * @return a ResultSet containing the descriptions, one row for each column, + * in the format defined above. + * @throws SQLException + * a database error occurred + */ + public ResultSet getVersionColumns(String catalog, String schema, + String table) throws SQLException; + + /** + * Determine if a visible row insert can be detected by calling + * ResultSet.rowInserted. + * + * @param type + * the ResultSet type. This may be one of + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> or + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code> or + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * @return <code>true</code> if ResultSet.rowInserted detects a visible + * row insert otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean insertsAreDetected(int type) throws SQLException; + + /** + * Determine whether a fully qualified table name is prefixed or suffixed to + * a fully qualified table name. + * + * @return <code>true</code> if the catalog appears at the start of a + * fully qualified table name, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean isCatalogAtStart() throws SQLException; + + /** + * Determine if the database is in read-only mode. + * + * @return <code>true</code> if the database is in read-only mode, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean isReadOnly() throws SQLException; + + /** + * Determine if updates are made to a copy of, or directly on, Large Objects + * (LOBs). + * + * @return <code>true</code> if updates are made to a copy of the Large + * Object, <code>false</code> otherwise + * @throws SQLException + * a database error occurred + */ + public boolean locatorsUpdateCopy() throws SQLException; + + /** + * Determine if the database handles concatenations between + * <code>NULL</code> and non-<code>NULL</code> values by producing a + * <code>NULL</code> output. + * + * @return <code>true</code> if <code>NULL</code> to non-<code>NULL</code> + * concatenations produce a <code>NULL</code> result, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean nullPlusNonNullIsNull() throws SQLException; + + /** + * Determine if <code>NULL</code> values are always sorted to the end of + * sorted results regardless of requested sort order. This means that they + * will appear at the end of sorted lists whatever other non-<code>NULL</code> + * values may be present. + * + * @return <code>true</code> if <code>NULL</code> values are sorted at + * the end, <code>false</code> otherwise + * @throws SQLException + * a database error occurred + */ + public boolean nullsAreSortedAtEnd() throws SQLException; + + /** + * Determine if <code>NULL</code> values are always sorted at the start of + * the sorted list, irrespective of the sort order. This means that they + * appear at the start of sorted lists, whatever other values may be + * present. + * + * @return <code>true</code> if <code>NULL</code> values are sorted at + * the start, <code>false</code> otherwise + * @throws SQLException + * a database error occurred + */ + public boolean nullsAreSortedAtStart() throws SQLException; + + /** + * Determine if <code>NULL</code> values are sorted high - i.e. they are + * sorted as if they are higher than any other values. + * + * @return <code>true</code> if <code>NULL</code> values are sorted + * high, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean nullsAreSortedHigh() throws SQLException; + + /** + * Determine if <code>NULL</code> values are sorted low - ie they are + * sorted as if they are lower than any other values. + * + * @return <code>true</code> if <code>NULL</code> values are sorted low, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean nullsAreSortedLow() throws SQLException; + + /** + * Determine if deletes made by others are visible, for a specified + * ResultSet type. + * + * @param type + * the type of the ResultSet. It may be either + * <code>ResultSet.TYPE_FORWARD_ONLY</code> or + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>) + * @return <code>true</code> if others' deletes are visible, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean othersDeletesAreVisible(int type) throws SQLException; + + /** + * Determine if inserts made by others are visible, for a specified + * ResultSet type. + * + * @param type + * the type of the ResultSet. May be + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, or + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if others' inserts are visible otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean othersInsertsAreVisible(int type) throws SQLException; + + /** + * Determine if updates made by others are visible, for a specified + * ResultSet type. + * + * @param type + * the type of the ResultSet. May be + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, or + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if others' inserts are visible otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean othersUpdatesAreVisible(int type) throws SQLException; + + /** + * Determine if a ResultSet's own deletes are visible, for a specified + * ResultSet type. + * + * @param type + * the type of the ResultSet: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if the delete's are seen by the own ResultSet + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean ownDeletesAreVisible(int type) throws SQLException; + + /** + * Determine if its own inserts are visible to a given ResultSet type. + * + * @param type + * the type of the ResultSet: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if inserts are visible for this type + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean ownInsertsAreVisible(int type) throws SQLException; + + /** + * Determine if for a supplied type of ResultSet, the ResultSet's own + * updates are visible. + * + * @param type + * the type of the ResultSet: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if updates are visible to in this ResultSet + * type otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean ownUpdatesAreVisible(int type) throws SQLException; + + /** + * Determine whether the database treats SQL identifiers that are in mixed + * case (and unquoted) as case insensitive. If true then the database stores + * them in lower case. + * + * @return <code>true</code> if unquoted SQL identifiers are stored in + * lower case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesLowerCaseIdentifiers() throws SQLException; + + /** + * Determine whether the database considers mixed case quoted SQL + * identifiers as case insensitive and stores them in lower case. + * + * @return <code>true</code> if quoted SQL identifiers are stored in lower + * case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesLowerCaseQuotedIdentifiers() throws SQLException; + + /** + * Determine whether the database considers mixed case unquoted SQL + * identifiers as case insensitive and stores them in mixed case. + * + * @return <code>true</code> if unquoted SQL identifiers as stored in + * mixed case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesMixedCaseIdentifiers() throws SQLException; + + /** + * Determine whether the database considers identifiers as case insensitive + * if they are mixed case quoted SQL. The database stores them in mixed + * case. + * + * @return <code>true</code> if quoted SQL identifiers are stored in mixed + * case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesMixedCaseQuotedIdentifiers() throws SQLException; + + /** + * Determine whether the database considers mixed case unquoted SQL + * identifiers as case insensitive and stores them in upper case. + * + * @return <code>true</code> if unquoted SQL identifiers are stored in + * upper case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesUpperCaseIdentifiers() throws SQLException; + + /** + * Determine whether the database considers mixed case quoted SQL + * identifiers as case insensitive and stores them in upper case. + * + * @return <code>true</code> if quoted SQL identifiers are stored in upper + * case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean storesUpperCaseQuotedIdentifiers() throws SQLException; + + /** + * Determine if the database supports ALTER TABLE operation with add column. + * + * @return <code>true</code> if ALTER TABLE with add column is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsAlterTableWithAddColumn() throws SQLException; + + /** + * Determine if the database supports ALTER TABLE operation with drop + * column. + * + * @return <code>true</code> if ALTER TABLE with drop column is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsAlterTableWithDropColumn() throws SQLException; + + /** + * Determine if the database supports the ANSI92 entry level SQL grammar. + * + * @return <code>true</code> if the ANSI92 entry level SQL grammar is + * supported, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsANSI92EntryLevelSQL() throws SQLException; + + /** + * Determine if the database supports the ANSI92 full SQL grammar. + * + * @return <code>true</code> if the ANSI92 full SQL grammar is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsANSI92FullSQL() throws SQLException; + + /** + * Determine if the database supports the ANSI92 intermediate SQL Grammar. + * + * @return <code>true</code> if the ANSI92 intermediate SQL grammar is + * supported, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsANSI92IntermediateSQL() throws SQLException; + + /** + * Determine if the database supports Batch Updates. + * + * @return <code>true</code> if batch updates are supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsBatchUpdates() throws SQLException; + + /** + * Determine whether catalog names may be used in data manipulation + * statements. + * + * @return <code>true</code> if catalog names can be used in data + * manipulation statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCatalogsInDataManipulation() throws SQLException; + + /** + * Determine if catalog names can be used in Index Definition statements. + * + * @return <code>true</code> if catalog names can be used in Index + * Definition statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCatalogsInIndexDefinitions() throws SQLException; + + /** + * Determine if catalog names can be used in privilege definition + * statements. + * + * @return <code>true</code> if catalog names can be used in privilege + * definition statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException; + + /** + * Determine if catalog names can be used in procedure call statements. + * + * @return <code>true</code> if catalog names can be used in procedure + * call statements. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCatalogsInProcedureCalls() throws SQLException; + + /** + * Determine if catalog names may be used in table definition statements. + * + * @return <code>true</code> if catalog names can be used in definition + * statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCatalogsInTableDefinitions() throws SQLException; + + /** + * Determine if the database supports column aliasing. + * <p> + * If aliasing is supported, then the SQL AS clause is used to provide names + * for computed columns and provide alias names for columns. + * + * @return <code>true</code> if column aliasing is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsColumnAliasing() throws SQLException; + + /** + * Determine if the database supports the CONVERT operation between SQL + * types. + * + * @return <code>true</code> if the CONVERT operation is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsConvert() throws SQLException; + + /** + * Determine if the database supports CONVERT operation for two supplied SQL + * types. + * + * @param fromType + * the Type to convert from, as defined by + * <code>java.sql.Types</code> + * @param toType + * the Type to convert to, as defined by + * <code>java.sql.Types</code> + * @return <code>true</code> if the CONVERT operation is supported for + * these types, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsConvert(int fromType, int toType) + throws SQLException; + + /** + * Determine if the database supports the Core SQL Grammar for ODBC. + * + * @return <code>true</code> if the Core SQL Grammar is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCoreSQLGrammar() throws SQLException; + + /** + * Determine if the database supports correlated sub-queries. + * + * @return <code>true</code> if the database does support correlated + * sub-queries and <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsCorrelatedSubqueries() throws SQLException; + + /** + * Determine if the database allows both data definition and data + * manipulation statements inside a transaction. + * + * @return <code>true</code> if both types of statement are permitted, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsDataDefinitionAndDataManipulationTransactions() + throws SQLException; + + /** + * Determine if the database only allows data manipulation statements inside + * a transaction. + * + * @return <code>true</code> if only data manipulation statements are + * permitted, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsDataManipulationTransactionsOnly() + throws SQLException; + + /** + * Determine if table correlation names are restricted to be different from + * the names of the tables, when they are supported. + * + * @return <code>true</code> if correlation names must be different to + * table names, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsDifferentTableCorrelationNames() throws SQLException; + + /** + * Determine whether expressions in ORDER BY lists are supported. + * + * @return <code>true</code> if expressions in ORDER BY lists are + * supported. + * @throws SQLException + * a database error occurred + */ + public boolean supportsExpressionsInOrderBy() throws SQLException; + + /** + * Determine whether the Extended SQL Grammar for ODBC is supported. + * + * @return <code>true</code> if the Extended SQL Grammar is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsExtendedSQLGrammar() throws SQLException; + + /** + * Determine if the database supports full nested outer joins. + * + * @return <code>true</code> if full nested outer joins are supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsFullOuterJoins() throws SQLException; + + /** + * Determine if auto generated keys can be returned when a statement + * executes. + * + * @return <code>true</code> if auto generated keys can be returned, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsGetGeneratedKeys() throws SQLException; + + /** + * Determine if the database supports a form of GROUP BY clause. + * + * @return <code>true</code> if a form of GROUP BY clause is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsGroupBy() throws SQLException; + + /** + * Determine if the database supports using a column name in a GROUP BY + * clause not included in the SELECT statement as long as all of the columns + * in the SELECT statement are used in the GROUP BY clause. + * + * @return <code>true</code> if GROUP BY clauses can use column names in + * this way, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsGroupByBeyondSelect() throws SQLException; + + /** + * Determine if the database supports using a column name in a GROUP BY + * clause that is not in the SELECT statement. + * + * @return <code>true</code> if GROUP BY clause can use a column name not + * in the SELECT statement, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsGroupByUnrelated() throws SQLException; + + /** + * Determine whether the database supports SQL Integrity Enhancement + * Facility. + * + * @return <code>true</code> if the Integrity Enhancement Facility is + * supported, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsIntegrityEnhancementFacility() throws SQLException; + + /** + * Determine if the database supports using a LIKE escape clause. + * + * @return <code>true</code> if LIKE escape clause is supported, + * <code>false</code> otherwise + * @throws SQLException + * a database error occurred + */ + public boolean supportsLikeEscapeClause() throws SQLException; + + /** + * Determine if the database provides limited support for outer Join + * operations. + * + * @return <code>true</code> if there is limited support for outer Join + * operations, <code>false</code> otherwise. This will be + * <code>true</code> if <code>supportsFullOuterJoins</code> + * returns <code>true</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsLimitedOuterJoins() throws SQLException; + + /** + * Determine if the database supports Minimum SQL Grammar for ODBC. + * + * @return <code>true</code> if the Minimum SQL Grammar is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMinimumSQLGrammar() throws SQLException; + + /** + * Determine if the database treats mixed case unquoted SQL identifiers as + * case sensitive storing them in mixed case. + * + * @return <code>true</code> if unquoted SQL identifiers are stored in + * mixed case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMixedCaseIdentifiers() throws SQLException; + + /** + * Determine whether the database considers mixed case quoted SQL + * identifiers as case sensitive, storing them in mixed case. + * + * @return <code>true</code> if quoted SQL identifiers are stored in mixed + * case, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException; + + /** + * Determine if it is possible for a single CallableStatement to return + * multiple ResultSets simultaneously. + * + * @return <code>true</code> if a single CallableStatement can return + * multiple ResultSets simultaneously, <code>false</code> + * otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMultipleOpenResults() throws SQLException; + + /** + * Determine whether retrieving multiple ResultSets from a single call to + * the <code>execute</code> method is supported. + * + * @return <code>true</code> if multiple ResultSets can be retrieved, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMultipleResultSets() throws SQLException; + + /** + * Determine whether multiple transactions in progress at at time on + * different connections are supported. + * + * @return <code>true</code> if multiple open transactions are supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsMultipleTransactions() throws SQLException; + + /** + * Determine whether call-able statements with named parameters is + * supported. + * + * @return <code>true</code> if named parameters can be used with + * call-able statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsNamedParameters() throws SQLException; + + /** + * Determine if columns in the database can be defined as non-nullable. + * + * @return <code>true</code> if Columns can be defined non-nullable, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsNonNullableColumns() throws SQLException; + + /** + * Determine whether keeping Cursors open across Commit operations is + * supported. + * + * @return <code>true</code> if Cursors can be kept open across Commit + * operations, <code>false</code> if they might get closed. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOpenCursorsAcrossCommit() throws SQLException; + + /** + * Determine if the database can keep Cursors open across Rollback + * operations. + * + * @return <code>true</code> if Cursors can be kept open across Rollback + * operations, <code>false</code> if they might get closed. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOpenCursorsAcrossRollback() throws SQLException; + + /** + * Determine whether keeping Statements open across Commit operations is + * supported. + * + * @return <code>true</code> if Statements can be kept open, + * <code>false</code> if they might not. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOpenStatementsAcrossCommit() throws SQLException; + + /** + * Determine whether keeping Statements open across Rollback operations is + * supported. + * + * @return <code>true</code> if Statements can be kept open, + * <code>false</code> if they might not. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOpenStatementsAcrossRollback() throws SQLException; + + /** + * Determine whether using a column in an ORDER BY clause that is not in the + * SELECT statement is supported. + * + * @return <code>true</code> if it is possible to ORDER using a column not + * in the SELECT, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOrderByUnrelated() throws SQLException; + + /** + * Determine whether outer join operations are supported. + * + * @return <code>true</code> if outer join operations are supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsOuterJoins() throws SQLException; + + /** + * Determine whether positioned DELETE statements are supported. + * + * @return <code>true</code> if the database supports positioned DELETE + * statements. + * @throws SQLException + * a database error occurred + */ + public boolean supportsPositionedDelete() throws SQLException; + + /** + * Determine whether positioned UPDATE statements are supported. + * + * @return <code>true</code> if the database supports positioned UPDATE + * statements, <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsPositionedUpdate() throws SQLException; + + /** + * Determine whether there is support for a given concurrency style for the + * given ResultSet. + * + * @param type + * the ResultSet type, as defined in + * <code>java.sql.ResultSet</code>: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @param concurrency + * a concurrency type, which may be one of + * <code>ResultSet.CONCUR_READ_ONLY</code> or + * <code>ResultSet.CONCUR_UPDATABLE</code>. + * @return <code>true</code> if that concurrency and ResultSet type + * pairing is supported otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsResultSetConcurrency(int type, int concurrency) + throws SQLException; + + /** + * Determine whether the supplied ResultSet holdability is supported. + * + * @param holdability + * as specified in java.sql.ResultSet: + * ResultSet.HOLD_CURSORS_OVER_COMMIT or + * ResultSet.CLOSE_CURSORS_AT_COMMIT + * @return <code>true</code> if the given ResultSet holdability is + * supported and if it isn't then <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsResultSetHoldability(int holdability) + throws SQLException; + + /** + * Determine whether the supplied ResultSet type is supported. + * + * @param type + * the ResultSet type as defined in java.sql.ResultSet: + * <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> if the ResultSet type is supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsResultSetType(int type) throws SQLException; + + /** + * Determine whether Savepoints for transactions are supported. + * + * @return <code>true</code> if Savepoints are supported, + * <code>false</code> otherwise. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSavepoints() throws SQLException; + + /** + * Determine whether a schema name may be used in a data manipulation + * statement. + * + * @return <code>true</code> if a schema name can be used in a data + * manipulation otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSchemasInDataManipulation() throws SQLException; + + /** + * Determine whether a schema name may be used in an index definition + * statement. + * + * @return <code>true</code> if a schema name can be used in an index + * definition otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSchemasInIndexDefinitions() throws SQLException; + + /** + * Determine whether a database schema name can be used in a privilege + * definition statement. + * + * @return <code>true</code> if a database schema name may be used in a + * privilege definition otherwise <code>false</code> + * @throws SQLException + * a database error occurred + */ + public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException; + + /** + * Determine if a procedure call statement may be contain in a schema name. + * + * @return <code>true</code> if a schema name can be used in a procedure + * call otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSchemasInProcedureCalls() throws SQLException; + + /** + * Determine if a schema name can be used in a table definition statement. + * + * @return <code>true</code> if a schema name can be used in a table + * definition otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSchemasInTableDefinitions() throws SQLException; + + /** + * Determine if this <code>SELECT FOR UPDATE</code> statements ar + * supported. + * + * @return <code>true</code> if <code>SELECT FOR UPDATE</code> + * statements are supported otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSelectForUpdate() throws SQLException; + + /** + * Determine whether statement pooling is supported. + * + * @return <code>true</code> of the database does support statement + * pooling otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsStatementPooling() throws SQLException; + + /** + * Determine whether stored procedure calls using the stored procedure + * escape syntax is supported. + * + * @return <code>true</code> if stored procedure calls using the stored + * procedure escape syntax are supported otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsStoredProcedures() throws SQLException; + + /** + * Determine whether subqueries in comparison expressions are supported. + * + * @return <code>true</code> if subqueries are supported in comparison + * expressions. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSubqueriesInComparisons() throws SQLException; + + /** + * Determine whether subqueries in EXISTS expressions are supported. + * + * @return <code>true</code> if subqueries are supported in EXISTS + * expressions otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSubqueriesInExists() throws SQLException; + + /** + * Determine whether subqueries in <code>IN</code> statements are + * supported. + * + * @return <code>true</code> if subqueries are supported in IN statements + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSubqueriesInIns() throws SQLException; + + /** + * Determine whether subqueries in quantified expressions are supported. + * + * @return <code>true</code> if subqueries are supported otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsSubqueriesInQuantifieds() throws SQLException; + + /** + * Determine whether the database has table correlation names support. + * + * @return <code>true</code> if table correlation names are supported + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsTableCorrelationNames() throws SQLException; + + /** + * Determine whether a specified transaction isolation level is supported. + * + * @param level + * the transaction isolation level, as specified in + * <code>java.sql.Connection</code>: + * <code>TRANSACTION_NONE</code>, + * <code>TRANSACTION_READ_COMMITTED</code>, + * <code>TRANSACTION_READ_UNCOMMITTED</code>, + * <code>TRANSACTION_REPEATABLE_READ</code>, + * <code>TRANSACTION_SERIALIZABLE</code> + * @return <code>true</code> if the specific isolation level is supported + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsTransactionIsolationLevel(int level) + throws SQLException; + + /** + * Determine whether transactions are supported. + * <p> + * If transactions are not supported, then the <code>commit</code> method + * does nothing and the transaction isolation level is always + * <code>TRANSACTION_NONE</code>. + * + * @return <code>true</code> if transactions are supported otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsTransactions() throws SQLException; + + /** + * Determine whether the <code>SQL UNION</code> operation is supported. + * + * @return <code>true</code> of the database does support + * <code>UNION</code> otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsUnion() throws SQLException; + + /** + * Determine whether the <code>SQL UNION ALL</code> operation is + * supported. + * + * @return <code>true</code> if the database does support UNION ALL + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean supportsUnionAll() throws SQLException; + + /** + * Determine if the method <code>ResultSet.rowUpdated</code> can detect a + * visible row update. + * + * @param type + * ResultSet type: <code>ResultSet.TYPE_FORWARD_ONLY</code>, + * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or + * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> + * @return <code>true</code> detecting changes is possible otherwise + * <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean updatesAreDetected(int type) throws SQLException; + + /** + * Determine if this database uses a file for each table. + * + * @return <code>true</code> if the database uses one file for each table + * otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean usesLocalFilePerTable() throws SQLException; + + /** + * Determine whether this database uses a local file to store tables. + * + * @return <code>true</code> of the database does store tables in a local + * file otherwise <code>false</code>. + * @throws SQLException + * a database error occurred + */ + public boolean usesLocalFiles() throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Date.java b/sql/src/main/java/java/sql/Date.java new file mode 100644 index 0000000..ce31b01 --- /dev/null +++ b/sql/src/main/java/java/sql/Date.java @@ -0,0 +1,233 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.text.SimpleDateFormat; + +/** + * A Date class which can consume and produce dates in SQL Date format. + * <p> + * The SQL date format represents a date as yyyy-mm-dd. Note that this date + * format only deals with year, month and day values. There are no values for + * hours, minutes, seconds. + * <p> + * This contrasts with regular java.util.Date values, which include time values + * for hours, minutes, seconds, milliseconds. + * <p> + * Time points are handled as millisecond values - milliseconds since the epoch, + * January 1st 1970, 00:00:00.000 GMT. Time values passed to the java.sql.Date + * class are "normalized" to the time 00:00:00.000 GMT on the date implied by + * the time value. + */ +public class Date extends java.util.Date { + + private static final long serialVersionUID = 1511598038487230103L; + + /** + * @deprecated Please use the constructor {@link #Date(long)} Constructs a Date + * object corresponding to the supplied Year, Month and Day. + * @param theYear + * the year, specified as the year minus 1900. Must be in the + * range 0 to 8099. + * @param theMonth + * the month, specified as a number with 0 = January. Must be in + * the range 0 to 11. + * @param theDay + * the day in the month. Must be in the range 1 to 31. + */ + @SuppressWarnings("deprecation") + @Deprecated + public Date(int theYear, int theMonth, int theDay) { + super(theYear, theMonth, theDay); + } + + /** + * Creates a Date which corresponds to the day implied by the supplied + * theDate milliseconds time value. + * + * @param theDate - + * a time value in milliseconds since the epoch - January 1 1970 + * 00:00:00 GMT. The time value (hours, minutes, seconds, + * milliseconds) stored in the Date object is adjusted to + * correspond to 00:00:00 GMT on the day implied by the supplied + * time value. + */ + public Date(long theDate) { + super(normalizeTime(theDate)); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have an hours component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getHours() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have a minutes component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getMinutes() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have a seconds component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getSeconds() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have an hours component. + * @param theHours + * the number of hours to set + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setHours(int theHours) { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have a minutes component. + * @param theMinutes + * the number of minutes to set + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setMinutes(int theMinutes) { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. SQL Date + * values do not have a seconds component. + * @param theSeconds + * the number of seconds to set + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setSeconds(int theSeconds) { + throw new IllegalArgumentException(); + } + + /** + * Sets this date to a date supplied as a milliseconds value. The date is + * set based on the supplied time value after removing any time elements + * finer than a day, based on zero GMT for that day. + * + * @param theTime + * the time in milliseconds since the Epoch + */ + @Override + public void setTime(long theTime) { + /* + * Store the Date based on the supplied time after removing any time + * elements finer than the day based on zero GMT + */ + super.setTime(normalizeTime(theTime)); + } + + /** + * Produces a string representation of the Date in SQL format + * + * @return a string representation of the Date in SQL format - "yyyy-mm-dd". + */ + @Override + public String toString() { + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); //$NON-NLS-1$ + return dateFormat.format(this); + } + + /** + * Creates a Date from a string representation of a date in SQL format. + * + * @param dateString + * the string representation of a date in SQL format - + * "yyyy-mm-dd". + * @return the Date object + * @throws IllegalArgumentException + * if the format of the supplied string does not match the SQL + * format. + */ + public static Date valueOf(String dateString) { + if (dateString == null) { + throw new IllegalArgumentException(); + } + int firstIndex = dateString.indexOf('-'); + int secondIndex = dateString.indexOf('-', firstIndex + 1); + // secondIndex == -1 means none or only one separator '-' has been + // found. + // The string is separated into three parts by two separator characters, + // if the first or the third part is null string, we should throw + // IllegalArgumentException to follow RI + if (secondIndex == -1 || firstIndex == 0 + || secondIndex + 1 == dateString.length()) { + throw new IllegalArgumentException(); + } + // parse each part of the string + int year = Integer.parseInt(dateString.substring(0, firstIndex)); + int month = Integer.parseInt(dateString.substring(firstIndex + 1, + secondIndex)); + int day = Integer.parseInt(dateString.substring(secondIndex + 1, + dateString.length())); + return new Date(year - 1900, month - 1, day); + } + + /* + * Private method which normalizes a Time value, removing all low + * significance digits corresponding to milliseconds, seconds, minutes and + * hours, so that the returned Time value corresponds to 00:00:00 GMT on a + * particular day. + */ + private static long normalizeTime(long theTime) { + return theTime; + } +} diff --git a/sql/src/main/java/java/sql/Driver.java b/sql/src/main/java/java/sql/Driver.java new file mode 100644 index 0000000..7833724 --- /dev/null +++ b/sql/src/main/java/java/sql/Driver.java @@ -0,0 +1,113 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Properties; + +/** + * An Interface to a JDBC Driver. + * <p> + * The JDBC Driver uses URLs to specify the location of specific data. URL + * format typically takes the form "xxxx:yyyy:SpecificData", where "xxxx:yyyy" + * is termed the subprotocol and is normally the same for all uses of a + * particular driver. "SpecificData" is a string which identifies the particular + * data source that the driver should use. + * + */ +public interface Driver { + + /** + * Returns whether the driver thinks that it can open a connection to the + * given URL. + * + * @param url + * the URL to connect to. + * @return true if the driver thinks that is can open a connection to the + * supplied URL, false otherwise. Typically, the driver will respond + * true if it thinks that it can handle the subprotocol specified by + * the driver. + * @throws SQLException + */ + public boolean acceptsURL(String url) throws SQLException; + + /** + * Attempts to make a database connection to a datasource specified by a + * supplied URL. + * + * @param url + * the url to connect. + * @param info + * some properties that should be used in establishing the + * connection. The properties consist of name/value pairs of + * Strings. Normally, a connection to a database requires at + * least two properties - for "user" and "password" in order to + * pass authentication to the database. + * @return a Connection object representing the connection to the database. + * @throws SQLException + * if a database error occurs + */ + public Connection connect(String url, Properties info) throws SQLException; + + /** + * Gets the driver's major version number. + * + * @return the major version number of the Driver - typically starts at 1. + */ + public int getMajorVersion(); + + /** + * Gets the driver's minor version number. + * + * @return the minor version number of the Driver - typically starts at 0. + */ + public int getMinorVersion(); + + /** + * Gets information about possible properties for this driver. + * <p> + * This method is intended to provide a listing of possible properties that + * the user of the driver may need to supply in order to correct connect to + * a database. Note that the returned array of Properties may change + * depending on the supplied list of property values. + * + * @param url + * the url of the database. A using program may call this method + * iteratively as the property list is built up - for example, + * when displaying a dialog to an end-user as part of the + * database login process. + * @param info + * @return an array of DriverPropertyInfo records which provide detail on + * each property that the driver will accept. + * @throws SQLException + */ + public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) + throws SQLException; + + /** + * Reports whether this driver is a genuine JDBC CompliantTM driver. The + * driver may only return true from this method if it passes all the JDBC + * Compliance tests. + * <p> + * A driver may not be fully compliant if the underlying database has + * limited functionality. + * + * @return true if the driver is fully JDBC compliant, false otherwise. + */ + public boolean jdbcCompliant(); + +} diff --git a/sql/src/main/java/java/sql/DriverManager.java b/sql/src/main/java/java/sql/DriverManager.java new file mode 100644 index 0000000..78f362c --- /dev/null +++ b/sql/src/main/java/java/sql/DriverManager.java @@ -0,0 +1,433 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Properties; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.Set; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.util.HashSet; +import java.util.Vector; +import org.apache.harmony.sql.internal.nls.Messages; +import org.apache.harmony.kernel.vm.VM; + +/** + * Provides facilities for managing JDBC Drivers. + * <p> + * The DriverManager class will load JDBC drivers during its initialization, + * from the list of drivers referenced by the System Property "jdbc.drivers". + */ +public class DriverManager { + + /* + * Facilities for logging. The Print Stream is deprecated but is maintained + * here for compatibility. + */ + private static PrintStream thePrintStream; + + private static PrintWriter thePrintWriter; + + // Login timeout value - by default set to 0 -> "wait forever" + private static int loginTimeout = 0; + + /* + * Set to hold Registered Drivers - initial capacity 10 drivers (will expand + * automatically if necessary. + */ + private static final Set<Driver> theDriverSet = new HashSet<Driver>(10); + + // Permission for setting log + private static final SQLPermission logPermission = new SQLPermission("setLog"); //$NON-NLS-1$ + + /* + * Load drivers on initialization + */ + static { + loadInitialDrivers(); + } + + /* + * Loads the set of JDBC drivers defined by the Property "jdbc.drivers" if + * it is defined. + */ + private static void loadInitialDrivers() { + String theDriverList = System.getProperty("jdbc.drivers", null); //$NON-NLS-1$ + if (theDriverList == null) { + return; + } + + /* + * Get the names of the drivers as an array of Strings from the system + * property by splitting the property at the separator character ':' + */ + String[] theDriverNames = theDriverList.split(":"); //$NON-NLS-1$ + + for (String element : theDriverNames) { + try { + // Load the driver class + Class + .forName(element, true, ClassLoader + .getSystemClassLoader()); + } catch (Throwable t) { + // Ignored + } + } + } + + /* + * A private constructor to prevent allocation + */ + private DriverManager() { + super(); + } + + /** + * Removes a driver from the DriverManager's registered driver list. This + * will only succeed where the caller's classloader loaded the driver that + * is to be removed. If the driver was loaded by a different classloader, + * the removal of the driver will fail silently. + * <p> + * If the removal succeeds, the DriverManager will not in future use this + * driver when asked to get a Connection. + * + * @param driver + * @throws SQLException + * if there is an exception accessing the database. + */ + public static void deregisterDriver(Driver driver) throws SQLException { + if (driver == null) { + return; + } +// ClassLoader callerClassLoader = VM.callerClassLoader(); //???SQL VM.callerClassLoader not implemented -> null +// +// if (!DriverManager.isClassFromClassLoader(driver, callerClassLoader)) { +// // sql.1=DriverManager: calling class not authorized to deregister JDBC driver +// throw new SecurityException(Messages.getString("sql.1")); //$NON-NLS-1$ +// } // end if + synchronized (theDriverSet) { + theDriverSet.remove(driver); + } + } + + /** + * Attempts to establish a connection to the given database URL. + * + * @param url + * a URL string representing the database target to connect with + * @return a Connection to the database identified by the URL. null if no + * connection can be made. + * @throws SQLException + * if there is an error while attempting to connect to the + * database identified by the URL + */ + public static Connection getConnection(String url) throws SQLException { + return getConnection(url, new Properties()); + } + + /** + * Attempts to establish a connection to the given database URL. + * + * @param url + * a URL string representing the database target to connect with + * @param info + * a set of Properties to use as arguments to set up the + * connection. Properties are arbitrary string/value pairs. + * Normally, at least the properties "user" and "password" should + * be passed, with appropriate settings for the userid and its + * corresponding password to get access to the database + * concerned. + * @return a Connection to the database identified by the URL. null if no + * connection can be made. + * @throws SQLException + * if there is an error while attempting to connect to the + * database identified by the URL + */ + public static Connection getConnection(String url, Properties info) + throws SQLException { + // 08 - connection exception + // 001 - SQL-client unable to establish SQL-connection + String sqlState = "08001"; //$NON-NLS-1$ + if (url == null) { + // sql.5=The url cannot be null + throw new SQLException(Messages.getString("sql.5"), sqlState); //$NON-NLS-1$ + } + synchronized (theDriverSet) { + /* + * Loop over the drivers in the DriverSet checking to see if one can + * open a connection to the supplied URL - return the first + * connection which is returned + */ + for (Driver theDriver : theDriverSet) { + Connection theConnection = theDriver.connect(url, info); + if (theConnection != null) { + return theConnection; + } + } + } + // If we get here, none of the drivers are able to resolve the URL + // sql.6=No suitable driver + throw new SQLException(Messages.getString("sql.6"), sqlState); //$NON-NLS-1$ + } + + /** + * Attempts to establish a connection to the given database URL. + * + * @param url + * a URL string representing the database target to connect with + * @param user + * a userid used to login to the database + * @param password + * a password for the userid to login to the database + * @return a Connection to the database identified by the URL. null if no + * connection can be made. + * @throws SQLException + * if there is an error while attempting to connect to the + * database identified by the URL + */ + public static Connection getConnection(String url, String user, + String password) throws SQLException { + Properties theProperties = new Properties(); + if(null != user){ + theProperties.setProperty("user", user); //$NON-NLS-1$ + } + if(null != password){ + theProperties.setProperty("password", password); //$NON-NLS-1$ + } + return getConnection(url, theProperties); + } + + /** + * Tries to find a driver that can interpret the supplied URL. + * + * @param url + * the URL of a database + * @return a Driver that can understand the given URL. null if no Driver + * understands the URL + * @throws SQLException + * if there is any kind of Database Access problem + */ + public static Driver getDriver(String url) throws SQLException { +// ClassLoader callerClassLoader = VM.callerClassLoader(); //???SQL VM.callerClassLoader not implemented -> null + + synchronized (theDriverSet) { + /* + * Loop over the drivers in the DriverSet checking to see if one + * does understand the supplied URL - return the first driver which + * does understand the URL + */ + Iterator<Driver> theIterator = theDriverSet.iterator(); + while (theIterator.hasNext()) { + Driver theDriver = theIterator.next(); + if (theDriver.acceptsURL(url) +// && DriverManager.isClassFromClassLoader(theDriver, +// callerClassLoader)) { //???SQL VM.callerClassLoader not implemented -> null + ){ + return theDriver; + } + } + } + // If no drivers understand the URL, throw an SQLException + // sql.6=No suitable driver + //SQLState: 08 - connection exception + //001 - SQL-client unable to establish SQL-connection + throw new SQLException(Messages.getString("sql.6"), "08001"); //$NON-NLS-1$ //$NON-NLS-2$ + } + + /** + * Returns an Enumeration that contains all of the loaded JDBC drivers that + * the current caller can access. + * + * @return An Enumeration containing all the currently loaded JDBC Drivers + */ + public static Enumeration<Driver> getDrivers() { +// ClassLoader callerClassLoader = VM.callerClassLoader(); //???SQL VM.callerClassLoader not implemented -> null + /* + * Synchronize to avoid clashes with additions and removals of drivers + * in the DriverSet + */ + synchronized (theDriverSet) { + /* + * Create the Enumeration by building a Vector from the elements of + * the DriverSet + */ + Vector<Driver> theVector = new Vector<Driver>(); + Iterator<Driver> theIterator = theDriverSet.iterator(); + while (theIterator.hasNext()) { + Driver theDriver = theIterator.next(); +// if (DriverManager.isClassFromClassLoader(theDriver, //???SQL VM.callerClassLoader not implemented -> null +// callerClassLoader)) { + theVector.add(theDriver); +// } + } + return theVector.elements(); + } + } + + /** + * Returns the login timeout when connecting to a database, in seconds. + * + * @return the login timeout in seconds + */ + public static int getLoginTimeout() { + return loginTimeout; + } + + /** + * @deprecated Gets the log PrintStream used by the DriverManager and all + * the JDBC Drivers. + * @return the PrintStream used for logging activity + */ + @Deprecated + public static PrintStream getLogStream() { + return thePrintStream; + } + + /** + * Retrieves the log writer. + * + * @return A PrintWriter object used as the log writer. null if no log + * writer is set. + */ + public static PrintWriter getLogWriter() { + return thePrintWriter; + } + + /** + * Prints a message to the current JDBC log stream. This is either the + * PrintWriter or (deprecated) the PrintStream, if set. + * + * @param message + * the message to print to the JDBC log stream + */ + public static void println(String message) { + if (thePrintWriter != null) { + thePrintWriter.println(message); + thePrintWriter.flush(); + } else if (thePrintStream != null) { + thePrintStream.println(message); + thePrintStream.flush(); + } + /* + * If neither the PrintWriter not the PrintStream are set, then silently + * do nothing the message is not recorded and no exception is generated. + */ + return; + } + + /** + * Registers a given JDBC driver with the DriverManager. + * <p> + * A newly loaded JDBC driver class should register itself with the + * DriverManager by calling this method. + * + * @param driver + * the Driver to register with the DriverManager + * @throws SQLException + * if a database access error occurs. + */ + public static void registerDriver(Driver driver) throws SQLException { + if (driver == null) { + throw new NullPointerException(); + } + synchronized (theDriverSet) { + theDriverSet.add(driver); + } + } + + /** + * Set the login timeout when connecting to a database, in seconds. + * + * @param seconds + * seconds until timeout. 0 indicates wait forever. + */ + public static void setLoginTimeout(int seconds) { + loginTimeout = seconds; + return; + } + + /** + * @deprecated Sets the Print Stream to use for logging data from the + * DriverManager and the JDBC drivers. + * <p> + * Use {@link #setLogWriter} instead. + * @param out + * the PrintStream to use for logging. + */ + @Deprecated + public static void setLogStream(PrintStream out) { + checkLogSecurity(); + thePrintStream = out; + } + + /** + * Sets the PrintWriter that will be used by all loaded drivers, and also + * the DriverManager. + * + * @param out + * the PrintWriter to be used + */ + public static void setLogWriter(PrintWriter out) { + checkLogSecurity(); + thePrintWriter = out; + } + + /* + * Method which checks to see if setting a logging stream is allowed by the + * Security manager + */ + private static void checkLogSecurity() { + SecurityManager securityManager = System.getSecurityManager(); + if (securityManager != null) { + // Throws a SecurityException if setting the log is not permitted + securityManager.checkPermission(logPermission); + } + } + + /** + * Finds if a supplied Object belongs to the given ClassLoader. + * + * @param theObject + * the object to check + * @param theClassLoader + * the ClassLoader + * @return true if the Object does belong to the ClassLoader, false + * otherwise + */ + private static boolean isClassFromClassLoader(Object theObject, + ClassLoader theClassLoader) { + + if ((theObject == null) || (theClassLoader == null)) { + return false; + } + + Class<?> objectClass = theObject.getClass(); + + try { + Class<?> checkClass = Class.forName(objectClass.getName(), true, + theClassLoader); + if (checkClass == objectClass) { + return true; + } + } catch (Throwable t) { + // Empty + } + return false; + } +} diff --git a/sql/src/main/java/java/sql/DriverPropertyInfo.java b/sql/src/main/java/java/sql/DriverPropertyInfo.java new file mode 100644 index 0000000..bf261db --- /dev/null +++ b/sql/src/main/java/java/sql/DriverPropertyInfo.java @@ -0,0 +1,72 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * A class holding information about Driver Properties for making a Connection. + * This class is returned from the <code>Driver.getDriverProperties</code> + * method and is useful in using Connections in an advanced way. + */ +public class DriverPropertyInfo { + + /** + * If the value member can be chosen from a set of possible values, they are + * contained here. Otherwise choices is null. + */ + public String[] choices; + + /** + * A description of the property. May be null. + */ + public String description; + + /** + * The name of the property. + */ + public String name; + + /** + * True when the value member must be provided during Driver.connect. False + * otherwise. + */ + public boolean required; + + /** + * The current value associated with this property. This is based on the + * data gathered by the getPropertyInfo method, the general Java environment + * and the default values for the driver. + */ + public String value; + + /** + * Creates a DriverPropertyInfo instance with the supplied name and value. + * Other members take their default values. + * + * @param name + * The property name + * @param value + * The property value + */ + public DriverPropertyInfo(String name, String value) { + this.name = name; + this.value = value; + this.choices = null; + this.description = null; + this.required = false; + } +} diff --git a/sql/src/main/java/java/sql/ParameterMetaData.java b/sql/src/main/java/java/sql/ParameterMetaData.java new file mode 100644 index 0000000..7d644d3 --- /dev/null +++ b/sql/src/main/java/java/sql/ParameterMetaData.java @@ -0,0 +1,183 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * An interface used to get information about the types and properties of + * parameters in a PreparedStatement object. + */ +public interface ParameterMetaData { + + /** + * Indicates that the parameter mode is IN. + */ + public static final int parameterModeIn = 1; + + /** + * Indicates that the parameter mode is INOUT. + */ + public static final int parameterModeInOut = 2; + + /** + * Indicates that the parameter mode is OUT. + */ + public static final int parameterModeOut = 4; + + /** + * Indicates that the parameter mode is not known. + */ + public static final int parameterModeUnknown = 0; + + /** + * Indicates that a parameter is not permitted to be NULL. + */ + public static final int parameterNoNulls = 0; + + /** + * Indicates that a parameter is permitted to be NULL. + */ + public static final int parameterNullable = 1; + + /** + * Indicates that whether a parameter is allowed to be null or not is not + * known. + */ + public static final int parameterNullableUnknown = 2; + + /** + * Gets the fully-qualified name of the Java class which should be passed as + * a parameter to the method <code>PreparedStatement.setObject</code>. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return a String with the fully qualified Java class name of the + * parameter with the specified index. This class name is used for + * custom mapping. + * @throws SQLException + * if a database error happens + */ + public String getParameterClassName(int paramIndex) throws SQLException; + + /** + * Gets the number of parameters in the PreparedStatement for which this + * ParameterMetaData contains information. + * + * @return the number of parameters as an int + * @throws SQLException + * if a database error happens + */ + public int getParameterCount() throws SQLException; + + /** + * Gets the mode of the specified parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return the parameters mode. Can be: ParameterMetaData.parameterModeIn, + * ParameterMetaData.parameterModeOut, + * ParameterMetaData.parameterModeInOut or + * ParameterMetaData.parameterModeUnknown. + * @throws SQLException + * if a database error happens + */ + public int getParameterMode(int paramIndex) throws SQLException; + + /** + * Gets the SQL type of a specified parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return the type of the parameter - an SQL type as defined in + * java.sql.Types. + * @throws SQLException + * if a database error happens + */ + public int getParameterType(int paramIndex) throws SQLException; + + /** + * Gets the database-specific type name of a specified parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return the type name for the parameter as used by the database. A + * fully-qualified name is returned if the parameter is a User + * Defined Type. + * @throws SQLException + * if a database error happens + */ + public String getParameterTypeName(int paramIndex) throws SQLException; + + /** + * Gets the number of decimal digits for a specified parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return the number of decimal digits ("the precision") for the parameter. + * 0 if the parameter is not a numeric type. + * @throws SQLException + * if a database error happens + */ + public int getPrecision(int paramIndex) throws SQLException; + + /** + * Gets the number of digits after the decimal point for a specified + * parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return the number of digits after the decimal point ("the scale") for + * the parameter. 0 if the parameter is not a numeric type. + * @throws SQLException + * if a database error happens + */ + public int getScale(int paramIndex) throws SQLException; + + /** + * Gets whether null values are allowed for the specified parameter. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return indicator of nullability, can be: + * ParameterMetaData.parameterNoNulls, + * ParameterMetaData.parameterNullable, or + * ParameterMetaData.parameterNullableUnknown + * @throws SQLException + * if a database error is encountered + */ + public int isNullable(int paramIndex) throws SQLException; + + /** + * Gets whether values for the specified parameter can be signed numbers. + * + * @param paramIndex + * the index number of the parameter, where the first parameter + * has an index of 1 + * @return true if values can be signed numbers for this parameter, false + * otherwise. + * @throws SQLException + * if a database error happens + */ + public boolean isSigned(int paramIndex) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/PreparedStatement.java b/sql/src/main/java/java/sql/PreparedStatement.java new file mode 100644 index 0000000..5941200 --- /dev/null +++ b/sql/src/main/java/java/sql/PreparedStatement.java @@ -0,0 +1,631 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Calendar; +import java.net.URL; +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; + +/** + * An interface for a Precompiled SQL Statement. + * <p> + * An SQL Statement is put into a PreparedStatement and is precompiled so that + * it can be executed multiple times efficiently. + * <p> + * Setter methods are supplied in the PreparedStatement interface for the + * setting of IN parameters for the Statement. The setter method used for each + * IN parameter must match the type of the IN parameter being set. + */ +public interface PreparedStatement extends Statement { + + /** + * Add a set of parameters to the PreparedStatement's command batch. + * + * @throws SQLException + * if a database error happens + */ + public void addBatch() throws SQLException; + + /** + * Clear the current parameter values. + * <p> + * Typically, parameter values are retained for multiple executions of the + * Statement. Setting a parameter value replaces the previous value. This + * method clears the values for all parameters, releasing all resources used + * by those parameters. + * + * @throws SQLException + * if a database error happens + */ + public void clearParameters() throws SQLException; + + /** + * Executes the SQL statement in this PreparedStatement. + * <p> + * A PreparedStatement may return multiple results. The execute method + * returns a flag indicating the kind of result produced by + * PreparedStatement. The methods <code> + * getResultSet</code> or + * <code>getUpdateCount</code> are used to retrieve the first result, + * while <code>getMoreResults</code> must be used to retrieve the second + * and subsequent results. + * + * @return true if the result of the execution is a ResultSet, false if + * there is no result or if the result is an update count. + * @throws SQLException + * if a database error happens + */ + public boolean execute() throws SQLException; + + /** + * Execute the SQL query in the PreparedStatement and return the ResultSet + * generated by the query. + * + * @return the ResultSet generated by the query - never null. + * @throws SQLException + * if a database error happens or if the SQL statement does not + * produce a ResultSet. + */ + public ResultSet executeQuery() throws SQLException; + + /** + * Invoke the SQL command contained within the Prepared Statement. This must + * be INSERT, UPDATE, DELETE, or a command that returns nothing. + * + * @return the count of rows for INSERT, UPDATE or DELETE statements, 0 for + * statements that return nothing + * @throws SQLException + * if a database error happens or if the SQL statement returns a + * ResultSet. + */ + public int executeUpdate() throws SQLException; + + /** + * Returns a ResultSetMetaData containing data from the ResultSet that is + * produced when the PreparedStatement is invoked. + * <p> + * It is possible to know the Metadata for the ResultSet without executing + * the PreparedStatement, because the PreparedStatement is precompiled. As a + * result the Metadata can be queried ahead of time without actually + * executing the statement. + * + * @return a ResultSetMetaData object with the information about the columns + * of the ResultSet, if the driver can return a ResultSetMetaData. + * null otherwise. + * @throws SQLException + * if there is a database error + */ + public ResultSetMetaData getMetaData() throws SQLException; + + /** + * Gets information about the parameters of the PreparedStatement. + * + * @return a ParameterMetaData object which holds information about the + * number, type and properties of the parameters of this + * PreparedStatement. + * @throws SQLException + * if a database error happens + */ + public ParameterMetaData getParameterMetaData() throws SQLException; + + /** + * Sets the value of a specified parameter to the supplied Array object. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theArray + * a java.sql.Array holing the data to set. + * @throws SQLException + * if a database error happens + */ + public void setArray(int parameterIndex, Array theArray) + throws SQLException; + + /** + * Sets the value of a specified parameter to the content of a supplied + * InputStream, which has a specified number of bytes. + * <p> + * This is a good method for setting an SQL LONVARCHAR parameter where the + * length of the data is large. Data is read from the InputStream until + * end-of-file is reached or the specified number of bytes is copied. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theInputStream + * the ASCII InputStream carrying the data to update the + * parameter + * @param length + * the number of bytes in the InputStream to copy to the + * parameter + * @throws SQLException + * if a database error happens + */ + public void setAsciiStream(int parameterIndex, InputStream theInputStream, + int length) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied + * java.math.BigDecimal value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theBigDecimal + * the java.math.BigInteger value to set + * @throws SQLException + * if a database error happens + */ + public void setBigDecimal(int parameterIndex, BigDecimal theBigDecimal) + throws SQLException; + + /** + * Sets the value of a specified parameter to the content of a supplied + * binary InputStream, which has a specified number of bytes. + * <p> + * Use this method when a large amount of data needs to be set into a + * LONGVARBINARY parameter. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theInputStream + * the binary InputStream carrying the data to update the + * parameter + * @param length + * the number of bytes in the InputStream to copy to the + * parameter + * @throws SQLException + * if a database error happens + */ + public void setBinaryStream(int parameterIndex, InputStream theInputStream, + int length) throws SQLException; + + /** + * Sets the value of a specified parameter to the given Blob object. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theBlob + * a java.sql.Blob holding the data to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setBlob(int parameterIndex, Blob theBlob) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied boolean value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theBoolean + * the boolean value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setBoolean(int parameterIndex, boolean theBoolean) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied byte value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theByte + * the byte value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setByte(int parameterIndex, byte theByte) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied array of bytes. The + * array is mapped to a VARBINARY or LONGVARBINARY in the database. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theBytes + * the array of bytes to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setBytes(int parameterIndex, byte[] theBytes) + throws SQLException; + + /** + * Sets the value of a specified parameter to the character content of a + * Reader object, with the specified length of character data. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param reader + * the java.io.Reader encompassing the character data + * @param length + * the amount of characters to be read + * @throws SQLException + * if a database error happens + */ + public void setCharacterStream(int parameterIndex, Reader reader, int length) + throws SQLException; + + /** + * Sets the value of a specified parameter to the given Clob object. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theClob + * a java.sql.Clob holding the data to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setClob(int parameterIndex, Clob theClob) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Date + * value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theDate + * a java.sql.Date to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setDate(int parameterIndex, Date theDate) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Date + * value, using a supplied Calendar to map the Date. The Calendar allows the + * application to control the timezone used to compute the SQL DATE in the + * database - without the supplied Calendar, the driver uses the default + * timezone of the Java virtual machine. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theDate + * a java.sql.Date to update the parameter + * @param cal + * a Calendar to use to construct the SQL DATE value + * @throws SQLException + * if a database error happens + */ + public void setDate(int parameterIndex, Date theDate, Calendar cal) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied double value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theDouble + * the double value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setDouble(int parameterIndex, double theDouble) + throws SQLException; + + /** + * Sets the value of a specified parameter to to a supplied float value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theFloat + * the float value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setFloat(int parameterIndex, float theFloat) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied int value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theInt + * the int value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setInt(int parameterIndex, int theInt) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied long value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theLong + * the long value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setLong(int parameterIndex, long theLong) throws SQLException; + + /** + * Sets the value of a specified parameter to SQL NULL. Don't use this + * version of setNull for User Defined Types or for REF type parameters. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param sqlType + * the SQL Type of the parameter, as defined in java.sql.Types + * @throws SQLException + * if a database error happens + */ + public void setNull(int parameterIndex, int sqlType) throws SQLException; + + /** + * Sets the value of a specified parameter to SQL NULL. This version of + * setNull should be used for User Defined Types (UDTs) and also REF types. + * UDTs can be STRUCT, DISTINCT, JAVA_OBJECT and named array types. + * <p> + * Applications must provide the SQL Type code and also a fully qualified + * SQL Type name when supplying a NULL UDT or REF. For a UDT, the type name + * is the type name of the parameter itself, but for a REF parameter the + * type name is the type name of the referenced type. + * + * @param paramIndex + * the parameter number index, where the first parameter has + * index 1 + * @param sqlType + * the SQL Type of the parameter, as defined in java.sql.Types + * @param typeName + * the fully qualified name of a UDT or REF type - ignored if the + * parameter is not a UDT. + * @throws SQLException + * if a database error happens + */ + public void setNull(int paramIndex, int sqlType, String typeName) + throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. + * <p> + * There is a standard mapping from Java types to SQL types, defined in the + * JDBC specification. The passed object is then transformed into the + * appropriate SQL type, and then transferred to the database. setObject can + * be used to pass abstract data types unique to the database, by using a + * JDBC driver specific Java type. If the object's class implements the + * interface SQLData, the JDBC driver calls <code>SQLData.writeSQL</code> + * to write it to the SQL data stream. If the object's class implements Ref, + * Blob, Clob, Struct, or Array, the driver passes it to the database as a + * value of the corresponding SQL type. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theObject + * the Object containing the value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setObject(int parameterIndex, Object theObject) + throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. + * <p> + * The Object is converted to the given targetSqlType before it is sent to + * the database. If the object has a custom mapping (its class implements + * the interface SQLData), the JDBC driver will call the method + * SQLData.writeSQL to write it to the SQL data stream. If the object's + * class implements Ref, Blob, Clob, Struct, or Array, the driver will pass + * it to the database in the form of the relevant SQL type. + * + * @param parameterIndex + * the parameter index, where the first parameter has index 1 + * @param theObject + * the Object containing the value to update the parameter + * @param targetSqlType + * the SQL Type to send to the database, as defined in + * java.sql.Types + * @throws SQLException + * if a database error happens + */ + public void setObject(int parameterIndex, Object theObject, + int targetSqlType) throws SQLException; + + /** + * Sets the value of a specified parameter using a supplied object. + * <p> + * The Object is converted to the given targetSqlType before it is sent to + * the database. If the object has a custom mapping (its class implements + * the interface SQLData), the JDBC driver will call the method + * SQLData.writeSQL to write it to the SQL data stream. If the object's + * class implements Ref, Blob, Clob, Struct, or Array, the driver will pass + * it to the database in the form of the relevant SQL type. + * + * @param parameterIndex + * the parameter index, where the first parameter has index 1 + * @param theObject + * the Object containing the value to update the parameter + * @param targetSqlType + * the SQL Type to send to the database, as defined in + * java.sql.Types + * @param scale + * the number of digits after the decimal point - only applies to + * the types java.sql.Types.DECIMAL and java.sql.Types.NUMERIC - + * ignored for all other types. + * @throws SQLException + * if a database error happens + */ + public void setObject(int parameterIndex, Object theObject, + int targetSqlType, int scale) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied REF(<structured-type>) + * value. This is stored as an SQL REF. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theRef + * a java.sql.Ref value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setRef(int parameterIndex, Ref theRef) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied short value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theShort + * a short value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setShort(int parameterIndex, short theShort) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied String. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theString + * a String value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setString(int parameterIndex, String theString) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Time + * value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theTime + * a java.sql.Time value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setTime(int parameterIndex, Time theTime) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Time + * value, using a supplied Calendar. + * <p> + * The driver uses the supplied Calendar to create the SQL TIME value, which + * allows it to use a custom timezone - otherwise the driver uses the + * default timezone of the Java virtual machine. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theTime + * a java.sql.Time value to update the parameter + * @param cal + * a Calendar to use to construct the SQL TIME value + * @throws SQLException + * if a database error happens + */ + public void setTime(int parameterIndex, Time theTime, Calendar cal) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Timestamp + * value. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theTimestamp + * the java.sql.Timestamp value to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setTimestamp(int parameterIndex, Timestamp theTimestamp) + throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.sql.Timestamp + * value, using the supplied Calendar. + * <p> + * The driver uses the supplied Calendar to create the SQL TIMESTAMP value, + * which allows it to use a custom timezone - otherwise the driver uses the + * default timezone of the Java virtual machine. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theTimestamp + * the java.sql.Timestamp value to update the parameter + * @param cal + * a Calendar to use to construct the SQL TIMESTAMP value + * @throws SQLException + * if a database error happens + */ + public void setTimestamp(int parameterIndex, Timestamp theTimestamp, + Calendar cal) throws SQLException; + + /** + * @deprecated Sets the value of a specified parameter to the characters + * from a supplied InputStream, with a specified number of + * bytes. + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theInputStream + * the InputStream with the character data to update the + * parameter + * @param length + * the number of bytes to read from the InputStream + * @throws SQLException + * if a database error happens + */ + @Deprecated + public void setUnicodeStream(int parameterIndex, + InputStream theInputStream, int length) throws SQLException; + + /** + * Sets the value of a specified parameter to a supplied java.net.URL. + * + * @param parameterIndex + * the parameter number index, where the first parameter has + * index 1 + * @param theURL + * the URL to update the parameter + * @throws SQLException + * if a database error happens + */ + public void setURL(int parameterIndex, URL theURL) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Ref.java b/sql/src/main/java/java/sql/Ref.java new file mode 100644 index 0000000..cc0adf4 --- /dev/null +++ b/sql/src/main/java/java/sql/Ref.java @@ -0,0 +1,79 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Map; + +/** + * A manifestation of the SQL REF type - a reference to an SQL type contained in + * the database. + * <p> + * The SQL REF's are held in a table along with SQL structured types. Every REF + * has an individual identifier for each single instance. The SQL REF is used + * instead of the structured type it references. + * <p> + * A Ref object is stored into the database using the PreparedStatement.setRef + * method. + */ +public interface Ref { + + /** + * Gets the fully-qualified SQL name of the SQL structured type that this + * Ref references. + * + * @return the fully qualified name of the SQL structured type + * @throws SQLException + * if there is a database error + */ + public String getBaseTypeName() throws SQLException; + + /** + * Gets the SQL structured type instance referenced by this Ref. + * + * @return a Java object whose type is defined by the mapping for the SQL + * structured type. + * @throws SQLException + * if there is a database error + */ + public Object getObject() throws SQLException; + + /** + * Returns the associated object and uses the relevant mapping to convert it + * to a Java type. + * + * @param map + * a java.util.Map which contains the mapping to use + * @return a Java object whose type is defined by the mapping for the SQL + * structured type. + * @throws SQLException + * if there is a database error + */ + public Object getObject(Map<String, Class<?>> map) throws SQLException; + + /** + * Sets the value of the structured typethat this Ref references to a + * supplied Object. + * + * @param value + * the Object representing the new SQL structured type that this + * Ref will reference. + * @throws SQLException + * if there is a database error + */ + public void setObject(Object value) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/ResultSet.java b/sql/src/main/java/java/sql/ResultSet.java new file mode 100644 index 0000000..dd2334e --- /dev/null +++ b/sql/src/main/java/java/sql/ResultSet.java @@ -0,0 +1,1870 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.InputStream; +import java.math.BigDecimal; +import java.io.Reader; +import java.util.Calendar; +import java.util.Map; +import java.net.URL; + +/** + * An interface to an Object which represents a Table of Data, typically + * returned as the result of a Query to a Database. + * <p> + * <code>ResultSets</code> have a Cursor which points to a current row of + * data. When a ResultSet is created, the Cursor is positioned before the first + * row. To move the Cursor to the next row in the table, use the + * <code>next</code> method. The next method returns true until there are no + * more rows in the ResultSet, when it returns false. + * <p> + * The default type of ResultSet cannot be updated and its cursor can only move + * forward through the rows of data. This means that it is only possible to read + * through it once. However, it is possible to create types of ResultSet that + * can be updated and also types where the cursor can be scrolled forward and + * backward through the rows of data. This is shown in the following code + * example: <code> + * Connection con; + * Statement aStatement = con.createStatement( ResultSet.TYPE_SCROLL_SENSITIVE, + * ResultSet.CONCUR_UPDATABLE ); + * ResultSet theResultSet = theStatement.executeQuery("SELECT price, quantity FROM STOCKTABLE"); + * // theResultSet will be both scrollable and updateable + * </code> + * <p> + * The ResultSet interface provides a series of methods for retrieving data from + * columns in the current row, such as getDate, getFloat. The columns are + * identified either by their index number (starting at 1) or by their name - + * there are separate methods for both techniques of column addressing. The + * column names are case insensitive. If several columns have the same name, + * then the getter methods use the first matching column. This means that if + * column names are used, it is not possible to guarantee that the name will + * retrieve data from the intended column - for certainty it is better to use + * column indexes. Ideally the columns should be read left-to-right and read + * once only, since not all * databases are optimized to handle other techniques + * of reading the data. + * <p> + * When reading data, the JDBC driver maps the SQL data retrieved from the + * database to the Java type implied by the method invoked by the application. + * The JDBC specification has a table of allowable mappings from SQL types to + * Java types. + * <p> + * There are also methods for writing data into the ResultSet, such as + * updateInt, updateString. The update methods can be used either to modify the + * data of an existing row or to insert new data rows into the ResultSet. + * Modification of existing data involves moving the Cursor to the row which + * needs modification and then using the update methods to modify the data, + * followed by calling the ResultSet.updateRow method. For insertion of new + * rows, the cursor is first moved to a special row called the Insert Row, data + * is added using the update methods, followed by calling the + * ResultSet.insertRow method. + * <p> + * A ResultSet is closed if the Statement object which generated it closed, + * executed again or is used to retrieve the next result from a sequence of + * results. + * + */ +public interface ResultSet { + + /** + * A constant used to indicate that a ResultSet object must be closed when + * the method Connection.commit is invoked. + */ + public static final int CLOSE_CURSORS_AT_COMMIT = 2; + + /** + * A constant used to indicate that a ResultSet object must not be closed + * when the method Connection.commit is invoked. + */ + public static final int HOLD_CURSORS_OVER_COMMIT = 1; + + /** + * A constant used to indicate the Concurrency Mode for a ResultSet object + * that cannot be updated. + */ + public static final int CONCUR_READ_ONLY = 1007; + + /** + * A constant used to indicate the Concurrency Mode for a ResultSet object + * that can be updated. + */ + public static final int CONCUR_UPDATABLE = 1008; + + /** + * A constant used to indicate processing of the rows of a ResultSet in the + * forward direction, first to last + */ + public static final int FETCH_FORWARD = 1000; + + /** + * A constant used to indicate processing of the rows of a ResultSet in the + * reverse direction, last to first + */ + public static final int FETCH_REVERSE = 1001; + + /** + * A constant used to indicate that the order of processing of the rows of a + * ResultSet is unknown. + */ + public static final int FETCH_UNKNOWN = 1002; + + /** + * A constant used to indicate a ResultSet object whose Cursor can only move + * forward + */ + public static final int TYPE_FORWARD_ONLY = 1003; + + /** + * A constant used to indicate a ResultSet object which is Scrollable but + * which is not sensitive to changes made by others + */ + public static final int TYPE_SCROLL_INSENSITIVE = 1004; + + /** + * A constant used to indicate a ResultSet object which is Scrollable but + * which is sensitive to changes made by others + */ + public static final int TYPE_SCROLL_SENSITIVE = 1005; + + /** + * Moves the Cursor to a specified row number in the ResultSet. + * + * @param row + * The new row number for the Cursor + * @return true if the new Cursor position is on the ResultSet, false + * otherwise + * @throws SQLException + * if a database error happens + */ + public boolean absolute(int row) throws SQLException; + + /** + * Moves the Cursor to the end of the ResultSet, after the last row. + * + * @throws SQLException + * if a database error happens + */ + public void afterLast() throws SQLException; + + /** + * Moves the Cursor to the start of the ResultSet, before the first row. + * + * @throws SQLException + * if a database error happens + */ + public void beforeFirst() throws SQLException; + + /** + * Cancels any updates made to the current row in the ResultSet. + * + * @throws SQLException + * if a database error happens + */ + public void cancelRowUpdates() throws SQLException; + + /** + * Clears all the warnings related to this ResultSet. + * + * @throws SQLException + * if a database error happens + */ + public void clearWarnings() throws SQLException; + + /** + * Releases this ResultSet's database and JDBC resources. You are strongly + * advised to use this method rather than relying on the release being done + * when the ResultSet's finalize method is called during garbage collection + * process. Note that the close() method might take some time to complete + * since it is dependent on the behaviour of the connection to the database + * and the database itself. + * + * @throws SQLException + * if a database error happens + */ + public void close() throws SQLException; + + /** + * Deletes the current row from the ResultSet and from the underlying + * database. + * + * @throws SQLException + * if a database error happens + */ + public void deleteRow() throws SQLException; + + /** + * Gets the index number for a column in the ResultSet from the provided + * Column Name. + * + * @param columnName + * the column name + * @return the index of the column in the ResultSet for the column name + * @throws SQLException + * if a database error happens + */ + public int findColumn(String columnName) throws SQLException; + + /** + * Shifts the cursor position to the first row in the ResultSet. + * + * @return true if the position is in a legitimate row, false if the + * ResultSet contains no rows. + * @throws SQLException + * if a database error happens + */ + public boolean first() throws SQLException; + + /** + * Gets the content of a column specified as a column index in the current + * row of this ResultSet as a java.sql.Array. + * + * @param columnIndex + * the index of the column to read + * @return a java.sql.Array with the data from the column + * @throws SQLException + * if a database error happens + */ + public Array getArray(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a + * java.sql.Array. + * + * @param colName + * the name of the column to read + * @return a java.sql.Array with the data from the column + * @throws SQLException + * if a database error happens + */ + public Array getArray(String colName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as an ASCII + * character stream. + * + * @param columnIndex + * the index of the column to read + * @return an InputStream with the data from the column + * @throws SQLException + * if a database error happens + */ + public InputStream getAsciiStream(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as an ASCII + * character stream. + * + * @param columnName + * the name of the column to read + * @return an InputStream with the data from the column + * @throws SQLException + * if a database error happens + */ + public InputStream getAsciiStream(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.math.BigDecimal. + * + * @param columnIndex + * the index of the column to read + * @return a BigDecimal with the value of the column + * @throws SQLException + * if a database error happens + */ + public BigDecimal getBigDecimal(int columnIndex) throws SQLException; + + /** + * @deprecated Gets the value of a column specified as a column index as a + * java.math.BigDecimal. + * @param columnIndex + * the index of the column to read + * @param scale + * the number of digits after the decimal point + * @return a BigDecimal with the value of the column + * @throws SQLException + * if a database error happens + */ + @Deprecated + public BigDecimal getBigDecimal(int columnIndex, int scale) + throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a + * java.math.BigDecimal. + * + * @param columnName + * the name of the column to read + * @return a BigDecimal with the value of the column + * @throws SQLException + * if a database error happens + */ + public BigDecimal getBigDecimal(String columnName) throws SQLException; + + /** + * @deprecated Gets the value of a column specified as a column name, as a + * java.math.BigDecimal. + * @param columnName + * the name of the column to read + * @param scale + * the number of digits after the decimal point + * @return a BigDecimal with the value of the column + * @throws SQLException + * if a database error happens + */ + @Deprecated + public BigDecimal getBigDecimal(String columnName, int scale) + throws SQLException; + + /** + * Gets the value of a column specified as a column index as a binary + * stream. + * <p> + * This method can be used to read LONGVARBINARY values. All of the data in + * the InputStream should be read before getting data from any other column. + * A further call to a getter method will implicitly close the InputStream. + * + * @param columnIndex + * the index of the column to read + * @return an InputStream with the data from the column. If the column value + * is SQL NULL, null is returned. + * @throws SQLException + * if a database error happens + */ + public InputStream getBinaryStream(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a binary stream. + * <p> + * This method can be used to read LONGVARBINARY values. All of the data in + * the InputStream should be read before getting data from any other column. + * A further call to a getter method will implicitly close the InputStream. + * + * @param columnName + * the name of the column to read + * @return an InputStream with the data from the column If the column value + * is SQL NULL, null is returned. + * @throws SQLException + * if a database error happens + */ + public InputStream getBinaryStream(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a java.sql.Blob + * object. + * + * @param columnIndex + * the index of the column to read + * @return a java.sql.Blob with the value of the column + * @throws SQLException + * if a database error happens + */ + public Blob getBlob(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a java.sql.Blob + * object. + * + * @param columnName + * the name of the column to read + * @return a java.sql.Blob with the value of the column + * @throws SQLException + * if a database error happens + */ + public Blob getBlob(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a boolean. + * + * @param columnIndex + * the index of the column to read + * @return a boolean value from the column. If the column is SQL NULL, false + * is returned. + * @throws SQLException + * if a database error happens + */ + public boolean getBoolean(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a boolean. + * + * @param columnName + * the name of the column to read + * @return a boolean value from the column. If the column is SQL NULL, false + * is returned. + * @throws SQLException + * if a database error happens + */ + public boolean getBoolean(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a byte. + * + * @param columnIndex + * the index of the column to read + * @return a byte containing the value of the column. 0 if the value is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public byte getByte(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a byte. + * + * @param columnName + * the name of the column to read + * @return a byte containing the value of the column. 0 if the value is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public byte getByte(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a byte array. + * + * @param columnIndex + * the index of the column to read + * @return a byte array containing the value of the column. null if the + * column contains SQL NULL. + * @throws SQLException + * if a database error happens + */ + public byte[] getBytes(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a byte array. + * + * @param columnName + * the name of the column to read + * @return a byte array containing the value of the column. null if the + * column contains SQL NULL. + * @throws SQLException + * if a database error happens + */ + public byte[] getBytes(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.io.Reader object. + * + * @param columnIndex + * the index of the column to read + * @return a Reader holding the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Reader getCharacterStream(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a java.io.Reader + * object. + * + * @param columnName + * the name of the column to read + * @return a Reader holding the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Reader getCharacterStream(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.sql.Clob. + * + * @param columnIndex + * the index of the column to read + * @return a Clob object representing the value in the column. null if the + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Clob getClob(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a java.sql.Clob. + * + * @param colName + * the name of the column to read + * @return a Clob object representing the value in the column. null if the + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Clob getClob(String colName) throws SQLException; + + /** + * Gets the concurrency mode of this ResultSet. + * + * @return the concurrency mode - one of: ResultSet.CONCUR_READ_ONLY, + * ResultSet.CONCUR_UPDATABLE + * @throws SQLException + * if a database error happens + */ + public int getConcurrency() throws SQLException; + + /** + * Gets the name of the SQL cursor of this ResultSet. + * + * @return a String containing the SQL cursor name + * @throws SQLException + * if a database error happens + */ + public String getCursorName() throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.sql.Date. + * + * @param columnIndex + * the index of the column to read + * @return a java.sql.Date matching the column value. null if the column is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.sql.Date. This method uses a supplied calendar to compute the Date. + * + * @param columnIndex + * the index of the column to read + * @param cal + * a java.util.Calendar to use in constructing the Date. + * @return a java.sql.Date matching the column value. null if the column is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(int columnIndex, Calendar cal) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a java.sql.Date. + * + * @param columnName + * the name of the column to read + * @return a java.sql.Date matching the column value. null if the column is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a java.sql.Date + * object. + * + * @param columnName + * the name of the column to read + * @param cal + * java.util.Calendar to use in constructing the Date. + * @return a java.sql.Date matching the column value. null if the column is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Date getDate(String columnName, Calendar cal) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a double value. + * + * @param columnIndex + * the index of the column to read + * @return a double containing the column value. 0.0 if the column is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public double getDouble(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a double value. + * + * @param columnName + * the name of the column to read + * @return a double containing the column value. 0.0 if the column is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public double getDouble(String columnName) throws SQLException; + + /** + * Gets the direction in which rows are fetched for this ResultSet object. + * + * @return the fetch direction. Will be: ResultSet.FETCH_FORWARD, + * ResultSet.FETCH_REVERSE or ResultSet.FETCH_UNKNOWN + * @throws SQLException + * if a database error happens + */ + public int getFetchDirection() throws SQLException; + + /** + * Gets the fetch size (in number of rows) for this ResultSet + * + * @return the fetch size as an int + * @throws SQLException + * if a database error happens + */ + public int getFetchSize() throws SQLException; + + /** + * Gets the value of a column specified as a column index as a float value. + * + * @param columnIndex + * the index of the column to read + * @return a float containing the column value. 0.0 if the column is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public float getFloat(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a float value. + * + * @param columnName + * the name of the column to read + * @return a float containing the column value. 0.0 if the column is SQL + * NULL. + * @throws SQLException + * if a database error happens + */ + public float getFloat(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as an int value. + * + * @param columnIndex + * the index of the column to read + * @return an int containing the column value. 0 if the column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public int getInt(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as an int value. + * + * @param columnName + * the name of the column to read + * @return an int containing the column value. 0 if the column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public int getInt(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a long value. + * + * @param columnIndex + * the index of the column to read + * @return a long containing the column value. 0 if the column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public long getLong(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a long value. + * + * @param columnName + * the name of the column to read + * @return a long containing the column value. 0 if the column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public long getLong(String columnName) throws SQLException; + + /** + * Gets the Metadata for this ResultSet. This defines the number, types and + * properties of the columns in the ResultSet. + * + * @return a ResultSetMetaData object with information about this ResultSet. + * @throws SQLException + * if a database error happens + */ + public ResultSetMetaData getMetaData() throws SQLException; + + /** + * Gets the value of a specified column as a Java Object. The type of the + * returned object will be the default according to the column's SQL type, + * following the JDBC specification for built-in types. + * <p> + * For SQL User Defined Types, if a column value is Structured or Distinct, + * this method behaves the same as a call to: getObject(columnIndex, + * this.getStatement().getConnection().getTypeMap()) + * + * @param columnIndex + * the index of the column to read + * @return an Object containing the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Object getObject(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a Java Object. + * <p> + * The type of the Java object will be determined by the supplied Map to + * perform the mapping of SQL Struct or Distinct types into Java objects. + * + * @param columnIndex + * the index of the column to read + * @param map + * a java.util.Map containing a mapping from SQL Type names to + * Java classes. + * @return an Object containing the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Object getObject(int columnIndex, Map<String, Class<?>> map) + throws SQLException; + + /** + * Gets the value of a specified column as a Java Object. The type of the + * returned object will be the default according to the column's SQL type, + * following the JDBC specification for built-in types. + * <p> + * For SQL User Defined Types, if a column value is Structured or Distinct, + * this method behaves the same as a call to: getObject(columnIndex, + * this.getStatement().getConnection().getTypeMap()) + * + * @param columnName + * the name of the column to read + * @return an Object containing the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Object getObject(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a Java Object. + * <p> + * The type of the Java object will be determined by the supplied Map to + * perform the mapping of SQL Struct or Distinct types into Java objects. + * + * @param columnName + * the name of the column to read + * @param map + * a java.util.Map containing a mapping from SQL Type names to + * Java classes. + * @return an Object containing the value of the column. null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Object getObject(String columnName, Map<String, Class<?>> map) + throws SQLException; + + /** + * Gets the value of a column specified as a column index as a Java + * java.sql.Ref. + * + * @param columnIndex + * the index of the column to read + * @return a Ref representing the value of the SQL REF in the column + * @throws SQLException + * if a database error happens + */ + public Ref getRef(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a Java + * java.sql.Ref. + * + * @param colName + * the name of the column to read + * @return a Ref representing the value of the SQL REF in the column + * @throws SQLException + * if a database error happens + */ + public Ref getRef(String colName) throws SQLException; + + /** + * Gets the number of the current row in the ResultSet. Row numbers start at + * 1 for the first row. + * + * @return the index number of the current row. 0 is returned if there is no + * current row. + * @throws SQLException + * if a database error happens + */ + public int getRow() throws SQLException; + + /** + * Gets the value of a column specified as a column index as a short value. + * + * @param columnIndex + * the index of the column to read + * @return a short value containing the value of the column. 0 if the value + * is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public short getShort(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a short value. + * + * @param columnName + * the name of the column to read + * @return a short value containing the value of the column. 0 if the value + * is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public short getShort(String columnName) throws SQLException; + + /** + * Gets the Statement that produced this ResultSet. If the ResultSet was not + * created by a Statement (eg it was returned from one of the + * DatabaseMetaData methods), null is returned. + * + * @return the Statement which produced this ResultSet, or null if the + * ResultSet was not created by a Statement. + * @throws SQLException + */ + public Statement getStatement() throws SQLException; + + /** + * Gets the value of a column specified as a column index as a String. + * + * @param columnIndex + * the index of the column to read + * @return the String representing the value of the column, null if the + * column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public String getString(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a String. + * + * @param columnName + * the name of the column to read + * @return the String representing the value of the column, null if the + * column is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public String getString(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a java.sql.Time + * value. + * + * @param columnIndex + * the index of the column to read + * @return a Time representing the column value, null if the column value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a java.sql.Time + * value. The supplied Calendar is used to map between the SQL Time value + * and the Java Time value. + * + * @param columnIndex + * the index of the column to read + * @param cal + * a Calendar to use in creating the Java Time value. + * @return a Time representing the column value, null if the column value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(int columnIndex, Calendar cal) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a java.sql.Time + * value. + * + * @param columnName + * the name of the column to read + * @return a Time representing the column value, null if the column value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index, as a + * java.sql.Time value. The supplied Calendar is used to map between the SQL + * Time value and the Java Time value. + * + * @param columnName + * the name of the column to read + * @param cal + * a Calendar to use in creating the Java Time value. + * @return a Time representing the column value, null if the column value is + * SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Time getTime(String columnName, Calendar cal) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a + * java.sql.Timestamp value. + * + * @param columnIndex + * the index of the column to read + * @return a Timestamp representing the column value, null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column index, as a + * java.sql.Timestamp value. The supplied Calendar is used to map between + * the SQL Timestamp value and the Java Timestamp value. + * + * @param columnIndex + * the index of the column to read + * @param cal + * Calendar to use in creating the Java Timestamp value. + * @return a Timestamp representing the column value, null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(int columnIndex, Calendar cal) + throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a + * java.sql.Timestamp value. + * + * @param columnName + * the name of the column to read + * @return a Timestamp representing the column value, null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column name, as a + * java.sql.Timestamp value. The supplied Calendar is used to map between + * the SQL Timestamp value and the Java Timestamp value. + * + * @param columnName + * the name of the column to read + * @param cal + * Calendar to use in creating the Java Timestamp value. + * @return a Timestamp representing the column value, null if the column + * value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public Timestamp getTimestamp(String columnName, Calendar cal) + throws SQLException; + + /** + * Gets the type of the ResultSet. + * + * @return The ResultSet type, one of: ResultSet.TYPE_FORWARD_ONLY, + * ResultSet.TYPE_SCROLL_INSENSITIVE, or + * ResultSet.TYPE_SCROLL_SENSITIVE + * @throws SQLException + * if there is a database error + */ + public int getType() throws SQLException; + + /** + * @deprecated Use {@link #getCharacterStream}. + * <p> + * Gets the value of the column as an InputStream of Unicode + * characters. + * @param columnIndex + * the index of the column to read + * @return an InputStream holding the value of the column. null if the + * column value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + @Deprecated + public InputStream getUnicodeStream(int columnIndex) throws SQLException; + + /** + * @deprecated Use {@link #getCharacterStream} + * <p> + * Gets the value of the column as an InputStream of Unicode + * characters. + * @param columnName + * the name of the column to read + * @return an InputStream holding the value of the column. null if the + * column value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + @Deprecated + public InputStream getUnicodeStream(String columnName) throws SQLException; + + /** + * Gets the value of a column specified as a column index as a java.net.URL. + * + * @param columnIndex + * the index of the column to read + * @return a URL. null if the column value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public URL getURL(int columnIndex) throws SQLException; + + /** + * Gets the value of a column specified as a column name as a java.net.URL + * object. + * + * @param columnName + * the name of the column to read + * @return a URL. null if the column value is SQL NULL. + * @throws SQLException + * if a database error happens + */ + public URL getURL(String columnName) throws SQLException; + + /** + * Gets the first warning generated by calls on this ResultSet. Subsequent + * warnings on this ResultSet are chained to the first one. + * <p> + * The warnings are cleared when a new Row is read from the ResultSet. The + * warnings returned by this method are only the warnings generated by + * ResultSet method calls - warnings generated by Statement methods are held + * by the Statement. + * <p> + * An SQLException is generated if this method is called on a closed + * ResultSet. + * + * @return an SQLWarning which is the first warning for this ResultSet. null + * if there are no warnings. + * @throws SQLException + * if a database error happens + */ + public SQLWarning getWarnings() throws SQLException; + + /** + * Insert the insert row into the ResultSet and into the underlying + * database. The Cursor must be set to the Insert Row before this method is + * invoked. + * + * @throws SQLException + * if a database error happens. Particular cases include the + * Cursor not being on the Insert Row or if any Columns in the + * Row do not have a value where the column is declared as + * not-nullable. + */ + public void insertRow() throws SQLException; + + /** + * Gets if the cursor is after the last row of the ResultSet. + * + * @return true if the Cursor is after the last Row in the ResultSet, false + * if the cursor is at any other position in the ResultSet. + * @throws SQLException + * if a database error happens + */ + public boolean isAfterLast() throws SQLException; + + /** + * Gets if the cursor is before the first row of the ResultSet. + * + * @return true if the Cursor is before the last Row in the ResultSet, false + * if the cursor is at any other position in the ResultSet. + * @throws SQLException + * if a database error happens + */ + public boolean isBeforeFirst() throws SQLException; + + /** + * Gets if the cursor is on the first row of the ResultSet. + * + * @return true if the Cursor is on the first Row in the ResultSet, false if + * the cursor is at any other position in the ResultSet. + * @throws SQLException + * if a database error happens + */ + public boolean isFirst() throws SQLException; + + /** + * Gets if the cursor is on the last row of the ResultSet + * + * @return true if the Cursor is on the last Row in the ResultSet, false if + * the cursor is at any other position in the ResultSet. + * @throws SQLException + */ + public boolean isLast() throws SQLException; + + /** + * Shifts the cursor position to the last row of the ResultSet. + * + * @return true if the new position is in a legitimate row, false if the + * ResultSet contains no rows. + * @throws SQLException + * if there is a database error + */ + public boolean last() throws SQLException; + + /** + * Moves the cursor to the remembered position, usually the current row. + * This only applies if the cursor is on the Insert row. + * + * @throws SQLException + * if a database error happens + */ + public void moveToCurrentRow() throws SQLException; + + /** + * Moves the cursor position to the Insert row. The current position is + * remembered and the cursor is positioned at the Insert row. The columns in + * the Insert row should be filled in with the appropriate update methods, + * before calling <code>insertRow</code> to insert the new row into the + * database. + * + * @throws SQLException + * if a database error happens + */ + public void moveToInsertRow() throws SQLException; + + /** + * Shifts the cursor position down one row in this ResultSet object. + * <p> + * Any InputStreams associated with the current row are closed and any + * warnings are cleared. + * + * @return true if the updated cursor position is pointing to a valid row, + * false otherwise (ie when the cursor is after the last row in the + * ResultSet). + * @throws SQLException + * if a database error happens + */ + public boolean next() throws SQLException; + + /** + * Relocates the cursor position to the preceding row in this ResultSet. + * + * @return true if the new position is in a legitimate row, false if the + * cursor is now before the first row. + * @throws SQLException + * if a database error happens + */ + public boolean previous() throws SQLException; + + /** + * Refreshes the current row with its most up to date value in the database. + * Must not be called when the cursor is on the Insert row. + * <p> + * If any columns in the current row have been updated but the + * <code>updateRow</code> has not been called, then the updates are lost + * when this method is called. + * + * @throws SQLException + * if a database error happens, including if the current row is + * the Insert row. + */ + public void refreshRow() throws SQLException; + + /** + * Moves the cursor position up or down by a specified number of rows. If + * the new position is beyond the start or end rows, the cursor position is + * set before the first row/after the last row. + * + * @param rows + * a number of rows to move the cursor - may be positive or + * negative + * @return true if the new cursor position is on a row, false otherwise + * @throws SQLException + * if a database error happens + */ + public boolean relative(int rows) throws SQLException; + + /** + * Indicates whether a row has been deleted. This method depends on whether + * the JDBC driver and database can detect deletions. + * + * @return true if a row has been deleted and if deletions are detected, + * false otherwise. + * @throws SQLException + * if a database error happens + */ + public boolean rowDeleted() throws SQLException; + + /** + * Indicates whether the current row has had an insertion operation. This + * method depends on whether the JDBC driver and database can detect + * insertions. + * + * @return true if a row has been inserted and if insertions are detected, + * false otherwise. + * @throws SQLException + * if a database error happens + */ + public boolean rowInserted() throws SQLException; + + /** + * Indicates whether the current row has been updated. This method depends + * on whether the JDBC driver and database can detect updates. + * + * @return true if the current row has been updated and if updates can be + * detected, false otherwise. + * @throws SQLException + * if a database error happens + */ + public boolean rowUpdated() throws SQLException; + + /** + * Indicates which direction (forward/reverse) will be used to process the + * rows of this ResultSet object. This is treated as a hint by the JDBC + * driver. + * + * @param direction + * can be ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or + * ResultSet.FETCH_UNKNOWN + * @throws SQLException + * if there is a database error + */ + public void setFetchDirection(int direction) throws SQLException; + + /** + * Indicates the amount of rows to fetch from the database when extra rows + * are required for this ResultSet. This used as a hint to the JDBC driver. + * + * @param rows + * the number of rows to fetch. 0 implies that the JDBC driver + * can make its own decision about the fetch size. The number + * should not be greater than the maximum number of rows + * established by the Statement that generated the ResultSet. + * @throws SQLException + * if a database error happens + */ + public void setFetchSize(int rows) throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.Array value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateArray(int columnIndex, Array x) throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.Array value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateArray(String columnName, Array x) throws SQLException; + + /** + * Updates a column specified by a column index with an ASCII stream value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @param length + * the length of the data to write from the stream + * @throws SQLException + * if a database error happens + */ + public void updateAsciiStream(int columnIndex, InputStream x, int length) + throws SQLException; + + /** + * Updates a column specified by a column name with an Ascii stream value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @param length + * the length of the data to write from the stream + * @throws SQLException + * if a database error happens + */ + public void updateAsciiStream(String columnName, InputStream x, int length) + throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.BigDecimal + * value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBigDecimal(int columnIndex, BigDecimal x) + throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.BigDecimal + * value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBigDecimal(String columnName, BigDecimal x) + throws SQLException; + + /** + * Updates a column specified by a column index with a binary stream value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @param length + * @throws SQLException + * if a database error happens + */ + public void updateBinaryStream(int columnIndex, InputStream x, int length) + throws SQLException; + + /** + * Updates a column specified by a column name with a binary stream value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @param length + * @throws SQLException + * if a database error happens + */ + public void updateBinaryStream(String columnName, InputStream x, int length) + throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.Blob value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBlob(int columnIndex, Blob x) throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.Blob value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBlob(String columnName, Blob x) throws SQLException; + + /** + * Updates a column specified by a column index with a boolean value. + * + * @param columnIndex + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBoolean(int columnIndex, boolean x) throws SQLException; + + /** + * Updates a column specified by a column name with a boolean value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBoolean(String columnName, boolean x) throws SQLException; + + /** + * Updates a column specified by a column index with a byte value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateByte(int columnIndex, byte x) throws SQLException; + + /** + * Updates a column specified by a column name with a byte value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateByte(String columnName, byte x) throws SQLException; + + /** + * Updates a column specified by a column index with a byte array value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBytes(int columnIndex, byte[] x) throws SQLException; + + /** + * Updates a column specified by a column name with a byte array value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateBytes(String columnName, byte[] x) throws SQLException; + + /** + * Updates a column specified by a column index with a character stream + * value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @param length + * the length of data to write from the stream + * @throws SQLException + * if a database error happens + */ + public void updateCharacterStream(int columnIndex, Reader x, int length) + throws SQLException; + + /** + * Updates a column specified by a column name with a character stream + * value. + * + * @param columnName + * the name of the column to update + * @param reader + * the new value for the specified column + * @param length + * the length of data to write from the Reader + * @throws SQLException + * if a database error happens + */ + public void updateCharacterStream(String columnName, Reader reader, + int length) throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.Clob value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateClob(int columnIndex, Clob x) throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.Clob value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateClob(String columnName, Clob x) throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.Date value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateDate(int columnIndex, Date x) throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.Date value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateDate(String columnName, Date x) throws SQLException; + + /** + * Updates a column specified by a column index with a double value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateDouble(int columnIndex, double x) throws SQLException; + + /** + * Updates a column specified by a column name with a double value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateDouble(String columnName, double x) throws SQLException; + + /** + * Updates a column specified by a column index with a float value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateFloat(int columnIndex, float x) throws SQLException; + + /** + * Updates a column specified by a column name with a float value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateFloat(String columnName, float x) throws SQLException; + + /** + * Updates a column specified by a column index with an int value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateInt(int columnIndex, int x) throws SQLException; + + /** + * Updates a column specified by a column name with an int value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateInt(String columnName, int x) throws SQLException; + + /** + * Updates a column specified by a column index with a long value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateLong(int columnIndex, long x) throws SQLException; + + /** + * Updates a column specified by a column name with a long value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateLong(String columnName, long x) throws SQLException; + + /** + * Updates a column specified by a column index with a null value. + * + * @param columnIndex + * the index of the column to update + * @throws SQLException + * if a database error happens + */ + public void updateNull(int columnIndex) throws SQLException; + + /** + * Updates a column specified by a column name with a null value. + * + * @param columnName + * the name of the column to update + * @throws SQLException + * if a database error happens + */ + public void updateNull(String columnName) throws SQLException; + + /** + * Updates a column specified by a column index with an Object value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateObject(int columnIndex, Object x) throws SQLException; + + /** + * Updates a column specified by a column index with an Object value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @param scale + * for the types java.sql.Types.DECIMAL or + * java.sql.Types.NUMERIC, this specifies the number of digits + * after the decimal point. + * @throws SQLException + * if a database error happens + */ + public void updateObject(int columnIndex, Object x, int scale) + throws SQLException; + + /** + * Updates a column specified by a column name with an Object value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateObject(String columnName, Object x) throws SQLException; + + /** + * Updates a column specified by a column name with an Object value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @param scale + * for the types java.sql.Types.DECIMAL or + * java.sql.Types.NUMERIC, this specifies the number of digits + * after the decimal point. + * @throws SQLException + * if a database error happens + */ + public void updateObject(String columnName, Object x, int scale) + throws SQLException; + + /** + * Updates a column specified by a column index with a java.sql.Ref value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateRef(int columnIndex, Ref x) throws SQLException; + + /** + * Updates a column specified by a column name with a java.sql.Ref value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateRef(String columnName, Ref x) throws SQLException; + + /** + * Updates the database with the new contents of the current row of this + * ResultSet object. + * + * @throws SQLException + */ + public void updateRow() throws SQLException; + + /** + * Updates a column specified by a column index with a short value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateShort(int columnIndex, short x) throws SQLException; + + /** + * Updates a column specified by a column name with a short value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateShort(String columnName, short x) throws SQLException; + + /** + * Updates a column specified by a column index with a String value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateString(int columnIndex, String x) throws SQLException; + + /** + * Updates a column specified by a column name with a String value. + * + * @param columnName + * the name of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateString(String columnName, String x) throws SQLException; + + /** + * Updates a column specified by a column index with a Time value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateTime(int columnIndex, Time x) throws SQLException; + + /** + * Updates a column specified by a column name with a Time value. + * + * @param columnName + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateTime(String columnName, Time x) throws SQLException; + + /** + * Updates a column specified by a column index with a Timestamp value. + * + * @param columnIndex + * the index of the column to update + * @param x + * the new value for the specified column + * @throws SQLException + * if a database error happens + */ + public void updateTimestamp(int columnIndex, Timestamp x) + throws SQLException; + + /** + * Updates a column specified by column name with a Timestamp value. + * + * @param columnName + * the name of the column to update + * @param x + * @throws SQLException + * if a database error happens + */ + public void updateTimestamp(String columnName, Timestamp x) + throws SQLException; + + /** + * Determines if the last column read from this ResultSet contained SQL + * NULL. + * + * @return true if the last column contained SQL NULL, false otherwise + * @throws SQLException + * if a database error happens + */ + public boolean wasNull() throws SQLException; +} diff --git a/sql/src/main/java/java/sql/ResultSetMetaData.java b/sql/src/main/java/java/sql/ResultSetMetaData.java new file mode 100644 index 0000000..d530d11 --- /dev/null +++ b/sql/src/main/java/java/sql/ResultSetMetaData.java @@ -0,0 +1,277 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * Provides information about the columns in a ResultSet. + */ +public interface ResultSetMetaData { + + /** + * Indicates that a column cannot contain NULL values + */ + public static final int columnNoNulls = 0; + + /** + * Indicates that a column can contain NULL values + */ + public static final int columnNullable = 1; + + /** + * Indicates that it is unknown whether a column can contain NULLs or not + */ + public static final int columnNullableUnknown = 2; + + /** + * Returns the title of indexed columns catalog + * + * @param column + * the column index, starting at 1 + * @return the catalog title + * @throws SQLException + * if there is a database error + */ + public String getCatalogName(int column) throws SQLException; + + /** + * Returns the fully-qualified type of the class that is produced when + * invoking ResultSet.getObject to recover this columns value. + * + * @param column + * the column index, starting at 1 + * @return the fully-qualified class name + * @throws SQLException + * if there is a database error + */ + public String getColumnClassName(int column) throws SQLException; + + /** + * Returns a count of the columns in this set of results. + * + * @return the column count + * @throws SQLException + * if there is a database error + */ + public int getColumnCount() throws SQLException; + + /** + * Returns the indexed column's standard maximum width, expressed in number + * of characters. + * + * @param column + * the column index, starting at 1 + * @return the column's max width + * @throws SQLException + * if there is a database error + */ + public int getColumnDisplaySize(int column) throws SQLException; + + /** + * Returns a recommended title for the indexed column, to be used when the + * title needs to be displayed. + * + * @param column + * the column index, starting at 1 + * @return the column's title + * @throws SQLException + * if there is a database error + */ + public String getColumnLabel(int column) throws SQLException; + + /** + * Returns the title of the indexed column + * + * @param column + * the column index, starting at 1 + * @return the column title + * @throws SQLException + * if there is a database error + */ + public String getColumnName(int column) throws SQLException; + + /** + * Returns the type of the indexed column + * + * @param column + * the column index, starting at 1 + * @return the column type + * @throws SQLException + * if there is a database error + */ + public int getColumnType(int column) throws SQLException; + + /** + * Returns the type name of the indexed column + * + * @param column + * the column index, starting at 1 + * @return the type name + * @throws SQLException + * if there is a database error + */ + public String getColumnTypeName(int column) throws SQLException; + + /** + * Returns the decimal precision of the indexed column + * + * @param column + * the column index, starting at 1 + * @return the precision + * @throws SQLException + * if there is a database error + */ + public int getPrecision(int column) throws SQLException; + + /** + * Returns the number of decimal places in the indexed column. + * + * @param column + * the column index, starting at 1 + * @return number of decimal places + * @throws SQLException + * if there is a database error + */ + public int getScale(int column) throws SQLException; + + /** + * Returns the name of the indexed columns schema + * + * @param column + * the column index, starting at 1 + * @return the name of the columns schema + * @throws SQLException + * if there is a database error + */ + public String getSchemaName(int column) throws SQLException; + + /** + * Returns the title of the indexed columns table. + * + * @param column + * the column index, starting at 1 + * @return the table title + * @throws SQLException + * if there is a database error + */ + public String getTableName(int column) throws SQLException; + + /** + * Returns and indication of whether the indexed column has automatic + * numbering and is therefore read-only + * + * @param column + * the column index, starting at 1 + * @return true if it is automatically numbered, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isAutoIncrement(int column) throws SQLException; + + /** + * Returns an indicator of whether the case of the indexed column is + * important + * + * @param column + * the column index, starting at 1 + * @return true if case matters, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isCaseSensitive(int column) throws SQLException; + + /** + * Returns if the indexed column contains a monetary amount. + * + * @param column + * the column index, starting at 1 + * @return true if it is a monetary value, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isCurrency(int column) throws SQLException; + + /** + * Returns an indication of whether writing to the indexed column is + * guaranteed to be successful + * + * @param column + * the column index, starting at 1 + * @return true if the write is guaranteed, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isDefinitelyWritable(int column) throws SQLException; + + /** + * Returns whether the indexed column is nullable. + * + * @param column + * the column index, starting at 1 + * @return true if it is nullable, false otherwise + * @throws SQLException + * if there is a database error + */ + public int isNullable(int column) throws SQLException; + + /** + * Returns an indication of whether writing to the indexed column is + * guaranteed to be unsuccessful + * + * @param column + * the column index, starting at 1 + * @return true if the column is read-only, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isReadOnly(int column) throws SQLException; + + /** + * Returns an indication of whether the indexed column is searchable. + * + * @param column + * the column index, starting at 1 + * @return true if the indexed column is searchable, false otherwise. + * @throws SQLException + * if there is a database error + */ + public boolean isSearchable(int column) throws SQLException; + + /** + * Returns an indicator of whether the values contained in the indexed + * column are signed. + * + * @param column + * the column index, starting at 1 + * @return true if they are signed, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isSigned(int column) throws SQLException; + + /** + * Returns an indication of whether writing to the indexed column is + * possible. + * + * @param column + * the column index, starting at 1 + * @return true if it is possible to write, false otherwise + * @throws SQLException + * if there is a database error + */ + public boolean isWritable(int column) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/SQLData.java b/sql/src/main/java/java/sql/SQLData.java new file mode 100644 index 0000000..7b07835 --- /dev/null +++ b/sql/src/main/java/java/sql/SQLData.java @@ -0,0 +1,106 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * An interface for the custom mapping of an SQL User Defined Type (UDT) to a + * Java Class. The Java Class object will be added to the Connection's type map + * with the SQL Name of the UDT which it maps. + * <p> + * Usually within an implementation of SQLData, there is a corresponding field + * for every attribute of an SQL type, or only one field if the type is SQL + * DISTINCT. When the UDT is returned within a ResultSet, it is accessed with + * the ResultSet.getObject method and is returned as an Object which is an + * instance of the class defined by the SQLData mapping. The application can use + * this object just like any other Java object and can store changes back into + * the database using the PreparedStatement.setObject method which performs the + * reverse mapping into the SQL UDT. + * <p> + * It is standard for an implementation for a custom mapping to be generated by + * a tool. The tool usually requires the name of the SQL UDT, the name of the + * class which it is going to be mapped to, and the field names to which the UDT + * attributes will be mapped. The tool can then implement the SQLData readSQL + * and writeSQL methods. readSQL reads attributes from an SQLInput object, and + * writeSQL writes them. This is done via SQLInput and SQLOutput method calls + * respectively + * <p> + * Ordinarily a programmer would not call SQLData methods directly. Similarly + * SQLInput and SQLOutput methods are not usually called directly. + */ +public interface SQLData { + + /** + * Gets the SQL name of the User Defined Type (UDT) that this object + * represents. This method, usually invoked by the JDBC driver, retrieves + * the name of the UDT instance associated with this SQLData object. + * + * @return a string with UDT type name for this object mapping, passed to + * readSQL when the object was created + * @throws SQLException + * if a database error occurs + */ + public String getSQLTypeName() throws SQLException; + + /** + * Reads data from the database into this object. This method follows these + * steps: + * <ul> + * <li>Utilize the passed input stream to read the attributes or entries of + * the SQL type</li> + * <li>This is carried out by reading each entry from the input stream, + * ordered as the are the SQL definition.</li> + * <li>Assign the data to the appropriate fields or elements. This is done + * by calling the relevant reader method for the type involved (eg. + * SQLInput.readString, SQLInputreadBigDecimal). If the type is distinct, + * then read its only data entry. For structured types, read every entry.</li> + * </ul> + * The supplied input stream is typically initialized by the calling JDBC + * driver with the type map before readSQL is called. + * + * @param stream + * the SQLInput stream from which the type map data is read for + * the custom mapping + * @param typeName + * the SQL Type name for the type which is being mapped + * @throws SQLException + * if a database error occurs + */ + public void readSQL(SQLInput stream, String typeName) throws SQLException; + + /** + * Writes the object to a supplied SQLOutput data stream, writing it out as + * an SQL value to the data source. + * <p> + * This method follows the following steps: + * <ul> + * <li>Write each attribute of the SQL type to the output stream.</li> + * <li>Write each item by calling a method on the output stream, in the + * order they appear in the SQL definition of the type. Use the appropriate + * SQLOutput methods (eg. writeInt, writeString). Write a single data + * element for a Distinct type. For a Structured type, write a value for + * each attribute of the the SQL type.</li> + * </ul> + * + * @param stream + * the SQLOutput stream to use to write out the data for the + * custom mapping + * @throws SQLException + * if a database error occurs + */ + public void writeSQL(SQLOutput stream) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/SQLException.java b/sql/src/main/java/java/sql/SQLException.java new file mode 100644 index 0000000..07a4763 --- /dev/null +++ b/sql/src/main/java/java/sql/SQLException.java @@ -0,0 +1,153 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.Serializable; + +/** + * An Exception class that is used in conjunction with JDBC operations. It + * provides information about problems encountered with Database access and + * other problems related to JDBC + * <p> + * The SQLException class provides the following information: + * <ul> + * <li>A standard Java exception message, as a String + * <li>An SQLState string. This is an error description string which follows + * either the SQL 99 conventions or the XOPEN SQLstate conventions. The + * potential values of the SQLState string are described in each of the + * specifications. Which of the conventions is being used by the SQLState string + * can be discovered by using the getSQLStateType method of the DatabaseMetaData + * interface. + * <li>An Error Code, an an integer. The error code is specific to each + * database vendor and is typically the error code returned by the database + * itself. + * <li>A chain to a next Exception, if relevant, which can give access to + * additional error information. + * </ul> + */ +public class SQLException extends Exception implements Serializable { + + private static final long serialVersionUID = 2135244094396331484L; + + private String SQLState = null; + + private int vendorCode = 0; + + private SQLException next = null; + + /** + * Creates an SQLException object. The Reason string is set to null, the + * SQLState string is set to null and the Error Code is set to 0. + */ + public SQLException() { + super(); + } + + /** + * Creates an SQLException object. The Reason string is set to the given + * reason string, the SQLState string is set to null and the Error Code is + * set to 0. + * + * @param theReason + * the string to use as the Reason string + */ + public SQLException(String theReason) { + this(theReason, null, 0); + } + + /** + * Creates an SQLException object. The Reason string is set to the given + * reason string, the SQLState string is set to the given SQLState string + * and the Error Code is set to 0. + * + * @param theReason + * the string to use as the Reason string + * @param theSQLState + * the string to use as the SQLState string + */ + public SQLException(String theReason, String theSQLState) { + this(theReason, theSQLState, 0); + } + + /** + * Creates an SQLException object. The Reason string is set to the given + * reason string, the SQLState string is set to the given SQLState string + * and the Error Code is set to the given error code value. + * + * @param theReason + * the string to use as the Reason string + * @param theSQLState + * the string to use as the SQLState string + * @param theErrorCode + * the integer value for the error code + */ + public SQLException(String theReason, String theSQLState, int theErrorCode) { + super(theReason); + SQLState = theSQLState; + vendorCode = theErrorCode; + } + + /** + * Returns the integer error code for this SQLException + * + * @return The integer error code for this SQLException. The meaning of the + * code is specific to the vendor of the database. + */ + public int getErrorCode() { + return vendorCode; + } + + /** + * Retrieves the SQLException chained to this SQLException, if any. + * + * @return The SQLException chained to this SQLException. null if there is + * no SQLException chained to this SQLException. + */ + public SQLException getNextException() { + return next; + } + + /** + * Retrieves the SQLState description string for this SQLException object + * + * @return The SQLState string for this SQLException object. This is an + * error description string which follows either the SQL 99 + * conventions or the XOPEN SQLstate conventions. The potential + * values of the SQLState string are described in each of the + * specifications. Which of the conventions is being used by the + * SQLState string can be discovered by using the getSQLStateType + * method of the DatabaseMetaData interface. + */ + public String getSQLState() { + return SQLState; + } + + /** + * Adds the SQLException to the end of this SQLException chain. + * + * @param ex + * the new SQLException to be added to the end of the chain + */ + public void setNextException(SQLException ex) { + if (next != null) { + next.setNextException(ex); + } else { + next = ex; + } + } +} diff --git a/sql/src/main/java/java/sql/SQLInput.java b/sql/src/main/java/java/sql/SQLInput.java new file mode 100644 index 0000000..d30da9f --- /dev/null +++ b/sql/src/main/java/java/sql/SQLInput.java @@ -0,0 +1,280 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.math.BigDecimal; +import java.io.Reader; +import java.io.InputStream; +import java.net.URL; + +/** + * The SQLInput interface defines operations which apply to a type of input + * stream which carries a series of values which represent an instance of an SQL + * structured type or SQL distinct type. + * <p> + * SQLInput interface is used for custom mapping of SQL User Defined Types + * (UDTs)to Java classes. It is used by JDBC drivers below the level of the + * public interfaces and application programs do not normally use the SQLInput + * methods directly. Reader methods such as readLong and readBytes provide means + * to read values from an SQLInput stream. + * <p> + * When the getObject method is called with an object which implements the + * SQLData interface, the JDBC driver determines the SQL type of the UDT being + * mapped by calling the SQLData.getSQLType method. The driver creates an + * instance of an SQLInput stream, filling the stream with the attributes of the + * UDT. The SQLInput stream is passed to the SQLData.readSQL method which then + * calls the SQLInput reader methods to read the attributes. + */ +public interface SQLInput { + + /** + * Returns the next attribute in the stream in the form of a String. + * + * @return the next attribute as a String. null if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public String readString() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a boolean. + * + * @return the next attribute as a boolean. false if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public boolean readBoolean() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a byte. + * + * @return the next attribute as a byte. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public byte readByte() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a short. + * + * @return the next attribute as a short. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public short readShort() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of an int. + * + * @return the next attribute as an int. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public int readInt() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a long. + * + * @return the next attribute as a long. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public long readLong() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a float. + * + * @return the next attribute as a float. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public float readFloat() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a double. + * + * @return the next attribute as a double. 0 if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public double readDouble() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a + * java.math.BigDecimal. + * + * @return the attribute as a java.math.BigDecimal. null if the read returns + * SQL NULL. + * @throws SQLException + * if there is a database error + */ + public BigDecimal readBigDecimal() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a byte array. + * + * @return the attribute as a byte array. null if the read returns SQL NULL. + * @throws SQLException + * if there is a database error + */ + public byte[] readBytes() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Date. + * + * @return the next attribute as a java.sql.Date. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Date readDate() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Time. + * + * @return the attribute as a java.sql.Time. null if the read returns SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Time readTime() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a + * java.sql.Timestamp. + * + * @return the attribute as a java.sql.Timestamp. null if the read returns + * SQL NULL. + * @throws SQLException + * if there is a database error + */ + public Timestamp readTimestamp() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a Unicode + * character stream embodied as a java.io.Reader. + * + * @return the next attribute as a java.io.Reader. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Reader readCharacterStream() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of an ASCII + * character stream embodied as a java.io.InputStream. + * + * @return the next attribute as a java.io.InputStream. null if the value is + * SQL NULL. + * @throws SQLException + * if there is a database error + */ + public InputStream readAsciiStream() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a stream of bytes + * embodied as a java.io.InputStream. + * + * @return the next attribute as a java.io.InputStream. null if the value is + * SQL NULL. + * @throws SQLException + * if there is a database error + */ + public InputStream readBinaryStream() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a + * java.lang.Object. + * <p> + * The type of the Object returned is determined by the type mapping for + * this JDBC driver, including any customized mappings in force. A type map + * is given to the SQLInput by the JDBC driver before the SQLInput is given + * to the application. + * <p> + * If the attribute is an SQL structured or distinct type, its SQL type is + * determined. If the streams type map contains an element for that SQL + * type, the driver creates an object of relevant type and invokes the + * method SQLData.readSQL on it, which reads supplementary data from the + * stream using whichever protocol is defined for that method. + * + * @return the next attribute as an Object. null if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public Object readObject() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Ref. + * + * @return the next attribute as a java.sql.Ref. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Ref readRef() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Blob. + * + * @return the next attribute as a java.sql.Blob. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Blob readBlob() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Clob. + * + * @return the next attribute as a java.sql.Clob. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public Clob readClob() throws SQLException; + + /** + * Returns the next attribute in the stream in the form of a java.sql.Array. + * + * @return the next attribute as an Array. null if the value is SQL NULL. + * @throws SQLException + * if there is a database error + */ + public Array readArray() throws SQLException; + + /** + * Reports whether the last value read was SQL NULL. + * + * @return true if the last value read was SQL NULL, false otherwise. + * @throws SQLException + * if there is a database error + */ + public boolean wasNull() throws SQLException; + + /** + * Reads the next attribute in the stream (SQL DATALINK value) and returns + * it as a java.net.URL object. + * + * @return the next attribute as a java.net.URL. null if the value is SQL + * NULL. + * @throws SQLException + * if there is a database error + */ + public URL readURL() throws SQLException; +} diff --git a/sql/src/main/java/java/sql/SQLOutput.java b/sql/src/main/java/java/sql/SQLOutput.java new file mode 100644 index 0000000..287a5f6 --- /dev/null +++ b/sql/src/main/java/java/sql/SQLOutput.java @@ -0,0 +1,280 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; +import java.net.URL; + +/** + * The interface for an output stream used to write attributes of an SQL User + * Defined Type to the database. This interface is used for custom mapping of + * types and is called by the JDBC driver. It is not expected that this + * interface is used by applications. + * <p> + * When an object which implements the SQLData interface is used as an argument + * to an SQL statement, the JDBC driver calls the method + * <code>SQLData.getSQLType</code> to establish the type of the SQL UDT that + * is being passed. The driver then creates an SQLOutput stream and passes it to + * the <code>SQLData.writeSQL</code> method, which in turn uses the + * appropriate SQLOutput writer methods to write the data from the SQLData + * object into the stream according to the defined mapping. + */ +public interface SQLOutput { + + /** + * Write a String value into the output stream. + * + * @param theString + * the String to write + * @throws SQLException + * if a database error occurs + */ + public void writeString(String theString) throws SQLException; + + /** + * Write a boolean value into the output stream. + * + * @param theFlag + * the boolean value to write + * @throws SQLException + * if a database error occurs + */ + public void writeBoolean(boolean theFlag) throws SQLException; + + /** + * Write a byte value into the output stream. + * + * @param theByte + * the byte value to write + * @throws SQLException + * if a database error occurs + */ + public void writeByte(byte theByte) throws SQLException; + + /** + * Write a short value into the output stream. + * + * @param theShort + * the short value to write + * @throws SQLException + * if a database error occurs + */ + public void writeShort(short theShort) throws SQLException; + + /** + * Write an int value into the output stream. + * + * @param theInt + * the int value to write + * @throws SQLException + * if a database error occurs + */ + public void writeInt(int theInt) throws SQLException; + + /** + * Write a long value into the output stream. + * + * @param theLong + * the long value to write + * @throws SQLException + * if a database error occurs + */ + public void writeLong(long theLong) throws SQLException; + + /** + * Write a float value into the output stream. + * + * @param theFloat + * the float value to write + * @throws SQLException + * if a database error occurs + */ + public void writeFloat(float theFloat) throws SQLException; + + /** + * Write a double value into the output stream. + * + * @param theDouble + * the double value to write + * @throws SQLException + * if a database error occurs + */ + public void writeDouble(double theDouble) throws SQLException; + + /** + * Write a java.math.BigDecimal value into the output stream. + * + * @param theBigDecimal + * the BigDecimal value to write + * @throws SQLException + * if a database error occurs + */ + public void writeBigDecimal(BigDecimal theBigDecimal) throws SQLException; + + /** + * Write an array of bytes into the output stream. + * + * @param theBytes + * the array of bytes to write + * @throws SQLException + * if a database error occurs + */ + public void writeBytes(byte[] theBytes) throws SQLException; + + /** + * Write a java.sql.Date value into the output stream. + * + * @param theDate + * the Date value to write + * @throws SQLException + * if a database error occurs + */ + public void writeDate(Date theDate) throws SQLException; + + /** + * Write a java.sql.Time value into the output stream. + * + * @param theTime + * the Time value to write + * @throws SQLException + * if a database error occurs + */ + public void writeTime(Time theTime) throws SQLException; + + /** + * Write a java.sql.Timestamp value into the output stream. + * + * @param theTimestamp + * the Timestamp value to write + * @throws SQLException + * if a database error occurs + */ + public void writeTimestamp(Timestamp theTimestamp) throws SQLException; + + /** + * Write a stream of Unicode characters into the output stream. + * + * @param theStream + * the stream of Unicode characters to write, as a java.io.Reader + * object + * @throws SQLException + * if a database error occurs + */ + public void writeCharacterStream(Reader theStream) throws SQLException; + + /** + * Write a stream of ASCII characters into the output stream. + * + * @param theStream + * the stream of ASCII characters to write, as a + * java.io.InputStream object + * @throws SQLException + * if a database error occurs + */ + public void writeAsciiStream(InputStream theStream) throws SQLException; + + /** + * Write a stream of uninterpreted bytes into the output stream. + * + * @param theStream + * the stream of bytes to write, as a java.io.InputStream object + * @throws SQLException + * if a database error occurs + */ + public void writeBinaryStream(InputStream theStream) throws SQLException; + + /** + * Write an SQLData object into the output stream. + * <p> + * If the SQLData object is null, writes SQL NULL to the stream. + * <p> + * Otherwise, calls the <code>SQLData.writeSQL</code> method of the + * object, which writes the object's attributes to the stream by calling the + * appropriate SQLOutput writer methods for each attribute, in order. The + * order of the attributes is the order they are listed in the SQL + * definition of the User Defined Type. + * + * @param theObject + * the SQLData object to write + * @throws SQLException + * if a database error occurs + */ + public void writeObject(SQLData theObject) throws SQLException; + + /** + * Write an SQL Ref value into the output stream. + * + * @param theRef + * the java.sql.Ref object to write + * @throws SQLException + * if a database error occurs + */ + public void writeRef(Ref theRef) throws SQLException; + + /** + * Write an SQL Blob value into the output stream. + * + * @param theBlob + * the java.sql.Blob object to write + * @throws SQLException + * if a database error occurs + */ + public void writeBlob(Blob theBlob) throws SQLException; + + /** + * Write an SQL Clob value into the output stream. + * + * @param theClob + * the java.sql.Clob object to write + * @throws SQLException + * if a database error occurs + */ + public void writeClob(Clob theClob) throws SQLException; + + /** + * Write an SQL Struct value into the output stream. + * + * @param theStruct + * the java.sql.Struct object to write + * @throws SQLException + * if a database error occurs + */ + public void writeStruct(Struct theStruct) throws SQLException; + + /** + * Write an SQL Array value into the output stream. + * + * @param theArray + * the java.sql.Array object to write + * @throws SQLException + * if a database error occurs + */ + public void writeArray(Array theArray) throws SQLException; + + /** + * Write an SQL DATALINK value into the output stream. + * + * @param theURL + * the Datalink value as a java.net.URL to write + * @throws SQLException + * if a database error occurs + */ + public void writeURL(URL theURL) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/SQLPermission.java b/sql/src/main/java/java/sql/SQLPermission.java new file mode 100644 index 0000000..734f1f2 --- /dev/null +++ b/sql/src/main/java/java/sql/SQLPermission.java @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.Serializable; +import java.security.BasicPermission; +import java.security.Guard; + +/** + * Permission relating to security access control in the java.sql package. + * <p> + * Currently, the only permission supported has the name "setLog". The setLog + * permission controls whether a Java application or applet can open a logging + * stream using the DriverManager.setLogWriter method or the + * DriverManager.setLogStream method. This is a potentially dangerous operation + * since the logging stream can contain usernames, passwords + */ +public final class SQLPermission extends BasicPermission implements Guard, + Serializable { + + private static final long serialVersionUID = -1439323187199563495L; + + /** + * Creates a new SQLPermission object with the specified name. + * + * @param name + * the name to use for this SQLPermission + */ + public SQLPermission(String name) { + super(name); + } + + /** + * Creates a new SQLPermission object with the specified name. + * + * @param name + * is the name of the SQLPermission. Currently only "setLog" is + * allowed. + * @param actions + * is currently unused and should be set to null + */ + public SQLPermission(String name, String actions) { + super(name, null); + } +} diff --git a/sql/src/main/java/java/sql/SQLWarning.java b/sql/src/main/java/java/sql/SQLWarning.java new file mode 100644 index 0000000..efaf216 --- /dev/null +++ b/sql/src/main/java/java/sql/SQLWarning.java @@ -0,0 +1,103 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.io.Serializable; + +import org.apache.harmony.sql.internal.nls.Messages; + +/** + * An exception class that holds information about Database access warnings. + */ +public class SQLWarning extends SQLException implements Serializable { + + private static final long serialVersionUID = 3917336774604784856L; + + /** + * Creates an SQLWarning object. The Reason string is set to null, the + * SQLState string is set to null and the Error Code is set to 0. + */ + public SQLWarning() { + super(); + } + + /** + * Creates an SQLWarning object. The Reason string is set to the given + * reason string, the SQLState string is set to null and the Error Code is + * set to 0. + * + * @param theReason + */ + public SQLWarning(String theReason) { + super(theReason); + } + + /** + * Creates an SQLWarning object. The Reason string is set to the given + * reason string, the SQLState string is set to the given SQLState string + * and the Error Code is set to 0. + * + * @param theReason + * the string to use as the Reason string + * @param theSQLState + * the string to use as the SQLState string + */ + public SQLWarning(String theReason, String theSQLState) { + super(theReason, theSQLState); + } + + /** + * Creates an SQLWarning object. The Reason string is set to the given + * reason string, the SQLState string is set to the given SQLState string + * and the Error Code is set to the given ErrorCode value. + * + * @param theReason + * @param theSQLState + * @param theErrorCode + */ + public SQLWarning(String theReason, String theSQLState, int theErrorCode) { + super(theReason, theSQLState, theErrorCode); + } + + /** + * Gets the SQLWarning chained to this SQLWarning object. + * + * @return the SQLWarning chained to this SQLWarning. null if no SQLWarning + * is chained to this SQLWarning. + */ + public SQLWarning getNextWarning() { + SQLException next = super.getNextException(); + if (next == null) { + return null; + } + if (next instanceof SQLWarning) { + return (SQLWarning) next; + } + throw new Error(Messages.getString("sql.8")); //$NON-NLS-1$ + } + + /** + * Chains a supplied SQLWarning to this SQLWarning. + * + * @param w + * the SQLWarning to chain to this SQLWarning. + */ + public void setNextWarning(SQLWarning w) { + super.setNextException(w); + } +} diff --git a/sql/src/main/java/java/sql/Savepoint.java b/sql/src/main/java/java/sql/Savepoint.java new file mode 100644 index 0000000..fd27877 --- /dev/null +++ b/sql/src/main/java/java/sql/Savepoint.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * A Savepoint is an instant during the current transaction that can be utilized + * by a Rollback from the Connection.rollback method. Rolling back to a + * particular Savepoint means that all changes that occurred after that + * Savepoint are removed. + */ +public interface Savepoint { + + /** + * Returns the constructed ID for this Savepoint. + * + * @return the ID for this Savepoint. + * @throws SQLException + */ + public int getSavepointId() throws SQLException; + + /** + * Returns the name for this Savepoint. + * + * @return the name of this Savepoint. + * @throws SQLException + */ + public String getSavepointName() throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Statement.java b/sql/src/main/java/java/sql/Statement.java new file mode 100644 index 0000000..8896dbf --- /dev/null +++ b/sql/src/main/java/java/sql/Statement.java @@ -0,0 +1,620 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * Interface used for executing static SQL statements and returning their + * results. + * + * By default, an object implementing the Statement interface can returns + * results as ResultSets. For any given Statement object, only one ResultSet can + * be open at one time. A call to any of the execution methods of Statement will + * cause any previously created ResultSet object for that Statement to be closed + * implicitly. + * <p> + * To have multiple ResultSet objects open concurrently, multiple Statement + * objects must be used. + */ +public interface Statement { + + /** + * Passing this constant to getMoreResults implies that all ResultSet + * objects previously kept open should be closed. + */ + public static final int CLOSE_ALL_RESULTS = 3; + + /** + * Passing this constant to getMoreResults implies that the current + * ResultSet object should be closed + */ + public static final int CLOSE_CURRENT_RESULT = 1; + + /** + * Indicates that an error was encountered during execution of a batch + * statement. + */ + public static final int EXECUTE_FAILED = -3; + + /** + * Passing this constant to getMoreResults implies that the current + * ResultSet object should not be closed. + */ + public static final int KEEP_CURRENT_RESULT = 2; + + /** + * Indicates that generated keys should not be accessible for retrieval. + */ + public static final int NO_GENERATED_KEYS = 2; + + /** + * Indicates that generated keys should be accessible for retrieval. + */ + public static final int RETURN_GENERATED_KEYS = 1; + + /** + * Indicates that a batch statement was executed with a successful result, + * but a count of the number of rows it affected is unavailable. + */ + public static final int SUCCESS_NO_INFO = -2; + + /** + * Adds a specified SQL commands to the list of commands for this Statement. + * <p> + * The list of commands is executed by invoking the + * <code>executeBatch</code> method. + * + * @param sql + * the SQL command as a String. Typically an INSERT or UPDATE + * statement. + * @throws SQLException + * if an error occurs accessing the database or the database + * does not support batch updates + */ + public void addBatch(String sql) throws SQLException; + + /** + * Cancels this Statement execution if both the database and the JDBC driver + * support aborting an SQL statement in flight. This method can be used by + * one thread to stop a Statement that is being executed on another thread. + * + * @throws SQLException + * if an error occurs accessing the database + */ + public void cancel() throws SQLException; + + /** + * Clears the current list of SQL commands for this Statement. + * + * @throws SQLException + * if an error occurs accessing the database or the database + * does not support batch updates + */ + public void clearBatch() throws SQLException; + + /** + * Clears all SQLWarnings from this Statement. + * + * @throws SQLException + * if an error occurs accessing the database + */ + public void clearWarnings() throws SQLException; + + /** + * Releases this Statement's database and JDBC driver resources. + * <p> + * Using this method to release these resources as soon as possible is + * strongly recommended. It is not a good idea to rely on these resources + * being released when the Statement object is finalized during garbage + * collection. Doing so can result in unpredictable performance + * characteristics for the application. + * + * @throws SQLException + * if an error occurs accessing the database + */ + public void close() throws SQLException; + + /** + * Executes a supplied SQL statement. This may return multiple ResultSets. + * <p> + * Use the <code>getResultSet</code> or <code>getUpdateCount</code> + * methods to get the first result and <code>getMoreResults</code> to get + * any subsequent results. + * + * @param sql + * the SQL statement to execute + * @return true if the first result is a ResultSet, false if the first + * result is an update count or if there is no result + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean execute(String sql) throws SQLException; + + /** + * Executes a supplied SQL statement. This may return multiple ResultSets. + * This method allows control of whether auto-generated Keys should be made + * available for retrieval, if the SQL statement is an INSERT statement. + * <p> + * Use the <code>getResultSet</code> or <code>getUpdateCount</code> + * methods to get the first result and <code>getMoreResults</code> to get + * any subsequent results. + * + * @param sql + * the SQL statement to execute + * @param autoGeneratedKeys + * a flag indicating whether to make auto generated keys + * available for retrieval. This parameter must be one of + * Statement.NO_GENERATED_KEYS or Statement.RETURN_GENERATED_KEYS + * @return true if results exists and the first result is a ResultSet, false + * if the first result is an update count or if there is no result + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean execute(String sql, int autoGeneratedKeys) + throws SQLException; + + /** + * Executes the supplied SQL statement. This may return multiple ResultSets. + * This method allows retrieval of auto generated keys specified by the + * supplied array of column indexes, if the SQL statement is an INSERT + * statement. + * <p> + * Use the <code>getResultSet</code> or <code>getUpdateCount</code> + * methods to get the first result and <code>getMoreResults</code> to get + * any subsequent results. + * + * @param sql + * the SQL statement to execute + * @param columnIndexes + * an array of indexes of the columns in the inserted row which + * should be made available for retrieval via the + * <code>getGeneratedKeys</code> method. + * @return true if the first result is a ResultSet, false if the first + * result is an update count or if there is no result + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean execute(String sql, int[] columnIndexes) throws SQLException; + + /** + * Executes the supplied SQL statement. This may return multiple ResultSets. + * This method allows retrieval of auto generated keys specified by the + * supplied array of column indexes, if the SQL statement is an INSERT + * statement. + * <p> + * Use the <code>getResultSet</code> or <code>getUpdateCount</code> + * methods to get the first result and <code>getMoreResults</code> to get + * any subsequent results. + * + * @param sql + * the SQL statement to execute + * @param columnNames + * an array of column names in the inserted row which should be + * made available for retrieval via the + * <code>getGeneratedKeys</code> method. + * @return true if the first result is a ResultSet, false if the first + * result is an update count or if there is no result + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean execute(String sql, String[] columnNames) + throws SQLException; + + /** + * Submits a batch of SQL commands to the database. Returns an array of + * update counts, if all the commands execute successfully. + * <p> + * If one of the commands in the batch fails, this method can throw a + * BatchUpdateException and the JDBC driver may or may not process the + * remaining commands. The JDBC driver must behave consistently with the + * underlying database, either always continuing or never continuing. If the + * driver continues processing, the array of results returned contains the + * same number of elements as there are commands in the batch, with a + * minimum of one of the elements having the EXECUTE_FAILED value. + * + * @return an array of update counts, with one entry for each command in the + * batch. The elements are ordered according to the order in which + * the commands were added to the batch. + * <p> + * <ol> + * <li> If the value of an element is >=0, the corresponding command + * completed successfully and the value is the update count for that + * command, which is the number of rows in the database affected by + * the command.</li> + * <li> If the value is SUCCESS_NO_INFO, the command completed + * successfully but the number of rows affected is unknown. + * <li> + * <li> If the value is EXECUTE_FAILED, the command failed. + * </ol> + * @throws SQLException + * if an error occurs accessing the database + */ + public int[] executeBatch() throws SQLException; + + /** + * Executes a supplied SQL statement. Returns a single ResultSet. + * + * @param sql + * an SQL statement to execute. Typically a SELECT statement + * @return a ResultSet containing the data produced by the SQL statement. + * Never null. + * @throws SQLException + * if an error occurs accessing the database or if the statement + * produces anything other than a single ResultSet + */ + public ResultSet executeQuery(String sql) throws SQLException; + + /** + * Executes the supplied SQL statement. The statement may be an INSERT, + * UPDATE or DELETE statement or a statement which returns nothing. + * + * @param sql + * an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or + * a statement which returns nothing + * @return the count of updated rows, or 0 for a statement that returns + * nothing. + * @throws SQLException + * if an error occurs accessing the database or if the statement + * produces a ResultSet + */ + public int executeUpdate(String sql) throws SQLException; + + /** + * Executes the supplied SQL statement. This method allows control of + * whether auto-generated Keys should be made available for retrieval. + * + * @param sql + * an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or + * a statement which does not return anything. + * @param autoGeneratedKeys + * a flag that indicates whether to allow retrieval of auto + * generated keys. Parameter must be one of + * Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS + * @return the number of updated rows, or 0 if the statement returns + * nothing. + * @throws SQLException + * if an error occurs accessing the database or if the statement + * produces a ResultSet + */ + public int executeUpdate(String sql, int autoGeneratedKeys) + throws SQLException; + + /** + * Executes the supplied SQL statement. This method allows retrieval of auto + * generated keys specified by the supplied array of column indexes. + * + * @param sql + * an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or + * a statement which returns nothing + * @param columnIndexes + * an array of indexes of the columns in the inserted row which + * should be made available for retrieval via the + * <code>getGeneratedKeys</code> method. + * @return the count of updated rows, or 0 for a statement that returns + * nothing. + * @throws SQLException + * if an error occurs accessing the database or if the statement + * produces a ResultSet + */ + public int executeUpdate(String sql, int[] columnIndexes) + throws SQLException; + + /** + * Executes the supplied SQL statement. This method allows retrieval of auto + * generated keys specified by the supplied array of column names. + * + * @param sql + * an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or + * a statement which returns nothing + * @param columnNames + * an array of column names in the inserted row which should be + * made available for retrieval via the + * <code>getGeneratedKeys</code> method. + * @return the count of updated rows, or 0 for a statement that returns + * nothing. + * @throws SQLException + * if an error occurs accessing the database or if the statement + * produces a ResultSet + */ + public int executeUpdate(String sql, String[] columnNames) + throws SQLException; + + /** + * Gets the Connection that produced this Statement. + * + * @return the Connection + * @throws SQLException + * if an error occurs accessing the database + */ + public Connection getConnection() throws SQLException; + + /** + * Gets the default direction for fetching rows for ResultSets generated + * from this Statement. + * + * @return an integer describing the default fetch direction, one of: + * ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, + * ResultSet.FETCH_UNKNOWN + * @throws SQLException + * if an error occurs accessing the database + */ + public int getFetchDirection() throws SQLException; + + /** + * Gets the default number of rows for a fetch for the ResultSet objects + * returned from this Statement. + * + * @return the default fetch size for ResultSets produced by this Statement + * @throws SQLException + * if an error occurs accessing the database + */ + public int getFetchSize() throws SQLException; + + /** + * Returns auto generated keys created by executing this Statement. + * + * @return a ResultSet containing the auto generated keys - empty if no keys + * were generated by the Statement + * @throws SQLException + * if an error occurs accessing the database + */ + public ResultSet getGeneratedKeys() throws SQLException; + + /** + * Gets the maximum number of bytes which can be returned for values from + * Character and Binary values in a ResultSet derived from this Statement. + * This limit applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, + * and LONGVARCHAR types. Any data exceeding the maximum size is abandoned + * without announcement. + * + * @return the current size limit, where 0 means that there is no limit + * @throws SQLException + * if an error occurs accessing the database + */ + public int getMaxFieldSize() throws SQLException; + + /** + * Gets the maximum number of rows that a ResultSet can contain when + * produced from this Statement. If the limit is exceeded, the excess rows + * are discarded silently. + * + * @return the current row limit, where 0 means that there is no limit. + * @throws SQLException + * if an error occurs accessing the database + */ + public int getMaxRows() throws SQLException; + + /** + * Moves to this Statement's next result. Returns true if it is a ResultSet. + * Any current ResultSet objects previously obtained with + * <code>getResultSet()</code> are closed implicitly. + * + * @return true if the next result is a ResultSet, false if the next result + * is not a ResultSet or if there are no more results. Note that if + * there is no more data, this method will return false and + * <code>getUpdateCount</code> will return -1. + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean getMoreResults() throws SQLException; + + /** + * Moves to this Statement's next result. Returns true if the next result is + * a ResultSet. Any current ResultSet objects previously obtained with + * <code>getResultSet()</code> are handled as indicated by a supplied Flag + * parameter. + * + * @param current + * a flag indicating what to do with existing ResultSets. This + * parameter must be one of Statement.CLOSE_ALL_RESULTS, + * Statement.CLOSE_CURRENT_RESULT or + * Statement.KEEP_CURRENT_RESULT. + * @return true if the next result exists and is a ResultSet, false if the + * next result is not a ResultSet or if there are no more results. + * Note that if there is no more data, this method will return false + * and <code>getUpdateCount</code> will return -1. + * @throws SQLException + * if an error occurs accessing the database + */ + public boolean getMoreResults(int current) throws SQLException; + + /** + * Gets the timeout value for Statement execution. The JDBC driver will wait + * up to this value for the execution to complete - after the limit is + * exceeded an SQL Exception is thrown. + * + * @return the current Query Timeout value, where 0 indicates that there is + * no current timeout. + * @throws SQLException + * if an error occurs accessing the database + */ + public int getQueryTimeout() throws SQLException; + + /** + * Gets the current result. Should only be called once per result. + * + * @return the ResultSet for the current result. null if the result is an + * update count or if there are no more results. + * @throws SQLException + * if an error occurs accessing the database + */ + public ResultSet getResultSet() throws SQLException; + + /** + * Gets the concurrency setting for ResultSet objects generated by this + * Statement. + * + * @return ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE + * @throws SQLException + * if an error occurs accessing the database + */ + public int getResultSetConcurrency() throws SQLException; + + /** + * Gets the cursor hold setting for ResultSet objects generated by this + * Statement. + * + * @return ResultSet.HOLD_CURSORS_OVER_COMMIT or + * ResultSet.CLOSE_CURSORS_AT_COMMIT + * @throws SQLException + * if there is an error while accessing the database + */ + public int getResultSetHoldability() throws SQLException; + + /** + * Gets the ResultSet type setting for ResultSets derived from this + * Statement. + * + * @return ResultSet.TYPE_FORWARD_ONLY for a ResultSet where the cursor can + * only move forward, ResultSet.TYPE_SCROLL_INSENSITIVE for a + * ResultSet which is Scrollable but is not sensitive to changes + * made by others, ResultSet.TYPE_SCROLL_SENSITIVE for a ResultSet + * which is Scrollable but is sensitive to changes made by others + * @throws SQLException + * if there is an error accessing the database + */ + public int getResultSetType() throws SQLException; + + /** + * Gets an update count for the current result if it is not a ResultSet. + * + * @return the current result as an update count. -1 if the current result + * is a ResultSet or if there are no more results + * @throws SQLException + * if an error occurs accessing the database + */ + public int getUpdateCount() throws SQLException; + + /** + * Retrieves the first SQLWarning reported by calls on this Statement. + * <p> + * If there are multiple warnings, subsequent warnings are chained to the + * first one. + * <p> + * The chain or warnings is cleared each time the Statement is executed. + * <p> + * Warnings associated with reads from the ResultSet returned from executing + * a Statement will be attached to the ResultSet, not the Statement object. + * + * @return an SQLWarning, null if there are no warnings + * @throws SQLException + * if an error occurs accessing the database + */ + public SQLWarning getWarnings() throws SQLException; + + /** + * Sets the SQL cursor name. This name is used by subsequent Statement + * execute methods. + * <p> + * Cursor names must be unique within one Connection. + * <p> + * With the Cursor name set, it can then be utilized in SQL positioned + * update or delete statements to determine the current row in a ResultSet + * generated from this Statement. The positioned update or delete must be + * done with a different Statement than this one. + * + * @param name + * the Cursor name as a String, + * @throws SQLException + * if an error occurs accessing the database + */ + public void setCursorName(String name) throws SQLException; + + /** + * Sets Escape Processing mode. + * <p> + * If Escape Processing is on, the JDBC driver will do escape substitution + * on an SQL statement before sending it for execution. This does not apply + * to PreparedStatements since they are processed when created, before this + * method can be called. + * + * @param enable + * true to set escape processing mode on, false to turn it off. + * @throws SQLException + * if an error occurs accessing the database + */ + public void setEscapeProcessing(boolean enable) throws SQLException; + + /** + * Sets the fetch direction - a hint to the JDBC driver about the direction + * of processing of rows in ResultSets created by this Statement. The + * default fetch direction is FETCH_FORWARD. + * + * @param direction + * which fetch direction to use. This parameter should be one of + * ResultSet.FETCH_UNKNOWN, ResultSet.FETCH_FORWARD or + * ResultSet.FETCH_REVERSE + * @throws SQLException + * if there is an error while accessing the database or if the + * fetch direction is unrecognized + */ + public void setFetchDirection(int direction) throws SQLException; + + /** + * Sets the fetch size. This is a hint to the JDBC driver about how many + * rows should be fetched from the database when more are required by + * application processing. + * + * @param rows + * the number of rows that should be fetched. 0 tells the driver + * to ignore the hint. Should be less than + * <code>getMaxRows</code> for this statement. Should not be + * negative. + * @throws SQLException + * if an error occurs accessing the database, or if the rows + * parameter is out of range. + */ + public void setFetchSize(int rows) throws SQLException; + + /** + * Sets the maximum number of bytes for ResultSet columns that contain + * character or binary values. This applies to BINARY, VARBINARY, + * LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR fields. Any data exceeding + * the maximum size is abandoned without announcement. + * + * @param max + * the maximum field size in bytes. O means "no limit". + * @throws SQLException + * if an error occurs accessing the database or the max value is + * <0. + */ + public void setMaxFieldSize(int max) throws SQLException; + + /** + * Sets the maximum number of rows that any ResultSet can contain. If the + * number of rows exceeds this value, the additional rows are silently + * discarded. + * + * @param max + * the maximum number of rows. 0 means "no limit". + * @throws SQLException + * if an error occurs accessing the database or if max <0. + */ + public void setMaxRows(int max) throws SQLException; + + /** + * Sets the timeout, in seconds, for queries - how long the driver will + * allow for completion of a Statement execution. If the timeout is + * exceeded, the query will throw an SQLException. + * + * @param seconds + * timeout in seconds. 0 means no timeout ("wait forever") + * @throws SQLException + * if an error occurs accessing the database or if seconds <0. + */ + public void setQueryTimeout(int seconds) throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Struct.java b/sql/src/main/java/java/sql/Struct.java new file mode 100644 index 0000000..0404cb7 --- /dev/null +++ b/sql/src/main/java/java/sql/Struct.java @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.util.Map; + +/** + * An interface which provides facilities for mapping an SQL structured type to + * Java. The Struct object has a value for each attribute of the SQL structured + * type + */ +public interface Struct { + + /** + * Gets the SQL Type name of the SQL structured type that this Struct + * represents + * + * @return the fully qualified name of SQL structured type + * @throws SQLException + * if a database error occurs + */ + public String getSQLTypeName() throws SQLException; + + /** + * Gets the values of the attributes of this SQL structured type. This + * method uses the type map associated with the Connection for customized + * type mappings. Where there is no entry in the Type Map which matches the + * this structured type, the JDBC driver uses the standard mapping. + * + * @return an Object array containing the attributes, in order + * @throws SQLException + * if a database error occurs + */ + public Object[] getAttributes() throws SQLException; + + /** + * Gets the values of the attributes of this SQL structured type. This + * method uses the supplied type map for customized type mappings. Where + * there is no entry in the Type Map which matches the this structured type, + * the JDBC driver uses the default mapping. The Connection type map is + * never utilized by this method. + * + * @param theMap + * a Map describing how SQL Type names are mapped to classes. + * @return an Object array containing the attributes, in order + * @throws SQLException + * if a database error occurs + */ + public Object[] getAttributes(Map<String, Class<?>> theMap) + throws SQLException; +} diff --git a/sql/src/main/java/java/sql/Time.java b/sql/src/main/java/java/sql/Time.java new file mode 100644 index 0000000..048259d --- /dev/null +++ b/sql/src/main/java/java/sql/Time.java @@ -0,0 +1,221 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * Java representation of an SQL TIME value. Provides functions to aid + * generation and interpretation of JDBC escape format for time values. + * + */ +public class Time extends Date { + + private static final long serialVersionUID = 8397324403548013681L; + + /** + * @deprecated Please use the constructor {@link #Time(long)} Constructs a Time + * object using the supplied values for Hour, Minute and Second. + * The Year, Month and Day elements of the Time object are set + * to 1970, January, 1 reflecting the Epoch (Time in + * milliseconds = 0). + * <p> + * Any attempt to access the Year, Month or Day elements of a + * Time object will result in an IllegalArgumentException. + * <p> + * Result is undefined if any argument is out of bounds. + * @param theHour + * a value from 0 - 23 + * @param theMinute + * a value from 0 - 59 + * @param theSecond + * a value from 0 - 59 + */ + @SuppressWarnings("deprecation") + @Deprecated + public Time(int theHour, int theMinute, int theSecond) { + super(70, 0, 1, theHour, theMinute, theSecond); + } + + /** + * Constructs a Time object using a supplied time specified in milliseconds + * + * @param theTime + * a Time specified in milliseconds since the Epoch (January 1st + * 1970, 00:00:00.000) + */ + public Time(long theTime) { + super(theTime); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Date component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getDate() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Day component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getDay() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Month component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getMonth() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Year component. + * @return does not return + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public int getYear() { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Date component. + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setDate(int i) { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Month component. + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setMonth(int i) { + throw new IllegalArgumentException(); + } + + /** + * @deprecated This method is deprecated and must not be used. An SQL Time + * object does not have a Year component. + * @throws IllegalArgumentException + * if this method is called + */ + @SuppressWarnings("deprecation") + @Deprecated + @Override + public void setYear(int i) { + throw new IllegalArgumentException(); + } + + /** + * Sets the time for this Time object to the supplied milliseconds value. + * + * @param time + * A time value expressed as milliseconds since the Epoch. + * Negative values are milliseconds before the Epoch. The Epoch + * is January 1 1970, 00:00:00.000 + */ + @Override + public void setTime(long time) { + super.setTime(time); + } + + /** + * Formats the Time as a String in JDBC escape format: hh:mm:ss + * + * @return A String representing the Time value in JDBC escape format: + * HH:mm:ss + */ + @Override + public String toString() { + SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss"); //$NON-NLS-1$ + return dateFormat.format(this); + } + + /** + * Creates a Time object from a String holding a time represented in JDBC + * escape format: hh:mm:ss. + * <p> + * An exception occurs if the input string is not in the form of a time in + * JDBC escape format. + * + * @param timeString + * A String representing the time value in JDBC escape format: + * hh:mm:ss + * @return The Time object set to a time corresponding to the given time + * @throws IllegalArgumentException + * if the supplied time string is not in JDBC escape format. + */ + public static Time valueOf(String timeString) { + if (timeString == null) { + throw new IllegalArgumentException(); + } + int firstIndex = timeString.indexOf(':'); + int secondIndex = timeString.indexOf(':', firstIndex + 1); + // secondIndex == -1 means none or only one separator '-' has been found. + // The string is separated into three parts by two separator characters, + // if the first or the third part is null string, we should throw + // IllegalArgumentException to follow RI + if (secondIndex == -1|| firstIndex == 0 || secondIndex + 1 == timeString.length()) { + throw new IllegalArgumentException(); + } + // parse each part of the string + int hour = Integer.parseInt(timeString.substring(0, firstIndex)); + int minute = Integer.parseInt(timeString.substring(firstIndex + 1, secondIndex)); + int second = Integer.parseInt(timeString.substring(secondIndex + 1, timeString + .length())); + return new Time(hour, minute, second); + } +} diff --git a/sql/src/main/java/java/sql/Timestamp.java b/sql/src/main/java/java/sql/Timestamp.java new file mode 100644 index 0000000..da8fa7a --- /dev/null +++ b/sql/src/main/java/java/sql/Timestamp.java @@ -0,0 +1,478 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +import java.text.DecimalFormat; +import java.text.ParsePosition; +import java.text.SimpleDateFormat; +import java.util.Date; + +import org.apache.harmony.sql.internal.nls.Messages; + +/** + * A Java representation of the SQL TIMESTAMP type. It provides the capability + * to represent the SQL TIMESTAMP nanosecond value, in addition to the regular + * date/time value which has millisecond resolution. + * <p> + * The Timestamp class consists of a regular Date/Time value, where only the + * integral seconds value is stored, plus a nanoseconds value where the + * fractional seconds are stored. + * <p> + * The addition of the nanosecond value field to the Timestamp object makes it + * significantly different from the java.util.Date object which it extends. + * Users should be cautious in their use of Timestamp objects and should not + * assume that they are interchangeable with java.util.Date objects when used + * outside the confines of the java.sql package. + * + */ +public class Timestamp extends Date { + + private static final long serialVersionUID = 2745179027874758501L; + + // The nanoseconds time value of the Timestamp + private int nanos; + + /** + * @deprecated Please use the constructor {@link #Timestamp(long)} Returns a + * Timestamp corresponding to the time specified by the supplied + * values for Year, Month, Date, Hour, Minutes, Seconds and + * Nanoseconds + * @param theYear + * specified as the year minus 1900 + * @param theMonth + * specified as an integer in the range 0 - 11 + * @param theDate + * specified as an integer in the range 1 - 31 + * @param theHour + * specified as an integer in the range 0 - 23 + * @param theMinute + * specified as an integer in the range 0 - 59 + * @param theSecond + * specified as an integer in the range 0 - 59 + * @param theNano + * which defines the nanosecond value of the timestamp specified + * as an integer in the range 0 - 999,999,999 + * @throws IllegalArgumentException + * if any of the parameters is out of range + */ + @SuppressWarnings("deprecation") + @Deprecated + public Timestamp(int theYear, int theMonth, int theDate, int theHour, + int theMinute, int theSecond, int theNano) + throws IllegalArgumentException { + super(theYear, theMonth, theDate, theHour, theMinute, theSecond); + if (theNano < 0 || theNano > 999999999) { + throw new IllegalArgumentException(); + } + nanos = theNano; + } + + /** + * Returns a Timestamp object corresponding to the time represented by a + * supplied time value. + * + * @param theTime + * a time value in the format of milliseconds since the Epoch + * (January 1 1970 00:00:00.000 GMT) + */ + public Timestamp(long theTime) { + super(theTime); + /* + * Now set the time for this Timestamp object - which deals with the + * nanosecond value as well as the base time + */ + this.setTime(theTime); + } + + /** + * Returns true if this timestamp object is later than the supplied + * timestamp, otherwise returns false. + * + * @param theTimestamp + * the timestamp to compare with this timestamp object + * @return true if this timestamp object is later than the supplied + * timestamp, false otherwise + */ + public boolean after(Timestamp theTimestamp) { + long thisTime = this.getTime(); + long compareTime = theTimestamp.getTime(); + + // If the time value is later, the timestamp is later + if (thisTime > compareTime) { + return true; + } + // If the time value is earlier, the timestamp is not later + else if (thisTime < compareTime) { + return false; + } + /* + * Otherwise the time values are equal in which case the nanoseconds + * value determines whether this timestamp is later... + */ + else if (this.getNanos() > theTimestamp.getNanos()) { + return true; + } else { + return false; + } + } + + /** + * Returns true if this timestamp object is earlier than the supplied + * timestamp, otherwise returns false. + * + * @param theTimestamp + * the timestamp to compare with this timestamp object + * @return true if this timestamp object is earlier than the supplied + * timestamp, false otherwise + */ + public boolean before(Timestamp theTimestamp) { + long thisTime = this.getTime(); + long compareTime = theTimestamp.getTime(); + + // If the time value is later, the timestamp is later + if (thisTime < compareTime) { + return true; + } + // If the time value is earlier, the timestamp is not later + else if (thisTime > compareTime) { + return false; + } + /* + * Otherwise the time values are equal in which case the nanoseconds + * value determines whether this timestamp is later... + */ + else if (this.getNanos() < theTimestamp.getNanos()) { + return true; + } else { + return false; + } + } + + /** + * Compares this Timestamp object with a supplied Timestamp object + * + * @param theObject + * the timestamp to compare with this timestamp object, passed in + * as an Object + * @return 0 if the two Timestamp objects are equal in time, a value <0 if + * this Timestamp object is before the supplied Timestamp and a + * value >0 if this Timestamp object is after the supplied Timestamp + * @throws ClassCastException + * if the supplied object is not a Timestamp object + */ + @Override + public int compareTo(Date theObject) throws ClassCastException { + return this.compareTo((Timestamp) theObject); + } + + /** + * Compares this Timestamp object with a supplied Timestamp object + * + * @param theTimestamp + * the timestamp to compare with this timestamp object, passed in + * as a Timestamp + * @return 0 if the two Timestamp objects are equal in time, a value <0 if + * this Timestamp object is before the supplied Timestamp and a + * value >0 if this Timestamp object is after the supplied Timestamp + */ + public int compareTo(Timestamp theTimestamp) { + int result = super.compareTo(theTimestamp); + if (result == 0) { + int thisNano = this.getNanos(); + int thatNano = theTimestamp.getNanos(); + if (thisNano > thatNano) { + return 1; + } else if (thisNano == thatNano) { + return 0; + } else { + return -1; + } + } + return result; + } + + /** + * Tests to see if this timestamp is equal to a supplied object. + * + * @param theObject + * @return true if this Timestamp object is equal to the supplied Timestamp + * object false if the object is not a Timestamp object or if the + * object is a Timestamp but represents a different instant in time + */ + @Override + public boolean equals(Object theObject) { + if (theObject instanceof Timestamp) { + return equals((Timestamp) theObject); + } + return false; + } + + /** + * Tests to see if this timestamp is equal to a supplied timestamp. + * + * @param theTimestamp + * the timestamp to compare with this timestamp object, passed in + * as an Object + * @return true if this Timestamp object is equal to the supplied Timestamp + * object + */ + public boolean equals(Timestamp theTimestamp) { + if (theTimestamp == null) { + return false; + } + return (this.getTime() == theTimestamp.getTime()) + && (this.getNanos() == theTimestamp.getNanos()); + } + + /** + * Gets this Timestamp's nanosecond value + * + * @return The timestamp's nanosecond value, an integer between 0 and + * 999,999,999 + */ + public int getNanos() { + return nanos; + } + + /** + * Returns the time represented by this Timestamp object, as a long value + * containing the number of milliseconds since the Epoch (January 1 1970, + * 00:00:00.000 GMT) + */ + @Override + public long getTime() { + long theTime = super.getTime(); + theTime = theTime + (nanos / 1000000); + return theTime; + } + + /** + * Sets the nanosecond value for this timestamp + * @param n number of nanoseconds + * @throws IllegalArgumentException if number of nanoseconds smaller than 0 + * or greater than 999999999 + */ + public void setNanos(int n) throws IllegalArgumentException { + if ((n < 0) || (n > 999999999)) { + // sql.0=Value out of range + throw new IllegalArgumentException(Messages.getString("sql.0")); //$NON-NLS-1$ + } + nanos = n; + } + + /** + * Sets the time represented by this Timestamp object to the supplied time, + * defined as the number of milliseconds since the Epoch (January 1 1970, + * 00:00:00.000 GMT) + */ + @Override + public void setTime(long theTime) { + /* + * Deal with the nanoseconds value. The supplied time is in milliseconds - + * so we must extract the milliseconds value and multiply by 1000000 to + * get nanoseconds. Things are more complex if theTime value is + * negative, since then the time value is the time before the Epoch but + * the nanoseconds value of the Timestamp must be positive - so we must + * take the "raw" milliseconds value and subtract it from 1000 to get to + * the true nanoseconds value Simultaneously, recalculate the time value + * to the exact nearest second and reset the Date time value + */ + int milliseconds = (int) (theTime % 1000); + theTime = theTime - milliseconds; + if (milliseconds < 0) { + theTime = theTime - 1000; + milliseconds = 1000 + milliseconds; + } + super.setTime(theTime); + setNanos(milliseconds * 1000000); + } + + /** + * Returns the timestamp formatted as a String in the JDBC Timestamp Escape + * format, which is of the form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn" + * + * @return A string representing the instant defined by the Timestamp, in + * JDBC Timestamp escape format + */ + @SuppressWarnings("deprecation") + @Override + public String toString() { + /* + * Use a DecimalFormat to lay out the nanosecond value as a simple + * string of 9 integers, with leading Zeros + */ + DecimalFormat decimalFormat = new DecimalFormat("0"); //$NON-NLS-1$ + decimalFormat.setMinimumIntegerDigits(9); + decimalFormat.setMaximumIntegerDigits(9); + String theNanos = decimalFormat.format(nanos); + theNanos = stripTrailingZeros(theNanos); + + String year = format((getYear() + 1900), 4); + String month = format((getMonth() + 1), 2); + String date = format(getDate(), 2); + String hours = format(getHours(), 2); + String minutes = format(getMinutes(), 2); + String seconds = format(getSeconds(), 2); + + return year + '-' + month + '-' + date + ' ' + hours + ':' + minutes + + ':' + seconds + '.' + theNanos; + } + + /* + * Private method to format the time + */ + private String format(int date, int digits) { + StringBuilder dateStringBuffer = new StringBuilder(String.valueOf(date)); + while (dateStringBuffer.length() < digits) { + dateStringBuffer = dateStringBuffer.insert(0,'0'); + } + return dateStringBuffer.toString(); + } + + /* + * Private method to strip trailing '0' characters from a string. @param + * inputString the starting string @return a string with the trailing zeros + * stripped - will leave a single 0 at the beginning of the string + */ + private String stripTrailingZeros(String inputString) { + String finalString; + + int i; + for (i = inputString.length(); i > 0; i--) { + if (inputString.charAt(i - 1) != '0') { + break; + } + /* + * If the string has a 0 as its first character, return a string + * with a single '0' + */ + if (i == 1) { + return "0"; //$NON-NLS-1$ + } + } + + finalString = inputString.substring(0, i); + return finalString; + } + + /** + * Creates a Timestamp object with a time value equal to the time specified + * by a supplied String holding the time in JDBC timestamp escape format, + * which is of the form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn" + * + * @param s + * the String containing a time in JDBC timestamp escape format + * @return A timestamp object with time value as defined by the supplied + * String + * @throws IllegalArgumentException if the provided String is null + */ + public static Timestamp valueOf(String s) throws IllegalArgumentException { + if (s == null) { + // sql.3=Argument cannot be null + throw new IllegalArgumentException(Messages.getString("sql.3")); //$NON-NLS-1$ + } + + SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //$NON-NLS-1$ + ParsePosition pp = new ParsePosition(0); + + /* + * First parse out the yyyy-MM-dd HH:mm:ss component of the String into + * a Date object using the SimpleDateFormat. This should stop after the + * seconds value, according to the definition of SimpleDateFormat.parse, + * with the ParsePosition indicating the index of the "." which should + * precede the nanoseconds value + */ + Date theDate; + try { + theDate = df.parse(s, pp); + } catch (Exception e) { + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + + if (theDate == null) { + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + + /* + * If we get here, the Date part of the string was OK - now for the + * nanoseconds value. Strictly, this requires the remaining part of the + * String to look like ".nnnnnnnnn". However, we accept anything with a + * '.' followed by 1 to 9 digits - we also accept nothing (no fractions + * of a second). Anything else is interpreted as incorrect format which + * will generate an IllegalArgumentException + */ + int position = pp.getIndex(); + int remaining = s.length() - position; + int theNanos; + + if (remaining == 0) { + // First, allow for the case where no fraction of a second is given: + theNanos = 0; + } else { + /* + * Case where fraction of a second is specified: Require 1 character + * plus the "." in the remaining part of the string... + */ + if ((s.length() - position) < ".n".length()) { //$NON-NLS-1$ + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + + /* + * If we're strict, we should not allow any EXTRA characters after + * the 9 digits + */ + if ((s.length() - position) > ".nnnnnnnnn".length()) { //$NON-NLS-1$ + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + + // Require the next character to be a "." + if (s.charAt(position) != '.') { + // sql.4=Bad input string format: expected '.' not {0} + throw new NumberFormatException(Messages.getString("sql.4", s.charAt(position))); //$NON-NLS-1$ + } + // Get the length of the number string - need to account for the '.' + int nanoLength = s.length() - position - 1; + + // Get the 9 characters following the "." as an integer + String theNanoString = s.substring(position + 1, position + 1 + + nanoLength); + /* + * We must adjust for the cases where the nanos String was not 9 + * characters long by padding out with zeros + */ + theNanoString = theNanoString + "000000000"; //$NON-NLS-1$ + theNanoString = theNanoString.substring(0, 9); + + try { + theNanos = Integer.parseInt(theNanoString); + } catch (Exception e) { + // If we get here, the string was not a number + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + } + + if (theNanos < 0 || theNanos > 999999999) { + throw new IllegalArgumentException(Messages.getString("sql.2")); //$NON-NLS-1$ + } + + Timestamp theTimestamp = new Timestamp(theDate.getTime()); + theTimestamp.setNanos(theNanos); + + return theTimestamp; + } +} diff --git a/sql/src/main/java/java/sql/Types.java b/sql/src/main/java/java/sql/Types.java new file mode 100644 index 0000000..5e9aa4c --- /dev/null +++ b/sql/src/main/java/java/sql/Types.java @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package java.sql; + +/** + * A class which defines constants used to identify generic SQL types, also + * called JDBC types. The type constant values are equivalent to those in XOPEN. + */ +public class Types { + + /* + * Private constructor to prevent instantiation. + */ + private Types() { + super(); + } + + /** + * The type code that identifies the SQL type ARRAY. + */ + public static final int ARRAY = 2003; + + /** + * The type code that identifies the SQL type BIGINT. + */ + public static final int BIGINT = -5; + + /** + * The type code that identifies the SQL type BINARY. + */ + public static final int BINARY = -2; + + /** + * The type code that identifies the SQL type BIT. + */ + public static final int BIT = -7; + + /** + * The type code that identifies the SQL type BLOB. + */ + public static final int BLOB = 2004; + + /** + * The type code that identifies the SQL type BOOLEAN. + */ + public static final int BOOLEAN = 16; + + /** + * The type code that identifies the SQL type CHAR. + */ + public static final int CHAR = 1; + + /** + * The type code that identifies the SQL type CLOB. + */ + public static final int CLOB = 2005; + + /** + * The type code that identifies the SQL type DATALINK. + */ + public static final int DATALINK = 70; + + /** + * The type code that identifies the SQL type DATE. + */ + public static final int DATE = 91; + + /** + * The type code that identifies the SQL type DECIMAL. + */ + public static final int DECIMAL = 3; + + /** + * The type code that identifies the SQL type DISTINCT. + */ + public static final int DISTINCT = 2001; + + /** + * The type code that identifies the SQL type DOUBLE. + */ + public static final int DOUBLE = 8; + + /** + * The type code that identifies the SQL type FLOAT. + */ + public static final int FLOAT = 6; + + /** + * The type code that identifies the SQL type INTEGER. + */ + public static final int INTEGER = 4; + + /** + * The type code that identifies the SQL type JAVA_OBJECT. + */ + public static final int JAVA_OBJECT = 2000; + + /** + * The type code that identifies the SQL type LONGVARBINARY. + */ + public static final int LONGVARBINARY = -4; + + /** + * The type code that identifies the SQL type LONGVARCHAR. + */ + public static final int LONGVARCHAR = -1; + + /** + * The type code that identifies the SQL type NULL. + */ + public static final int NULL = 0; + + /** + * The type code that identifies the SQL type NUMERIC. + */ + public static final int NUMERIC = 2; + + /** + * The type code that identifies that the SQL type is database specific and + * is mapped to a Java object, accessed via the methods + * <code>getObject</code> and <code>setObject</code>. + */ + public static final int OTHER = 1111; + + /** + * The type code that identifies the SQL type REAL. + */ + public static final int REAL = 7; + + /** + * The type code that identifies the SQL type REF. + */ + public static final int REF = 2006; + + /** + * The type code that identifies the SQL type SMALLINT. + */ + public static final int SMALLINT = 5; + + /** + * The type code that identifies the SQL type STRUCT. + */ + public static final int STRUCT = 2002; + + /** + * The type code that identifies the SQL type TIME. + */ + public static final int TIME = 92; + + /** + * The type code that identifies the SQL type TIMESTAMP. + */ + public static final int TIMESTAMP = 93; + + /** + * The type code that identifies the SQL type TINYINT. + */ + public static final int TINYINT = -6; + + /** + * The type code that identifies the SQL type VARBINARY. + */ + public static final int VARBINARY = -3; + + /** + * The type code that identifies the SQL type VARCHAR. + */ + public static final int VARCHAR = 12; +} diff --git a/sql/src/main/java/java/sql/package.html b/sql/src/main/java/java/sql/package.html new file mode 100644 index 0000000..e46f170 --- /dev/null +++ b/sql/src/main/java/java/sql/package.html @@ -0,0 +1,7 @@ +<html> + <body> + <p> + Provides a standard interface for accessing SQL-based databases. + <p> + </body> +</html>
\ No newline at end of file diff --git a/sql/src/main/java/javax/sql/ConnectionEvent.java b/sql/src/main/java/javax/sql/ConnectionEvent.java new file mode 100644 index 0000000..e8ec7c3 --- /dev/null +++ b/sql/src/main/java/javax/sql/ConnectionEvent.java @@ -0,0 +1,72 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.util.EventObject; +import java.sql.SQLException; +import java.io.Serializable; + +/** + * An Event object which is sent when specific events happen on a + * PooledConnection object. The events involved are when the application closing + * the PooledConnection and when an error occurs in the PooledConnection. + */ +public class ConnectionEvent extends EventObject implements Serializable { + + private static final long serialVersionUID = -4843217645290030002L; + + private SQLException theSQLException; + + /** + * Creates a connection event initialized with a supplied PooledConnection. + * + * @param theConnection + * the PooledConnection + */ + public ConnectionEvent(PooledConnection theConnection) { + super(theConnection); + } + + /** + * Creates a ConnectionEvent initialized with a supplied PooledConnection + * and with a supplied SQLException indicating that an error has occurred + * within the PooledConnection. + * + * @param theConnection + * the PooledConnection + * @param theException + * the SQLException holding information about the error that has + * occurred, which is about to be returned to the application. + */ + public ConnectionEvent(PooledConnection theConnection, + SQLException theException) { + super(theConnection); + theSQLException = theException; + } + + /** + * Gets the SQLException which holds information about the error which + * occurred in the PooledConnection. + * + * @return an SQLException containing information about the error. May be + * null if no error has occurred. + */ + public SQLException getSQLException() { + return theSQLException; + } +} diff --git a/sql/src/main/java/javax/sql/ConnectionEventListener.java b/sql/src/main/java/javax/sql/ConnectionEventListener.java new file mode 100644 index 0000000..7156558 --- /dev/null +++ b/sql/src/main/java/javax/sql/ConnectionEventListener.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.util.EventListener; + +/** + * An interface used to receive events generated by a + * <code>PooledConnection</code>. + * <p> + * This interface would typically be implemented by a component which implements + * Connection Pooling (a Connection Pool Manager). A Connection will signal + * events to a ConnectionEventListener either when the application closes a + * Connection it has been using or when a significant error occurs while the + * Connection is being used, where the Connection should not be used again. + * <p> + * The Connection Pool Manager can return closed Connections to the Pool for + * later reuse. Connections experiencing an error should be discarded. + * + */ +public interface ConnectionEventListener extends EventListener { + + /** + * Notifies the ConnectionEventListener that an application has called the + * <code>close</code> method on a pooled Connection. + * + * @param theEvent + * a ConnectionEvent containing detail about the source of the + * event. + */ + public void connectionClosed(ConnectionEvent theEvent); + + /** + * Notifies the ConnectionEventListener that an error has occurred while a + * PooledConnection was being used and that the PooledConnection can no + * longer be used for work. This notification is done just before the + * SQLException passed in the event message is thrown to the application. + * + * @param theEvent + * a ConnectionEvent containing detail about the source of the + * event and the SQLException that has occurred. + */ + public void connectionErrorOccurred(ConnectionEvent theEvent); +} diff --git a/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java b/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java new file mode 100644 index 0000000..5be75d9 --- /dev/null +++ b/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java @@ -0,0 +1,123 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; +import java.io.PrintWriter; + +/** + * An interface for the creation of PooledConnection objects. Used internally + * within the package. + * <p> + * A class which implements the ConnectionPoolDataSource interface is typically + * registered with a JNDI naming service directory and is retrieved from there + * by name. + */ +public interface ConnectionPoolDataSource { + + /** + * Gets the Login Timeout value for this ConnectionPoolDataSource. The Login + * Timeout is the maximum time in seconds that the ConnectionPoolDataSource + * will wait when opening a connection to a database. A Timeout value of 0 + * implies either the system default timeout value (if there is one) or that + * there is no timeout. The default value for the Login Timeout is 0. + * + * @return the Login Timeout value in seconds. + * @throws SQLException + * if there is a problem accessing the database. + */ + public int getLoginTimeout() throws SQLException; + + /** + * Gets the Log Writer for this ConnectionPoolDataSource. + * <p> + * The Log Writer is a stream to which all log and trace messages are sent + * from this ConnectionPoolDataSource. The Log Writer can be null, in which + * case, log and trace capture is disabled. The default value for the Log + * Writer when an ConnectionPoolDataSource is created is null. Note that the + * Log Writer for an ConnectionPoolDataSource is not the same as the Log + * Writer used by a <code>DriverManager</code>. + * + * @return a PrintWriter which is the Log Writer for this + * ConnectionPoolDataSource. Can be null, in which case log writing + * is disabled for this ConnectionPoolDataSource. + * @throws SQLException + * if there is a problem accessing the database. + */ + public PrintWriter getLogWriter() throws SQLException; + + /** + * Create a connection to a database which can then be used as a pooled + * connection. + * + * @return a PooledConnection which represents the connection to the + * database + * @throws SQLException + * if there is a problem accessing the database. + */ + public PooledConnection getPooledConnection() throws SQLException; + + /** + * Create a connection to a database, using a supplied Username and + * Password, which can then be used as a pooled connection. + * + * @param theUser + * a String containing a User Name for the database + * @param thePassword + * a String containing the Password for the user identified by + * <code>theUser</code> + * @return a PooledConnection which represents the connection to the + * database + * @throws SQLException + * if there is a problem accessing the database. + */ + public PooledConnection getPooledConnection(String theUser, + String thePassword) throws SQLException; + + /** + * Sets the Login Timeout value for this ConnectionPoolDataSource. The Login + * Timeout is the maximum time in seconds that the ConnectionPoolDataSource + * will wait when opening a connection to a database. A Timeout value of 0 + * implies either the system default timeout value (if there is one) or that + * there is no timeout. The default value for the Login Timeout is 0. + * + * @param theTimeout + * the new Login Timeout value in seconds. + * @throws SQLException + * if there is a problem accessing the database. + */ + public void setLoginTimeout(int theTimeout) throws SQLException; + + /** + * Sets the Log Writer for this ConnectionPoolDataSource. + * <p> + * The Log Writer is a stream to which all log and trace messages are sent + * from this ConnectionPoolDataSource. The Log Writer can be null, in which + * case, log and trace capture is disabled. The default value for the Log + * Writer when an ConnectionPoolDataSource is created is null. Note that the + * Log Writer for an ConnectionPoolDataSource is not the same as the Log + * Writer used by a <code>DriverManager</code>. + * + * @param theWriter + * a PrintWriter to use as the Log Writer for this + * ConnectionPoolDataSource. + * @throws SQLException + * if there is a problem accessing the database. + */ + public void setLogWriter(PrintWriter theWriter) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/DataSource.java b/sql/src/main/java/javax/sql/DataSource.java new file mode 100644 index 0000000..cd3e0a3 --- /dev/null +++ b/sql/src/main/java/javax/sql/DataSource.java @@ -0,0 +1,138 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; +import java.sql.Connection; +import java.io.PrintWriter; + +/** + * An interface for the creation of Connection objects which represent a + * connection to a database. This interface is an alternative to the + * <code>java.sql.DriverManager</code>. + * <p> + * A class which implements the DataSource interface is typically registered + * with a JNDI naming service directory and is retrieved from there by name. + * <p> + * The DataSource interface is typically implemented by the writer of a JDBC + * driver. There are three variants of the DataSource interface, which produce + * Connections with differing characteristics: + * <ol> + * <li>Standard DataSource, which produces standard Connection objects with no + * special features.</li> + * <li>Connection Pool DataSource, which produces PooledConnection objects + * which are able to participate in connection pooling, typically involving a + * connection pooling manager as an intermediary between applications and the + * database.</li> + * <li>Distributed transaction DataSource ("XADataSource"), which produces + * XAConnection objects which can be used to handle distributed transactions and + * which typically involve a transaction manager component in the system. + * XAConnection objects also typically provide connection pooling capabilities + * as well as distributed transaction capabilities. </li> + * </ol> + * <p> + * Note that a JDBC driver which is accessed via the DataSource interface is + * loaded via a JNDI lookup process. A driver loaded in this way does not + * register itself with the <code>DriverManager</code>. + */ +public interface DataSource { + + /** + * Creates a connection to the database represented by this DataSource. + * + * @return a Connection object which is a connection to the database. + * @throws SQLException + * if there is a problem accessing the database. + */ + public Connection getConnection() throws SQLException; + + /** + * Creates a connection to the database represented by this DataSource, + * using a supplied Username and Password,. + * + * @param theUsername + * a String containing a User Name for the database + * @param thePassword + * a String containing the Password for the user identified by + * <code>theUsername</code> + * @return a Connection object which is a connection to the database. + * @throws SQLException + * if there is a problem accessing the database. + */ + public Connection getConnection(String theUsername, String thePassword) + throws SQLException; + + /** + * Gets the Login Timeout value for this DataSource. The Login Timeout is + * the maximum time in seconds that the DataSource will wait when opening a + * connection to a database. A Timeout value of 0 implies either the system + * default timeout value (if there is one) or that there is no timeout. The + * default value for the Login Timeout is 0. + * + * @return the Login Timeout value in seconds. + * @throws SQLException + * if there is a problem accessing the database. + */ + public int getLoginTimeout() throws SQLException; + + /** + * Gets the Log Writer for this DataSource. + * <p> + * The Log Writer is a stream to which all log and trace messages are sent + * from this DataSource. The Log Writer can be null, in which case, log and + * trace capture is disabled. The default value for the Log Writer when an + * DataSource is created is null. Note that the Log Writer for an DataSource + * is not the same as the Log Writer used by a <code>DriverManager</code>. + * + * @return a PrintWriter which is the Log Writer for this DataSource. Can be + * null, in which case log writing is disabled for this DataSource. + * @throws SQLException + * if there is a problem accessing the database. + */ + public PrintWriter getLogWriter() throws SQLException; + + /** + * Sets the Login Timeout value for this DataSource. The Login Timeout is + * the maximum time in seconds that the DataSource will wait when opening a + * connection to a database. A Timeout value of 0 implies either the system + * default timeout value (if there is one) or that there is no timeout. The + * default value for the Login Timeout is 0. + * + * @param theTimeout + * the new Login Timeout value in seconds. + * @throws SQLException + * if there is a problem accessing the database. + */ + public void setLoginTimeout(int theTimeout) throws SQLException; + + /** + * Sets the Log Writer for this DataSource. + * <p> + * The Log Writer is a stream to which all log and trace messages are sent + * from this DataSource. The Log Writer can be null, in which case, log and + * trace capture is disabled. The default value for the Log Writer when an + * DataSource is created is null. Note that the Log Writer for an DataSource + * is not the same as the Log Writer used by a <code>DriverManager</code>. + * + * @param theWriter + * a PrintWriter to use as the Log Writer for this DataSource. + * @throws SQLException + * if there is a problem accessing the database. + */ + public void setLogWriter(PrintWriter theWriter) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/PooledConnection.java b/sql/src/main/java/javax/sql/PooledConnection.java new file mode 100644 index 0000000..50f7ae9 --- /dev/null +++ b/sql/src/main/java/javax/sql/PooledConnection.java @@ -0,0 +1,111 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; +import java.sql.Connection; + +/** + * An interface which provides facilities for handling connections to a database + * which are pooled. + * <p> + * Typically, a PooledConnection is recycled when it is no longer required by an + * application, rather than being closed and discarded. The reason for treating + * connections in this way is that it can be an expensive process both to + * establish a connection to a database and to destroy the connection. Reusing + * connections through a pool is a way of improving system performance and + * reducing overhead. + * <p> + * It is not intended that an application use the PooledConnection interface + * directly. The PooledConnection interface is intended for use by a component + * called a Connection Pool Manager, typically part of the infrastructure that + * supports use of the database by applications. + * <p> + * Applications obtain connections to the database by calling the + * <code>DataSource.getConnection</code> method. Under the covers, the + * Connection Pool Manager will get a PooledConnection object from its + * connection pool and passes back a Connection object that wraps or references + * the PooledConnection object. A new PooledConnection object will only be + * created if the pool is empty. + * <p> + * When the application is finished using a PooledConnection, the application + * calls the <code>Connection.close</code> method. The Connection Pool Manager + * is notified via a ConnectionEvent from the Connection that this has happened + * (the Pool Manager registers itself with the Connection before the Connection + * is given to the application). The Pool Manager removes the underlying + * PooledConnection object from the Connection and returns it to the pool for + * reuse - the PooledConnection is thus recycled rather than being destroyed. + * <p> + * The connection to the database represented by the PooledConnection is kept + * open until the PooledConnection object itself is deactivated by the + * Connection Pool Manager, which calls the <code>PooledConnection.close</code> + * method. This is typically done if there are too many inactive connections in + * the pool, if the PooledConnection encounters a problem that makes it unusable + * or if the whole system is being shut down. + * + */ +public interface PooledConnection { + + /** + * Registers the supplied ConnectionEventListener with this + * PooledConnection. Once registered, the ConnectionEventListener will + * receive ConnectionEvent events when they occur in the PooledConnection. + * + * @param theListener + * an object which implements the ConnectionEventListener + * interface. + */ + public void addConnectionEventListener(ConnectionEventListener theListener); + + /** + * Closes the connection to the database held by this PooledConnection. This + * method should not be called directly by application code - it is intended + * for use by the Connection Pool manager component. + * + * @throws SQLException + * if there is a problem accessing the database. + */ + public void close() throws SQLException; + + /** + * Creates a connection to the database. This method is typically called by + * the Connection Pool manager when an application invokes the method + * <code>DataSource.getConnection</code> and there are no PooledConnection + * objects available in the connection pool. + * + * @return a Connection object that is a handle to this PooledConnection + * object. + * @throws SQLException + * if there is a problem accessing the database. + */ + public Connection getConnection() throws SQLException; + + /** + * Deregister the supplied ConnectionEventListener from this + * PooledConnection. Once deregistered, the ConnectionEventListener will not + * longer receive events occurring in the PooledConnection. + * + * @param theListener + * an object which implements the ConnectionEventListener + * interface. This object should have previously been registered + * with the PooledConnection using the + * <code>addConnectionEventListener</code> method. + */ + public void removeConnectionEventListener( + ConnectionEventListener theListener); +} diff --git a/sql/src/main/java/javax/sql/RowSet.java b/sql/src/main/java/javax/sql/RowSet.java new file mode 100644 index 0000000..2794ff2 --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSet.java @@ -0,0 +1,856 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Array; +import java.sql.Blob; +import java.sql.Clob; +import java.sql.Date; +import java.sql.Ref; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Map; +import java.io.InputStream; +import java.io.Reader; +import java.util.Calendar; +import java.math.BigDecimal; + +/** + * A RowSet is an interface which provides access to data being sent from/to a + * database and which extends the functionality of ResultSet into a form that + * can be used as a JavaBeans component, perhaps being used in a visual + * programming environment. + * <p> + * Facilities are provided for get/set of properties relating to the Database + * and the SQL Command and for getting/setting data within the Rows represented + * by the RowSet. The RowSet supports JavaBeans events so that other components + * in an application can be informed when various changes happen to the RowSet, + * such as changes in data values. + * <p> + * RowSet is implemented as a layer on top of the remainder of the JDBC API. A + * RowSet may be <i>connected</i> where it maintains a connection to the + * database throughout its lifecycle. A RowSet may be <i>disconnected</i> where + * it establishes a connection to the database, gets data and then closes the + * connection. Updates to a disconnected RowSet can be made and later send back + * the changes to the database, but this requires the RowSet to first reconnect + * to the database before the changes are sent back. + * <p> + * Disconnected RowSets may make use of RowSetReaders to populate the RowSet + * with data, possibly from a non-relational database source. Disconnected + * RowSets may also use RowSetWriters to send data back to the underlying data + * store. There is considerable freedom in the way that RowSetReaders and + * RowSetWriters are implemented to get and store data. + */ +public interface RowSet extends ResultSet { + + /** + * Registers a supplied RowSetListener with this RowSet. Once registered, + * the RowSetListener is notified of events generated by the RowSet. + * + * @param theListener + * an object which implements the <code>rowSetListener</code> + * interface. + */ + public void addRowSetListener(RowSetListener theListener); + + /** + * Clears the parameters previously set for this RowSet. + * <p> + * Parameter values apply to repeated use of a RowSet object. Setting a new + * value for a parameter clears its previous value. + * <code>clearParameters</code> clears the values for all parameters with + * one method call. + * + * @throws SQLException + * if a problem occurs accessing the database + */ + public void clearParameters() throws SQLException; + + /** + * Fetches data for this RowSet. If successful, any existing data for the + * RowSet is discarded and the metadata for the rowset is set. + * <p> + * Data is retrieved connects to the database and executes a Command. This + * requires some or all of the following properties to be set: url, data + * source name, user name, password, transaction isolation, type map ; plus + * some or all of the properties: command, read only, maximum field size, + * maximum rows, escape processing, and query timeout. + * <p> + * The RowSet may use a RowSetReader to access the database - in this case a + * reader must be registered with the RowSet and the RowSet will then invoke + * the <code>readData</code> method on the reader to fetch the data. + * + * @throws SQLException + * if a problem occurs accessing the database or if the + * properties needed to access the database have not been set + */ + public void execute() throws SQLException; + + /** + * Gets the RowSet's Command property. + * + * @return a string containing the RowSet's Command property - this is an + * SQL Query which can be executed to fetch data into the RowSet. + */ + public String getCommand(); + + /** + * Gets the name of the datasource for this RowSet. + * + * @return a String containing the name of the datasource. + */ + public String getDataSourceName(); + + /** + * Reports if escape processing is enabled for this RowSet. + * <p> + * If <code>true</code> (the default) the driver will automatically + * perform escape code processing on SQL statements prior to them being sent + * to the database. + * + * @return true if escape processing is enabled, false otherwise. + * @throws SQLException + * if a problem occurs accessing the database + */ + public boolean getEscapeProcessing() throws SQLException; + + /** + * Gets the maximum number of bytes that can be returned for column values + * which are of types BINARY, VARBINARY, LONGVARBINARYBINARY, CHAR, VARCHAR, + * or LONGVARCHAR. Excess data is silently discarded if the number is + * exceeded. + * + * @return the current maximum size in bytes. 0 means no limit + * @throws SQLException + * if a problem occurs accessing the database + */ + public int getMaxFieldSize() throws SQLException; + + /** + * Gets the maximum number of rows for this RowSet. Excess rows are + * discarded silently if the limit is exceeded. + * + * @return the previous maximum number of rows. 0 implies no limit. + * @throws SQLException + * if a problem occurs accessing the database + */ + public int getMaxRows() throws SQLException; + + /** + * Gets the value of the password property for this RowSet. This property + * is used when making a connection to the database and should be set before + * invoking the <code>execute</code> method. + * + * @return a String containing the value of the password property. + */ + public String getPassword(); + + /** + * Gets the Timeout for the driver when executing a Query operation. + * <p> + * If a Query takes longer than the Timeout, an exception is thrown. + * + * @return the Timeout value in seconds. + * @throws SQLException + * if an error occurs accessing the database. + */ + public int getQueryTimeout() throws SQLException; + + /** + * Gets the transaction isolation property setting for this RowSet. + * + * @return an integer holding the current transaction isolation setting. One + * of: one of Connection.TRANSACTION_READ_UNCOMMITTED, + * Connection.TRANSACTION_READ_COMMITTED, + * Connection.TRANSACTION_REPEATABLE_READ, + * Connection.TRANSACTION_SERIALIZABLE + */ + public int getTransactionIsolation(); + + /** + * Gets the custom mapping of SQL types for this RowSet, if any. + * + * @return a Map holding the custom mappings of SQL types to Java classes for + * this RowSet. By default, the Map is empty. + * @throws SQLException + * if an error occurs accessing the database. + */ + public Map<String, Class<?>> getTypeMap() throws SQLException; + + /** + * Gets the URL property value for this RowSet. If there is no DataSource + * object specified, the RowSet uses the URL to establish a connection to + * the database. The default value for the URL is null. + * + * @return a String holding the value of the URL property. + * @throws SQLException + * if an error occurs accessing the database. + */ + public String getUrl() throws SQLException; + + /** + * Gets the value of the Username property for this RowSet. The Username is + * used when establishing a connection to the database and should be set + * before the <code>execute</code> method is invoked. + * + * @return a String holing the value of the Username property. + */ + public String getUsername(); + + /** + * Reports if this RowSet is read only. + * + * @return true if this RowSet is read only, false if it is updateable. + */ + public boolean isReadOnly(); + + /** + * Removes a specified RowSetListener object from the set of listeners which + * will be notified of events by this RowSet. + * + * @param theListener + * the RowSetListener to remove from the set of listeners for + * this RowSet. + */ + public void removeRowSetListener(RowSetListener theListener); + + /** + * Sets the specified ARRAY parameter in the RowSet command with the + * supplied java.sql.Array value. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theArray + * the java.sql.Array value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setArray(int parameterIndex, Array theArray) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * ASCII data in the supplied java.io.InputStream value. Data is read from + * the InputStream until end-of-file is reached. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theInputStream + * an InputStream containing the ASCII data to set into the + * parameter value + * @param length + * the length of the data in bytes + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setAsciiStream(int parameterIndex, InputStream theInputStream, + int length) throws SQLException; + + /** + * Sets the value of the specified SQL NUMERIC parameter in the RowSet + * command with the data in the supplied java.math.BigDecimal value. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theBigDecimal + * the BigDecimal containing the value + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setBigDecimal(int parameterIndex, BigDecimal theBigDecimal) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * binary data in the supplied java.io.InputStream value. Data is read from + * the InputStream until end-of-file is reached. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theInputStream + * an InputStream containing the binary data to set into the + * parameter value + * @param length + * the length of the data in bytes + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setBinaryStream(int parameterIndex, InputStream theInputStream, + int length) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * value of a supplied java.sql.Blob. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theBlob + * the Blob value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setBlob(int parameterIndex, Blob theBlob) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to the + * supplied boolean. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theBoolean + * the boolean value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setBoolean(int parameterIndex, boolean theBoolean) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to the + * supplied byte value. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theByte + * the byte value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setByte(int parameterIndex, byte theByte) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to the + * supplied byte array value. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theByteArray + * the array of bytes to set into the parameter. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setBytes(int parameterIndex, byte[] theByteArray) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to the + * sequence of Unicode characters carried by the supplied java.io.Reader. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theReader + * the Reader which contains the Unicode data to set into the + * parameter + * @param length + * the length of the data in the Reader in characters + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setCharacterStream(int parameterIndex, Reader theReader, + int length) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * value of a supplied java.sql.Clob. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theClob + * the Clob value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setClob(int parameterIndex, Clob theClob) throws SQLException; + + /** + * Sets the Command property for this RowSet - the command is an SQL Query + * which runs when the <code>execute</code> method is invoked. This + * property is optional for datasources that do not support commands. + * + * @param cmd + * a String containing the SQL Query. Can be null. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setCommand(String cmd) throws SQLException; + + /** + * Sets the concurrency property of this RowSet. The default value is + * ResultSet.CONCUR_READ_ONLY. + * + * @param concurrency + * the new concurrency value - one of: ResultSet.CONCUR_READ_ONLY + * or ResultSet.CONCUR_UPDATABLE + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setConcurrency(int concurrency) throws SQLException; + + /** + * Sets the Data Source Name property for the RowSet. + * <p> + * The Data Source Name can be used to find a <code>DataSource</code> + * which has been registered with a naming service - the DataSource can then + * be used to create a connection to the database. + * + * @param name + * a String with the new Data Source Name. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setDataSourceName(String name) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * value of a supplied java.sql.Date. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theDate + * the Date to use + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setDate(int parameterIndex, Date theDate) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * value of a supplied java.sql.Date, where the conversion of the Date to an + * SQL DATE value is calculated using a supplied Calendar. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theDate + * the Date to use + * @param theCalendar + * the Calendar to use in converting the Date to an SQL DATE value + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setDate(int parameterIndex, Date theDate, Calendar theCalendar) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * supplied double. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theDouble + * the double value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setDouble(int parameterIndex, double theDouble) + throws SQLException; + + /** + * Sets the Escape Processing status for this RowSet. If escape processing + * is on, the driver performs escape substitution before sending an SQL + * command to the database. The default value for escape processing is on. + * + * @param enable + * true to enable Escape Processing, false to turn it off. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setEscapeProcessing(boolean enable) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * supplied float. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theFloat + * the float value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setFloat(int parameterIndex, float theFloat) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * supplied integer. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theInteger + * the integer value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setInt(int parameterIndex, int theInteger) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command with the + * supplied long. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theLong + * the long value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setLong(int parameterIndex, long theLong) throws SQLException; + + /** + * Sets the maximum number of bytes which can be returned for a column value + * where the column type BINARY, VARBINARY, LONGVARBINARYBINARY, CHAR, + * VARCHAR, or LONGVARCHAR. Data which exceeds this limit is silently + * discarded. For portability, a value greater than 256 is recommended. + * + * @param max + * the maximum size of the returned column value in bytes. 0 + * means unlimited. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setMaxFieldSize(int max) throws SQLException; + + /** + * Sets the maximum number of rows which can be held by the RowSet. Any + * additional rows are silently discarded. + * + * @param max + * the maximum number of rows which can be held in the RowSet. 0 + * means no limit. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setMaxRows(int max) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to SQL + * NULL. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param sqlType + * the type of the parameter, as defined by java.sql.Types. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setNull(int parameterIndex, int sqlType) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to SQL + * NULL. This form of the <code>setNull</code> method should be used for + * User Defined Types and REF parameters. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param sqlType + * the type of the parameter, as defined by java.sql.Types. + * @param typeName + * the fully qualified name of an SQL User Defined Type or the + * name of the SQL structured type referenced by a REF type. + * Ignored if the sqlType is not a UDT or REF type. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setNull(int parameterIndex, int sqlType, String typeName) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied Java object. + * <p> + * The JDBC specification provides a standard mapping for Java objects to + * SQL data types. Database specific types can be mapped by JDBC driver + * specific Java types. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theObject + * the Java object containing the data value. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setObject(int parameterIndex, Object theObject) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied Java object. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theObject + * the Java object containing the data value. + * @param targetSqlType + * the SQL type to send to the database, as defined in + * java.sql.Types. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setObject(int parameterIndex, Object theObject, + int targetSqlType) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied Java object. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theObject + * the Java object containing the data value. + * @param targetSqlType + * the SQL type to send to the database, as defined in + * java.sql.Types. + * @param scale + * the number of digits after the decimal point, for + * java.sql.Types.DECIMAL and java.sql.Types.NUMERIC types. + * Ignored for all other types. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setObject(int parameterIndex, Object theObject, + int targetSqlType, int scale) throws SQLException; + + /** + * Sets the database Password for this RowSet. + * + * @param password + * a string holding the new password + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setPassword(String password) throws SQLException; + + /** + * Sets the Timeout value for this RowSet. The timeout is the maximum time + * that the driver will wait while executing a command - after this time, an + * SQLException is thrown. + * + * @param seconds + * the number of seconds for the Timeout. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setQueryTimeout(int seconds) throws SQLException; + + /** + * Sets whether the RowSet is read only or is updateable. + * + * @param readOnly + * true to set the RowSet to readonly state, false to allow + * updates. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setReadOnly(boolean readOnly) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied java.sql.Ref. This is sent to the database as an SQL REF value. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theRef + * the Ref value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setRef(int parameterIndex, Ref theRef) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied short integer. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theShort + * the short value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setShort(int parameterIndex, short theShort) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied String. The String is placed into the database as a VARCHAR or + * LONGVARCHAR SQL value, depending on the database limits for the length of + * VARCHAR values. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theString + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setString(int parameterIndex, String theString) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied java.sql.Time, converting to an SQL TIME value using the system + * default Calendar. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theTime + * the Time value to set + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTime(int parameterIndex, Time theTime) throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied java.sql.Time, converting to an SQL TIME value using a supplied + * Calendar. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theTime + * the Time value to set + * @param theCalendar + * the Calendar to use in the conversion operation + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTime(int parameterIndex, Time theTime, Calendar theCalendar) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied java.sql.Timestamp, converting to an SQL TIMESTAMP value using + * the system default Calendar. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theTimestamp + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTimestamp(int parameterIndex, Timestamp theTimestamp) + throws SQLException; + + /** + * Sets the value of the specified parameter in the RowSet command to a + * supplied java.sql.Timestamp converting to an SQL TIMESTAMP value using a + * supplied Calendar. + * + * @param parameterIndex + * index of the parameter to set, where the first parameter has + * index = 1. + * @param theTimestamp + * @param theCalendar + * the Calendar to use in the conversion operation + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTimestamp(int parameterIndex, Timestamp theTimestamp, + Calendar theCalendar) throws SQLException; + + /** + * Updates the target instance's transaction isolation level to one of a + * discrete set of possible values. + * + * @param level + * the new transaction isolation level. One of: + * Connection.TRANSACTION_READ_UNCOMMITTED, + * Connection.TRANSACTION_READ_COMMITTED, + * Connection.TRANSACTION_REPEATABLE_READ, or + * Connection.TRANSACTION_SERIALIZABLE + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTransactionIsolation(int level) throws SQLException; + + /** + * Sets the type of this RowSet. By default, the type is non-scrollable. + * + * @param type + * the new type for the RowSet. One of: + * ResultSet.TYPE_FORWARD_ONLY, + * ResultSet.TYPE_SCROLL_INSENSITIVE, or + * ResultSet.TYPE_SCROLL_SENSITIVE + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setType(int type) throws SQLException; + + /** + * Sets the Map used to map SQL User Defined Types to Java classes. + * + * @param theTypeMap + * a Map which defines the names of SQL UDTs and the Java classes + * to which they are mapped. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setTypeMap(Map<String, Class<?>> theTypeMap) + throws SQLException; + + /** + * Sets the URL used by this RowSet to access the database via a + * <code>DriverManager</code>. The URL is optional - an alternative is to + * use a Data Source Name to create a connection. + * + * @param theURL + * a String containing the URL for the database. Can be null. + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setUrl(String theURL) throws SQLException; + + /** + * Sets the Username property for the RowSet, used to authenticate a + * connection to the database. + * + * @param theUsername + * a String containing the User Name + * @throws SQLException + * if an error occurs accessing the database. + */ + public void setUsername(String theUsername) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/RowSetEvent.java b/sql/src/main/java/javax/sql/RowSetEvent.java new file mode 100644 index 0000000..8682957 --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetEvent.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.util.EventObject; +import java.io.Serializable; + +/** + * An event which is sent when specific events happen to a RowSet object. The + * events are sent to inform registered listeners that changes have occurred to + * the RowSet. The events covered are: + * <ol> + * <li>A single row in the RowSet changes</li> + * <li>The whole set of data in the RowSet changes</li> + * <li>The RowSet cursor position changes</li> + * </ol> + * The event contains a reference to the RowSet object which generated the + * message so that the listeners can extract whatever information they need from + * that reference. + * + */ +public class RowSetEvent extends EventObject implements Serializable { + + private static final long serialVersionUID = -1875450876546332005L; + + /** + * Creates a RowSetEvent object containing a reference to the RowSet object + * that generated the event. Information about the changes that have + * occurred to the RowSet can be extracted from the RowSet using one or more + * of the query methods available on the RowSet. + * + * @param theSource + * the RowSet which generated the event + */ + public RowSetEvent(RowSet theSource) { + super(theSource); + } +} diff --git a/sql/src/main/java/javax/sql/RowSetInternal.java b/sql/src/main/java/javax/sql/RowSetInternal.java new file mode 100644 index 0000000..f224a13 --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetInternal.java @@ -0,0 +1,86 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; +import java.sql.Connection; +import java.sql.ResultSet; + +/** + * An interface provided by a RowSet object to either a RowSetReader or a + * RowSetWriter, providing facilities to read and update the internal state of + * the RowSet. + */ +public interface RowSetInternal { + + /** + * Gets the Connection associated with this RowSet object. + * + * @return the Connection + * @throws SQLException + * if there is a problem accessing the database. + */ + public Connection getConnection() throws SQLException; + + /** + * Gets the ResultSet that was the original (unmodified) content of the + * RowSet. + * <p> + * The ResultSet cursor is positioned before the first row of data + * + * @return the ResultSet that contained the original data value of the + * RowSet + * @throws SQLException + * if there is a problem accessing the database. + */ + public ResultSet getOriginal() throws SQLException; + + /** + * Gets the original value of the current row only. If the current row did + * not have an original value, then an empty value is returned. + * + * @return a ResultSet containing the value of the current row only. + * @throws SQLException + * if there is a problem accessing the database, or if the + * cursor is not on a valid row (before first, after last or + * pointing to the insert row). + */ + public ResultSet getOriginalRow() throws SQLException; + + /** + * Gets the parameter values that have been set for this RowSet's command. + * + * @return an Object array containing the values of parameters that have + * been set. + * @throws SQLException + * if there is a problem accessing the database. + */ + public Object[] getParams() throws SQLException; + + /** + * Sets RowSetMetaData for this RowSet. The RowSetMetaData is used by a + * RowSetReader to set values giving information about the RowSet's columns. + * + * @param theMetaData + * a RowSetMetaData holding the metadata about the RowSet's + * columns. + * @throws SQLException + * if there is a problem accessing the database. + */ + public void setMetaData(RowSetMetaData theMetaData) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/RowSetListener.java b/sql/src/main/java/javax/sql/RowSetListener.java new file mode 100644 index 0000000..a482d2b --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetListener.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.util.EventListener; + +/** + * An interface used to send notification of events occurring in a RowSet. To + * receive the notification events, an object must implement the RowSetListener + * interface and then register itself with the RowSet of interest using the + * <code>RowSet.addRowSetListener</code> method. + */ +public interface RowSetListener extends EventListener { + + /** + * Notifies the listener that one of the RowSet's rows has changed. + * + * @param theEvent + * a RowSetEvent that contains information about the RowSet + * involved. This information can be used to retrieve information + * about the change, such as the new cursor position. + */ + public void cursorMoved(RowSetEvent theEvent); + + /** + * Notifies the listener that the RowSet's cursor has moved. + * + * @param theEvent + * theEvent a RowSetEvent that contains information about the + * RowSet involved. This information can be used to retrieve + * information about the change, such as the updated data values. + */ + public void rowChanged(RowSetEvent theEvent); + + /** + * Notifies the listener that the RowSet's entire contents have been updated + * (an example is the execution of a command which retrieves new data from + * the database). + * + * @param theEvent + * theEvent a RowSetEvent that contains information about the + * RowSet involved. This information can be used to retrieve + * information about the change, such as the updated rows of + * data. + */ + public void rowSetChanged(RowSetEvent theEvent); +} diff --git a/sql/src/main/java/javax/sql/RowSetMetaData.java b/sql/src/main/java/javax/sql/RowSetMetaData.java new file mode 100644 index 0000000..89d6f7f --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetMetaData.java @@ -0,0 +1,283 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.ResultSetMetaData; +import java.sql.SQLException; + +/** + * An interface which provides facilities for getting information about the + * columns in a RowSet. + * <p> + * RowSetMetaData extends ResultSetMetaData, adding new operations for carrying + * out value sets. + * <p> + * Application code would not normally call this interface directly. It would be + * called internally when <code>RowSet.execute</code> is called. + */ +public interface RowSetMetaData extends ResultSetMetaData { + + /** + * Sets automatic numbering for a specified column in the RowSet. If + * automatic numbering is on, the column is read only. The default value is + * for automatic numbering to be off. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param autoIncrement + * true to set automatic numbering on, false to turn it off. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setAutoIncrement(int columnIndex, boolean autoIncrement) + throws SQLException; + + /** + * Sets the case sensitive property for a specified column in the RowSet. + * The default is that the column is not case sensitive. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param caseSensitive + * true to make the column case sensitive, false to make it not + * case sensitive. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setCaseSensitive(int columnIndex, boolean caseSensitive) + throws SQLException; + + /** + * Sets the Catalog Name for a specified column in the RowSet. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param catalogName + * a string containing the new Catalog Name + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setCatalogName(int columnIndex, String catalogName) + throws SQLException; + + /** + * Sets the number of columns in the Row Set. + * + * @param columnCount + * an integer containing the number of columns in the RowSet. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnCount(int columnCount) throws SQLException; + + /** + * Sets the normal maximum width in characters for a specified column in the + * RowSet. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param displaySize + * an integer with the normal maximum column width in characters + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnDisplaySize(int columnIndex, int displaySize) + throws SQLException; + + /** + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theLabel + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnLabel(int columnIndex, String theLabel) + throws SQLException; + + /** + * Sets the suggested column label for a specified column in the RowSet. + * This label is typically used in displaying or printing the column. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theColumnName + * a string containing the column label + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnName(int columnIndex, String theColumnName) + throws SQLException; + + /** + * Sets the SQL type for a specified column in the RowSet + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theSQLType + * an integer containing the SQL Type, as defined by + * java.sql.Types. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnType(int columnIndex, int theSQLType) + throws SQLException; + + /** + * Sets the Type Name for a specified column in the RowSet, where the data + * type is specific to the datasource. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theTypeName + * a string containing the Type Name for the column + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setColumnTypeName(int columnIndex, String theTypeName) + throws SQLException; + + /** + * Sets whether a specified column is a currency value. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param isCurrency + * true if the column should be treated as a currency value, + * false if it should not be treated as a currency value. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setCurrency(int columnIndex, boolean isCurrency) + throws SQLException; + + /** + * Sets whether a specified column can contain SQL NULL values. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param nullability + * an integer which is one of the following values: + * ResultSetMetaData.columnNoNulls, + * ResultSetMetaData.columnNullable, or + * ResultSetMetaData.columnNullableUnknown + * <p> + * The default value is ResultSetMetaData.columnNullableUnknown + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setNullable(int columnIndex, int nullability) + throws SQLException; + + /** + * Sets the number of decimal digits for a specified column in the RowSet. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param thePrecision + * an integer containing the number of decimal digits + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setPrecision(int columnIndex, int thePrecision) + throws SQLException; + + /** + * For the column specified by <code>columnIndex</code> declares how many + * digits there should be after a decimal point. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theScale + * an integer containing the number of digits after the decimal + * point + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setScale(int columnIndex, int theScale) throws SQLException; + + /** + * Sets the Schema Name for a specified column in the RowSet + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theSchemaName + * a String containing the schema name + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setSchemaName(int columnIndex, String theSchemaName) + throws SQLException; + + /** + * Sets whether a specified column can be used in a search involving a WHERE + * clause. The default value is false. + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param isSearchable + * true of the column can be used in a WHERE clause search, false + * otherwise. + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setSearchable(int columnIndex, boolean isSearchable) + throws SQLException; + + /** + * Sets if a specified column can contain signed numbers + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param isSigned + * true if the column can contain signed numbers, false otherwise + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setSigned(int columnIndex, boolean isSigned) + throws SQLException; + + /** + * Sets the Table Name for a specified column in the RowSet + * + * @param columnIndex + * the index number for the column, where the first column has + * index 1. + * @param theTableName + * a String containing the Table Name for the column + * @throws SQLException + * if a problem occurs accessing the database + */ + public void setTableName(int columnIndex, String theTableName) + throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/RowSetReader.java b/sql/src/main/java/javax/sql/RowSetReader.java new file mode 100644 index 0000000..bc17ded --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetReader.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; + +/** + * An interface which provides functionality for a disconnected RowSet to get + * data from a data source into its rows. The RowSet calls the RowSetReader + * interface when the RowSet's execute method is invoked - a RowSetReader must + * first be registered with the RowSet for this to work. + */ +public interface RowSetReader { + + /** + * Reads new data into the RowSet. The calling RowSet object must itself + * implement the RowSetInternal interface and the RowSetReader must be + * registered as a Reader on the RowSet. + * <p> + * This method adds rows into the calling RowSet. The Reader may invoke any + * of the RowSet's methods except for the <code>execute</code> method + * (calling execute will cause an SQLException to be thrown). However, when + * the Reader calls the RowSet's methods, no events are sent to listeners - + * any listeners are informed by the calling RowSet's execute method once + * the Reader returns from the readData method. + * + * @param theCaller + * must be the calling RowSet object, which must have implemented + * the RowSetInternal interface. + * @throws SQLException + * if a problem occurs accessing the database or if the Reader + * calls the RowSet.execute method. + */ + public void readData(RowSetInternal theCaller) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/RowSetWriter.java b/sql/src/main/java/javax/sql/RowSetWriter.java new file mode 100644 index 0000000..ba95f59 --- /dev/null +++ b/sql/src/main/java/javax/sql/RowSetWriter.java @@ -0,0 +1,52 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package javax.sql; + +import java.sql.SQLException; + +/** + * An interface which provides functionality for a disconnected RowSet to put + * data updates back to the data source from which the RowSet was originally + * populated. An object implementing this interface is called a Writer. + * <p> + * The Writer must establish a connection to the RowSet's data source before + * writing the data. The RowSet calling this interface must implement the + * RowSetInternal interface. + * <p> + * The Writer may encounter a situation where the updated data being written + * back to the data source has already been updated in the data source. How a + * conflict of this kind is handled is determined by the implementation of the + * Writer. + */ +public interface RowSetWriter { + + /** + * Writes changes in the RowSet associated with this RowSetWriter back to + * its data source. + * + * @param theRowSet + * the RowSet object. This RowSet must a) Implement the + * RowSetInternal interface and b) have have this RowSetWriter + * registered with it and c) must call this method internally + * @return true if the modified data was written, false otherwise (which + * typically implies some form of conflict) + * @throws SQLException + * if a problem occurs accessing the database + */ + public boolean writeData(RowSetInternal theRowSet) throws SQLException; +} diff --git a/sql/src/main/java/javax/sql/package.html b/sql/src/main/java/javax/sql/package.html new file mode 100644 index 0000000..c5d5aee --- /dev/null +++ b/sql/src/main/java/javax/sql/package.html @@ -0,0 +1,8 @@ +<html> + <body> + <p> + Provides extensions to the standard interface for accessing SQL-based + databases. + <p> + </body> +</html>
\ No newline at end of file diff --git a/sql/src/main/java/org/apache/harmony/sql/internal/nls/Messages.java b/sql/src/main/java/org/apache/harmony/sql/internal/nls/Messages.java new file mode 100644 index 0000000..77b669b --- /dev/null +++ b/sql/src/main/java/org/apache/harmony/sql/internal/nls/Messages.java @@ -0,0 +1,124 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * THE FILE HAS BEEN AUTOGENERATED BY MSGTOOL TOOL. + * All changes made to this file manually will be overwritten + * if this tool runs again. Better make changes in the template file. + */ + +package org.apache.harmony.sql.internal.nls; + +import org.apache.harmony.luni.util.MsgHelp; + +/** + * This class retrieves strings from a resource bundle and returns them, + * formatting them with MessageFormat when required. + * <p> + * It is used by the system classes to provide national language support, by + * looking up messages in the <code> + * org.apache.harmony.sql.internal.nls.messages + * </code> + * resource bundle. Note that if this file is not available, or an invalid key + * is looked up, or resource bundle support is not available, the key itself + * will be returned as the associated message. This means that the <em>KEY</em> + * should a reasonable human-readable (english) string. + * + */ +public class Messages { + + private static final String sResource = + "org.apache.harmony.sql.internal.nls.messages"; //$NON-NLS-1$ + + /** + * Retrieves a message which has no arguments. + * + * @param msg + * String the key to look up. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg) { + return MsgHelp.getString(sResource, msg); + } + + /** + * Retrieves a message which takes 1 argument. + * + * @param msg + * String the key to look up. + * @param arg + * Object the object to insert in the formatted output. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg, Object arg) { + return getString(msg, new Object[] { arg }); + } + + /** + * Retrieves a message which takes 1 integer argument. + * + * @param msg + * String the key to look up. + * @param arg + * int the integer to insert in the formatted output. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg, int arg) { + return getString(msg, new Object[] { Integer.toString(arg) }); + } + + /** + * Retrieves a message which takes 1 character argument. + * + * @param msg + * String the key to look up. + * @param arg + * char the character to insert in the formatted output. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg, char arg) { + return getString(msg, new Object[] { String.valueOf(arg) }); + } + + /** + * Retrieves a message which takes 2 arguments. + * + * @param msg + * String the key to look up. + * @param arg1 + * Object an object to insert in the formatted output. + * @param arg2 + * Object another object to insert in the formatted output. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg, Object arg1, Object arg2) { + return getString(msg, new Object[] { arg1, arg2 }); + } + + /** + * Retrieves a message which takes several arguments. + * + * @param msg + * String the key to look up. + * @param args + * Object[] the objects to insert in the formatted output. + * @return String the message for that key in the system message bundle. + */ + static public String getString(String msg, Object[] args) { + return MsgHelp.getString(sResource, msg, args); + } +} diff --git a/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties b/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties new file mode 100644 index 0000000..3e6ff1d --- /dev/null +++ b/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties @@ -0,0 +1,42 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# messages for EN locale +sql.0=Value out of range +sql.1=DriverManager: calling class not authorized to deregister JDBC driver +sql.2=Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff +sql.3=Argument cannot be null +sql.4=Bad input string format: expected '.' not {0} +sql.5=The url cannot be null +sql.6=No suitable driver +sql.8=SQLWarning chain holds value that is not a SQLWarning +sql.9=Cannot instantiate a SerialRef object with a null Ref object +sql.10=Cannot instantiate a SerialRef object that returns a null base type name +sql.11=SQLException: {0} +sql.12=Cannot serialize empty URL instance +sql.13=Cannot instantiate a SerialBlob object with a null Blob object +sql.14=Invalid starting position or length +sql.15=Invalid position in BLOB object set +sql.16=Invalid offset in byte array set +sql.17=javax.sql.rowset.serial.SerialException: Length more than what can be truncated +sql.18=Unsupported operation. SerialBlob cannot return a writable binary stream, unless instantiated with a Blob object that provides a setBinaryStream() implementation +sql.19=Cannot instantiate a SerialClob object with a null Clob object +sql.20=Invalid Clob object. Calls to getCharacterStream or getAsciiStream return null which cannot be serialized. +sql.21=Invalid position in CLOB object set +sql.22=Invalid position and substring length +sql.23=Buffer is not sufficient to hold the value +sql.24=Invalid length for truncate +sql.25=Unsupported operation. SerialClob is not instantiated with a fully implemented Clob object. |