activerecord 5.1.0.beta1 → 5.1.0.rc1

data/lib/active_record/relation.rb

@@ -261,10 +261,6 @@ module ActiveRecord
       coder.represent_seq(nil, records)
     end
 
-    def as_json(options = nil) #:nodoc:
-      records.as_json(options)
-    end
-
     # Returns size of the records.
     def size
       loaded? ? @records.length : count(:all)

data/lib/active_record/relation/calculations.rb

@@ -37,11 +37,8 @@ module ActiveRecord
     # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid #count expressions. The specifics differ
     # between databases. In invalid cases, an error from the database is thrown.
     def count(column_name = nil)
-      if block_given?
-        to_a.count { |*block_args| yield(*block_args) }
-      else
-        calculate(:count, column_name)
-      end
+      return super() if block_given?
+      calculate(:count, column_name)
     end
 
     # Calculates the average value on a given column. Returns +nil+ if there's
@@ -75,8 +72,8 @@ module ActiveRecord
     # #calculate for examples with options.
     #
     #   Person.sum(:age) # => 4562
-    def sum(column_name = nil, &block)
-      return super(&block) if block_given?
+    def sum(column_name = nil)
+      return super() if block_given?
       calculate(:sum, column_name)
     end
 
@@ -232,7 +229,7 @@ module ActiveRecord
           query_builder = build_count_subquery(spawn, column_name, distinct)
         else
           # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
-          relation = unscope(:order)
+          relation = unscope(:order).distinct!(false)
 
           column = aggregate_column(column_name)
 
@@ -282,7 +279,7 @@ module ActiveRecord
             operation,
             distinct).as(aggregate_alias)
         ]
-        select_values += select_values unless having_clause.empty?
+        select_values += self.select_values unless having_clause.empty?
 
         select_values.concat group_columns.map { |aliaz, field|
           if field.respond_to?(:as)
@@ -292,7 +289,7 @@ module ActiveRecord
           end
         }
 
-        relation = except(:group)
+        relation = except(:group).distinct!(false)
         relation.group_values  = group_fields
         relation.select_values = select_values
 

data/lib/active_record/relation/delegation.rb

@@ -36,9 +36,9 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :encode_with, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join,
+    delegate :to_xml, :encode_with, :length, :each, :uniq, :to_ary, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :compact, :in_groups, :in_groups_of,
-             :to_sentence, :to_formatted_s,
+             :to_sentence, :to_formatted_s, :as_json,
              :shuffle, :split, :index, to: :records
 
     delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,

data/lib/active_record/relation/finder_methods.rb

@@ -147,7 +147,7 @@ module ActiveRecord
     def last(limit = nil)
       return find_last(limit) if loaded? || limit_value
 
-      result = limit(limit || 1)
+      result = limit(limit)
       result.order!(arel_attribute(primary_key)) if order_values.empty? && primary_key
       result = result.reverse_order!
 
@@ -430,140 +430,142 @@ module ActiveRecord
         reflections.none?(&:collection?)
       end
 
-      private
+      def find_with_ids(*ids)
+        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
 
-        def find_with_ids(*ids)
-          raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
 
-          expects_array = ids.first.kind_of?(Array)
-          return ids.first if expects_array && ids.first.empty?
+        ids = ids.flatten.compact.uniq
 
-          ids = ids.flatten.compact.uniq
-
-          case ids.size
-          when 0
-            raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
-          when 1
-            result = find_one(ids.first)
-            expects_array ? [ result ] : result
-          else
-            find_some(ids)
-          end
-        rescue ::RangeError
-          raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
+        case ids.size
+        when 0
+          raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids)
         end
+      rescue ::RangeError
+        raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
+      end
 
-        def find_one(id)
-          if ActiveRecord::Base === id
-            raise ArgumentError, <<-MSG.squish
-              You are passing an instance of ActiveRecord::Base to `find`.
-              Please pass the id of the object by calling `.id`.
-            MSG
-          end
-
-          relation = where(primary_key => id)
-          record = relation.take
-
-          raise_record_not_found_exception!(id, 0, 1) unless record
-
-          record
+      def find_one(id)
+        if ActiveRecord::Base === id
+          raise ArgumentError, <<-MSG.squish
+            You are passing an instance of ActiveRecord::Base to `find`.
+            Please pass the id of the object by calling `.id`.
+          MSG
         end
 
