activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -2,13 +2,11 @@ require 'active_record/connection_adapters/abstract_mysql_adapter'
 require 'active_record/connection_adapters/statement_pool'
 require 'active_support/core_ext/hash/keys'
 
-gem 'mysql', '~> 2.8'
+gem 'mysql', '~> 2.9'
 require 'mysql'
 
 class Mysql
   class Time
-    ###
-    # This monkey patch is for test_additional_columns_from_join_table
     def to_date
       Date.new(year, month, day)
     end
@@ -18,9 +16,9 @@ class Mysql
 end
 
 module ActiveRecord
-  class Base
+  module ConnectionHandling # :nodoc:
     # Establishes a connection to the database that's used by all Active Record objects.
-    def self.mysql_connection(config) # :nodoc:
+    def mysql_connection(config)
       config = config.symbolize_keys
       host     = config[:host]
       port     = config[:port]
@@ -36,6 +34,12 @@ module ActiveRecord
       default_flags |= Mysql::CLIENT_FOUND_ROWS if Mysql.const_defined?(:CLIENT_FOUND_ROWS)
       options = [host, username, password, database, port, socket, default_flags]
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
+    rescue Mysql::Error => error
+      if error.message.include?("Unknown database")
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
+      else
+        raise
+      end
     end
   end
 
@@ -53,6 +57,8 @@ module ActiveRecord
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
     # * <tt>:encoding</tt> - (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection.
     # * <tt>:reconnect</tt> - Defaults to false (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/auto-reconnect.html).
+    # * <tt>:strict</tt> - Defaults to true. Enable STRICT_ALL_TABLES. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/sql-mode.html)
+    # * <tt>:variables</tt> - (Optional) A hash session variables to send as <tt>SET @@SESSION.key = value</tt> on each database connection. Use the value +:default+ to set a variable to its DEFAULT value. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/set-statement.html).
     # * <tt>:sslca</tt> - Necessary to use MySQL with an SSL connection.
     # * <tt>:sslkey</tt> - Necessary to use MySQL with an SSL connection.
     # * <tt>:sslcert</tt> - Necessary to use MySQL with an SSL connection.
@@ -60,36 +66,7 @@ module ActiveRecord
     # * <tt>:sslcipher</tt> - Necessary to use MySQL with an SSL connection.
     #
     class MysqlAdapter < AbstractMysqlAdapter
-
-      class Column < AbstractMysqlAdapter::Column #:nodoc:
-        def self.string_to_time(value)
-          return super unless Mysql::Time === value
-          new_time(
-            value.year,
-            value.month,
-            value.day,
-            value.hour,
-            value.minute,
-            value.second,
-            value.second_part)
-        end
-
-        def self.string_to_dummy_time(v)
-          return super unless Mysql::Time === v
-          new_time(2000, 01, 01, v.hour, v.minute, v.second, v.second_part)
-        end
-
-        def self.string_to_date(v)
-          return super unless Mysql::Time === v
-          new_date(v.year, v.month, v.day)
-        end
-
-        def adapter
-          MysqlAdapter
-        end
-      end
-
-      ADAPTER_NAME = 'MySQL'
+      ADAPTER_NAME = 'MySQL'.freeze
 
       class StatementPool < ConnectionAdapters::StatementPool
         def initialize(connection, max = 1000)
@@ -111,7 +88,7 @@ module ActiveRecord
         end
 
         def clear
-          cache.values.each do |hash|
+          cache.each_value do |hash|
             hash[:stmt].close
           end
           cache.clear
@@ -119,14 +96,14 @@ module ActiveRecord
 
         private
         def cache
-          @cache[$$]
+          @cache[Process.pid]
         end
       end
 
       def initialize(connection, logger, connection_options, config)
         super
         @statements = StatementPool.new(@connection,
-                                        config.fetch(:statement_limit) { 1000 })
+                                        self.class.type_cast_config_to_integer(config.fetch(:statement_limit) { 1000 }))
         @client_encoding = nil
         connect
       end
