activerecord-jdbc-adapter-ficoh 1.3.21-java

data/src/java/arjdbc/postgresql/ByteaUtils.java

@@ -0,0 +1,171 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2015 Karol Bucek
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.postgresql;
+
+/**
+ * Based on JDBC PostgreSQL driver's <code>org.postgresql.util.PGbytea</code>.
+ *
+ * @author kares
+ */
+abstract class ByteaUtils {
+
+    //static byte[] toBytes(final byte[] s) {
+    //    return toBytes(s, 0, s.length);
+    //}
+
+    /*
+     * Converts a PG bytea raw value (i.e. the raw binary representation
+     * of the bytea data type) into a java byte[]
+     */
+    static byte[] toBytes(final byte[] s, final int off, final int len) {
+        // Starting with PG 9.0, a new hex format is supported
+        // that starts with "\x".  Figure out which format we're
+        // dealing with here.
+        //
+        if ( s.length < 2 || s[0] != '\\' || s[1] != 'x' ) {
+            return toBytesOctalEscaped(s, off, len);
+        }
+        return toBytesHexEscaped(s, off, len);
+    }
+
+    private static byte[] toBytesHexEscaped(final byte[] s, final int off, final int len) {
+        final byte[] out = new byte[(len - 2) / 2];
+        for (int i = 0; i < out.length; i++) {
+            final int j = off + (2 + i * 2);
+            byte b1 = hexByte( s[j] );
+            byte b2 = hexByte( s[j + 1] );
+            out[i] = (byte) ((b1 << 4) | b2);
+        }
+        return out;
+    }
+
+    private static byte hexByte(final byte b) {
+        // 0-9 == 48-57
+        if (b <= 57) return (byte) (b - 48);
+
+        // a-f == 97-102
+        if (b >= 97) return (byte) (b - 97 + 10);
+
+        // A-F == 65-70
+        return (byte) (b - 65 + 10);
+    }
+
+    private static final int MAX_3_BUFF_SIZE = 2 * 1024 * 1024;
+
+    private static byte[] toBytesOctalEscaped(final byte[] s, final int off, final int len) {
+        final byte[] out;
+        final int end = off + len;
+        int correctSize = len;
+        if ( len > MAX_3_BUFF_SIZE ) {
+            // count backslash escapes, they will be either
+            // backslashes or an octal escape \\ or \003
+            //
+            for ( int i = off; i < end; ++i ) {
+                if ( s[i] == '\\' ) {
+                    byte next = s[ ++i ];
+                    if (next == '\\') {
+                        --correctSize;
+                    }
+                    else {
+                        correctSize -= 3;
+                    }
+                }
+            }
+            out = new byte[correctSize];
+        }
+        else {
+            out = new byte[len];
+        }
+
+        int pos = 0;
+        for ( int i = off; i < end; i++ ) {
+            final byte b = s[i];
+            if ( b == (byte) '\\' ) {
+                final byte b1 = s[++i];
+                if ( b1 == (byte) '\\' ) { // escaped \
+                    out[ pos++ ] = (byte) '\\';
+                }
+                else {
+                    int thebyte = (b1 - 48) * 64 + (s[++i] - 48) * 8 + (s[++i] - 48);
+                    if ( thebyte > 127 ) thebyte -= 256;
+                    out[ pos++ ] = (byte) thebyte;
+                }
+            }
+            else {
+                out[ pos++ ] = b;
+            }
+        }
+
+        if ( pos == correctSize ) return out;
+
+        final byte[] out2 = new byte[pos];
+        System.arraycopy(out, 0, out2, 0, pos);
+        return out2;
+    }
+
+    /*
+     * Converts a java byte[] into a PG bytea string (i.e. the text
+     * representation of the bytea data type)
+     */
+    /*
+    public static String toPGString(byte[] p_buf)  {
+        if (p_buf == null)
+            return null;
+        StringBuffer l_strbuf = new StringBuffer(2 * p_buf.length);
+        for (int i = 0; i < p_buf.length; i++)
+        {
+            int l_int = (int)p_buf[i];
+            if (l_int < 0)
+            {
+                l_int = 256 + l_int;
+            }
+            //we escape the same non-printable characters as the backend
+            //we must escape all 8bit characters otherwise when convering
+            //from java unicode to the db character set we may end up with
+            //question marks if the character set is SQL_ASCII
+            if (l_int < 040 || l_int > 0176)
+            {
+                //escape charcter with the form \000, but need two \\ because of
+                //the Java parser
+                l_strbuf.append("\\");
+                l_strbuf.append((char)(((l_int >> 6) & 0x3) + 48));
+                l_strbuf.append((char)(((l_int >> 3) & 0x7) + 48));
+                l_strbuf.append((char)((l_int & 0x07) + 48));
+            }
+            else if (p_buf[i] == (byte)'\\')
+            {
+                //escape the backslash character as \\, but need four \\\\ because
+                //of the Java parser
+                l_strbuf.append("\\\\");
+            }
+            else
+            {
+                //other characters are left alone
+                l_strbuf.append((char)p_buf[i]);
+            }
+        }
+        return l_strbuf.toString();
+    } */
+
+}

