activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

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

@@ -32,11 +32,17 @@ import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
- *
+ * @deprecated implement a {@link Callable} directly instead.
+ * 
  * @author nicksieger
  */
-public abstract class SQLBlock {
-    protected abstract Object call(Connection c) throws SQLException;
+@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);

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

@@ -25,32 +25,34 @@
  ***** END LICENSE BLOCK *****/
 package arjdbc.mssql;
 
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import java.sql.DatabaseMetaData;
 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.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 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) {
@@ -66,29 +68,47 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
             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);
+   
+    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) );
     }
-
-    /**
-     * 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;
+    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 super.jdbcToRuby(runtime, column, type, resultSet);
+        return tables;
     }
-
+    
     /**
      * Microsoft SQL 2000+ support schemas
      */
@@ -96,32 +116,49 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
     protected boolean databaseSupportsSchemas() {
         return true;
     }
-
+    
+    /**
+     * Treat LONGVARCHAR as CLOB on MSSQL for purposes of converting a JDBC value to Ruby.
+     */
     @Override
-    protected void populateFromResultSet(ThreadContext context, Ruby runtime, List results,
-                                         ResultSet resultSet, ColumnData[] columns) throws SQLException {
-        super.populateFromResultSet(context, runtime, results, resultSet, filterRowNumFromColumns(columns));
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
+        throws SQLException {
+        if ( type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR ) type = Types.CLOB;
+        return super.jdbcToRuby(runtime, column, type, resultSet);
     }
 
+    @Override
+    protected ColumnData[] extractColumns(final Ruby runtime, 
+        final DatabaseMetaData metaData, final ResultSet resultSet, 
+        final boolean downCase) throws SQLException {
+        return filterRowNumFromColumns( super.extractColumns(runtime, metaData, 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 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) {
+    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) {
+                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

@@ -24,6 +24,7 @@
 
 package arjdbc.mysql;
 
+import static arjdbc.jdbc.RubyJdbcConnection.debugStackTrace;
 import static arjdbc.util.QuotingUtils.BYTES_0;
 import static arjdbc.util.QuotingUtils.BYTES_1;
 
@@ -61,9 +62,9 @@ public class MySQLModule {
         final IRubyObject recv, final IRubyObject string) {
         
         final ByteList stringBytes = ((RubyString) string).getByteList();
-        final byte[] bytes = stringBytes.bytes; // unsafeBytes();
-        final int begin = stringBytes.begin; // getBegin();
-        final int realSize = stringBytes.realSize; // getRealSize();
+        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++ ) {
@@ -82,10 +83,10 @@ public class MySQLModule {
                 if ( quotedBytes == null ) {
                     quotedBytes = new ByteList(
                         new byte[realSize + STRING_QUOTES_OPTIMISTIC_QUESS], 
-                        stringBytes.encoding // getEncoding()
+                        stringBytes.getEncoding()
                     );
-                    quotedBytes.begin = 0; // setBegin(0);
-                    quotedBytes.realSize = 0; // setRealSize(0);
+                    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);
@@ -126,18 +127,18 @@ public class MySQLModule {
      */
     @JRubyMethod(module = true, frame = false)
     public static IRubyObject kill_cancel_timer(final ThreadContext context, 
-        final IRubyObject recv, final IRubyObject raw_connection) {
+        final IRubyObject self, final IRubyObject raw_connection) {
         
         final Connection conn = (Connection) raw_connection.dataGetStruct();
-        if (conn != null && conn.getClass().getClassLoader() == recv.getRuntime().getJRubyClassLoader()) {
+        if (conn != null && conn.getClass().getClassLoader() == self.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) { /* ignored */ }
+            catch (Exception e) { debugStackTrace(context, e); }
         }
-        return recv.getRuntime().getNil();
+        return self.getRuntime().getNil();
     }
 }

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

@@ -25,6 +25,9 @@
  ***** END LICENSE BLOCK *****/
 package arjdbc.mysql;
 
+import arjdbc.jdbc.RubyJdbcConnection;
+import arjdbc.jdbc.Callable;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -35,46 +38,44 @@ 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);
+    protected boolean doExecute(final Statement statement, 
+        final String query) throws SQLException {
+        return statement.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;
+    protected IRubyObject unmarshalKeysOrUpdateCount(final ThreadContext context, 
+        final Connection connection, final Statement statement) throws SQLException {
+        final Ruby runtime = context.getRuntime();
+        final IRubyObject key = unmarshalIdResult(runtime, statement);
+        return key.isNil() ? runtime.newFixnum(statement.getUpdateCount()) : 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);
+        throws SQLException {
+        if ( Types.BOOLEAN == type || Types.BIT == type ) {
+            final boolean value = resultSet.getBoolean(column);
+            return resultSet.wasNull() ? runtime.getNil() : runtime.newFixnum(value ? 1 : 0);
         }
         return super.jdbcToRuby(runtime, column, type, resultSet);
     }
@@ -86,76 +87,81 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
 
         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));
+    @Override
+    protected IRubyObject indexes(final ThreadContext context, final String tableName, final String name, final String schemaName) {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                final Ruby runtime = context.getRuntime();
+                final RubyModule indexDefinition = getIndexDefinition(runtime);
+                final DatabaseMetaData metaData = connection.getMetaData();
+                final String jdbcTableName = caseConvertIdentifierForJdbc(metaData, tableName);
+                final String jdbcSchemaName = caseConvertIdentifierForJdbc(metaData, schemaName);
+                final IRubyObject rubyTableName = RubyString.newUnicodeString(
+                    runtime, caseConvertIdentifierForJdbc(metaData, tableName)
+                );
+                
+                StringBuilder query = new StringBuilder("SHOW KEYS FROM ");
+                if (jdbcSchemaName != null) {
+                    query.append(jdbcSchemaName).append(".");
+                }
+                query.append(jdbcTableName);
+                query.append(" WHERE key_name != 'PRIMARY'");
+                
+                final List<IRubyObject> indexes = new ArrayList<IRubyObject>();
+                PreparedStatement statement = null;
+                ResultSet keySet = null;
+
+                try {
+                    statement = connection.prepareStatement(query.toString());
+                    keySet = statement.executeQuery();
+                    
+                    String currentKeyName = null;
+
+                    while ( keySet.next() ) {
+                        final String keyName = caseConvertIdentifierForRails(metaData, keySet.getString("key_name"));
+
+                        if ( ! keyName.equals(currentKeyName) ) {
+                            currentKeyName = keyName;
+
+                            final boolean nonUnique = keySet.getBoolean("non_unique");
+                            
+                            IRubyObject[] args = new IRubyObject[] {
+                                rubyTableName, // table_name
+                                RubyString.newUnicodeString(runtime, keyName), // index_name
+                                runtime.newBoolean( ! nonUnique ), // unique
+                                runtime.newArray(), // [] for column names, we'll add to that in just a bit
+                                runtime.newArray() // lengths
+                            };
+
+                            indexes.add( indexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
+                        }
+
+                        IRubyObject lastIndexDef = indexes.isEmpty() ? null : indexes.get(indexes.size() - 1);
+                        if (lastIndexDef != null) {
+                            final String columnName = caseConvertIdentifierForRails(metaData, keySet.getString("column_name"));
+                            final int length = keySet.getInt("sub_part");
+                            final boolean nullLength = keySet.wasNull();
+
+                            lastIndexDef.callMethod(context, "columns").callMethod(context, 
+                                    "<<", RubyString.newUnicodeString(runtime, columnName));
+                            lastIndexDef.callMethod(context, "lengths").callMethod(context, 
+                                    "<<", nullLength ? runtime.getNil() : runtime.newFixnum(length));
+                        }
+                    }
+                    
+                    return runtime.newArray(indexes);    
+                }
+                finally {
+                    close(keySet);
+                    close(statement);
+                }
             }
-          }
-
-          return runtime.newArray(indexes);
-        } finally {
-          close(rs);
-          close(stmt);
-        }
-      }
-    });
-  }
+        });
+    }
 }