tgbyte-activerecord-jdbc-adapter 1.2.2.2

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

@@ -0,0 +1,48 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * 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;
+
+/**
+ *
+ * @author nicksieger
+ */
+public abstract class SQLBlock {
+    protected abstract Object call(Connection c) throws SQLException;
+
+    public void close(Statement statement) {
+        RubyJdbcConnection.close(statement);
+    }
+
+    public void close(ResultSet resultSet) {
+        RubyJdbcConnection.close(resultSet);
+    }
+}

data/src/java/arjdbc/mssql/MssqlRubyJdbcConnection.java

@@ -0,0 +1,127 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * 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 java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.List;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import static arjdbc.jdbc.RubyJdbcConnection.ColumnData;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class MssqlRubyJdbcConnection extends RubyJdbcConnection {
+
+    private RubyString _row_num;
+
+    protected MssqlRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+        _row_num = runtime.newString("_row_num");
+    }
+
+    public static RubyClass createMssqlJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("MssqlJdbcConnection",
+                jdbcConnection, MSSQL_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(MssqlRubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator MSSQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new MssqlRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    protected static IRubyObject booleanToRuby(Ruby runtime, ResultSet resultSet, boolean booleanValue)
+            throws SQLException {
+        if (booleanValue == false && resultSet.wasNull()) return runtime.getNil();
+        return runtime.newBoolean(booleanValue);
+    }
+
+    /**
+     * Treat LONGVARCHAR as CLOB on Mssql for purposes of converting a JDBC value to Ruby.
+     * Treat BOOLEAN/BIT as Boolean, rather than the default behaviour of conversion to string
+     */
+    @Override
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
+            throws SQLException {
+        if ( Types.BOOLEAN == type || Types.BIT == type ) {
+          return booleanToRuby(runtime, resultSet, resultSet.getBoolean(column));
+        }
+        if (type == Types.LONGVARCHAR) {
+            type = Types.CLOB;
+        }
+        return super.jdbcToRuby(runtime, column, type, resultSet);
+    }
+
+    /**
+     * Microsoft SQL 2000+ support schemas
+     */
+    @Override
+    protected boolean databaseSupportsSchemas() {
+        return true;
+    }
+
+    @Override
+    protected void populateFromResultSet(ThreadContext context, Ruby runtime, List results,
+                                         ResultSet resultSet, ColumnData[] columns) throws SQLException {
+        super.populateFromResultSet(context, runtime, results, resultSet, filterRowNumFromColumns(columns));
+    }
+
+    /**
+     * Filter out the <tt>_row_num</tt> column from results.
+     */
+    private ColumnData[] filterRowNumFromColumns(ColumnData[] columns) {
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].name.equals(_row_num)) {
+                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;
+    }
+}

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

