NestedDB.java

/*
 * Copyright (c) 2007 David Crawshaw <david@zentus.com>
 * 
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
package org.sqlite;

import java.io.PrintWriter;
import java.sql.SQLException;

import org.ibex.nestedvm.Runtime;

// FEATURE: strdup is wasteful, SQLite interface will take unterminated char*

/** Communicates with the Java version of SQLite provided by NestedVM. */
final class NestedDB extends DB implements Runtime.CallJavaCB
{
 /** database pointer */
 int handle = 0;

 /** sqlite binary embedded in nestedvm */
 private Runtime rt = null;

 /** user defined functions referenced by position (stored in used data) */
 private Function[] functions = null;
 private String[] funcNames = null;

 // WRAPPER FUNCTIONS ////////////////////////////////////////////

 @Override
 protected synchronized void _open(String filename, int openFlags) throws SQLException {
 if (handle != 0)
 throw new SQLException("DB already open");

 // handle silly windows drive letter mapping
 if (filename.length() > 2) {
 char drive = Character.toLowerCase(filename.charAt(0));
 if (filename.charAt(1) == ':' && drive >= 'a' && drive <= 'z') {

 // convert to nestedvm's "/c:/file" format
 filename = filename.substring(2);
 filename = filename.replace('\\', '/');
 filename = "/" + drive + ":" + filename;
 }
 }

 // start the nestedvm runtime
 try {
 rt = (Runtime) Class.forName("org.sqlite.SQLite").newInstance();
 rt.start();
 }
 catch (Exception e) {
 throw new CausedSQLException(e);
 }

 // callback for user defined functions
 rt.setCallJavaCB(this);

 // open the db and retrieve sqlite3_db* pointer
 int passback = rt.xmalloc(4);
 int str = rt.strdup(filename);
 // if (call("sqlite3_open_v2", str, openFlags, 0, passback) != SQLITE_OK)
 if (call("sqlite3_open_v2", str, passback, openFlags, 0) != SQLITE_OK)
 throwex();
 handle = deref(passback);
 rt.free(str);
 rt.free(passback);
 }

 /* callback for Runtime.CallJavaCB above */
 public int call(int xType, int context, int args, int value) {
 xUDF(xType, context, args, value);
 return 0;
 }

 @Override
 protected synchronized void _close() throws SQLException {
 if (handle == 0)
 return;
 try {
 if (call("sqlite3_close", handle) != SQLITE_OK)
 throwex();
 }
 finally {
 handle = 0;
 rt.stop();
 rt = null;
 }
 }

 @Override
 int shared_cache(boolean enable) throws SQLException {
 // The shared cache is per-process, so it is useless as
 // each nested connection is its own process.
 return -1;
 }

 @Override
 int enable_load_extension(boolean enable) throws SQLException {
 // TODO enable_load_extension is not supported in pure-java mode
 //return call("sqlite3_enable_load_extension", handle, enable ? 1 : 0);
 return 1;
 }

 @Override
 synchronized void interrupt() throws SQLException {
 call("sqlite3_interrupt", handle);
 }

 @Override
 synchronized void busy_timeout(int ms) throws SQLException {
 call("sqlite3_busy_timeout", handle, ms);
 }

 @Override
 protected synchronized long prepare(String sql) throws SQLException {

 int passback = rt.xmalloc(4);
 int str = rt.strdup(sql);
 int ret = call("sqlite3_prepare_v2", handle, str, -1, passback, 0);
 rt.free(str);
 if (ret != SQLITE_OK) {
 rt.free(passback);
 throwex(ret);
 }
 int pointer = deref(passback);
 rt.free(passback);
 return pointer;
 }

 @Override
 synchronized String errmsg() throws SQLException {
 return cstring(call("sqlite3_errmsg", handle));
 }

 @Override
 synchronized String libversion() throws SQLException {
 return cstring(call("sqlite3_libversion", handle));
 }

 @Override
 synchronized int changes() throws SQLException {
 return call("sqlite3_changes", handle);
 }

 @Override
 protected synchronized int _exec(String sql) throws SQLException {
 if (rt == null)
 throw DB.newSQLException(SQLiteErrorCode.SQLITE_MISUSE.code, "attempt to use the closed conection");
 int passback = rt.xmalloc(4);
 int str = rt.strdup(sql);
 int status = call("sqlite3_exec", handle, str, 0, 0, passback);
 if (status != SQLITE_OK) {
 String errorMessage = cstring(passback);
 call("sqlite3_free", deref(passback));
 rt.free(passback);
 throwex(status, errorMessage);
 }
 rt.free(passback);
 return status;
 }

