activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -36,9 +36,9 @@ module ActiveRecord
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
     rescue Mysql::Error => error
       if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
@@ -57,7 +57,7 @@ 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>:strict</tt> - Defaults to true. Enable STRICT_ALL_TABLES. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html)
     # * <tt>:variables</tt> - (Optional) A hash session variables to send as `SET @@SESSION.key = value` 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.
@@ -66,35 +66,6 @@ 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'
 
       class StatementPool < ConnectionAdapters::StatementPool
@@ -156,10 +127,6 @@ module ActiveRecord
         end
       end
 
-      def new_column(field, default, type, null, collation, extra = "") # :nodoc:
-        Column.new(field, default, type, null, collation, strict_mode?, extra)
-      end
-
       def error_number(exception) # :nodoc:
         exception.errno if exception.respond_to?(:errno)
       end
@@ -222,6 +189,7 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
+        super
         @statements.clear
       end
 
@@ -294,126 +262,70 @@ module ActiveRecord
         @connection.insert_id
       end
 
-      module Fields
-        class Type
-          def type; end
-
-          def type_cast_for_write(value)
-            value
-          end
-        end
-
-        class Identity < Type
-          def type_cast(value); value; end
-        end
-
-        class Integer < Type
-          def type_cast(value)
-            return if value.nil?
-
-            value.to_i rescue value ? 1 : 0
-          end
-        end
-
-        class Date < Type
-          def type; :date; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.value_to_date value
-          end
-        end
-
-        class DateTime < Type
-          def type; :datetime; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.string_to_time value
-          end
-        end
-
-        class Time < Type
-          def type; :time; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.string_to_dummy_time value
-          end
-        end
-
-        class Float < Type
-          def type; :float; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            value.to_f
+      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
         end
 
-        class Decimal < Type
-          def type_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::Column.value_to_decimal value
+        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 Boolean < Type
-          def type_cast(value)
-            return if value.nil?
+        class << self
+          TYPES = Type::HashLookupTypeMap.new # :nodoc:
 
-            ConnectionAdapters::Column.value_to_boolean value
-          end
-        end
-
-        TYPES = {}
-
-        # Register an MySQL +type_id+ with a typecasting object in
-        # +type+.
-        def self.register_type(type_id, type)
-          TYPES[type_id] = type
-        end
+          delegate :register_type, :alias_type, to: :TYPES
 
-        def self.alias_type(new, old)
-          TYPES[new] = TYPES[old]
-        end
-
-        def self.find_type(field)
-          if field.type == Mysql::Field::TYPE_TINY && field.length > 1
-            TYPES[Mysql::Field::TYPE_LONG]
-          else
-            TYPES.fetch(field.type) { Fields::Identity.new }
+          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,    Fields::Boolean.new
-        register_type Mysql::Field::TYPE_LONG,    Fields::Integer.new
+        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_VAR_STRING, Fields::Identity.new
-        register_type Mysql::Field::TYPE_BLOB, Fields::Identity.new
-        register_type Mysql::Field::TYPE_DATE, Fields::Date.new
+        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, Fields::Float.new
+        register_type Mysql::Field::TYPE_FLOAT, Type::Float.new
+      end
 
-        Mysql::Field.constants.grep(/TYPE/).map { |class_name|
-          Mysql::Field.const_get class_name
-        }.reject { |const| TYPES.key? const }.each do |const|
-          register_type const, Fields::Identity.new
-        end
+      def initialize_type_map(m) # :nodoc:
+        super
+        m.register_type %r(datetime)i, Fields::DateTime.new
+        m.register_type %r(time)i,     Fields::Time.new
       end
 
       def exec_without_stmt(sql, name = 'SQL') # :nodoc:
@@ -431,7 +343,7 @@ module ActiveRecord
               fields << field_name
 
               if field.decimals > 0
-                types[field_name] = Fields::Decimal.new
+                types[field_name] = Type::Decimal.new
               else
                 types[field_name] = Fields.find_type field
               end
