activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/src/java/arjdbc/oracle/OracleRubyJdbcConnection.java

@@ -25,13 +25,18 @@
  ***** END LICENSE BLOCK *****/
 package arjdbc.oracle;
 
+import arjdbc.jdbc.RubyJdbcConnection;
+
 import java.sql.ResultSet;
 import java.sql.SQLException;
-
-import arjdbc.jdbc.RubyJdbcConnection;
+import java.sql.DatabaseMetaData;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.jruby.Ruby;
+import org.jruby.RubyArray;
 import org.jruby.RubyClass;
+import org.jruby.RubyString;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.builtin.IRubyObject;
 
@@ -40,15 +45,15 @@ import org.jruby.runtime.builtin.IRubyObject;
  * @author nicksieger
  */
 public class OracleRubyJdbcConnection extends RubyJdbcConnection {
+    
     protected OracleRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
-
+    
     public static RubyClass createOracleJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
-        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("OracleJdbcConnection",
-                jdbcConnection, ORACLE_JDBCCONNECTION_ALLOCATOR);
+        final RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).
+            defineClassUnder("OracleJdbcConnection", jdbcConnection, ORACLE_JDBCCONNECTION_ALLOCATOR);
         clazz.defineAnnotatedMethods(OracleRubyJdbcConnection.class);
-
         return clazz;
     }
 
@@ -76,5 +81,20 @@ public class OracleRubyJdbcConnection extends RubyJdbcConnection {
         final String type = resultSet.getString(TYPE_NAME);
         return formatTypeWithPrecisionAndScale(type, precision, scale);
     }
-
+    
+    @Override
+    protected RubyArray mapTables(final Ruby runtime, final DatabaseMetaData metaData, 
+            final String catalog, final String schemaPattern, final String tablePattern, 
+            final ResultSet tablesSet) throws SQLException {
+        final List<IRubyObject> tables = new ArrayList<IRubyObject>(32);
+        while ( tablesSet.next() ) {
+            String name = tablesSet.getString(TABLES_TABLE_NAME);
+            name = caseConvertIdentifierForRails(metaData, name);
+            // Handle stupid Oracle 10g RecycleBin feature
+            if ( name.startsWith("bin$") ) continue;
+            tables.add(RubyString.newUnicodeString(runtime, name));
+        }
+        return runtime.newArray(tables);
+    }
+    
 }