data/src/java/arjdbc/postgresql/DriverImplementation.java

@@ -0,0 +1,78 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2015 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.postgresql;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Driver specifics hidden behind curtains.
+ * 
+ * @author kares
+ */
+interface DriverImplementation {
+
+    Connection newConnection(final Connection connection) throws SQLException ;
+
+    //
+
+    IRubyObject objectToRuby(final ThreadContext context,
+        final ResultSet resultSet, final int column) throws SQLException ;
+
+    // prepared statements :
+
+    boolean setStringParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, final IRubyObject value,
+        final IRubyObject column, final int type) throws SQLException ;
+
+    boolean setTimestampParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, IRubyObject value,
+        final IRubyObject column, final int type) throws SQLException ;
+
+    boolean setObjectParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, Object value,
+        final IRubyObject column, final int type) throws SQLException ;
+
+    /*
+    public void setJsonParameter(final ThreadContext context,
+            final PreparedStatement statement, final int index,
+            Object value, final IRubyObject column) throws SQLException ;
+
+    public void setRangeParameter(final ThreadContext context,
+        final PreparedStatement statement, final int index,
+        final Object value, final IRubyObject column,
+        final String columnType) throws SQLException ;
+
+    public void setTsVectorParameter(
+        final PreparedStatement statement, final int index,
+        Object value) throws SQLException ; */
+
+}

data/src/java/arjdbc/postgresql/PGDriverImplementation.java

