activerecord-jdbc-adapter 60.0-java → 61.0-java

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '60.0'
+  VERSION = '61.0'
 end

data/rakelib/01-tomcat.rake

@@ -1,6 +1,6 @@
 namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
 
-  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_MAVEN_REPO = 'https://repo1.maven.org/maven2/org/apache/tomcat'
   TOMCAT_VERSION = '7.0.54'
 
   DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
@@ -48,4 +48,4 @@ namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
     rm jar_path if File.exist?(jar_path)
   end
 
-end
+end

data/rakelib/rails.rake

@@ -51,7 +51,7 @@ namespace :rails do
       ruby_opts_string += " -C \"#{ar_path}\""
       ruby_opts_string += " -rbundler/setup"
       ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
-      file_list = ENV["TEST"] ? FileList[ ENV["TEST"] ] : test_files_finder.call
+      file_list = ENV["TEST"] ? FileList[ ENV["TEST"].split(',') ] : test_files_finder.call
       file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
       # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct
       option_list = ( ENV["TESTOPTS"] || ENV["TESTOPT"] || ENV["TEST_OPTS"] || '' )

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

@@ -86,6 +86,7 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.ext.date.RubyDate;
+import org.jruby.ext.date.RubyDateTime;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.Block;
@@ -124,6 +125,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject config;
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
+    private RubyClass attributeClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -132,6 +134,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
+        attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -359,7 +362,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.commit();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.runtime.newBoolean(true);
                 }
                 finally {
@@ -380,7 +383,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.tru;
                 } finally {
                     connection.setAutoCommit(true);
@@ -516,7 +519,7 @@ public class RubyJdbcConnection extends RubyObject {
         return null;
     }
 
-    protected boolean resetSavepoints(final ThreadContext context) {
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
         if ( hasInternalVariable("savepoints") ) {
             removeInternalVariable("savepoints");
             return true;
@@ -610,11 +613,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return convertJavaToRuby( connection.unwrap(Connection.class) );
             }
         }
-        catch (AbstractMethodError e) {
-            debugStackTrace(context, e);
-            warn(context, "driver/pool connection does not support unwrapping: " + e);
-        }
-        catch (SQLException e) {
+        catch (AbstractMethodError | SQLException e) {
             debugStackTrace(context, e);
             warn(context, "driver/pool connection does not support unwrapping: " + e);
         }
@@ -676,7 +675,10 @@ public class RubyJdbcConnection extends RubyObject {
 
     private void connectImpl(final boolean forceConnection) throws SQLException {
         setConnection( forceConnection ? newConnection() : null );
-        if ( forceConnection ) configureConnection();
+        if (forceConnection) {
+            if (getConnectionImpl() == null) throw new SQLException("Didn't get a connection. Wrong URL?");
+            configureConnection();
+        }
     }
 
     @JRubyMethod(name = "read_only?")
@@ -832,24 +834,45 @@ public class RubyJdbcConnection extends RubyObject {
         return mapQueryResult(context, connection, resultSet);
     }
 
+    private static String[] createStatementPk(IRubyObject pk) {
+        String[] statementPk;
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            int size = ary.size();
+            statementPk = new String[size];
+            for (int i = 0; i < size; i++) {
+                statementPk[i] = sqlString(ary.eltInternal(i));
+            }
+        } else {
+            statementPk = new String[] { sqlString(pk) };
+        }
+        return statementPk;
+    }
+
     /**
      * Executes an INSERT SQL statement
      * @param context
      * @param sql
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 1)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
+    @JRubyMethod(name = "execute_insert_pk", required = 2)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
         return withConnection(context, connection -> {
             Statement statement = null;
             final String query = sqlString(sql);
             try {
 
                 statement = createStatement(context, connection);
-                statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                return mapGeneratedKeys(context, connection, statement);
 
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement.executeUpdate(query, createStatementPk(pk));
+                }
+
+                return mapGeneratedKeys(context, connection, statement);
             } catch (final SQLException e) {
                 debugErrorSQL(context, query);
                 throw e;
@@ -859,26 +882,37 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 1)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, context.nil);
+    }
+
     /**
      * Executes an INSERT SQL statement using a prepared statement
      * @param context
      * @param sql
      * @param binds RubyArray of values to be bound to the query
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 2)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
+    @JRubyMethod(name = "execute_insert_pk", required = 3)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
+                                         final IRubyObject pk) {
         return withConnection(context, connection -> {
             PreparedStatement statement = null;
             final String query = sqlString(sql);
             try {
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement = connection.prepareStatement(query, createStatementPk(pk));
+                }
 
-                statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
                 setStatementParameters(context, connection, statement, (RubyArray) binds);
                 statement.executeUpdate();
                 return mapGeneratedKeys(context, connection, statement);
-
             } catch (final SQLException e) {
                 debugErrorSQL(context, query);
                 throw e;
@@ -888,6 +922,12 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 2)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject binds, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, binds, context.nil);
+    }
+
     /**
      * Executes an UPDATE (DELETE) SQL statement
      * @param context
@@ -967,12 +1007,12 @@ public class RubyJdbcConnection extends RubyObject {
                     binds = null;
                 } else {                              // (sql, binds)
                     maxRows = 0;
-                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
+                    binds = (RubyArray) TypeConverter.checkArrayType(context, args[1]);
                 }
                 break;
             case 3:                                   // (sql, max_rows, binds)
                 maxRows = RubyNumeric.fix2int(args[1]);
-                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                binds = (RubyArray) TypeConverter.checkArrayType(context, args[2]);
                 break;
             default:                                  // (sql) 1-arg
                 maxRows = 0;
@@ -1061,6 +1101,28 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @JRubyMethod(required = 1)
+    public IRubyObject get_first_value(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
+                statement.execute(query);
+                ResultSet rs = statement.getResultSet();
+                if (rs == null || !rs.next()) return context.nil;
+
+                return jdbcToRuby(context, context.getRuntime(), 1, rs.getMetaData().getColumnType(1), rs);
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
+            }
+        });
+    }
+
     /**
      * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
      * @param context which context this method is executing on.
@@ -2120,7 +2182,7 @@ public class RubyJdbcConnection extends RubyObject {
             return RubyString.newString(runtime, DateTimeUtils.dateToString(value));
         }
 
-        return DateTimeUtils.newDateAsTime(context, value, null).callMethod(context, "to_date");
+        return DateTimeUtils.newDateAsTime(context, value, DateTimeZone.UTC).callMethod(context, "to_date");
     }
 
     protected IRubyObject timeToRuby(final ThreadContext context,
@@ -2357,9 +2419,16 @@ public class RubyJdbcConnection extends RubyObject {
             final Connection connection, final PreparedStatement statement,
             final int index, IRubyObject attribute) throws SQLException {
 
-        //debugMessage(context, attribute);
-        final int type = jdbcTypeForAttribute(context, attribute);
-        IRubyObject value = valueForDatabase(context, attribute);
+        final IRubyObject value;
+        final int type;
+
+        if (attributeClass.isInstance(attribute)) {
+            type = jdbcTypeForAttribute(context, attribute);
+            value = valueForDatabase(context, attribute);
+        } else {
+            type = jdbcTypeForPrimitiveAttribute(context, attribute);
+            value = attribute;
+        }
 
         // All the set methods were calling this first so save a method call in the nil case
         if ( value == context.nil ) {
@@ -2475,6 +2544,34 @@ public class RubyJdbcConnection extends RubyObject {
         return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
+    protected String internedTypeForPrimitive(final ThreadContext context, final IRubyObject value) throws SQLException {
+        if (value instanceof RubyString) {
+            return "string";
+        }
+        if (value instanceof RubyInteger) {
+            return "integer";
+        }
+        if (value instanceof RubyNumeric) {
+            return "float";
+        }
+        if (value instanceof RubyTime || value instanceof RubyDateTime) {
+            return "timestamp";
+        }
+        if (value instanceof RubyDate) {
+            return "date";
+        }
+        if (value instanceof RubyBoolean) {
+            return "boolean";
+        }
+        return "string";
+    }
+
+    protected Integer jdbcTypeForPrimitiveAttribute(final ThreadContext context,
+                                                    final IRubyObject attribute) throws SQLException {
+        final String internedType = internedTypeForPrimitive(context, attribute);
+        return jdbcTypeFor(internedType);
+    }
+
     protected Integer jdbcTypeFor(final String type) {
         return JDBC_TYPE_FOR.get(type);
     }
@@ -2486,7 +2583,9 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected static IRubyObject attributeSQLType(final ThreadContext context, final IRubyObject attribute) {
-        return attributeType(context, attribute).callMethod(context, "type");
+        final IRubyObject type = attributeType(context, attribute);
+        if (type != null) return type.callMethod(context, "type");
+        return context.nil;
     }
 
     private final CachingCallSite value_site = new FunctionalCachingCallSite("value"); // AR::Attribute#value
@@ -2499,23 +2598,7 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject value = value_site.call(context, attribute, attribute);
 
-        if (value instanceof RubyInteger) {
-            return "integer";
-        }
-
-        if (value instanceof RubyNumeric) {
-            return "float";
-        }
-
-        if (value instanceof RubyTime) {
-            return "timestamp";
-        }
-
-        if (value instanceof RubyBoolean) {
-            return "boolean";
-        }
-
-        return "string";
+        return internedTypeForPrimitive(context, value);
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final IRubyObject value) {

data/src/java/arjdbc/mssql/MSSQLRubyJdbcConnection.java

@@ -200,6 +200,57 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         });
     }
 
+    /**
+     * Executes an INSERT SQL statement
+     * @param context
+     * @param sql
+     * @param pk Rails PK
+     * @return ActiveRecord::Result
+     * @throws SQLException
+     */
+    @Override
+    @JRubyMethod(name = "execute_insert_pk", required = 2)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
+
+        // MSSQL does not like composite primary keys here so chop it if there is more than one column
+        IRubyObject modifiedPk = pk;
+
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            if (ary.size() > 0) {
+                modifiedPk = ary.eltInternal(0);
+            }
+        }
+
+        return super.execute_insert_pk(context, sql, modifiedPk);
+    }
+
+    /**
+     * Executes an INSERT SQL statement using a prepared statement
+     * @param context
+     * @param sql
+     * @param binds RubyArray of values to be bound to the query
+     * @param pk Rails PK
+     * @return ActiveRecord::Result
+     * @throws SQLException
+     */
+    @Override
+    @JRubyMethod(name = "execute_insert_pk", required = 3)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
+                                         final IRubyObject pk) {
+        // MSSQL does not like composite primary keys here so chop it if there is more than one column
+        IRubyObject modifiedPk = pk;
+
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            if (ary.size() > 0) {
+                modifiedPk = ary.eltInternal(0);
+            }
+        }
+
+        return super.execute_insert_pk(context, sql, binds, modifiedPk);
+    }
+
     @Override
     protected Integer jdbcTypeFor(final String type) {
 

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

@@ -36,26 +36,18 @@ import java.io.ByteArrayInputStream;
 import java.lang.StringBuilder;
 import java.lang.reflect.InvocationTargetException;
 import java.math.BigDecimal;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.sql.Types;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
+import java.sql.*;
+import java.sql.Date;
+import java.util.*;
 import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 
+import org.joda.time.DateTime;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
+import org.jruby.ext.date.RubyDate;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -115,6 +107,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
 
     // Used to wipe trailing 0's from points (3.0, 5.6) -> (3, 5.6)
     private static final Pattern pointCleanerPattern = Pattern.compile("\\.0\\b");
+    private static final TimeZone TZ_DEFAULT = TimeZone.getDefault();
 
     private RubyClass resultClass;
     private RubyHash typeMap = null;
@@ -204,9 +197,9 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         RubyClass arrayClass = oidArray(context);
         RubyBasicObject attributeType = (RubyBasicObject) attributeType(context, attribute);
         // The type or its delegate is an OID::Array
-        if (arrayClass.isInstance(attributeType) ||
+        if (attributeType != null && (arrayClass.isInstance(attributeType) ||
                 (attributeType.hasInstanceVariable("@delegate_dc_obj") &&
-                        arrayClass.isInstance(attributeType.getInstanceVariable("@delegate_dc_obj")))) {
+                        arrayClass.isInstance(attributeType.getInstanceVariable("@delegate_dc_obj"))))) {
             return "array";
         }
 
@@ -386,7 +379,20 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
             }
         }
 
