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 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 autoload_at 'active_record/connection_adapters/abstract/connection_pool' do autoload :ConnectionHandler autoload :ConnectionManagement end 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. # # All the concrete database adapters follow the interface laid down in this class. # ActiveRecord::Base.connection returns an AbstractAdapter object, which # you can use. # # 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 end def self.type_cast_config_to_boolean(config) if config == "false" false else config end 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 def valid_type?(type) true end 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 def quote_column_name(name) @conn.quote_column_name name end def quote_table_name(name) @conn.quote_table_name name end def type_to_sql(type, limit, precision, scale) @conn.type_to_sql type.to_sym, limit, precision, scale end 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 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 # Returns the human-readable name of the adapter. Use mixed case - one # can always use downcase if needed. def adapter_name 'Abstract' end # Does this adapter support migrations? Backend specific, as the # abstract adapter always returns +false+. def supports_migrations? false 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 # Does this adapter support using DISTINCT within COUNT? This is +true+ # for all adapters except sqlite. def supports_count_distinct? true 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 def supports_bulk_alter? false end # Does this adapter support savepoints? PostgreSQL and MySQL do, # SQLite < 3.6.8 does not. def supports_savepoints? false end # 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 # Does this adapter support index sort order? def supports_index_sort_order? false end # Does this adapter support partial indices? def supports_partial_index? 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 # Does this adapter support setting the isolation level for a transaction? def supports_transaction_isolation? false end # Does this adapter support database extensions? As of this writing only # postgresql does. def supports_extensions? false end # A list of extensions, to be filled in by adapters that support them. At # the moment only postgresql does. def extensions [] 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 # QUOTING ================================================== # 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 &block. 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 active?. 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