activerecord 4.2.0

data/lib/active_record/connection_adapters/column.rb

@@ -0,0 +1,82 @@
+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, :cast_type, :null, :sql_type, :default, :default_function
+
+      delegate :type, :precision, :scale, :limit, :klass, :accessor,
+        :number?, :binary?, :changed?,
+        :type_cast_from_user, :type_cast_from_database, :type_cast_for_database,
+        :type_cast_for_schema,
+        to: :cast_type
+
+      # 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>.
+      # +cast_type+ is the object used for type casting and type information.
+      # +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, cast_type, sql_type = nil, null = true)
+        @name             = name
+        @cast_type        = cast_type
+        @sql_type         = sql_type
+        @null             = null
+        @default          = default
+        @default_function = nil
+      end
+
+      def has_default?
+        !default.nil?
+      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 with_type(type)
+        dup.tap do |clone|
+          clone.instance_variable_set('@cast_type', type)
+        end
+      end
+
+      def ==(other)
+        other.name == name &&
+          other.default == default &&
+          other.cast_type == cast_type &&
+          other.sql_type == sql_type &&
+          other.null == null &&
+          other.default_function == default_function
+      end
+      alias :eql? :==
+
+      def hash
+        attributes_for_hash.hash
+      end
+
+      private
+
+      def attributes_for_hash
+        [self.class, name, default, cast_type, sql_type, null, default_function]
+      end
+    end
+  end
+  # :startdoc:
+end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -0,0 +1,275 @@
+require 'uri'
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionSpecification #:nodoc:
+      attr_reader :config, :adapter_method
+
+      def initialize(config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+
+      def initialize_dup(original)
+        @config = original.config.dup
+      end
+
+      # Expands a connection string into a hash.
+      class ConnectionUrlResolver # :nodoc:
+
+        # == Example
+        #
+        #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+        #   ConnectionUrlResolver.new(url).to_hash
+        #   # => {
+        #     "adapter"  => "postgresql",
+        #     "host"     => "localhost",
+        #     "port"     => 9000,
+        #     "database" => "foo_test",
+        #     "username" => "foo",
+        #     "password" => "bar",
+        #     "pool"     => "5",
+        #     "timeout"  => "3000"
+        #   }
+        def initialize(url)
+          raise "Database URL cannot be empty" if url.blank?
+          @uri     = uri_parser.parse(url)
+          @adapter = @uri.scheme.tr('-', '_')
+          @adapter = "postgresql" if @adapter == "postgres"
+
+          if @uri.opaque
+            @uri.opaque, @query = @uri.opaque.split('?', 2)
+          else
+            @query = @uri.query
+          end
+        end
+
+        # Converts the given URL to a full connection hash.
+        def to_hash
+          config = raw_config.reject { |_,value| value.blank? }
+          config.map { |key,value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+          config
+        end
+
+        private
+
+        def uri
+          @uri
+        end
+
+        def uri_parser
+          @uri_parser ||= URI::Parser.new
+        end
+
+        # Converts the query parameters of the URI into a hash.
+        #
+        #   "localhost?pool=5&reaping_frequency=2"
+        #   # => { "pool" => "5", "reaping_frequency" => "2" }
+        #
+        # returns empty hash if no query present.
+        #
+        #   "localhost"
+        #   # => {}
+        def query_hash
+          Hash[(@query || '').split("&").map { |pair| pair.split("=") }]
+        end
+
+        def raw_config
+          if uri.opaque
+            query_hash.merge({
+              "adapter"  => @adapter,
+              "database" => uri.opaque })
+          else
+            query_hash.merge({
+              "adapter"  => @adapter,
+              "username" => uri.user,
+              "password" => uri.password,
+              "port"     => uri.port,
+              "database" => database_from_path,
+              "host"     => uri.hostname })
+          end
+        end
+
+        # Returns name of the database.
+        def database_from_path
+          if @adapter == 'sqlite3'
+            # 'sqlite3:/foo' is absolute, because that makes sense. The
+            # corresponding relative version, 'sqlite3:foo', is handled
+            # elsewhere, as an "opaque".
+
+            uri.path
+          else
+            # Only SQLite uses a filename as the "database" name; for
+            # anything else, a leading slash would be silly.
+
+            uri.path.sub(%r{^/}, "")
+          end
+        end
+      end
+
+      ##
+      # Builds a ConnectionSpecification from user input.
+      class Resolver # :nodoc:
+        attr_reader :configurations
+
+        # Accepts a hash two layers deep, keys on the first layer represent
+        # environments such as "production". Keys must be strings.
+        def initialize(configurations)
+          @configurations = configurations
+        end
+
+        # Returns a hash with database connection information.
+        #
+        # == Examples
+        #
+        # Full hash Configuration.
+        #
+        #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   Resolver.new(configurations).resolve(:production)
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
+        #
+        # Initialized with URL configuration strings.
+        #
+        #   configurations = { "production" => "postgresql://localhost/foo" }
+        #   Resolver.new(configurations).resolve(:production)
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+        #
+        def resolve(config)
+          if config
+            resolve_connection config
+          elsif env = ActiveRecord::ConnectionHandling::RAILS_ENV.call
+            resolve_symbol_connection env.to_sym
+          else
+            raise AdapterNotSpecified
+          end
+        end
+
+        # Expands each key in @configurations hash into fully resolved hash
+        def resolve_all
+          config = configurations.dup
+          config.each do |key, value|
+            config[key] = resolve(value) if value
+          end
+          config
+        end
+
+        # Returns an instance of ConnectionSpecification for a given adapter.
+        # Accepts a hash one layer deep that contains all connection information.
+        #
+        # == Example
+        #
+        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   spec = Resolver.new(config).spec(:production)
+        #   spec.adapter_method
+        #   # => "sqlite3_connection"
+        #   spec.config
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
+        #
+        def spec(config)
+          spec = resolve(config).symbolize_keys
+
+          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+          path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
+          begin
+            require path_to_adapter
+          rescue Gem::LoadError => e
+            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
+          rescue LoadError => e
+            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql', 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
+          end
+
+          adapter_method = "#{spec[:adapter]}_connection"
+          ConnectionSpecification.new(spec, adapter_method)
+        end
+
+        private
+
+        # Returns fully resolved connection, accepts hash, string or symbol.
+        # Always returns a hash.
+        #
+        # == Examples
+        #
+        # Symbol representing current environment.
+        #
+        #   Resolver.new("production" => {}).resolve_connection(:production)
+        #   # => {}
+        #
+        # One layer deep hash of connection values.
+        #
+        #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
+        #   # => { "adapter" => "sqlite3" }
+        #
+        # Connection URL.
+        #
+        #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+        #
+        def resolve_connection(spec)
+          case spec
+          when Symbol
+            resolve_symbol_connection spec
+          when String
+            resolve_string_connection spec
+          when Hash
+            resolve_hash_connection spec
+          end
+        end
+
+        def resolve_string_connection(spec)
+          # Rails has historically accepted a string to mean either
+          # an environment key or a URL spec, so we have deprecated
+          # this ambiguous behaviour and in the future this function
+          # can be removed in favor of resolve_url_connection.
+          if configurations.key?(spec) || spec !~ /:/
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Passing a string to ActiveRecord::Base.establish_connection for a
+              configuration lookup is deprecated, please pass a symbol
+              (#{spec.to_sym.inspect}) instead.
+            MSG
+
+            resolve_symbol_connection(spec)
+          else
+            resolve_url_connection(spec)
+          end
+        end
+
+        # Takes the environment such as +:production+ or +:development+.
+        # This requires that the @configurations was initialized with a key that
+        # matches.
+        #
+        #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
+        #   # => {}
+        #
+        def resolve_symbol_connection(spec)
+          if config = configurations[spec.to_s]
+            resolve_connection(config)
+          else
+            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+          end
+        end
+
+        # Accepts a hash. Expands the "url" key that contains a
+        # URL database connection to a full connection
+        # hash and merges with the rest of the hash.
+        # Connection details inside of the "url" key win any merge conflicts
+        def resolve_hash_connection(spec)
+          if spec["url"] && spec["url"] !~ /^jdbc:/
+            connection_hash = resolve_url_connection(spec.delete("url"))
+            spec.merge!(connection_hash)
+          end
+          spec
+        end
+
+        # Takes a connection URL.
+        #
+        #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+        #
+        def resolve_url_connection(url)
+          ConnectionUrlResolver.new(url).to_hash
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,282 @@
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+
+gem 'mysql2', '~> 0.3.13'
+require 'mysql2'
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def mysql2_connection(config)
+      config = config.symbolize_keys
+
+      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)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+    rescue Mysql2::Error => error
+      if error.message.include?("Unknown database")
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
+      else
+        raise
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class Mysql2Adapter < AbstractMysqlAdapter
+      ADAPTER_NAME = 'Mysql2'.freeze
+
+      def initialize(connection, logger, connection_options, config)
+        super
+        @prepared_statements = false
+        configure_connection
+      end
+
+      MAX_INDEX_LENGTH_FOR_UTF8MB4 = 191
+      def initialize_schema_migrations_table
+        if @config[:encoding] == 'utf8mb4'
+          ActiveRecord::SchemaMigration.create_table(MAX_INDEX_LENGTH_FOR_UTF8MB4)
+        else
+          ActiveRecord::SchemaMigration.create_table
+        end
+      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 error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
+      end
+
+      #--
+      # QUOTING ==================================================
+      #++
+
+      def quote_string(string)
+        @connection.escape(string)
+      end
+
+      def quoted_date(value)
+        if value.acts_like?(:time) && value.respond_to?(:usec)
+          "#{super}.#{sprintf("%06d", value.usec)}"
+        else
+          super
+        end
+      end
+
+      #--
+      # CONNECTION MANAGEMENT ====================================
+      #++
+
+      def active?
+        return false unless @connection
+        @connection.ping
+      end
+
+      def reconnect!
+        super
+        disconnect!
+        connect
+      end
+      alias :reset! :reconnect!
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        super
+        unless @connection.nil?
+          @connection.close
+          @connection = nil
+        end
+      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, binds = [])
+        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
+
+      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, pk = nil, sequence_name = nil)
+        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)
+        super
+      end
+
+      def full_version
+        @full_version ||= @connection.info[:version]
+      end
+
+      def set_field_encoding field_name
+        field_name
+      end
+    end
+  end
+end