activerecord-jdbc-adapter 1.0.3-java → 50.1-java

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

@@ -0,0 +1,90 @@
+/*
+ * 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.quoteCharAndDecorateWith;
+import static arjdbc.util.QuotingUtils.quoteSingleQuotesWithFallback;
+
+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.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;
+    }
+
+    public static RubyModule load(final Ruby runtime) {
+        return load( arjdbc.ArJdbcModule.get(runtime) );
+    }
+
+    @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.runtime, BYTES_1);
+    }
+
+    @JRubyMethod(name = "quoted_false", required = 0)
+    public static IRubyObject quoted_false(final ThreadContext context,
+        final IRubyObject self) {
+        return RubyString.newString(context.runtime, 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
+        }
+
+        return quoteCharAndDecorateWith(context, partString, ']', ']', (byte) '[', (byte) ']');
+    }
+
+}

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

@@ -0,0 +1,181 @@
+/***** 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.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+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;
+
+    public 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;
+    }
+
+    public static RubyClass load(final Ruby runtime) {
+        RubyClass jdbcConnection = getJdbcConnection(runtime);
+        return createMSSQLJdbcConnectionClass(runtime, jdbcConnection);
+    }
+
+    protected 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 RubyBoolean exec_p(ThreadContext context, IRubyObject self, IRubyObject sql) {
+        final ByteList sqlBytes = sql.asString().getByteList();
+        return context.runtime.newBoolean( startsWithIgnoreCase(sqlBytes, EXEC) );
+    }
+
+    @Override
+    protected RubyArray mapTables(final ThreadContext context, final Connection connection,
+            final String catalog, final String schemaPattern, final String tablePattern,
+            final ResultSet tablesSet) throws SQLException, IllegalStateException {
+
+        final RubyArray tables = context.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`");
+            }
+            tables.add( cachedString(context, caseConvertIdentifierForRails(connection, name)) );
+        }
+        return tables;
+    }
+
+    /**
+     * 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 ThreadContext context,
+        final Connection connection, final ResultSet resultSet,
+        final boolean downCase) throws SQLException {
+        return filterRowNumFromColumns( super.extractColumns(context, connection, resultSet, downCase) );
+    }
+
+    /**
+     * 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".equals( columns[i].getName() ) ) {
+                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 RubyBoolean 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<RubyBoolean>() {
+            // NOTE: only used in one place for now (on release_savepoint) ...
+            // might get optimized to only happen once since driver won't change
+            public RubyBoolean 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

@@ -1,4 +1,5 @@
 /***** 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>
  *
@@ -24,111 +25,128 @@
 
 package arjdbc.mysql;
 
-import java.sql.Connection;
-
+import org.jcodings.specific.UTF8Encoding;
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
 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;
 
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+import static arjdbc.util.QuotingUtils.quoteCharAndDecorateWith;
+
 public class MySQLModule {
-    public static void load(RubyModule arJdbc) {
+
+    public static RubyModule load(final RubyModule arJdbc) {
         RubyModule mysql = arJdbc.defineModuleUnder("MySQL");
         mysql.defineAnnotatedMethods(MySQLModule.class);
+        return mysql;
     }
 
-    private final static byte BACKQUOTE = '`';
-    private final static byte[] QUOTED_DOT = new byte[] {'`', '.', '`'};
-
-    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[] {'\\','\\'};
-
-    @JRubyMethod(name = "quote_string", required = 1, frame=false)
-    public static IRubyObject quote_string(ThreadContext context, IRubyObject recv, IRubyObject string) {
-        ByteList bytes = ((RubyString) string).getByteList();
-        ByteList newBytes = new ByteList();
-
-        newBytes.append(bytes);
-
-        for(int i = newBytes.begin; i < newBytes.begin + newBytes.realSize; i++) {
-            byte[] rep = null;
-            switch (newBytes.bytes[i]) {
-            case 0: rep = ZERO; break;
-            case '\n': rep = NEWLINE; break;
-            case '\r': rep = CARRIAGE; break;
-            case 26: rep = ZED; break;
-            case '"': rep = DBL; break;
-            case '\'': rep = SINGLE; break;
-            case '\\': rep = ESCAPE; break;
-            }
+    public static RubyModule load(final Ruby runtime) {
+        return load( arjdbc.ArJdbcModule.get(runtime) );
+    }
 
-            if (rep != null) {
-                newBytes.replace(i, 1, rep);
-                i += rep.length - 1; // We subtract one since for loop already adds one
+    // ActiveRecord::ConnectionAdapters::MySQL::Quoting (almost all of)
+    // without the column/table name 'caches' replicated across threads
+
+    //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)
+    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
 
-        // Nothing changed, can return original
-        if (newBytes.length() == bytes.length()) return string;
+        final Ruby runtime = context.runtime;
+        final RubyString quoted = runtime.newString(quotedBytes);
 
-        return context.getRuntime().newString(newBytes);
-    }
+        quoted.associateEncoding(UTF8Encoding.INSTANCE);
 
-    @JRubyMethod(name = "quote_column_name", frame=false)
-    public static IRubyObject quote_column_name(ThreadContext context, IRubyObject recv, IRubyObject arg) {
-        ByteList bytes = arg.asString().getByteList();
-        ByteList newBytes = new ByteList();
+        return quoted;
+    }
 
-        newBytes.insert(0, BACKQUOTE);
-        newBytes.append(bytes);
-        newBytes.append(BACKQUOTE);
+    @JRubyMethod(name = "quoted_true")
+    public static IRubyObject quoted_true(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyString.newString(context.runtime, BYTES_1).freeze(context);
+    }
 
-        return context.getRuntime().newString(newBytes);
+    @JRubyMethod(name = "quoted_false")
+    public static IRubyObject quoted_false(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyString.newString(context.runtime, BYTES_0).freeze(context);
     }
 
-    @JRubyMethod(name = "quote_table_name", frame=false)
-    public static IRubyObject quote_table_name(ThreadContext context, IRubyObject recv, IRubyObject arg) {
-        ByteList bytes = arg.asString().getByteList();
-        ByteList newBytes = new ByteList();
-
-        newBytes.insert(0, BACKQUOTE);
-        newBytes.append(bytes);
-        int i = 0, j = 0;
-        while ((i = newBytes.indexOf('.', j)) != -1) {
-            newBytes.replace(i, 1, QUOTED_DOT);
-            j = i+3;
-        }
-        newBytes.append(BACKQUOTE);
+    @JRubyMethod(name = "unquoted_true")
+    public static IRubyObject unquoted_true(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyFixnum.one(context.runtime);
+    }
 
-        return context.getRuntime().newString(newBytes);
+    @JRubyMethod(name = "unquoted_false")
+    public static IRubyObject unquoted_false(
+            final ThreadContext context,
+            final IRubyObject self) {
+        return RubyFixnum.zero(context.runtime);
     }
 
-    /**
-     * HACK HACK HACK See http://bugs.mysql.com/bug.php?id=36565
-     * MySQL's statement cancel timer can cause memory leaks, so cancel it
-     * if we loaded MySQL classes from the same classloader as JRuby
-     */
-    @JRubyMethod(module = true, frame = false)
-    public static IRubyObject kill_cancel_timer(ThreadContext context, IRubyObject recv, IRubyObject raw_connection) {
-        Connection conn = (Connection) raw_connection.dataGetStruct();
-        if (conn != null && conn.getClass().getClassLoader() == recv.getRuntime().getJRubyClassLoader()) {
-            try {
-                java.lang.reflect.Field f = conn.getClass().getDeclaredField("cancelTimer");
-                f.setAccessible(true);
-                java.util.Timer timer = (java.util.Timer) f.get(null);
-                timer.cancel();
-            } catch (Exception e) {
-            }
-        }
-        return recv.getRuntime().getNil();
+    @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) '`');
     }
+
 }