neo-activerecord-jdbc-adapter 5.0.pre2

data/src/java/arjdbc/jdbc/SQLBlock.java

@@ -0,0 +1,54 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2012-2013 Karol Bucek <self@kares.org>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * 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.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.jdbc;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+/**
+ * @deprecated implement a {@link Callable} directly instead.
+ *
+ * @author nicksieger
+ */
+@Deprecated
+public abstract class SQLBlock implements Callable {
+
+    /**
+     * @see Callable#call(Connection)
+     */
+    public abstract Object call(final Connection connection) throws SQLException;
+
+    public void close(Statement statement) {
+        RubyJdbcConnection.close(statement);
+    }
+
+    public void close(ResultSet resultSet) {
+        RubyJdbcConnection.close(resultSet);
+    }
+}

data/src/java/arjdbc/mssql/MSSQLModule.java

@@ -0,0 +1,102 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 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.mssql;
+
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+import static arjdbc.util.QuotingUtils.quoteCharWith;
+import static arjdbc.util.QuotingUtils.quoteSingleQuotesWithFallback;
+
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * ArJdbc::MSSQL
+ *
+ * @author kares
+ */
+public class MSSQLModule {
+
+    public static RubyModule load(final RubyModule arJdbc) {
+        RubyModule mssql = arJdbc.defineModuleUnder("MSSQL");
+        mssql.defineAnnotatedMethods( MSSQLModule.class );
+        return mssql;
+    }
+
+    @JRubyMethod(name = "quote_string", required = 1)
+    public static IRubyObject quote_string(final ThreadContext context,
+        final IRubyObject self, final IRubyObject string) {
+        return quoteSingleQuotesWithFallback(context, string);
+    }
+
+    @JRubyMethod(name = "quoted_true", required = 0)
+    public static IRubyObject quoted_true(final ThreadContext context,
+        final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_1);
+    }
+
+    @JRubyMethod(name = "quoted_false", required = 0)
+    public static IRubyObject quoted_false(final ThreadContext context,
+        final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_0);
+    }
+
+    // part =~ /^\[.*\]$/ ? part : "[#{part.gsub(']', ']]')}]"
+    @SuppressWarnings("deprecation")
+    @JRubyMethod(required = 1, visibility = Visibility.PRIVATE)
+    public static IRubyObject quote_name_part(final ThreadContext context,
+        final IRubyObject self, final IRubyObject part) {
+
+        final RubyString partString = ((RubyString) part);
+        final ByteList str = partString.getByteList();
+        if ( str.charAt(0) == '[' && str.charAt(str.length() - 1) == ']' ) {
+            return part; // part =~ /^\[.*\]$/ ? part
+        }
+        final RubyString quotedString = // part.gsub(']', ']]')
+            quoteCharWith(context, partString, ']', ']', 1, 4 + 1);
+        if ( quotedString == partString ) {
+            final int realSize = str.getRealSize();
+            final ByteList quoted = new ByteList(
+                new byte[realSize + 2], partString.getEncoding(), false
+            );
+            quoted.begin = 0; quoted.realSize = 0;
+            quoted.append('[');
+            quoted.append(str.unsafeBytes(), str.getBegin(), realSize);
+            quoted.append(']');
+            return context.getRuntime().newString(quoted);
+        }
+        // we got a new string with a reserve of 1 byte front and back :
+        final ByteList quoted = quotedString.getByteList();
+        quoted.begin = 0; // setBegin invalidates
+        quoted.bytes[0] = '['; quoted.realSize++;
+        quoted.append(']');
+        return quotedString;
+    }
+
+}

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

