activerecord-jdbc-adapter 60.2-java → 61.1-java

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

@@ -197,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";
         }
 
@@ -436,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":
@@ -493,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) :
@@ -874,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();

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

@@ -370,10 +370,9 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override
-    public IRubyObject begin(ThreadContext context, IRubyObject level) {
-        throw context.runtime.newRaiseException(getTransactionIsolationError(context.runtime),
-                "SQLite3 does not support isolation levels"
-        );
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
+        connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+        return super.resetSavepoints(context, connection);
     }
 
     @Override

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '60.2'
+  version: '61.1'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-29 00:00:00.000000000 Z
+date: 2021-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   name: activerecord
-  type: :runtime
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 description: 'AR-JDBC is a database adapter for Rails'' ActiveRecord component designed
   to be used with JRuby built upon Java''s JDBC API for database access. Provides
   (ActiveRecord) built-in adapters: MySQL,  PostgreSQL, SQLite3, and SQLServer.'
@@ -230,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.14
 signing_key:
 specification_version: 4
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.