activerecord-jdbc-alt-adapter 51.7.0-java → 52.2.0-java

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

@@ -29,33 +29,22 @@ import arjdbc.jdbc.Callable;
 import arjdbc.jdbc.RubyJdbcConnection;
 import arjdbc.util.DateTimeUtils;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
-import java.sql.Date;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.Savepoint;
-import java.sql.Statement;
 import java.sql.SQLException;
-import java.sql.Timestamp;
 import java.sql.Types;
+import java.sql.Timestamp;
 import java.util.Locale;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 
-import org.joda.time.DateTime;
-import org.joda.time.DateTimeZone;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
 import org.jruby.RubyString;
 import org.jruby.RubySymbol;
-import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -69,54 +58,6 @@ import org.jruby.util.ByteList;
 public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
     private static final long serialVersionUID = -745716565005219263L;
 
-    private static final int DATETIMEOFFSET_TYPE;
-    private static final Method DateTimeOffsetGetMinutesOffsetMethod;
-    private static final Method DateTimeOffsetGetTimestampMethod;
-    private static final Method DateTimeOffsetValueOfMethod;
-    private static final Method PreparedStatementSetDateTimeOffsetMethod;
-
-    private static final Map<String, Integer> MSSQL_JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
-    static {
-
-        Class<?> DateTimeOffset;
-        Class<?> MssqlPreparedStatement;
-        Class<?> MssqlTypes;
-        try {
-            DateTimeOffset = Class.forName("microsoft.sql.DateTimeOffset");
-            MssqlPreparedStatement = Class.forName("com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement");
-            MssqlTypes = Class.forName("microsoft.sql.Types");
-        } catch (ClassNotFoundException e) {
-            System.err.println("You must require the Microsoft JDBC driver to use this gem"); // The exception doesn't bubble when ruby is initializing
-            throw new RuntimeException("You must require the Microsoft JDBC driver to use this gem");
-        }
-
-        try {
-            DATETIMEOFFSET_TYPE = MssqlTypes.getField("DATETIMEOFFSET").getInt(null);
-            DateTimeOffsetGetMinutesOffsetMethod = DateTimeOffset.getDeclaredMethod("getMinutesOffset");
-            DateTimeOffsetGetTimestampMethod = DateTimeOffset.getDeclaredMethod("getTimestamp");
-
-            Class<?>[] valueOfArgTypes = { Timestamp.class, int.class };
-            DateTimeOffsetValueOfMethod = DateTimeOffset.getDeclaredMethod("valueOf", valueOfArgTypes);
-
-            Class<?>[] setOffsetArgTypes = { int.class, DateTimeOffset };
-            PreparedStatementSetDateTimeOffsetMethod = MssqlPreparedStatement.getDeclaredMethod("setDateTimeOffset", setOffsetArgTypes);
-        } catch (Exception e) {
-            System.err.println("You must require the Microsoft JDBC driver to use this gem"); // The exception doesn't bubble when ruby is initializing
-            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
-        }
-
-        MSSQL_JDBC_TYPE_FOR.put("binary_basic", Types.BINARY);
-        MSSQL_JDBC_TYPE_FOR.put("image", Types.BINARY);
-        MSSQL_JDBC_TYPE_FOR.put("datetimeoffset", DATETIMEOFFSET_TYPE);
-        MSSQL_JDBC_TYPE_FOR.put("money", Types.DECIMAL);
-        MSSQL_JDBC_TYPE_FOR.put("smalldatetime", Types.TIMESTAMP);
-        MSSQL_JDBC_TYPE_FOR.put("smallmoney", Types.DECIMAL);
-        MSSQL_JDBC_TYPE_FOR.put("ss_timestamp", Types.BINARY);
-        MSSQL_JDBC_TYPE_FOR.put("text_basic", Types.LONGVARCHAR);
-        MSSQL_JDBC_TYPE_FOR.put("uuid", Types.CHAR);
-        MSSQL_JDBC_TYPE_FOR.put("varchar_max", Types.VARCHAR);
-    }
-
     public MSSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