data/src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -0,0 +1,214 @@
+/*
+ **** 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.postgresql;
+
+import java.sql.Array;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.UUID;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.postgresql.util.PGInterval;
+import org.postgresql.util.PGobject;
+
+/**
+ *
+ * @author enebo
+ */
+public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection {
+    
+    protected PostgreSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createPostgreSQLJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        final RubyClass clazz = getConnectionAdapters(runtime).
+            defineClassUnder("PostgreSQLJdbcConnection", jdbcConnection, POSTGRESQL_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(PostgreSQLRubyJdbcConnection.class);
+        getConnectionAdapters(runtime).setConstant("PostgresJdbcConnection", clazz); // backwards-compat
+        return clazz;
+    }
+    
+    private static ObjectAllocator POSTGRESQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new PostgreSQLRubyJdbcConnection(runtime, klass);
+        }
+    };
+    
+    @Override
+    protected String caseConvertIdentifierForJdbc(final DatabaseMetaData metaData, final String value)
+        throws SQLException {
+        if ( value != null ) {
+            if ( metaData.storesUpperCaseIdentifiers() ) {
+                return value.toUpperCase();
+            }
+            // for PostgreSQL we do not care about storesLowerCaseIdentifiers()
+        }
+        return value;
+    }
+    
+    /**
+     * Override jdbcToRuby type conversions to handle infinite timestamps.
+     * Handing timestamp off to ruby as string so adapter can perform type
+     * conversion to timestamp
+     */
+    @Override
+    protected IRubyObject jdbcToRuby(final Ruby runtime, 
+        final int column, final int type, final ResultSet resultSet)
+        throws SQLException {
+        switch ( type ) {
+            case Types.TIMESTAMP:
+                return stringToRuby(runtime, resultSet, column);
+            case Types.BIT:
+                // we do get BIT for 't' 'f' as well as BIT strings e.g. "0110" :
+                final String bits = resultSet.getString(column);
+                if ( bits == null ) return runtime.getNil();
+                if ( bits.length() > 1 ) {
+                    return RubyString.newUnicodeString(runtime, bits);
+                }
+                return booleanToRuby(runtime, resultSet, column);
+            //case Types.JAVA_OBJECT: case Types.OTHER:
+                //return objectToRuby(runtime, resultSet, resultSet.getObject(column));
+        }
+        return super.jdbcToRuby(runtime, column, type, resultSet);
+    }
+    
+    @Override
+    protected IRubyObject arrayToRuby(
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException {
+        // NOTE: avoid `finally { array.free(); }` on PostgreSQL due :
+        // java.sql.SQLFeatureNotSupportedException: 
+        // Method org.postgresql.jdbc4.Jdbc4Array.free() is not yet implemented.
+        final Array value = resultSet.getArray(column);
+        
+        if ( value == null && resultSet.wasNull() ) return runtime.getNil();
+
+        final RubyArray array = runtime.newArray();
+
+        final ResultSet arrayResult = value.getResultSet(); // 1: index, 2: value
+        final int baseType = value.getBaseType();
+        while ( arrayResult.next() ) {
+            IRubyObject element = jdbcToRuby(runtime, 2, baseType, arrayResult);
+            array.append(element);
+        }
+        return array;
+    }
+    
+    @Override
+    protected IRubyObject objectToRuby(
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException {
+        final Object object = resultSet.getObject(column);
+        
+        if ( object == null && resultSet.wasNull() ) return runtime.getNil();
+        
+        final Class<?> objectClass = object.getClass();
+        if ( objectClass == UUID.class ) {
+            return runtime.newString( object.toString() );
+        }
+        
+        if ( objectClass == PGInterval.class ) {
+            return runtime.newString( formatInterval(object) );
+        }
+        
+        if ( object instanceof PGobject ) {
+            // PG 9.2 JSON type will be returned here as well
+            return runtime.newString( object.toString() );
+        }
+        
+        return JavaUtil.convertJavaToRuby(runtime, object);
+    }
+    
+    @Override
+    protected TableName extractTableName(
+        final Connection connection, String catalog, String schema, 
+        final String tableName) throws IllegalArgumentException, SQLException {
+        // The postgres JDBC driver will default to searching every schema if no
+        // schema search path is given.  Default to the 'public' schema instead:
+        if ( schema == null ) schema = "public";
+        return super.extractTableName(connection, catalog, schema, tableName);
+    }
+    
+    // NOTE: do not use PG classes in the API so that loading is delayed !
+    private String formatInterval(final Object object) {
+        final PGInterval interval = (PGInterval) object;
+        if ( useRawIntervalType() ) return interval.getValue();
+        
+        final StringBuilder str = new StringBuilder(32);
+        
+        final int years = interval.getYears();
+        if ( years != 0 ) str.append(years).append(" years ");
+        final int months = interval.getMonths();
+        if ( months != 0 ) str.append(months).append(" months ");
+        final int days = interval.getDays();
+        if ( days != 0 ) str.append(days).append(" days ");
+        final int hours = interval.getHours();
+        final int mins = interval.getMinutes();
+        final int secs = (int) interval.getSeconds();
+        if ( hours != 0 || mins != 0 || secs != 0 ) { // xx:yy:zz if not all 00
+            if ( hours < 10 ) str.append('0');
+            str.append(hours).append(':');
+            if ( mins < 10 ) str.append('0');
+            str.append(mins).append(':');
+            if ( secs < 10 ) str.append('0');
+            str.append(secs);
+        }
+        else {
+            if ( str.length() > 1 ) str.deleteCharAt( str.length() - 1 ); // " " at the end
+        }
+        
+        return str.toString();
+    }
+    
+    // whether to use "raw" interval values off by default - due native adapter compatibilty :
+    // RAW values :
+    // - 2 years 0 mons 0 days 0 hours 3 mins 0.00 secs
+    // - -1 years 0 mons -2 days 0 hours 0 mins 0.00 secs
+    // Rails style :
+    // - 2 years 00:03:00
+    // - -1 years -2 days
+    private static boolean rawIntervalType = Boolean.getBoolean("arjdbc.postgresql.iterval.raw");
+
+    public static boolean useRawIntervalType() {
+        return rawIntervalType;
+    }
+
+    public static void setRawIntervalType(boolean rawInterval) {
+        PostgreSQLRubyJdbcConnection.rawIntervalType = rawInterval;
+    }
+    
+}

data/src/java/arjdbc/postgresql/PostgresqlRubyJdbcConnection.java

@@ -1,82 +1,40 @@
 /*
- **** 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>
+ * The MIT License
  *
- * 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:
+ * Copyright 2013 Karol Bucek.
  *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
+ * 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 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 *****/
+ * 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.
+ */
 package arjdbc.postgresql;
 
-import arjdbc.jdbc.RubyJdbcConnection;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Types;
-
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.builtin.IRubyObject;
 
 /**
- *
- * @author enebo
+ * @see PostgreSQLRubyJdbcConnection
+ * @deprecated only for Java API backwards-compatibility
  */
-public class PostgresqlRubyJdbcConnection extends RubyJdbcConnection {
+@Deprecated
+public class PostgresqlRubyJdbcConnection extends PostgreSQLRubyJdbcConnection {
+    
     protected PostgresqlRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
-
-    public static RubyClass createPostgresqlJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
-        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("PostgresJdbcConnection",
-                jdbcConnection, POSTGRESQL_JDBCCONNECTION_ALLOCATOR);
-        clazz.defineAnnotatedMethods(PostgresqlRubyJdbcConnection.class);
-
-        return clazz;
-    }
-
-    /**
-     * Override jdbcToRuby type conversions to handle infinite timestamps.
-     * Handing timestamp off to ruby as string so adapter can perform type
-     * conversion to timestamp
-     */
-    @Override
-    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, 
-                                     ResultSet resultSet)
-        throws SQLException {
-        if(type == Types.TIMESTAMP) {
-            try {
-                return stringToRuby(runtime, resultSet, 
-                                    resultSet.getString(column));
-            } catch(java.io.IOException ioe) {
-                SQLException ex = new SQLException(ioe.getMessage());
-                throw (SQLException) ex.initCause(ioe);
-            }
-        }
-        return super.jdbcToRuby(runtime, column, type, resultSet);
-    }
-
-    private static ObjectAllocator POSTGRESQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
-            return new PostgresqlRubyJdbcConnection(runtime, klass);
-        }
-    };
+    
 }