-        def find_some(ids)
-          return find_some_ordered(ids) unless order_values.present?
+        relation = where(primary_key => id)
+        record = relation.take
 
-          result = where(primary_key => ids).to_a
+        raise_record_not_found_exception!(id, 0, 1) unless record
 
-          expected_size =
-            if limit_value && ids.size > limit_value
-              limit_value
-            else
-              ids.size
-            end
+        record
+      end
 
-          # 11 ids with limit 3, offset 9 should give 2 results.
-          if offset_value && (ids.size - offset_value < expected_size)
-            expected_size = ids.size - offset_value
-          end
+      def find_some(ids)
+        return find_some_ordered(ids) unless order_values.present?
 
-          if result.size == expected_size
-            result
+        result = where(primary_key => ids).to_a
+
+        expected_size =
+          if limit_value && ids.size > limit_value
+            limit_value
           else
-            raise_record_not_found_exception!(ids, result.size, expected_size)
+            ids.size
           end
+
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if offset_value && (ids.size - offset_value < expected_size)
+          expected_size = ids.size - offset_value
         end
 
-        def find_some_ordered(ids)
-          ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+        if result.size == expected_size
+          result
+        else
+          raise_record_not_found_exception!(ids, result.size, expected_size)
+        end
+      end
 
-          result = except(:limit, :offset).where(primary_key => ids).records
+      def find_some_ordered(ids)
+        ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
 
-          if result.size == ids.size
-            pk_type = @klass.type_for_attribute(primary_key)
+        result = except(:limit, :offset).where(primary_key => ids).records
 
-            records_by_id = result.index_by(&:id)
-            ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
-          else
-            raise_record_not_found_exception!(ids, result.size, ids.size)
-          end
-        end
+        if result.size == ids.size
+          pk_type = @klass.type_for_attribute(primary_key)
 
-        def find_take
-          if loaded?
-            records.first
-          else
-            @take ||= limit(1).records.first
-          end
+          records_by_id = result.index_by(&:id)
+          ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
+        else
+          raise_record_not_found_exception!(ids, result.size, ids.size)
         end
+      end
 
-        def find_take_with_limit(limit)
-          if loaded?
-            records.take(limit)
-          else
-            limit(limit).to_a
-          end
+      def find_take
+        if loaded?
+          records.first
+        else
+          @take ||= limit(1).records.first
         end
+      end
 
-        def find_nth(index)
-          @offsets[offset_index + index] ||= find_nth_with_limit(index, 1).first
+      def find_take_with_limit(limit)
+        if loaded?
+          records.take(limit)
+        else
+          limit(limit).to_a
         end
+      end
+
+      def find_nth(index)
+        @offsets[offset_index + index] ||= find_nth_with_limit(index, 1).first
+      end
 
-        def find_nth_with_limit(index, limit)
-          if loaded?
-            records[index, limit] || []
+      def find_nth_with_limit(index, limit)
+        if loaded?
+          records[index, limit] || []
+        else
+          relation = if order_values.empty? && primary_key
+            order(arel_attribute(primary_key).asc)
           else
-            relation = if order_values.empty? && primary_key
-              order(arel_attribute(primary_key).asc)
-            else
-              self
-            end
+            self
+          end
 
+          if limit_value.nil? || index < limit_value
             relation = relation.offset(offset_index + index) unless index.zero?
             relation.limit(limit).to_a
+          else
+            []
           end
         end
+      end
 
-        def find_nth_from_last(index)
-          if loaded?
-            records[-index]
+      def find_nth_from_last(index)
+        if loaded?
+          records[-index]
+        else
+          relation = if order_values.empty? && primary_key
+            order(arel_attribute(primary_key).asc)
           else
-            relation = if order_values.empty? && primary_key
-              order(arel_attribute(primary_key).asc)
-            else
-              self
-            end
-
-            relation.to_a[-index]
-            # TODO: can be made more performant on large result sets by
-            # for instance, last(index)[-index] (which would require
-            # refactoring the last(n) finder method to make test suite pass),
-            # or by using a combination of reverse_order, limit, and offset,
-            # e.g., reverse_order.offset(index-1).first
+            self
           end
-        end
 
