RubyGems - active_mailer - Versions diffs - 0.0.10 → 1.0.0 - Mend

active_mailer 0.0.10 → 1.0.0

Files changed (4435) hide show

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/activerecord-3.2.12/lib/active_record/connection_adapters/abstract_adapter.rb DELETED

@@ -1,296 +0,0 @@
-require 'date'
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'active_support/core_ext/benchmark'
-require 'active_support/deprecation'
-require 'active_record/connection_adapters/schema_cache'
-require 'monitor'
-module ActiveRecord
-  module ConnectionAdapters # :nodoc:
-    extend ActiveSupport::Autoload
-    autoload :Column
-    autoload_under 'abstract' do
-      autoload :IndexDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
-      autoload :ColumnDefinition, 'active_record/connection_adapters/abstract/schema_definitions'
-      autoload :TableDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
-      autoload :Table,            'active_record/connection_adapters/abstract/schema_definitions'
-      autoload :SchemaStatements
-      autoload :DatabaseStatements
-      autoload :DatabaseLimits
-      autoload :Quoting
-      autoload :ConnectionPool
-      autoload :ConnectionHandler,       'active_record/connection_adapters/abstract/connection_pool'
-      autoload :ConnectionManagement,    'active_record/connection_adapters/abstract/connection_pool'
-      autoload :ConnectionSpecification
-      autoload :QueryCache
-    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
-      define_callbacks :checkout, :checkin
-      attr_accessor :visitor, :pool
-      attr_reader :schema_cache, :last_use, :in_use, :logger
-      alias :in_use? :in_use
-      def initialize(connection, logger = nil, pool = nil) #:nodoc:
-        super()
-        @active              = nil
-        @connection          = connection
-        @in_use              = false
-        @instrumenter        = ActiveSupport::Notifications.instrumenter
-        @last_use            = false
-        @logger              = logger
-        @open_transactions   = 0
-        @pool                = pool
-        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
-        @query_cache_enabled = false
-        @schema_cache        = SchemaCache.new self
-        @visitor             = nil
-      end
-      def lease
-        synchronize do
-          unless in_use
-            @in_use   = true
-            @last_use = Time.now
-          end
-        end
-      end
-      def expire
-        @in_use = false
-      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 explain? As of this writing sqlite3,
-      # mysql2, and postgresql are the only ones that do.
-      def supports_explain?
-        false
-      end
-      # QUOTING ==================================================
-      # Override to return the quoted table name. Defaults to column quoting.
-      def quote_table_name(name)
-        quote_column_name(name)
-      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?
-        @active != false
-      end
-      # Disconnects from the database if already connected, and establishes a
-      # new connection with the database.
-      def reconnect!
-        @active = true
-      end
-      # Disconnects from the database if already connected. Otherwise, this
-      # method does nothing.
-      def disconnect!
-        @active = false
-      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
-      attr_reader :open_transactions
-      def increment_open_transactions
-        @open_transactions += 1
-      end
-      def decrement_open_transactions
-        @open_transactions -= 1
-      end
-      def transaction_joinable=(joinable)
-        @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 Exception => e
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-          @logger.debug message if @logger
-          exception = translate_exception(e, message)
-          exception.set_backtrace e.backtrace
-          raise exception
-        end
-        def translate_exception(e, message)
-          # override in derived class
-          ActiveRecord::StatementInvalid.new(message)
-        end
-    end
-  end
-end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/activerecord-3.2.12/lib/active_record/connection_adapters/abstract_mysql_adapter.rb DELETED

@@ -1,674 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'arel/visitors/bind_visitor'
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractMysqlAdapter < AbstractAdapter
-      class Column < ConnectionAdapters::Column # :nodoc:
-        attr_reader :collation
-        def initialize(name, default, sql_type = nil, null = true, collation = nil)
-          super(name, default, sql_type, null)
-          @collation = collation
-        end
-        def extract_default(default)
-          if sql_type =~ /blob/i || type == :text
-            if default.blank?
-              return null ? nil : ''
-            else
-              raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-            end
-          elsif missing_default_forged_as_empty_string?(default)
-            nil
-          else
-            super
-          end
-        end
-        def has_default?
-          return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
-          super
-        end
-        # Must return the relevant concrete adapter
-        def adapter
-          raise NotImplementedError
-        end
-        def case_sensitive?
-          collation && !collation.match(/_ci$/)
-        end
-        private
-        def simplified_type(field_type)
-          return :boolean if adapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
-          case field_type
-          when /enum/i, /set/i then :string
-          when /year/i         then :integer
-          when /bit/i          then :binary
-          else
-            super
-          end
-        end
-        def extract_limit(sql_type)
-          case sql_type
-          when /blob|text/i
-            case sql_type
-            when /tiny/i
-              255
-            when /medium/i
-              16777215
-            when /long/i
-              2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
-            else
-              super # we could return 65535 here, but we leave it undecorated by default
-            end
-          when /^bigint/i;    8
-          when /^int/i;       4
-          when /^mediumint/i; 3
-          when /^smallint/i;  2
-          when /^tinyint/i;   1
-          when /^enum\((.+)\)/i
-            $1.split(',').map{|enum| enum.strip.length - 2}.max
-          else
-            super
-          end
-        end
-        # MySQL misreports NOT NULL column default when none is given.
-        # We can't detect this for columns which may have a legitimate ''
-        # default (string) but we can for others (integer, datetime, boolean,
-        # and the rest).
-        #
-        # Test whether the column has default '', is not null, and is not
-        # a type allowing default ''.
-        def missing_default_forged_as_empty_string?(default)
-          type != :string && !null && default == ''
-        end
-      end
-      ##
-      # :singleton-method:
-      # By default, the MysqlAdapter will consider all columns of type <tt>tinyint(1)</tt>
-      # as boolean. If you wish to disable this emulation (which was the default
-      # behavior in versions 0.13.1 and earlier) you can add the following line
-      # to your application.rb file:
-      #
-      #   ActiveRecord::ConnectionAdapters::Mysql[2]Adapter.emulate_booleans = false
-      class_attribute :emulate_booleans
-      self.emulate_booleans = true
-      LOST_CONNECTION_ERROR_MESSAGES = [
-        "Server shutdown in progress",
-        "Broken pipe",
-        "Lost connection to MySQL server during query",
-        "MySQL server has gone away" ]
-      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
-      NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-        :string      => { :name => "varchar", :limit => 255 },
-        :text        => { :name => "text" },
-        :integer     => { :name => "int", :limit => 4 },
-        :float       => { :name => "float" },
-        :decimal     => { :name => "decimal" },
-        :datetime    => { :name => "datetime" },
-        :timestamp   => { :name => "datetime" },
-        :time        => { :name => "time" },
-        :date        => { :name => "date" },
-        :binary      => { :name => "blob" },
-        :boolean     => { :name => "tinyint", :limit => 1 }
-      }
-      class BindSubstitution < Arel::Visitors::MySQL # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-      # FIXME: Make the first parameter more similar for the two adapters
-      def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @connection_options, @config = connection_options, config
-        @quoted_column_names, @quoted_table_names = {}, {}
-        if config.fetch(:prepared_statements) { true }
-          @visitor = Arel::Visitors::MySQL.new self
-        else
-          @visitor = BindSubstitution.new self
-        end
-      end
-      def adapter_name #:nodoc:
-        self.class::ADAPTER_NAME
-      end
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
-        true
-      end
-      def supports_primary_key?
-        true
-      end
-      # Returns true, since this connection adapter supports savepoints.
-      def supports_savepoints?
-        true
-      end
-      def supports_bulk_alter? #:nodoc:
-        true
-      end
-      # Technically MySQL allows to create indexes with the sort order syntax
-      # but at the moment (5.5) it doesn't yet implement them
-      def supports_index_sort_order?
-        true
-      end
-      def native_database_types
-        NATIVE_DATABASE_TYPES
-      end
-      # HELPER METHODS ===========================================
-      # The two drivers have slightly different ways of yielding hashes of results, so
-      # this method must be implemented to provide a uniform interface.
-      def each_hash(result) # :nodoc:
-        raise NotImplementedError
-      end
-      # Overridden by the adapters to instantiate their specific Column type.
-      def new_column(field, default, type, null, collation) # :nodoc:
-        Column.new(field, default, type, null, collation)
-      end
-      # Must return the Mysql error number from the exception, if the exception has an
-      # error number.
-      def error_number(exception) # :nodoc:
-        raise NotImplementedError
-      end
-      # QUOTING ==================================================
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-          s = column.class.string_to_binary(value).unpack("H*")[0]
-          "x'#{s}'"
-        else
-          super
-        end
-      end
-      def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
-      end
-      def quote_table_name(name) #:nodoc:
-        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
-      end
-      def quoted_true
-        QUOTED_TRUE
-      end
-      def quoted_false
-        QUOTED_FALSE
-      end
-      # REFERENTIAL INTEGRITY ====================================
-      def disable_referential_integrity(&block) #:nodoc:
-        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
-        begin
-          update("SET FOREIGN_KEY_CHECKS = 0")
-          yield
-        ensure
-          update("SET FOREIGN_KEY_CHECKS = #{old}")
-        end
-      end
-      # DATABASE STATEMENTS ======================================
-      # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil)
-        if name == :skip_logging
-          @connection.query(sql)
-        else
-          log(sql, name) { @connection.query(sql) }
-        end
-      rescue ActiveRecord::StatementInvalid => exception
-        if exception.message.split(":").first =~ /Packets out of order/
-          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
-        else
-          raise
-        end
-      end
-      # MysqlAdapter has to free a result after using it, so we use this method to write
-      # stuff in a abstract way without concerning ourselves about whether it needs to be
-      # explicitly freed or not.
-      def execute_and_free(sql, name = nil) #:nodoc:
-        yield execute(sql, name)
-      end
-      def update_sql(sql, name = nil) #:nodoc:
-        super
-        @connection.affected_rows
-      end
-      def begin_db_transaction
-        execute "BEGIN"
-      rescue Exception
-        # Transactions aren't supported
-      end
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-      def rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      end
-      def create_savepoint
-        execute("SAVEPOINT #{current_savepoint_name}")
-      end
-      def rollback_to_savepoint
-        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-      end
-      def release_savepoint
-        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
-      end
-      # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
-      # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
-      # these, we must use a subquery. However, MySQL is too stupid to create a
-      # temporary table for this automatically, so we have to give it some prompting
-      # in the form of a subsubquery. Ugh!
-      def join_to_update(update, select) #:nodoc:
-        if select.limit || select.offset || select.orders.any?
-          subsubselect = select.clone
-          subsubselect.projections = [update.key]
-          subselect = Arel::SelectManager.new(select.engine)
-          subselect.project Arel.sql(update.key.name)
-          subselect.from subsubselect.as('__active_record_temp')
-          update.where update.key.in(subselect)
-        else
-          update.table select.source
-          update.wheres = select.constraints
-        end
-      end
-      # SCHEMA STATEMENTS ========================================
-      def structure_dump #:nodoc:
-        if supports_views?
-          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-        else
-          sql = "SHOW TABLES"
-        end
-        select_all(sql).map { |table|
-          table.delete('Table_type')
-          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
-          exec_query(sql).first['Create Table'] + ";\n\n"
-        }.join
-      end
-      # Drops the database specified on the +name+ attribute
-      # and creates it again using the provided +options+.
-      def recreate_database(name, options = {})
-        drop_database(name)
-        create_database(name, options)
-      end
-      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
-      # Charset defaults to utf8.
-      #
-      # Example:
-      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
-      #   create_database 'matt_development'
-      #   create_database 'matt_development', :charset => :big5
-      def create_database(name, options = {})
-        if options[:collation]
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
-        else
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
-        end
-      end
-      # Drops a MySQL database.
-      #
-      # Example:
-      #   drop_database('sebastian_development')
-      def drop_database(name) #:nodoc:
-        execute "DROP DATABASE IF EXISTS `#{name}`"
-      end
-      def current_database
-        select_value 'SELECT DATABASE() as db'
-      end
-      # Returns the database character set.
-      def charset
-        show_variable 'character_set_database'
-      end
-      # Returns the database collation strategy.
-      def collation
-        show_variable 'collation_database'
-      end
-      def tables(name = nil, database = nil, like = nil) #:nodoc:
-        sql = "SHOW TABLES "
-        sql << "IN #{quote_table_name(database)} " if database
-        sql << "LIKE #{quote(like)}" if like
-        execute_and_free(sql, 'SCHEMA') do |result|
-          result.collect { |field| field.first }
-        end
-      end
-      def table_exists?(name)
-        return false unless name
-        return true if tables(nil, nil, name).any?
-        name          = name.to_s
-        schema, table = name.split('.', 2)
-        unless table # A table was provided without a schema
-          table  = schema
-          schema = nil
-        end
-        tables(nil, schema, table).any?
-      end
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil) #:nodoc:
-        indexes = []
-        current_index = nil
-        execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", 'SCHEMA') do |result|
-          each_hash(result) do |row|
-            if current_index != row[:Key_name]
-              next if row[:Key_name] == 'PRIMARY' # skip the primary key
-              current_index = row[:Key_name]
-              indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique].to_i == 0, [], [])
-            end
-            indexes.last.columns << row[:Column_name]
-            indexes.last.lengths << row[:Sub_part]
-          end
-        end
-        indexes
-      end
-      # Returns an array of +Column+ objects for the table specified by +table_name+.
-      def columns(table_name, name = nil)#:nodoc:
-        sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
-        execute_and_free(sql, 'SCHEMA') do |result|
-          each_hash(result).map do |field|
-            new_column(field[:Field], field[:Default], field[:Type], field[:Null] == "YES", field[:Collation])
-          end
-        end
-      end
-      def create_table(table_name, options = {}) #:nodoc:
-        super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
-      end
-      def bulk_change_table(table_name, operations) #:nodoc:
-        sqls = operations.map do |command, args|
-          table, arguments = args.shift, args
-          method = :"#{command}_sql"
-          if respond_to?(method, true)
-            send(method, table, *arguments)
-          else
-            raise "Unknown method called : #{method}(#{arguments.inspect})"
-          end
-        end.flatten.join(", ")
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
-      end
-      # Renames a table.
-      #
-      # Example:
-      #   rename_table('octopuses', 'octopi')
-      def rename_table(table_name, new_name)
-        execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-      end
-      def add_column(table_name, column_name, type, options = {})
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
-      end
-      def change_column_default(table_name, column_name, default)
-        column = column_for(table_name, column_name)
-        change_column table_name, column_name, column.sql_type, :default => default
-      end
-      def change_column_null(table_name, column_name, null, default = nil)
-        column = column_for(table_name, column_name)
-        unless null || default.nil?
-          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
-        end
-        change_column table_name, column_name, column.sql_type, :null => null
-      end
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
-      end
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
-      end
-      # Maps logical Rails types to MySQL-specific data types.
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        case type.to_s
-        when 'integer'
-          case limit
-          when 1; 'tinyint'
-          when 2; 'smallint'
-          when 3; 'mediumint'
-          when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-          when 5..8; 'bigint'
-          else raise(ActiveRecordError, "No integer type has byte size #{limit}")
-          end
-        when 'text'
-          case limit
-          when 0..0xff;               'tinytext'
-          when nil, 0x100..0xffff;    'text'
-          when 0x10000..0xffffff;     'mediumtext'
-          when 0x1000000..0xffffffff; 'longtext'
-          else raise(ActiveRecordError, "No text type has character length #{limit}")
-          end
-        else
-          super
-        end
-      end
-      def add_column_position!(sql, options)
-        if options[:first]
-          sql << " FIRST"
-        elsif options[:after]
-          sql << " AFTER #{quote_column_name(options[:after])}"
-        end
-      end
-      # SHOW VARIABLES LIKE 'name'
-      def show_variable(name)
-        variables = select_all("SHOW VARIABLES LIKE '#{name}'")
-        variables.first['Value'] unless variables.empty?
-      end
-      # Returns a table's primary key and belonging sequence.
-      def pk_and_sequence_for(table)
-        execute_and_free("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA') do |result|
-          create_table = each_hash(result).first[:"Create Table"]
-          if create_table.to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
-            keys = $1.split(",").map { |key| key.gsub(/[`"]/, "") }
-            keys.length == 1 ? [keys.first, nil] : nil
-          else
-            nil
-          end
-        end
-      end
-      # Returns just a table's primary key
-      def primary_key(table)
-        pk_and_sequence = pk_and_sequence_for(table)
-        pk_and_sequence && pk_and_sequence.first
-      end
-      def case_sensitive_modifier(node)
-        Arel::Nodes::Bin.new(node)
-      end
-      def case_insensitive_comparison(table, attribute, column, value)
-        if column.case_sensitive?
-          super
-        else
-          table[attribute].eq(value)
-        end
-      end
-      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-        where_sql
-      end
-      protected
-      def add_index_length(option_strings, column_names, options = {})
-        if options.is_a?(Hash) && length = options[:length]
-          case length
-          when Hash
-            column_names.each {|name| option_strings[name] += "(#{length[name]})" if length.has_key?(name) && length[name].present?}
-          when Fixnum
-            column_names.each {|name| option_strings[name] += "(#{length})"}
-          end
-        end
-        return option_strings
-      end
-      def quoted_columns_for_index(column_names, options = {})
-        option_strings = Hash[column_names.map {|name| [name, '']}]
-        # add index length
-        option_strings = add_index_length(option_strings, column_names, options)
-        # add index sort order
-        option_strings = add_index_sort_order(option_strings, column_names, options)
-        column_names.map {|name| quote_column_name(name) + option_strings[name]}
-      end
-      def translate_exception(exception, message)
-        case error_number(exception)
-        when 1062
-          RecordNotUnique.new(message, exception)
-        when 1452
-          InvalidForeignKey.new(message, exception)
-        else
-          super
-        end
-      end
-      def add_column_sql(table_name, column_name, type, options = {})
-        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        add_column_sql
-      end
-      def change_column_sql(table_name, column_name, type, options = {})
-        column = column_for(table_name, column_name)
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-        change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        change_column_sql
-      end
-      def rename_column_sql(table_name, column_name, new_column_name)
-        options = {}
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-        rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        rename_column_sql
-      end
-      def remove_column_sql(table_name, *column_names)
-        columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
-      end
-      alias :remove_columns_sql :remove_column
-      def add_index_sql(table_name, column_name, options = {})
-        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
-        "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
-      end
-      def remove_index_sql(table_name, options = {})
-        index_name = index_name_for_remove(table_name, options)
-        "DROP INDEX #{index_name}"
-      end
-      def add_timestamps_sql(table_name)
-        [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
-      end
-      def remove_timestamps_sql(table_name)
-        [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
-      end
-      private
-      def supports_views?
-        version[0] >= 5
-      end
-      def column_for(table_name, column_name)
-        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-          raise "No such column: #{table_name}.#{column_name}"
-        end
-        column
-      end
-    end
-  end
-end