activerecord 3.1.12 → 3.2.0.rc1

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -1,14 +1,10 @@
-require 'active_support/core_ext/module/deprecation'
-
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
       # Converts an arel AST to SQL
-      def to_sql(arel, binds = [])
+      def to_sql(arel)
         if arel.respond_to?(:ast)
-          visitor.accept(arel.ast) do
-            quote(*binds.shift.reverse)
-          end
+          visitor.accept(arel.ast)
         else
           arel
         end
@@ -17,7 +13,7 @@ module ActiveRecord
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
       def select_all(arel, name = nil, binds = [])
-        select(to_sql(arel, binds), name, binds)
+        select(to_sql(arel), name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values
@@ -37,7 +33,7 @@ module ActiveRecord
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       def select_values(arel, name = nil)
-        result = select_rows(to_sql(arel, []), name)
+        result = select_rows(to_sql(arel), name)
         result.map { |v| v[0] }
       end
 
@@ -53,7 +49,7 @@ module ActiveRecord
       undef_method :execute
 
       # Executes +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes.  +name+ is logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_query(sql, name = 'SQL', binds = [])
       end
@@ -88,19 +84,19 @@ module ActiveRecord
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
+        sql, binds = sql_for_insert(to_sql(arel), pk, id_value, sequence_name, binds)
         value      = exec_insert(sql, name, binds)
         id_value || last_inserted_id(value)
       end
 
       # Executes the update statement and returns the number of rows affected.
       def update(arel, name = nil, binds = [])
-        exec_update(to_sql(arel, binds), name, binds)
+        exec_update(to_sql(arel), name, binds)
       end
 
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
-        exec_delete(to_sql(arel, binds), name, binds)
+        exec_delete(to_sql(arel), name, binds)
       end
 
       # Checks whether there is currently no transaction active. This is done
@@ -256,38 +252,13 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
-      # fragment that has the same semantics as LIMIT and OFFSET.
-      #
-      # +options+ must be a Hash which contains a +:limit+ option
-      # and an +:offset+ option.
-      #
-      # This method *modifies* the +sql+ parameter.
-      #
-      # This method is deprecated!! Stop using it!
-      #
-      # ===== Examples
-      #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
-      # generates
-      #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
-      def add_limit_offset!(sql, options)
-        if limit = options[:limit]
-          sql << " LIMIT #{sanitize_limit(limit)}"
-        end
-        if offset = options[:offset]
-          sql << " OFFSET #{offset.to_i}"
-        end
-        sql
-      end
-      deprecate :add_limit_offset!
-
       def default_sequence_name(table, column)
         nil
       end
 
       # Set the sequence to the max value of the table's column.
       def reset_sequence!(table, column, sequence = nil)
-        # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
+        # Do nothing by default. Implement for PostgreSQL, Oracle, ...
       end
 
       # Inserts the given fixture into the table. Overridden in adapters that require
@@ -319,10 +290,10 @@ module ActiveRecord
       # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
       #
       # The +limit+ may be anything that can evaluate to a string via #to_s. It
-      # should look like an integer, or a comma-delimited list of integers, or 
+      # should look like an integer, or a comma-delimited list of integers, or
       # an Arel SQL literal.
       #
-      # Returns Integer and Arel::Nodes::SqlLiteral limits as is. 
+      # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
       # Returns the sanitized limit parameter, either as an integer, or as a
       # string which contains a comma-delimited list of integers.
       def sanitize_limit(limit)
@@ -370,7 +341,7 @@ module ActiveRecord
 
         # Send a rollback message to all records after they have been rolled back. If rollback
         # is false, only rollback records since the last save point.
-        def rollback_transaction_records(rollback) #:nodoc
+        def rollback_transaction_records(rollback)
           if rollback
             records = @_current_transaction_records.flatten
             @_current_transaction_records.clear
@@ -390,7 +361,7 @@ module ActiveRecord
         end
 
         # Send a commit message to all records after they have been committed.
-        def commit_transaction_records #:nodoc
+        def commit_transaction_records
           records = @_current_transaction_records.flatten
           @_current_transaction_records.clear
           unless records.blank?

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -57,7 +57,7 @@ module ActiveRecord
 
       def select_all(arel, name = nil, binds = [])
         if @query_cache_enabled
-          sql = to_sql(arel, binds)
+          sql = to_sql(arel)
           cache_sql(sql, binds) { super(sql, name, binds) }
         else
           super

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -102,10 +102,13 @@ module ActiveRecord
       def quoted_date(value)
         if value.acts_like?(:time)
           zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-          value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
-        else
-          value
-        end.to_s(:db)
+
+          if value.respond_to?(zone_conversion_method)
+            value = value.send(zone_conversion_method)
+          end
+        end
+
+        value.to_s(:db)
       end
     end
   end

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -6,7 +6,7 @@ require 'bigdecimal/util'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
-    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders) #:nodoc:
     end
 
     # Abstract representation of a column definition. Instances of this type
