activerecord 1.0.0 → 4.0.0

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,326 +1,440 @@
-require 'benchmark'
 require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'active_support/core_ext/benchmark'
+require 'active_record/connection_adapters/schema_cache'
+require 'active_record/connection_adapters/abstract/schema_dumper'
+require 'monitor'
 
 module ActiveRecord
-  class Base
-    class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
-      def initialize (config, adapter_method)
-        @config, @adapter_method = config, adapter_method
-      end
+  module ConnectionAdapters # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :Column
+    autoload :ConnectionSpecification
+
+    autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
+      autoload :IndexDefinition
+      autoload :ColumnDefinition
+      autoload :TableDefinition
+      autoload :Table
+      autoload :AlterTable
     end
 
-    # The class -> [adapter_method, config] map
-    @@defined_connections = {}
+    autoload_at 'active_record/connection_adapters/abstract/connection_pool' do
+      autoload :ConnectionHandler
+      autoload :ConnectionManagement
+    end
 
-    # Establishes the connection to the database. Accepts a hash as input where
-    # the :adapter key must be specified with the name of a database adapter (in lower-case)
-    # example for regular databases (MySQL, Postgresql, etc):
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     :adapter  => "mysql",
-    #     :host     => "localhost",
-    #     :username => "myuser",
-    #     :password => "mypass",
-    #     :database => "somedatabase"
-    #   )
-    #
-    # Example for SQLite database:
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     :adapter => "sqlite",
-    #     :dbfile  => "path/to/dbfile"
-    #   )
-    #
-    # Also accepts keys as strings (for parsing from yaml for example):
-    #   ActiveRecord::Base.establish_connection(
-    #     "adapter" => "sqlite",
-    #     "dbfile"  => "path/to/dbfile"
-    #   )
-    #
-    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
-    # may be returned on an error.
-    #
-    # == Connecting to another database for a single model
-    #
-    # To support different connections for different classes, you can
-    # simply call establish_connection with the classes you wish to have
-    # different connections for:
+    autoload_under 'abstract' do
+      autoload :SchemaStatements
+      autoload :DatabaseStatements
+      autoload :DatabaseLimits
+      autoload :Quoting
+      autoload :ConnectionPool
+      autoload :QueryCache
+    end
+
+    autoload_at 'active_record/connection_adapters/abstract/transaction' do
+      autoload :ClosedTransaction
+      autoload :RealTransaction
+      autoload :SavepointTransaction
+    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
+    # abstract interface for database-specific functionality such as establishing
+    # a connection, escaping values, building the right SQL fragments for ':offset'
+    # and ':limit' options, etc.
     #
-    #   class Courses < ActiveRecord::Base
-    #    ...
-    #   end
+    # All the concrete database adapters follow the interface laid down in this class.
+    # ActiveRecord::Base.connection returns an AbstractAdapter object, which
+    # you can use.
     #
-    #   Courses.establish_connection( ... )
-    def self.establish_connection(spec)
-      if spec.instance_of? ConnectionSpecification
-        @@defined_connections[self] = spec
-      else
-        if spec.nil? then raise AdapterNotSpecified end
-        symbolize_strings_in_hash(spec)
-        unless spec.key?(:adapter) then raise AdapterNotSpecified end
-    
-        adapter_method = "#{spec[:adapter]}_connection"
-        unless methods.include?(adapter_method) then raise AdapterNotFound end
-        remove_connection
-        @@defined_connections[self] = ConnectionSpecification.new(spec, adapter_method)
-      end
-    end
-    
-    # Locate the connection of the nearest super class. This can be an
-    # active or defined connections: if it is the latter, it will be
-    # opened and set as the active connection for the class it was defined
-    # for (not necessarily the current class).
-    def self.retrieve_connection #:nodoc:
-      klass = self
-      until klass == ActiveRecord::Base.superclass
-        Thread.current['active_connections'] ||= {}
-        if Thread.current['active_connections'][klass]
-          return Thread.current['active_connections'][klass]
-        elsif @@defined_connections[klass]
-          klass.connection = @@defined_connections[klass]
-          return self.connection
+    # Most of the methods in the adapter are useful during migrations. Most
+    # notably, the instance methods provided by SchemaStatement are very useful.
+    class AbstractAdapter
+      include Quoting, DatabaseStatements, SchemaStatements
+      include DatabaseLimits
+      include QueryCache
+      include ActiveSupport::Callbacks
+      include MonitorMixin
+      include ColumnDumper
+
+      SIMPLE_INT = /\A\d+\z/
+
+      define_callbacks :checkout, :checkin
+
+      attr_accessor :visitor, :pool
+      attr_reader :schema_cache, :last_use, :in_use, :logger
+      alias :in_use? :in_use
+
+      def self.type_cast_config_to_integer(config)
+        if config =~ SIMPLE_INT
+          config.to_i
+        else
+          config
         end
