activerecord 2.3.18 → 3.2.22

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

@@ -1,3 +1,5 @@
+require 'uri'
+
 module ActiveRecord
   class Base
     class ConnectionSpecification #:nodoc:
@@ -5,12 +7,81 @@ module ActiveRecord
       def initialize (config, adapter_method)
         @config, @adapter_method = config, adapter_method
       end
+
+      ##
+      # Builds a ConnectionSpecification from user input
+      class Resolver # :nodoc:
+        attr_reader :config, :klass, :configurations
+
+        def initialize(config, configurations)
+          @config         = config
+          @configurations = configurations
+        end
+
+        def spec
+          case config
+          when nil
+            raise AdapterNotSpecified unless defined?(Rails.env)
+            resolve_string_connection Rails.env
+          when Symbol, String
+            resolve_string_connection config.to_s
+          when Hash
+            resolve_hash_connection config
+          end
+        end
+
+        private
+        def resolve_string_connection(spec) # :nodoc:
+          hash = configurations.fetch(spec) do |k|
+            connection_url_to_hash(k)
+          end
+
+          raise(AdapterNotSpecified, "#{spec} database is not configured") unless hash
+
+          resolve_hash_connection hash
+        end
+
+        def resolve_hash_connection(spec) # :nodoc:
+          spec = spec.symbolize_keys
+
+          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+          begin
+            require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
+          rescue LoadError => e
+            raise LoadError, "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{e.message})", e.backtrace
+          end
+
+          adapter_method = "#{spec[:adapter]}_connection"
+
+          ConnectionSpecification.new(spec, adapter_method)
+        end
+
+        def connection_url_to_hash(url) # :nodoc:
+          config = URI.parse url
+          adapter = config.scheme
+          adapter = "postgresql" if adapter == "postgres"
+          spec = { :adapter  => adapter,
+                   :username => config.user,
+                   :password => config.password,
+                   :port     => config.port,
+                   :database => config.path.sub(%r{^/},""),
+                   :host     => config.host }
+          spec.reject!{ |_,value| value.blank? }
+          spec.map { |key,value| spec[key] = URI.unescape(value) if value.is_a?(String) }
+          if config.query
+            options = Hash[config.query.split("&").map{ |pair| pair.split("=") }].symbolize_keys
+            spec.merge!(options)
+          end
+          spec
+        end
+      end
     end
 
     ##
     # :singleton-method:
     # The connection handler
-    class_attribute :connection_handler
+    class_attribute :connection_handler, :instance_writer => false
     self.connection_handler = ConnectionAdapters::ConnectionHandler.new
 
     # Returns the connection currently associated with the class. This can
@@ -46,84 +117,61 @@ module ActiveRecord
     #     "database"  => "path/to/dbfile"
     #   )
     #
+    # Or a URL:
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     "postgres://myuser:mypass@localhost/somedatabase"
+    #   )
+    #
     # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
     # may be returned on an error.