-        super.setDateParameter(context, connection, statement, index, value, attribute, type);
+        if ( ! "Date".equals(value.getMetaClass().getName()) && value.respondsTo("to_date") ) {
+            value = value.callMethod(context, "to_date");
+        }
+
+        if (value instanceof RubyDate) {
+            RubyDate rubyDate = (RubyDate) value;
+            DateTime dt = rubyDate.getDateTime();
+            // pgjdbc needs adjustment for default JVM timezone
+            statement.setDate(index, new Date(dt.getMillis() - TZ_DEFAULT.getOffset(dt.getMillis())));
+            return;
+        }
+
+        // NOTE: assuming Date#to_s does right ...
+        statement.setDate(index, Date.valueOf(value.toString()));
     }
 
     @Override
@@ -430,7 +436,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
                 break;
 
             case "interval":
-                statement.setObject(index, new PGInterval(value.toString()));
+                statement.setObject(index, stringToPGInterval(value.toString()));
                 break;
 
             case "json":
@@ -487,6 +493,74 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         }
     }
 
+    private int lookAhead(String value, int position, String find) {
+        char [] tokens = find.toCharArray();
+        int found = -1;
+
+        for ( int i = 0; i < tokens.length; i++ ) {
+            found = value.indexOf(tokens[i], position);
+            if ( found > 0 ) {
+                return found;
+            }
+        }
+        return found;
+    }
+
+    private Object stringToPGInterval(String value) throws SQLException {
+        if (!value.startsWith("P")) return new PGInterval(value);
+
+        PGInterval interval = new PGInterval();
+
+        /* this is copied from pgjdbc with fixes for Rails */
+        int number = 0;
+        String dateValue;
+        String timeValue = null;
+
+        int hasTime = value.indexOf('T');
+        if ( hasTime > 0 ) {
+          /* skip over the P */
+          dateValue = value.substring(1,hasTime);
+          timeValue = value.substring(hasTime + 1);
+        } else {
+          /* skip over the P */
+          dateValue = value.substring(1);
+        }
+
+        for ( int i = 0; i < dateValue.length(); i++ ) {
+          int lookAhead = lookAhead(dateValue, i, "YMD");
+          if (lookAhead > 0) {
+            char type = dateValue.charAt(lookAhead);
+            number = Integer.parseInt(dateValue.substring(i, lookAhead));
+            if (type == 'Y') {
+              interval.setYears(number);
+            } else if (type == 'M') {
+              interval.setMonths(number);
+            } else if (type == 'D') {
+              interval.setDays(number);
+            }
+            i = lookAhead;
+          }
+        }
+        if ( timeValue != null ) {
+          for (int i = 0; i < timeValue.length(); i++) {
+            int lookAhead = lookAhead(timeValue, i, "HMS");
+            if (lookAhead > 0) {
+              char type = timeValue.charAt(lookAhead);
+              String part = timeValue.substring(i, lookAhead);
+              if (timeValue.charAt(lookAhead) == 'H') {
+                interval.setHours(Integer.parseInt(part));
+              } else if (timeValue.charAt(lookAhead) == 'M') {
+                interval.setMinutes(Integer.parseInt(part));
+              } else if (timeValue.charAt(lookAhead) == 'S') {
+                interval.setSeconds(Double.parseDouble(part));
+              }
+              i = lookAhead;
+            }
+          }
+        }
+        return interval;
+    }
+
     protected IRubyObject jdbcToRuby(ThreadContext context, Ruby runtime, int column, int type, ResultSet resultSet) throws SQLException {
         return typeMap != null ?
                 convertWithTypeMap(context, runtime, column, type, resultSet) :
@@ -868,34 +942,25 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
     private static String formatInterval(final Object object) {
         final PGInterval interval = (PGInterval) object;
         final StringBuilder str = new StringBuilder(32);
+        str.append("P");
 
         final int years = interval.getYears();
-        if (years != 0) str.append(years).append(" years ");
+        if (years != 0) str.append(years).append("Y");
 
         final int months = interval.getMonths();
-        if (months != 0) str.append(months).append(" months ");
+        if (months != 0) str.append(months).append("M");
 
         final int days = interval.getDays();
-        if (days != 0) str.append(days).append(" days ");
+        if (days != 0) str.append(days).append("D");
 
         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
+        final double secs = interval.getSeconds();
+        if (hours != 0 || mins != 0 || secs != 0) {
+            str.append("T");
+            if (hours != 0) str.append(hours).append("H");
+            if (mins != 0) str.append(mins).append("M");
+            if (secs != 0) str.append(secs).append("S");
         }
 
         return str.toString();