@@ -0,0 +1,535 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2015 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.postgresql;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.Map;
+import java.util.UUID;
+
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.SafePropertyAccessor;
+
+import org.postgresql.PGConnection;
+import org.postgresql.PGStatement;
+import org.postgresql.core.BaseConnection;
+import org.postgresql.jdbc4.Jdbc4Array;
+import org.postgresql.util.PGInterval;
+import org.postgresql.util.PGobject;
+
+import arjdbc.util.NumberUtils;
+import static arjdbc.jdbc.RubyJdbcConnection.isAr42;
+
+/**
+ * Official JDBC driver internals.
+ *
+ * @author kares
+ */
+public final class PGDriverImplementation implements DriverImplementation {
+
+    private static final boolean initConnection;
+    static {
+        String initConn = SafePropertyAccessor.getProperty("arjdbc.postgresql.connection.init", "true");
+        initConnection = Boolean.parseBoolean(initConn);
+    }
+
+    public static void initConnection(final Connection connection) throws SQLException {
+        final PGConnection pgConnection;
+        if ( connection instanceof PGConnection ) {
+            pgConnection = (PGConnection) connection;
+        }
+        else {
+            pgConnection = connection.unwrap(PGConnection.class);
+        }
+        pgConnection.addDataType("daterange", DateRangeType.class);
+        pgConnection.addDataType("tsrange",   TsRangeType.class);
+        pgConnection.addDataType("tstzrange", TstzRangeType.class);
+        pgConnection.addDataType("int4range", Int4RangeType.class);
+        pgConnection.addDataType("int8range", Int8RangeType.class);
+        pgConnection.addDataType("numrange",  NumRangeType.class);
+    }
+
+    public Connection newConnection(final Connection connection) throws SQLException {
+        if ( initConnection ) initConnection(connection);
+        return connection;
+    }
+
+    public IRubyObject objectToRuby(final ThreadContext context,
+        final ResultSet resultSet, final int column) throws SQLException {
+
+        final Object object = resultSet.getObject(column);
+
+        if ( object == null ) return context.nil;
+
+        final Class<?> objectClass = object.getClass();
+        if ( objectClass == UUID.class ) {
+            return RubyString.newString( context.runtime, object.toString() );
+        }
+
+        if ( objectClass == PGInterval.class ) {
+            if ( PostgreSQLRubyJdbcConnection.rawIntervalType ) {
+                final String value = ((PGInterval) object).getValue();
+                return RubyString.newString( context.runtime, value );
+            }
+            return RubyString.newString( context.runtime, formatInterval(object) );
+        }
+
+        if ( object instanceof PGobject ) {
+            // PG 9.2 JSON type will be returned here as well
+            return RubyString.newString( context.runtime, object.toString() );
+        }
+
+        if ( object instanceof Map ) { // hstore
+            if ( PostgreSQLRubyJdbcConnection.rawHstoreType == Boolean.TRUE ) {
+                return RubyString.newString( context.runtime, resultSet.getString(column) );
+            }
+            // by default we avoid double parsing by driver and than column :
+            final RubyHash rubyObject = RubyHash.newHash(context.runtime);
+            rubyObject.putAll((Map) object); // converts keys/values to ruby
+            return rubyObject;
+        }
+
+        return JavaUtil.convertJavaToRuby(context.runtime, object);
+    }
+
+    private static final byte[] _years_ =  { ' ','y','e','a','r','s',' ' };
+    private static final byte[] _months_ =  { ' ','m','o','n','t','h','s',' ' };
+    private static final byte[] _days_ =  { ' ','d','a','y','s',' ' };
+
+    // NOTE: do not use PG classes in the API so that loading is delayed ! still?
+    private static ByteList formatInterval(final Object object) {
+        final PGInterval interval = (PGInterval) object;
+
+        final ByteList str = new ByteList(32);
+
+        final int years = interval.getYears();
+        if ( years != 0 ) {
+            NumberUtils.appendInteger(years, str).append(_years_);
+        }
+        final int months = interval.getMonths();
+        if ( months != 0 ) {
+            NumberUtils.appendInteger(months, str).append(_months_);
+        }
+        final int days = interval.getDays();
+        if ( days != 0 ) {
+            NumberUtils.appendInteger(days, str).append(_days_);
+        }
+        final int hours = interval.getHours();
+        final int mins = interval.getMinutes();
+        final int secs = (int) interval.getSeconds();
+        if ( hours != 0 || mins != 0 || secs != 0 ) { // xx:yy:zz if not all 00
+            if ( hours < 10 ) str.append('0');
+            NumberUtils.appendInteger(hours, str).append(':');
+            if ( mins < 10 ) str.append('0');
+            NumberUtils.appendInteger(mins, str).append(':');
+            if ( secs < 10 ) str.append('0');
+            NumberUtils.appendInteger(secs, str);
+        }
+        else {
+            final int size = str.getRealSize();
+            if ( size > 1 ) str.setRealSize(size - 1); // " " at the end
+        }
+
+        return str;
+    }
+
+    public boolean setStringParameter(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 ( PostgreSQLRubyJdbcConnection.rawArrayType == Boolean.TRUE ) { // array's type is :string
+                if ( sqlType != null && arrayLike(sqlType) ) {
+                    statement.setNull(index, Types.ARRAY); return true;
+                }
+                statement.setNull(index, type); return true;
+            }
+            statement.setNull(index, Types.VARCHAR);
+        }
+        else {
+            final String valueStr = value.asString().toString();
+            if ( sqlType != null ) {
+                if ( PostgreSQLRubyJdbcConnection.rawArrayType == Boolean.TRUE && arrayLike(sqlType) ) {
+                    final int oid = PostgreSQLRubyJdbcConnection.oid(context, column);
+                    Jdbc4Array valueArr = new Jdbc4Array(connection.unwrap(BaseConnection.class), oid, valueStr);
+                    statement.setArray(index, valueArr); return true;
+                }
+                if ( sqlType.getByteList().startsWith( INTERVAL ) ) {
+                    statement.setObject( index, new PGInterval( valueStr ) ); return true;
+                }
+            }
+            statement.setString( index, valueStr );
+        }
+
+        return true;
+    }
+
+    private static final ByteList INTERVAL =
+        new ByteList( new byte[] { 'i','n','t','e','r','v','a','l' }, false );
+
+    private static boolean arrayLike(final RubyString sqlType) {
+        final int size = sqlType.size(); // does bytes.getRealSize()
+        if ( size <= 2 ) return false;
+        final ByteList bytes = sqlType.getByteList();
+        return bytes.charAt(size - 2) == '[' && bytes.charAt(size - 1) == ']';
+    }
+
+    // to handle infinity timestamp values
+    public boolean 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 instanceof RubyFloat ) {
+            final double doubleValue = ( (RubyFloat) value ).getValue();
+            if ( Double.isInfinite(doubleValue) ) {
+                final Timestamp timestamp;
+                if ( doubleValue < 0 ) {
+                    timestamp = new Timestamp(PGStatement.DATE_NEGATIVE_INFINITY);
+                }
+                else {
+                    timestamp = new Timestamp(PGStatement.DATE_POSITIVE_INFINITY);
+                }
+                statement.setTimestamp( index, timestamp );
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean 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 true;
+        }
+
+        if ( columnType == (Object) "json" ) {
+            setJsonParameter(context, statement, index, value, column, false);
+            return true;
+        }
+        if ( columnType == (Object) "jsonb" ) {
+            setJsonParameter(context, statement, index, value, column, true);
+            return true;
+        }
+
+        if ( columnType == (Object) "tsvector" ) {
+            setTsVectorParameter(statement, index, value);
+            return true;
+        }
+
+        if ( columnType == (Object) "hstore" ) {
+            setHstoreParameter(context, statement, index, value, column);
+            return true;
+        }
+
+        if ( columnType == (Object) "cidr" || columnType == (Object) "inet"
+                || columnType == (Object) "macaddr" ) {
+            setAddressParameter(context, statement, index, value, column, columnType);
+            return true;
+        }
+
+        if ( columnType != null && columnType.endsWith("range") ) {
+            setRangeParameter(context, statement, index, value, column, columnType);
+            return true;
+        }
+
+        return false;
+    }
+
+    static 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;
+            }
+        }
+        else if ( value == null ) {
+            statement.setNull(index, Types.OTHER); return;
+        }
+
+        final Object uuid = UUID.fromString( value.toString() );
+        statement.setObject(index, uuid);
+    }
+
+    static 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;
+        }
+
+        final PGobject pgAddress = new PGobject();
+        pgAddress.setType(columnType);
+        pgAddress.setValue(value.toString());
+        statement.setObject(index, pgAddress);
+    }
+
+    static void setJsonParameter(final ThreadContext context,
+        final PreparedStatement statement, final int index,
+        Object value, final IRubyObject column, final boolean jsonb) throws SQLException {
+
+        if ( value instanceof IRubyObject ) {
+            final IRubyObject rubyValue = (IRubyObject) value;
+            if ( rubyValue.isNil() ) {
+                statement.setNull(index, Types.OTHER); return;
+            }
+            if ( ! isAr42(column) ) {
+                final String method = jsonb ? "jsonb_to_string" : "json_to_string";
+                value = column.getMetaClass().callMethod(context, method, rubyValue);
+            }
+        }
+        else if ( value == null ) {
+            statement.setNull(index, Types.OTHER); return;
+        }
+
+        final PGobject pgJson = new PGobject();
+        pgJson.setType(jsonb ? "jsonb" : "json");
+        pgJson.setValue(value.toString());
+        statement.setObject(index, pgJson);
+    }
+
+    static void setHstoreParameter(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 = column.getMetaClass().callMethod(context, "hstore_to_string", rubyValue);
+            }
+        }
+        else if ( value == null ) {
+            statement.setNull(index, Types.OTHER); return;
+        }
+
+        final PGobject hstore = new PGobject();
+        hstore.setType("hstore");
+        hstore.setValue(value.toString());
+        statement.setObject(index, hstore);
+    }
+
+    static 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);
+    }
+
+    static void setRangeParameter(final ThreadContext context,
+        final PreparedStatement statement, final int index,
+        final Object value, final IRubyObject column,
+        final String columnType) throws SQLException {
+
+        final String rangeValue;
+
+        if ( value instanceof IRubyObject ) {
+            final IRubyObject rubyValue = (IRubyObject) value;
+            if ( rubyValue.isNil() ) {
+                statement.setNull(index, Types.OTHER); return;
+            }
+            if ( isAr42(column) ) {
+                rangeValue = rubyValue.toString(); // expect a type_casted RubyString
+            }
+            else {
+                rangeValue = column.getMetaClass().callMethod(context, "range_to_string", rubyValue).toString();
+            }
+        }
+        else {
+            if ( value == null ) {
+                statement.setNull(index, Types.OTHER); return;
+            }
+            rangeValue = value.toString();
+        }
+
+        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);
+    }
+
+    // NOTE: without these custom registered Postgre (driver) types
+    // ... we can not set range parameters in prepared statements !
+
+    public static final class DateRangeType extends PGobject {
+
+        private static final long serialVersionUID = -5378414736244196691L;
+
+        public DateRangeType() {
+            setType("daterange");
+        }
+
+        public DateRangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+    public static final class TsRangeType extends PGobject {
+
+        private static final long serialVersionUID = -2991390995527988409L;
+
+        public TsRangeType() {
+            setType("tsrange");
+        }
+
+        public TsRangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+    public static final class TstzRangeType extends PGobject {
+
+        private static final long serialVersionUID = 6492535255861743334L;
+
+        public TstzRangeType() {
+            setType("tstzrange");
+        }
+
+        public TstzRangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+    public static final class Int4RangeType extends PGobject {
+
+        private static final long serialVersionUID = 4490562039665289763L;
+
+        public Int4RangeType() {
+            setType("int4range");
+        }
+
+        public Int4RangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+    public static final class Int8RangeType extends PGobject {
+
+        private static final long serialVersionUID = -1458706215346897102L;
+
+        public Int8RangeType() {
+            setType("int8range");
+        }
+
+        public Int8RangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+    public static final class NumRangeType extends PGobject {
+
+        private static final long serialVersionUID = 5892509252900362510L;
+
+        public NumRangeType() {
+            setType("numrange");
+        }
+
+        public NumRangeType(final String value) throws SQLException {
+            this();
+            this.value = value;
+        }
+
+    }
+
+}