@@ -0,0 +1,195 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2012-2013 Karol Bucek <self@kares.org>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * 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.
+ ***** END LICENSE BLOCK *****/
+package arjdbc.mssql;
+
+import arjdbc.jdbc.Callable;
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+
+import org.jcodings.specific.UTF8Encoding;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
+    private static final long serialVersionUID = -745716565005219263L;
+
+    protected MSSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createMSSQLJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        final RubyClass clazz = getConnectionAdapters(runtime). // ActiveRecord::ConnectionAdapters
+            defineClassUnder("MSSQLJdbcConnection", jdbcConnection, ALLOCATOR);
+        clazz.defineAnnotatedMethods(MSSQLRubyJdbcConnection.class);
+        getConnectionAdapters(runtime).setConstant("MssqlJdbcConnection", clazz); // backwards-compat
+        return clazz;
+    }
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new MSSQLRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    private static final byte[] EXEC = new byte[] { 'e', 'x', 'e', 'c' };
+
+    @JRubyMethod(name = "exec?", required = 1, meta = true, frame = false)
+    public static IRubyObject exec_p(ThreadContext context, IRubyObject self, IRubyObject sql) {
+        final ByteList sqlBytes = sql.convertToString().getByteList();
+        return context.getRuntime().newBoolean( startsWithIgnoreCase(sqlBytes, EXEC) );
+    }
+
+    @Override
+    protected RubyArray mapTables(final Ruby runtime, final DatabaseMetaData metaData,
+            final String catalog, final String schemaPattern, final String tablePattern,
+            final ResultSet tablesSet) throws SQLException, IllegalStateException {
+
+        final RubyArray tables = runtime.newArray();
+
+        while ( tablesSet.next() ) {
+            String schema = tablesSet.getString(TABLES_TABLE_SCHEM);
+            if ( schema != null ) schema = schema.toLowerCase();
+            // Under MS-SQL, don't return system tables/views unless explicitly asked for :
+            if ( schemaPattern == null &&
+                ( "sys".equals(schema) || "information_schema".equals(schema) ) ) {
+                continue;
+            }
+            String name = tablesSet.getString(TABLES_TABLE_NAME);
+            if ( name == null ) {
+                // NOTE: seems there's a jTDS but when doing getColumns while
+                // EXPLAIN is on (e.g. `SET SHOWPLAN_TEXT ON`) not returning
+                // correct result set with table info (null NAME, invalid CAT)
+                throw new IllegalStateException("got null name while matching table(s): [" +
+                    catalog + "." + schemaPattern + "." + tablePattern + "] check " +
+                    "if this happened during EXPLAIN (SET SHOWPLAN_TEXT ON) if so please try " +
+                    "turning it off using the system property 'arjdbc.mssql.explain_support.disabled=true' " +
+                    "or programatically by changing: `ArJdbc::MSSQL::ExplainSupport::DISABLED`");
+            }
+            name = caseConvertIdentifierForRails(metaData, name);
+            tables.add(RubyString.newUnicodeString(runtime, name));
+        }
+        return tables;
+    }
+
+    @Override
+    protected RubyArray mapColumnsResult(final ThreadContext context,
+        final DatabaseMetaData metaData, final TableName components, final ResultSet results)
+        throws SQLException {
+
+        final RubyClass Column = getJdbcColumnClass(context);
+        final boolean lookupCastType = Column.isMethodBound("cast_type", false);
+        // NOTE: MSSQL depends on Column#primary? no matter the AR version - thus always set @primary
+        return mapColumnsResult(context, metaData, components, results, Column, lookupCastType, true);
+    }
+
+    /**
+     * Microsoft SQL 2000+ support schemas
+     */
+    @Override
+    protected boolean databaseSupportsSchemas() {
+        return true;
+    }
+
+    /**
+     * Treat LONGVARCHAR as CLOB on MSSQL for purposes of converting a JDBC value to Ruby.
+     */
+    @Override
+    protected IRubyObject jdbcToRuby(
+        final ThreadContext context, final Ruby runtime,
+        final int column, int type, final ResultSet resultSet)
+        throws SQLException {
+        if ( type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR ) type = Types.CLOB;
+        return super.jdbcToRuby(context, runtime, column, type, resultSet);
+    }
+
+    @Override
+    protected ColumnData[] extractColumns(final Ruby runtime,
+        final Connection connection, final ResultSet resultSet,
+        final boolean downCase) throws SQLException {
+        return filterRowNumFromColumns( super.extractColumns(runtime, connection, resultSet, downCase) );
+    }
+
+    private static final ByteList _row_num; // "_row_num"
+    static {
+        _row_num = new ByteList(new byte[] { '_','r','o','w','_','n','u','m' }, false);
+        _row_num.setEncoding(UTF8Encoding.INSTANCE);
+    }
+
+    /**
+     * Filter out the <tt>_row_num</tt> column from results.
+     */
+    private static ColumnData[] filterRowNumFromColumns(final ColumnData[] columns) {
+        for ( int i = 0; i < columns.length; i++ ) {
+            if ( _row_num.equal( columns[i].name.getByteList() ) ) {
+                final ColumnData[] filtered = new ColumnData[columns.length - 1];
+
+                if ( i > 0 ) {
+                    System.arraycopy(columns, 0, filtered, 0, i);
+                }
+
+                if ( i + 1 < columns.length ) {
+                    System.arraycopy(columns, i + 1, filtered, i, columns.length - (i + 1));
+                }
+
+                return filtered;
+            }
+        }
+        return columns;
+    }
+
+    // internal helper not meant as a "public" API - used in one place thus every
+    @JRubyMethod(name = "jtds_driver?")
+    public IRubyObject jtds_driver_p(final ThreadContext context) throws SQLException {
+        // "jTDS Type 4 JDBC Driver for MS SQL Server and Sybase"
+        // SQLJDBC: "Microsoft JDBC Driver 4.0 for SQL Server"
+        return withConnection(context, new Callable<IRubyObject>() {
+            // NOTE: only used in one place for now (on release_savepoint) ...
+            // might get optimized to only happen once since driver won't change
+            public IRubyObject call(final Connection connection) throws SQLException {
+                final String driver = connection.getMetaData().getDriverName();
+                return context.getRuntime().newBoolean( driver.indexOf("jTDS") >= 0 );
+            }
+        });
+    }
+
+}

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