 @Override
 protected synchronized int finalize(long stmt) throws SQLException {
 return call("sqlite3_finalize", (int) stmt);
 }

 @Override
 protected synchronized int step(long stmt) throws SQLException {
 return call("sqlite3_step", (int) stmt);
 }

 @Override
 protected synchronized int reset(long stmt) throws SQLException {
 return call("sqlite3_reset", (int) stmt);
 }

 @Override
 synchronized int clear_bindings(long stmt) throws SQLException {
 return call("sqlite3_clear_bindings", (int) stmt);
 }

 @Override
 synchronized int bind_parameter_count(long stmt) throws SQLException {
 return call("sqlite3_bind_parameter_count", (int) stmt);
 }

 @Override
 synchronized int column_count(long stmt) throws SQLException {
 return call("sqlite3_column_count", (int) stmt);
 }

 @Override
 synchronized int column_type(long stmt, int col) throws SQLException {
 return call("sqlite3_column_type", (int) stmt, col);
 }

 @Override
 synchronized String column_name(long stmt, int col) throws SQLException {
 return utfstring(call("sqlite3_column_name", (int) stmt, col));
 }

 @Override
 synchronized String column_text(long stmt, int col) throws SQLException {
 return utfstring(call("sqlite3_column_text", (int) stmt, col));
 }

 @Override
 synchronized byte[] column_blob(long stmt, int col) throws SQLException {
 int addr = call("sqlite3_column_blob", (int) stmt, col);
 if (addr == 0)
 return null;
 byte[] blob = new byte[call("sqlite3_column_bytes", (int) stmt, col)];
 copyin(addr, blob, blob.length);
 return blob;
 }

 @Override
 synchronized double column_double(long stmt, int col) throws SQLException {
 try {
 return Double.parseDouble(column_text(stmt, col));
 }
 catch (NumberFormatException e) {
 return Double.NaN;
 } // TODO
 }

 @Override
 synchronized long column_long(long stmt, int col) throws SQLException {
 try {
 return Long.parseLong(column_text(stmt, col));
 }
 catch (NumberFormatException e) {
 return 0;
 } // TODO
 }

 @Override
 synchronized int column_int(long stmt, int col) throws SQLException {
 return call("sqlite3_column_int", (int) stmt, col);
 }

 @Override
 synchronized String column_decltype(long stmt, int col) throws SQLException {
 return utfstring(call("sqlite3_column_decltype", (int) stmt, col));
 }

 @Override
 synchronized String column_table_name(long stmt, int col) throws SQLException {
 return utfstring(call("sqlite3_column_table_name", (int) stmt, col));
 }

 @Override
 synchronized int bind_null(long stmt, int pos) throws SQLException {
 return call("sqlite3_bind_null", (int) stmt, pos);
 }

 @Override
 synchronized int bind_int(long stmt, int pos, int v) throws SQLException {
 return call("sqlite3_bind_int", (int) stmt, pos, v);
 }

 @Override
 synchronized int bind_long(long stmt, int pos, long v) throws SQLException {
 return bind_text(stmt, pos, Long.toString(v)); // TODO
 }

 @Override
 synchronized int bind_double(long stmt, int pos, double v) throws SQLException {
 return bind_text(stmt, pos, Double.toString(v)); // TODO
 }

 @Override
 synchronized int bind_text(long stmt, int pos, String v) throws SQLException {
 if (v == null)
 return bind_null(stmt, pos);
 return call("sqlite3_bind_text", (int) stmt, pos, rt.strdup(v), -1, rt.lookupSymbol("free"));
 }

 @Override
 synchronized int bind_blob(long stmt, int pos, byte[] buf) throws SQLException {
 if (buf == null || buf.length < 1)
 return bind_null(stmt, pos);
 int len = buf.length;
 int blob = rt.xmalloc(len); // free()ed by sqlite3_bind_blob
 copyout(buf, blob, len);
 return call("sqlite3_bind_blob", (int) stmt, pos, blob, len, rt.lookupSymbol("free"));
 }

 @Override
 synchronized void result_null(long cxt) throws SQLException {
 call("sqlite3_result_null", (int) cxt);
 }

 @Override
 synchronized void result_text(long cxt, String val) throws SQLException {
 call("sqlite3_result_text", (int) cxt, rt.strdup(val), -1, rt.lookupSymbol("free"));
 }

 @Override
 synchronized void result_blob(long cxt, byte[] val) throws SQLException {
 if (val == null || val.length == 0) {
 result_null(cxt);
 return;
 }
 int blob = rt.xmalloc(val.length);
 copyout(val, blob, val.length);
 call("sqlite3_result_blob", (int) cxt, blob, val.length, rt.lookupSymbol("free"));
 }

