activerecord-jdbc-adapter 52.1-java → 52.2-java

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -128,6 +128,7 @@ public class RubyJdbcConnection extends RubyObject {
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
     private boolean configureConnection = true; // final once initialized
+    private int fetchSize = 0; // 0 = JDBC default
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
@@ -571,6 +572,11 @@ public class RubyJdbcConnection extends RubyObject {
         else {
             this.configureConnection = value != context.runtime.getFalse();
         }
+
+        IRubyObject jdbcFetchSize = getConfigValue(context, "jdbc_fetch_size");
+        if (jdbcFetchSize != context.nil) {
+            this.fetchSize = RubyNumeric.fix2int(jdbcFetchSize);
+        }
     }
 
     @JRubyMethod(name = "adapter")
@@ -818,6 +824,7 @@ public class RubyJdbcConnection extends RubyObject {
                             // 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
                             result = mapExecuteResult(context, connection, resultSet);
+                            resultSet.close();
                         } else {
                             result = context.runtime.newFixnum(updateCount);
                         }
@@ -851,6 +858,7 @@ public class RubyJdbcConnection extends RubyObject {
         else {
             statement.setEscapeProcessing(escapeProcessing.isTrue());
         }
+        if (fetchSize != 0) statement.setFetchSize(fetchSize);
         return statement;
     }
 
@@ -1045,6 +1053,7 @@ public class RubyJdbcConnection extends RubyObject {
                     else {
                         final PreparedStatement prepStatement;
                         statement = prepStatement = connection.prepareStatement(query);
+                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
                         statement.setMaxRows(maxRows); // zero means there is no limit
                         setStatementParameters(context, connection, prepStatement, binds);
                         hasResult = prepStatement.execute();
@@ -1112,6 +1121,24 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    /**
+     * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
+     * @param context which context this method is executing on.
+     * @param sql the query to prepare-
+     * @return a Ruby <code>PreparedStatement</code>
+     */
+    @JRubyMethod(required = 1)
+    public IRubyObject prepare_statement(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(Connection connection) throws SQLException {
+                final String query = sql.convertToString().getUnicodeValue();
+                PreparedStatement statement = connection.prepareStatement(query);
+                if (fetchSize != 0) statement.setFetchSize(fetchSize);
+                return JavaUtil.convertJavaToRuby(context.runtime, statement);
+            }
+        });
+    }
+
     // Called from exec_query in abstract/database_statements
     /**
      * Executes a query and returns the (AR) result.  There are three parameters:
@@ -1142,6 +1169,7 @@ public class RubyJdbcConnection extends RubyObject {
                         statement = (PreparedStatement) JavaEmbedUtils.rubyToJava(cachedStatement);
                     } else {
                         statement = connection.prepareStatement(query);
+                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
                     }
 
                     setStatementParameters(context, connection, statement, (RubyArray) binds);
@@ -1149,12 +1177,7 @@ public class RubyJdbcConnection extends RubyObject {
                     if (statement.execute()) {
                         ResultSet resultSet = statement.getResultSet();
                         IRubyObject results = mapQueryResult(context, connection, resultSet);
-
-                        if (cached) {
-                            // Make sure we free the result set if we are caching the statement
-                            // It gets closed automatically when the statement is closed if we aren't caching
-                            resultSet.close();
-                        }
+                        resultSet.close();
 
                         return results;
                     } else {
@@ -1807,7 +1830,7 @@ public class RubyJdbcConnection extends RubyObject {
         if ( url.isNil() || ( driver.isNil() && driver_instance.isNil() ) ) {
             final Ruby runtime = context.runtime;
             final RubyClass errorClass = getConnectionNotEstablished( runtime );
-            throw new RaiseException(runtime, errorClass, "adapter requires :driver class and jdbc :url", false);
+            throw runtime.newRaiseException(errorClass, "adapter requires :driver class and jdbc :url");
         }
 
         final String jdbcURL = buildURL(context, url);
@@ -1824,7 +1847,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return factory;
             }
             else {
-                setConnectionFactory(factory = new RubyConnectionFactoryImpl(
+                setConnectionFactory(factory = new RubyConnectionFactory(
                         driver_instance, context.runtime.newString(jdbcURL),
                         ( username.isNil() ? username : username.asString() ),
                         ( password.isNil() ? password : password.asString() )
@@ -2485,6 +2508,8 @@ public class RubyJdbcConnection extends RubyObject {
             while ( arrayResult.next() ) {
                 array.append( jdbcToRuby(context, runtime, 2, baseType, arrayResult) );
             }
+            arrayResult.close();
+
             return array;
         }
         finally { if ( value != null ) value.free(); }
@@ -2687,7 +2712,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final IRubyObject value) {
-        return timeInDefaultTimeZone(context, toTime(context, value));
+        return timeInDefaultTimeZone(context, DateTimeUtils.toTime(context, value));
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final RubyTime time) {
@@ -2699,11 +2724,14 @@ public class RubyJdbcConnection extends RubyObject {
         return timeInDefaultTZ;
     }
 
+    protected final DateTime dateTimeInDefaultTimeZone(final ThreadContext context, final DateTime dateTime) {
+        final DateTimeZone defaultZone = getDefaultTimeZone(context);
+        if (defaultZone == dateTime.getZone()) return dateTime;
+        return dateTime.withZone(defaultZone);
+    }
+
     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;
+        return DateTimeUtils.toTime(context, value);
     }
 
     protected boolean isDefaultTimeZoneUTC(final ThreadContext context) {
@@ -2803,8 +2831,8 @@ public class RubyJdbcConnection extends RubyObject {
         final int index, IRubyObject value,
         final IRubyObject attribute, final int type) throws SQLException {
 
-        final RubyTime timeValue = timeInDefaultTimeZone(context, value);
-        final DateTime dateTime = timeValue.getDateTime();
+        final RubyTime timeValue = DateTimeUtils.toTime(context, value);
+        final DateTime dateTime = dateTimeInDefaultTimeZone(context, timeValue.getDateTime());
         final Timestamp timestamp = new Timestamp(dateTime.getMillis());
         // 1942-11-30T01:02:03.123_456
         if (timeValue.getNSec() > 0) timestamp.setNanos((int) (timestamp.getNanos() + timeValue.getNSec()));
@@ -3005,7 +3033,7 @@ public class RubyJdbcConnection extends RubyObject {
     private void handleNotConnected() {
         final Ruby runtime = getRuntime();
         final RubyClass errorClass = getConnectionNotEstablished( runtime );
-        throw new RaiseException(runtime, errorClass, "no connection available", false);
+        throw runtime.newRaiseException(errorClass, "no connection available");
     }
 
     /**
@@ -3542,7 +3570,7 @@ public class RubyJdbcConnection extends RubyObject {
             return (RaiseException) exception;
         }
         if ( exception instanceof RuntimeException ) {
-            return RaiseException.createNativeRaiseException(runtime, exception);
+            return wrapException(context, context.runtime.getRuntimeError(), exception);
         }
         // NOTE: compat - maybe makes sense or maybe not (e.g. IOException) :
         return wrapException(context, getJDBCError(runtime), exception);
@@ -3555,7 +3583,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     public static RaiseException wrapException(final ThreadContext context,
                                                final RubyClass errorClass, final Throwable exception, final String message) {
-        final RaiseException error = new RaiseException(context.runtime, errorClass, message, true);
+        final RaiseException error = context.runtime.newRaiseException(errorClass, message);
         error.initCause(exception);
         return error;
     }

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

@@ -107,8 +107,8 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             final int minor = jdbcDriver.getMinorVersion();
             if ( major < 5 ) {
                 final RubyClass errorClass = getConnectionNotEstablished(context.runtime);
-                throw new RaiseException(context.runtime, errorClass,
-                    "MySQL adapter requires driver >= 5.0 got: " + major + "." + minor + "", false);
+                throw context.runtime.newRaiseException(errorClass,
+                    "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"

data/src/java/arjdbc/postgresql/PgDateTimeUtils.java

@@ -0,0 +1,52 @@
+package arjdbc.postgresql;
+
+import arjdbc.util.DateTimeUtils;
+import org.joda.time.DateTimeZone;
+import org.jruby.RubyArray;
+import org.jruby.RubyFloat;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * PostgreSQL specific DateTime/Timestamp helpers
+ * @author dritz
+ */
+public abstract class PgDateTimeUtils extends DateTimeUtils {
+    /**
+     * Convert a ruby value to a PostgreSQL timestamp string
+     * @param context
+     * @param value Ruby value, typically a Time instance
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in string?
+     * @return A string fit for PostgreSQL
+     */
+    public static String timestampValueToString(final ThreadContext context, IRubyObject value, DateTimeZone zone,
+                                         boolean withZone) {
+        if (value instanceof RubyFloat) {
+            final double dv = ((RubyFloat) value).getValue();
+            if (dv == Double.POSITIVE_INFINITY) {
+                return "infinity";
+            } else if (dv == Double.NEGATIVE_INFINITY) {
+                return "-infinity";
+            }
+        }
+        return timestampTimeToString(context, value, zone, withZone);
+    }
+
+    /**
+     * Converts a RubyArray with timestamp values to a java array of PostgreSQL timestamp strings
+     * @param context
+     * @param rubyArray
+     * @return Array of timestamp strings
+     */
+    public static String[] timestampStringArray(final ThreadContext context, final RubyArray rubyArray) {
+        int size = rubyArray.size();
+        String[] values = new String[size];
+
+        for (int i = 0; i < size; i++) {
+            IRubyObject elem = rubyArray.eltInternal(i);
+            values[i] = timestampValueToString(context, elem, DateTimeZone.UTC, false);
+        }
+        return values;
+    }
+}

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

@@ -4,15 +4,17 @@ import arjdbc.jdbc.JdbcResult;
 import arjdbc.jdbc.RubyJdbcConnection;
 
 import java.sql.ResultSet;
+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.RubyMethod;
 import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.Block;
@@ -21,17 +23,15 @@ import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-import org.postgresql.core.Field;
-import org.postgresql.jdbc.PgResultSetMetaData;
-import org.postgresql.jdbc.PgResultSetMetaDataWrapper; // This is a hack unfortunately to get around method scoping
-
 /*
- * 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 PgResultSetMetaData resultSetMetaData;
+    private final ResultSetMetaData resultSetMetaData;
 
     /********* JRuby compat methods ***********/
 
@@ -61,7 +61,7 @@ public class PostgreSQLResult extends JdbcResult {
                              ResultSet resultSet) throws SQLException {
         super(context, clazz, connection, resultSet);
 
-        resultSetMetaData = (PgResultSetMetaData) resultSet.getMetaData();
+        resultSetMetaData = resultSet.getMetaData();
     }
 
     /**
@@ -74,16 +74,28 @@ public class PostgreSQLResult extends JdbcResult {
     protected IRubyObject columnTypeMap(final ThreadContext context) throws SQLException {
         Ruby runtime = context.runtime;
         RubyHash types = RubyHash.newHash(runtime);
-        PgResultSetMetaDataWrapper mdWrapper = new PgResultSetMetaDataWrapper(resultSetMetaData);
         int columnCount = columnNames.length;
 
         IRubyObject adapter = connection.adapter(context);
         for (int i = 0; i < columnCount; i++) {
-            final Field field = mdWrapper.getField(i + 1);
+            int col = i + 1;
+            String typeName = resultSetMetaData.getColumnTypeName(col);
+
+            int mod = 0;
+            if  ("numeric".equals(typeName)) {
+                // this field is only relevant for "numeric" type in AR
+                // AR checks (fmod - 4 & 0xffff).zero?
+                // pgjdbc:
+                //  - for typmod == -1, getScale() and getPrecision() return 0
+                //  - for typmod != -1, getScale() returns "(typmod - 4) & 0xFFFF;"
+                mod = resultSetMetaData.getScale(col);
+                mod = mod == 0 && resultSetMetaData.getPrecision(col) == 0 ? -1 : mod + 4;
+            }
+
             final RubyString name = columnNames[i];
             final IRubyObject type = Helpers.invoke(context, adapter, "get_oid_type",
-                    runtime.newFixnum(field.getOID()),
-                    runtime.newFixnum(field.getMod()),
+                    runtime.newString(typeName),
+                    runtime.newFixnum(mod),
                     name);
 
             if (!type.isNil()) types.fastASet(name, type);
@@ -99,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()) {
@@ -131,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();
     }
@@ -144,7 +156,7 @@ public class PostgreSQLResult extends JdbcResult {
      * @return ActiveRecord::Result object with the data from this result set
      * @throws SQLException can be caused by postgres generating its type map
      */
-    @Override
+    @Override @SuppressWarnings("unchecked")
     public IRubyObject toARResult(final ThreadContext context) throws SQLException {
         RubyClass BinaryDataClass = null;
         int rowCount = 0;
@@ -163,7 +175,7 @@ public class PostgreSQLResult extends JdbcResult {
                     RubyArray row = (RubyArray) values.eltInternal(rowIndex);
                     IRubyObject value = row.eltInternal(columnIndex);
                     if (value != context.nil) {
-                        row.eltInternalSet(columnIndex, (IRubyObject) BinaryDataClass.newInstance(context, value, Block.NULL_BLOCK));
+                        row.eltInternalSet(columnIndex, BinaryDataClass.newInstance(context, value, Block.NULL_BLOCK));
                     }
                 }
             }
@@ -177,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);
@@ -282,6 +284,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 +331,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 +355,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
@@ -435,8 +424,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":
@@ -497,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 {
@@ -984,4 +987,20 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
 
     }
 
+    @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;
+    }
 }