activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/src/java/arjdbc/h2/H2RubyJdbcConnection.java

@@ -0,0 +1,70 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.h2;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class H2RubyJdbcConnection extends RubyJdbcConnection {
+    protected H2RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createH2JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("H2JdbcConnection",
+                jdbcConnection, H2_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(H2RubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator H2_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new H2RubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    /**
+     * H2 supports schemas.
+     */
+    @Override
+    protected boolean databaseSupportsSchemas() {
+        return true;
+    }
+}

data/src/java/{jdbc_adapter/MssqlRubyJdbcConnection.java → arjdbc/informix/InformixRubyJdbcConnection.java}

@@ -1,6 +1,6 @@
 /*
  **** BEGIN LICENSE BLOCK *****
- * Copyright (c) 2006-2009 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
  * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
  *
@@ -23,11 +23,15 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ***** END LICENSE BLOCK *****/
-package jdbc_adapter;
+
+package arjdbc.informix;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Types;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.runtime.ObjectAllocator;
@@ -37,28 +41,27 @@ import org.jruby.runtime.builtin.IRubyObject;
  *
  * @author nicksieger
  */
-public class MssqlRubyJdbcConnection extends RubyJdbcConnection {
-
-    protected MssqlRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+public class InformixRubyJdbcConnection extends RubyJdbcConnection {
+    protected InformixRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
 
-    public static RubyClass createMssqlJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
-        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("MssqlJdbcConnection",
-                jdbcConnection, MSSQL_JDBCCONNECTION_ALLOCATOR);
-        clazz.defineAnnotatedMethods(MssqlRubyJdbcConnection.class);
+    public static RubyClass createInformixJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("InformixJdbcConnection",
+                jdbcConnection, INFORMIX_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(InformixRubyJdbcConnection.class);
 
         return clazz;
     }
-    private static ObjectAllocator MSSQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
 
+    private static ObjectAllocator INFORMIX_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
-            return new MssqlRubyJdbcConnection(runtime, klass);
+            return new InformixRubyJdbcConnection(runtime, klass);
         }
     };
 
     /**
-     * Treat LONGVARCHAR as CLOB on Mssql for purposes of converting a JDBC value to Ruby.
+     * Treat LONGVARCHAR as CLOB on Informix for purposes of converting a JDBC value to Ruby.
      */
     @Override
     protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)

data/src/java/{jdbc_adapter/JdbcAdapterInternalService.java → arjdbc/jdbc/AdapterJavaService.java}

@@ -1,6 +1,6 @@
 /*
  **** BEGIN LICENSE BLOCK *****
- * Copyright (c) 2006-2009 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
  * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
  *
@@ -24,10 +24,20 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ***** END LICENSE BLOCK *****/
 
-package jdbc_adapter;
+package arjdbc.jdbc;
 
 import java.io.IOException;
 
+import arjdbc.derby.DerbyModule;
+import arjdbc.h2.H2RubyJdbcConnection;
+import arjdbc.informix.InformixRubyJdbcConnection;
+import arjdbc.mssql.MssqlRubyJdbcConnection;
+import arjdbc.mysql.MySQLModule;
+import arjdbc.mysql.MySQLRubyJdbcConnection;
+import arjdbc.oracle.OracleRubyJdbcConnection;
+import arjdbc.postgresql.PostgresqlRubyJdbcConnection;
+import arjdbc.sqlite3.Sqlite3RubyJdbcConnection;
+
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyModule;
@@ -35,19 +45,22 @@ import org.jruby.RubyObjectAdapter;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.runtime.load.BasicLibraryService;
 
-public class JdbcAdapterInternalService implements BasicLibraryService {
+public class AdapterJavaService implements BasicLibraryService {
     private static RubyObjectAdapter rubyApi;
 
     public boolean basicLoad(final Ruby runtime) throws IOException {
         RubyClass jdbcConnection = RubyJdbcConnection.createJdbcConnectionClass(runtime);
-        PostgresRubyJdbcConnection.createPostgresJdbcConnectionClass(runtime, jdbcConnection);
+        PostgresqlRubyJdbcConnection.createPostgresqlJdbcConnectionClass(runtime, jdbcConnection);
         MssqlRubyJdbcConnection.createMssqlJdbcConnectionClass(runtime, jdbcConnection);
+        InformixRubyJdbcConnection.createInformixJdbcConnectionClass(runtime, jdbcConnection);
+        OracleRubyJdbcConnection.createOracleJdbcConnectionClass(runtime, jdbcConnection);
         Sqlite3RubyJdbcConnection.createSqlite3JdbcConnectionClass(runtime, jdbcConnection);
-        RubyModule jdbcSpec = runtime.getOrCreateModule("JdbcSpec");
-
+        H2RubyJdbcConnection.createH2JdbcConnectionClass(runtime, jdbcConnection);
+        MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(runtime, jdbcConnection);
+        RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
         rubyApi = JavaEmbedUtils.newObjectAdapter();
-        JdbcMySQLSpec.load(jdbcSpec);
-        JdbcDerbySpec.load(jdbcSpec, rubyApi);
+        MySQLModule.load(arJdbc);
+        DerbyModule.load(arJdbc, rubyApi);
         return true;
     }
 }

data/src/java/{jdbc_adapter → arjdbc/jdbc}/JdbcConnectionFactory.java

@@ -1,7 +1,7 @@
 /***** BEGIN LICENSE BLOCK *****
- * Copyright (c) 2006-2007 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -9,10 +9,10 @@
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -22,13 +22,13 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ***** END LICENSE BLOCK *****/
 
-package jdbc_adapter;
+package arjdbc.jdbc;
 
 import java.sql.Connection;
 
 /**
  * Interface to be implemented in Ruby for retrieving a new connection
- *  
+ *
  * @author nicksieger
  */
 public interface JdbcConnectionFactory {

data/src/java/{jdbc_adapter → arjdbc/jdbc}/RubyJdbcConnection.java

@@ -1,6 +1,6 @@
 /*
  **** BEGIN LICENSE BLOCK *****
- * Copyright (c) 2006-2009 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
  * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
  *
@@ -23,25 +23,14 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  ***** END LICENSE BLOCK *****/
-package jdbc_adapter;
+package arjdbc.jdbc;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
 import java.io.StringReader;
-import org.jruby.Ruby;
-import org.jruby.RubyClass;
-import org.jruby.RubyModule;
-import org.jruby.RubyObject;
-import org.jruby.RubyObjectAdapter;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.javasupport.JavaEmbedUtils;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.ByteList;
-
+import java.math.BigInteger;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -57,17 +46,31 @@ import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
+
+import org.jruby.Ruby;
 import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyClass;
 import org.jruby.RubyHash;
+import org.jruby.RubyModule;
 import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyObjectAdapter;
 import org.jruby.RubyString;
 import org.jruby.RubySymbol;
 import org.jruby.RubyTime;
+import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.Java;
+import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaObject;
+import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 
 /**
  * Part of our ActiveRecord::ConnectionAdapters::Connection impl.
@@ -117,35 +120,51 @@ public class RubyJdbcConnection extends RubyObject {
             throws SQLException, IOException {
         return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
             public Object call(Connection c) throws SQLException {
-                ResultSet results = null;
+                ResultSet results = null, pkeys = null;
                 try {
                     String table_name = rubyApi.convertToRubyString(args[0]).getUnicodeValue();
                     String schemaName = null;
 
-                    int index = table_name.indexOf(".");
-                    if(index != -1) {
-                        schemaName = table_name.substring(0, index);
-                        table_name = table_name.substring(index + 1);
+                    final String[] name_parts = table_name.split( "\\." );
+                    if ( name_parts.length > 3 ) {
+                        throw new SQLException("Table name '" + table_name + "' should not contain more than 2 '.'");
                     }
 
                     DatabaseMetaData metadata = c.getMetaData();
+                    String clzName = metadata.getClass().getName().toLowerCase();
+                    boolean isDB2 = clzName.indexOf("db2") != -1 || clzName.indexOf("as400") != -1;
+
+                    String catalog = c.getCatalog();
+                    if( name_parts.length == 2 ) {
+                        schemaName = name_parts[0];
+                        table_name = name_parts[1];
+                    }
+                    else if ( name_parts.length == 3 ) {
+                        catalog = name_parts[0];
+                        schemaName = name_parts[1];
+                        table_name = name_parts[2];
+                    }
 
                     if(args.length > 2 && schemaName == null) schemaName = toStringOrNull(args[2]);
 
                     if (schemaName != null) schemaName = caseConvertIdentifierForJdbc(metadata, schemaName);
                     table_name = caseConvertIdentifierForJdbc(metadata, table_name);
 
+                    if (schemaName != null && !isDB2 && !databaseSupportsSchemas()) { catalog = schemaName; }
+
                     String[] tableTypes = new String[]{"TABLE","VIEW","SYNONYM"};
                     RubyArray matchingTables = (RubyArray) tableLookupBlock(context.getRuntime(),
-                            c.getCatalog(), schemaName, table_name, tableTypes, false).call(c);
+                            catalog, schemaName, table_name, tableTypes, false).call(c);
                     if (matchingTables.isEmpty()) {
                         throw new SQLException("Table " + table_name + " does not exist");
                     }
 
-                    results = metadata.getColumns(c.getCatalog(),schemaName,table_name,null);
-                    return unmarshal_columns(context, metadata, results);
+                    results = metadata.getColumns(catalog,schemaName,table_name,null);
+                    pkeys = metadata.getPrimaryKeys(catalog,schemaName,table_name);
+                    return unmarshal_columns(context, metadata, results, pkeys);
                 } finally {
                     close(results);
+                    close(pkeys);
                 }
             }
         });
@@ -192,15 +211,62 @@ public class RubyJdbcConnection extends RubyObject {
         return setConnection(null);
     }
 
+    @JRubyMethod
+    public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
+        return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
+            public Object call(Connection c) throws SQLException {
+                Statement stmt = null;
+                String query = rubyApi.convertToRubyString(sql).getUnicodeValue();
+                try {
+                    stmt = c.createStatement();
+                    if (genericExecute(stmt, query)) {
+                        return unmarshalResults(context, c.getMetaData(), stmt, false);
+                    } else {
+                        return unmarshalKeysOrUpdateCount(context, c, stmt);
+                    }
+                } catch (SQLException sqe) {
+                    if (context.getRuntime().isDebug()) {
+                        System.out.println("Error SQL: " + query);
+                    }
+                    throw sqe;
+                } finally {
+                    close(stmt);
+                }
+            }
+        });
+    }
+
+    protected boolean genericExecute(Statement stmt, String query) throws SQLException {
+        return stmt.execute(query);
+    }
+
+    protected IRubyObject unmarshalKeysOrUpdateCount(ThreadContext context, Connection c, Statement stmt) throws SQLException {
+        IRubyObject key = context.getRuntime().getNil();
+        if (c.getMetaData().supportsGetGeneratedKeys()) {
+            key = unmarshal_id_result(context.getRuntime(), stmt.getGeneratedKeys());
+        }
+        if (key.isNil()) {
+            return context.getRuntime().newFixnum(stmt.getUpdateCount());
+        } else {
+            return key;
+        }
+    }
+
     @JRubyMethod(name = "execute_id_insert", required = 2)
-    public IRubyObject execute_id_insert(ThreadContext context, final IRubyObject sql,
+    public IRubyObject execute_id_insert(final ThreadContext context, final IRubyObject sql,
             final IRubyObject id) throws SQLException {
         return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
             public Object call(Connection c) throws SQLException {
-                PreparedStatement ps = c.prepareStatement(rubyApi.convertToRubyString(sql).getUnicodeValue());
+                String insert = rubyApi.convertToRubyString(sql).getUnicodeValue();
+                PreparedStatement ps = c.prepareStatement(insert);
                 try {
                     ps.setLong(1, RubyNumeric.fix2long(id));
                     ps.executeUpdate();
+                } catch (SQLException sqe) {
+                    if (context.getRuntime().isDebug()) {
+                        System.out.println("Error SQL: " + insert);
+                    }
+                    throw sqe;
                 } finally {
                     close(ps);
                 }
@@ -215,10 +281,16 @@ public class RubyJdbcConnection extends RubyObject {
         return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
             public Object call(Connection c) throws SQLException {
                 Statement stmt = null;
+                String insert = rubyApi.convertToRubyString(sql).getUnicodeValue();
                 try {
                     stmt = c.createStatement();
-                    stmt.executeUpdate(rubyApi.convertToRubyString(sql).getUnicodeValue(), Statement.RETURN_GENERATED_KEYS);
+                    stmt.executeUpdate(insert, Statement.RETURN_GENERATED_KEYS);
                     return unmarshal_id_result(context.getRuntime(), stmt.getGeneratedKeys());
+                } catch (SQLException sqe) {
+                    if (context.getRuntime().isDebug()) {
+                        System.out.println("Error SQL: " + insert);
+                    }
+                    throw sqe;
                 } finally {
                     close(stmt);
                 }
@@ -252,6 +324,11 @@ public class RubyJdbcConnection extends RubyObject {
                     stmt = c.createStatement();
                     stmt.setMaxRows(maxRows);
                     return unmarshalResult(context, metadata, stmt.executeQuery(query), false);
+                } catch (SQLException sqe) {
+                    if (context.getRuntime().isDebug()) {
+                        System.out.println("Error SQL: " + query);
+                    }
+                    throw sqe;
                 } finally {
                     close(stmt);
                 }
@@ -265,9 +342,15 @@ public class RubyJdbcConnection extends RubyObject {
         return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
             public Object call(Connection c) throws SQLException {
                 Statement stmt = null;
+                String update = rubyApi.convertToRubyString(sql).getUnicodeValue();
                 try {
                     stmt = c.createStatement();
-                    return context.getRuntime().newFixnum((long)stmt.executeUpdate(rubyApi.convertToRubyString(sql).getUnicodeValue()));
+                    return context.getRuntime().newFixnum((long)stmt.executeUpdate(update));
+                } catch (SQLException sqe) {
+                    if (context.getRuntime().isDebug()) {
+                        System.out.println("Error SQL: " + update);
+                    }
+                    throw sqe;
                 } finally {
                     close(stmt);
                 }
@@ -583,10 +666,11 @@ public class RubyJdbcConnection extends RubyObject {
     public static String caseConvertIdentifierForJdbc(DatabaseMetaData metadata, String value)
             throws SQLException {
         if (value == null) return null;
+        boolean isPostgres = metadata.getDatabaseProductName().equals("PostgreSQL");
 
         if (metadata.storesUpperCaseIdentifiers()) {
             return value.toUpperCase();
-        } else if (metadata.storesLowerCaseIdentifiers()) {
+        } else if (metadata.storesLowerCaseIdentifiers() && ! isPostgres) {
             return value.toLowerCase();
         }
 
@@ -647,6 +731,14 @@ public class RubyJdbcConnection extends RubyObject {
         return conn;
     }
 
+    protected IRubyObject getAdapter(ThreadContext context) {
+        return callMethod(context, "adapter");
+    }
+
+    protected IRubyObject getJdbcColumnClass(ThreadContext context) {
+        return getAdapter(context).callMethod(context, "jdbc_column_class");
+    }
+
     protected JdbcConnectionFactory getConnectionFactory() throws RaiseException {
         IRubyObject connection_factory = getInstanceVariable("@connection_factory");
         JdbcConnectionFactory factory = null;
@@ -729,12 +821,18 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected IRubyObject integerToRuby(Ruby runtime, ResultSet resultSet, long longValue)
-            throws SQLException, IOException {
+            throws SQLException {
         if (longValue == 0 && resultSet.wasNull()) return runtime.getNil();
 
         return runtime.newFixnum(longValue);
     }
 
+    protected IRubyObject bigIntegerToRuby(Ruby runtime, ResultSet resultSet, String bigint) throws SQLException {
+        if (bigint == null && resultSet.wasNull()) return runtime.getNil();
+
+        return RubyBignum.bignorm(runtime, new BigInteger(bigint));
+    }
+
     protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
             throws SQLException {
         try {
@@ -749,10 +847,14 @@ public class RubyJdbcConnection extends RubyObject {
                 return readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column));
             case Types.TIMESTAMP:
                 return timestampToRuby(runtime, resultSet, resultSet.getTimestamp(column));
-            case Types.INTEGER: case Types.SMALLINT: case Types.TINYINT:
+            case Types.INTEGER:
+            case Types.SMALLINT:
+            case Types.TINYINT:
                 return integerToRuby(runtime, resultSet, resultSet.getLong(column));
             case Types.REAL:
                 return doubleToRuby(runtime, resultSet, resultSet.getDouble(column));
+            case Types.BIGINT:
+                return bigIntegerToRuby(runtime, resultSet, resultSet.getString(column));
             default:
                 return stringToRuby(runtime, resultSet, resultSet.getString(column));
             }
@@ -769,8 +871,9 @@ public class RubyJdbcConnection extends RubyObject {
             RubyHash row = RubyHash.newHash(runtime);
 
             for (int i = 0; i < columnCount; i++) {
-                row.op_aset(context, columns[i].name, jdbcToRuby(runtime, i + 1, columns[i].type, resultSet));
+                row.op_aset(context, columns[i].name, jdbcToRuby(runtime, columns[i].index, columns[i].type, resultSet));
             }
+
             results.add(row);
         }
     }
@@ -900,10 +1003,12 @@ public class RubyJdbcConnection extends RubyObject {
                     DatabaseMetaData metadata = c.getMetaData();
                     String clzName = metadata.getClass().getName().toLowerCase();
                     boolean isOracle = clzName.indexOf("oracle") != -1 || clzName.indexOf("oci") != -1;
+                    boolean isDerby = clzName.indexOf("derby") != 1;
 
                     String realschema = schemapat;
                     String realtablepat = tablepat;
 
+                    if (isDerby && realschema != null && realschema.equals("")) realschema = null;  // Derby doesn't like empty-string schema name
                     if (realtablepat != null) realtablepat = caseConvertIdentifierForJdbc(metadata, realtablepat);
                     if (realschema != null) realschema = caseConvertIdentifierForJdbc(metadata, realschema);
 
@@ -931,26 +1036,29 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected IRubyObject timestampToRuby(Ruby runtime, ResultSet resultSet, Timestamp time)
-            throws SQLException, IOException {
+            throws SQLException {
         if (time == null && resultSet.wasNull()) return runtime.getNil();
 
         String str = time.toString();
         if (str.endsWith(" 00:00:00.0")) {
             str = str.substring(0, str.length() - (" 00:00:00.0".length()));
         }
+        if (str.endsWith(".0")) {
+            str = str.substring(0, str.length() - (".0".length()));
+        }
 
         return RubyString.newUnicodeString(runtime, str);
     }
 
-    private static final int COLUMN_NAME = 4;
-    private static final int DATA_TYPE = 5;
-    private static final int TYPE_NAME = 6;
-    private static final int COLUMN_SIZE = 7;
-    private static final int DECIMAL_DIGITS = 9;
-    private static final int COLUMN_DEF = 13;
-    private static final int IS_NULLABLE = 18;
+    protected static final int COLUMN_NAME = 4;
+    protected static final int DATA_TYPE = 5;
+    protected static final int TYPE_NAME = 6;
+    protected static final int COLUMN_SIZE = 7;
+    protected static final int DECIMAL_DIGITS = 9;
+    protected static final int COLUMN_DEF = 13;
+    protected static final int IS_NULLABLE = 18;
 
-    private int intFromResultSet(ResultSet resultSet, int column) throws SQLException {
+    protected int intFromResultSet(ResultSet resultSet, int column) throws SQLException {
         int precision = resultSet.getInt(column);
 
         return precision == 0 && resultSet.wasNull() ? -1 : precision;
@@ -959,20 +1067,11 @@ public class RubyJdbcConnection extends RubyObject {
     /**
      * Create a string which represents a sql type usable by Rails from the resultSet column
      * metadata object.
-     *
-     * @param numberAsBoolean the database uses decimal as a boolean data type
-     * because it does not support optional SQL92 type or mandatory SQL99
-     * booleans.
      */
-    private String typeFromResultSet(ResultSet resultSet, boolean numberAsBoolean) throws SQLException {
+    protected String typeFromResultSet(ResultSet resultSet) throws SQLException {
         int precision = intFromResultSet(resultSet, COLUMN_SIZE);
         int scale = intFromResultSet(resultSet, DECIMAL_DIGITS);
 
-        // Assume db's which use decimal for boolean will not also specify a
-        // valid precision 1 decimal also.  Seems sketchy to me...
-        if (numberAsBoolean && precision != 1 &&
-            resultSet.getInt(DATA_TYPE) == java.sql.Types.DECIMAL) precision = -1;
-
         String type = resultSet.getString(TYPE_NAME);
         if (precision > 0) {
             type += "(" + precision;
@@ -991,34 +1090,35 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     private IRubyObject unmarshal_columns(ThreadContext context, DatabaseMetaData metadata,
-            ResultSet rs) throws SQLException {
+                                          ResultSet rs, ResultSet pkeys) throws SQLException {
         try {
             Ruby runtime = context.getRuntime();
             List columns = new ArrayList();
+            List pkeyNames = new ArrayList();
             String clzName = metadata.getClass().getName().toLowerCase();
-            boolean isOracle = clzName.indexOf("oracle") != -1 || clzName.indexOf("oci") != -1;
 
             RubyHash types = (RubyHash) native_database_types();
-            IRubyObject jdbcCol = getConnectionAdapters(runtime).getConstant("JdbcColumn");
+            IRubyObject jdbcCol = getJdbcColumnClass(context);
+
+            while (pkeys.next()) {
+                pkeyNames.add(pkeys.getString(COLUMN_NAME));
+            }
 
-            while(rs.next()) {
+            while (rs.next()) {
+                String colName = rs.getString(COLUMN_NAME);
                 IRubyObject column = jdbcCol.callMethod(context, "new",
                         new IRubyObject[] {
                             getInstanceVariable("@config"),
                             RubyString.newUnicodeString(runtime,
-                                    caseConvertIdentifierForRails(metadata, rs.getString(COLUMN_NAME))),
+                                    caseConvertIdentifierForRails(metadata, colName)),
                             defaultValueFromResultSet(runtime, rs),
-                            RubyString.newUnicodeString(runtime, typeFromResultSet(rs, isOracle)),
+                            RubyString.newUnicodeString(runtime, typeFromResultSet(rs)),
                             runtime.newBoolean(!rs.getString(IS_NULLABLE).trim().equals("NO"))
                         });
                 columns.add(column);
 
-                IRubyObject tp = (IRubyObject)types.fastARef(column.callMethod(context,"type"));
-                if(tp != null && !tp.isNil() && tp.callMethod(context, "[]", runtime.newSymbol("limit")).isNil()) {
-                    column.callMethod(context, "limit=", runtime.getNil());
-                    if(!column.callMethod(context, "type").equals(runtime.newSymbol("decimal"))) {
-                        column.callMethod(context, "precision=", runtime.getNil());
-                    }
+                if (pkeyNames.contains(colName)) {
+                    column.callMethod(context, "primary=", runtime.getTrue());
                 }
             }
             return runtime.newArray(columns);
@@ -1039,13 +1139,32 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
+    protected IRubyObject unmarshalResults(ThreadContext context, DatabaseMetaData metadata,
+                                           Statement stmt, boolean downCase) throws SQLException {
+        Ruby runtime = context.getRuntime();
+        List<IRubyObject> sets = new ArrayList<IRubyObject>();
+
+        while (true) {
+            sets.add(unmarshalResult(context, metadata, stmt.getResultSet(), downCase));
+            if (!stmt.getMoreResults()) {
+                break;
+            }
+        }
+
+        if (sets.size() > 1) {
+            return runtime.newArray(sets);
+        } else {
+            return sets.get(0);
+        }
+    }
+
     /**
      * Converts a jdbc resultset into an array (rows) of hashes (row) that AR expects.
      *
      * @param downCase should column names only be in lower case?
      */
     protected IRubyObject unmarshalResult(ThreadContext context, DatabaseMetaData metadata,
-            ResultSet resultSet, boolean downCase) throws SQLException {
+                                          ResultSet resultSet, boolean downCase) throws SQLException {
         Ruby runtime = context.getRuntime();
         List results = new ArrayList();
 
@@ -1075,6 +1194,11 @@ public class RubyJdbcConnection extends RubyObject {
                 while (toWrap.getCause() != null && toWrap.getCause() != toWrap) {
                     toWrap = toWrap.getCause();
                 }
+
+                if (context.getRuntime().isDebug()) {
+                    toWrap.printStackTrace(System.out);
+                }
+
                 i++;
                 if (autoCommit) {
                     if (i == 1) {
@@ -1094,15 +1218,32 @@ public class RubyJdbcConnection extends RubyObject {
         throw wrap(context, toWrap);
     }
 
-    private static RuntimeException wrap(ThreadContext context, Throwable exception) {
-        RubyClass err = context.getRuntime().getModule("ActiveRecord").getClass("ActiveRecordError");
-        return (RuntimeException) new RaiseException(context.getRuntime(), err, exception.getMessage(), false).initCause(exception);
+    protected RuntimeException wrap(ThreadContext context, Throwable exception) {
+        Ruby runtime = context.getRuntime();
+        RaiseException arError = new RaiseException(runtime, runtime.getModule("ActiveRecord").getClass("JDBCError"),
+                                                    exception.getMessage(), true);
+        arError.initCause(exception);
+        if (exception instanceof SQLException) {
+            RuntimeHelpers.invoke(context, arError.getException(),
+                                  "errno=", runtime.newFixnum(((SQLException) exception).getErrorCode()));
+            RuntimeHelpers.invoke(context, arError.getException(),
+                                  "sql_exception=", JavaEmbedUtils.javaToRuby(runtime, exception));
+        }
+        return (RuntimeException) arError;
     }
 
     private IRubyObject wrappedConnection(Connection c) {
         return Java.java_to_ruby(this, JavaObject.wrap(getRuntime(), c), Block.NULL_BLOCK);
     }
 
+    /**
+     * Some databases support schemas and others do not.
+     * For ones which do this method should return true, aiding in decisions regarding schema vs database determination.
+     */
+    protected boolean databaseSupportsSchemas() {
+        return false;
+    }
+
     private static int whitespace(int start, ByteList bl) {
         int end = bl.begin + bl.realSize;
 
@@ -1133,11 +1274,13 @@ public class RubyJdbcConnection extends RubyObject {
 
     public static class ColumnData {
         public IRubyObject name;
+        public int index;
         public int type;
 
-        public ColumnData(IRubyObject name, int type) {
+        public ColumnData(IRubyObject name, int type, int idx) {
             this.name = name;
             this.type = type;
+            this.index = idx;
         }
 
         public static ColumnData[] setup(Ruby runtime, DatabaseMetaData databaseMetadata,
@@ -1153,7 +1296,7 @@ public class RubyJdbcConnection extends RubyObject {
                     name = RubyJdbcConnection.caseConvertIdentifierForRails(databaseMetadata, metadata.getColumnLabel(i));
                 }
 
-                columns[i - 1] = new ColumnData(RubyString.newUnicodeString(runtime, name), metadata.getColumnType(i));
+                columns[i - 1] = new ColumnData(RubyString.newUnicodeString(runtime, name), metadata.getColumnType(i), i);
             }
 
             return columns;