@@ -66,6 +66,7 @@ module ActiveRecord
 
       def initialize(base)
         @columns = []
+        @columns_hash = {}
         @base = base
       end
 
@@ -86,7 +87,7 @@ module ActiveRecord
 
       # Returns a ColumnDefinition for the column with name +name+.
       def [](name)
-        @columns.find {|column| column.name.to_s == name.to_s}
+        @columns_hash[name.to_s]
       end
 
       # Instantiates a new column for the table.
@@ -224,35 +225,38 @@ module ActiveRecord
       #     t.references :taggable, :polymorphic => { :default => 'Photo' }
       #   end
       def column(name, type, options = {})
-        column = self[name] || ColumnDefinition.new(@base, name, type)
-        if options[:limit]
-          column.limit = options[:limit]
-        elsif native[type.to_sym].is_a?(Hash)
-          column.limit = native[type.to_sym][:limit]
+        name = name.to_s
+        type = type.to_sym
+
+        column = self[name] || new_column_definition(@base, name, type)
+
+        limit = options.fetch(:limit) do
+          native[type][:limit] if native[type].is_a?(Hash)
         end
+
+        column.limit     = limit
         column.precision = options[:precision]
-        column.scale = options[:scale]
-        column.default = options[:default]
-        column.null = options[:null]
-        @columns << column unless @columns.include? column
+        column.scale     = options[:scale]
+        column.default   = options[:default]
+        column.null      = options[:null]
         self
       end
 
       %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
-          def #{column_type}(*args)                                               # def string(*args)
-            options = args.extract_options!                                       #   options = args.extract_options!
-            column_names = args                                                   #   column_names = args
-                                                                                  #
-            column_names.each { |name| column(name, '#{column_type}', options) }  #   column_names.each { |name| column(name, 'string', options) }
-          end                                                                     # end
+          def #{column_type}(*args)                                   # def string(*args)
+            options = args.extract_options!                           #   options = args.extract_options!
+            column_names = args                                       #   column_names = args
+            type = :'#{column_type}'                                  #   type = :string
+            column_names.each { |name| column(name, type, options) }  #   column_names.each { |name| column(name, type, options) }
+          end                                                         # end
         EOV
       end
 
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
       # <tt>:updated_at</tt> to the table.
       def timestamps(*args)
-        options = args.extract_options!
+        options = { :null => false }.merge(args.extract_options!)
         column(:created_at, :datetime, options)
         column(:updated_at, :datetime, options)
       end
@@ -275,9 +279,16 @@ module ActiveRecord
       end
 
       private
-        def native
-          @base.native_database_types
-        end
+      def new_column_definition(base, name, type)
+        definition = ColumnDefinition.new base, name, type
+        @columns << definition
+        @columns_hash[name] = definition
+        definition
+      end
+
+      def native
+        @base.native_database_types
+      end
     end
 
     # Represents an SQL table in an abstract way for updating a table.
@@ -453,13 +464,13 @@ module ActiveRecord
           def #{column_type}(*args)                                          # def string(*args)
             options = args.extract_options!                                  #   options = args.extract_options!
             column_names = args                                              #   column_names = args