@@ -148,176 +89,6 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         return context.runtime.newBoolean( startsWithIgnoreCase(sqlBytes, EXEC) );
     }
 
-    // Support multiple result sets for mssql
-    @Override
-    @JRubyMethod(name = "execute", required = 1)
-    public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
-        final String query = sqlString(sql);
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                try {
-                    statement = createStatement(context, connection);
-
-                    // For DBs that do support multiple statements, lets return the last result set
-                    // to be consistent with AR
-                    boolean hasResultSet = doExecute(statement, query);
-                    int updateCount = statement.getUpdateCount();
-
-                    final List<IRubyObject> results = new ArrayList<IRubyObject>();
-                    ResultSet resultSet;
-
-                    while (hasResultSet || updateCount != -1) {
-
-                        if (hasResultSet) {
-                            resultSet = statement.getResultSet();
-
-                            // Unfortunately the result set gets closed when getMoreResults()
-                            // is called, so we have to process the result sets as we get them
-                            // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
-                            results.add(mapExecuteResult(context, connection, resultSet));
-                        } else {
-                            results.add(context.runtime.newFixnum(updateCount));
-                        }
-
-                        // Check to see if there is another result set
-                        hasResultSet = statement.getMoreResults();
-                        updateCount = statement.getUpdateCount();
-                    }
-
-                    if (results.size() == 0) {
-                        return context.nil; // If no results, return nil
-                    } else if (results.size() == 1) {
-                        return results.get(0);
-                    } else {
-                        return context.runtime.newArray(results);
-                    }
-
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
-                }
-            }
-        });
-    }
-
-    /**
-     * 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) {
-
-        Integer typeValue = MSSQL_JDBC_TYPE_FOR.get(type);
-
-        if ( typeValue != null ) {
-            return typeValue;
-        }
-
-        return super.jdbcTypeFor(type);
-    }
-
-    // Datetimeoffset values also make it into here
-    @Override
-    protected void setStringParameter(final ThreadContext context, final Connection connection,
-            final PreparedStatement statement, final int index, final IRubyObject value,
-            final IRubyObject attribute, final int type) throws SQLException {
-
-        // datetimeoffset values also make it in here
-        if (type == DATETIMEOFFSET_TYPE) {
-
-            Object dto = convertToDateTimeOffset(context, value);
-
-            try {
-
-                Object[] setStatementArgs = { index, dto };
-                PreparedStatementSetDateTimeOffsetMethod.invoke(statement, setStatementArgs);
-
-            } catch (IllegalAccessException e) {
-                debugMessage(context.runtime, e.getMessage());
-                throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
-            } catch (InvocationTargetException e) {
-                debugMessage(context.runtime, e.getMessage());
-                throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
-            }
-
-            return;
-        }
-        super.setStringParameter(context, connection, statement, index, value, attribute, type);
-    }
-
-    private Object convertToDateTimeOffset(final ThreadContext context, final IRubyObject value) {
-
-        RubyTime time = (RubyTime) value;
-        DateTime dt = time.getDateTime();
-        Timestamp timestamp = new Timestamp(dt.getMillis());
-        timestamp.setNanos(timestamp.getNanos() + (int) time.getNSec());
-        int offsetMinutes = dt.getZone().getOffset(dt.getMillis()) / 60000;
-
-        try {
-
-            Object[] dtoArgs = { timestamp, offsetMinutes };
-            return DateTimeOffsetValueOfMethod.invoke(null, dtoArgs);
-
-        } catch (IllegalAccessException e) {
-            debugMessage(context.runtime, e.getMessage());
-            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
-        } catch (InvocationTargetException e) {
-            debugMessage(context.runtime, e.getMessage());
-            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
-        }
-    }
-
-
     @Override
     protected RubyArray mapTables(final ThreadContext context, final Connection connection,
             final String catalog, final String schemaPattern, final String tablePattern,
@@ -534,6 +305,29 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         statement.setObject(index, timeStr, Types.NVARCHAR);
     }
 
+    // Overrides the method in parent, we only remove the savepoint
+    // from the getSavepoints Map
+    @JRubyMethod(name = "release_savepoint", required = 1)
+    public IRubyObject release_savepoint(final ThreadContext context, final IRubyObject name) {
+      if (name == context.nil) throw context.runtime.newArgumentError("nil savepoint name given");
+
+      final Connection connection = getConnection(true);
+
+      Object savepoint = getSavepoints(context).remove(name);
+
+      if (savepoint == null) throw newSavepointNotSetError(context, name, "release");
+
+      // NOTE: RubyHash.remove does not convert to Java as get does :
+      if (!(savepoint instanceof Savepoint)) {
+        savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
+      }
+
+      // The 'releaseSavepoint' method is not currently supported
+      // by the Microsoft SQL Server JDBC Driver
+      // connection.releaseSavepoint((Savepoint) savepoint);
+      return context.nil;
+    }
+
     //----------------------------------------------------------------
     // read_uncommitted: "READ UNCOMMITTED",
     // read_committed:   "READ COMMITTED",
@@ -659,64 +453,16 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
 
     /**
      * Treat LONGVARCHAR as CLOB on MSSQL for purposes of converting a JDBC value to Ruby.
-     * Also handle datetimeoffset values here
      */
     @Override
     protected IRubyObject jdbcToRuby(
         final ThreadContext context, final Ruby runtime,
         final int column, int type, final ResultSet resultSet)
         throws SQLException {
-
-        if (type == DATETIMEOFFSET_TYPE) {
-
-            Object dto = resultSet.getObject(column); // Returns a microsoft.sql.DateTimeOffset
-
-            if (dto == null) return context.nil;
-
-            try {
-
-                int minutes = (int) DateTimeOffsetGetMinutesOffsetMethod.invoke(dto);
-                DateTimeZone zone = DateTimeZone.forOffsetHoursMinutes(minutes / 60, minutes % 60);
-                Timestamp ts = (Timestamp) DateTimeOffsetGetTimestampMethod.invoke(dto);
-
-                int nanos = ts.getNanos(); // max 999-999-999
-                nanos = nanos % 1000000;
-
-                // We have to do this differently than the newTime helper because the Timestamp loses its zone information when passed around
-                DateTime dateTime = new DateTime(ts.getTime(), zone);
-                return RubyTime.newTime(context.runtime, dateTime, nanos);
-
-            } catch (IllegalAccessException e) {
-                debugMessage(runtime, e.getMessage());
-                return context.nil;
-            } catch (InvocationTargetException e) {
-                debugMessage(runtime, e.getMessage());
-                return context.nil;
-            }
-        }
-
-        if (type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR) type = Types.CLOB;
+        if ( type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR ) type = Types.CLOB;
         return super.jdbcToRuby(context, runtime, column, type, resultSet);
     }
 
