activerecord-jdbc-alt-adapter 50.3.0-java

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

@@ -0,0 +1,157 @@
+/*
+ * 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 org.jruby.util.ByteList;
+
+/**
+ * Based on JDBC PostgreSQL driver's <code>org.postgresql.util.PGbytea</code>.
+ *
+ * @author kares
+ */
+abstract class ByteaUtils {
+
+    /*
+     * Converts a PG bytea raw value (i.e. the raw binary representation
+     * of the bytea data type) into a java byte[]
+     */
+    static ByteList 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 new ByteList(toBytesHexEscaped(s, off, len), false);
+    }
+
+    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] );
+            // squid:S3034
+            // Raw byte values should not be used in bitwise operations in combination with shifts
+            out[i] = (byte) ((b1 << 4) | (b2 & 0xff));
+        }
+        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 ByteList 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) '\\' ) {
+                    if (s[ ++i ] == (byte) '\\') {
+                        --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;
+            }
+        }
+
+        return new ByteList(out, 0, pos, false);
+    }
+
+    /*
+     * Converts a java byte[] into a PG bytea string (i.e. the text
+     * representation of the bytea data type)
+     */
+    static ByteList toStr(final byte[] p_buf, final int off, final int len)  {
+        ByteList l_strbuf = new ByteList(2 * p_buf.length);
+        for (int i = off; i < off + len; 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 character with the form \000
+                l_strbuf.append((byte)'\\');
+                l_strbuf.append((((l_int >> 6) & 0x3) + 48));
+                l_strbuf.append((((l_int >> 3) & 0x7) + 48));
+                l_strbuf.append(((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((byte)'\\').append((byte)'\\');
+            }
+            else {
+                //other characters are left alone
+                l_strbuf.append(p_buf[i]);
+            }
+        }
+        return l_strbuf;
+    }
+
+}

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/PostgreSQLModule.java

@@ -0,0 +1,77 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2014 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 static arjdbc.util.QuotingUtils.quoteCharAndDecorateWith;
+import static arjdbc.util.QuotingUtils.quoteCharWith;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * ArJdbc::PostgreSQL
+ *
+ * @author kares
+ */
+public class PostgreSQLModule {
+
+    public static RubyModule load(final RubyModule arJdbc) {
+        RubyModule postgreSQL = arJdbc.defineModuleUnder("PostgreSQL");
+        postgreSQL.defineAnnotatedMethods( PostgreSQLModule.class );
+        return postgreSQL;
+    }
+
+    public static RubyModule load(final Ruby runtime) {
+        return load( arjdbc.ArJdbcModule.get(runtime) );
+    }
+
+    @JRubyMethod(name = "quote_column_name", required = 1)
+    public static IRubyObject quote_column_name(
+            final ThreadContext context,
+            final IRubyObject self,
+            final IRubyObject string) { // %("#{name.to_s.gsub("\"", "\"\"")}")
+        return quoteCharAndDecorateWith(context, string.asString(), '"', '"', (byte) '"', (byte) '"');
+    }
+
+    @JRubyMethod(name = "quote_string", required = 1)
+    public static IRubyObject quote_string(
+            final ThreadContext context,
+            final IRubyObject self,
+            final IRubyObject string) {
+        // NOTE: since AR 5.0 standard_conforming_strings are always set - no need for extra quoting
+        return quoteCharWith(context, string.asString(), '\'', '\''); // string.gsub("'", "''")
+    }
+
+    @JRubyMethod(name = "unescape_bytea", meta = true)
+    public static RubyString unescape_bytea(final ThreadContext context, final IRubyObject self, final IRubyObject escaped) {
+        final ByteList bytes = ((RubyString) escaped).getByteList();
+        return RubyString.newString(context.runtime, ByteaUtils.toBytes(bytes.unsafeBytes(), bytes.getBegin(), bytes.getRealSize()));
+    }
+
+}

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

@@ -0,0 +1,192 @@
+package arjdbc.postgresql;
+
+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 org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.Helpers;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/*
+ * This class mimics the PG:Result class enough to get by
+ */
+public class PostgreSQLResult extends JdbcResult {
+
+    // These are needed when generating an AR::Result
+    private final ResultSetMetaData resultSetMetaData;
+
+    /********* JRuby compat methods ***********/
+
+    static RubyClass createPostgreSQLResultClass(Ruby runtime, RubyClass postgreSQLConnection) {
+        RubyClass rubyClass = postgreSQLConnection.defineClassUnder("Result", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+        rubyClass.defineAnnotatedMethods(PostgreSQLResult.class);
+        rubyClass.includeModule(runtime.getEnumerable());
+        return rubyClass;
+    }
+
+    /**
+     * Generates a new PostgreSQLResult object for the given result set
+     * @param context current thread context
+     * @param clazz metaclass for this result object
+     * @param resultSet the set of results that should be returned
+     * @return an instantiated result object
+     * @throws SQLException throws!
+     */
+    static PostgreSQLResult newResult(ThreadContext context,  RubyClass clazz, PostgreSQLRubyJdbcConnection connection,
+                                      ResultSet resultSet) throws SQLException {
+        return new PostgreSQLResult(context, clazz, connection, resultSet);
+    }
+
+    /********* End JRuby compat methods ***********/
+
+    private PostgreSQLResult(ThreadContext context, RubyClass clazz, RubyJdbcConnection connection,
+                             ResultSet resultSet) throws SQLException {
+        super(context, clazz, connection, resultSet);
+
+        resultSetMetaData = resultSet.getMetaData();
+    }
+
+    /**
+     * Generates a type map to be given to the AR::Result object
+     * @param context current thread context
+     * @return RubyHash RubyString - column name, Type::Value - type object)
+     * @throws SQLException if it fails to get the field
+     */
+    @Override
+    protected IRubyObject columnTypeMap(final ThreadContext context) throws SQLException {
+        Ruby runtime = context.runtime;
+        RubyHash types = RubyHash.newHash(runtime);
+        int columnCount = columnNames.length;
+
+        IRubyObject adapter = connection.adapter(context);
+        for (int i = 0; i < columnCount; i++) {
+            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.newString(typeName),
+                    runtime.newFixnum(mod),
+                    name);
+
+            if (!type.isNil()) types.fastASet(name, type);
+        }
+
+        return types;
+    }
+
+    /**
+     * This is to support the Enumerable module.
+     * This is needed when setting up the type maps so the Enumerable methods work
+     * @param context the thread this is being executed on
+     * @param block which may handle each result
+     * @return this object or RubyNil
+     */
+    @JRubyMethod
+    public IRubyObject each(ThreadContext context, Block block) {
+        // At this point we don't support calling this without a block
+        if (block.isGiven()) {
+            if (tuples == null) {
+                populateTuples(context);
+            }
+
+            for (RubyHash tuple : tuples) {
+                block.yield(context, tuple);
+            }
+
+            return this;
+        } else {
+            return context.nil;
+        }
+    }
+
+    private RubyClass getBinaryDataClass(final ThreadContext context) {
+        return ((RubyModule) context.runtime.getModule("ActiveModel").getConstantAt("Type")).getClass("Binary").getClass("Data");
+    }
+
+    private boolean isBinaryType(final int type) {
+        return type == Types.BLOB || type == Types.BINARY || type == Types.VARBINARY || type == Types.LONGVARBINARY;
+    }
+
+    /**
+     * Gives the number of rows to be returned.
+     * currently defined so we match existing returned results
+     * @param context current thread contect
+     * @return <code>Fixnum</code>
+     */
+    @JRubyMethod
+    public IRubyObject length(final ThreadContext context) {
+        return values.length();
+    }
+
+    /**
+     * Creates an <code>ActiveRecord::Result</code> with the data from this result.
+     * Overriding the base method so we can modify binary data columns first to mark them
+     * as already unencoded
+     * @param context current thread context
+     * @return ActiveRecord::Result object with the data from this result set
+     * @throws SQLException can be caused by postgres generating its type map
+     */
+    @Override @SuppressWarnings("unchecked")
+    public IRubyObject toARResult(final ThreadContext context) throws SQLException {
+        RubyClass BinaryDataClass = null;
+        int rowCount = 0;
+
+        // This is destructive, but since this is typically the final
+        // use of the rows I'm going to leave it this way unless it becomes an issue
+        for (int columnIndex = 0; columnIndex < columnTypes.length; columnIndex++) {
+            if (isBinaryType(columnTypes[columnIndex])) {
+                // Convert the values in this column to ActiveModel::Type::Binary::Data instances
+                // so AR knows it has already been unescaped
+                if (BinaryDataClass == null) {
+                    BinaryDataClass = getBinaryDataClass(context);
+                    rowCount = values.getLength();
+                }
+                for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                    RubyArray row = (RubyArray) values.eltInternal(rowIndex);
+                    IRubyObject value = row.eltInternal(columnIndex);
+                    if (value != context.nil) {
+                        row.eltInternalSet(columnIndex, BinaryDataClass.newInstance(context, value, Block.NULL_BLOCK));
+                    }
+                }
+            }
+        }
+
+        return super.toARResult(context);
+    }
+
+    /**
+     * Returns an array of arrays of the values in the result.
+     * This is defined in PG::Result and is used by some Rails tests
+     * @return IRubyObject RubyArray of RubyArray of values
+     */
+    @JRubyMethod
+    public IRubyObject values() {
+        return values;
+    }
+}