 @Override
 synchronized void result_double(long cxt, double val) throws SQLException {
 result_text(cxt, Double.toString(val));
 } // TODO

 @Override
 synchronized void result_long(long cxt, long val) throws SQLException {
 result_text(cxt, Long.toString(val));
 } // TODO

 @Override
 synchronized void result_int(long cxt, int val) throws SQLException {
 call("sqlite3_result_int", (int) cxt, val);
 }

 @Override
 synchronized void result_error(long cxt, String err) throws SQLException {
 int str = rt.strdup(err);
 call("sqlite3_result_error", (int) cxt, str, -1);
 rt.free(str);
 }

 @Override
 synchronized int value_bytes(Function f, int arg) throws SQLException {
 return call("sqlite3_value_bytes", value(f, arg));
 }

 @Override
 synchronized String value_text(Function f, int arg) throws SQLException {
 return utfstring(call("sqlite3_value_text", value(f, arg)));
 }

 @Override
 synchronized byte[] value_blob(Function f, int arg) throws SQLException {
 int addr = call("sqlite3_value_blob", value(f, arg));
 if (addr == 0)
 return null;
 byte[] blob = new byte[value_bytes(f, arg)];
 copyin(addr, blob, blob.length);
 return blob;
 }

 @Override
 synchronized double value_double(Function f, int arg) throws SQLException {
 return Double.parseDouble(value_text(f, arg)); // TODO
 }

 @Override
 synchronized long value_long(Function f, int arg) throws SQLException {
 return Long.parseLong(value_text(f, arg)); // TODO
 }

 @Override
 synchronized int value_int(Function f, int arg) throws SQLException {
 return call("sqlite3_value_int", value(f, arg));
 }

 @Override
 synchronized int value_type(Function f, int arg) throws SQLException {
 return call("sqlite3_value_type", value(f, arg));
 }

 private int value(Function f, int arg) throws SQLException {
 return deref((int) f.value + (arg * 4));
 }

 @Override
 synchronized int create_function(String name, Function func) throws SQLException {
 if (functions == null) {
 functions = new Function[10];
 funcNames = new String[10];
 }

 // find a position
 int pos;
 for (pos = 0; pos < functions.length; pos++)
 if (functions[pos] == null)
 break;

 if (pos == functions.length) { // expand function arrays
 Function[] fnew = new Function[functions.length * 2];
 String[] nnew = new String[funcNames.length * 2];
 System.arraycopy(functions, 0, fnew, 0, functions.length);
 System.arraycopy(funcNames, 0, nnew, 0, funcNames.length);
 functions = fnew;
 funcNames = nnew;
 }

 // register function
 functions[pos] = func;
 funcNames[pos] = name;
 int rc;
 int str = rt.strdup(name);
 rc = call("create_function_helper", handle, str, pos, func instanceof Function.Aggregate ? 1 : 0);
 rt.free(str);
 return rc;
 }

 @Override
 synchronized int destroy_function(String name) throws SQLException {
 if (name == null)
 return 0;

 // find function position number
 int pos;
 for (pos = 0; pos < funcNames.length; pos++)
 if (name.equals(funcNames[pos]))
 break;
 if (pos == funcNames.length)
 return 0;

 functions[pos] = null;
 funcNames[pos] = null;

 // deregister function
 int rc;
 int str = rt.strdup(name);
 rc = call("create_function_helper", handle, str, -1, 0);
 rt.free(str);
 return rc;
 }

 /* unused as we use the user_data pointer to store a single word */
 @Override
 synchronized void free_functions() {}

 /** Callback used by xFunc (1), xStep (2) and xFinal (3). */
 synchronized void xUDF(int xType, int context, int args, int value) {
 Function func = null;

 try {
 int pos = call("sqlite3_user_data", context);
 func = functions[pos];
 if (func == null)
 throw new SQLException("function state inconsistent");

 func.context = context;
 func.value = value;
 func.args = args;

 switch (xType) {
 case 1:
 func.xFunc();
 break;
 case 2:
 ((Function.Aggregate) func).xStep();
 break;
 case 3:
 ((Function.Aggregate) func).xFinal();
 break;
 }
 }
 catch (SQLException e) {
 try {
 String err = e.toString();
 if (err == null)
 err = "unknown error";
 int str = rt.strdup(err);
 call("sqlite3_result_error", context, str, -1);
 rt.free(str);
 }
 catch (SQLException exp) {
 exp.printStackTrace();//TODO
 }
 }
 finally {
 if (func != null) {
 func.context = 0;
 func.value = 0;
 func.args = 0;
 }
 }
 }