-    /**
-     * Converts a JDBC date object to a Ruby date by referencing Date#civil
-     * @param context current thread context
-     * @param resultSet the jdbc result set to pull the value from
-     * @param index the index of the column to convert
-     * @return RubyNil if NULL or RubyDate if there is a value
-     * @throws SQLException if it fails to retrieve the value from the result set
-     */
-    @Override
-    protected IRubyObject dateToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int index) throws SQLException {
-
-        final Date value = resultSet.getDate(index);
-
-        if (value == null) return context.nil;
-
-        return DateTimeUtils.newDate(context, value);
-    }
-
     @Override
     protected ColumnData[] extractColumns(final ThreadContext context,
         final Connection connection, final ResultSet resultSet,
@@ -746,9 +492,19 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         return columns;
     }
 
-    @Override
-    protected void releaseSavepoint(final Connection connection, final Savepoint savepoint) throws SQLException {
-        // MSSQL doesn't support releasing savepoints
+    // internal helper not meant as a "public" API - used in one place thus every
+    @JRubyMethod(name = "jtds_driver?")
+    public RubyBoolean jtds_driver_p(final ThreadContext context) throws SQLException {
+        // "jTDS Type 4 JDBC Driver for MS SQL Server and Sybase"
+        // SQLJDBC: "Microsoft JDBC Driver 4.0 for SQL Server"
+        return withConnection(context, new Callable<RubyBoolean>() {
+            // NOTE: only used in one place for now (on release_savepoint) ...
+            // might get optimized to only happen once since driver won't change
+            public RubyBoolean call(final Connection connection) throws SQLException {
+                final String driver = connection.getMetaData().getDriverName();
+                return context.getRuntime().newBoolean( driver.indexOf("jTDS") >= 0 );
+            }
+        });
     }
 
 }