-                                                                             #
+            type = :'#{column_type}'                                         #   type = :string
             column_names.each do |name|                                      #   column_names.each do |name|
-              column = ColumnDefinition.new(@base, name, '#{column_type}')   #     column = ColumnDefinition.new(@base, name, 'string')
+              column = ColumnDefinition.new(@base, name.to_s, type)          #     column = ColumnDefinition.new(@base, name, type)
               if options[:limit]                                             #     if options[:limit]
                 column.limit = options[:limit]                               #       column.limit = options[:limit]
-              elsif native['#{column_type}'.to_sym].is_a?(Hash)              #     elsif native['string'.to_sym].is_a?(Hash)
-                column.limit = native['#{column_type}'.to_sym][:limit]       #       column.limit = native['string'.to_sym][:limit]
+              elsif native[type].is_a?(Hash)                                 #     elsif native[type].is_a?(Hash)
+                column.limit = native[type][:limit]                          #       column.limit = native[type][:limit]
               end                                                            #     end
               column.precision = options[:precision]                         #     column.precision = options[:precision]
               column.scale = options[:scale]                                 #     column.scale = options[:scale]

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1,10 +1,11 @@
 require 'active_support/core_ext/array/wrap'
+require 'active_support/deprecation/reporting'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module SchemaStatements
       # Returns a Hash of mappings from the abstract data types to the native
-      # database types.  See TableDefinition#column for details on the recognized
+      # database types. See TableDefinition#column for details on the recognized
       # abstract data types.
       def native_database_types
         {}
@@ -15,8 +16,6 @@ module ActiveRecord
         table_name[0...table_alias_length].gsub(/\./, '_')
       end
 
-      # def tables(name = nil) end
-
       # Checks to see if the table +table_name+ exists on the database.
       #
       # === Example
@@ -78,7 +77,7 @@ module ActiveRecord
       # Creates a new table with the name +table_name+. +table_name+ may either
       # be a String or a Symbol.
       #
-      # There are two ways to work with +create_table+.  You can use the block
+      # There are two ways to work with +create_table+. You can use the block
       # form or the regular form, like this:
       #
       # === Block form
@@ -113,7 +112,7 @@ module ActiveRecord
       #   Defaults to +id+. If <tt>:id</tt> is false this option is ignored.
       #
       #   Also note that this just sets the primary key in the table. You additionally
-      #   need to configure the primary key in the model via the +set_primary_key+ macro.
+      #   need to configure the primary key in the model via +self.primary_key=+.
       #   Models do NOT auto-detect the primary key from their table definition.
       #
       # [<tt>:options</tt>]
@@ -161,7 +160,7 @@ module ActiveRecord
         yield td if block_given?
 
         if options[:force] && table_exists?(table_name)
-          drop_table(table_name, options)
+          drop_table(table_name)
         end
 
         create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
@@ -253,7 +252,7 @@ module ActiveRecord
       end
 
       # Drops a table from the database.
-      def drop_table(table_name, options = {})
+      def drop_table(table_name)
         execute "DROP TABLE #{quote_table_name(table_name)}"
       end
 
@@ -299,7 +298,7 @@ module ActiveRecord
         raise NotImplementedError, "rename_column is not implemented"
       end
 
-      # Adds a new index to the table.  +column_name+ can be a single Symbol, or
+      # Adds a new index to the table. +column_name+ can be a single Symbol, or
       # an Array of Symbols.
       #
       # The index will be named after the table and the first column name,
@@ -339,6 +338,14 @@ module ActiveRecord
       #  CREATE INDEX by_name_surname ON accounts(name(10), surname(15))
       #
       # Note: SQLite doesn't support index length
+      #
+      # ====== Creating an index with a sort order (desc or asc, asc is the default)
+      #  add_index(:accounts, [:branch_id, :party_id, :surname], :order => {:branch_id => :desc, :part_id => :asc})
+      # generates
+      #  CREATE INDEX by_branch_desc_party ON accounts(branch_id DESC, party_id ASC, surname)
+      #
+      # Note: mysql doesn't yet support index order (it accepts the syntax but ignores it)
+      #
       def add_index(table_name, column_name, options = {})
         index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
         execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})"
