activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/src/java/arjdbc/mysql/MySQLModule.java

@@ -100,9 +100,9 @@ public class MySQLModule {
 
         final Ruby runtime = context.getRuntime();
         final RubyString quoted = runtime.newString(quotedBytes);
-        if ( runtime.is1_9() ) { // only due mysql2 compatibility
-            quoted.associateEncoding( UTF8Encoding.INSTANCE );
-        }
+
+        quoted.associateEncoding(UTF8Encoding.INSTANCE);
+
         return quoted;
     }
 

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

@@ -26,7 +26,6 @@
 package arjdbc.mysql;
 
 import arjdbc.jdbc.RubyJdbcConnection;
-import arjdbc.jdbc.Callable;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -43,17 +42,18 @@ import java.util.TimeZone;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.joda.time.DateTime;
 import org.jruby.Ruby;
-import org.jruby.RubyArray;
 import org.jruby.RubyClass;
-import org.jruby.RubyFloat;
 import org.jruby.RubyInteger;
-import org.jruby.RubyModule;
 import org.jruby.RubyString;
+import org.jruby.RubyTime;
+import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.TypeConverter;
 
 /**
  *
@@ -79,25 +79,20 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         return clazz;
     }
 
-    @Override
-    protected boolean doExecute(final Statement statement, final String query)
-        throws SQLException {
-        return statement.execute(query, Statement.RETURN_GENERATED_KEYS);
+    @JRubyMethod
+    public IRubyObject query(final ThreadContext context, final IRubyObject sql) throws SQLException {
+        final String query = sql.convertToString().getUnicodeValue(); // sql
+        return executeUpdate(context, query, false);
     }
 
     @Override
-    protected IRubyObject mapGeneratedKeysOrUpdateCount(final ThreadContext context,
-        final Connection connection, final Statement statement) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        final IRubyObject key = mapGeneratedKeys(runtime, connection, statement);
-        return ( key == null || key.isNil() ) ? runtime.newFixnum( statement.getUpdateCount() ) : key;
+    protected boolean doExecute(final Statement statement, final String query) throws SQLException {
+        return statement.execute(query, Statement.RETURN_GENERATED_KEYS);
     }
 
     @Override
-    protected IRubyObject jdbcToRuby(
-        final ThreadContext context, final Ruby runtime,
-        final int column, final int type, final ResultSet resultSet)
-        throws SQLException {
+    protected IRubyObject jdbcToRuby(final ThreadContext context, final Ruby runtime,
+        final int column, final int type, final ResultSet resultSet) throws SQLException {
         if ( type == Types.BIT ) {
             final int value = resultSet.getInt(column);
             return resultSet.wasNull() ? runtime.getNil() : runtime.newFixnum(value);
@@ -106,53 +101,50 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override // can not use statement.setTimestamp( int, Timestamp, Calendar )
-    protected void setTimestampParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIMESTAMP);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyString ) { // yyyy-[m]m-[d]d hh:mm:ss[.f...]
-                final Timestamp timestamp = Timestamp.valueOf( value.toString() );
-                statement.setTimestamp( index, timestamp ); // assume local time-zone
-            }
-            else { // Time or DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final double time = adjustTimeFromDefaultZone(value);
-                final RubyFloat timeValue = context.getRuntime().newFloat( time );
-                statement.setTimestamp( index, convertToTimestamp(timeValue) );
-            }
-        }
+    protected void setTimestampParameter(ThreadContext context, Connection connection, PreparedStatement statement,
+        int index, IRubyObject value, IRubyObject column, int type) throws SQLException {
+        value = callMethod(context, "time_in_default_timezone", value);
+        TypeConverter.checkType(context, value, context.runtime.getTime());
+        setTimestamp(statement, index, (RubyTime) value, type);
     }
 
-    @Override // can not use statement.setTime( int, Time, Calendar )
-    protected void setTimeParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIME);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyString ) {
-                final Time time = Time.valueOf( value.toString() );
-                statement.setTime( index, time ); // assume local time-zone
-            }
-            else { // Time or DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final double timeValue = adjustTimeFromDefaultZone(value);
-                final Time time = new Time(( (long) timeValue ) * 1000); // millis
-                // java.sql.Time is expected to be only up to second precision
-                statement.setTime( index, time );
-            }
-        }
+    @Override
+    protected void setTimeParameter(ThreadContext context, Connection connection, PreparedStatement statement,
+        int index, IRubyObject value, IRubyObject column, int type) throws SQLException {
+        setTimestampParameter(context, connection, statement, index, value, column, type);
     }
 
-    private static double adjustTimeFromDefaultZone(final IRubyObject value) {
-        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
-        final double time = value.convertToFloat().getDoubleValue(); // to_f
-        // NOTE: MySQL assumes default TZ thus need to adjust to match :
-        final int offset = TimeZone.getDefault().getOffset((long) time * 1000);
-        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
-        return time - ( offset / 1000.0 );
+    // FIXME: we should detect adapter and not do this timezone offset calculation is it is jdbc version 6+.
+    private void setTimestamp(PreparedStatement statement, int index, RubyTime value, int type) throws SQLException {
+        DateTime dateTime = value.getDateTime();
+        int offset = TimeZone.getDefault().getOffset(dateTime.getMillis()); // JDBC <6.x ignores time zone info (we adjust manually).
+        Timestamp timestamp = new Timestamp(dateTime.getMillis() - offset);
+
+        // 1942-11-30T01:02:03.123_456
+        if (type != Types.DATE && value.getNSec() >= 0) timestamp.setNanos((int) (timestamp.getNanos() + value.getNSec()));
+
+        statement.setTimestamp(index, timestamp);
+    }
+
+    // FIXME: I think we can unify this back to main adapter code since previous conflict involved not using
+    // the raw string return type and not the extra formatting logic.
+    @Override
+    protected IRubyObject timeToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int column) throws SQLException {
+        Time value = resultSet.getTime(column);
+
+        if (value == null) return resultSet.wasNull() ? runtime.getNil() : runtime.newString();
+
+        String strValue = value.toString();
+
+        // If time is column type but that time had a precision which included
+        // nanoseconds we used timestamp to save the data.  Since this is conditional
+        // we grab data a second time as a timestamp to look for nsecs.
+        Timestamp nsecTimeHack = resultSet.getTimestamp(column);
+        if (nsecTimeHack.getNanos() != 0) {
+            strValue = String.format("%s.%09d", strValue, nsecTimeHack.getNanos());
+        }
+
+        return RubyString.newUnicodeString(runtime,strValue);
     }
 
     @Override
@@ -192,80 +184,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override
-    protected IRubyObject indexes(final ThreadContext context, final String tableName, final String name, final String schemaName) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final Ruby runtime = context.getRuntime();
-                final RubyModule indexDefinition = getIndexDefinition(runtime);
-                final String jdbcTableName = caseConvertIdentifierForJdbc(connection, tableName);
-                final String jdbcSchemaName = caseConvertIdentifierForJdbc(connection, schemaName);
-                final IRubyObject rubyTableName = RubyString.newUnicodeString(
-                    runtime, caseConvertIdentifierForJdbc(connection, tableName)
-                );
-
-                StringBuilder query = new StringBuilder("SHOW KEYS FROM ");
-                if (jdbcSchemaName != null) {
-                    query.append(jdbcSchemaName).append(".");
-                }
-                query.append(jdbcTableName);
-                query.append(" WHERE key_name != 'PRIMARY'");
-
-                final RubyArray indexes = runtime.newArray(8);
-                PreparedStatement statement = null;
-                ResultSet keySet = null;
-
-                try {
-                    statement = connection.prepareStatement(query.toString());
-                    keySet = statement.executeQuery();
-
-                    String currentKeyName = null;
-
-                    while ( keySet.next() ) {
-                        final String keyName = caseConvertIdentifierForRails(connection, keySet.getString("key_name"));
-
-                        if ( ! keyName.equals(currentKeyName) ) {
-                            currentKeyName = keyName;
-
-                            final boolean nonUnique = keySet.getBoolean("non_unique");
-
-                            IRubyObject[] args = new IRubyObject[] {
-                                rubyTableName, // table_name
-                                RubyString.newUnicodeString(runtime, keyName), // index_name
-                                runtime.newBoolean( ! nonUnique ), // unique
-                                runtime.newArray(), // [] for column names, we'll add to that in just a bit
-                                runtime.newArray() // lengths
-                            };
-
-                            indexes.append( indexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
-                        }
-
-                        IRubyObject lastIndexDef = indexes.isEmpty() ? null : indexes.entry(-1);
-                        if ( lastIndexDef != null ) {
-                            final String columnName = caseConvertIdentifierForRails(connection, keySet.getString("column_name"));
-                            final int length = keySet.getInt("sub_part");
-                            final boolean nullLength = keySet.wasNull();
-
-                            lastIndexDef.callMethod(context, "columns").callMethod(context,
-                                    "<<", RubyString.newUnicodeString(runtime, columnName));
-                            lastIndexDef.callMethod(context, "lengths").callMethod(context,
-                                    "<<", nullLength ? runtime.getNil() : runtime.newFixnum(length));
-                        }
-                    }
-
-                    return indexes;
-                }
-                finally {
-                    close(keySet);
-                    close(statement);
-                }
-            }
-        });
-    }
-
-    @Override
-    protected String caseConvertIdentifierForRails(final Connection connection, final String value)
-        throws SQLException {
-        if ( value == null ) return null;
+    protected String caseConvertIdentifierForRails(Connection connection, String value) throws SQLException {
         return value; // MySQL does not storesUpperCaseIdentifiers() :
     }
 

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

@@ -27,6 +27,7 @@ package arjdbc.postgresql;
 
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.lang.StringBuilder;
 import java.sql.Array;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -35,8 +36,10 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.Timestamp;
 import java.sql.Types;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import java.util.regex.Pattern;
 
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -46,6 +49,7 @@ import org.jruby.RubyFixnum;
 import org.jruby.RubyFloat;
 import org.jruby.RubyHash;
 import org.jruby.RubyIO;
+import org.jruby.RubyModule;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.javasupport.JavaUtil;
@@ -57,7 +61,9 @@ import org.jruby.util.ByteList;
 import org.postgresql.PGConnection;
 import org.postgresql.PGStatement;
 import org.postgresql.core.BaseConnection;
-import org.postgresql.jdbc4.Jdbc4Array;
+import org.postgresql.geometric.PGline;
+import org.postgresql.geometric.PGlseg;
+import org.postgresql.geometric.PGpoint;
 import org.postgresql.util.PGInterval;
 import org.postgresql.util.PGobject;
 
@@ -67,6 +73,52 @@ import org.postgresql.util.PGobject;
  */
 public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection {
     private static final long serialVersionUID = 7235537759545717760L;
+    private static final int HSTORE_TYPE = 100000 + 1111;
+    private static final Pattern binaryStringPattern = Pattern.compile("^[01]+$");
+    private static final Pattern uuidPattern = Pattern.compile("^\\p{XDigit}{8}-(?:\\p{XDigit}{4}-){3}\\p{XDigit}{12}$");
+
+    private static final String[] binaryStrings = {
+        "0000",
+        "0001",
+        "0010",
+        "0011",
+        "0100",
+        "0101",
+        "0110",
+        "0111",
+        "1000",
+        "1001",
+        "1010",
+        "1011",
+        "1100",
+        "1101",
+        "1110",
+        "1111"
+    };
+
+    private static final Map<String, Integer> POSTGRES_JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
+    static {
+        POSTGRES_JDBC_TYPE_FOR.put("bit", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("bit_varying", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("citext", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("daterange", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("hstore", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("int4range", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("int8range", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("interval", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("json", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("jsonb", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("line", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("lseg", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("ltree", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("numrange", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("point", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("tsrange", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("tstzrange", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("tsvector", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("uuid", Types.OTHER);
+    }
+
 
     protected PostgreSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
@@ -128,6 +180,20 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         return value;
     }
 
+    @Override
+    protected String internedTypeFor(final ThreadContext context, final IRubyObject attribute) throws SQLException {
+
+        final RubyModule postgreSQL = (RubyModule) getConnectionAdapters(context.runtime).getConstant("PostgreSQL");
+        final RubyModule oid = (RubyModule) postgreSQL.getConstant("OID");
+        final RubyClass arrayClass = oid.getClass("Array");
+
+        if ( arrayClass.isInstance(attributeType(context, attribute)) ) {
+            return "array";
+        }
+
+        return super.internedTypeFor(context, attribute);
+    }
+
     @Override
     protected Connection newConnection() throws SQLException {
         final Connection connection = getConnectionFactory().newConnection();
@@ -147,43 +213,27 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         return connection;
     }
 
-    @Override // due statement.setNull(index, Types.BLOB) not working :
-    // org.postgresql.util.PSQLException: ERROR: column "sample_binary" is of type bytea but expression is of type oid
-    protected void setBlobParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setBlobParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.BINARY);
-            else {
-                statement.setBinaryStream(index, (InputStream) value);
-            }
-        }
-    }
-
     @Override // due statement.setNull(index, Types.BLOB) not working :
     // org.postgresql.util.PSQLException: ERROR: column "sample_binary" is of type bytea but expression is of type oid
     protected void setBlobParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
+        final IRubyObject attribute, final int type) throws SQLException {
+
+        // TODO: Somewhere in the process of storing binary data, we lose about 50 bytes in one of the tests
+
         if ( value.isNil() ) {
             statement.setNull(index, Types.BINARY);
         }
-        else {
-            if ( value instanceof RubyIO ) { // IO/File
-                statement.setBinaryStream(index, ((RubyIO) value).getInStream());
-            }
-            else { // should be a RubyString
-                final ByteList blob = value.asString().getByteList();
-                statement.setBinaryStream(index,
-                    new ByteArrayInputStream(blob.unsafeBytes(), blob.getBegin(), blob.getRealSize()),
-                    blob.getRealSize() // length
-                );
-            }
+        else if ( value instanceof RubyIO ) { // IO/File
+            statement.setBinaryStream(index, ((RubyIO) value).getInStream());
+        }
+        else { // should be a RubyString
+            final ByteList blob = value.asString().getByteList();
+            statement.setBinaryStream(index,
+                new ByteArrayInputStream(blob.unsafeBytes(), blob.getBegin(), blob.getRealSize()),
+                blob.getRealSize() // length
+            );
         }
     }
 
@@ -211,250 +261,178 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         super.setTimestampParameter(context, connection, statement, index, value, column, type);
     }
 
-    private static final ByteList INTERVAL =
-        new ByteList( new byte[] { 'i','n','t','e','r','v','a','l' }, false );
-
-    private static final ByteList ARRAY_END = new ByteList( new byte[] { '[',']' }, false );
-
     @Override
-    protected void setStringParameter(final ThreadContext context,
+    protected void setObjectParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
-        final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        final RubyString sqlType;
-        if ( column != null && ! column.isNil() ) {
-            sqlType = (RubyString) column.callMethod(context, "sql_type");
-        }
-        else {
-            sqlType = null;
-        }
-
-        if ( value.isNil() ) {
-            if ( rawArrayType == Boolean.TRUE ) { // array's type is :string
-                if ( sqlType != null && sqlType.getByteList().endsWith( ARRAY_END ) ) {
-                    statement.setNull(index, Types.ARRAY); return;
-                }
-                statement.setNull(index, type); return;
-            }
-            statement.setNull(index, Types.VARCHAR);
-        }
-        else {
-            final String valueStr = value.asString().toString();
-            if ( sqlType != null ) {
-                if ( rawArrayType == Boolean.TRUE && sqlType.getByteList().endsWith( ARRAY_END ) ) {
-                    final int oid = oid(context, column);
-                    final Array valueArr = new Jdbc4Array(connection.unwrap(BaseConnection.class), oid, valueStr);
-                    statement.setArray(index, valueArr); return;
+        final int index, IRubyObject value,
+        final IRubyObject attribute, final int type) throws SQLException {
+
+        final String columnType = attributeSQLType(context, attribute).asJavaString();
+
+        switch ( columnType ) {
+            case "bit":
+            case "bit_varying":
+                setBitStringParameter(statement, index, value);
+                break;
+
+            case "cidr":
+            case "citext":
+            case "hstore":
+            case "inet":
+            case "ltree":
+            case "macaddr":
+            case "tsvector":
+                setPGobjectParameter(statement, index, value, columnType);
+                break;
+
+            case "interval":
+                statement.setObject(index, new PGInterval(value.toString()));
+                break;
+
+            case "json":
+            case "jsonb":
+                setJsonParameter(context, statement, index, value, columnType);
+                break;
+
+            case "line":
+                statement.setObject(index, new PGline(value.toString()));
+                break;
+
+            case "lseg":
+                statement.setObject(index, new PGlseg(value.toString()));
+                break;
+
+            case "point":
+                statement.setObject(index, new PGpoint(value.toString()));
+                break;
+
+            case "uuid":
+                setUUIDParameter(statement, index, value);
+                break;
+
+            default:
+                if ( columnType.endsWith("range") ) {
+                    setRangeParameter(context, statement, index, value, columnType);
                 }
-                if ( sqlType.getByteList().startsWith( INTERVAL ) ) {
-                    statement.setObject( index, new PGInterval( valueStr ) ); return;
+                else {
+                    super.setObjectParameter(context, connection, statement, index, value, attribute, type);
                 }
-            }
-            statement.setString( index, valueStr );
         }
     }
 
-    private static int oid(final ThreadContext context, final IRubyObject column) {
-        // our column convention :
-        IRubyObject oid = column.getInstanceVariables().getInstanceVariable("@oid");
-        if ( oid == null || oid.isNil() ) { // only for user instantiated Column
-            throw new IllegalStateException("missing @oid for column: " + column.inspect());
-        }
-        return RubyFixnum.fix2int(oid);
-    }
-
-    @Override
-    protected void setObjectParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, Object value,
-        final IRubyObject column, final int type) throws SQLException {
-
-        final String columnType = column.callMethod(context, "type").asJavaString();
-
-        if ( columnType == (Object) "uuid" ) {
-            setUUIDParameter(statement, index, value);
-            return;
-        }
-
-        if ( columnType == (Object) "json" ) {
-            setJsonParameter(context, statement, index, value, column);
-            return;
-        }
-
-        if ( columnType == (Object) "tsvector" ) {
-            setTsVectorParameter(statement, index, value);
-            return;
-        }
-
-        if ( columnType == (Object) "cidr" || columnType == (Object) "inet"
-                || columnType == (Object) "macaddr" ) {
-            setAddressParameter(context, statement, index, value, column, columnType);
-            return;
-        }
-
-        if ( columnType != null && columnType.endsWith("range") ) {
-            setRangeParameter(context, statement, index, value, column, columnType);
-            return;
-        }
+    // value should be a ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bit::Data
+    private void setBitStringParameter(final PreparedStatement statement, final int index,
+        final IRubyObject value) throws SQLException {
 
-        super.setObjectParameter(context, connection, statement, index, value, column, type);
-    }
+        String valueForDB = value.toString();
+        int length = valueForDB.length();
 
-    private void setUUIDParameter(
-        final PreparedStatement statement, final int index,
-        Object value) throws SQLException {
-
-        if ( value instanceof IRubyObject ) {
-            final IRubyObject rubyValue = (IRubyObject) value;
-            if ( rubyValue.isNil() ) {
-                statement.setNull(index, Types.OTHER); return;
+        /*
+            This means that if somebody sets their binary string to be "111" it
+            will always be assumed to be in binary. This matches the AR (5.0) functionality.
+            If it is meant to be a hex string they should use "0x111".
+        */
+        if (length > 0 && !binaryStringPattern.matcher(valueForDB).matches()) {
+            StringBuilder builder = new StringBuilder(length * 4);
+            for (int i = 0; i < length; i++) {
+                builder.append(binaryStrings[Character.digit(valueForDB.charAt(i), 16)]);
             }
-        }
-        else if ( value == null ) {
-            statement.setNull(index, Types.OTHER); return;
+            valueForDB = builder.toString();
         }
 
-        final Object uuid = UUID.fromString( value.toString() );
-        statement.setObject(index, uuid);
+        setPGobjectParameter(statement, index, valueForDB, "bit");
     }
 
     private void setJsonParameter(final ThreadContext context,
         final PreparedStatement statement, final int index,
-        Object value, final IRubyObject column) throws SQLException {
-
-        if ( value instanceof IRubyObject ) {
-            final IRubyObject rubyValue = (IRubyObject) value;
-            if ( rubyValue.isNil() ) {
-                statement.setNull(index, Types.OTHER); return;
-            }
-            if (!isAr42(column)) { // Value has already been cast for AR42
-                value = column.getMetaClass().callMethod(context, "json_to_string", rubyValue);
-            }
-        }
-        else if ( value == null ) {
-            statement.setNull(index, Types.OTHER); return;
-        }
+        final IRubyObject value, final String columnType) throws SQLException {
 
         final PGobject pgJson = new PGobject();
-        pgJson.setType("json");
+        pgJson.setType(columnType);
         pgJson.setValue(value.toString());
         statement.setObject(index, pgJson);
     }
 
-    private void setTsVectorParameter(
-        final PreparedStatement statement, final int index,
-        Object value) throws SQLException {
-
-        if ( value instanceof IRubyObject ) {
-            final IRubyObject rubyValue = (IRubyObject) value;
-            if ( rubyValue.isNil() ) {
-                statement.setNull(index, Types.OTHER); return;
-            }
-        }
-        else if ( value == null ) {
-            statement.setNull(index, Types.OTHER); return;
-        }
-
-        final PGobject pgTsVector = new PGobject();
-        pgTsVector.setType("tsvector");
-        pgTsVector.setValue(value.toString());
-        statement.setObject(index, pgTsVector);
-    }
-
-    private void setAddressParameter(final ThreadContext context,
-        final PreparedStatement statement, final int index,
-        Object value, final IRubyObject column,
-        final String columnType) throws SQLException {
-
-        if ( value instanceof IRubyObject ) {
-            final IRubyObject rubyValue = (IRubyObject) value;
-            if ( rubyValue.isNil() ) {
-                statement.setNull(index, Types.OTHER); return;
-            }
-            if (!isAr42(column)) { // Value has already been cast for AR42
-                value = column.getMetaClass().callMethod(context, "cidr_to_string", rubyValue);
-            }
-        }
-        else if ( value == null ) {
-            statement.setNull(index, Types.OTHER); return;
-        }
+    private void setPGobjectParameter(final PreparedStatement statement, final int index,
+        final Object value, final String columnType) throws SQLException {
 
-        final PGobject pgAddress = new PGobject();
-        pgAddress.setType(columnType);
-        pgAddress.setValue(value.toString());
-        statement.setObject(index, pgAddress);
+        final PGobject param = new PGobject();
+        param.setType(columnType);
+        param.setValue(value.toString());
+        statement.setObject(index, param);
     }
 
     private void setRangeParameter(final ThreadContext context,
         final PreparedStatement statement, final int index,
-        final Object value, final IRubyObject column,
-        final String columnType) throws SQLException {
+        final IRubyObject value, final String columnType) throws SQLException {
 
-        final String rangeValue;
+        final String rangeValue = value.toString();
+        final Object pgRange;
 
-        if ( value instanceof IRubyObject ) {
-            final IRubyObject rubyValue = (IRubyObject) value;
-            if ( rubyValue.isNil() ) {
-                statement.setNull(index, Types.OTHER); return;
-            }
-            rangeValue = column.getMetaClass().callMethod(context, "range_to_string", rubyValue).toString();
-        }
-        else {
-            if ( value == null ) {
-                statement.setNull(index, Types.OTHER); return;
-            }
-            rangeValue = value.toString();
+        switch ( columnType ) {
+            case "daterange":
+                pgRange = new DateRangeType(rangeValue);
+                break;
+            case "tsrange":
+                pgRange = new TsRangeType(rangeValue);
+                break;
+            case "tstzrange":
+                pgRange = new TstzRangeType(rangeValue);
+                break;
+            case "int4range":
+                pgRange = new Int4RangeType(rangeValue);
+                break;
+            case "int8range":
+                pgRange = new Int8RangeType(rangeValue);
+                break;
+            default:
+                pgRange = new NumRangeType(rangeValue);
         }
 
-        final Object pgRange;
-        if ( columnType == (Object) "daterange" ) {
-            pgRange = new DateRangeType(rangeValue);
-        }
-        else if ( columnType == (Object) "tsrange" ) {
-            pgRange = new TsRangeType(rangeValue);
-        }
-        else if ( columnType == (Object) "tstzrange" ) {
-            pgRange = new TstzRangeType(rangeValue);
-        }
-        else if ( columnType == (Object) "int4range" ) {
-            pgRange = new Int4RangeType(rangeValue);
-        }
-        else if ( columnType == (Object) "int8range" ) {
-            pgRange = new Int8RangeType(rangeValue);
-        }
-        else { // if ( columnType == (Object) "numrange" )
-            pgRange = new NumRangeType(rangeValue);
-        }
         statement.setObject(index, pgRange);
     }
 
     @Override
-    protected String resolveArrayBaseTypeName(final ThreadContext context,
-        final Object value, final IRubyObject column, final int type) {
-        String sqlType = column.callMethod(context, "sql_type").toString();
-        if ( sqlType.startsWith("character varying") ) return "text";
-        final int index = sqlType.indexOf('('); // e.g. "character varying(255)"
-        if ( index > 0 ) sqlType = sqlType.substring(0, index);
-        return sqlType;
+    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 {
+
+        if ( attributeSQLType(context, attribute).isNil() ) {
+            /*
+                We have to check for a uuid here because in some cases
+                (for example,  when doing "exists?" checks, or with legacy binds)
+                ActiveRecord doesn't send us the actual type of the attribute
+                and Postgres won't compare a uuid column with a string
+            */
+            final String uuid = value.toString();
+
+            // Checking the length so we don't have the overhead of the regex unless it "looks" like a UUID
+            if ( uuid.length() == 36 && uuidPattern.matcher(uuid).matches() ) {
+                setUUIDParameter(statement, index, value);
+                return;
+            }
+        }
+
+        super.setStringParameter(context, connection, statement, index, value, attribute, type);
     }
 
-    private static final int HSTORE_TYPE = 100000 + 1111;
+    private void setUUIDParameter(final PreparedStatement statement,
+        final int index, final IRubyObject value) throws SQLException {
+
+        statement.setObject(index, UUID.fromString(value.toString()));
+    }
 
     @Override
-    protected int jdbcTypeFor(final ThreadContext context, final Ruby runtime,
-        final IRubyObject column, final Object value) throws SQLException {
-        // NOTE: likely wrong but native adapters handles this thus we should
-        // too - used from #table_exists? `binds << [ nil, schema ] if schema`
-        if ( column == null || column.isNil() ) return Types.VARCHAR; // assume type == :string
-        final int type = super.jdbcTypeFor(context, runtime, column, value);
-        /*
-        if ( type == Types.OTHER ) {
-            final IRubyObject columnType = column.callMethod(context, "type");
-            if ( "hstore" == (Object) columnType.asJavaString() ) {
-                return HSTORE_TYPE;
-            }
-        } */
-        return type;
+    protected Integer jdbcTypeFor(final String type) {
+
+        Integer typeValue = POSTGRES_JDBC_TYPE_FOR.get(type);
+
+        if ( typeValue != null ) {
+            return typeValue;
+        }
+
+        return super.jdbcTypeFor(type);
     }
 
     /**
@@ -498,12 +476,8 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         if ( rawDateTime != null && rawDateTime.booleanValue() ) return strValue;
 
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
-        if ( usesType(runtime) ) {
-            return typeCastFromDatabase(context, adapter, runtime.newSymbol("timestamp"), strValue);
-        }
 
-        if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
-        return adapter.callMethod(context, "_string_to_timestamp", strValue);
+        return typeCastFromDatabase(context, adapter, runtime.newSymbol("timestamp"), strValue);
     }
 
     @Override