-        klass = klass.superclass
       end
-      raise ConnectionNotEstablished
-    end
-    
-    # Returns true if a connection that's accessible to this class have already been opened.
-    def self.connected?
-      klass = self
-      until klass == ActiveRecord::Base.superclass
-        if Thread.current['active_connections'].is_a?(Hash) && Thread.current['active_connections'][klass]
-          return true 
+
+      def self.type_cast_config_to_boolean(config)
+        if config == "false"
+          false
         else
-          klass = klass.superclass
+          config
         end
       end
-      return false
-    end
-    
-    # Remove the connection for this class. This will close the active
-    # connection and the defined connection (if they exist). The result
-    # can be used as argument for establish_connection, for easy
-    # re-establishing of the connection.
-    def self.remove_connection(klass=self)
-      conn = @@defined_connections[klass]
-      @@defined_connections.delete(klass)
-      Thread.current['active_connections'] ||= {}
-      Thread.current['active_connections'][klass] = nil
-      conn.config if conn
-    end
-    
-    # Set the connection for the class.
-    def self.connection=(spec)
-      raise ConnectionNotEstablished unless spec
-      conn = self.send(spec.adapter_method, spec.config)
-      Thread.current['active_connections'] ||= {}
-      Thread.current['active_connections'][self] = conn
-    end
 
-    # Converts all strings in a hash to symbols.
-    def self.symbolize_strings_in_hash(hash)
-      hash.each do |key, value|
-        if key.class == String
-          hash.delete key
-          hash[key.intern] = value
-        end
+      def initialize(connection, logger = nil, pool = nil) #:nodoc:
+        super()
+
+        @connection          = connection
+        @in_use              = false
+        @instrumenter        = ActiveSupport::Notifications.instrumenter
+        @last_use            = false
+        @logger              = logger
+        @pool                = pool
+        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
+        @query_cache_enabled = false
+        @schema_cache        = SchemaCache.new self
+        @visitor             = nil
       end
-    end
-  end
 
-  module ConnectionAdapters # :nodoc:
-    class Column # :nodoc:
-      attr_reader :name, :default, :type, :limit
-      # The name should contain the name of the column, such as "name" in "name varchar(250)"
-      # The default should contain the type-casted default of the column, such as 1 in "count int(11) DEFAULT 1"
-      # The type parameter should either contain :integer, :float, :datetime, :date, :text, or :string
-      # The sql_type is just used for extracting the limit, such as 10 in "varchar(10)"
-      def initialize(name, default, sql_type = nil)
-        @name, @default, @type = name, default, simplified_type(sql_type)
-        @limit = extract_limit(sql_type) unless sql_type.nil?
-      end
-
-      def default
-        type_cast(@default)
-      end
-
-      def klass
-        case type
-          when :integer       then Fixnum
-          when :float         then Float
-          when :datetime      then Time
-          when :date          then Date
-          when :text, :string then String
-          when :boolean       then Object
-        end
+      def valid_type?(type)
+        true
       end