@@ -0,0 +1,147 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2012-2013 Karol Bucek <self@kares.org>
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ *
+ * 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.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.mysql;
+
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+import static arjdbc.util.QuotingUtils.quoteCharWith;
+
+import org.jcodings.specific.UTF8Encoding;
+
+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;
+
+public class MySQLModule {
+
+    public static RubyModule load(final RubyModule arJdbc) {
+        RubyModule mysql = arJdbc.defineModuleUnder("MySQL");
+        mysql.defineAnnotatedMethods(MySQLModule.class);
+        return mysql;
+    }
+
+    //private final static byte[] ZERO = new byte[] {'\\','0'};
+    //private final static byte[] NEWLINE = new byte[] {'\\','n'};
+    //private final static byte[] CARRIAGE = new byte[] {'\\','r'};
+    //private final static byte[] ZED = new byte[] {'\\','Z'};
+    //private final static byte[] DBL = new byte[] {'\\','"'};
+    //private final static byte[] SINGLE = new byte[] {'\\','\''};
+    //private final static byte[] ESCAPE = new byte[] {'\\','\\'};
+
+    private static final int STRING_QUOTES_OPTIMISTIC_QUESS = 24;
+
+    @JRubyMethod(name = "quote_string", required = 1, frame = false)
+    public static IRubyObject quote_string(final ThreadContext context,
+        final IRubyObject recv, final IRubyObject string) {
+
+        final ByteList stringBytes = ((RubyString) string).getByteList();
+        final byte[] bytes = stringBytes.unsafeBytes();
+        final int begin = stringBytes.getBegin();
+        final int realSize = stringBytes.getRealSize();
+
+        ByteList quotedBytes = null; int appendFrom = begin;
+        for ( int i = begin; i < begin + realSize; i++ ) {
+            final byte byte2;
+            switch ( bytes[i] ) {
+                case   0  : byte2 = '0';  break;
+                case '\n' : byte2 = 'n';  break;
+                case '\r' : byte2 = 'r';  break;
+                case  26  : byte2 = 'Z';  break;
+                case '"'  : byte2 = '"';  break;
+                case '\'' : byte2 = '\''; break;
+                case '\\' : byte2 = '\\'; break;
+                default   : byte2 = 0;
+            }
+            if ( byte2 != 0 ) {
+                if ( quotedBytes == null ) {
+                    quotedBytes = new ByteList(
+                        new byte[realSize + STRING_QUOTES_OPTIMISTIC_QUESS],
+                        stringBytes.getEncoding()
+                    );
+                    quotedBytes.setBegin(0);
+                    quotedBytes.setRealSize(0);
+                } // copy string on-first quote we "optimize" for non-quoted
+                quotedBytes.append(bytes, appendFrom, i - appendFrom);
+                quotedBytes.append('\\').append(byte2);
+                appendFrom = i + 1;
+            }
+        }
+        if ( quotedBytes != null ) { // append what's left in the end :
+            quotedBytes.append(bytes, appendFrom, begin + realSize - appendFrom);
+        }
+        else return string; // nothing changed, can return original
+
+        final Ruby runtime = context.getRuntime();
+        final RubyString quoted = runtime.newString(quotedBytes);
+
+        quoted.associateEncoding(UTF8Encoding.INSTANCE);
+
+        return quoted;
+    }
+
+    @JRubyMethod(name = "quoted_true", required = 0, frame = false)
+    public static IRubyObject quoted_true(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_1);
+    }
+
+    @JRubyMethod(name = "quoted_false", required = 0, frame = false)
+    public static IRubyObject quoted_false(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_0);
+    }
+
+    @JRubyMethod(name = "quote_column_name", required = 1, frame = false)
+    public static IRubyObject quote_column_name(
+            final ThreadContext context,
+            final IRubyObject self,
+            final IRubyObject string) { // "`#{name.to_s.gsub('`', '``')}`"
+        RubyString origin = string.asString();
+        RubyString quoted = quoteCharWith(context, origin, '`', '`');
+        final ByteList bytes = quoted.getByteList();
+        if ( origin == quoted ) {
+            final RubyString result =
+                RubyString.newStringLight(context.getRuntime(), bytes.getRealSize() + 2, bytes.getEncoding());
+            final ByteList resultBytes = result.getByteList();
+            resultBytes.append( (byte) '`' );
+            resultBytes.append( bytes );
+            resultBytes.append( (byte) '`' );
+            return result;
+        }
+        else {
+            bytes.append( (byte) '`' );
+            bytes.prepend( (byte) '`' );
+            return quoted;
+        }
+    }
+
+}