data/src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -26,24 +26,28 @@
 
 package arjdbc.sqlite3;
 
-import java.io.ByteArrayInputStream;
+import arjdbc.jdbc.Callable;
+import arjdbc.jdbc.RubyJdbcConnection;
+
 import java.io.IOException;
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.sql.Types;
-
-import arjdbc.jdbc.RubyJdbcConnection;
-import arjdbc.jdbc.SQLBlock;
+import java.sql.DatabaseMetaData;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.jruby.Ruby;
+import org.jruby.RubyArray;
 import org.jruby.RubyClass;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 
 /**
  *
@@ -72,56 +76,55 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
     @JRubyMethod(name = "last_insert_row_id")
     public IRubyObject getLastInsertRowId(final ThreadContext context) 
         throws SQLException {
-        return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
-                public Object call(Connection c) throws SQLException {
-                    Statement stmt = null;
-                    try {
-                        stmt = c.createStatement();
-                        return unmarshal_id_result(context.getRuntime(),
-                                                   stmt.getGeneratedKeys());
-                    } catch (SQLException sqe) {
-                        if (context.getRuntime().isDebug()) {
-                            System.out.println("Error SQL:" + sqe.getMessage());
-                        }
-                        throw sqe;
-                    } finally {
-                        close(stmt);
-                    }
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                Statement statement = null;
+                try {
+                    statement = connection.createStatement();
+                    return unmarshalIdResult(context.getRuntime(), statement);
                 }
-            });
+                catch (final SQLException e) {
+                    debugMessage(context, "Failed to get generated keys: " + e.getMessage());
+                    throw e;
+                }
+                finally { close(statement); }
+            }
+        });
     }
 
     @Override
-    protected IRubyObject tables(ThreadContext context, String catalog, String schemaPattern, String tablePattern, String[] types) {
-        return (IRubyObject) withConnectionAndRetry(context, tableLookupBlock(context.getRuntime(), catalog, schemaPattern, tablePattern, types, true));
+    protected IRubyObject jdbcToRuby(final Ruby runtime, final int column, int type, final ResultSet resultSet)
+        throws SQLException {
+        // This is rather gross, and only needed because the resultset metadata for SQLite tries to be overly
+        // clever, and returns a type for the column of the "current" row, so an integer value stored in a 
+        // decimal column is returned as Types.INTEGER.  Therefore, if the first row of a resultset was an
+        // integer value, all rows of that result set would get truncated.
+        if ( resultSet instanceof ResultSetMetaData ) {
+            type = ((ResultSetMetaData) resultSet).getColumnType(column);
+        }
+        return super.jdbcToRuby(runtime, column, type, resultSet);
+    }
+    
+    @Override
+    protected IRubyObject streamToRuby(
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException, IOException {
+        final byte[] bytes = resultSet.getBytes(column);
+        if ( resultSet.wasNull() ) return runtime.getNil();
+        return runtime.newString( new ByteList(bytes, false) );
     }
-
+    
     @Override
-    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
-            throws SQLException {
-        try {
-            // This is rather gross, and only needed because the resultset metadata for SQLite tries to be overly
-            // clever, and returns a type for the column of the "current" row, so an integer value stored in a 
-            // decimal column is returned as Types.INTEGER.  Therefore, if the first row of a resultset was an
-            // integer value, all rows of that result set would get truncated.
-            if( resultSet instanceof ResultSetMetaData ) {
-                type = ((ResultSetMetaData)resultSet).getColumnType(column);
-            }
-            switch (type) {
-            case Types.BINARY:
-            case Types.BLOB:
-            case Types.LONGVARBINARY:
-            case Types.VARBINARY:
-                return streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
-            case Types.LONGVARCHAR:
-                return runtime.is1_9() ?
-                    readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column)) :
-                    streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
-            default:
-                return super.jdbcToRuby(runtime, column, type, resultSet);
-            }
-        } catch (IOException ioe) {
-            throw (SQLException) new SQLException(ioe.getMessage()).initCause(ioe);
+    protected RubyArray mapTables(final Ruby runtime, final DatabaseMetaData metaData, 
+            final String catalog, final String schemaPattern, final String tablePattern, 
+            final ResultSet tablesSet) throws SQLException {
+        final List<IRubyObject> tables = new ArrayList<IRubyObject>(32);
+        while ( tablesSet.next() ) {
+            String name = tablesSet.getString(TABLES_TABLE_NAME);
+            name = name.toLowerCase(); // simply lower-case for SQLite3
+            tables.add(RubyString.newUnicodeString(runtime, name));
         }
+        return runtime.newArray(tables);
     }
+    
 }