@@ -447,7 +359,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
@@ -460,7 +372,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|
@@ -497,7 +409,7 @@ module ActiveRecord
             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

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

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLColumn < Column
-      module ArrayParser
+    module PostgreSQL
+      module ArrayParser # :nodoc:
 
         DOUBLE_QUOTE = '"'
         BACKSLASH = "\\"
@@ -9,35 +9,23 @@ module ActiveRecord
         BRACKET_OPEN = '{'
         BRACKET_CLOSE = '}'
 
-        private
-          # Loads pg_array_parser if available. String parsing can be
-          # performed quicker by a native extension, which will not create
-          # a large amount of Ruby objects that will need to be garbage
-          # collected. pg_array_parser has a C and Java extension
-          begin
-            require 'pg_array_parser'
-            include PgArrayParser
-          rescue LoadError
-            def parse_pg_array(string)
-              parse_data(string)
+        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
 
-          def parse_data(string)
-            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
 
-            array
-          end
+        private
 
           def parse_array_contents(array, string, index)
             is_escaping  = false

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

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

@@ -1,6 +1,6 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    module PostgreSQL
       module DatabaseStatements
         def explain(arel, binds = [])
           sql = "EXPLAIN #{to_sql(arel, binds)}"
@@ -44,10 +44,32 @@ module ActiveRecord
           end
         end
 
+        def select_value(arel, name = nil, binds = [])
+          arel, binds = binds_from_relation arel, binds
+          sql = to_sql(arel, binds)
+          execute_and_clear(sql, name, binds) do |result|
+            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
+          end
+        end
+
+        def select_values(arel, name = nil)
+          arel, binds = binds_from_relation arel, []
+          sql = to_sql(arel, binds)
+          execute_and_clear(sql, name, binds) do |result|
+            if result.nfields > 0
+              result.column_values(0)
+            else
+              []
+            end
+          end
+        end
+
         # Executes a SELECT query and returns an array of rows. Each row is an
         # array of field values.
         def select_rows(sql, name = nil, binds = [])
-          exec_query(sql, name, binds).rows
+          execute_and_clear(sql, name, binds) do |result|
+            result.values
+          end
         end
 
         # Executes an INSERT query and returns the new record's ID
@@ -72,6 +94,11 @@ module ActiveRecord
           super.insert
         end
 
+        # The internal PostgreSQL identifier of the money data type.
+        MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
+        # The internal PostgreSQL identifier of the BYTEA data type.
+        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
+
         # create a 2D array representing the result set
         def result_as_array(res) #:nodoc:
           # check if we have any binary column and if they need escaping
@@ -134,28 +161,20 @@ module ActiveRecord
         end
 
         def exec_query(sql, name = 'SQL', binds = [])
-          result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
-                                                        exec_cache(sql, name, binds)
-
-          types = {}
-          fields = result.fields
-          fields.each_with_index do |fname, i|
-            ftype = result.ftype i
-            fmod  = result.fmod i
-            types[fname] = get_oid_type(ftype, fmod, fname)
+          execute_and_clear(sql, name, binds) do |result|
+            types = {}
+            fields = result.fields
+            fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = get_oid_type(ftype, fmod, fname)
+            end
+            ActiveRecord::Result.new(fields, result.values, types)
           end
-
-          ret = ActiveRecord::Result.new(fields, result.values, types)
-          result.clear
-          return ret
         end
 
         def exec_delete(sql, name = 'SQL', binds = [])