@@ -150,27 +127,19 @@ module ActiveRecord
         end
       end
 
-      def new_column(field, default, type, null, collation) # :nodoc:
-        Column.new(field, default, type, null, collation)
-      end
-
       def error_number(exception) # :nodoc:
         exception.errno if exception.respond_to?(:errno)
       end
 
       # QUOTING ==================================================
 
-      def type_cast(value, column)
-        return super unless value == true || value == false
-
-        value ? 1 : 0
-      end
-
       def quote_string(string) #:nodoc:
         @connection.quote(string)
       end
 
+      #--
       # CONNECTION MANAGEMENT ====================================
+      #++
 
       def active?
         if @connection.respond_to?(:stat)
@@ -190,14 +159,15 @@ module ActiveRecord
       end
 
       def reconnect!
+        super
         disconnect!
-        clear_cache!
         connect
       end
 
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
+        super
         @connection.close rescue nil
       end
 
@@ -210,83 +180,78 @@ module ActiveRecord
         end
       end
 
+      #--
       # DATABASE STATEMENTS ======================================
+      #++
 
-      def select_rows(sql, name = nil)
+      def select_rows(sql, name = nil, binds = [])
         @connection.query_with_result = true
-        rows = exec_query(sql, name).rows
+        rows = exec_query(sql, name, binds).rows
         @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
         rows
       end
 
       # Clears the prepared statements cache.
       def clear_cache!
+        super
         @statements.clear
       end
 
