activerecord-jdbc-adapter 50.2-java → 50.3-java

data/src/java/arjdbc/jdbc/DataSourceConnectionFactory.java

@@ -68,7 +68,6 @@ final class DataSourceConnectionFactory implements ConnectionFactory {
 
     @Override
     public Connection newConnection() throws SQLException {
-        DataSource dataSource = this.dataSource;
         // in case DS failed previously look it up again from JNDI :
         if (dataSource == null) {
             lookupDataSource();

data/src/java/arjdbc/jdbc/RubyConnectionFactory.java

@@ -0,0 +1,61 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2012-2014 Karol Bucek <self@kares.org>
+ * 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
+ * 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.jdbc;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+// @legacy ActiveRecord::ConnectionAdapters::JdbcDriver
+class RubyConnectionFactory implements ConnectionFactory {
+
+    private final IRubyObject driver;
+    final RubyString url;
+    final IRubyObject username, password; // null allowed
+
+    private final RubyObject contextProvider;
+
+    public RubyConnectionFactory(final IRubyObject driver, final RubyString url,
+                                 final IRubyObject username, final IRubyObject password) {
+        this.driver = driver; this.url = url;
+        this.username = username; this.password = password;
+        contextProvider = (RubyObject) driver;
+    }
+
+    @Override
+    public Connection newConnection() throws SQLException {
+        final ThreadContext context = contextProvider.getRuntime().getCurrentContext();
+        final IRubyObject connection = driver.callMethod(context, "connection", new IRubyObject[] { url, username, password });
+        return (Connection) connection.toJava(Connection.class);
+    }
+
+    IRubyObject getDriver() { return driver; } /* for tests */
+
+}

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -128,6 +128,7 @@ public class RubyJdbcConnection extends RubyObject {
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
     private boolean configureConnection = true; // final once initialized
+    private int fetchSize = 0; // 0 = JDBC default
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
@@ -571,6 +572,11 @@ public class RubyJdbcConnection extends RubyObject {
         else {
             this.configureConnection = value != context.runtime.getFalse();
         }
+
+        IRubyObject jdbcFetchSize = getConfigValue(context, "jdbc_fetch_size");
+        if (jdbcFetchSize != context.nil) {
+            this.fetchSize = RubyNumeric.fix2int(jdbcFetchSize);
+        }
     }
 
     @JRubyMethod(name = "adapter")
@@ -818,6 +824,7 @@ public class RubyJdbcConnection extends RubyObject {
                             // is called, so we have to process the result sets as we get them
                             // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
                             result = mapExecuteResult(context, connection, resultSet);
+                            resultSet.close();
                         } else {
                             result = context.runtime.newFixnum(updateCount);
                         }
@@ -851,6 +858,7 @@ public class RubyJdbcConnection extends RubyObject {
         else {
             statement.setEscapeProcessing(escapeProcessing.isTrue());
         }
+        if (fetchSize != 0) statement.setFetchSize(fetchSize);
         return statement;
     }
 
@@ -1045,6 +1053,7 @@ public class RubyJdbcConnection extends RubyObject {
                     else {
                         final PreparedStatement prepStatement;
                         statement = prepStatement = connection.prepareStatement(query);
+                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
                         statement.setMaxRows(maxRows); // zero means there is no limit
                         setStatementParameters(context, connection, prepStatement, binds);
                         hasResult = prepStatement.execute();
@@ -1112,6 +1121,24 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    /**
+     * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
+     * @param context which context this method is executing on.
+     * @param sql the query to prepare-
+     * @return a Ruby <code>PreparedStatement</code>
+     */
+    @JRubyMethod(required = 1)
+    public IRubyObject prepare_statement(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(Connection connection) throws SQLException {
+                final String query = sql.convertToString().getUnicodeValue();
+                PreparedStatement statement = connection.prepareStatement(query);
+                if (fetchSize != 0) statement.setFetchSize(fetchSize);
+                return JavaUtil.convertJavaToRuby(context.runtime, statement);
+            }
+        });
+    }
+
     // Called from exec_query in abstract/database_statements
     /**
      * Executes a query and returns the (AR) result.  There are three parameters:
@@ -1142,6 +1169,7 @@ public class RubyJdbcConnection extends RubyObject {
                         statement = (PreparedStatement) JavaEmbedUtils.rubyToJava(cachedStatement);
                     } else {
                         statement = connection.prepareStatement(query);
+                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
                     }
 
                     setStatementParameters(context, connection, statement, (RubyArray) binds);
@@ -1149,12 +1177,7 @@ public class RubyJdbcConnection extends RubyObject {
                     if (statement.execute()) {
                         ResultSet resultSet = statement.getResultSet();
                         IRubyObject results = mapQueryResult(context, connection, resultSet);
-
-                        if (cached) {
-                            // Make sure we free the result set if we are caching the statement
-                            // It gets closed automatically when the statement is closed if we aren't caching
-                            resultSet.close();
-                        }
+                        resultSet.close();
 
                         return results;
                     } else {
@@ -1807,7 +1830,7 @@ public class RubyJdbcConnection extends RubyObject {
         if ( url.isNil() || ( driver.isNil() && driver_instance.isNil() ) ) {
             final Ruby runtime = context.runtime;
             final RubyClass errorClass = getConnectionNotEstablished( runtime );
-            throw new RaiseException(runtime, errorClass, "adapter requires :driver class and jdbc :url", false);
+            throw runtime.newRaiseException(errorClass, "adapter requires :driver class and jdbc :url");
         }
 
         final String jdbcURL = buildURL(context, url);
@@ -1824,7 +1847,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return factory;
             }
             else {
-                setConnectionFactory(factory = new RubyConnectionFactoryImpl(
+                setConnectionFactory(factory = new RubyConnectionFactory(
                         driver_instance, context.runtime.newString(jdbcURL),
                         ( username.isNil() ? username : username.asString() ),
                         ( password.isNil() ? password : password.asString() )
@@ -2485,6 +2508,8 @@ public class RubyJdbcConnection extends RubyObject {
             while ( arrayResult.next() ) {
                 array.append( jdbcToRuby(context, runtime, 2, baseType, arrayResult) );
             }
+            arrayResult.close();
+
             return array;
         }
         finally { if ( value != null ) value.free(); }
@@ -2683,7 +2708,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final IRubyObject value) {
-        return timeInDefaultTimeZone(context, toTime(context, value));
+        return timeInDefaultTimeZone(context, DateTimeUtils.toTime(context, value));
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final RubyTime time) {
@@ -2695,11 +2720,14 @@ public class RubyJdbcConnection extends RubyObject {
         return timeInDefaultTZ;
     }
 
+    protected final DateTime dateTimeInDefaultTimeZone(final ThreadContext context, final DateTime dateTime) {
+        final DateTimeZone defaultZone = getDefaultTimeZone(context);
+        if (defaultZone == dateTime.getZone()) return dateTime;
+        return dateTime.withZone(defaultZone);
+    }
+
     public static RubyTime toTime(final ThreadContext context, final IRubyObject value) {
-        if ( ! ( value instanceof RubyTime ) ) { // unlikely
-            return (RubyTime) TypeConverter.convertToTypeWithCheck(value, context.runtime.getTime(), "to_time");
-        }
-        return (RubyTime) value;
+        return DateTimeUtils.toTime(context, value);
     }
 
     protected boolean isDefaultTimeZoneUTC(final ThreadContext context) {
@@ -2799,8 +2827,8 @@ public class RubyJdbcConnection extends RubyObject {
         final int index, IRubyObject value,
         final IRubyObject attribute, final int type) throws SQLException {
 
-        final RubyTime timeValue = timeInDefaultTimeZone(context, value);
-        final DateTime dateTime = timeValue.getDateTime();
+        final RubyTime timeValue = DateTimeUtils.toTime(context, value);
+        final DateTime dateTime = dateTimeInDefaultTimeZone(context, timeValue.getDateTime());
         final Timestamp timestamp = new Timestamp(dateTime.getMillis());
         // 1942-11-30T01:02:03.123_456
         if (timeValue.getNSec() > 0) timestamp.setNanos((int) (timestamp.getNanos() + timeValue.getNSec()));
@@ -2894,7 +2922,7 @@ public class RubyJdbcConnection extends RubyObject {
         final RubySymbol type = (RubySymbol) attributeSQLType(context, attribute);
 
         // For some reason the driver doesn't like "character varying" as a type
-        if ( type.eql(context.runtime.newSymbol("string")) ) return "text";
+        if ( type.eql(context.runtime.newSymbol("string")) ) return "varchar";
 
         final RubyHash nativeTypes = (RubyHash) getAdapter().callMethod(context, "native_database_types");
         // e.g. `integer: { name: 'integer' }`
@@ -3001,7 +3029,7 @@ public class RubyJdbcConnection extends RubyObject {
     private void handleNotConnected() {
         final Ruby runtime = getRuntime();
         final RubyClass errorClass = getConnectionNotEstablished( runtime );
-        throw new RaiseException(runtime, errorClass, "no connection available", false);
+        throw runtime.newRaiseException(errorClass, "no connection available");
     }
 
     /**
@@ -3538,7 +3566,7 @@ public class RubyJdbcConnection extends RubyObject {
             return (RaiseException) exception;
         }
         if ( exception instanceof RuntimeException ) {
-            return RaiseException.createNativeRaiseException(runtime, exception);
+            return wrapException(context, context.runtime.getRuntimeError(), exception);
         }
         // NOTE: compat - maybe makes sense or maybe not (e.g. IOException) :
         return wrapException(context, getJDBCError(runtime), exception);
@@ -3551,7 +3579,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     public static RaiseException wrapException(final ThreadContext context,
                                                final RubyClass errorClass, final Throwable exception, final String message) {
-        final RaiseException error = new RaiseException(context.runtime, errorClass, message, true);
+        final RaiseException error = context.runtime.newRaiseException(errorClass, message);
         error.initCause(exception);
         return error;
     }

data/src/java/arjdbc/mysql/MySQLRubyJdbcConnection.java

@@ -107,8 +107,8 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             final int minor = jdbcDriver.getMinorVersion();
             if ( major < 5 ) {
                 final RubyClass errorClass = getConnectionNotEstablished(context.runtime);
-                throw new RaiseException(context.runtime, errorClass,
-                    "MySQL adapter requires driver >= 5.0 got: " + major + "." + minor + "", false);
+                throw context.runtime.newRaiseException(errorClass,
+                    "MySQL adapter requires driver >= 5.0 got: " + major + "." + minor + "");
             }
             if ( major == 5 && minor < 1 ) { // need 5.1 for JDBC 4.0
                 // lightweight validation query: "/* ping */ SELECT 1"

data/src/java/arjdbc/postgresql/PgDateTimeUtils.java

@@ -0,0 +1,52 @@
+package arjdbc.postgresql;
+
+import arjdbc.util.DateTimeUtils;
+import org.joda.time.DateTimeZone;
+import org.jruby.RubyArray;
+import org.jruby.RubyFloat;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * PostgreSQL specific DateTime/Timestamp helpers
+ * @author dritz
+ */
+public abstract class PgDateTimeUtils extends DateTimeUtils {
+    /**
+     * Convert a ruby value to a PostgreSQL timestamp string
+     * @param context
+     * @param value Ruby value, typically a Time instance
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in string?
+     * @return A string fit for PostgreSQL
+     */
+    public static String timestampValueToString(final ThreadContext context, IRubyObject value, DateTimeZone zone,
+                                         boolean withZone) {
+        if (value instanceof RubyFloat) {
+            final double dv = ((RubyFloat) value).getValue();
+            if (dv == Double.POSITIVE_INFINITY) {
+                return "infinity";
+            } else if (dv == Double.NEGATIVE_INFINITY) {
+                return "-infinity";
+            }
+        }
+        return timestampTimeToString(context, value, zone, withZone);
+    }
+
+    /**
+     * Converts a RubyArray with timestamp values to a java array of PostgreSQL timestamp strings
+     * @param context
+     * @param rubyArray
+     * @return Array of timestamp strings
+     */
+    public static String[] timestampStringArray(final ThreadContext context, final RubyArray rubyArray) {
+        int size = rubyArray.size();
+        String[] values = new String[size];
+
+        for (int i = 0; i < size; i++) {
+            IRubyObject elem = rubyArray.eltInternal(i);
+            values[i] = timestampValueToString(context, elem, DateTimeZone.UTC, false);
+        }
+        return values;
+    }
+}

data/src/java/arjdbc/postgresql/PostgreSQLResult.java

@@ -4,6 +4,7 @@ import arjdbc.jdbc.JdbcResult;
 import arjdbc.jdbc.RubyJdbcConnection;
 
 import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Types;
 
@@ -11,7 +12,6 @@ import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyHash;
-import org.jruby.RubyMethod;
 import org.jruby.RubyModule;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
@@ -21,17 +21,13 @@ import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-import org.postgresql.core.Field;
-import org.postgresql.jdbc.PgResultSetMetaData;
-import org.postgresql.jdbc.PgResultSetMetaDataWrapper; // This is a hack unfortunately to get around method scoping
-
 /*
  * This class mimics the PG:Result class enough to get by
  */
 public class PostgreSQLResult extends JdbcResult {
 
     // These are needed when generating an AR::Result
-    private final PgResultSetMetaData resultSetMetaData;
+    private final ResultSetMetaData resultSetMetaData;
 
     /********* JRuby compat methods ***********/
 
@@ -61,7 +57,7 @@ public class PostgreSQLResult extends JdbcResult {
                              ResultSet resultSet) throws SQLException {
         super(context, clazz, connection, resultSet);
 
-        resultSetMetaData = (PgResultSetMetaData) resultSet.getMetaData();
+        resultSetMetaData = resultSet.getMetaData();
     }
 
     /**
@@ -74,16 +70,28 @@ public class PostgreSQLResult extends JdbcResult {
     protected IRubyObject columnTypeMap(final ThreadContext context) throws SQLException {
         Ruby runtime = context.runtime;
         RubyHash types = RubyHash.newHash(runtime);
-        PgResultSetMetaDataWrapper mdWrapper = new PgResultSetMetaDataWrapper(resultSetMetaData);
         int columnCount = columnNames.length;
 
         IRubyObject adapter = connection.adapter(context);
         for (int i = 0; i < columnCount; i++) {
-            final Field field = mdWrapper.getField(i + 1);
+            int col = i + 1;
+            String typeName = resultSetMetaData.getColumnTypeName(col);
+
+            int mod = 0;
+            if  ("numeric".equals(typeName)) {
+                // this field is only relevant for "numeric" type in AR
+                // AR checks (fmod - 4 & 0xffff).zero?
+                // pgjdbc:
+                //  - for typmod == -1, getScale() and getPrecision() return 0
+                //  - for typmod != -1, getScale() returns "(typmod - 4) & 0xFFFF;"
+                mod = resultSetMetaData.getScale(col);
+                mod = mod == 0 && resultSetMetaData.getPrecision(col) == 0 ? -1 : mod + 4;
+            }
+
             final RubyString name = columnNames[i];
             final IRubyObject type = Helpers.invoke(context, adapter, "get_oid_type",
-                    runtime.newFixnum(field.getOID()),
-                    runtime.newFixnum(field.getMod()),
+                    runtime.newString(typeName),
+                    runtime.newFixnum(mod),
                     name);
 
             if (!type.isNil()) types.fastASet(name, type);
@@ -144,7 +152,7 @@ public class PostgreSQLResult extends JdbcResult {
      * @return ActiveRecord::Result object with the data from this result set
      * @throws SQLException can be caused by postgres generating its type map
      */
-    @Override
+    @Override @SuppressWarnings("unchecked")
     public IRubyObject toARResult(final ThreadContext context) throws SQLException {
         RubyClass BinaryDataClass = null;
         int rowCount = 0;
@@ -163,7 +171,7 @@ public class PostgreSQLResult extends JdbcResult {
                     RubyArray row = (RubyArray) values.eltInternal(rowIndex);
                     IRubyObject value = row.eltInternal(columnIndex);
                     if (value != context.nil) {
-                        row.eltInternalSet(columnIndex, (IRubyObject) BinaryDataClass.newInstance(context, value, Block.NULL_BLOCK));
+                        row.eltInternalSet(columnIndex, BinaryDataClass.newInstance(context, value, Block.NULL_BLOCK));
                     }
                 }
             }

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

@@ -281,6 +281,30 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         return mapExecuteResult(context, connection, resultSet).toARResult(context);
     }
 
+    @Override
+    protected void setArrayParameter(final ThreadContext context,
+                                     final Connection connection, final PreparedStatement statement,
+                                     final int index, final IRubyObject value,
+                                     final IRubyObject attribute, final int type) throws SQLException {
+
+        final String typeName = resolveArrayBaseTypeName(context, attribute);
+        final RubyArray valueForDB = (RubyArray) value.callMethod(context, "values");
+
+        Object[] values;
+        switch (typeName) {
+        case "datetime":
+        case "timestamp": {
+            values = PgDateTimeUtils.timestampStringArray(context, valueForDB);
+            break;
+        }
+        default:
+            values = valueForDB.toArray();
+            break;
+        }
+
+        statement.setArray(index, connection.createArrayOf(typeName, values));
+    }
+
     @Override
     protected void setBlobParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
@@ -304,47 +328,9 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         final Connection connection, final PreparedStatement statement,
         final int index, IRubyObject value,
         final IRubyObject attribute, final int type) throws SQLException {
-
-        if ( value instanceof RubyFloat ) {
-            final double doubleValue = ( (RubyFloat) value ).getValue();
-            if ( Double.isInfinite(doubleValue) ) {
-                setTimestampInfinity(statement, index, doubleValue);
-                return;
-            }
-        }
-
-        RubyTime timeValue = toTime(context, value);
-
-        final Timestamp timestamp;
-
-        if (timeValue.getDateTime().getYear() > 0) {
-            timeValue = timeInDefaultTimeZone(context, timeValue);
-            DateTime dateTime = timeValue.getDateTime();
-            timestamp = new Timestamp(dateTime.getMillis());
-
-            if (timeValue.getNSec() > 0) timestamp.setNanos((int) (timestamp.getNanos() + timeValue.getNSec()));
-
-            statement.setTimestamp(index, timestamp, getCalendar(dateTime.getZone()));
-        }
-        else {
-            setTimestampBC(statement, index, timeValue);
-        }
-    }
-
-    private static void setTimestampBC(final PreparedStatement statement,
-                                       final int index, final RubyTime timeValue) throws SQLException {
-        DateTime dateTime = timeValue.getDateTime();
-        @SuppressWarnings("deprecated")
-        Timestamp timestamp = new Timestamp(dateTime.getYear() - 1900,
-                dateTime.getMonthOfYear() - 1,
-                dateTime.getDayOfMonth(),
-                dateTime.getHourOfDay(),
-                dateTime.getMinuteOfHour(),
-                dateTime.getSecondOfMinute(),
-                dateTime.getMillisOfSecond() * 1_000_000 + (int) timeValue.getNSec()
-        );
-
-        statement.setObject(index, timestamp);
+        // PGJDBC uses strings internally anyway, so using Timestamp doesn't do any good
+        String tsString = PgDateTimeUtils.timestampValueToString(context, value, null, true);
+        statement.setObject(index, tsString, Types.OTHER);
     }
 
     private static void setTimestampInfinity(final PreparedStatement statement,
@@ -366,7 +352,8 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         final int index, IRubyObject value,
         final IRubyObject attribute, final int type) throws SQLException {
         // to handle more fractional second precision than (default) 59.123 only
-        super.setTimestampParameter(context, connection, statement, index, value, attribute, type);
+        String timeStr = DateTimeUtils.timeString(context, value, getDefaultTimeZone(context), true);
+        statement.setObject(index, timeStr, Types.OTHER);
     }
 
     @Override
@@ -420,8 +407,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
                 break;
 
             case "enum":
-                // FIXME: This doesn't work but it gives a better error message than letting it be treated as a PGobject
-                statement.setObject(index, value.toString());
+                statement.setObject(index, value.toString(), Types.OTHER);
                 break;
 
             case "interval":