-        def find_last(limit)
-          limit ? records.last(limit) : records.last
+          relation.to_a[-index]
+          # TODO: can be made more performant on large result sets by
+          # for instance, last(index)[-index] (which would require
+          # refactoring the last(n) finder method to make test suite pass),
+          # or by using a combination of reverse_order, limit, and offset,
+          # e.g., reverse_order.offset(index-1).first
         end
+      end
+
+      def find_last(limit)
+        limit ? records.last(limit) : records.last
+      end
   end
 end

data/lib/active_record/relation/query_methods.rb

@@ -1130,7 +1130,12 @@ module ActiveRecord
             arel_attribute(arg).asc
           when Hash
             arg.map { |field, dir|
-              arel_attribute(field).send(dir.downcase)
+              case field
+              when Arel::Nodes::SqlLiteral
+                field.send(dir.downcase)
+              else
+                arel_attribute(field).send(dir.downcase)
+              end
             }
           else
             arg

data/lib/active_record/result.rb

@@ -41,10 +41,15 @@ module ActiveRecord
       @column_types = column_types
     end
 
+    # Returns the number of elements in the rows array.
     def length
       @rows.length
     end
 
+    # Calls the given block once for each element in row collection, passing
+    # row as parameter.
+    #
+    # Returns an +Enumerator+ if no block is given.
     def each
       if block_given?
         hash_rows.each { |row| yield row }
@@ -53,6 +58,7 @@ module ActiveRecord
       end
     end
 
+    # Returns an array of hashes representing each row record.
     def to_hash
       hash_rows
     end
@@ -60,11 +66,12 @@ module ActiveRecord
     alias :map! :map
     alias :collect! :map
 
-    # Returns true if there are no records.
+    # Returns true if there are no records, otherwise false.
     def empty?
       rows.empty?
     end
 
+    # Returns an array of hashes representing each row record.
     def to_ary
       hash_rows
     end
@@ -73,11 +80,15 @@ module ActiveRecord
       hash_rows[idx]
     end
 
+    # Returns the first record from the rows collection.
+    # If the rows collection is empty, returns +nil+.
     def first
       return nil if @rows.empty?
       Hash[@columns.zip(@rows.first)]
     end
 
+    # Returns the last record from the rows collection.
+    # If the rows collection is empty, returns +nil+.
     def last
       return nil if @rows.empty?
       Hash[@columns.zip(@rows.last)]

data/lib/active_record/sanitization.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   module Sanitization
     extend ActiveSupport::Concern
@@ -207,9 +206,9 @@ module ActiveRecord
         end
     end
 
-    # TODO: Deprecate this
     def quoted_id # :nodoc:
       self.class.connection.quote(@attributes[self.class.primary_key].value_for_database)
     end
+    deprecate :quoted_id
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -85,7 +85,7 @@ HEADER
       end
 
       def tables(stream)
-        sorted_tables = @connection.data_sources.sort - @connection.views
+        sorted_tables = @connection.tables.sort
 
         sorted_tables.each do |table_name|
           table(table_name, stream) unless ignored?(table_name)

data/lib/active_record/schema_migration.rb

@@ -39,7 +39,11 @@ module ActiveRecord
       end
 
       def normalized_versions
-        pluck(:version).map { |v| normalize_migration_number v }
+        all_versions.map { |v| normalize_migration_number v }
+      end
+
+      def all_versions
+        order(:version).pluck(:version)
       end
     end
 

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -1,8 +1,11 @@
+require "tempfile"
+
 module ActiveRecord
   module Tasks # :nodoc:
     class PostgreSQLDatabaseTasks # :nodoc:
       DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
       ON_ERROR_STOP_1 = "ON_ERROR_STOP=1".freeze
+      SQL_COMMENT_BEGIN = "--".freeze
 
       delegate :connection, :establish_connection, :clear_active_connections!,
         to: ActiveRecord::Base
@@ -65,6 +68,7 @@ module ActiveRecord
         end
         args << configuration["database"]
         run_cmd("pg_dump", args, "dumping")
+        remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
@@ -110,6 +114,22 @@ module ActiveRecord
           msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
           msg
         end
+
+        def remove_sql_header_comments(filename)
+          removing_comments = true
+          tempfile = Tempfile.open("uncommented_structure.sql")
+          begin
+            File.foreach(filename) do |line|
+              unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
+                tempfile << line
+                removing_comments = false
+              end
+            end
+          ensure
+            tempfile.close
+          end
+          FileUtils.mv(tempfile.path, filename)
+        end
     end
   end
 end