activerecord 4.1.15 → 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

data/lib/active_record/core.rb

@@ -1,6 +1,7 @@
+require 'thread'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/duplicable'
-require 'thread'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module Core
@@ -16,7 +17,6 @@ module ActiveRecord
       mattr_accessor :logger, instance_writer: false
 
       ##
-      # :singleton-method:
       # Contains the database configuration - as is typically stored in config/database.yml -
       # as a Hash.
       #
@@ -88,11 +88,14 @@ module ActiveRecord
       mattr_accessor :maintain_test_schema, instance_accessor: false
 
       def self.disable_implicit_join_references=(value)
-        ActiveSupport::Deprecation.warn("Implicit join references were removed with Rails 4.1." \
-                                        "Make sure to remove this configuration because it does nothing.")
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Implicit join references were removed with Rails 4.1.
+          Make sure to remove this configuration because it does nothing.
+        MSG
       end
 
       class_attribute :default_connection_handler, instance_writer: false
+      class_attribute :find_by_statement_cache
 
       def self.connection_handler
         ActiveRecord::RuntimeRegistry.connection_handler || default_connection_handler
@@ -106,7 +109,94 @@ module ActiveRecord
     end
 
     module ClassMethods
-      def initialize_generated_modules
+      def allocate
+        define_attribute_methods
+        super
+      end
+
+      def initialize_find_by_cache # :nodoc:
+        self.find_by_statement_cache = {}.extend(Mutex_m)
+      end
+
+      def inherited(child_class) # :nodoc:
+        child_class.initialize_find_by_cache
+        super
+      end
+
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        # Allow symbols to super to maintain compatibility for deprecated finders until Rails 5
+        return super if ids.first.kind_of?(Symbol)
+        return super if block_given? ||
+                        primary_key.nil? ||
+                        default_scopes.any? ||
+                        current_scope ||
+                        columns_hash.include?(inheritance_column) ||
+                        ids.first.kind_of?(Array)
+
+        id  = ids.first
+        if ActiveRecord::Base === id
+          id = id.id
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            You are passing an instance of ActiveRecord::Base to `find`.
+            Please pass the id of the object by calling `.id`
+          MSG
+        end
+        key = primary_key
+
+        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
+          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+            where(key => params.bind).limit(1)
+          }
+        }
+        record = s.execute([id], self, connection).first
+        unless record
+          raise RecordNotFound, "Couldn't find #{name} with '#{primary_key}'=#{id}"
+        end
+        record
+      rescue RangeError
+        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
+      end
+
+      def find_by(*args) # :nodoc:
+        return super if current_scope || !(Hash === args.first) || reflect_on_all_aggregations.any?
+        return super if default_scopes.any?
+
+        hash = args.first
+
+        return super if hash.values.any? { |v|
+          v.nil? || Array === v || Hash === v
+        }
+
+        # We can't cache Post.find_by(author: david) ...yet
+        return super unless hash.keys.all? { |k| columns_hash.has_key?(k.to_s) }
+
+        key  = hash.keys
+
+        klass = self
+        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
+          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+            wheres = key.each_with_object({}) { |param,o|
+              o[param] = params.bind
+            }
+            klass.where(wheres).limit(1)
+          }
+        }
+        begin
+          s.execute(hash.values, self, connection).first
+        rescue TypeError => e
+          raise ActiveRecord::StatementInvalid.new(e.message, e)
+        rescue RangeError
+          nil
+        end
+      end
+
+      def find_by!(*args) # :nodoc:
+        find_by(*args) or raise RecordNotFound.new("Couldn't find #{name}")
+      end
+
+      def initialize_generated_modules # :nodoc:
         generated_association_methods
       end
 
@@ -180,12 +270,8 @@ module ActiveRecord
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil, options = {})
-      defaults = self.class.column_defaults.dup
-      defaults.each { |k, v| defaults[k] = v.dup if v.duplicable? }
-
-      @attributes   = self.class.initialize_attributes(defaults)
-      @column_types_override = nil
-      @column_types = self.class.column_types
+      @attributes = self.class._default_attributes.dup
+      self.class.define_attribute_methods
 
       init_internals
       initialize_internals_callback
@@ -195,32 +281,35 @@ module ActiveRecord
       init_attributes(attributes, options) if attributes
 
       yield self if block_given?
-      run_callbacks :initialize unless _initialize_callbacks.empty?
+      _run_initialize_callbacks
     end
 
-    # Initialize an empty model object from +coder+. +coder+ must contain
-    # the attributes necessary for initializing an empty model object. For
-    # example:
+    # Initialize an empty model object from +coder+. +coder+ should be
+    # the result of previously encoding an Active Record model, using
+    # `encode_with`
     #
     #   class Post < ActiveRecord::Base
     #   end
     #
+    #   old_post = Post.new(title: "hello world")
+    #   coder = {}
+    #   old_post.encode_with(coder)
+    #
     #   post = Post.allocate
