activerecord 4.1.8 → 4.2.11.3

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   module ConnectionAdapters
     class SchemaCache
@@ -12,15 +11,15 @@ module ActiveRecord
         @columns_hash = {}
         @primary_keys = {}
         @tables       = {}
-        prepare_default_proc
       end
 
       def primary_keys(table_name)
-        @primary_keys[table_name]
+        @primary_keys[table_name] ||= table_exists?(table_name) ? connection.primary_key(table_name) : nil
       end
 
       # A cached lookup for table existence.
       def table_exists?(name)
+        prepare_tables if @tables.empty?
         return @tables[name] if @tables.key? name
 
         @tables[name] = connection.table_exists?(name)
@@ -29,9 +28,9 @@ module ActiveRecord
       # Add internal cache for table with +table_name+.
       def add(table_name)
         if table_exists?(table_name)
-          @primary_keys[table_name]
-          @columns[table_name]
-          @columns_hash[table_name]
+          primary_keys(table_name)
+          columns(table_name)
+          columns_hash(table_name)
         end
       end
 
@@ -40,14 +39,16 @@ module ActiveRecord
       end
 
       # Get the columns for a table
-      def columns(table)
-        @columns[table]
+      def columns(table_name)
+        @columns[table_name] ||= connection.columns(table_name)
       end
 
       # Get the columns for a table as a hash, key is the column name
       # value is the column object.
-      def columns_hash(table)
-        @columns_hash[table]
+      def columns_hash(table_name)
+        @columns_hash[table_name] ||= Hash[columns(table_name).map { |col|
+          [col.name, col]
+        }]
       end
 
       # Clears out internal caches
@@ -76,33 +77,18 @@ module ActiveRecord
       def marshal_dump
         # if we get current version during initialization, it happens stack over flow.
         @version = ActiveRecord::Migrator.current_version
-        [@version] + [@columns, @columns_hash, @primary_keys, @tables].map { |val|
-          Hash[val]
-        }
+        [@version, @columns, @columns_hash, @primary_keys, @tables]
       end
 
       def marshal_load(array)
         @version, @columns, @columns_hash, @primary_keys, @tables = array
-        prepare_default_proc
       end
 
       private
 
-      def prepare_default_proc
-        @columns.default_proc = Proc.new do |h, table_name|
-          h[table_name] = connection.columns(table_name)
-        end
-
-        @columns_hash.default_proc = Proc.new do |h, table_name|
-          h[table_name] = Hash[columns(table_name).map { |col|
-            [col.name, col]
-          }]
+        def prepare_tables
+          connection.tables.each { |table| @tables[table] = true }
         end
-
-        @primary_keys.default_proc = Proc.new do |h, table_name|
-          h[table_name] = table_exists?(table_name) ? connection.primary_key(table_name) : nil
-        end
-      end
     end
   end
 end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -14,9 +14,9 @@ module ActiveRecord
         raise ArgumentError, "No database file specified. Missing argument: database"
       end
 
-      # Allow database path relative to Rails.root, but only if
-      # the database path is not the special path that tells
-      # Sqlite to build a database only in memory.
+      # Allow database path relative to Rails.root, but only if the database
+      # path is not the special path that tells sqlite to build a database only
+      # in memory.
       if ':memory:' != config[:database]
         config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
         dirname = File.dirname(config[:database])
@@ -30,25 +30,23 @@ module ActiveRecord
 
       db.busy_timeout(ConnectionAdapters::SQLite3Adapter.type_cast_config_to_integer(config[:timeout])) if config[:timeout]
 
-      ConnectionAdapters::SQLite3Adapter.new(db, logger, config)
+      ConnectionAdapters::SQLite3Adapter.new(db, logger, nil, config)
     rescue Errno::ENOENT => error
       if error.message.include?("No such file or directory")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
 
   module ConnectionAdapters #:nodoc:
-    class SQLite3Column < Column #:nodoc:
-      class <<  self
-        def binary_to_string(value)
-          if value.encoding != Encoding::ASCII_8BIT
-            value = value.force_encoding(Encoding::ASCII_8BIT)
-          end
-          value
+    class SQLite3Binary < Type::Binary # :nodoc:
+      def cast_value(value)
+        if value.encoding != Encoding::ASCII_8BIT
+          value = value.force_encoding(Encoding::ASCII_8BIT)
         end
+        value
       end
     end
 
@@ -59,35 +57,23 @@ module ActiveRecord
     #
     # * <tt>:database</tt> - Path to the database file.
     class SQLite3Adapter < AbstractAdapter
+      ADAPTER_NAME = 'SQLite'.freeze
       include Savepoints
 
       NATIVE_DATABASE_TYPES = {
         primary_key:  'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL',
-        string:       { name: "varchar", limit: 255 },
+        string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
         float:        { name: "float" },
         decimal:      { name: "decimal" },
         datetime:     { name: "datetime" },
-        timestamp:    { name: "datetime" },
         time:         { name: "time" },
         date:         { name: "date" },
         binary:       { name: "blob" },
         boolean:      { name: "boolean" }
       }
 
-      class Version
-        include Comparable
-
-        def initialize(version_string)
-          @version = version_string.split('.').map { |v| v.to_i }
-        end
-
-        def <=>(version_string)
-          @version <=> version_string.split('.').map { |v| v.to_i }
-        end
-      end
-
       class StatementPool < ConnectionAdapters::StatementPool
         def initialize(connection, max)
           super
@@ -107,7 +93,7 @@ module ActiveRecord
         end
 
         def clear
-          cache.values.each do |hash|
+          cache.each_value do |hash|
             dealloc hash[:stmt]
           end
           cache.clear
