activerecord 1.0.0 → 3.0.0

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

@@ -0,0 +1,329 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module DatabaseStatements
+      # 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)
+      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)
+        result.first if result
+      end
+
+      # Returns a single value from a record
+      def select_value(sql, name = nil)
+        if result = select_one(sql, 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)
+        result.map { |v| v[0] }
+      end
+
+      # Returns an array of arrays containing the field values.
+      # Order is the same as that returned by +columns+.
+      def select_rows(sql, name = nil)
+      end
+      undef_method :select_rows
+
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil, skip_logging = false)
+      end
+      undef_method :execute
+
+      # 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)
+      end
+
+      # Executes the update statement and returns the number of rows affected.
+      def update(sql, name = nil)
+        update_sql(sql, name)
+      end
+
+      # Executes the delete statement and returns the number of rows affected.
+      def delete(sql, name = nil)
+        delete_sql(sql, name)
+      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
+      # friends.
+      #
+      # Returns true if there is no transaction active, false if there is a
+      # transaction active, and nil if this information is unknown.
+      #
+      # Not all adapters supports transaction state introspection. Currently,
+      # only the PostgreSQL adapter supports this.
+      def outside_transaction?
+        nil
+      end
+
+      # Runs the given block in a database transaction, and returns the result
+      # of the block.
+      #
+      # == Nested transactions support
+      #
+      # Most databases don't support true nested transactions. At the time of
+      # writing, the only database that supports true nested transactions that
+      # we're aware of, is MS-SQL.
+      #
+      # 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
+      # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
+      #
+      # It is safe to call this method if a database transaction is already open,
+      # i.e. if #transaction is called within another #transaction block. In case
+      # of a nested call, #transaction will behave as follows:
+      #
+      # - The block will be run without doing anything. All database statements
+      #   that happen within the block are effectively appended to the already
+      #   open database transaction.
+      # - However, if +:requires_new+ is set, the block will be wrapped in a
+      #   database savepoint acting as a sub-transaction.
+      #
+      # === Caveats
+      #
+      # MySQL doesn't support DDL transactions. If you perform a DDL operation,
+      # then any created savepoints will be automatically released. For example,
+      # if you've created a savepoint, then you execute a CREATE TABLE statement,
+      # then the savepoint that was created will be automatically released.
+      #
+      # This means that, on MySQL, you shouldn't execute DDL operations inside
+      # a #transaction call that you know might create a savepoint. Otherwise,
+      # #transaction will raise exceptions when it tries to release the
+      # already-automatically-released savepoints:
+      #
+      #   Model.connection.transaction do  # BEGIN
+      #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
+      #       Model.connection.create_table(...)
+      #       # active_record_1 now automatically released
+      #     end  # RELEASE SAVEPOINT active_record_1  <--- BOOM! database error!
+      #   end
+      def transaction(options = {})
+        options.assert_valid_keys :requires_new, :joinable
+
+        last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
+        if options.has_key?(:joinable)
+          @transaction_joinable = options[:joinable]
+        else
+          @transaction_joinable = true
+        end
+        requires_new = options[:requires_new] || !last_transaction_joinable
+
+        transaction_open = false
+        @_current_transaction_records ||= []
+
+        begin
+          if block_given?
+            if requires_new || open_transactions == 0
+              if open_transactions == 0
+                begin_db_transaction
+              elsif requires_new
+                create_savepoint
+              end
+              increment_open_transactions
+              transaction_open = true
+              @_current_transaction_records.push([])
+            end
+            yield
+          end
+        rescue Exception => database_transaction_rollback
+          if transaction_open && !outside_transaction?
+            transaction_open = false
+            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)
+        end
+      ensure
+        @transaction_joinable = last_transaction_joinable
+
+        if outside_transaction?
+          @open_transactions = 0
+        elsif transaction_open
+          decrement_open_transactions
+          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
+
+      # Commits the transaction (and turns on auto-committing).
+      def commit_db_transaction()   end
+
+      # Rolls back the transaction (and turns on auto-committing). Must be
+      # 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.
+      #
+      # ===== 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
+
+      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, ...
+      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'
+      end
+
+      def empty_insert_statement_value
+        "VALUES(DEFAULT)"
+      end
+
+      def case_sensitive_equality_operator
+        "="
+      end
+
+      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
+        "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
+      end
+
+      protected
+        # Returns an array of record hashes with the column names as keys and
+        # column values as values.
+        def select(sql, name = nil)
+        end
+        undef_method :select
+
+        # Returns the last auto-generated ID from the affected table.
+        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+          execute(sql, name)
+          id_value
+        end
+
+        # Executes the update statement and returns the number of rows affected.
+        def update_sql(sql, name = nil)
+          execute(sql, name)
+        end
+
+        # Executes the delete statement and returns the number of rows affected.
+        def delete_sql(sql, name = nil)
+          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(',')
+          else
+            limit.to_i
+          end
+        end
+
+        # 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
+          if rollback
+            records = @_current_transaction_records.flatten
+            @_current_transaction_records.clear
+          else
+            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 #:nodoc
+          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
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'active_support/core_ext/object/duplicable'
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module QueryCache
+      class << self
+        def included(base)
+          dirties_query_cache base, :insert, :update, :delete
+        end
+
+        def dirties_query_cache(base, *method_names)
+          method_names.each do |method_name|
+            base.class_eval <<-end_code, __FILE__, __LINE__ + 1
+              def #{method_name}(*)                         # def update_with_query_dirty(*args)
+                clear_query_cache if @query_cache_enabled   #   clear_query_cache if @query_cache_enabled
+                super                                       #   update_without_query_dirty(*args)
+              end                                           # end
+            end_code
+          end
+        end
+      end
+
+      attr_reader :query_cache, :query_cache_enabled
+
+      # Enable the query cache within the block.
+      def cache
+        old, @query_cache_enabled = @query_cache_enabled, true
+        yield
+      ensure
+        clear_query_cache
+        @query_cache_enabled = old
+      end
+
+      # Disable the query cache within the block.
+      def uncached
+        old, @query_cache_enabled = @query_cache_enabled, false
+        yield
+      ensure
+        @query_cache_enabled = old
+      end
+
+      # Clears the query cache.
+      #
+      # One reason you may wish to call this method explicitly is between queries
+      # that ask the database to randomize results. Otherwise the cache would see
+      # the same SQL query and repeatedly return the same result each time, silently
+      # undermining the randomness you were expecting.
+      def clear_query_cache
+        @query_cache.clear
+      end
+
+      def select_all(*args)
+        if @query_cache_enabled
+          cache_sql(args.first) { super }
+        else
+          super
+        end
+      end
+
+      private
+        def cache_sql(sql)
+          result =
+            if @query_cache.has_key?(sql)
+              ActiveSupport::Notifications.instrument("sql.active_record",
+                :sql => sql, :name => "CACHE", :connection_id => self.object_id)
+              @query_cache[sql]
+            else
+              @query_cache[sql] = yield
+            end
+
+          if Array === result
+            result.collect { |row| row.dup }
+          else
+            result.duplicable? ? result.dup : result
+          end
+        rescue TypeError
+          result
+        end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/big_decimal/conversions'
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value, column = nil)
+        # records are quoted as their primary key
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
+        case value
+          when String, ActiveSupport::Multibyte::Chars
+            value = value.to_s
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+            elsif column && [:integer, :float].include?(column.type)
+              value = column.type == :integer ? value.to_i : value.to_f
+              value.to_s
+            else
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
+          when NilClass                 then "NULL"
+          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
+          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
+          when Float, Fixnum, Bignum    then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal               then value.to_s('F')
+          else
+            if value.acts_like?(:date) || value.acts_like?(:time)
+              "'#{quoted_date(value)}'"
+            else
+              "'#{quote_string(value.to_s)}'"
+            end
+        end
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      # Quotes the column name. Defaults to no quoting.
+      def quote_column_name(column_name)
+        column_name
+      end
+
+      # Quotes the table name. Defaults to column name quoting.
+      def quote_table_name(table_name)
+        quote_column_name(table_name)
+      end
+
+      def quoted_true
+        "'t'"
+      end
+
+      def quoted_false
+        "'f'"
+      end
+
+      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)
+      end
+    end
+  end
+end