@@ -405,7 +412,7 @@ module ActiveRecord
 
       def dump_schema_information #:nodoc:
         sm_table = ActiveRecord::Migrator.schema_migrations_table_name
-        migrated = select_values("SELECT version FROM #{sm_table}")
+        migrated = select_values("SELECT version FROM #{sm_table} ORDER BY version")
         migrated.map { |v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}');" }.join("\n\n")
       end
 
@@ -426,6 +433,7 @@ module ActiveRecord
           si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix
 
           if table_exists?(si_table)
+            ActiveRecord::Deprecation.warn "Usage of the schema table `#{si_table}` is deprecated. Please switch to using `schema_migrations` table"
 
             old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i
             assume_migrated_upto_version(old_version)
@@ -507,8 +515,8 @@ module ActiveRecord
       # ===== Examples
       #  add_timestamps(:suppliers)
       def add_timestamps(table_name)
-        add_column table_name, :created_at, :datetime
-        add_column table_name, :updated_at, :datetime
+        add_column table_name, :created_at, :datetime, :null => false
+        add_column table_name, :updated_at, :datetime, :null => false
       end
 
       # Removes the timestamp columns (created_at and updated_at) from the table definition.
@@ -520,9 +528,29 @@ module ActiveRecord
       end
 
       protected
+        def add_index_sort_order(option_strings, column_names, options = {})
+          if options.is_a?(Hash) && order = options[:order]
+            case order
+            when Hash
+              column_names.each {|name| option_strings[name] += " #{order[name].to_s.upcase}" if order.has_key?(name)}
+            when String
+              column_names.each {|name| option_strings[name] += " #{order.upcase}"}
+            end
+          end
+
+          return option_strings
+        end
+
         # Overridden by the mysql adapter for supporting index lengths
         def quoted_columns_for_index(column_names, options = {})
-          column_names.map {|name| quote_column_name(name) }
+          option_strings = Hash[column_names.map {|name| [name, '']}]
+
+          # add index sort order if supported
+          if supports_index_sort_order?
+            option_strings = add_index_sort_order(option_strings, column_names, options)
+          end
+
+          column_names.map {|name| quote_column_name(name) + option_strings[name]}
         end
 
         def options_include_default?(options)
@@ -564,7 +592,7 @@ module ActiveRecord
         def columns_for_remove(table_name, *column_names)
           column_names = column_names.flatten
 
-          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.blank?
+          raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.blank?
           column_names.map {|column_name| quote_column_name(column_name) }
         end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -3,21 +3,34 @@ require 'bigdecimal'
 require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
 require 'active_support/deprecation'
-
-# TODO: Autoload these files
-require 'active_record/connection_adapters/column'
-require 'active_record/connection_adapters/abstract/schema_definitions'
-require 'active_record/connection_adapters/abstract/schema_statements'
-require 'active_record/connection_adapters/abstract/database_statements'
-require 'active_record/connection_adapters/abstract/quoting'
-require 'active_record/connection_adapters/abstract/connection_pool'
-require 'active_record/connection_adapters/abstract/connection_specification'
-require 'active_record/connection_adapters/abstract/query_cache'
-require 'active_record/connection_adapters/abstract/database_limits'
-require 'active_record/result'
+require 'active_record/connection_adapters/schema_cache'
+require 'monitor'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :Column
+
+    autoload_under 'abstract' do
+      autoload :IndexDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
+      autoload :ColumnDefinition, 'active_record/connection_adapters/abstract/schema_definitions'
+      autoload :TableDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
+      autoload :Table,            'active_record/connection_adapters/abstract/schema_definitions'
+
+      autoload :SchemaStatements
+      autoload :DatabaseStatements
+      autoload :DatabaseLimits
+      autoload :Quoting
+
+      autoload :ConnectionPool
+      autoload :ConnectionHandler,       'active_record/connection_adapters/abstract/connection_pool'
+      autoload :ConnectionManagement,    'active_record/connection_adapters/abstract/connection_pool'
+      autoload :ConnectionSpecification
+
+      autoload :QueryCache
+    end
+
     # Active Record supports multiple database systems. AbstractAdapter and
     # related classes form the abstraction layer which makes this possible.
     # An AbstractAdapter represents a connection to a database, and provides an
