require "active_record/type" require "active_record/connection_adapters/determine_if_preparable_visitor" require "active_record/connection_adapters/schema_cache" require "active_record/connection_adapters/sql_type_metadata" require "active_record/connection_adapters/abstract/schema_dumper" require "active_record/connection_adapters/abstract/schema_creation" require "arel/collectors/bind" require "arel/collectors/sql_string" 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 :ChangeColumnDefinition autoload :ForeignKeyDefinition autoload :TableDefinition autoload :Table autoload :AlterTable autoload :ReferenceDefinition end autoload_at "active_record/connection_adapters/abstract/connection_pool" do autoload :ConnectionHandler end autoload_under "abstract" do autoload :SchemaStatements autoload :DatabaseStatements autoload :DatabaseLimits autoload :Quoting autoload :ConnectionPool autoload :QueryCache autoload :Savepoints end autoload_at "active_record/connection_adapters/abstract/transaction" do autoload :TransactionManager autoload :NullTransaction autoload :RealTransaction autoload :SavepointTransaction autoload :TransactionState 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}[rdoc-ref:ConnectionHandling#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 SchemaStatements are very useful. class AbstractAdapter ADAPTER_NAME = "Abstract".freeze include ActiveSupport::Callbacks define_callbacks :checkout, :checkin include Quoting, DatabaseStatements, SchemaStatements include DatabaseLimits include QueryCache include ColumnDumper include Savepoints SIMPLE_INT = /\A\d+\z/ attr_accessor :visitor, :pool attr_reader :schema_cache, :owner, :logger alias :in_use? :owner 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 attr_reader :prepared_statements def initialize(connection, logger = nil, config = {}) # :nodoc: super() @connection = connection @owner = nil @instrumenter = ActiveSupport::Notifications.instrumenter @logger = logger @config = config @pool = nil @schema_cache = SchemaCache.new self @quoted_column_names, @quoted_table_names = {}, {} @visitor = arel_visitor @lock = Monitor.new if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true }) @prepared_statements = true @visitor.extend(DetermineIfPreparableVisitor) else @prepared_statements = false end end class Version include Comparable def initialize(version_string) @version = version_string.split(".").map(&:to_i) end def <=>(version_string) @version <=> version_string.split(".").map(&:to_i) end end class BindCollector < Arel::Collectors::Bind def compile(bvs, conn) casted_binds = bvs.map(&:value_for_database) super(casted_binds.map { |value| conn.quote(value) }) end end class SQLString < Arel::Collectors::SQLString def compile(bvs, conn) super(bvs) end end def collector if prepared_statements SQLString.new else BindCollector.new end end def arel_visitor # :nodoc: Arel::Visitors::ToSql.new(self) end def valid_type?(type) # :nodoc: !native_database_types[type].nil? end def schema_creation SchemaCreation.new self end # Returns an array of +Column+ objects for the table specified by +table_name+. def columns(table_name) # :nodoc: table_name = table_name.to_s column_definitions(table_name).map do |field| new_column_from_field(table_name, field) end end # this method must only be called while holding connection pool's mutex def lease if in_use? msg = "Cannot lease connection, " if @owner == Thread.current msg << "it is already leased by the current thread." else msg << "it is already in use by a different thread: #{@owner}. " \ "Current thread: #{Thread.current}." end raise ActiveRecordError, msg end @owner = Thread.current end def schema_cache=(cache) cache.connection = self @schema_cache = cache end # this method must only be called while holding connection pool's mutex def expire if in_use? if @owner != Thread.current raise ActiveRecordError, "Cannot expire connection, " \ "it is owned by a different thread: #{@owner}. " \ "Current thread: #{Thread.current}." end @owner = nil else raise ActiveRecordError, "Cannot expire connection, it is not currently leased." end end # this method must only be called while holding connection pool's mutex (and a desire for segfaults) def steal! # :nodoc: if in_use? if @owner != Thread.current pool.send :remove_connection_from_thread_cache, self, @owner @owner = Thread.current end else raise ActiveRecordError, "Cannot steal connection, it is not currently leased." end end def unprepared_statement old_prepared_statements, @prepared_statements = @prepared_statements, false yield ensure @prepared_statements = old_prepared_statements end # Returns the human-readable name of the adapter. Use mixed case - one # can always use downcase if needed. def adapter_name self.class::ADAPTER_NAME end def supports_migrations? # :nodoc: true end deprecate :supports_migrations? def supports_primary_key? # :nodoc: true end deprecate :supports_primary_key? # Does this adapter support DDL rollbacks in transactions? That is, would # CREATE TABLE or ALTER TABLE get rolled back by a transaction? def supports_ddl_transactions? false end def supports_bulk_alter? false end # Does this adapter support savepoints? def supports_savepoints? false end # Does this adapter support application-enforced advisory locking? def supports_advisory_locks? 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. 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 expression indices? def supports_expression_index? false end # Does this adapter support explain? 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? def supports_extensions? false end # Does this adapter support creating indexes in the same statement as # creating the table? def supports_indexes_in_create? false end # Does this adapter support creating foreign key constraints? def supports_foreign_keys? false end # Does this adapter support creating foreign key constraints # in the same statement as creating the table? def supports_foreign_keys_in_create? supports_foreign_keys? end # Does this adapter support views? def supports_views? false end # Does this adapter support datetime with precision? def supports_datetime_with_precision? false end # Does this adapter support json data type? def supports_json? false end # Does this adapter support metadata comments on database objects (tables, columns, indexes)? def supports_comments? false end # Can comments for tables, columns, and indexes be specified in create/alter table statements? def supports_comments_in_create? false end # Does this adapter support multi-value insert? def supports_multi_insert? true end # Does this adapter support virtual columns? def supports_virtual_columns? false end # This is meant to be implemented by the adapters that support extensions def disable_extension(name) end # This is meant to be implemented by the adapters that support extensions def enable_extension(name) end # This is meant to be implemented by the adapters that support advisory # locks # # Return true if we got the lock, otherwise false def get_advisory_lock(lock_id) # :nodoc: end # This is meant to be implemented by the adapters that support advisory # locks. # # Return true if we released the lock, otherwise false def release_advisory_lock(lock_id) # :nodoc: end # A list of extensions, to be filled in by adapters that support them. def extensions [] end # A list of index algorithms, to be filled by adapters that support them. def index_algorithms {} 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. 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) if ignored.size > 0 ActiveSupport::Deprecation.warn("Passing arguments to #verify method of the connection has no effect and has been deprecated. Please remove all arguments from the #verify method call.") end reconnect! unless active? end # Provides access to the underlying database driver for this adapter. For # example, this method returns a Mysql2::Client object in case of Mysql2Adapter, # 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 case_sensitive_comparison(table, attribute, column, value) # :nodoc: table[attribute].eq(value) end def case_insensitive_comparison(table, attribute, column, value) # :nodoc: if can_perform_case_insensitive_comparison_for?(column) table[attribute].lower.eq(table.lower(value)) else table[attribute].eq(value) end end def can_perform_case_insensitive_comparison_for?(column) true end private :can_perform_case_insensitive_comparison_for? # Check the connection back in to the connection pool def close pool.checkin self end def type_map # :nodoc: @type_map ||= Type::TypeMap.new.tap do |mapping| initialize_type_map(mapping) end end def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil) # :nodoc: Column.new(name, default, sql_type_metadata, null, table_name, default_function, collation) end def lookup_cast_type(sql_type) # :nodoc: type_map.lookup(sql_type) end def column_name_for_operation(operation, node) # :nodoc: visitor.accept(node, collector).value end def combine_bind_parameters( from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil ) # :nodoc: result = from_clause + join_clause + where_clause + having_clause if limit result << limit end if offset result << offset end result end def default_index_type?(index) # :nodoc: index.using.nil? end private def initialize_type_map(m) register_class_with_limit m, %r(boolean)i, Type::Boolean register_class_with_limit m, %r(char)i, Type::String register_class_with_limit m, %r(binary)i, Type::Binary register_class_with_limit m, %r(text)i, Type::Text register_class_with_precision m, %r(date)i, Type::Date register_class_with_precision m, %r(time)i, Type::Time register_class_with_precision m, %r(datetime)i, Type::DateTime register_class_with_limit m, %r(float)i, Type::Float register_class_with_limit m, %r(int)i, Type::Integer m.alias_type %r(blob)i, "binary" m.alias_type %r(clob)i, "text" m.alias_type %r(timestamp)i, "datetime" m.alias_type %r(numeric)i, "decimal" m.alias_type %r(number)i, "decimal" m.alias_type %r(double)i, "float" m.register_type(%r(decimal)i) do |sql_type| scale = extract_scale(sql_type) precision = extract_precision(sql_type) if scale == 0 # FIXME: Remove this class as well Type::DecimalWithoutScale.new(precision: precision) else Type::Decimal.new(precision: precision, scale: scale) end end end def reload_type_map type_map.clear initialize_type_map(type_map) end def register_class_with_limit(mapping, key, klass) mapping.register_type(key) do |*args| limit = extract_limit(args.last) klass.new(limit: limit) end end def register_class_with_precision(mapping, key, klass) mapping.register_type(key) do |*args| precision = extract_precision(args.last) klass.new(precision: precision) end end def extract_scale(sql_type) case sql_type when /\((\d+)\)/ then 0 when /\((\d+)(,(\d+))\)/ then $3.to_i end end def extract_precision(sql_type) $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/ end def extract_limit(sql_type) case sql_type when /^bigint/i 8 when /\((.*)\)/ $1.to_i end end def translate_exception_class(e, sql) begin message = "#{e.class.name}: #{e.message}: #{sql}" rescue Encoding::CompatibilityError message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}" end exception = translate_exception(e, message) exception.set_backtrace e.backtrace exception end def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc: @instrumenter.instrument( "sql.active_record", sql: sql, name: name, binds: binds, type_casted_binds: type_casted_binds, statement_name: statement_name, connection_id: object_id) do @lock.synchronize do yield end end rescue => e raise translate_exception_class(e, sql) end def translate_exception(exception, message) # override in derived class case exception when RuntimeError exception else ActiveRecord::StatementInvalid.new(message) end end def without_prepared_statement?(binds) !prepared_statements || binds.empty? end def column_for(table_name, column_name) column_name = column_name.to_s columns(table_name).detect { |c| c.name == column_name } || raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}") end end end end