@@ -0,0 +1,134 @@
+/***** BEGIN LICENSE BLOCK *****
+ * 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 java.sql.Connection;
+
+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 void load(RubyModule arJdbc) {
+        RubyModule mysql = arJdbc.defineModuleUnder("MySQL");
+        mysql.defineAnnotatedMethods(MySQLModule.class);
+    }
+
+    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;
+            }
+
+            if (rep != null) {
+                newBytes.replace(i, 1, rep);
+                i += rep.length - 1; // We subtract one since for loop already adds one
+            }
+        }
+
+        // Nothing changed, can return original
+        if (newBytes.length() == bytes.length()) return string;
+
+        return context.getRuntime().newString(newBytes);
+    }
+
+    @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();
+
+        newBytes.insert(0, BACKQUOTE);
+        newBytes.append(bytes);
+        newBytes.append(BACKQUOTE);
+
+        return context.getRuntime().newString(newBytes);
+    }
+
+    @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);
+
+        return context.getRuntime().newString(newBytes);
+    }
+
+    /**
+     * 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();
+    }
+}

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

@@ -0,0 +1,161 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * 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.mysql;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+import arjdbc.jdbc.SQLBlock;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNil;
+import org.jruby.RubyString;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
+    protected MySQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    @Override
+    protected boolean genericExecute(Statement stmt, String query) throws SQLException {
+        return stmt.execute(query, Statement.RETURN_GENERATED_KEYS);
+    }
+
+    @Override
+    protected IRubyObject unmarshalKeysOrUpdateCount(ThreadContext context, Connection c, Statement stmt) throws SQLException {
+        IRubyObject key = unmarshal_id_result(context.getRuntime(), stmt.getGeneratedKeys());
+        if (key.isNil()) {
+            return context.getRuntime().newFixnum(stmt.getUpdateCount());
+        }
+        return key;
+    }
+
+    @Override
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
+            throws SQLException {
+        if (Types.BOOLEAN == type || Types.BIT == type) {
+            return integerToRuby(runtime, resultSet, resultSet.getBoolean(column) ? 1 : 0);
+        }
+        return super.jdbcToRuby(runtime, column, type, resultSet);
+    }
+
+    public static RubyClass createMySQLJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("MySQLJdbcConnection",
+                jdbcConnection, MYSQL_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(MySQLRubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator MYSQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new MySQLRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+  @Override
+  protected IRubyObject indexes(final ThreadContext context, final String tableNameArg, String name, final String schemaNameArg) {
+    return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
+      @Override
+      public Object call(Connection connection) throws SQLException {
+        Ruby runtime = context.getRuntime();
+        DatabaseMetaData metadata = connection.getMetaData();
+        String jdbcTableName = caseConvertIdentifierForJdbc(metadata, tableNameArg);
+        String jdbcSchemaName = caseConvertIdentifierForJdbc(metadata, schemaNameArg);
+
+        StringBuilder buffer = new StringBuilder("SHOW KEYS FROM ");
+        if (jdbcSchemaName != null) buffer.append(jdbcSchemaName).append(".");
+        buffer.append(jdbcTableName);
+        buffer.append(" WHERE key_name != 'PRIMARY'");
+        String query = buffer.toString();
+
+        List<IRubyObject> indexes = new ArrayList<IRubyObject>();
+        PreparedStatement stmt = null;
+        ResultSet rs = null;
+
+        try {
+          stmt = connection.prepareStatement(query);
+          rs = stmt.executeQuery();
+
+          IRubyObject rubyTableName = RubyString.newUnicodeString(runtime, caseConvertIdentifierForJdbc(metadata, tableNameArg));
+          RubyModule indexDefinitionClass = getConnectionAdapters(runtime).getClass("IndexDefinition");
+          String currentKeyName = null;
+
+          while (rs.next()) {
+            String keyName = caseConvertIdentifierForRails(metadata, rs.getString("key_name"));
+
+            if (!keyName.equals(currentKeyName)) {
+              currentKeyName = keyName;
+
+              boolean nonUnique = rs.getBoolean("non_unique");
+              IRubyObject indexDefinition = indexDefinitionClass.callMethod(context, "new", new IRubyObject[]{
+                rubyTableName,
+                RubyString.newUnicodeString(runtime, keyName),
+                runtime.newBoolean(!nonUnique),
+                runtime.newArray(),
+                runtime.newArray()
+              });
+
+              indexes.add(indexDefinition);
+            }
+
+            IRubyObject lastIndex = indexes.get(indexes.size() - 1);
+            if (lastIndex != null) {
+              String columnName = caseConvertIdentifierForRails(metadata, rs.getString("column_name"));
+              int length = rs.getInt("sub_part");
+              boolean lengthIsNull = rs.wasNull();
+
+              lastIndex.callMethod(context, "columns").callMethod(context, "<<", RubyString.newUnicodeString(runtime, columnName));
+              lastIndex.callMethod(context, "lengths").callMethod(context, "<<", lengthIsNull ? runtime.getNil() : runtime.newFixnum(length));
+            }
+          }
+
+          return runtime.newArray(indexes);
+        } finally {
+          close(rs);
+          close(stmt);
+        }
+      }
+    });
+  }
+}