-      if "<3".respond_to?(:encode)
-        # Taken from here:
-        #   https://github.com/tmtm/ruby-mysql/blob/master/lib/mysql/charset.rb
-        # Author: TOMITA Masahiro <tommy@tmtm.org>
-        ENCODINGS = {
-          "armscii8" => nil,
-          "ascii"    => Encoding::US_ASCII,
-          "big5"     => Encoding::Big5,
-          "binary"   => Encoding::ASCII_8BIT,
-          "cp1250"   => Encoding::Windows_1250,
-          "cp1251"   => Encoding::Windows_1251,
-          "cp1256"   => Encoding::Windows_1256,
-          "cp1257"   => Encoding::Windows_1257,
-          "cp850"    => Encoding::CP850,
-          "cp852"    => Encoding::CP852,
-          "cp866"    => Encoding::IBM866,
-          "cp932"    => Encoding::Windows_31J,
-          "dec8"     => nil,
-          "eucjpms"  => Encoding::EucJP_ms,
-          "euckr"    => Encoding::EUC_KR,
-          "gb2312"   => Encoding::EUC_CN,
-          "gbk"      => Encoding::GBK,
-          "geostd8"  => nil,
-          "greek"    => Encoding::ISO_8859_7,
-          "hebrew"   => Encoding::ISO_8859_8,
-          "hp8"      => nil,
-          "keybcs2"  => nil,
-          "koi8r"    => Encoding::KOI8_R,
-          "koi8u"    => Encoding::KOI8_U,
-          "latin1"   => Encoding::ISO_8859_1,
-          "latin2"   => Encoding::ISO_8859_2,
-          "latin5"   => Encoding::ISO_8859_9,
-          "latin7"   => Encoding::ISO_8859_13,
-          "macce"    => Encoding::MacCentEuro,
-          "macroman" => Encoding::MacRoman,
-          "sjis"     => Encoding::SHIFT_JIS,
-          "swe7"     => nil,
-          "tis620"   => Encoding::TIS_620,
-          "ucs2"     => Encoding::UTF_16BE,
-          "ujis"     => Encoding::EucJP_ms,
-          "utf8"     => Encoding::UTF_8,
-          "utf8mb4"  => Encoding::UTF_8,
-        }
-      else
-        ENCODINGS = Hash.new { |h,k| h[k] = k }
-      end
+      # Taken from here:
+      #   https://github.com/tmtm/ruby-mysql/blob/master/lib/mysql/charset.rb
+      # Author: TOMITA Masahiro <tommy@tmtm.org>
+      ENCODINGS = {
+        "armscii8" => nil,
+        "ascii"    => Encoding::US_ASCII,
+        "big5"     => Encoding::Big5,
+        "binary"   => Encoding::ASCII_8BIT,
+        "cp1250"   => Encoding::Windows_1250,
+        "cp1251"   => Encoding::Windows_1251,
+        "cp1256"   => Encoding::Windows_1256,
+        "cp1257"   => Encoding::Windows_1257,
+        "cp850"    => Encoding::CP850,
+        "cp852"    => Encoding::CP852,
+        "cp866"    => Encoding::IBM866,
+        "cp932"    => Encoding::Windows_31J,
+        "dec8"     => nil,
+        "eucjpms"  => Encoding::EucJP_ms,
+        "euckr"    => Encoding::EUC_KR,
+        "gb2312"   => Encoding::EUC_CN,
+        "gbk"      => Encoding::GBK,
+        "geostd8"  => nil,
+        "greek"    => Encoding::ISO_8859_7,
+        "hebrew"   => Encoding::ISO_8859_8,
+        "hp8"      => nil,
+        "keybcs2"  => nil,
+        "koi8r"    => Encoding::KOI8_R,
+        "koi8u"    => Encoding::KOI8_U,
+        "latin1"   => Encoding::ISO_8859_1,
+        "latin2"   => Encoding::ISO_8859_2,
+        "latin5"   => Encoding::ISO_8859_9,
+        "latin7"   => Encoding::ISO_8859_13,
+        "macce"    => Encoding::MacCentEuro,
+        "macroman" => Encoding::MacRoman,
+        "sjis"     => Encoding::SHIFT_JIS,
+        "swe7"     => nil,
+        "tis620"   => Encoding::TIS_620,
+        "ucs2"     => Encoding::UTF_16BE,
+        "ujis"     => Encoding::EucJP_ms,
+        "utf8"     => Encoding::UTF_8,
+        "utf8mb4"  => Encoding::UTF_8,
+      }
 
       # Get the client encoding for this database
       def client_encoding
         return @client_encoding if @client_encoding
 
         result = exec_query(
-          "SHOW VARIABLES WHERE Variable_name = 'character_set_client'",
+          "select @@character_set_client",
           'SCHEMA')
         @client_encoding = ENCODINGS[result.rows.last.last]
       end
 
       def exec_query(sql, name = 'SQL', binds = [])
-        # If the configuration sets prepared_statements:false, binds will
-        # always be empty, since the bind variables will have been already
-        # substituted and removed from binds by BindVisitor, so this will
-        # effectively disable prepared statement usage completely.
-        if binds.empty?
+        if without_prepared_statement?(binds)
           result_set, affected_rows = exec_without_stmt(sql, name)
         else
           result_set, affected_rows = exec_stmt(sql, name, binds)
@@ -301,6 +266,79 @@ module ActiveRecord
         @connection.insert_id
       end
 
