activerecord-jdbc-adapter 51.2-java → 51.3-java

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

@@ -282,6 +282,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,
@@ -305,47 +329,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,
@@ -367,7 +353,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
@@ -421,8 +408,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":

data/src/java/arjdbc/util/DateTimeUtils.java

@@ -28,6 +28,7 @@ import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.TimeZone;
 
+import org.joda.time.Chronology;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.chrono.ISOChronology;
@@ -40,6 +41,7 @@ import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
 
 import static arjdbc.util.StringHelper.decByte;
 
@@ -48,6 +50,17 @@ import static arjdbc.util.StringHelper.decByte;
  * @author kares
  */
 public abstract class DateTimeUtils {
+    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;
+    }
+
+    public static DateTime dateTimeInZone(final DateTime dateTime, final DateTimeZone zone) {
+        if (zone == dateTime.getZone()) return dateTime;
+        return dateTime.withZone(zone);
+    }
 
     @SuppressWarnings("deprecation")
     public static ByteList timeToString(final Time time) {
@@ -577,4 +590,110 @@ public abstract class DateTimeUtils {
         return n;
     }
 
+
+    private static final char[] ZEROS = {'0', '0', '0', '0', '0', '0'};
+    private static final char[][] NUMBERS;
+
+    static {
+        // maximum value is 60 (seconds)
+        NUMBERS = new char[60][];
+        for (int i = 0; i < NUMBERS.length; i++) {
+            NUMBERS[i] = ((i < 10 ? "0" : "") + Integer.toString(i)).toCharArray();
+        }
+    }
+
+    /**
+     * Converts a ruby timestamp to a java string, optionally with timezone and timezone adjustment
+     * @param context
+     * @param value the ruby value, typically a Time
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in the string?
+     * @return timestamp as string
+     */
+    public static String timestampTimeToString(final ThreadContext context,
+                                               final IRubyObject value, DateTimeZone zone, boolean withZone) {
+        RubyTime timeValue = toTime(context, value);
+        DateTime dt = timeValue.getDateTime();
+
+        StringBuilder sb = new StringBuilder(36);
+
+        int year = dt.getYear();
+        if (year <= 0) {
+            year--;
+        } else if (zone != null) {
+            dt = dateTimeInZone(dt, zone);
+            year = dt.getYear();
+        }
+
+        Chronology chrono = dt.getChronology();
+        long millis = dt.getMillis();
+
+        // always use 4 digits for year to avoid short dates being misinterpreted
+        sb.append(Math.abs(year));
+        int lead = 4 - sb.length();
+        if (lead > 0) sb.insert(0, ZEROS, 0, lead);
+        sb.append('-');
+        sb.append(NUMBERS[chrono.monthOfYear().get(millis)]);
+        sb.append('-');
+        sb.append(NUMBERS[chrono.dayOfMonth().get(millis)]);
+        if (year < 0) sb.append(" BC");
+        sb.append(' ');
+
+        appendTime(sb, chrono, millis, (int) timeValue.getUSec(), withZone);
+
+        return sb.toString();
+    }
+
+    /**
+     * Converts a ruby time to a java string, optionally with timezone and timezone adjustment
+     * @param context
+     * @param value the ruby value, typically a Time
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in the string?
+     * @return time as string
+     */
+    public static String timeString(final ThreadContext context,
+                                    final IRubyObject value, DateTimeZone zone, boolean withZone) {
+        StringBuilder sb = new StringBuilder(21);
+        RubyTime timeValue = toTime(context, value);
+        DateTime dt = timeValue.getDateTime();
+        if (zone != null) dt = dateTimeInZone(dt, zone);
+
+        appendTime(sb, dt.getChronology(), dt.getMillis(), (int) timeValue.getUSec(), withZone);
+        return sb.toString();
+    }
+
+    private static void appendTime(StringBuilder sb, Chronology chrono,
+                                   long millis, int usec, boolean withZone) {
+        sb.append(NUMBERS[chrono.hourOfDay().get(millis)]);
+        sb.append(':');
+        sb.append(NUMBERS[chrono.minuteOfHour().get(millis)]);
+        sb.append(':');
+        sb.append(NUMBERS[chrono.secondOfMinute().get(millis)]);
+
+        // PG has microsecond resolution. Change when nanos are required
+        int micros = chrono.millisOfSecond().get(millis) * 1000 + usec;
+        if (micros > 0) {
+            sb.append('.');
+
+            int len = sb.length();
+            sb.append(micros);
+            int lead = 6 - (sb.length() - len);
+            if (lead > 0) sb.insert(len, ZEROS, 0, lead);
+
+            for (int end = sb.length() - 1; sb.charAt(end) == '0'; end--) {
+                sb.setLength(end);
+            }
+        }
+
+        if (withZone) {
+            int offset = chrono.getZone().getOffset(millis) / 1000;
+            int absoff = Math.abs(offset);
+            int hours = absoff / 3600;
+            int mins = (absoff - hours * 3600) / 60;
+
+            sb.append(offset < 0 ? '-' : '+');
+            sb.append(NUMBERS[hours]).append(':').append(NUMBERS[mins]);
+        }
+    }
 }

