activerecord-jdbc-adapter 60.4-java → 61.2-java

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);
         }
@@ -860,27 +859,25 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(name = "execute_insert_pk", required = 2)
     public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
-                try {
-
-                    statement = createStatement(context, connection);
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
 
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement.executeUpdate(query, createStatementPk(pk));
-                    }
+                statement = createStatement(context, connection);
 
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(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;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -903,26 +900,24 @@ public class RubyJdbcConnection extends RubyObject {
     @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, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                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));
-                    }
-
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
-                    statement.executeUpdate();
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+        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));
                 }
+
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
+                statement.executeUpdate();
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -1012,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;
@@ -1106,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.
@@ -2402,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 ) {
@@ -2520,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);
     }
@@ -2531,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
@@ -2544,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/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,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '60.4'
+  version: '61.2'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-29 00:00:00.000000000 Z
+date: 2022-04-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
   prerelease: false
   type: :runtime
@@ -23,7 +23,7 @@ dependencies:
     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.'
@@ -35,6 +35,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - ".yardopts"
@@ -230,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.14
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.