+      module Fields # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def cast_value(value)
+            if Mysql::Time === value
+              new_time(
+                value.year,
+                value.month,
+                value.day,
+                value.hour,
+                value.minute,
+                value.second,
+                value.second_part)
+            else
+              super
+            end
+          end
+
+          def has_precision?
+            precision || 0
+          end
+        end
+
+        class Time < Type::Time # :nodoc:
+          def cast_value(value)
+            if Mysql::Time === value
+              new_time(
+                2000,
+                01,
+                01,
+                value.hour,
+                value.minute,
+                value.second,
+                value.second_part)
+            else
+              super
+            end
+          end
+        end
+
+        class << self
+          TYPES = Type::HashLookupTypeMap.new # :nodoc:
+
+          delegate :register_type, :alias_type, to: :TYPES
+
+          def find_type(field)
+            if field.type == Mysql::Field::TYPE_TINY && field.length > 1
+              TYPES.lookup(Mysql::Field::TYPE_LONG)
+            else
+              TYPES.lookup(field.type)
+            end
+          end
+        end
+
+        register_type Mysql::Field::TYPE_TINY,    Type::Boolean.new
+        register_type Mysql::Field::TYPE_LONG,    Type::Integer.new
+        alias_type Mysql::Field::TYPE_LONGLONG,   Mysql::Field::TYPE_LONG
+        alias_type Mysql::Field::TYPE_NEWDECIMAL, Mysql::Field::TYPE_LONG
+
+        register_type Mysql::Field::TYPE_DATE, Type::Date.new
+        register_type Mysql::Field::TYPE_DATETIME, Fields::DateTime.new
+        register_type Mysql::Field::TYPE_TIME, Fields::Time.new
+        register_type Mysql::Field::TYPE_FLOAT, Type::Float.new
+      end
+
+      def initialize_type_map(m) # :nodoc:
+        super
+        m.register_type %r(time)i,     Fields::Time.new
+        m.register_type(%r(datetime)i) do |sql_type|
+          precision = extract_precision(sql_type)
+          Fields::DateTime.new(precision: precision)
+        end
+      end
+
       def exec_without_stmt(sql, name = 'SQL') # :nodoc:
         # Some queries, like SHOW CREATE TABLE don't work through the prepared
         # statement API. For those queries, we need to use this method. :'(
@@ -309,8 +347,20 @@ module ActiveRecord
           affected_rows = @connection.affected_rows
 
           if result
-            cols = result.fetch_fields.map { |field| field.name }
-            result_set = ActiveRecord::Result.new(cols, result.to_a)
+            types = {}
+            fields = []
+            result.fetch_fields.each { |field|
+              field_name = field.name
+              fields << field_name
+
+              if field.decimals > 0
+                types[field_name] = Type::Decimal.new
+              else
+                types[field_name] = Fields.find_type field
+              end
+            }
+
+            result_set = ActiveRecord::Result.new(fields, result.to_a, types)
             result.free
           else
             result_set = ActiveRecord::Result.new([], [])
@@ -320,7 +370,7 @@ module ActiveRecord
         end
       end
 
-      def execute_and_free(sql, name = nil)
+      def execute_and_free(sql, name = nil) # :nodoc:
         result = execute(sql, name)
         ret = yield result
         result.free
@@ -333,7 +383,7 @@ module ActiveRecord
       end
       alias :create :insert_sql
 
-      def exec_delete(sql, name, binds)
+      def exec_delete(sql, name, binds) # :nodoc:
         affected_rows = 0
 
         exec_query(sql, name, binds) do |n|
@@ -346,15 +396,17 @@ module ActiveRecord
 
       def begin_db_transaction #:nodoc:
         exec_query "BEGIN"
-      rescue Mysql::Error
-        # Transactions aren't supported
       end
 
       private
 
       def exec_stmt(sql, name, binds)
         cache = {}
-        log(sql, name, binds) do
+        type_casted_binds = binds.map { |col, val|
+          [col, type_cast(val, col)]
+        }
+
+        log(sql, name, type_casted_binds) do
           if binds.empty?
             stmt = @connection.prepare(sql)
           else
@@ -365,10 +417,10 @@ module ActiveRecord
           end
 
           begin
-            stmt.execute(*binds.map { |col, val| type_cast(val, col) })
+            stmt.execute(*type_casted_binds.map { |_, val| val })
           rescue Mysql::Error => e
             # Older versions of MySQL leave the prepared statement in a bad
-            # place when an error occurs. To support older mysql versions, we
+            # place when an error occurs. To support older MySQL versions, we
             # need to close the statement and delete the statement from the
             # cache.
             stmt.close
@@ -381,12 +433,12 @@ module ActiveRecord
             cols = cache[:cols] ||= metadata.fetch_fields.map { |field|
               field.name
             }
