activerecord-jdbc-adapter 0.6

data/src/java/JDBCDerbySpec.java

@@ -0,0 +1,323 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: CPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Common Public
+ * License Version 1.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.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 Ola Bini <ola.bini@gmail.com>
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.RubyFloat;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyBigDecimal;
+import org.jruby.RubyRange;
+import org.jruby.RubyNumeric;
+
+import org.jruby.runtime.Arity;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.MethodIndex;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.util.ByteList;
+
+import java.sql.SQLException;
+
+public class JDBCDerbySpec {
+    public static void load(Ruby runtime, RubyModule jdbcSpec) {
+        RubyModule derby = jdbcSpec.defineModuleUnder("Derby");
+        CallbackFactory cf = runtime.callbackFactory(JDBCDerbySpec.class);
+        derby.defineFastMethod("quote_string",cf.getFastSingletonMethod("quote_string",IRubyObject.class));
+        derby.defineFastMethod("quote",cf.getFastOptSingletonMethod("quote"));
+        derby.defineFastMethod("_execute",cf.getFastOptSingletonMethod("_execute"));
+        derby.defineFastMethod("add_limit_offset!",cf.getFastSingletonMethod("add_limit_offset", IRubyObject.class, IRubyObject.class));
+        derby.defineFastMethod("select_all",cf.getFastOptSingletonMethod("select_all"));
+        derby.defineFastMethod("select_one",cf.getFastOptSingletonMethod("select_one"));
+        RubyModule col = derby.defineModuleUnder("Column");
+        col.defineFastMethod("type_cast",cf.getFastSingletonMethod("type_cast", IRubyObject.class));
+    }
+
+    /*
+     * JdbcSpec::Derby::Column.type_cast(value)
+     */
+    public static IRubyObject type_cast(IRubyObject recv, IRubyObject value) {
+        Ruby runtime = recv.getRuntime();
+
+        if(value.isNil() || ((value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null"))) {
+            return runtime.getNil();
+        }
+
+        String type = recv.getInstanceVariable("@type").toString();
+
+        switch(type.charAt(0)) {
+        case 's': //string
+            return value;
+        case 't': //text, timestamp, time
+            if(type.equals("text")) {
+                return value;
+            } else {
+                return recv.callMethod(runtime.getCurrentContext(), "cast_to_time", value);
+            }
+        case 'i': //integer
+        case 'p': //primary key
+            if(value.respondsTo("to_i")) {
+                return value.callMethod(runtime.getCurrentContext(), "to_i");
+            } else {
+                return runtime.newFixnum( value.isTrue() ? 1 : 0 );
+            }
+        case 'd': //decimal, datetime, date
+            if(type.equals("datetime")) {
+                return recv.callMethod(runtime.getCurrentContext(), "cast_to_date_or_time", value);
+            } else if(type.equals("date")) {
+                return recv.getMetaClass().callMethod(runtime.getCurrentContext(), "string_to_date", value);
+            } else {
+                return recv.getMetaClass().callMethod(runtime.getCurrentContext(), "value_to_decimal", value);
+            }
+        case 'f': //float
+            return value.callMethod(runtime.getCurrentContext(),"to_f");
+        case 'b': //binary, boolean
+            if(type.equals("binary")) {
+                return recv.callMethod(runtime.getCurrentContext(), "value_to_binary", value);
+            } else {
+                return recv.getMetaClass().callMethod(runtime.getCurrentContext(), "value_to_boolean", value);
+            }
+        }
+        return value;
+    }
+
+    public static IRubyObject quote(IRubyObject recv, IRubyObject[] args) {
+        Ruby runtime = recv.getRuntime();
+        Arity.checkArgumentCount(runtime, args, 1, 2);
+        IRubyObject value = args[0];
+        if(args.length > 1) {
+            IRubyObject col = args[1];
+            IRubyObject type = col.callMethod(runtime.getCurrentContext(),"type");
+            if(value instanceof RubyString) {
+                if(type == runtime.newSymbol("string")) {
+                    return quote_string_with_surround(runtime, "'", (RubyString)value, "'");
+                } else if(type == runtime.newSymbol("text")) {
+                    return quote_string_with_surround(runtime, "CAST('", (RubyString)value, "' AS CLOB)");
+                } else if(type == runtime.newSymbol("binary")) {
+                    return hexquote_string_with_surround(runtime, "CAST('", (RubyString)value, "' AS BLOB)");
+                } else {
+                    // column type :integer or other numeric or date version
+                    if(only_digits((RubyString)value)) {
+                        return value;
+                    } else {
+                        return super_quote(recv, runtime, value, col);
+                    }
+                }
+            } else if((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+                if(type == runtime.newSymbol("string")) {
+                    return quote_string_with_surround(runtime, "'", RubyString.objAsString(value), "'");
+                }
+            }
+        } 
+        return super_quote(recv, runtime, value, runtime.getNil());
+    }
+
+    private final static ByteList NULL = new ByteList("NULL".getBytes());
+
+    public static IRubyObject super_quote(IRubyObject recv, Ruby runtime, IRubyObject value, IRubyObject col) {
+        if(value.respondsTo("quoted_id")) {
+            return value.callMethod(runtime.getCurrentContext(), "quoted_id");
+        }
+        
+        IRubyObject type = (col.isNil()) ? col : col.callMethod(runtime.getCurrentContext(),"type");
+        if(value instanceof RubyString || 
+           value.isKindOf((RubyModule)(((RubyModule)((RubyModule)runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars")))) {
+            RubyString svalue = RubyString.objAsString(value);
+            if(type == runtime.newSymbol("binary") && col.getType().respondsTo("string_to_binary")) {
+                return quote_string_with_surround(runtime, "'", (RubyString)(col.getType().callMethod(runtime.getCurrentContext(), "string_to_binary", svalue)), "'"); 
+            } else if(type == runtime.newSymbol("integer") || type == runtime.newSymbol("float")) {
+                return RubyString.objAsString(((type == runtime.newSymbol("integer")) ? 
+                                               svalue.callMethod(runtime.getCurrentContext(), "to_i") : 
+                                               svalue.callMethod(runtime.getCurrentContext(), "to_f")));
+            } else {
+                return quote_string_with_surround(runtime, "'", svalue, "'"); 
+            }
+        } else if(value.isNil()) {
+            return runtime.newStringShared(NULL);
+        } else if(value instanceof RubyBoolean) {
+            return (value.isTrue() ? 
+                    (type == runtime.newSymbol(":integer")) ? runtime.newString("1") : recv.callMethod(runtime.getCurrentContext(),"quoted_true") :
+                    (type == runtime.newSymbol(":integer")) ? runtime.newString("0") : recv.callMethod(runtime.getCurrentContext(),"quoted_false"));
+        } else if((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+            return RubyString.objAsString(value);
+        } else if(value instanceof RubyBigDecimal) {
+            return value.callMethod(runtime.getCurrentContext(), "to_s", runtime.newString("F"));
+        } else if(value.isKindOf(runtime.getModule("Date"))) {
+            return quote_string_with_surround(runtime, "'", RubyString.objAsString(value), "'"); 
+        } else if(value.isKindOf(runtime.getModule("Time")) || value.isKindOf(runtime.getModule("DateTime"))) {
+            return quote_string_with_surround(runtime, "'", (RubyString)(recv.callMethod(runtime.getCurrentContext(), "quoted_date", value)), "'"); 
+        } else {
+            return quote_string_with_surround(runtime, "'", (RubyString)(value.callMethod(runtime.getCurrentContext(), "to_yaml")), "'");
+        }
+    }
+
+    private final static ByteList TWO_SINGLE = new ByteList(new byte[]{'\'','\''});
+
+    public static IRubyObject quote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
+        ByteList input = string.getByteList();
+        ByteList output = new ByteList(before.getBytes());
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            switch(input.bytes[i]) {
+            case '\'':
+                output.append(input.bytes[i]);
+                //FALLTHROUGH
+            default:
+                output.append(input.bytes[i]);
+            }
+
+        }
+
+        output.append(after.getBytes());
+
+        return runtime.newStringShared(output);
+    }
+
+    private final static byte[] HEX = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+
+    public static IRubyObject hexquote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
+        ByteList input = string.getByteList();
+        ByteList output = new ByteList(before.getBytes());
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            byte b1 = input.bytes[i];
+            byte higher = HEX[(((char)b1)>>4)%16];
+            byte lower = HEX[((char)b1)%16];
+            if(b1 == '\'') {
+                output.append(higher);
+                output.append(lower);
+            }
+            output.append(higher);
+            output.append(lower);
+        }
+
+        output.append(after.getBytes());
+        return runtime.newStringShared(output);
+    }
+
+    private static boolean only_digits(RubyString inp) {
+        ByteList input = inp.getByteList();
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            if(input.bytes[i] < '0' || input.bytes[i] > '9') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static IRubyObject quote_string(IRubyObject recv, IRubyObject string) {
+        boolean replacementFound = false;
+        ByteList bl = ((RubyString) string).getByteList();
+        
+        for(int i = bl.begin; i < bl.begin + bl.realSize; i++) {
+            switch (bl.bytes[i]) {
+            case '\'': break;
+            default: continue;
+            }
+            
+            // On first replacement allocate a different bytelist so we don't manip original 
+            if(!replacementFound) {
+                i-= bl.begin;
+                bl = new ByteList(bl);
+                replacementFound = true;
+            }
+
+            bl.replace(i, 1, TWO_SINGLE);
+            i+=1;
+        }
+        if(replacementFound) {
+            return recv.getRuntime().newStringShared(bl);
+        } else {
+            return string;
+        }
+    }
+
+    public static IRubyObject select_all(IRubyObject recv, IRubyObject[] args) {
+        return recv.callMethod(recv.getRuntime().getCurrentContext(),"execute",args);
+    }
+
+    public static IRubyObject select_one(IRubyObject recv, IRubyObject[] args) {
+        IRubyObject limit = recv.getInstanceVariable("@limit");
+        if(limit == null || limit.isNil()) {
+            recv.setInstanceVariable("@limit", recv.getRuntime().newFixnum(1));
+        }
+        try {
+            return recv.callMethod(recv.getRuntime().getCurrentContext(),"execute",args).callMethod(recv.getRuntime().getCurrentContext(), "first");
+        } finally {
+            recv.setInstanceVariable("@limit", recv.getRuntime().getNil());
+        }
+    }
+
+    public static IRubyObject add_limit_offset(IRubyObject recv, IRubyObject sql, IRubyObject options) {
+        recv.setInstanceVariable("@limit", options.callMethod(recv.getRuntime().getCurrentContext(), MethodIndex.AREF, "[]", recv.getRuntime().newSymbol("limit")));
+        return recv.setInstanceVariable("@offset", options.callMethod(recv.getRuntime().getCurrentContext(), MethodIndex.AREF, "[]", recv.getRuntime().newSymbol("offset")));
+    }
+
+    public static IRubyObject _execute(IRubyObject recv, IRubyObject[] args) throws SQLException, java.io.IOException {
+        Ruby runtime = recv.getRuntime();
+        try {
+            IRubyObject conn = recv.getInstanceVariable("@connection");
+            String sql = args[0].toString().trim().toLowerCase();
+            if(sql.charAt(0) == '(') {
+                sql = sql.substring(1).trim();
+            }
+            if(sql.startsWith("insert")) {
+                return JdbcAdapterInternalService.execute_insert(conn, args[0]);
+            } else if(sql.startsWith("select") || sql.startsWith("show")) {
+                IRubyObject offset = recv.getInstanceVariable("@offset");
+                if(offset == null || offset.isNil()) {
+                    offset = RubyFixnum.zero(runtime);
+                }
+                IRubyObject limit = recv.getInstanceVariable("@limit");
+                IRubyObject range;
+                IRubyObject max;
+                if(limit == null || limit.isNil() || RubyNumeric.fix2int(limit) == -1) {
+                    range = RubyRange.newRange(runtime, offset, runtime.newFixnum(-1), false);
+                    max = RubyFixnum.zero(runtime);
+                } else {
+                    IRubyObject v1 = offset.callMethod(runtime.getCurrentContext(), MethodIndex.OP_PLUS, "+", limit);
+                    range = RubyRange.newRange(runtime, offset, v1, true);
+                    max = v1.callMethod(runtime.getCurrentContext(), MethodIndex.OP_PLUS, "+", RubyFixnum.one(runtime));
+                }
+                IRubyObject ret = JdbcAdapterInternalService.execute_query(conn, new IRubyObject[]{args[0], max}).
+                    callMethod(runtime.getCurrentContext(), MethodIndex.AREF, "[]", range);
+                if(ret.isNil()) {
+                    return runtime.newArray();
+                } else {
+                    return ret;
+                }
+            } else {
+                return JdbcAdapterInternalService.execute_update(conn, args[0]);
+            }
+        } finally {
+            recv.setInstanceVariable("@limit",runtime.getNil());
+            recv.setInstanceVariable("@offset",runtime.getNil());
+        }
+    }
+}

data/src/java/JDBCMySQLSpec.java

@@ -0,0 +1,89 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: CPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Common Public
+ * License Version 1.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.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 Ola Bini <ola.bini@gmail.com>
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.util.ByteList;
+
+public class JDBCMySQLSpec {
+    public static void load(Ruby runtime, RubyModule jdbcSpec) {
+        RubyModule mysql = jdbcSpec.defineModuleUnder("MySQL");
+        CallbackFactory cf = runtime.callbackFactory(JDBCMySQLSpec.class);
+        mysql.defineFastMethod("quote_string",cf.getFastSingletonMethod("quote_string",IRubyObject.class));
+    }
+
+    private final static ByteList ZERO = new ByteList(new byte[]{'\\','0'});
+    private final static ByteList NEWLINE = new ByteList(new byte[]{'\\','n'});
+    private final static ByteList CARRIAGE = new ByteList(new byte[]{'\\','r'});
+    private final static ByteList ZED = new ByteList(new byte[]{'\\','Z'});
+    private final static ByteList DBL = new ByteList(new byte[]{'\\','"'});
+    private final static ByteList SINGLE = new ByteList(new byte[]{'\\','\''});
+    private final static ByteList ESCAPE = new ByteList(new byte[]{'\\','\\'});
+
+    public static IRubyObject quote_string(IRubyObject recv, IRubyObject string) {
+        boolean replacementFound = false;
+        ByteList bl = ((RubyString) string).getByteList();
+        
+        for(int i = bl.begin; i < bl.begin + bl.realSize; i++) {
+            ByteList rep = null;
+            switch (bl.bytes[i]) {
+            case 0: rep = ZERO; break;
+            case '\n': rep = NEWLINE; break;
+            case '\r': rep = CARRIAGE; break;
+            case 26: rep = ZED; break;
+            case '"': rep = DBL; break;
+            case '\'': rep = SINGLE; break;
+            case '\\': rep = ESCAPE; break;
+            default: continue;
+            }
+            
+            // On first replacement allocate a different bytelist so we don't manip original 
+            if(!replacementFound) {
+                i-= bl.begin;
+                bl = new ByteList(bl);
+                replacementFound = true;
+            }
+
+            bl.replace(i, 1, rep);
+            i+=1;
+        }
+
+        if(!replacementFound) {
+            return string;
+        }
+
+
+        return recv.getRuntime().newStringShared(bl);
+    }
+}

data/src/java/JdbcAdapterInternalService.java

@@ -0,0 +1,953 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: CPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Common Public
+ * License Version 1.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.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 Ola Bini <ola@ologix.com>
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+import java.io.IOException;
+import java.io.Reader;
+import java.io.InputStream;
+import java.io.ByteArrayInputStream;
+import java.io.StringReader;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSetMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.PreparedStatement;
+import java.sql.Timestamp;
+import java.sql.Types;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Iterator;
+import java.util.HashMap;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBigDecimal;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.RubyTime;
+import org.jruby.javasupport.JavaObject;
+import org.jruby.runtime.Arity;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.util.ByteList;
+
+public class JdbcAdapterInternalService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        RubyClass cJdbcConn = ((RubyModule)(runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters"))).
+            defineClassUnder("JdbcConnection",runtime.getObject(),runtime.getObject().getAllocator());
+
+        CallbackFactory cf = runtime.callbackFactory(JdbcAdapterInternalService.class);
+        cJdbcConn.defineMethod("unmarshal_result",cf.getSingletonMethod("unmarshal_result", IRubyObject.class));
+        cJdbcConn.defineFastMethod("set_connection",cf.getFastSingletonMethod("set_connection", IRubyObject.class));
+        cJdbcConn.defineFastMethod("execute_update",cf.getFastSingletonMethod("execute_update", IRubyObject.class));
+        cJdbcConn.defineFastMethod("execute_query",cf.getFastOptSingletonMethod("execute_query")); 
+        cJdbcConn.defineFastMethod("execute_insert",cf.getFastSingletonMethod("execute_insert", IRubyObject.class));
+        cJdbcConn.defineFastMethod("execute_id_insert",cf.getFastSingletonMethod("execute_id_insert", IRubyObject.class, IRubyObject.class));
+        cJdbcConn.defineFastMethod("primary_keys",cf.getFastSingletonMethod("primary_keys", IRubyObject.class));
+        cJdbcConn.defineFastMethod("set_native_database_types",cf.getFastSingletonMethod("set_native_database_types"));
+        cJdbcConn.defineFastMethod("native_database_types",cf.getFastSingletonMethod("native_database_types"));
+        cJdbcConn.defineFastMethod("begin",cf.getFastSingletonMethod("begin"));
+        cJdbcConn.defineFastMethod("commit",cf.getFastSingletonMethod("commit"));
+        cJdbcConn.defineFastMethod("rollback",cf.getFastSingletonMethod("rollback"));
+        cJdbcConn.defineFastMethod("database_name",cf.getFastSingletonMethod("database_name"));
+        cJdbcConn.defineFastMethod("columns",cf.getFastOptSingletonMethod("columns_internal"));
+        cJdbcConn.defineFastMethod("columns_internal",cf.getFastOptSingletonMethod("columns_internal"));
+        cJdbcConn.defineFastMethod("tables",cf.getFastOptSingletonMethod("tables"));
+
+        cJdbcConn.defineFastMethod("insert_bind",cf.getFastOptSingletonMethod("insert_bind"));
+        cJdbcConn.defineFastMethod("update_bind",cf.getFastOptSingletonMethod("update_bind"));
+
+        cJdbcConn.defineFastMethod("write_large_object",cf.getFastOptSingletonMethod("write_large_object"));
+
+        cJdbcConn.getMetaClass().defineFastMethod("insert?",cf.getFastSingletonMethod("insert_p", IRubyObject.class));
+        cJdbcConn.getMetaClass().defineFastMethod("select?",cf.getFastSingletonMethod("select_p", IRubyObject.class));
+
+        RubyModule jdbcSpec = runtime.getOrCreateModule("JdbcSpec");
+        JDBCMySQLSpec.load(runtime, jdbcSpec);
+        JDBCDerbySpec.load(runtime, jdbcSpec);
+
+        return true;
+    }
+
+    private static int whitespace(int p, final int pend, ByteList bl) {
+        while(p < pend) {
+            switch(bl.bytes[p]) {
+            case ' ':
+            case '\n':
+            case '\r':
+            case '\t':
+                p++;
+                break;
+            default:
+                return p;
+            }
+        }
+        return p;
+    }
+
+    public static IRubyObject insert_p(IRubyObject recv, IRubyObject _sql) {
+        ByteList bl = _sql.convertToString().getByteList();
+
+        int p = bl.begin;
+        int pend = p + bl.realSize;
+
+        p = whitespace(p, pend, bl);
+
+        if(pend - p >= 6) {
+            switch(bl.bytes[p++]) {
+            case 'i':
+            case 'I':
+                switch(bl.bytes[p++]) {
+                case 'n':
+                case 'N':
+                    switch(bl.bytes[p++]) {
+                    case 's':
+                    case 'S':
+                        switch(bl.bytes[p++]) {
+                        case 'e':
+                        case 'E':
+                            switch(bl.bytes[p++]) {
+                            case 'r':
+                            case 'R':
+                                switch(bl.bytes[p++]) {
+                                case 't':
+                                case 'T':
+                                    return recv.getRuntime().getTrue();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return recv.getRuntime().getFalse();
+    }
+
+    public static IRubyObject select_p(IRubyObject recv, IRubyObject _sql) {
+        ByteList bl = _sql.convertToString().getByteList();
+
+        int p = bl.begin;
+        int pend = p + bl.realSize;
+
+        p = whitespace(p, pend, bl);
+
+        if(pend - p >= 6) {
+            if(bl.bytes[p] == '(') {
+                p++;
+                p = whitespace(p, pend, bl);
+            }
+            if(pend - p >= 6) {
+                switch(bl.bytes[p++]) {
+                case 's':
+                case 'S':
+                    switch(bl.bytes[p++]) {
+                    case 'e':
+                    case 'E':
+                        switch(bl.bytes[p++]) {
+                        case 'l':
+                        case 'L':
+                            switch(bl.bytes[p++]) {
+                            case 'e':
+                            case 'E':
+                                switch(bl.bytes[p++]) {
+                                case 'c':
+                                case 'C':
+                                    switch(bl.bytes[p++]) {
+                                    case 't':
+                                    case 'T':
+                                        return recv.getRuntime().getTrue();
+                                    }
+                                }
+                            }
+                        }
+                    case 'h':
+                    case 'H':
+                        switch(bl.bytes[p++]) {
+                        case 'o':
+                        case 'O':
+                            switch(bl.bytes[p++]) {
+                            case 'w':
+                            case 'W':
+                                return recv.getRuntime().getTrue();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return recv.getRuntime().getFalse();
+    }
+
+    private static ResultSet intoResultSet(IRubyObject inp) {
+        return (ResultSet)((inp instanceof JavaObject ? ((JavaObject)inp) : (((JavaObject)(inp.getInstanceVariable("@java_object"))))).getValue());
+    }   
+
+    public static IRubyObject set_connection(IRubyObject recv, IRubyObject conn) {
+        Connection c = (Connection)recv.dataGetStruct();
+        if(c != null) {
+            try {
+                c.close();
+            } catch(Exception e) {}
+        }
+        recv.setInstanceVariable("@connection",conn);
+        c = (Connection)(((JavaObject)conn.getInstanceVariable("@java_object")).getValue());
+        recv.dataWrapStruct(c);
+        return recv;
+    }
+
+    public static IRubyObject tables(IRubyObject recv, IRubyObject[] args) throws SQLException, IOException {
+        Ruby runtime = recv.getRuntime();
+        String catalog = null, schemapat = null, tablepat = null;
+        String[] types = new String[]{"TABLE"};
+        if (args != null) {
+            if (args.length > 0) {
+                catalog = convertToStringOrNull(args[0]);
+            }
+            if (args.length > 1) {
+                schemapat = convertToStringOrNull(args[1]);
+            }
+            if (args.length > 2) {
+                tablepat = convertToStringOrNull(args[2]);
+            }
+            if (args.length > 3) {
+                IRubyObject typearr = args[3];
+                if (typearr instanceof RubyArray) {
+                    IRubyObject[] arr = ((RubyArray) typearr).toJavaArray();
+                    types = new String[arr.length];
+                    for (int i = 0; i < types.length; i++) {
+                        types[i] = arr[i].toString();
+                    }
+                } else {
+                    types = new String[] {types.toString()};
+                }
+            }
+        }
+        while (true) {
+            Connection c = (Connection) recv.dataGetStruct();
+            ResultSet rs = null;
+            try {
+                DatabaseMetaData metadata = c.getMetaData();
+                String clzName = metadata.getClass().getName().toLowerCase();
+                boolean isOracle = clzName.indexOf("oracle") != -1 || clzName.indexOf("oci") != -1;
+                
+                if(schemapat == null && isOracle) {
+                    ResultSet schemas = metadata.getSchemas();
+                    String username = metadata.getUserName();
+                    while(schemas.next()) {
+                        if(schemas.getString(1).equalsIgnoreCase(username)) {
+                            schemapat = schemas.getString(1);
+                            break;
+                        }
+                    }
+                    schemas.close();
+                }
+                rs = metadata.getTables(catalog, schemapat, tablepat, types);
+                List arr = new ArrayList();
+                while (rs.next()) {
+                    String name = rs.getString(3).toLowerCase();
+                    if(!isOracle || !name.startsWith("bin$")) { //Handle stupid Oracle 10g RecycleBin feature
+                        arr.add(runtime.newString(name));
+                    }
+                }
+                return runtime.newArray(arr);
+            } catch (SQLException e) {
+                if(c.isClosed()) {
+                    recv = recv.callMethod(recv.getRuntime().getCurrentContext(),"reconnect!");
+                    if(!((Connection)recv.dataGetStruct()).isClosed()) {
+                        continue;
+                    }
+                }
+                throw wrap(recv, e);
+            } finally {
+                try {
+                    rs.close();
+                } catch(Exception e) {}
+            }
+
+        }
+    }
+
+    public static IRubyObject native_database_types(IRubyObject recv) {
+        return recv.getInstanceVariable("@tps");
+    }    
+
+    public static IRubyObject set_native_database_types(IRubyObject recv) throws SQLException, IOException {
+        Ruby runtime = recv.getRuntime();
+        ThreadContext ctx = runtime.getCurrentContext();
+        IRubyObject types = unmarshal_result_downcase(recv, ((Connection)recv.dataGetStruct()).getMetaData().getTypeInfo());
+        recv.setInstanceVariable("@native_types", 
+                                 ((RubyModule)(runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters"))).
+                                 getConstant("JdbcTypeConverter").callMethod(ctx,"new", types).
+                                 callMethod(ctx, "choose_best_types"));
+        return runtime.getNil();
+    }
+
+    public static IRubyObject database_name(IRubyObject recv) throws SQLException {
+        String name = ((Connection)recv.dataGetStruct()).getCatalog();
+        if(null == name) {
+            name = ((Connection)recv.dataGetStruct()).getMetaData().getUserName();
+            if(null == name) {
+                name = "db1";
+            }
+        }
+        return recv.getRuntime().newString(name);
+    }
+
+    public static IRubyObject begin(IRubyObject recv) throws SQLException {
+        ((Connection)recv.dataGetStruct()).setAutoCommit(false);
+        return recv.getRuntime().getNil();
+    }
+
+    public static IRubyObject commit(IRubyObject recv) throws SQLException {
+        try {
+            ((Connection)recv.dataGetStruct()).commit();
+            return recv.getRuntime().getNil();
+        } finally {
+            ((Connection)recv.dataGetStruct()).setAutoCommit(true);
+        }
+    }
+
+    public static IRubyObject rollback(IRubyObject recv) throws SQLException {
+        try {
+            ((Connection)recv.dataGetStruct()).rollback();
+            return recv.getRuntime().getNil();
+        } finally {
+            ((Connection)recv.dataGetStruct()).setAutoCommit(true);
+        }
+    }
+
+    public static IRubyObject columns_internal(IRubyObject recv, IRubyObject[] args) throws SQLException, IOException {
+        String table_name = args[0].convertToString().getUnicodeValue();
+        int tries = 10;
+        while(true) {
+            Connection c = (Connection)recv.dataGetStruct();
+            try {
+                DatabaseMetaData metadata = c.getMetaData();
+                String clzName = metadata.getClass().getName().toLowerCase();
+                boolean isDerby = clzName.indexOf("derby") != -1;
+                boolean isOracle = clzName.indexOf("oracle") != -1 || clzName.indexOf("oci") != -1;
+                String schemaName = null;
+                if(args.length>2) {
+                    schemaName = args[2].toString();
+                }
+                if(metadata.storesUpperCaseIdentifiers()) {
+                    table_name = table_name.toUpperCase();
+                } else if(metadata.storesLowerCaseIdentifiers()) {
+                    table_name = table_name.toLowerCase();
+                }
+                if(schemaName == null && (isDerby || isOracle)) {
+                    ResultSet schemas = metadata.getSchemas();
+                    String username = metadata.getUserName();
+                    while(schemas.next()) {
+                        if(schemas.getString(1).equalsIgnoreCase(username)) {
+                            schemaName = schemas.getString(1);
+                            break;
+                        }
+                    }
+                    schemas.close();
+                }
+                
+                ResultSet results = metadata.getColumns(c.getCatalog(),schemaName,table_name,null);
+                return unmarshal_columns(recv, metadata, results);
+            } catch(SQLException e) {
+                if(c.isClosed()) {
+                    recv = recv.callMethod(recv.getRuntime().getCurrentContext(),"reconnect!");
+                    if(!((Connection)recv.dataGetStruct()).isClosed() && --tries > 0) {
+                        continue;
+                    }
+                }
+                throw wrap(recv, e);
+            }
+        }    
+    }
+
+    private static final java.util.regex.Pattern HAS_SMALL = java.util.regex.Pattern.compile("[a-z]");
+    private static final java.util.regex.Pattern HAS_LARGE = java.util.regex.Pattern.compile("[A-Z]");
+    private static IRubyObject unmarshal_columns(IRubyObject recv, DatabaseMetaData metadata, ResultSet rs) throws SQLException, IOException {
+        try {
+            List columns = new ArrayList();
+            String clzName = metadata.getClass().getName().toLowerCase();
+            boolean isDerby = clzName.indexOf("derby") != -1;
+            boolean isOracle = clzName.indexOf("oracle") != -1 || clzName.indexOf("oci") != -1;
+            Ruby runtime = recv.getRuntime();
+            ThreadContext ctx = runtime.getCurrentContext();
+
+            RubyHash tps = ((RubyHash)(recv.callMethod(ctx, "adapter").callMethod(ctx,"native_database_types")));
+
+            IRubyObject jdbcCol = ((RubyModule)(runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters"))).getConstant("JdbcColumn");
+
+            while(rs.next()) {
+                String column_name = rs.getString(4);
+                if(metadata.storesUpperCaseIdentifiers() && !HAS_SMALL.matcher(column_name).find()) {
+                    column_name = column_name.toLowerCase();
+                }
+
+                String prec = rs.getString(7);
+                String scal = rs.getString(9);
+                int precision = -1;
+                int scale = -1;
+                if(prec != null) {
+                    precision = Integer.parseInt(prec);
+                    if(scal != null) {
+                        scale = Integer.parseInt(scal);
+                    }
+                }
+                String type = rs.getString(6);
+                if(prec != null && precision > 0) {
+                    type += "(" + precision;
+                    if(scal != null && scale > 0) {
+                        type += "," + scale;
+                    }
+                    type += ")";
+                }
+                String def = rs.getString(13);
+                IRubyObject _def;
+                if(def == null || (isOracle && def.toLowerCase().trim().equals("null"))) {
+                    _def = runtime.getNil();
+                } else {
+                    if(isOracle) {
+                        def = def.trim();
+                    }
+                    if((isDerby || isOracle) && def.length() > 0 && def.charAt(0) == '\'') {
+                        def = def.substring(1, def.length()-1);
+                    }
+                    _def = runtime.newString(def);
+                }
+                IRubyObject c = jdbcCol.callMethod(ctx,"new", new IRubyObject[]{recv.getInstanceVariable("@config"), runtime.newString(column_name),
+                                                                                _def, runtime.newString(type), 
+                                                                                runtime.newBoolean(!rs.getString(18).trim().equals("NO"))});
+                columns.add(c);
+
+                IRubyObject tp = (IRubyObject)tps.fastARef(c.callMethod(ctx,"type"));
+                if(tp != null && !tp.isNil() && tp.callMethod(ctx,"[]",runtime.newSymbol("limit")).isNil()) {
+                    c.callMethod(ctx,"limit=", runtime.getNil());
+                    if(!c.callMethod(ctx,"type").equals(runtime.newSymbol("decimal"))) {
+                        c.callMethod(ctx,"precision=", runtime.getNil());
+                    }
+                }
+            }
+            return runtime.newArray(columns);
+        } finally {
+            try {
+                rs.close();
+            } catch(Exception e) {}
+        }
+    }
+
+    public static IRubyObject primary_keys(IRubyObject recv, IRubyObject _table_name) throws SQLException {
+        Connection c = (Connection)recv.dataGetStruct();
+        DatabaseMetaData metadata = c.getMetaData();
+        String table_name = _table_name.toString();
+        if(metadata.storesUpperCaseIdentifiers()) {
+            table_name = table_name.toUpperCase();
+        } else if(metadata.storesLowerCaseIdentifiers()) {
+            table_name = table_name.toLowerCase();
+        }
+        ResultSet result_set = metadata.getPrimaryKeys(null,null,table_name);
+        List keyNames = new ArrayList();
+        Ruby runtime = recv.getRuntime();
+        while(result_set.next()) {
+            String s1 = result_set.getString(4);
+            if(metadata.storesUpperCaseIdentifiers() && !HAS_SMALL.matcher(s1).find()) {
+                s1 = s1.toLowerCase();
+            }
+            keyNames.add(runtime.newString(s1));
+        }
+        
+        try {
+            result_set.close();
+        } catch(Exception e) {}
+
+        return runtime.newArray(keyNames);
+    }
+
+    public static IRubyObject execute_id_insert(IRubyObject recv, IRubyObject sql, IRubyObject id) throws SQLException {
+        Connection c = (Connection)recv.dataGetStruct();
+        PreparedStatement ps = c.prepareStatement(sql.convertToString().getUnicodeValue());
+        try {
+            ps.setLong(1,RubyNumeric.fix2long(id));
+            ps.executeUpdate();
+        } finally {
+            ps.close();
+        }
+        return id;
+    }
+
+    private static RuntimeException wrap(IRubyObject recv, Throwable exception) {
+        return recv.getRuntime().newArgumentError(exception.getMessage());
+    }
+
+    public static IRubyObject execute_update(IRubyObject recv, IRubyObject sql) throws SQLException {
+        int tries = 10;
+        while(true) {
+            Connection c = (Connection)recv.dataGetStruct();
+            Statement stmt = null;
+            try {
+                stmt = c.createStatement();
+                return recv.getRuntime().newFixnum(stmt.executeUpdate(sql.convertToString().getUnicodeValue()));
+            } catch(SQLException e) {
+                if(c.isClosed()) {
+                    recv = recv.callMethod(recv.getRuntime().getCurrentContext(),"reconnect!");
+                    if(!((Connection)recv.dataGetStruct()).isClosed() && --tries > 0) {
+                        continue;
+                    }
+                }
+
+                throw wrap(recv, e);
+            } finally {
+                if(null != stmt) {
+                    try {
+                        stmt.close();
+                    } catch(Exception e) {}
+                }
+            }
+        }
+    }
+
+    public static IRubyObject execute_query(IRubyObject recv, IRubyObject[] args) throws SQLException, IOException {
+        IRubyObject sql = args[0];
+        int maxrows = 0;
+        if(args.length > 1) {
+            maxrows = RubyNumeric.fix2int(args[1]);
+        }
+        int tries = 10;
+        while(true) {
+            Connection c = (Connection)recv.dataGetStruct();
+            Statement stmt = null;
+            try {
+                stmt = c.createStatement();
+                stmt.setMaxRows(maxrows);
+                return unmarshal_result(recv, stmt.executeQuery(sql.convertToString().getUnicodeValue()));
+            } catch(SQLException e) {
+                if(c.isClosed()) {
+                    recv = recv.callMethod(recv.getRuntime().getCurrentContext(),"reconnect!");
+                    if(!((Connection)recv.dataGetStruct()).isClosed() && --tries > 0) {
+                        continue;
+                    }
+                }
+                throw wrap(recv, e);
+            } finally {
+                if(null != stmt) {
+                    try {
+                        stmt.close();
+                    } catch(Exception e) {}
+                }
+            }
+        }
+    }
+
+    public static IRubyObject execute_insert(IRubyObject recv, IRubyObject sql) throws SQLException {
+        int tries = 10;
+        while(true) {
+            Connection c = (Connection)recv.dataGetStruct();
+            Statement stmt = null;
+            try {
+                stmt = c.createStatement();
+                stmt.executeUpdate(sql.convertToString().getUnicodeValue(), Statement.RETURN_GENERATED_KEYS);
+                return unmarshal_id_result(recv.getRuntime(), stmt.getGeneratedKeys());
+            } catch(SQLException e) {
+                if(c.isClosed()) {
+                    recv = recv.callMethod(recv.getRuntime().getCurrentContext(),"reconnect!");
+                    if(!((Connection)recv.dataGetStruct()).isClosed() && --tries > 0) {
+                        continue;
+                    }
+                }
+                throw wrap(recv, e);
+            } finally {
+                if(null != stmt) {
+                    try {
+                        stmt.close();
+                    } catch(Exception e) {}
+                }
+            }
+        }
+    }
+
+    public static IRubyObject unmarshal_result_downcase(IRubyObject recv, ResultSet rs) throws SQLException, IOException {
+        List results = new ArrayList();
+        Ruby runtime = recv.getRuntime();
+        try {
+            ResultSetMetaData metadata = rs.getMetaData();
+            int col_count = metadata.getColumnCount();
+            IRubyObject[] col_names = new IRubyObject[col_count];
+            int[] col_types = new int[col_count];
+            int[] col_scale = new int[col_count];
+
+            for(int i=0;i<col_count;i++) {
+                col_names[i] = runtime.newString(metadata.getColumnName(i+1).toLowerCase());
+                col_types[i] = metadata.getColumnType(i+1);
+                col_scale[i] = metadata.getScale(i+1);
+            }
+
+            while(rs.next()) {
+                RubyHash row = RubyHash.newHash(runtime);
+                for(int i=0;i<col_count;i++) {
+                    row.aset(col_names[i], jdbc_to_ruby(runtime, i+1, col_types[i], col_scale[i], rs));
+                }
+                results.add(row);
+            }
+        } finally {
+            try {
+                rs.close();
+            } catch(Exception e) {}
+        }
+ 
+        return runtime.newArray(results);
+    }
+
+    public static IRubyObject unmarshal_result(IRubyObject recv, ResultSet rs) throws SQLException, IOException {
+        Ruby runtime = recv.getRuntime();
+        List results = new ArrayList();
+        try {
+            ResultSetMetaData metadata = rs.getMetaData();
+            boolean storesUpper = rs.getStatement().getConnection().getMetaData().storesUpperCaseIdentifiers();
+            int col_count = metadata.getColumnCount();
+            IRubyObject[] col_names = new IRubyObject[col_count];
+            int[] col_types = new int[col_count];
+            int[] col_scale = new int[col_count];
+
+            for(int i=0;i<col_count;i++) {
+                String s1 = metadata.getColumnName(i+1);
+                if(storesUpper && !HAS_SMALL.matcher(s1).find()) {
+                    s1 = s1.toLowerCase();
+                }
+                col_names[i] = runtime.newString(s1);
+                col_types[i] = metadata.getColumnType(i+1);
+                col_scale[i] = metadata.getScale(i+1);
+            }
+
+            while(rs.next()) {
+                RubyHash row = RubyHash.newHash(runtime);
+                for(int i=0;i<col_count;i++) {
+                    row.aset(col_names[i], jdbc_to_ruby(runtime, i+1, col_types[i], col_scale[i], rs));
+                }
+                results.add(row);
+            }
+        } finally {
+            try {
+                rs.close();
+            } catch(Exception e) {}
+        }
+        return runtime.newArray(results);
+    }
+
+    public static IRubyObject unmarshal_result(IRubyObject recv, IRubyObject resultset, Block row_filter) throws SQLException, IOException {
+        Ruby runtime = recv.getRuntime();
+        ResultSet rs = intoResultSet(resultset);
+        List results = new ArrayList();
+        try {
+            ResultSetMetaData metadata = rs.getMetaData();
+            int col_count = metadata.getColumnCount();
+            IRubyObject[] col_names = new IRubyObject[col_count];
+            int[] col_types = new int[col_count];
+            int[] col_scale = new int[col_count];
+
+            for(int i=0;i<col_count;i++) {
+                col_names[i] = runtime.newString(metadata.getColumnName(i+1));
+                col_types[i] = metadata.getColumnType(i+1);
+                col_scale[i] = metadata.getScale(i+1);
+            }
+
+            if(row_filter.isGiven()) {
+                while(rs.next()) {
+                    if(row_filter.yield(runtime.getCurrentContext(),resultset).isTrue()) {
+                        RubyHash row = RubyHash.newHash(runtime);
+                        for(int i=0;i<col_count;i++) {
+                            row.aset(col_names[i], jdbc_to_ruby(runtime, i+1, col_types[i], col_scale[i], rs));
+                        }
+                        results.add(row);
+                    }
+                }
+            } else {
+                while(rs.next()) {
+                    RubyHash row = RubyHash.newHash(runtime);
+                    for(int i=0;i<col_count;i++) {
+                        row.aset(col_names[i], jdbc_to_ruby(runtime, i+1, col_types[i], col_scale[i], rs));
+                    }
+                    results.add(row);
+                }
+            }
+
+        } finally {
+            try {
+                rs.close();
+            } catch(Exception e) {}
+        }
+ 
+        return runtime.newArray(results);
+    }
+
+    private static IRubyObject jdbc_to_ruby(Ruby runtime, int row, int type, int scale, ResultSet rs) throws SQLException, IOException {
+        int n;
+        switch(type) {
+        case Types.BINARY:
+        case Types.BLOB:
+        case Types.LONGVARBINARY:
+        case Types.VARBINARY:
+            InputStream is = rs.getBinaryStream(row);
+            if(is == null || rs.wasNull()) {
+                return runtime.getNil();
+            }
+            ByteList str = new ByteList(2048);
+            byte[] buf = new byte[2048];
+            while((n = is.read(buf)) != -1) {
+                str.append(buf, 0, n);
+            }
+            is.close();
+            return runtime.newString(str);
+        case Types.LONGVARCHAR:
+        case Types.CLOB:
+            Reader rss = rs.getCharacterStream(row);
+            if(rss == null || rs.wasNull()) {
+                return runtime.getNil();
+            }
+            StringBuffer str2 = new StringBuffer(2048);
+            char[] cuf = new char[2048];
+            while((n = rss.read(cuf)) != -1) {
+                str2.append(cuf, 0, n);
+            }
+            rss.close();
+            return RubyString.newUnicodeString(runtime, str2.toString());
+        case Types.TIMESTAMP:
+        	Timestamp time = rs.getTimestamp(row);
+        	if (time == null || rs.wasNull()) {
+        		return runtime.getNil();
+        	}
+            String sttr = time.toString();
+            if(sttr.endsWith(" 00:00:00.0")) {
+                sttr = sttr.substring(0, sttr.length()-(" 00:00:00.0".length()));
+            }
+        	return RubyString.newUnicodeString(runtime, sttr);
+        default:
+            String vs = rs.getString(row);
+            if(vs == null || rs.wasNull()) {
+                return runtime.getNil();
+            }
+
+            return RubyString.newUnicodeString(runtime, vs);
+        }
+    }
+
+    public static IRubyObject unmarshal_id_result(Ruby runtime, ResultSet rs) throws SQLException {
+        try {
+            if(rs.next()) {
+                if(rs.getMetaData().getColumnCount() > 0) {
+                    return runtime.newFixnum(rs.getLong(1));
+                }
+            }
+            return runtime.getNil();
+        } finally {
+            try {
+                rs.close();
+            } catch(Exception e) {}
+        }
+    }
+
+    private static String convertToStringOrNull(IRubyObject obj) {
+        if (obj.isNil()) {
+            return null;
+        }
+        return obj.toString();
+    }
+
+    private static int getTypeValueFor(Ruby runtime, IRubyObject type) throws SQLException {
+        if(!(type instanceof RubySymbol)) {
+            type = type.callMethod(runtime.getCurrentContext(),"type");
+        }
+        if(type == runtime.newSymbol("string")) {
+            return Types.VARCHAR;
+        } else if(type == runtime.newSymbol("text")) {
+            return Types.CLOB;
+        } else if(type == runtime.newSymbol("integer")) {
+            return Types.INTEGER;
+        } else if(type == runtime.newSymbol("decimal")) {
+            return Types.DECIMAL;
+        } else if(type == runtime.newSymbol("float")) {
+            return Types.FLOAT;
+        } else if(type == runtime.newSymbol("datetime")) {
+            return Types.TIMESTAMP;
+        } else if(type == runtime.newSymbol("timestamp")) {
+            return Types.TIMESTAMP;
+        } else if(type == runtime.newSymbol("time")) {
+            return Types.TIME;
+        } else if(type == runtime.newSymbol("date")) {
+            return Types.DATE;
+        } else if(type == runtime.newSymbol("binary")) {
+            return Types.BLOB;
+        } else if(type == runtime.newSymbol("boolean")) {
+            return Types.BOOLEAN;
+        } else {
+            return -1;
+        }
+    }
+    
+    private final static DateFormat FORMAT = new SimpleDateFormat("%y-%M-%d %H:%m:%s");
+
+    private static void setValue(PreparedStatement ps, int index, Ruby runtime, IRubyObject value, IRubyObject type) throws SQLException {
+        final int tp = getTypeValueFor(runtime, type);
+        if(value.isNil()) {
+            ps.setNull(index, tp);
+            return;
+        }
+
+        switch(tp) {
+        case Types.VARCHAR:
+        case Types.CLOB:
+            ps.setString(index, RubyString.objAsString(value).toString());
+            break;
+        case Types.INTEGER:
+            ps.setLong(index, RubyNumeric.fix2long(value));
+            break;
+        case Types.FLOAT:
+            ps.setDouble(index, ((RubyNumeric)value).getDoubleValue());
+            break;
+        case Types.TIMESTAMP:
+        case Types.TIME:
+        case Types.DATE:
+            if(!(value instanceof RubyTime)) {
+                try {
+                    Date dd = FORMAT.parse(RubyString.objAsString(value).toString());
+                    ps.setTimestamp(index, new java.sql.Timestamp(dd.getTime()), Calendar.getInstance());
+                } catch(Exception e) {
+                    ps.setString(index, RubyString.objAsString(value).toString());
+                }
+            } else {
+                RubyTime rubyTime = (RubyTime) value;
+                java.util.Date date = rubyTime.getJavaDate();
+                long millis = date.getTime();
+                long micros = rubyTime.microseconds() - millis / 1000;
+                java.sql.Timestamp ts = new java.sql.Timestamp(millis);
+                java.util.Calendar cal = Calendar.getInstance();
+                cal.setTime(date);
+                ts.setNanos((int)(micros * 1000));
+                ps.setTimestamp(index, ts, cal);
+            }
+            break;
+        case Types.BOOLEAN:
+            ps.setBoolean(index, value.isTrue());
+            break;
+        default: throw new RuntimeException("type " + type + " not supported in _bind yet");
+        }
+    }
+
+    private static void setValuesOnPS(PreparedStatement ps, Ruby runtime, IRubyObject values, IRubyObject types) throws SQLException {
+        RubyArray vals = (RubyArray)values;
+        RubyArray tps = (RubyArray)types;
+
+        for(int i=0, j=vals.getLength(); i<j; i++) {
+            setValue(ps, i+1, runtime, vals.eltInternal(i), tps.eltInternal(i));
+        }
+    }
+
+    /*
+     * sql, values, types, name = nil, pk = nil, id_value = nil, sequence_name = nil
+     */
+    public static IRubyObject insert_bind(IRubyObject recv, IRubyObject[] args) throws SQLException {
+        Ruby runtime = recv.getRuntime();
+        Arity.checkArgumentCount(runtime, args, 3, 7);
+        Connection c = (Connection)recv.dataGetStruct();
+        PreparedStatement ps = null;
+        try {
+            ps = c.prepareStatement(RubyString.objAsString(args[0]).toString(), Statement.RETURN_GENERATED_KEYS);
+            setValuesOnPS(ps, runtime, args[1], args[2]);
+            ps.executeUpdate();
+            return unmarshal_id_result(runtime, ps.getGeneratedKeys());
+        } finally {
+            try {
+                ps.close();
+            } catch(Exception e) {}
+        }
+    }
+
+    /*
+     * sql, values, types, name = nil
+     */
+    public static IRubyObject update_bind(IRubyObject recv, IRubyObject[] args) throws SQLException {
+        Ruby runtime = recv.getRuntime();
+        Arity.checkArgumentCount(runtime, args, 3, 4);
+        Connection c = (Connection)recv.dataGetStruct();
+        PreparedStatement ps = null;
+        try {
+            ps = c.prepareStatement(RubyString.objAsString(args[0]).toString());
+            setValuesOnPS(ps, runtime, args[1], args[2]);
+            ps.executeUpdate();
+        } finally {
+            try {
+                ps.close();
+            } catch(Exception e) {}
+        }
+        return runtime.getNil();
+    }
+
+
+    private final static String LOB_UPDATE = "UPDATE ? WHERE ";
+
+    /*
+     * (is binary?, colname, tablename, primary key, id, value)
+     */
+    public static IRubyObject write_large_object(IRubyObject recv, IRubyObject[] args) throws SQLException, IOException {
+        Ruby runtime = recv.getRuntime();
+        Arity.checkArgumentCount(runtime, args, 6, 6);
+        Connection c = (Connection)recv.dataGetStruct();
+        String sql = "UPDATE " + args[2].toString() + " SET " + args[1].toString() + " = ? WHERE " + args[3] + "=" + args[4];
+        PreparedStatement ps = null;
+        try {
+            ByteList outp = RubyString.objAsString(args[5]).getByteList();
+            ps = c.prepareStatement(sql);
+            if(args[0].isTrue()) { // binary
+                ps.setBinaryStream(1,new ByteArrayInputStream(outp.bytes, outp.begin, outp.realSize), outp.realSize);
+            } else { // clob
+                String ss = outp.toString();
+                ps.setCharacterStream(1,new StringReader(ss), ss.length());
+            }
+            ps.executeUpdate();
+        } finally {
+            try {
+                ps.close();
+            } catch(Exception e) {}
+        }
+        return runtime.getNil();
+    }
+}