data/src/java/arjdbc/postgresql/PostgreSQLResult.java

@@ -8,11 +8,13 @@ import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Types;
 
+import arjdbc.util.PG;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyHash;
 import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.Block;
@@ -22,9 +24,11 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 /*
- * This class mimics the PG:Result class enough to get by
+ * This class mimics the PG::Result class enough to get by.  It also adorns common methods useful for
+ * gems like mini_sql to consume it similarly to PG::Result
  */
 public class PostgreSQLResult extends JdbcResult {
+    private RubyArray fields = null; // lazily created if PG fields method is called.
 
     // These are needed when generating an AR::Result
     private final ResultSetMetaData resultSetMetaData;
@@ -107,7 +111,7 @@ public class PostgreSQLResult extends JdbcResult {
      * @param block which may handle each result
      * @return this object or RubyNil
      */
-    @JRubyMethod
+    @PG @JRubyMethod
     public IRubyObject each(ThreadContext context, Block block) {
         // At this point we don't support calling this without a block
         if (block.isGiven()) {
@@ -139,7 +143,7 @@ public class PostgreSQLResult extends JdbcResult {
      * @param context current thread contect
      * @return <code>Fixnum</code>
      */
-    @JRubyMethod
+    @PG @JRubyMethod(name = {"length", "ntuples", "num_tuples"})
     public IRubyObject length(final ThreadContext context) {
         return values.length();
     }
@@ -185,8 +189,69 @@ public class PostgreSQLResult extends JdbcResult {
      * This is defined in PG::Result and is used by some Rails tests
      * @return IRubyObject RubyArray of RubyArray of values
      */
-    @JRubyMethod
+    @PG @JRubyMethod
     public IRubyObject values() {
         return values;
     }
+
+    /**
+     * Do we have any rows of result
+     * @param context the thread context
+     * @return number of rows
+     */
+    @JRubyMethod(name = "empty?")
+    public IRubyObject isEmpty(ThreadContext context) {
+        return context.runtime.newBoolean(values.isEmpty());
+    }
+
+    @PG @JRubyMethod
+    public RubyArray fields(ThreadContext context) {
+        if (fields == null) fields = RubyArray.newArrayNoCopy(context.runtime, getColumnNames());
+
+        return fields;
+    }
+
+    @PG @JRubyMethod(name = {"nfields", "num_fields"})
+    public IRubyObject nfields(ThreadContext context) {
+        return context.runtime.newFixnum(getColumnNames().length);
+    }
+
+    @PG @JRubyMethod
+    public IRubyObject getvalue(ThreadContext context, IRubyObject rowArg, IRubyObject columnArg) {
+        int rows = values.size();
+        int row = RubyNumeric.fix2int(rowArg);
+        int column = RubyNumeric.fix2int(columnArg);
+
+        if (row < 0 || row >= rows) throw context.runtime.newArgumentError("invalid tuple number " + row);
+        if (column < 0 || column >= getColumnNames().length) throw context.runtime.newArgumentError("invalid field number " + row);
+
+        return ((RubyArray) values.eltInternal(row)).eltInternal(column);
+    }
+
+    @PG @JRubyMethod(name = "[]")
+    public IRubyObject aref(ThreadContext context, IRubyObject rowArg) {
+        int row = RubyNumeric.fix2int(rowArg);
+        int rows = values.size();
+
+        if (row < 0 || row >= rows) throw context.runtime.newArgumentError("Index " + row + " is out of range");
+
+        RubyArray rowValues = (RubyArray) values.eltOk(row);
+        RubyHash resultHash = RubyHash.newSmallHash(context.runtime);
+        RubyArray fields = fields(context);
+        int length = rowValues.getLength();
+        for (int i = 0; i < length; i++) {
+            resultHash.op_aset(context, fields.eltOk(i), rowValues.eltOk(i));
+        }
+
+        return resultHash;
+    }
+
+    // Note: this is # of commands (insert/update/selects performed) and not number of rows.  In practice,
+    // so far users always just check this as to when it is 0 which ends up being the same as an update/insert
+    // where no rows were affected...so wrong value but the important value will be the same (I do not see
+    // how jdbc can do this).
+    @PG @JRubyMethod(name = {"cmdtuples", "cmd_tuples"})
+    public IRubyObject cmdtuples(ThreadContext context) {
+        return values.isEmpty() ? context.runtime.newFixnum(0) : aref(context, context.runtime.newFixnum(0));
+    }
 }

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

@@ -1,4 +1,5 @@
-/***** BEGIN LICENSE BLOCK *****
+/*
+ ***** BEGIN LICENSE BLOCK *****
  * Copyright (c) 2012-2015 Karol Bucek <self@kares.org>
  * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
@@ -27,8 +28,8 @@ package arjdbc.postgresql;
 
 import arjdbc.jdbc.Callable;
 import arjdbc.jdbc.DriverWrapper;
-import arjdbc.postgresql.PostgreSQLResult;
 import arjdbc.util.DateTimeUtils;
+import arjdbc.util.PG;
 import arjdbc.util.StringHelper;
 
 import java.io.ByteArrayInputStream;
@@ -39,6 +40,7 @@ import java.sql.DatabaseMetaData;
 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;
@@ -50,8 +52,6 @@ import java.util.UUID;
 import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 
-import org.joda.time.DateTime;
-import org.joda.time.DateTimeZone;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
@@ -62,6 +62,7 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 
+import org.jruby.util.TypeConverter;
 import org.postgresql.PGConnection;
 import org.postgresql.PGStatement;
 import org.postgresql.geometric.PGbox;
@@ -84,7 +85,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
     private static final Pattern doubleValuePattern = Pattern.compile("(-?\\d+(?:\\.\\d+)?)");
     private static final Pattern uuidPattern = Pattern.compile("\\{?\\p{XDigit}{4}(?:-?(\\p{XDigit}{4})){7}\\}?"); // Fuzzy match postgres's allowed formats
 
-    private static final Map<String, Integer> POSTGRES_JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
+    private static final Map<String, Integer> POSTGRES_JDBC_TYPE_FOR = new HashMap<>(32, 1);
     static {
         POSTGRES_JDBC_TYPE_FOR.put("bit", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("bit_varying", Types.OTHER);
@@ -116,6 +117,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
     private static final Pattern pointCleanerPattern = Pattern.compile("\\.0\\b");
 
     private RubyClass resultClass;
+    private RubyHash typeMap = null;
 
     public PostgreSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
@@ -363,13 +365,26 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         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;
+            }
+        }
+
         if ( ! "Date".equals(value.getMetaClass().getName()) && value.respondsTo("to_date") ) {
             value = value.callMethod(context, "to_date");
         }
 
-        // NOTE: Here we rely in ActiveRecord (ActiveSupport) to get
-        // the date as a string in the database format.
-        statement.setDate(index, Date.valueOf(value.callMethod(context, "to_s", context.runtime.newSymbol("db")).toString()));
+        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);
+
+        statement.setDate(index, date);
     }
 
     @Override
@@ -470,6 +485,21 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         }
     }
 
+    protected IRubyObject jdbcToRuby(ThreadContext context, Ruby runtime, int column, int type, ResultSet resultSet) throws SQLException {
+        return typeMap != null ?
+                convertWithTypeMap(context, runtime, column, type, resultSet) :
+                super.jdbcToRuby(context, runtime, column, type, resultSet);
+    }
+
+    private IRubyObject convertWithTypeMap(ThreadContext context, Ruby runtime, int column, int type, ResultSet resultSet) throws SQLException {
+        ResultSetMetaData metaData = resultSet.getMetaData();
+        IRubyObject decoder = typeMap.op_aref(context, STRING_CACHE.get(context, metaData.getColumnTypeName(column)));
+
+        if (decoder.isNil()) return super.jdbcToRuby(context, runtime, column, type, resultSet);
+
+        return decoder.callMethod(context, "decode", StringHelper.newDefaultInternalString(runtime, resultSet.getString(column)));
+    }
+
     // The tests won't start if this returns PGpoint[]
     // it fails with a runtime error: "NativeException: java.lang.reflect.InvocationTargetException: [Lorg/postgresql/geometric/PGpoint"
     private Object[] convertToPoints(Double[] values) throws SQLException {
@@ -516,7 +546,9 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         final PreparedStatement statement, final int index,
         final IRubyObject value, final String columnType) throws SQLException {
 
-        final String rangeValue = value.toString();
+        // As of AR 5.2 this is a Range object, I defer to the adapter for encoding because of the edge cases
+        // of dealing with the specific types in the range
+        final String rangeValue = adapter(context).callMethod(context, "encode_range", value).toString();
         final Object pgRange;
 
         switch ( columnType ) {
@@ -536,7 +568,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
                 pgRange = new Int8RangeType(rangeValue);
                 break;
             default:
-                pgRange = new NumRangeType(rangeValue);
+                pgRange = new NumRangeType(rangeValue, columnType);
         }
 
         statement.setObject(index, pgRange);
@@ -685,8 +717,16 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
     protected IRubyObject dateToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int index) throws SQLException {
         // NOTE: PostgreSQL adapter under MRI using pg gem returns UTC-d Date/Time values
         final String value = resultSet.getString(index);
+        if (value == null) return context.nil;
 
-        return value == null ? context.nil : DateTimeUtils.parseDate(context, value, getDefaultTimeZone(context));
+        final int len = value.length();
+        if (len < 10 && value.charAt(len - 1) == 'y') { // infinity / -infinity
+            IRubyObject infinity = parseInfinity(context.runtime, value);
+
+            if (infinity != null) return infinity;
+        }
+
+        return DateTimeUtils.parseDate(context, value, getDefaultTimeZone(context));
     }
 
 
@@ -940,11 +980,27 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
             setType("numrange");
         }
 
-        public NumRangeType(final String value) throws SQLException {
-            this();
+        public NumRangeType(final String value, final String type) throws SQLException {
+            setType(type);
             setValue(value);
         }
 
     }
 
+    @PG @JRubyMethod
+    public IRubyObject escape_string(ThreadContext context, IRubyObject string) {
+        return PostgreSQLModule.quote_string(context, this, string);
+    }
+
+    @PG @JRubyMethod(name = "typemap=")
+    public IRubyObject typemap_set(ThreadContext context, IRubyObject mapArg) {
+        if (mapArg.isNil()) {
+            typeMap = null;
+            return context.nil;
+        }
+
+        TypeConverter.checkHashType(context.runtime, mapArg);
+        this.typeMap = (RubyHash) mapArg;
+        return mapArg;
+    }
 }