+            metadata.free
           end
 
           result_set = ActiveRecord::Result.new(cols, stmt.to_a) if cols
           affected_rows = stmt.affected_rows
 
-          stmt.result_metadata.free if cols
           stmt.free_result
           stmt.close if binds.empty?
 
@@ -416,25 +468,30 @@ module ActiveRecord
         configure_connection
       end
 
+      # Many Rails applications monkey-patch a replacement of the configure_connection method
+      # and don't call 'super', so leave this here even though it looks superfluous.
       def configure_connection
-        encoding = @config[:encoding]
-        execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
-
-        # By default, MySQL 'where id is null' selects the last inserted id.
-        # Turn this off. http://dev.rubyonrails.org/ticket/6778
-        execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+        super
       end
 
       def select(sql, name = nil, binds = [])
         @connection.query_with_result = true
-        rows = exec_query(sql, name, binds).to_a
+        rows = super
         @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
         rows
       end
 
-      # Returns the version of the connected MySQL server.
-      def version
-        @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      # Returns the full version of the connected MySQL server.
+      def full_version
+        @full_version ||= @connection.server_info
+      end
+
+      def set_field_encoding field_name
+        field_name.force_encoding(client_encoding)
+        if internal_enc = Encoding.default_internal
+          field_name = field_name.encode!(internal_enc)
+        end
+        field_name
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/array_parser.rb

@@ -0,0 +1,93 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module ArrayParser # :nodoc:
+
+        DOUBLE_QUOTE = '"'
+        BACKSLASH = "\\"
+        COMMA = ','
+        BRACKET_OPEN = '{'
+        BRACKET_CLOSE = '}'
+
+        def parse_pg_array(string) # :nodoc:
+          local_index = 0
+          array = []
+          while(local_index < string.length)
+            case string[local_index]
+            when BRACKET_OPEN
+              local_index,array = parse_array_contents(array, string, local_index + 1)
+            when BRACKET_CLOSE
+              return array
+            end
+            local_index += 1
+          end
+
+          array
+        end
+
+        private
+
+          def parse_array_contents(array, string, index)
+            is_escaping  = false
+            is_quoted    = false
+            was_quoted   = false
+            current_item = ''
+
+            local_index = index
+            while local_index
+              token = string[local_index]
+              if is_escaping
+                current_item << token
+                is_escaping = false
+              else
+                if is_quoted
+                  case token
+                  when DOUBLE_QUOTE
+                    is_quoted = false
+                    was_quoted = true
+                  when BACKSLASH
+                    is_escaping = true
+                  else
+                    current_item << token
+                  end
+                else
+                  case token
+                  when BACKSLASH
+                    is_escaping = true
+                  when COMMA
+                    add_item_to_array(array, current_item, was_quoted)
+                    current_item = ''
+                    was_quoted = false
+                  when DOUBLE_QUOTE
+                    is_quoted = true
+                  when BRACKET_OPEN
+                    internal_items = []
+                    local_index,internal_items = parse_array_contents(internal_items, string, local_index + 1)
+                    array.push(internal_items)
+                  when BRACKET_CLOSE
+                    add_item_to_array(array, current_item, was_quoted)
+                    return local_index,array
+                  else
+                    current_item << token
+                  end
+                end
+              end
+
+              local_index += 1
+            end
+            return local_index,array
+          end
+
+          def add_item_to_array(array, current_item, quoted)
+            return if !quoted && current_item.length == 0
+
+            if !quoted && current_item == 'NULL'
+              array.push nil
+            else
+              array.push current_item
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/column.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # PostgreSQL-specific extensions to column definitions in a table.
+    class PostgreSQLColumn < Column #:nodoc:
+      attr_accessor :array
+
+      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
+        if sql_type =~ /\[\]$/
+          @array = true
+          super(name, default, cast_type, sql_type[0..sql_type.length - 3], null)
+        else
+          @array = false
+          super(name, default, cast_type, sql_type, null)
+        end
+
+        @default_function = default_function
+      end
+    end
+  end
+end