activerecord-jdbc-alt-adapter 52.4.0-java → 61.0.0-java

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

@@ -57,6 +57,7 @@ import org.jruby.RubyString;
 import org.jruby.RubySymbol;
 import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -203,6 +204,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) {
 
@@ -598,6 +650,42 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
       });
     }
 
+    // Get MSSQL minor version eg. 0
+    @JRubyMethod
+    public IRubyObject database_minor_version(final ThreadContext context) throws SQLException {
+      return withConnection(context, new Callable<IRubyObject>() {
+        public IRubyObject call(final Connection connection) throws SQLException {
+          final DatabaseMetaData metaData = connection.getMetaData();
+
+          return context.runtime.newFixnum( metaData.getDatabaseMinorVersion() );
+        }
+      });
+    }
+
+    // Get MSSQL product name eg. Microsoft SQL Server
+    @JRubyMethod
+    public IRubyObject database_product_name(final ThreadContext context) throws SQLException {
+      return withConnection(context, new Callable<IRubyObject>() {
+        public IRubyObject call(final Connection connection) throws SQLException {
+          final DatabaseMetaData metaData = connection.getMetaData();
+
+          return context.runtime.newString( metaData.getDatabaseProductName() );
+        }
+      });
+    }
+
+    // Get MSSQL product version eg. '14.00.3238'
+    @JRubyMethod
+    public IRubyObject database_product_version(final ThreadContext context) throws SQLException {
+      return withConnection(context, new Callable<IRubyObject>() {
+        public IRubyObject call(final Connection connection) throws SQLException {
+          final DatabaseMetaData metaData = connection.getMetaData();
+
+          return context.runtime.newString( metaData.getDatabaseProductVersion() );
+        }
+      });
+    }
+
     /**
      * Microsoft SQL 2000+ support schemas
      */

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

@@ -40,8 +40,6 @@ import java.sql.Statement;
 import java.sql.Timestamp;
 import java.sql.Types;
 
-import org.joda.time.DateTime;
-import org.joda.time.DateTimeZone;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
@@ -89,11 +87,9 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
 
     @JRubyMethod(name = { "full_version" })
     public IRubyObject db_version(final ThreadContext context) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                return context.runtime.newString(metaData.getDatabaseProductVersion());
-            }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            return context.runtime.newString(metaData.getDatabaseProductVersion());
         });
     }
 
@@ -108,7 +104,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             if ( major < 5 ) {
                 final RubyClass errorClass = getConnectionNotEstablished(context.runtime);
                 throw context.runtime.newRaiseException(errorClass,
-                    "MySQL adapter requires driver >= 5.0 got: " + major + "." + minor + "");
+                        "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"
@@ -203,7 +199,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             return resultSet.wasNull() ? context.nil : RubyString.newEmptyString(runtime);
         }
 
-        if ( rawDateTime != null && rawDateTime.booleanValue() ) {
+        if ( rawDateTime != null && rawDateTime) {
             return RubyString.newString(runtime, DateTimeUtils.dummyTimeToString(value));
         }
 
@@ -237,7 +233,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         if (lowerCase == null) {
             lowerCase = lowerCaseIdentifiers = connection.getMetaData().storesLowerCaseIdentifiers();
         }
-        return lowerCase.booleanValue() ? value.toLowerCase() : value;
+        return lowerCase ? value.toLowerCase() : value;
     }
 
     @Override
@@ -247,7 +243,9 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             connection = super.newConnection();
         }
         catch (SQLException ex) {
-            if (ex.getErrorCode() == 1049) throw newNoDatabaseError(ex);
+            int errorCode = ex.getErrorCode();
+            // access denied, no database
+            if (errorCode == 1044 || errorCode == 1049) throw newNoDatabaseError(ex);
             throw ex;
         }
         if ( doStopCleanupThread() ) shutdownCleanupThread();
@@ -261,7 +259,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
     }
 
     private static boolean doStopCleanupThread() throws SQLException {
-        return stopCleanupThread != null && stopCleanupThread.booleanValue();
+        return stopCleanupThread != null && stopCleanupThread;
     }
 
     private static boolean cleanupThreadShutdown;
@@ -276,19 +274,11 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         catch (ClassNotFoundException e) {
             debugMessage(null, "missing MySQL JDBC cleanup thread ", e);
         }
-        catch (NoSuchMethodException e) {
-            debugMessage(null, e);
-        }
-        catch (IllegalAccessException e) {
+        catch (NoSuchMethodException | SecurityException | IllegalAccessException e) {
             debugMessage(null, e);
-        }
-        catch (InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             debugMessage(null, e.getTargetException());
-        }
-        catch (SecurityException e) {
-            debugMessage(null, e);
-        }
-        finally { cleanupThreadShutdown = true; }
+        } finally { cleanupThreadShutdown = true; }
     }
 
 }

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