-    def self.establish_connection(spec = nil)
-      case spec
-        when nil
-          raise AdapterNotSpecified unless defined? RAILS_ENV
-          establish_connection(RAILS_ENV)
-        when ConnectionSpecification
-          self.connection_handler.establish_connection(name, spec)
-        when Symbol, String
-          if configuration = configurations[spec.to_s]
-            establish_connection(configuration)
-          else
-            raise AdapterNotSpecified, "#{spec} database is not configured"
-          end
-        else
-          spec = spec.symbolize_keys
-          unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
-
-          begin
-            require 'rubygems'
-            gem "activerecord-#{spec[:adapter]}-adapter"
-            require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          rescue LoadError
-            begin
-              require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-            rescue LoadError
-              raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{$!})"
-            end
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-          if !respond_to?(adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
-          end
+    def self.establish_connection(spec = ENV["DATABASE_URL"])
+      resolver = ConnectionSpecification::Resolver.new spec, configurations
+      spec = resolver.spec
 
-          remove_connection
-          establish_connection(ConnectionSpecification.new(spec, adapter_method))
+      unless respond_to?(spec.adapter_method)
+        raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
       end
+
+      remove_connection
+      connection_handler.establish_connection name, spec
     end
 
     class << self
-      # Deprecated and no longer has any effect.
-      def allow_concurrency
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_concurrency has been deprecated and no longer has any effect. Please remove all references to allow_concurrency.")
-      end
-
-      # Deprecated and no longer has any effect.
-      def allow_concurrency=(flag)
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_concurrency= has been deprecated and no longer has any effect. Please remove all references to allow_concurrency=.")
+      # Returns the connection currently associated with the class. This can
+      # also be used to "borrow" the connection to do database work unrelated
+      # to any of the specific Active Records.
+      def connection
+        retrieve_connection
       end
 
-      # Deprecated and no longer has any effect.
-      def verification_timeout
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.verification_timeout has been deprecated and no longer has any effect. Please remove all references to verification_timeout.")
+      def connection_id
+        Thread.current['ActiveRecord::Base.connection_id']
       end
 
-      # Deprecated and no longer has any effect.
-      def verification_timeout=(flag)
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.verification_timeout= has been deprecated and no longer has any effect. Please remove all references to verification_timeout=.")
+      def connection_id=(connection_id)
+        Thread.current['ActiveRecord::Base.connection_id'] = connection_id
       end
 
-      # Returns the connection currently associated with the class. This can
-      # also be used to "borrow" the connection to do database work unrelated
-      # to any of the specific Active Records.
-      def connection
-        retrieve_connection
+      # Returns the configuration of the associated connection as a hash:
+      #
+      #  ActiveRecord::Base.connection_config
+      #  # => {:pool=>5, :timeout=>5000, :database=>"db/development.sqlite3", :adapter=>"sqlite3"}
+      #
+      # Please use only for reading.
+      def connection_config
+        connection_pool.spec.config
       end
 
       def connection_pool
-        connection_handler.retrieve_connection_pool(self)
+        connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
       end
 
       def retrieve_connection
         connection_handler.retrieve_connection(self)
       end
 
-      # Returns true if +ActiveRecord+ is connected.
+      # Returns true if Active Record is connected.
       def connected?
         connection_handler.connected?(self)
       end
@@ -132,7 +180,11 @@ module ActiveRecord
         connection_handler.remove_connection(klass)
       end
 
-      delegate :clear_active_connections!, :clear_reloadable_connections!,
+      def clear_active_connections!
+        connection_handler.clear_active_connections!
+      end
+
+      delegate :clear_reloadable_connections!,
         :clear_all_connections!,:verify_active_connections!, :to => :connection_handler
     end
   end

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

@@ -2,52 +2,53 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
 
-      # the maximum length of a table alias
+      # Returns the maximum length of a table alias.
       def table_alias_length
         255
       end
 
-      # the maximum length of a column name
+      # Returns the maximum length of a column name.
       def column_name_length
         64
       end
 
-      # the maximum length of a table name
+      # Returns the maximum length of a table name.
       def table_name_length
         64
       end
 
-      # the maximum length of an index name
+      # Returns the maximum length of an index name.
       def index_name_length
         64
       end
 
-      # the maximum number of columns per table
+      # Returns the maximum number of columns per table.
       def columns_per_table
         1024
       end
 
-      # the maximum number of indexes per table
+      # Returns the maximum number of indexes per table.
       def indexes_per_table
         16
       end
 
-      # the maximum number of columns in a multicolumn index
+      # Returns the maximum number of columns in a multicolumn index.
       def columns_per_multicolumn_index
         16
       end
 
-      # the maximum number of elements in an IN (x,y,z) clause
+      # Returns the maximum number of elements in an IN (x,y,z) clause.
+      # nil means no limit.
       def in_clause_length
-        65535
+        nil
       end
 
-      # the maximum length of a SQL query
+      # Returns the maximum length of an SQL query.
       def sql_query_length
         1048575
       end
 
-      # maximum number of joins in a single query
+      # Returns maximum number of joins in a single query.
       def joins_per_query
         256
       end

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

@@ -1,30 +1,41 @@
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
+      # Converts an arel AST to SQL
+      def to_sql(arel, binds = [])
+        if arel.respond_to?(:ast)
+          visitor.accept(arel.ast) do
+            quote(*binds.shift.reverse)
+          end
+        else
+          arel
+        end
+      end
+
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
-      def select_all(sql, name = nil)
-        select(sql, name)
+      def select_all(arel, name = nil, binds = [])
+        select(to_sql(arel, binds), name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(sql, name = nil)
-        result = select_all(sql, name)
+      def select_one(arel, name = nil)
+        result = select_all(arel, name)
         result.first if result
       end
 
       # Returns a single value from a record
-      def select_value(sql, name = nil)
-        if result = select_one(sql, name)
+      def select_value(arel, name = nil)
+        if result = select_one(arel, name)
           result.values.first
         end
       end
 
       # 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(sql, name = nil)
-        result = select_rows(sql, name)
+      def select_values(arel, name = nil)
+        result = select_rows(to_sql(arel, []), name)
         result.map { |v| v[0] }
       end
 
@@ -35,25 +46,61 @@ module ActiveRecord
       undef_method :select_rows
 
       # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil, skip_logging = false)
+      def execute(sql, name = nil)
       end
       undef_method :execute
 
+      # Executes +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_query(sql, name = 'SQL', binds = [])
+      end
+
+      # Executes insert +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_insert(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes delete +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_delete(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes update +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_update(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
       # Returns the last auto-generated ID from the affected table.
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        insert_sql(sql, name, pk, id_value, sequence_name)
+      #
+      # +id_value+ will be returned unless the value is nil, in
+      # which case the database will attempt to calculate the last inserted
+      # id and return that value.
+      #
+      # 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)
+        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(sql, name = nil)
-        update_sql(sql, name)
+      def update(arel, name = nil, binds = [])
+        exec_update(to_sql(arel, binds), name, binds)
       end
 
       # Executes the delete statement and returns the number of rows affected.
-      def delete(sql, name = nil)
-        delete_sql(sql, name)
+      def delete(arel, name = nil, binds = [])
+        exec_delete(to_sql(arel, binds), name, binds)
       end
-      
+
       # Checks whether there is currently no transaction active. This is done
       # by querying the database driver, and does not use the transaction
       # house-keeping information recorded by #increment_open_transactions and
@@ -68,6 +115,12 @@ module ActiveRecord
         nil
       end
 
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        false
+      end
+
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
@@ -79,7 +132,7 @@ module ActiveRecord
       #
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
-      # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
+      # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
       # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
       #
       # It is safe to call this method if a database transaction is already open,
@@ -113,7 +166,7 @@ module ActiveRecord
       def transaction(options = {})
         options.assert_valid_keys :requires_new, :joinable
 
-        last_transaction_joinable = @transaction_joinable
+        last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
         if options.has_key?(:joinable)
           @transaction_joinable = options[:joinable]
         else
@@ -122,6 +175,8 @@ module ActiveRecord
         requires_new = options[:requires_new] || !last_transaction_joinable
 
         transaction_open = false
+        @_current_transaction_records ||= []
+
         begin
           if block_given?
             if requires_new || open_transactions == 0
@@ -132,6 +187,7 @@ module ActiveRecord
               end
               increment_open_transactions
               transaction_open = true
+              @_current_transaction_records.push([])
             end
             yield
           end
@@ -141,8 +197,10 @@ module ActiveRecord
             decrement_open_transactions
             if open_transactions == 0
               rollback_db_transaction
+              rollback_transaction_records(true)
             else
               rollback_to_savepoint
+              rollback_transaction_records(false)
             end
           end
           raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
@@ -157,20 +215,35 @@ module ActiveRecord
           begin
             if open_transactions == 0
               commit_db_transaction
+              commit_transaction_records
             else
               release_savepoint
+              save_point_records = @_current_transaction_records.pop
+              unless save_point_records.blank?
+                @_current_transaction_records.push([]) if @_current_transaction_records.empty?
+                @_current_transaction_records.last.concat(save_point_records)
+              end
             end
           rescue Exception => database_transaction_rollback
             if open_transactions == 0
               rollback_db_transaction
+              rollback_transaction_records(true)
             else
               rollback_to_savepoint
+              rollback_transaction_records(false)
             end
             raise
           end
         end
       end
-      
+
+      # Register a record with the current transaction so that its after_commit and after_rollback callbacks
+      # can be called.
+      def add_transaction_record(record)
+        last_batch = @_current_transaction_records.last
+        last_batch << record if last_batch
+      end
+
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
@@ -181,62 +254,31 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Alias for <tt>add_limit_offset!</tt>.
-      def add_limit!(sql, options)
-        add_limit_offset!(sql, options) if options
-      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 (required)
-      # and an +:offset+ option (optional).
-      #
-      # This method *modifies* the +sql+ parameter.
-      #
-      # ===== 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)}"
-          if offset = options[:offset]
-            sql << " OFFSET #{offset.to_i}"
-          end
-        end
-        sql
-      end
-
-      # Appends a locking clause to an SQL statement.
-      # This method *modifies* the +sql+ parameter.
-      #   # SELECT * FROM suppliers FOR UPDATE
-      #   add_lock! 'SELECT * FROM suppliers', :lock => true
-      #   add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
-      def add_lock!(sql, options)
-        case lock = options[:lock]
-          when true;   sql << ' FOR UPDATE'
-          when String; sql << " #{lock}"
-        end
-      end
-
       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
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
-        execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
+        columns = schema_cache.columns_hash(table_name)
+
+        key_list   = []
+        value_list = fixture.map do |name, value|
+          key_list << quote_column_name(name)
+          quote(value, columns[name])
+        end
+
+        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
       end
 
-      def empty_insert_statement(table_name)
-        "INSERT INTO #{quote_table_name(table_name)} VALUES(DEFAULT)"
+      def empty_insert_statement_value
+        "VALUES(DEFAULT)"
       end
 
       def case_sensitive_equality_operator
@@ -247,10 +289,39 @@ module ActiveRecord
         "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
       end
 
+      # 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
+      # an Arel SQL literal.
+      #
+      # 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)
+        if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
+          limit
+        elsif limit.to_s =~ /,/
+          Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
+        else
+          Integer(limit)
+        end
+      end
+
+      # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
+      # on mysql (even when aliasing the tables), but mysql allows using JOIN directly in
+      # an UPDATE statement, so in the mysql adapters we redefine this to do that.
+      def join_to_update(update, select) #:nodoc:
+        subselect = select.clone
+        subselect.projections = [update.key]
+
+        update.where update.key.in(subselect)
+      end
+
       protected
         # Returns an array of record hashes with the column names as keys and
         # column values as values.
-        def select(sql, name = nil)
+        def select(sql, name = nil, binds = [])
         end
         undef_method :select
 
@@ -270,20 +341,50 @@ module ActiveRecord
           update_sql(sql, name)
         end
 
-        # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-        #
-        # +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.
-        #
-        # 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)
-          if limit.to_s =~ /,/
-            limit.to_s.split(',').map{ |i| i.to_i }.join(',')
+        # 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)
+          if rollback
+            records = @_current_transaction_records.flatten
+            @_current_transaction_records.clear
           else
-            limit.to_i
+            records = @_current_transaction_records.pop
+          end
+
+          unless records.blank?
+            records.uniq.each do |record|
+              begin
+                record.rolledback!(rollback)
+              rescue Exception => e
+                record.logger.error(e) if record.respond_to?(:logger) && record.logger
+              end
+            end
           end
         end
+
+        # Send a commit message to all records after they have been committed.
+        def commit_transaction_records
+          records = @_current_transaction_records.flatten
+          @_current_transaction_records.clear
+          unless records.blank?
+            records.uniq.each do |record|
+              begin
+                record.committed!
+              rescue Exception => e
+                record.logger.error(e) if record.respond_to?(:logger) && record.logger
+              end
+            end
+          end
+        end
+
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        [sql, binds]
+      end
+
+      def last_inserted_id(result)
+        row = result.rows.first
+        row && row.first
+      end
     end
   end
 end