-    #   post.init_with('attributes' => { 'title' => 'hello world' })
+    #   post.init_with(coder)
     #   post.title # => 'hello world'
     def init_with(coder)
-      @attributes   = self.class.initialize_attributes(coder['attributes'])
-      @column_types_override = coder['column_types']
-      @column_types = self.class.column_types
+      coder = LegacyYamlAdapter.convert(self.class, coder)
+      @attributes = coder['attributes']
 
       init_internals
 
-      @new_record = false
+      @new_record = coder['new_record']
 
       self.class.define_attribute_methods
 
-      run_callbacks :find
-      run_callbacks :initialize
+      _run_find_callbacks
+      _run_initialize_callbacks
 
       self
     end
@@ -253,17 +342,13 @@ module ActiveRecord
 
     ##
     def initialize_dup(other) # :nodoc:
-      cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
-      self.class.initialize_attributes(cloned_attributes, :serialized => false)
-
-      @attributes = cloned_attributes
-      @attributes[self.class.primary_key] = nil
+      @attributes = @attributes.dup
+      @attributes.reset(self.class.primary_key)
 
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+      _run_initialize_callbacks
 
       @aggregation_cache = {}
       @association_cache = {}
-      @attributes_cache  = {}
 
       @new_record  = true
       @destroyed   = false
@@ -284,7 +369,11 @@ module ActiveRecord
     #   Post.new.encode_with(coder)
     #   coder # => {"attributes" => {"id" => nil, ... }}
     def encode_with(coder)
-      coder['attributes'] = attributes_for_coder
+      # FIXME: Remove this when we better serialize attributes
+      coder['raw_attributes'] = attributes_before_type_cast
+      coder['attributes'] = @attributes
+      coder['new_record'] = new_record?
+      coder['active_record_yaml_version'] = 0
     end
 
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
@@ -307,7 +396,11 @@ module ActiveRecord
     # Delegates to id in order to allow two records of the same type and id to work with something like:
     #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
     def hash
-      id.hash
+      if id
+        id.hash
+      else
+        super
+      end
     end
 
     # Clone and freeze the attributes hash such that associations are still
@@ -363,21 +456,45 @@ module ActiveRecord
       "#<#{self.class} #{inspection}>"
     end
 
+    # Takes a PP and prettily prints this record to it, allowing you to get a nice result from `pp record`
+    # when pp is required.
+    def pretty_print(pp)
+      return super if custom_inspect_method_defined?
+      pp.object_address_group(self) do
+        if defined?(@attributes) && @attributes
+          column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
+          pp.seplist(column_names, proc { pp.text ',' }) do |column_name|
+            column_value = read_attribute(column_name)
+            pp.breakable ' '
+            pp.group(1) do
+              pp.text column_name
+              pp.text ':'
+              pp.breakable
+              pp.pp column_value
+            end
+          end
+        else
+          pp.breakable ' '
+          pp.text 'not initialized'
+        end
+      end
+    end
+
     # Returns a hash of the given methods with their names as keys and returned values as values.
     def slice(*methods)
       Hash[methods.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
 
+    private
+
     def set_transaction_state(state) # :nodoc:
       @transaction_state = state
     end
 
     def has_transactional_callbacks? # :nodoc:
-      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_create_callbacks.empty?
+      !_rollback_callbacks.empty? || !_commit_callbacks.empty?
     end
 
-    private
-
     # Updates the attributes on this particular ActiveRecord object so that
     # if it is associated with a transaction, then the state of the AR object
     # will be updated to reflect the current state of the transaction
@@ -400,6 +517,8 @@ module ActiveRecord
     end
 
     def update_attributes_from_transaction_state(transaction_state, depth)
+      @reflects_state = [false] if depth == 0
+
       if transaction_state && transaction_state.finalized? && !has_transactional_callbacks?
         unless @reflects_state[depth]
           restore_transaction_record_state if transaction_state.rolledback?
@@ -426,12 +545,8 @@ module ActiveRecord
     end
 
     def init_internals
-      pk = self.class.primary_key
-      @attributes[pk] = nil unless @attributes.key?(pk)
-
       @aggregation_cache        = {}
       @association_cache        = {}
-      @attributes_cache         = {}
       @readonly                 = false
       @destroyed                = false
       @marked_for_destruction   = false
@@ -440,7 +555,6 @@ module ActiveRecord
       @txn                      = nil
       @_start_transaction_state = {}
       @transaction_state        = nil
-      @reflects_state           = [false]
     end
 
     def initialize_internals_callback
@@ -451,5 +565,15 @@ module ActiveRecord
     def init_attributes(attributes, options)
       assign_attributes(attributes)
     end
+
+    def thaw
+      if frozen?
+        @attributes = @attributes.dup
+      end
+    end
+
+    def custom_inspect_method_defined?
+      self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+    end
   end
 end