-      
-      def type_cast(value)
-        if value.nil? then return nil end
-        case type
-          when :string   then value
-          when :text     then value
-          when :integer  then value.to_i
-          when :float    then value.to_f
-          when :datetime then string_to_time(value)
-          when :date     then string_to_date(value)
-          when :boolean  then (value == "t" or value == true ? true : false)
-          else value
+
+      class SchemaCreation
+        def initialize(conn)
+          @conn  = conn
+          @cache = {}
+        end
+
+        def accept(o)
+          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+          send m, o
+        end
+
+        private
+
+        def visit_AlterTable(o)
+          sql = "ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+        end
+
+        def visit_AddColumn(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(sql, column_options(o))
+        end
+
+        def visit_ColumnDefinition(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.primary_key?
+          column_sql
+        end
+
+        def visit_TableDefinition(o)
+          create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
+          create_sql << "#{quote_table_name(o.name)} ("
+          create_sql << o.columns.map { |c| accept c }.join(', ')
+          create_sql << ") #{o.options}"
+          create_sql
+        end
+
+        def column_options(o)
+          column_options = {}
+          column_options[:null] = o.null unless o.null.nil?
+          column_options[:default] = o.default unless o.default.nil?
+          column_options[:column] = o
+          column_options
         end
-      end
-      
-      def human_name
-        Base.human_attribute_name(@name)
-      end
 
-      private
-        def string_to_date(string)
-          return string if Date === string
-          date_array = ParseDate.parsedate(string)
-          # treat 0000-00-00 as nil
-          Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
+        def quote_column_name(name)
+          @conn.quote_column_name name
         end
-        
-        def string_to_time(string)
-          return string if Time === string
-          time_array = ParseDate.parsedate(string).compact
-          # treat 0000-00-00 00:00:00 as nil
-          Time.local(*time_array) rescue nil
+
+        def quote_table_name(name)
+          @conn.quote_table_name name
         end
 
-        def extract_limit(sql_type)
-          $1.to_i if sql_type =~ /\((.*)\)/
+        def type_to_sql(type, limit, precision, scale)
+          @conn.type_to_sql type.to_sym, limit, precision, scale
         end
 
-        def simplified_type(field_type)
-          case field_type
-            when /int/i
-              :integer
-            when /float|double|decimal|numeric/i
-              :float
-            when /time/i
-              :datetime
-            when /date/i
-              :date
-            when /(c|b)lob/i, /text/i
-              :text
-            when /char/i, /string/i
-              :string
-            when /boolean/i
-              :boolean
+        def add_column_options!(column_sql, column_options)
+          @conn.add_column_options! column_sql, column_options
+          column_sql
+        end
+      end
+
+      def schema_creation
+        SchemaCreation.new self
+      end
+
+      def lease
+        synchronize do
+          unless in_use
+            @in_use   = true
+            @last_use = Time.now
           end
         end
-    end
+      end
 
-    # All the concrete database adapters follow the interface laid down in this class.
-    # You can use this interface directly by borrowing the database connection from the Base with
-    # Base.connection.
-    class AbstractAdapter
-      @@row_even = true
+      def schema_cache=(cache)
+        cache.connection = self
+        @schema_cache = cache
+      end
+
+      def expire
+        @in_use = false
+      end
+
+      def unprepared_visitor
+        self.class::BindSubstitution.new self
+      end
+
+      def unprepared_statement
+        old, @visitor = @visitor, unprepared_visitor
+        yield
+      ensure
+        @visitor = old
+      end
 
-      include Benchmark
+      # Returns the human-readable name of the adapter. Use mixed case - one
+      # can always use downcase if needed.
+      def adapter_name
+        'Abstract'
+      end
 
-      def initialize(connection, logger = nil) # :nodoc:
-        @connection, @logger = connection, logger
-        @runtime = 0
+      # Does this adapter support migrations? Backend specific, as the
+      # abstract adapter always returns +false+.
+      def supports_migrations?
+        false
       end
 
-      # Returns an array of record hashes with the column names as a keys and fields as values.
-      def select_all(sql, name = nil) end
-      
-      # Returns a record hash with the column names as a keys and fields as values.
-      def select_one(sql, name = nil) end
+      # Can this adapter determine the primary key for tables not attached
+      # to an Active Record class, such as join tables? Backend specific, as
+      # the abstract adapter always returns +false+.
+      def supports_primary_key?
+        false
+      end
 
-      # Returns an array of column objects for the table specified by +table_name+.
-      def columns(table_name, name = nil) end
+      # Does this adapter support using DISTINCT within COUNT? This is +true+
+      # for all adapters except sqlite.
+      def supports_count_distinct?
+        true
+      end
 
-      # Returns the last auto-generated ID from the affected table.
-      def insert(sql, name = nil, pk = nil, id_value = nil) end
+      # Does this adapter support DDL rollbacks in transactions? That is, would
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
+      # SQL Server, and others support this. MySQL and others do not.
+      def supports_ddl_transactions?
+        false
+      end
 
-      # Executes the update statement.
-      def update(sql, name = nil) end
+      def supports_bulk_alter?
+        false
+      end
 
-      # Executes the delete statement.
-      def delete(sql, name = nil) end
+      # Does this adapter support savepoints? PostgreSQL and MySQL do,
+      # SQLite < 3.6.8 does not.
+      def supports_savepoints?
+        false
+      end
 
-      def reset_runtime # :nodoc:
-        rt = @runtime
-        @runtime = 0
-        return rt
+      # Should primary key values be selected from their corresponding
+      # sequence before the insert statement? If true, next_sequence_value
+      # is called before each insert to set the record's primary key.
+      # This is false for all adapters but Firebird.
+      def prefetch_primary_key?(table_name = nil)
+        false
       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
+      # Does this adapter support index sort order?
+      def supports_index_sort_order?
+        false
+      end
 
-      # Rollsback 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
+      # Does this adapter support partial indices?
+      def supports_partial_index?
+        false
+      end
 
-      def quote(value, column = nil)
-        case value
-          when String                      then "'#{value.gsub(/\\/,'\&\&').gsub(/'/, "''")}'" # ' (for ruby-mode)
-          when NilClass                    then "NULL"
-          when TrueClass                   then (column && column.type == :boolean ? "'t'" : "1")
-          when FalseClass                  then (column && column.type == :boolean ? "'f'" : "0")
-          when Float, Fixnum, Bignum, Date then "'#{value.to_s}'" 
-          when Time, DateTime              then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-          else                                  "'#{value.to_yaml.gsub(/'/, "''")}'"
-        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
 
-      def quote_column_name(name)
-        return name
+      # Does this adapter support setting the isolation level for a transaction?
+      def supports_transaction_isolation?
+        false
       end
 
-      # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
-      def structure_dump() end
+      # Does this adapter support database extensions? As of this writing only
+      # postgresql does.
+      def supports_extensions?
+        false
+      end
 
-      protected
-        def log(sql, name, connection, &action)
-          begin
-            if @logger.nil?
-              action.call(connection)
-            else
-              result = nil
-              bm = measure { result = action.call(connection) }
-              @runtime += bm.real
-              log_info(sql, name, bm.real)
-              result
-            end
-          rescue => e
-            log_info("#{e.message}: #{sql}", name, 0)
-            raise ActiveRecord::StatementInvalid, "#{e.message}: #{sql}"
-          end
-        end
+      # A list of extensions, to be filled in by adapters that support them. At
+      # the moment only postgresql does.
+      def extensions
+        []
+      end
 
-        def log_info(sql, name, runtime)
-          if @logger.nil? then return end
+      # A list of index algorithms, to be filled by adapters that support them.
+      # MySQL and PostgreSQL have support for them right now.
+      def index_algorithms
+        {}
+      end
 
-          @logger.info(
-            format_log_entry(
-              "#{name.nil? ? "SQL" : name} (#{sprintf("%f", runtime)})", 
-              sql.gsub(/ +/, " ")
-            )
-          )
-        end
+      # QUOTING ==================================================
 
-        def format_log_entry(message, dump = nil)
-          if @@row_even then
-            @@row_even = false; caller_color = "1;32"; message_color = "4;33"; dump_color = "1;37"
-          else
-            @@row_even = true; caller_color = "1;36"; message_color = "4;35"; dump_color = "0;37"
-          end
-          
-          log_entry = "  \e[#{message_color}m#{message}\e[m"
-          log_entry << "   \e[#{dump_color}m%s\e[m" % dump if dump.kind_of?(String) && !dump.nil?
-          log_entry << "   \e[#{dump_color}m%p\e[m" % dump if !dump.kind_of?(String) && !dump.nil?
-          log_entry
-        end
+      # Returns a bind substitution value given a +column+ and list of current
+      # +binds+.
+      def substitute_at(column, index)
+        Arel::Nodes::BindParam.new '?'
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      # Override to turn off referential integrity while executing <tt>&block</tt>.
+      def disable_referential_integrity
+        yield
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      # Checks whether the connection to the database is still active. This includes
+      # checking whether the database is actually capable of responding, i.e. whether
+      # the connection isn't stale.
+      def active?
+      end
+
+      # Disconnects from the database if already connected, and establishes a
+      # new connection with the database. Implementors should call super if they
+      # override the default implementation.
+      def reconnect!
+        clear_cache!
+        reset_transaction
+      end
+
+      # Disconnects from the database if already connected. Otherwise, this
+      # method does nothing.
+      def disconnect!
+        clear_cache!
+        reset_transaction
+      end
+
+      # Reset the state of this connection, directing the DBMS to clear
+      # transactions and other connection-related server-side state. Usually a
+      # database-dependent operation.
+      #
+      # The default implementation does nothing; the implementation should be
+      # overridden by concrete adapters.
+      def reset!
+        # this should be overridden by concrete adapters
+      end
+
+      ###
+      # Clear any caching the database adapter may be doing, for example
+      # clearing the prepared statement cache. This is database specific.
+      def clear_cache!
+        # this should be overridden by concrete adapters
+      end
+
+      # Returns true if its required to reload the connection between requests for development mode.
+      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
+      def requires_reloading?
+        false
+      end
+
+      # Checks whether the connection to the database is still active (i.e. not stale).
+      # This is done under the hood by calling <tt>active?</tt>. If the connection
+      # is no longer active, then this method will reconnect to the database.
+      def verify!(*ignored)
+        reconnect! unless active?
+      end
+
+      # Provides access to the underlying database driver for this adapter. For
+      # example, this method returns a Mysql object in case of MysqlAdapter,
+      # and a PGconn object in case of PostgreSQLAdapter.
+      #
+      # This is useful for when you need to call a proprietary method such as
+      # PostgreSQL's lo_* methods.
+      def raw_connection
+        @connection
+      end
+
+      def open_transactions
+        @transaction.number
+      end
+
+      def increment_open_transactions
+        ActiveSupport::Deprecation.warn "#increment_open_transactions is deprecated and has no effect"
+      end
+
+      def decrement_open_transactions
+        ActiveSupport::Deprecation.warn "#decrement_open_transactions is deprecated and has no effect"
+      end
+
+      def transaction_joinable=(joinable)
+        message = "#transaction_joinable= is deprecated. Please pass the :joinable option to #begin_transaction instead."
+        ActiveSupport::Deprecation.warn message
+        @transaction.joinable = joinable
+      end
+
+      def create_savepoint
+      end
+
+      def rollback_to_savepoint
+      end
+
+      def release_savepoint
+      end
+
+      def case_sensitive_modifier(node)
+        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 = [])
+        @instrumenter.instrument(
+          "sql.active_record",
+          :sql           => sql,
+          :name          => name,
+          :connection_id => object_id,
+          :binds         => binds) { yield }
+      rescue => e
+        message = "#{e.class.name}: #{e.message}: #{sql}"
+        @logger.error message if @logger
+        exception = translate_exception(e, message)
+        exception.set_backtrace e.backtrace
+        raise exception
+      end
+
+      def translate_exception(exception, message)
+        # override in derived class
+        ActiveRecord::StatementInvalid.new(message, exception)
+      end
     end
   end
 end