-          result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
-                                                        exec_cache(sql, name, binds)
-          affected = result.cmd_tuples
-          result.clear
-          affected
+          execute_and_clear(sql, name, binds) {|result| result.cmd_tuples }
         end
         alias :exec_update :exec_delete
 

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -0,0 +1,96 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Array < Type::Value # :nodoc:
+          include Type::Mutable
+
+          # Loads pg_array_parser if available. String parsing can be
+          # performed quicker by a native extension, which will not create
+          # a large amount of Ruby objects that will need to be garbage
+          # collected. pg_array_parser has a C and Java extension
+          begin
+            require 'pg_array_parser'
+            include PgArrayParser
+          rescue LoadError
+            require 'active_record/connection_adapters/postgresql/array_parser'
+            include PostgreSQL::ArrayParser
+          end
+
+          attr_reader :subtype, :delimiter
+          delegate :type, to: :subtype
+
+          def initialize(subtype, delimiter = ',')
+            @subtype = subtype
+            @delimiter = delimiter
+          end
+
+          def type_cast_from_database(value)
+            if value.is_a?(::String)
+              type_cast_array(parse_pg_array(value), :type_cast_from_database)
+            else
+              super
+            end
+          end
+
+          def type_cast_from_user(value)
+            type_cast_array(value, :type_cast_from_user)
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array)
+              cast_value_for_database(value)
+            else
+              super
+            end
+          end
+
+          private
+
+          def type_cast_array(value, method)
+            if value.is_a?(::Array)
+              value.map { |item| type_cast_array(item, method) }
+            else
+              @subtype.public_send(method, value)
+            end
+          end
+
+          def cast_value_for_database(value)
+            if value.is_a?(::Array)
+              casted_values = value.map { |item| cast_value_for_database(item) }
+              "{#{casted_values.join(delimiter)}}"
+            else
+              quote_and_escape(subtype.type_cast_for_database(value))
+            end
+          end
+
+          ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
+
+          def quote_and_escape(value)
+            case value
+            when ::String
+              if string_requires_quoting?(value)
+                value = value.gsub(/\\/, ARRAY_ESCAPE)
+                value.gsub!(/"/,"\\\"")
+                %("#{value}")
+              else
+                value
+              end
+            when nil then "NULL"
+            else value
+            end
+          end
+
+          # See http://www.postgresql.org/docs/9.2/static/arrays.html#ARRAYS-IO
+          # for a list of all cases in which strings will be quoted.
+          def string_requires_quoting?(string)
+            string.empty? ||
+              string == "NULL" ||
+              string =~ /[\{\}"\\\s]/ ||
+              string.include?(delimiter)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/bit.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Bit < Type::Value # :nodoc:
+          def type
+            :bit
+          end
+
+          def type_cast(value)
+            if ::String === value
+              case value
+              when /^0x/i
+                value[2..-1].hex.to_s(2) # Hexadecimal notation
+              else
+                value                    # Bit-string notation
+              end
+            else
+              value
+            end
+          end
+
+          def type_cast_for_database(value)
+            Data.new(super) if value
+          end
+
+          class Data
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              value
+            end
+
+            def binary?
+              /\A[01]*\Z/ === value
+            end
+
+            def hex?
+              /\A[0-9A-F]*\Z/i === value
+            end
+
+            protected
+
+            attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class BitVarying < OID::Bit # :nodoc:
+          def type
+            :bit_varying
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/bytea.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Bytea < Type::Binary # :nodoc:
+          def type_cast_from_database(value)
+            return if value.nil?
+            PGconn.unescape_bytea(super)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/cidr.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Cidr < Type::Value # :nodoc:
+          def type
+            :cidr
+          end
+
+          def type_cast_for_schema(value)
+            subnet_mask = value.instance_variable_get(:@mask_addr)
+
+            # If the subnet mask is equal to /32, don't output it
+            if subnet_mask == (2**32 - 1)
+              "\"#{value.to_s}\""
+            else
+              "\"#{value.to_s}/#{subnet_mask.to_s(2).count('1')}\""
+            end
+          end
+
+          def type_cast_for_database(value)
+            if IPAddr === value
+              "#{value.to_s}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+            else
+              value
+            end
+          end
+
+          def cast_value(value)
+            if value.nil?
+              nil
+            elsif String === value
+              begin
+                IPAddr.new(value)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end