activerecord-jdbc-adapter 1.3.11 → 1.3.12

data/lib/arjdbc/sqlite3/adapter.rb

@@ -202,6 +202,11 @@ module ArJdbc
       true
     end
 
+    # @override
+    def supports_views?
+      true
+    end
+
     def sqlite_version
       @sqlite_version ||= Version.new(select_value('SELECT sqlite_version(*)'))
     end
@@ -213,8 +218,8 @@ module ArJdbc
 
       if value.kind_of?(String)
         column_type = column && column.type
-        if column_type == :binary && column.class.respond_to?(:string_to_binary)
-          "x'#{column.class.string_to_binary(value).unpack("H*")[0]}'"
+        if column_type == :binary
+          "x'#{value.unpack("H*")[0]}'"
         else
           super
         end
@@ -344,8 +349,15 @@ module ArJdbc
     # @override
     def columns(table_name, name = nil)
       klass = ::ActiveRecord::ConnectionAdapters::SQLite3Column
+      pass_cast_type = respond_to?(:lookup_cast_type)
       table_structure(table_name).map do |field|
-        klass.new(field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
+        sql_type = field['type']
+        if pass_cast_type
+          cast_type = lookup_cast_type(sql_type)
+          klass.new(field['name'], field['dflt_value'], cast_type, sql_type, field['notnull'] == 0)
+        else
+          klass.new(field['name'], field['dflt_value'], sql_type, field['notnull'] == 0)
+        end
       end
     end
 
@@ -355,6 +367,38 @@ module ArJdbc
       column && column['name']
     end
 
+    # NOTE: do not override indexes without testing support for 3.7.2 & 3.8.7 !
+    # @override
+    def indexes(table_name, name = nil)
+      # on JDBC 3.7 we'll simply do super since it can not handle "PRAGMA index_info"
+      return @connection.indexes(table_name, name) if sqlite_version < '3.8' # super
+
+      name ||= 'SCHEMA'
+      exec_query_raw("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+        index_name = row['name']
+        sql = "SELECT sql FROM sqlite_master"
+        sql << " WHERE name=#{quote(index_name)} AND type='index'"
+        sql << " UNION ALL "
+        sql << "SELECT sql FROM sqlite_temp_master"
+        sql << " WHERE name=#{quote(index_name)} AND type='index'"
+        where = nil
+        exec_query_raw(sql, name) do |index_sql|
+          match = /\sWHERE\s+(.+)$/i.match(index_sql)
+          where = match[1] if match
+        end
+        begin
+          columns = exec_query_raw("PRAGMA index_info('#{index_name}')", name).map { |col| col['name'] }
+        rescue => e
+          # NOTE: JDBC <= 3.8.7 bug work-around :
+          if e.message && e.message.index('[SQLITE_ERROR] SQL error or missing database')
+            columns = []
+          end
+          raise e
+        end
+        new_index_definition(table_name, index_name, row['unique'] != 0, columns, nil, nil, where)
+      end
+    end
+
     # @override
     def remove_index!(table_name, index_name)
       execute "DROP INDEX #{quote_column_name(index_name)}"
@@ -476,12 +520,17 @@ module ArJdbc
     end
 
     def translate_exception(exception, message)
-      case exception.message
-      when /column(s)? .* (is|are) not unique/
-        ActiveRecord::RecordNotUnique.new(message, exception)
-      else
-        super
+      if msg = exception.message
+        # SQLite 3.8.2 returns a newly formatted error message:
+        #   UNIQUE constraint failed: *table_name*.*column_name*
+        # Older versions of SQLite return:
+        #   column *column_name* is not unique
+        if msg.index('UNIQUE constraint failed: ') ||
+           msg =~ /column(s)? .* (is|are) not unique/
+          return RecordNotUnique.new(message, exception)
+        end
       end
+      super
     end
 
     # @private available in native adapter way back to AR-2.3
@@ -560,4 +609,4 @@ module ActiveRecord::ConnectionAdapters
 
     SQLiteAdapter = SQLite3Adapter
   end
-end
+end

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 module ArJdbc
-  VERSION = "1.3.11"
+  VERSION = "1.3.12"
   # @deprecated
   module Version
     # @private 1.2.x compatibility

data/rakelib/02-test.rake

@@ -53,7 +53,7 @@ def test_task_for(adapter, options = {})
   desc = options[:desc] || options[:comment] ||
     "Run tests against #{options[:database_name] || adapter}"
   adapter = adapter.to_s.downcase
-  driver = options.key?(:driver) ? options[:driver] : adapter
+  driver = adapter if ( driver = options[:driver] ).nil?
   prereqs = options[:prereqs] || []
   unless prereqs.frozen?
     prereqs = [ prereqs ].flatten; prereqs << 'test_appraisal_hint'
@@ -87,7 +87,7 @@ test_task_for :MSSQL, :driver => :jtds, :database_name => 'MS-SQL (SQLServer)'
 test_task_for :MySQL, :prereqs => 'db:mysql'
 test_task_for :PostgreSQL, :driver => 'postgres', :prereqs => 'db:postgresql'
 task :test_postgres => :test_postgresql # alias
-test_task_for :SQLite3
+test_task_for :SQLite3, :driver => ENV['JDBC_SQLITE_VERSION']
 task :test_sqlite => :test_sqlite3 # alias
 test_task_for :Firebird
 

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -89,7 +89,7 @@ import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 
 /**
- * Part of our ActiveRecord::ConnectionAdapters::Connection impl.
+ * Most of our ActiveRecord::ConnectionAdapters::JdbcConnection implementation.
  */
 public class RubyJdbcConnection extends RubyObject {
 
@@ -444,7 +444,16 @@ public class RubyJdbcConnection extends RubyObject {
      * @return connection
      */
     @JRubyMethod(name = "init_connection")
-    public synchronized IRubyObject init_connection(final ThreadContext context) throws SQLException {
+    public synchronized IRubyObject init_connection(final ThreadContext context) {
+        try {
+            return initConnection(context);
+        }
+        catch (SQLException e) {
+            return handleException(context, e); // throws
+        }
+    }
+
+    private IRubyObject initConnection(final ThreadContext context) throws SQLException {
         final IRubyObject jdbcConnection = setConnection( newConnection() );
         final IRubyObject adapter = callMethod("adapter"); // self.adapter
         if ( ! adapter.isNil() ) {
@@ -1140,10 +1149,10 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     // NOTE: metaData.getIndexInfo row mappings :
-    private static final int INDEX_INFO_TABLE_NAME = 3;
-    private static final int INDEX_INFO_NON_UNIQUE = 4;
-    private static final int INDEX_INFO_NAME = 6;
-    private static final int INDEX_INFO_COLUMN_NAME = 9;
+    protected static final int INDEX_INFO_TABLE_NAME = 3;
+    protected static final int INDEX_INFO_NON_UNIQUE = 4;
+    protected static final int INDEX_INFO_NAME = 6;
+    protected static final int INDEX_INFO_COLUMN_NAME = 9;
 
     /**
      * Default JDBC introspection for index metadata on the JdbcConnection.
@@ -1217,6 +1226,27 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @JRubyMethod(name = "supports_views?")
+    public IRubyObject supports_views_p(final ThreadContext context) throws SQLException {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                final DatabaseMetaData metaData = connection.getMetaData();
+                final ResultSet tableTypes = metaData.getTableTypes();
+                try {
+                    while ( tableTypes.next() ) {
+                        if ( "VIEW".equalsIgnoreCase( tableTypes.getString(1) ) ) {
+                            return context.getRuntime().newBoolean( true );
+                        }
+                    }
+                }
+                finally {
+                    close(tableTypes);
+                }
+                return context.getRuntime().newBoolean( false );
+            }
+        });
+    }
+
     // NOTE: this seems to be not used ... at all ?!
     /*
      * sql, values (array), types (column.type array), name = nil, pk = nil, id_value = nil, sequence_name = nil
@@ -1425,9 +1455,17 @@ public class RubyJdbcConnection extends RubyObject {
         return context.getRuntime().newBoolean( true );
     }
 
+    private IRubyObject getConfig(final ThreadContext context) {
+        return getInstanceVariable("@config"); // this.callMethod(context, "config");
+    }
+
     protected final IRubyObject getConfigValue(final ThreadContext context, final String key) {
-        final IRubyObject config = callMethod(context, "config");
-        return config.callMethod(context, "[]", context.getRuntime().newSymbol(key));
+        final IRubyObject config = getConfig(context);
+        final RubySymbol keySym = context.runtime.newSymbol(key);
+        if ( config instanceof RubyHash ) {
+            return ((RubyHash) config).op_aref(context, keySym);
+        }
+        return config.callMethod(context, "[]", keySym);
     }
 
     /**
@@ -1518,7 +1556,7 @@ public class RubyJdbcConnection extends RubyObject {
         final RubyArray resultRows = runtime.newArray();
 
         while ( resultSet.next() ) {
-            resultRows.add( resultHandler.mapRow(context, runtime, columns, resultSet, this) );
+            resultRows.append( resultHandler.mapRow(context, runtime, columns, resultSet, this) );
         }
 
         return resultHandler.newResult(context, runtime, columns, resultRows);
@@ -2897,7 +2935,7 @@ public class RubyJdbcConnection extends RubyObject {
         }
 
         final RubyArray columns = runtime.newArray();
-        final IRubyObject config = getInstanceVariable("@config");
+        final IRubyObject config = getConfig(context);
         while ( results.next() ) {
             final String colName = results.getString(COLUMN_NAME);
             IRubyObject column = jdbcColumn.callMethod(context, "new",

data/src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -37,6 +37,7 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.DatabaseMetaData;
 import java.sql.Savepoint;
+import java.sql.Types;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -118,15 +119,81 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override
-    protected IRubyObject indexes(final ThreadContext context, String tableName, final String name, String schemaName) {
-        if ( tableName != null ) {
-            final int i = tableName.indexOf('.');
-            if ( i > 0 && schemaName == null ) {
-                schemaName = tableName.substring(0, i);
-                tableName = tableName.substring(i + 1);
+    protected IRubyObject indexes(final ThreadContext context, String table, final String name, String schema) {
+        if ( table != null ) {
+            final int i = table.indexOf('.');
+            if ( i > 0 && schema == null ) {
+                schema = table.substring(0, i);
+                table = table.substring(i + 1);
             }
         }
-        return super.indexes(context, tableName, name, schemaName);
+        final String tableName = table;
+        final String schemaName = schema;
+        // return super.indexes(context, tableName, name, schemaName);
+        return withConnection(context, new Callable<IRubyObject>() {
+            public RubyArray call(final Connection connection) throws SQLException {
+                final Ruby runtime = context.runtime;
+                final RubyClass indexDefinition = getIndexDefinition(runtime);
+
+                final TableName table = extractTableName(connection, schemaName, tableName);
+
+                final List<RubyString> primaryKeys = primaryKeys(context, connection, table);
+
+                final DatabaseMetaData metaData = connection.getMetaData();
+                ResultSet indexInfoSet = null;
+                try {
+                    indexInfoSet = metaData.getIndexInfo(table.catalog, table.schema, table.name, false, true);
+                }
+                catch (SQLException e) {
+                    final String msg = e.getMessage();
+                    if ( msg != null && msg.startsWith("[SQLITE_ERROR] SQL error or missing database") ) {
+                        return RubyArray.newEmptyArray(runtime); // on 3.8.7 getIndexInfo fails if table has no indexes
+                    }
+                    throw e;
+                }
+                final RubyArray indexes = RubyArray.newArray(runtime, 8);
+                try {
+                    String currentIndex = null;
+
+                    while ( indexInfoSet.next() ) {
+                        String indexName = indexInfoSet.getString(INDEX_INFO_NAME);
+                        if ( indexName == null ) continue;
+
+                        final String columnName = indexInfoSet.getString(INDEX_INFO_COLUMN_NAME);
+                        final RubyString rubyColumnName = RubyString.newUnicodeString(runtime, columnName);
+                        if ( primaryKeys.contains(rubyColumnName) ) continue;
+
+                        // We are working on a new index
+                        if ( ! indexName.equals(currentIndex) ) {
+                            currentIndex = indexName;
+
+                            String indexTableName = indexInfoSet.getString(INDEX_INFO_TABLE_NAME);
+
+                            final boolean nonUnique = indexInfoSet.getBoolean(INDEX_INFO_NON_UNIQUE);
+
+                            IRubyObject[] args = new IRubyObject[] {
+                                RubyString.newUnicodeString(runtime, indexTableName), // table_name
+                                RubyString.newUnicodeString(runtime, indexName), // index_name
+                                runtime.newBoolean( ! nonUnique ), // unique
+                                runtime.newArray() // [] for column names, we'll add to that in just a bit
+                                // orders, (since AR 3.2) where, type, using (AR 4.0)
+                            };
+
+                            indexes.append( indexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
+                        }
+
+                        // One or more columns can be associated with an index
+                        IRubyObject lastIndexDef = indexes.isEmpty() ? null : indexes.entry(-1);
+                        if ( lastIndexDef != null ) {
+                            ( (RubyArray) lastIndexDef.callMethod(context, "columns") ).append(rubyColumnName);
+                        }
+                    }
+
+                    return indexes;
+
+                } finally { close(indexInfoSet); }
+            }
+        });
     }
 
     @Override
@@ -151,14 +218,10 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
             name = nameParts[2];
         }
 
-        name = caseConvertIdentifierForJdbc(connection, name);
-
         if ( schema != null ) {
-            schema = caseConvertIdentifierForJdbc(connection, schema);
             // NOTE: hack to work-around SQLite JDBC ignoring schema :
             return new TableName(catalog, null, schema + '.' + name);
         }
-
         return new TableName(catalog, schema, name);
     }
 
@@ -173,6 +236,13 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
         if ( resultSet instanceof ResultSetMetaData ) {
             type = ((ResultSetMetaData) resultSet).getColumnType(column);
         }
+        // since JDBC 3.8 there seems to be more cleverness built-in that
+        // seems (<= 3.8.7) to get things wrong ... reports DATE SQL type
+        // for "datetime" columns :
+        if ( type == Types.DATE ) {
+            // return timestampToRuby(context, runtime, resultSet, column);
+            return stringToRuby(context, runtime, resultSet, column);
+        }
         return super.jdbcToRuby(context, runtime, column, type, resultSet);
     }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: 1.3.11
+  version: 1.3.12
 platform: ruby
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-10-20 00:00:00.000000000 Z
+date: 2014-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord