activerecord 2.3.18 → 3.2.22

data/lib/active_record/connection_adapters/column.rb

@@ -0,0 +1,296 @@
+require 'set'
+
+module ActiveRecord
+  # :stopdoc:
+  module ConnectionAdapters
+    # An abstract definition of a column in a table.
+    class Column
+      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+
+      module Format
+        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+      end
+
+      attr_reader :name, :default, :type, :limit, :null, :sql_type, :precision, :scale
+      attr_accessor :primary, :coder
+
+      alias :encoded? :coder
+
+      # Instantiates a new column in the table.
+      #
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
+      # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
+      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in
+      # <tt>company_name varchar(60)</tt>.
+      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +null+ determines if this column allows +NULL+ values.
+      def initialize(name, default, sql_type = nil, null = true)
+        @name      = name
+        @sql_type  = sql_type
+        @null      = null
+        @limit     = extract_limit(sql_type)
+        @precision = extract_precision(sql_type)
+        @scale     = extract_scale(sql_type)
+        @type      = simplified_type(sql_type)
+        @default   = extract_default(default)
+        @primary   = nil
+        @coder     = nil
+      end
+
+      # Returns +true+ if the column is either of type string or text.
+      def text?
+        type == :string || type == :text
+      end
+
+      # Returns +true+ if the column is either of type integer, float or decimal.
+      def number?
+        type == :integer || type == :float || type == :decimal
+      end
+
+      def has_default?
+        !default.nil?
+      end
+
+      # Returns the Ruby class that corresponds to the abstract data type.
+      def klass
+        case type
+        when :integer                     then Fixnum
+        when :float                       then Float
+        when :decimal                     then BigDecimal
+        when :datetime, :timestamp, :time then Time
+        when :date                        then Date
+        when :text, :string, :binary      then String
+        when :boolean                     then Object
+        end
+      end
+
+      # Casts value (which is a String) to an appropriate instance.
+      def type_cast(value)
+        return nil if value.nil?
+        return coder.load(value) if encoded?
+
+        klass = self.class
+
+        case type
+        when :string, :text        then value
+        when :integer              then klass.value_to_integer(value)
+        when :float                then value.to_f
+        when :decimal              then klass.value_to_decimal(value)
+        when :datetime, :timestamp then klass.string_to_time(value)
+        when :time                 then klass.string_to_dummy_time(value)
+        when :date                 then klass.string_to_date(value)
+        when :binary               then klass.binary_to_string(value)
+        when :boolean              then klass.value_to_boolean(value)
+        else value
+        end
+      end
+
+      def type_cast_code(var_name)
+        klass = self.class.name
+
+        case type
+        when :string, :text        then var_name
+        when :integer              then "#{klass}.value_to_integer(#{var_name})"
+        when :float                then "#{var_name}.to_f"
+        when :decimal              then "#{klass}.value_to_decimal(#{var_name})"
+        when :datetime, :timestamp then "#{klass}.string_to_time(#{var_name})"
+        when :time                 then "#{klass}.string_to_dummy_time(#{var_name})"
+        when :date                 then "#{klass}.string_to_date(#{var_name})"
+        when :binary               then "#{klass}.binary_to_string(#{var_name})"
+        when :boolean              then "#{klass}.value_to_boolean(#{var_name})"
+        else var_name
+        end
+      end
+
+      # Returns the human name of the column name.
+      #
+      # ===== Examples
+      #  Column.new('sales_stage', ...).human_name # => 'Sales stage'
+      def human_name
+        Base.human_attribute_name(@name)
+      end
+
+      def extract_default(default)
+        type_cast(default)
+      end
+
+      # Used to convert from Strings to BLOBs
+      def string_to_binary(value)
+        self.class.string_to_binary(value)
+      end
+
+      class << self
+        # Used to convert from Strings to BLOBs
+        def string_to_binary(value)
+          value
+        end
+
+        # Used to convert from BLOBs to Strings
+        def binary_to_string(value)
+          value
+        end
+
+        def string_to_date(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_date(string) || fallback_string_to_date(string)
+        end
+
+        def string_to_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_time(string) || fallback_string_to_time(string)
+        end
+
+        def string_to_dummy_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          dummy_time_string = "2000-01-01 #{string}"
+
+          fast_string_to_time(dummy_time_string) || begin
+            time_hash = Date._parse(dummy_time_string)
+            return nil if time_hash[:hour].nil?
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+          end
+        end
+
+        # convert something to a boolean
+        def value_to_boolean(value)
+          if value.is_a?(String) && value.blank?
+            nil
+          else
+            TRUE_VALUES.include?(value)
+          end
+        end
+
+        # Used to convert values to integer.
+        # handle the case when an integer column is used to store boolean values
+        def value_to_integer(value)
+          case value
+          when TrueClass, FalseClass
+            value ? 1 : 0
+          else
+            value.to_i rescue nil
+          end
+        end
+
+        # convert something to a BigDecimal
+        def value_to_decimal(value)
+          # Using .class is faster than .is_a? and
+          # subclasses of BigDecimal will be handled
+          # in the else clause
+          if value.class == BigDecimal
+            value
+          elsif value.respond_to?(:to_d)
+            value.to_d
+          else
+            value.to_s.to_d
+          end
+        end
+
+        protected
+          # '0.123456' -> 123456
+          # '1.123456' -> 123456
+          def microseconds(time)
+            time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+          end
+
+          def new_date(year, mon, mday)
+            if year && year != 0
+              Date.new(year, mon, mday) rescue nil
+            end
+          end
+
+          def new_time(year, mon, mday, hour, min, sec, microsec)
+            # Treat 0000-00-00 00:00:00 as nil.
+            return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+
+          def fast_string_to_date(string)
+            if string =~ Format::ISO_DATE
+              new_date $1.to_i, $2.to_i, $3.to_i
+            end
+          end
+
+          if RUBY_VERSION >= '1.9'
+            # Doesn't handle time zones.
+            def fast_string_to_time(string)
+              if string =~ Format::ISO_DATETIME
+                microsec = ($7.to_r * 1_000_000).to_i
+                new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+              end
+            end
+          else
+            def fast_string_to_time(string)
+              if string =~ Format::ISO_DATETIME
+                microsec = ($7.to_f * 1_000_000).round.to_i
+                new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+              end
+            end
+          end
+
+          def fallback_string_to_date(string)
+            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+          end
+
+          def fallback_string_to_time(string)
+            time_hash = Date._parse(string)
+            time_hash[:sec_fraction] = microseconds(time_hash)
+
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+          end
+      end
+
+      private
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
+        end
+
+        def extract_precision(sql_type)
+          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
+        end
+
+        def extract_scale(sql_type)
+          case sql_type
+            when /^(numeric|decimal|number)\((\d+)\)/i then 0
+            when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
+          end
+        end
+
+        def simplified_type(field_type)
+          case field_type
+          when /int/i
+            :integer
+          when /float|double/i
+            :float
+          when /decimal|numeric|number/i
+            extract_scale(field_type) == 0 ? :integer : :decimal
+          when /datetime/i
+            :datetime
+          when /timestamp/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /clob/i, /text/i
+            :text
+          when /blob/i, /binary/i
+            :binary
+          when /char/i, /string/i
+            :string
+          when /boolean/i
+            :boolean
+          end
+        end
+    end
+  end
+  # :startdoc:
+end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,280 @@
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+gem 'mysql2', '~> 0.3.10'
+require 'mysql2'
+
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def self.mysql2_connection(config)
+      config[:username] = 'root' if config[:username].nil?
+
+      if Mysql2::Client.const_defined? :FOUND_ROWS
+        config[:flags] = Mysql2::Client::FOUND_ROWS
+      end
+
+      client = Mysql2::Client.new(config.symbolize_keys)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class Mysql2Adapter < AbstractMysqlAdapter
+
+      class Column < AbstractMysqlAdapter::Column # :nodoc:
+        def adapter
+          Mysql2Adapter
+        end
+      end
+
+      ADAPTER_NAME = 'Mysql2'
+
+      def initialize(connection, logger, connection_options, config)
+        super
+        @visitor = BindSubstitution.new self
+        configure_connection
+      end
+
+      def supports_explain?
+        true
+      end
+
+      # HELPER METHODS ===========================================
+
+      def each_hash(result) # :nodoc:
+        if block_given?
+          result.each(:as => :hash, :symbolize_keys => true) do |row|
+            yield row
+          end
+        else
+          to_enum(:each_hash, result)
+        end
+      end
+
+      def new_column(field, default, type, null, collation) # :nodoc:
+        Column.new(field, default, type, null, collation)
+      end
+
+      def error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
+      end
+
+      # QUOTING ==================================================
+
+      def quote_string(string)
+        @connection.escape(string)
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      def active?
+        return false unless @connection
+        @connection.ping
+      end
+
+      def reconnect!
+        disconnect!
+        connect
+      end
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        unless @connection.nil?
+          @connection.close
+          @connection = nil
+        end
+      end
+
+      def reset!
+        disconnect!
+        connect
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      def explain(arel, binds = [])
+        sql     = "EXPLAIN #{to_sql(arel, binds.dup)}"
+        start   = Time.now
+        result  = exec_query(sql, 'EXPLAIN', binds)
+        elapsed = Time.now - start
+
+        ExplainPrettyPrinter.new.pp(result, elapsed)
+      end
+
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+        # MySQL shell:
+        #
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   | id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra       |
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   |  1 | SIMPLE      | users | const | PRIMARY       | PRIMARY | 4       | const |    1 |             |
+        #   |  1 | SIMPLE      | posts | ALL   | NULL          | NULL    | NULL    | NULL  |    1 | Using where |
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   2 rows in set (0.00 sec)
+        #
+        # This is an exercise in Ruby hyperrealism :).
+        def pp(result, elapsed)
+          widths    = compute_column_widths(result)
+          separator = build_separator(widths)
+
+          pp = []
+
+          pp << separator
+          pp << build_cells(result.columns, widths)
+          pp << separator
+
+          result.rows.each do |row|
+            pp << build_cells(row, widths)
+          end
+
+          pp << separator
+          pp << build_footer(result.rows.length, elapsed)
+
+          pp.join("\n") + "\n"
+        end
+
+        private
+
+        def compute_column_widths(result)
+          [].tap do |widths|
+            result.columns.each_with_index do |column, i|
+              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
+              widths << cells_in_column.map(&:length).max
+            end
+          end
+        end
+
+        def build_separator(widths)
+          padding = 1
+          '+' + widths.map {|w| '-' * (w + (padding*2))}.join('+') + '+'
+        end
+
+        def build_cells(items, widths)
+          cells = []
+          items.each_with_index do |item, i|
+            item = 'NULL' if item.nil?
+            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
+            cells << item.to_s.send(justifier, widths[i])
+          end
+          '| ' + cells.join(' | ') + ' |'
+        end
+
+        def build_footer(nrows, elapsed)
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
+        end
+      end
+
+      # FIXME: re-enable the following once a "better" query_cache solution is in core
+      #
+      # The overrides below perform much better than the originals in AbstractAdapter
+      # because we're able to take advantage of mysql2's lazy-loading capabilities
+      #
+      # # Returns a record hash with the column names as keys and column values
+      # # as values.
+      # def select_one(sql, name = nil)
+      #   result = execute(sql, name)
+      #   result.each(:as => :hash) do |r|
+      #     return r
+      #   end
+      # end
+      #
+      # # Returns a single value from a record
+      # def select_value(sql, name = nil)
+      #   result = execute(sql, name)
+      #   if first = result.first
+      #     first.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)
+      #   execute(sql, name).map { |row| row.first }
+      # 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)
+        execute(sql, name).to_a
+      end
+
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil)
+        if @connection
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+        end
+
+        super
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        result = execute(sql, name)
+        ActiveRecord::Result.new(result.fields, result.to_a)
+      end
+
+      alias exec_without_stmt exec_query
+
+      # Returns an array of record hashes with the column names as keys and
+      # column values as values.
+      def select(sql, name = nil, binds = [])
+        exec_query(sql, name).to_a
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        super
+        id_value || @connection.last_id
+      end
+      alias :create :insert_sql
+
+      def exec_insert(sql, name, binds)
+        execute to_sql(sql, binds), name
+      end
+
+      def exec_delete(sql, name, binds)
+        execute to_sql(sql, binds), name
+        @connection.affected_rows
+      end
+      alias :exec_update :exec_delete
+
+      def last_inserted_id(result)
+        @connection.last_id
+      end
+
+      private
+
+      def connect
+        @connection = Mysql2::Client.new(@config)
+        configure_connection
+      end
+
+      def configure_connection
+        @connection.query_options.merge!(:as => :array)
+
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+        variable_assignments = ['SQL_AUTO_IS_NULL=0']
+        encoding = @config[:encoding]
+
+        # make sure we set the encoding
+        variable_assignments << "NAMES '#{encoding}'" if encoding
+
+        # increase timeout so mysql server doesn't disconnect us
+        wait_timeout = @config[:wait_timeout]
+        wait_timeout = 2147483 unless wait_timeout.is_a?(Fixnum)
+        variable_assignments << "@@wait_timeout = #{wait_timeout}"
+
+        execute("SET #{variable_assignments.join(', ')}", :skip_logging)
+      end
+
+      def version
+        @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      end
+    end
+  end
+end