@@ -36,39 +49,44 @@ module ActiveRecord
       include DatabaseLimits
       include QueryCache
       include ActiveSupport::Callbacks
+      include MonitorMixin
 
       define_callbacks :checkout, :checkin
 
-      attr_accessor :visitor
-      attr_reader :logger
-
-      def initialize(connection, logger = nil) #:nodoc:
-        @active = nil
-        @connection, @logger = connection, logger
+      attr_accessor :visitor, :pool
+      attr_reader :schema_cache, :last_use, :in_use
+      alias :in_use? :in_use
+
+      def initialize(connection, logger = nil, pool = nil) #:nodoc:
+        super()
+
+        @active              = nil
+        @connection          = connection
+        @in_use              = false
+        @instrumenter        = ActiveSupport::Notifications.instrumenter
+        @last_use            = false
+        @logger              = logger
+        @open_transactions   = 0
+        @pool                = pool
+        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
         @query_cache_enabled = false
-        @query_cache = Hash.new { |h,sql| h[sql] = {} }
-        @instrumenter = ActiveSupport::Notifications.instrumenter
-        @visitor = nil
-      end
-
-      # Returns a visitor instance for this adaptor, which conforms to the Arel::ToSql interface
-      def self.visitor_for(pool) # :nodoc:
-        adapter = pool.spec.config[:adapter]
-
-        if Arel::Visitors::VISITORS[adapter]
-          ActiveSupport::Deprecation.warn(
-            "Arel::Visitors::VISITORS is deprecated and will be removed. Database adapters " \
-            "should define a visitor_for method which returns the appropriate visitor for " \
-            "the database. For example, MysqlAdapter.visitor_for(pool) returns " \
-            "Arel::Visitors::MySQL.new(pool)."
-          )
-
-          Arel::Visitors::VISITORS[adapter].new(pool)
-        else
-          Arel::Visitors::ToSql.new(pool)
+        @schema_cache        = SchemaCache.new self
+        @visitor             = nil
+      end
+
+      def lease
+        synchronize do
+          unless in_use
+            @in_use   = true
+            @last_use = Time.now
+          end
         end
       end
 
+      def expire
+        @in_use = false
+      end
+
       # Returns the human-readable name of the adapter. Use mixed case - one
       # can always use downcase if needed.
       def adapter_name
@@ -119,6 +137,17 @@ module ActiveRecord
         false
       end
 
+      # Does this adapter support index sort order?
+      def supports_index_sort_order?
+        false
+      end
+
+      # Does this adapter support explain? As of this writing sqlite3,
+      # mysql2, and postgresql are the only ones that do.
+      def supports_explain?
+        false
+      end
+
       # QUOTING ==================================================
 
       # Override to return the quoted table name. Defaults to column quoting.
@@ -129,7 +158,7 @@ module ActiveRecord
       # Returns a bind substitution value given a +column+ and list of current
       # +binds+
       def substitute_at(column, index)
-        Arel::Nodes::BindParam.new '?'
+        Arel.sql '?'
       end
 
       # REFERENTIAL INTEGRITY ====================================
@@ -200,12 +229,9 @@ module ActiveRecord
         @connection
       end
 
-      def open_transactions
-        @open_transactions ||= 0
-      end
+      attr_reader :open_transactions
 
       def increment_open_transactions
-        @open_transactions ||= 0
         @open_transactions += 1
       end
 
@@ -230,10 +256,19 @@ module ActiveRecord
         node
       end
 
+      def case_insensitive_comparison(table, attribute, column, value)
+        table[attribute].lower.eq(table.lower(value))
+      end
+
       def current_savepoint_name
         "active_record_#{open_transactions}"
       end
 
+      # Check the connection back in to the connection pool
+      def close
+        pool.checkin self
+      end
+
       protected
 
         def log(sql, name = "SQL", binds = [])