@@ -123,11 +109,7 @@ module ActiveRecord
         end
       end
 
-      class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
-      def initialize(connection, logger, config)
+      def initialize(connection, logger, connection_options, config)
         super(connection, logger)
 
         @active     = nil
@@ -135,18 +117,15 @@ module ActiveRecord
                                         self.class.type_cast_config_to_integer(config.fetch(:statement_limit) { 1000 }))
         @config = config
 
+        @visitor = Arel::Visitors::SQLite.new self
+
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
-          @visitor = Arel::Visitors::SQLite.new self
         else
-          @visitor = unprepared_visitor
+          @prepared_statements = false
         end
       end
 
-      def adapter_name #:nodoc:
-        'SQLite'
-      end
-
       def supports_ddl_transactions?
         true
       end
@@ -178,7 +157,7 @@ module ActiveRecord
         true
       end
 
-      def supports_add_column?
+      def supports_views?
         true
       end
 
@@ -225,10 +204,25 @@ module ActiveRecord
 
       # QUOTING ==================================================
 
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary
-          s = value.unpack("H*")[0]
-          "x'#{s}'"
+      def _quote(value) # :nodoc:
+        case value
+        when Type::Binary::Data
+          "x'#{value.hex}'"
+        else
+          super
+        end
+      end
+
+      def _type_cast(value) # :nodoc:
+        case value
+        when BigDecimal
+          value.to_f
+        when String
+          if value.encoding == Encoding::ASCII_8BIT
+            super(value.encode(Encoding::UTF_8))
+          else
+            super
+          end
         else
           super
         end
@@ -256,24 +250,13 @@ module ActiveRecord
         end
       end
 
-      def type_cast(value, column) # :nodoc:
-        return value.to_f if BigDecimal === value
-        return super unless String === value
-        return super unless column && value
-
-        value = super
-        if column.type == :string && value.encoding == Encoding::ASCII_8BIT
-          logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
-          value = value.encode Encoding::UTF_8
-        end
-        value
-      end
-
+      #--
       # DATABASE STATEMENTS ======================================
+      #++
 
       def explain(arel, binds = [])
         sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
-        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', []))
       end
 
       class ExplainPrettyPrinter
@@ -362,7 +345,7 @@ module ActiveRecord
         log('commit transaction',nil) { @connection.commit }
       end
 
-      def rollback_db_transaction #:nodoc:
+      def exec_rollback_db_transaction #:nodoc:
         log('rollback transaction',nil) { @connection.rollback }
       end
 
@@ -372,7 +355,7 @@ module ActiveRecord
         sql = <<-SQL
           SELECT name
           FROM sqlite_master
-          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+          WHERE (type = 'table' OR type = 'view') AND NOT name = 'sqlite_sequence'
         SQL
         sql << " AND name = #{quote_table_name(table_name)}" if table_name
 
@@ -380,12 +363,14 @@ module ActiveRecord
           row['name']
         end
       end
+      alias data_sources tables
 
       def table_exists?(table_name)
         table_name && tables(nil, table_name).any?
       end
+      alias data_source_exists? table_exists?
 
-      # Returns an array of +SQLite3Column+ objects for the table specified by +table_name+.
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
       def columns(table_name) #:nodoc:
         table_structure(table_name).map do |field|
           case field["dflt_value"]
@@ -397,7 +382,9 @@ module ActiveRecord
             field["dflt_value"] = $1.gsub('""', '"')
           end
 
-          SQLite3Column.new(field['name'], field['dflt_value'], field['type'], field['notnull'].to_i == 0)
+          sql_type = field['type']
+          cast_type = lookup_cast_type(sql_type)
+          new_column(field['name'], field['dflt_value'], cast_type, sql_type, field['notnull'].to_i == 0)
         end
       end
 
@@ -427,10 +414,9 @@ module ActiveRecord
       end
 
       def primary_key(table_name) #:nodoc:
-        column = table_structure(table_name).find { |field|
-          field['pk'] == 1
-        }
-        column && column['name']
+        pks = table_structure(table_name).select { |f| f['pk'] > 0 }
+        return nil unless pks.count == 1
+        pks[0]['name']
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
@@ -448,12 +434,12 @@ module ActiveRecord
 
       # See: http://www.sqlite.org/lang_altertable.html
       # SQLite has an additional restriction on the ALTER TABLE statement
-      def valid_alter_table_options( type, options)
+      def valid_alter_table_type?(type)
         type.to_sym != :primary_key
       end
 
       def add_column(table_name, column_name, type, options = {}) #:nodoc:
-        if supports_add_column? && valid_alter_table_options( type, options )
+        if valid_alter_table_type?(type)
           super(table_name, column_name, type, options)
         else
           alter_table(table_name) do |definition|
@@ -498,16 +484,16 @@ module ActiveRecord
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        unless columns(table_name).detect{|c| c.name == column_name.to_s }
-          raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
-        end
-        alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
-        rename_column_indexes(table_name, column_name, new_column_name)
+        column = column_for(table_name, column_name)
+        alter_table(table_name, rename: {column.name => new_column_name.to_s})
+        rename_column_indexes(table_name, column.name, new_column_name)
       end
 
       protected
-        def select(sql, name = nil, binds = []) #:nodoc:
-          exec_query(sql, name, binds)
+
+        def initialize_type_map(m)
+          super
+          m.register_type(/binary/i, SQLite3Binary.new)
         end
 
         def table_structure(table_name)

data/lib/active_record/connection_handling.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module ConnectionHandling
-    RAILS_ENV   = -> { (Rails.env if defined?(Rails)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
+    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
     # Establishes the connection to the database. Accepts a hash as input where