 /** Calls support function found in upstream/sqlite-metadata.patch */
 @Override
 synchronized boolean[][] column_metadata(long stmt) throws SQLException {
 int colCount = call("sqlite3_column_count", (int) stmt);
 boolean[][] meta = new boolean[colCount][3];
 int pass;

 pass = rt.xmalloc(12); // struct metadata

 for (int i = 0; i < colCount; i++) {
 call("column_metadata_helper", handle, (int) stmt, i, pass);
 meta[i][0] = deref(pass) == 1;
 meta[i][1] = deref(pass + 4) == 1;
 meta[i][2] = deref(pass + 8) == 1;
 }

 rt.free(pass);
 return meta;
 }

 @Override
 int backup(String dbName, String destFileName, ProgressObserver observer) throws SQLException {
 throw new SQLException("backup command is not supported in pure-java mode");
 }

 @Override
 int restore(String dbName, String sourceFileName, ProgressObserver observer) throws SQLException {
 throw new SQLException("restore command is not supported in pure-java mode");
 }

 // HELPER FUNCTIONS /////////////////////////////////////////////

 /** safe to reuse parameter arrays as all functions are syncrhonized */
 private final int[] p0 = new int[] {}, p1 = new int[] { 0 }, p2 = new int[] { 0, 0 }, p3 = new int[] { 0, 0, 0 },
 p4 = new int[] { 0, 0, 0, 0 }, p5 = new int[] { 0, 0, 0, 0, 0 };

 private int call(String addr, int a0) throws SQLException {
 p1[0] = a0;
 return call(addr, p1);
 }

 private int call(String addr, int a0, int a1) throws SQLException {
 p2[0] = a0;
 p2[1] = a1;
 return call(addr, p2);
 }

 private int call(String addr, int a0, int a1, int a2) throws SQLException {
 p3[0] = a0;
 p3[1] = a1;
 p3[2] = a2;
 return call(addr, p3);
 }

 private int call(String addr, int a0, int a1, int a2, int a3) throws SQLException {
 p4[0] = a0;
 p4[1] = a1;
 p4[2] = a2;
 p4[3] = a3;
 return call(addr, p4);
 }

 private int call(String addr, int a0, int a1, int a2, int a3, int a4) throws SQLException {
 p5[0] = a0;
 p5[1] = a1;
 p5[2] = a2;
 p5[3] = a3;
 p5[4] = a4;
 return call(addr, p5);
 }

 private int call(String func, int[] args) throws SQLException {
 try {
 return rt.call(func, args);
 }
 catch (Runtime.CallException e) {
 throw new CausedSQLException(e);
 }
 }

 /** Dereferences a pointer, returning the word it points to. */
 private int deref(int pointer) throws SQLException {
 try {
 return rt.memRead(pointer);
 }
 catch (Runtime.ReadFaultException e) {
 throw new CausedSQLException(e);
 }
 }

 private String utfstring(int str) throws SQLException {
 try {
 return rt.utfstring(str);
 }
 catch (Runtime.ReadFaultException e) {
 throw new CausedSQLException(e);
 }
 }

 private String cstring(int str) throws SQLException {
 try {
 return rt.cstring(str);
 }
 catch (Runtime.ReadFaultException e) {
 throw new CausedSQLException(e);
 }
 }

 private void copyin(int addr, byte[] buf, int count) throws SQLException {
 try {
 rt.copyin(addr, buf, count);
 }
 catch (Runtime.ReadFaultException e) {
 throw new CausedSQLException(e);
 }
 }

 private void copyout(byte[] buf, int addr, int count) throws SQLException {
 try {
 rt.copyout(buf, addr, count);
 }
 catch (Runtime.FaultException e) {
 throw new CausedSQLException(e);
 }
 }

 /** Maps any exception onto an SQLException. */
 private static final class CausedSQLException extends SQLException
 {
 private final Exception cause;

 CausedSQLException(Exception e) {
 if (e == null)
 throw new RuntimeException("null exception cause");
 cause = e;
 }

 @Override
 public Throwable getCause() {
 return cause;
 }

 @Override
 public void printStackTrace() {
 cause.printStackTrace();
 }

 @Override
 public void printStackTrace(PrintWriter s) {
 cause.printStackTrace(s);
 }

 @Override
 public Throwable fillInStackTrace() {
 return cause.fillInStackTrace();
 }

 @Override
 public StackTraceElement[] getStackTrace() {
 return cause.getStackTrace();
 }

 @Override
 public String getMessage() {
 return cause.getMessage();
 }
 }
}