@@ -35,27 +35,19 @@ import arjdbc.util.StringHelper;
 import java.io.ByteArrayInputStream;
 import java.lang.StringBuilder;
 import java.lang.reflect.InvocationTargetException;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
+import java.math.BigDecimal;
+import java.sql.*;
 import java.sql.Date;
-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.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;
@@ -163,15 +156,12 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
             try { // public static String getVersion()
                 final String version = (String) // "PostgreSQL 9.2 JDBC4 (build 1002)"
                     jdbcDriver.getClass().getMethod("getVersion").invoke(null);
-                if ( version != null && version.indexOf("JDBC3") >= 0 ) {
+                if ( version != null && version.contains("JDBC3")) {
                     // config[:connection_alive_sql] ||= 'SELECT 1'
                     setConfigValueIfNotSet(context, "connection_alive_sql", context.runtime.newString("SELECT 1"));
                 }
             }
-            catch (NoSuchMethodException e) { }
-            catch (SecurityException e) { }
-            catch (IllegalAccessException e) { }
-            catch (InvocationTargetException e) { }
+            catch (NoSuchMethodException | SecurityException | InvocationTargetException | IllegalAccessException ignored) { }
         }
 
         return driverWrapper;
@@ -207,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";
         }
 
@@ -218,11 +208,9 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
 
     @JRubyMethod(name = "database_product")
     public IRubyObject database_product(final ThreadContext context) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                return RubyString.newString(context.runtime, metaData.getDatabaseProductName() + ' ' + metaData.getDatabaseProductVersion());
-            }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            return RubyString.newString(context.runtime, metaData.getDatabaseProductName() + ' ' + metaData.getDatabaseProductVersion());
         });
     }
 
@@ -308,6 +296,24 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         statement.setArray(index, connection.createArrayOf(typeName, values));
     }
 
+    protected void setDecimalParameter(final ThreadContext context,
+                                       final Connection connection, final PreparedStatement statement,
+                                       final int index, final IRubyObject value,
+                                       final IRubyObject attribute, final int type) throws SQLException {
+        if (value instanceof RubyBigDecimal) {
+            RubyBigDecimal bigDecimal = (RubyBigDecimal) value;
+
+            // too bad RubyBigDecimal.isNaN() isn't public
+            if (bigDecimal.nan_p(context) == context.tru) {
+                statement.setDouble(index, Double.NaN);
+            } else {
+                statement.setBigDecimal(index, bigDecimal.getValue());
+            }
+        } else {
+            super.setDecimalParameter(context, connection, statement, index, value, attribute, type);
+        }
+    }
+
     @Override
     protected void setBlobParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
@@ -377,14 +383,16 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
             value = value.callMethod(context, "to_date");
         }
 
-        int year = RubyNumeric.num2int(value.callMethod(context, "year"));
-        int month = RubyNumeric.num2int(value.callMethod(context, "month"));
-        int day = RubyNumeric.num2int(value.callMethod(context, "day"));
-
-        @SuppressWarnings("deprecated")
-        Date date = new Date(year - 1900, month - 1, day);
+        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;
+        }
 
-        statement.setDate(index, date);
+        // NOTE: assuming Date#to_s does right ...
+        statement.setDate(index, Date.valueOf(value.toString()));
     }
 
     @Override
@@ -428,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":
@@ -485,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) :
@@ -514,7 +590,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
 
     private static Double[] parseDoubles(IRubyObject value) {
         Matcher matches = doubleValuePattern.matcher(value.toString());
-        ArrayList<Double> doubles = new ArrayList<Double>(4); // Paths and polygons may be larger but this covers points/circles/boxes/line segments
+        ArrayList<Double> doubles = new ArrayList<>(4); // Paths and polygons may be larger but this covers points/circles/boxes/line segments
 
         while ( matches.find() ) {
             doubles.add(Double.parseDouble(matches.group()));
@@ -729,6 +805,11 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         return DateTimeUtils.parseDate(context, value, getDefaultTimeZone(context));
     }
 
+    protected IRubyObject decimalToRuby(final ThreadContext context,
+                                        final Ruby runtime, final ResultSet resultSet, final int column) throws SQLException {
+        if ("NaN".equals(resultSet.getString(column)))  return new RubyBigDecimal(runtime, BigDecimal.ZERO, true);
+        return super.decimalToRuby(context, runtime, resultSet, column);
+    }
 
     /**
      * Detects PG specific types and converts them to their Ruby equivalents
@@ -861,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();