data/src/java/arjdbc/util/QuotingUtils.java

@@ -52,7 +52,6 @@ public abstract class QuotingUtils {
         return quoteCharWith(context, string, value, quote, 0, 8);
     }
 
-    @SuppressWarnings("deprecation")
     public static RubyString quoteCharWith(
             final ThreadContext context,
             final RubyString string,
@@ -72,8 +71,8 @@ public abstract class QuotingUtils {
                         new byte[realSize + newOffset + newSizeDiff],
                         stringBytes.getEncoding(), false
                     );
-                    quotedBytes.begin = newOffset;
-                    quotedBytes.realSize = 0;
+                    quotedBytes.setBegin(newOffset);
+                    quotedBytes.setRealSize(0);
                 }
                 quotedBytes.append(bytes, appendFrom, i - appendFrom);
                 quotedBytes.append(quote).append(value); // e.g. "'" => "''"
@@ -88,7 +87,6 @@ public abstract class QuotingUtils {
         return context.runtime.newString(quotedBytes);
     }
 
-    @SuppressWarnings("deprecation")
     public static RubyString quoteCharAndDecorateWith(
         final ThreadContext context, final RubyString string,
         final char value, final char quote,
@@ -102,7 +100,7 @@ public abstract class QuotingUtils {
             final ByteList quoted = new ByteList(
                 new byte[realSize + 2], string.getEncoding(), false
             );
-            quoted.begin = 0; quoted.realSize = 0;
+            quoted.setRealSize(0);
             quoted.append(prefix);
             quoted.append(str.unsafeBytes(), str.getBegin(), realSize);
             quoted.append(suffix);
@@ -110,8 +108,9 @@ public abstract class QuotingUtils {
         }
         // we got a new string with a reserve of 1 byte front and back :
         final ByteList quoted = quotedString.getByteList();
-        quoted.begin = 0; // setBegin invalidates
-        quoted.bytes[0] = prefix; quoted.realSize++;
+        quoted.setBegin(0);
+        quoted.unsafeBytes()[0] = prefix;
+        quoted.setRealSize(quoted.getRealSize() + 1);
         quoted.append(suffix);
         return quotedString;
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '51.2'
+  version: '51.3'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2019-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -197,6 +197,7 @@ files:
 - src/java/arjdbc/jdbc/DriverConnectionFactory.java
 - src/java/arjdbc/jdbc/DriverWrapper.java
 - src/java/arjdbc/jdbc/JdbcResult.java
+- src/java/arjdbc/jdbc/RubyConnectionFactory.java
 - src/java/arjdbc/jdbc/RubyJdbcConnection.java
 - src/java/arjdbc/mssql/MSSQLModule.java
 - src/java/arjdbc/mssql/MSSQLRubyJdbcConnection.java
@@ -205,7 +206,7 @@ files:
 - src/java/arjdbc/oracle/OracleModule.java
 - src/java/arjdbc/oracle/OracleRubyJdbcConnection.java
 - src/java/arjdbc/postgresql/ByteaUtils.java
-- src/java/arjdbc/postgresql/PgResultSetMetaDataWrapper.java
+- src/java/arjdbc/postgresql/PgDateTimeUtils.java
 - src/java/arjdbc/postgresql/PostgreSQLModule.java
 - src/java/arjdbc/postgresql/PostgreSQLResult.java
 - src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java
@@ -242,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.14.1
+rubygems_version: 2.7.9
 signing_key:
 specification_version: 4
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.

data/src/java/arjdbc/postgresql/PgResultSetMetaDataWrapper.java

@@ -1,23 +0,0 @@
-/*
- * A class to loosen restrictions on the PgResultSetMetaData class,
- * we need to be able to get the field and the method is currently set to "package".
- */
-package org.postgresql.jdbc;
-
-import java.sql.SQLException;
-import org.postgresql.core.BaseConnection;
-import org.postgresql.core.Field;
-import org.postgresql.jdbc.PgResultSetMetaData;
-
-public class PgResultSetMetaDataWrapper {
-
-    private final PgResultSetMetaData metaData;
-
-    public PgResultSetMetaDataWrapper(PgResultSetMetaData metaData) {
-        this.metaData = metaData;
-    }
-
-    public Field getField(int i) throws SQLException {
-        return this.metaData.getField(i);
-    }
-}