Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
SQLite.JDBC2z.JDBCConnection Maven / Gradle / Ivy
package SQLite.JDBC2z;
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;
/**
* SQLite 3 VFS to use.
*/
protected String vfs;
/**
* 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;
/**
* Use double/julian date representation.
*/
protected boolean useJulian = false;
/**
* 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;
/**
* Transaction isolation mode.
*/
private int trmode = TRANSACTION_SERIALIZABLE;
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 dbx = null;
try {
dbx = new DatabaseX();
dbx.open(dbfile, readonly ? SQLite.Constants.SQLITE_OPEN_READONLY :
(SQLite.Constants.SQLITE_OPEN_READWRITE |
SQLite.Constants.SQLITE_OPEN_CREATE), vfs);
dbx.set_encoding(enc);
} catch (SQLite.Exception e) {
throw new SQLException(e.toString());
}
int loop = 0;
while (true) {
try {
dbx.exec("PRAGMA short_column_names = off;", null);
dbx.exec("PRAGMA full_column_names = on;", null);
dbx.exec("PRAGMA empty_result_callbacks = on;", null);
if (SQLite.Database.version().compareTo("2.6.0") >= 0) {
dbx.exec("PRAGMA show_datatypes = on;", null);
}
} catch (SQLite.Exception e) {
if (dbx.last_error() != SQLite.Constants.SQLITE_BUSY ||
!busy0(dbx, ++loop)) {
try {
dbx.close();
} catch (SQLite.Exception ee) {
}
throw new SQLException(e.toString());
}
continue;
}
break;
}
return dbx;
}
public JDBCConnection(String url, String enc, String pwd, String drep,
String vfs)
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;
this.vfs = vfs;
try {
db = open(readonly);
try {
if (pwd != null && pwd.length() > 0) {
db.key(pwd);
}
} catch (SQLite.Exception se) {
throw new SQLException("error while setting key");
}
db.busy_handler(this);
} catch (SQLException e) {
if (db != null) {
try {
db.close();
} catch (SQLite.Exception ee) {
}
}
throw e;
}
useJulian = drep != null &&
(drep.startsWith("j") || drep.startsWith("J"));
}
/* 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 {
if (resultSetType != ResultSet.TYPE_FORWARD_ONLY &&
resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE &&
resultSetType != ResultSet.TYPE_SCROLL_SENSITIVE) {
throw new SQLFeatureNotSupportedException("unsupported result set type");
}
if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY &&
resultSetConcurrency != ResultSet.CONCUR_UPDATABLE) {
throw new SQLFeatureNotSupportedException("unsupported result set concurrency");
}
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 trmode;
}
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 SQLFeatureNotSupportedException();
}
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 {
if (resultSetType != ResultSet.TYPE_FORWARD_ONLY &&
resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE &&
resultSetType != ResultSet.TYPE_SCROLL_SENSITIVE) {
throw new SQLFeatureNotSupportedException("unsupported result set type");
}
if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY &&
resultSetConcurrency != ResultSet.CONCUR_UPDATABLE) {
throw new SQLFeatureNotSupportedException("unsupported result set concurrency");
}
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());
} finally {
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 dbx = null;
try {
dbx = open(ro);
db.close();
db = dbx;
dbx = null;
readonly = ro;
} catch (SQLException e) {
throw e;
} catch (SQLite.Exception ee) {
if (dbx != null) {
try {
dbx.close();
} catch (SQLite.Exception eee) {
}
}
throw new SQLException(ee.toString());
}
}
}
public void setTransactionIsolation(int level) throws SQLException {
if (db.is3() && SQLite.JDBCDriver.sharedCache) {
String flag = null;
if (level == TRANSACTION_READ_UNCOMMITTED &&
trmode != TRANSACTION_READ_UNCOMMITTED) {
flag = "on";
} else if (level == TRANSACTION_SERIALIZABLE &&
trmode != TRANSACTION_SERIALIZABLE) {
flag = "off";
}
if (flag != null) {
try {
db.exec("PRAGMA read_uncommitted = " + flag + ";", null);
trmode = level;
} catch (java.lang.Exception e) {
}
}
}
if (level != trmode) {
throw new SQLException("not supported");
}
}
public java.util.Map> getTypeMap() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public void setTypeMap(java.util.Map map) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
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 SQLFeatureNotSupportedException("unsupported holdability");
}
public Savepoint setSavepoint() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public Savepoint setSavepoint(String name) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public void rollback(Savepoint x) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public void releaseSavepoint(Savepoint x) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public Statement createStatement(int resultSetType,
int resultSetConcurrency,
int resultSetHoldability)
throws SQLException {
if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT) {
throw new SQLFeatureNotSupportedException("unsupported holdability");
}
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 SQLFeatureNotSupportedException("unsupported holdability");
}
return prepareStatement(sql, resultSetType, resultSetConcurrency);
}
public CallableStatement prepareCall(String sql, int x, int y, int z)
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public PreparedStatement prepareStatement(String sql, int autokeys)
throws SQLException {
if (autokeys != Statement.NO_GENERATED_KEYS) {
throw new SQLFeatureNotSupportedException("generated keys not supported");
}
return prepareStatement(sql);
}
public PreparedStatement prepareStatement(String sql, int colIndexes[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public PreparedStatement prepareStatement(String sql, String columns[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public Clob createClob() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public Blob createBlob() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public NClob createNClob() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public SQLXML createSQLXML() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public boolean isValid(int timeout) throws SQLException {
return true;
}
public void setClientInfo(String name, String value)
throws SQLClientInfoException {
throw new SQLClientInfoException();
}
public void setClientInfo(Properties prop) throws SQLClientInfoException {
throw new SQLClientInfoException();
}
public String getClientInfo(String name) throws SQLException {
throw new SQLException("unsupported");
}
public Properties getClientInfo() throws SQLException {
return new Properties();
}
public Array createArrayOf(String type, Object[] elems)
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public Struct createStruct(String type, Object[] attrs)
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public T unwrap(java.lang.Class iface) throws SQLException {
throw new SQLException("unsupported");
}
public boolean isWrapperFor(java.lang.Class iface) throws SQLException {
return false;
}
}
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();
}
}
}
