activerecord-virtual_attributes 1.5.0 → 6.1.0

data/lib/active_record/virtual_attributes/virtual_fields.rb

@@ -101,186 +101,76 @@ module ActiveRecord
   module Associations
     class Preloader
       prepend(Module.new {
-        if ActiveRecord.version.to_s >= "6.0"
-          def preloaders_for_reflection(reflection, records, scope, polymorphic_parent)
-            case reflection
-            when Array
-              reflection.flat_map { |ref| preloaders_on(ref, records, scope, polymorphic_parent) }
-            when Hash
-              preloaders_on(reflection, records, scope, polymorphic_parent)
-            else
-              super(reflection, records, scope)
-            end
-          end
-
-          # rubocop:disable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
-          # preloader.rb active record 6.0
-          # changed:
-          # since grouped_records can return a hash/array, we need to handle those 2 new cases
-          def preloaders_for_hash(association, records, scope, polymorphic_parent)
-            association.flat_map { |parent, child|
-              grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
-                loaders = preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
-                recs = loaders.flat_map(&:preloaded_records).uniq
-                child_polymorphic_parent = reflection && reflection.respond_to?(:options) && reflection.options[:polymorphic]
-                loaders.concat Array.wrap(child).flat_map { |assoc|
-                  preloaders_on assoc, recs, scope, child_polymorphic_parent
-                }
-                loaders
-              end
-            }
-          end
-
-          # preloader.rb active record 6.0
-          # changed:
-          # since grouped_records can return a hash/array, we need to handle those 2 new cases
-          def preloaders_for_one(association, records, scope, polymorphic_parent)
-            grouped_records(association, records, polymorphic_parent)
-              .flat_map do |reflection, reflection_records|
-                preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
-              end
+        # preloader.rb active record 6.0
+        # changed:
+        # since grouped_records can return a hash/array, we need to handle those 2 new cases
+        def preloaders_for_reflection(reflection, records, scope, polymorphic_parent)
+          case reflection
+          when Array
+            reflection.flat_map { |ref| preloaders_on(ref, records, scope, polymorphic_parent) }
+          when Hash
+            preloaders_on(reflection, records, scope, polymorphic_parent)
+          else
+            super(reflection, records, scope)
           end
+        end
 
-          # preloader.rb active record 6.0
-          # changed:
-          def grouped_records(orig_association, records, polymorphic_parent)
-            h = {}
-            records.each do |record|
-              # each class can resolve virtual_{attributes,includes} differently
-              association = record.class.replace_virtual_fields(orig_association)
-              # 1 line optimization for single element array:
-              association = association.first if association.kind_of?(Array) && association.size == 1
-
-              case association
-              when Symbol, String
-                reflection = record.class._reflect_on_association(association)
-                next if polymorphic_parent && !reflection || !record.association(association).klass
-              when nil
-                next
-              else # need parent (preloaders_for_{hash,one}) to handle this Array/Hash
-                reflection = association
-              end
-              (h[reflection] ||= []) << record
+        # rubocop:disable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
+        # preloader.rb active record 6.0
+        # changed:
+        # passing polymorphic around (and makes 5.2 more similar to 6.0)
+        def preloaders_for_hash(association, records, scope, polymorphic_parent)
+          association.flat_map { |parent, child|
+            grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
+              loaders = preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
+              recs = loaders.flat_map(&:preloaded_records).uniq
+              child_polymorphic_parent = reflection && reflection.respond_to?(:options) && reflection.options[:polymorphic]
+              loaders.concat Array.wrap(child).flat_map { |assoc|
+                preloaders_on assoc, recs, scope, child_polymorphic_parent
+              }
+              loaders
             end
-            h
-          end
-          # rubocop:enable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
-        else
-          def preloaders_for_one(association, records, scope)
-            klass_map = records.compact.group_by(&:class)
+          }
+        end
 
-            # new logic: preload virtual fields / virtual includes
-            loaders = klass_map.keys.group_by { |klass| klass.virtual_includes(association) }.flat_map do |virtuals, klasses|
-              subset = klasses.flat_map { |klass| klass_map[klass] }
-              preload(subset, virtuals)
+        # preloader.rb active record 6.0
+        # changed:
+        # passing polymorphic_parent to preloaders_for_reflection
+        def preloaders_for_one(association, records, scope, polymorphic_parent)
+          grouped_records(association, records, polymorphic_parent)
+            .flat_map do |reflection, reflection_records|
+              preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
             end
-            # /new logic
+        end
 
-            records_with_association = klass_map.select { |k, _rs| k.reflect_on_association(association) }.flat_map { |_k, rs| rs }
-            if records_with_association.any?
-              loaders.concat(super(association, records_with_association, scope))
+        # preloader.rb active record 6.0, 6.1
+        def grouped_records(orig_association, records, polymorphic_parent)
+          h = {}
+          records.each do |record|
+            # The virtual_field lookup can return Symbol/Nil/Other (typically a Hash)
+            #   so the case statement and the cases for Nil/Other are new
+
+            # each class can resolve virtual_{attributes,includes} differently
+            association = record.class.replace_virtual_fields(orig_association)
+            # 1 line optimization for single element array:
+            association = association.first if association.kind_of?(Array) && association.size == 1
+
+            case association
+            when Symbol, String
+              reflection = record.class._reflect_on_association(association)
+              next if polymorphic_parent && !reflection || !record.association(association).klass
+            when nil
+              next
+            else # need parent (preloaders_for_{hash,one}) to handle this Array/Hash
+              reflection = association
             end
-
-            loaders
+            (h[reflection] ||= []) << record
           end
+          h
         end
+        # rubocop:enable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
       })
     end
-
-    # FIXME: Hopefully we can get this into Rails core so this is no longer
-    # required in our codebase, but the rule that are broken here are mostly
-    # due to the style of the Rails codebase conflicting with our own.
-    # Ignoring them to avoid noise in RuboCop, but allow us to keep the same
-    # syntax from the original codebase.
-    #
-    # rubocop:disable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
-    # rubocop:disable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
-    class JoinDependency
-      def instantiate(result_set, *_, &block)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases(join_root)
-
-        # New Code
-        #
-        # This monkey patches the ActiveRecord::Associations::JoinDependency to
-        # include columns into the main record that might have been added
-        # through a `select` clause.
-        #
-        # This can be seen with the following:
-        #
-        #   Vm.select(Vm.arel_table[Arel.star]).select(:some_vm_virtual_col)
-        #     .includes(:tags => {}).references(:tags)
-        #
-        # Which will produce a SQL SELECT statement kind of like this:
-        #
-        #   SELECT "vms".*,
-        #          (<virtual_attribute_arel>) AS some_vm_virtual_col,
-        #          "vms"."id"      AS t0_r0
-        #          "vms"."vendor"  AS t0_r1
-        #          "vms"."format"  AS t0_r1
-        #          "vms"."version" AS t0_r1
-        #          ...
-        #          "tags"."id"     AS t1_r0
-        #          "tags"."name"   AS t1_r1
-        #
-        # This is because rails is trying to reduce the number of queries
-        # needed to fetch all of the records in the include, so it grabs the
-        # columns for both of the tables together to do it.  Unfortuantely (or
-        # fortunately... depending on how you look at it), it does not remove
-        # any `.select` columns from the query that is run in the process, so
-        # that is brought along for the ride, but never used when this method
-        # instanciates the objects.
-        #
-        # The "New Code" here simply also instanciates any extra rows that
-        # might have been included in the select (virtual_columns) as well and
-        # brought back with the result set.
-        unless result_set.empty?
-          join_dep_keys         = aliases.columns.map(&:right)
-          join_root_aliases     = column_aliases.map(&:first)
-          additional_attributes = result_set.first.keys
-                                            .reject { |k| join_dep_keys.include?(k) }
-                                            .reject { |k| join_root_aliases.include?(k) }
-          column_aliases += if ActiveRecord.version.to_s >= "6.0"
-                              additional_attributes.map { |k| Aliases::Column.new(k, k) }
-                            else
-                              additional_attributes.map { |k| [k, k] }
-                            end
-        end
-        # End of New Code
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-          record_count: result_set.length,
-          class_name: join_root.base_klass.name
-        }
-
-        message_bus.instrument('instantiation.active_record', payload) do
-          result_set.each { |row_hash|
-            parent_key = primary_key ? row_hash[primary_key] : row_hash
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            if ActiveRecord.version.to_s < "6.0"
-              construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
-            else
-              construct(parent, join_root, row_hash, seen, model_cache)
-            end
-          }
-        end
-
-        parents.values
-      end
-      # rubocop:enable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
-      # rubocop:enable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
-    end
   end
 
   class Relation
@@ -295,99 +185,50 @@ module ActiveRecord
 
     include(Module.new {
       # From ActiveRecord::FinderMethods
-      if ActiveRecord.version.to_s >= "5.2"
-        def apply_join_dependency(*args, &block)
-          real = without_virtual_includes
-          if real.equal?(self)
-            super
-          else
-            real.apply_join_dependency(*args, &block)
-          end
-        end
-      else
-        def find_with_associations(&block)
-          real = without_virtual_includes
-          if real.equal?(self)
-            super
-          else
-            real.find_with_associations(&block)
-          end
+      def apply_join_dependency(*args, **kargs, &block)
+        real = without_virtual_includes
+        if real.equal?(self)
+          super
+        else
+          real.apply_join_dependency(*args, **kargs, &block)
         end
       end
 
-      # From ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      # From ActiveRecord::QueryMethods (rails 5.2 - 6.1)
       def build_select(arel)
         if select_values.any?
-          arel.project(*arel_columns(select_values.uniq, true))
-        elsif klass.ignored_columns.any?
-          arel.project(*klass.column_names.map { |field| arel_attribute(field) })
-        else
-          arel.project(table[Arel.star])
-        end
-      end
-
-      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
-      def arel_columns(columns, allow_alias = false)
-        columns.flat_map do |field|
-          case field
-          when Symbol
-            arel_column(field.to_s, allow_alias) do |attr_name|
-              connection.quote_table_name(attr_name)
+          cols = arel_columns(select_values.uniq).map do |col|
+            # if it is a virtual attribute, then add aliases to those columns
+            if col.kind_of?(Arel::Nodes::Grouping) && col.name
+              col.as(connection.quote_column_name(col.name))
+            else
+              col
             end
-          when String
-            arel_column(field, allow_alias, &:itself)
-          when Proc
-            field.call
-          else
-            field
           end
-        end
-      end
-
-      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
-      def arel_column(field, allow_alias = false, &block)
-        field = klass.attribute_aliases[field] || field
-        from = from_clause.name || from_clause.value
-
-        if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
-          arel_attribute(field)
-        elsif virtual_attribute?(field)
-          virtual_attribute_arel_column(field, allow_alias, &block)
+          arel.project(*cols)
         else
-          yield field
+          super
         end
       end
 
-      def virtual_attribute_arel_column(field, allow_alias)
-        arel = arel_attribute(field)
-        if arel.nil?
-          yield field
-        elsif allow_alias && arel && arel.respond_to?(:as) && !arel.kind_of?(Arel::Nodes::As) && !arel.try(:alias)
-          arel.as(connection.quote_column_name(field.to_s))
-        else
+      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      # TODO: remove from rails 7.0
+      def arel_column(field, &block)
+        if virtual_attribute?(field) && (arel = table[field])
           arel
+        else
+          super
         end
       end
 
-      # From ActiveRecord::QueryMethods
-      def table_name_matches?(from)
-        /(?:\A|(?<!FROM)\s)(?:\b#{table.name}\b|#{connection.quote_table_name(table.name)})(?!\.)/i.match?(from.to_s)
-      end
-
-      # From ActiveRecord::QueryMethods
-      def build_left_outer_joins(manager, outer_joins, *rest)
-        outer_joins = klass.replace_virtual_fields(outer_joins)
-        super if outer_joins.present?
+      def construct_join_dependency(associations, join_type) # :nodoc:
+        associations = klass.replace_virtual_fields(associations)
+        super
       end
 
       # From ActiveRecord::Calculations
+      # introduces virtual includes support for calculate (we mostly use COUNT(*))
       def calculate(operation, attribute_name)
-        if ActiveRecord.version.to_s < "5.1"
-          if (arel = klass.arel_attribute(attribute_name)) && virtual_attribute?(attribute_name)
-            attribute_name = arel
-          end
-        end
-
         # allow calculate to work with includes and a virtual attribute
         real = without_virtual_includes
         return super if real.equal?(self)

data/lib/active_record/virtual_attributes/virtual_total.rb

@@ -5,7 +5,7 @@ module VirtualAttributes
     module ClassMethods
       private
 
-      # define an attribute to calculating the total of a has many relationship
+      # define an attribute to calculate the total of a has many relationship
       #
       #  example:
       #
@@ -25,24 +25,45 @@ module VirtualAttributes
       #   # arel == (SELECT COUNT(*) FROM vms where ems.id = vms.ems_id)
       #
       def virtual_total(name, relation, options = {})
-        define_virtual_size_method(name, relation)
         define_virtual_aggregate_attribute(name, relation, :count, Arel.star, options)
+        define_method(name) { (has_attribute?(name) ? self[name] : send(relation).try(:size)) || 0 }
       end
 
-      # define an attribute to calculate the sum of a has may relationship
+      def virtual_sum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :sum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :sum)
+      end
+
+      def virtual_minimum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :minimum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :min, :minimum)
+      end
+
+      def virtual_maximum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :maximum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :max, :maximum)
+      end
+
+      def virtual_average(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :average, column, options)
+        define_virtual_aggregate_method(name, relation, column, :average) { |values| values.count == 0 ? 0 : values.sum / values.count }
+      end
+
+      #  @param method_name
+      #    :count :average :minimum :maximum :sum
       #
       #  example:
       #
       #    class Hardware
       #      has_many :disks
-      #      virtual_aggregate :allocated_disk_storage, :disks, :sum, :size
+      #      virtual_sum :allocated_disk_storage, :disks, :size
       #    end
       #
       #    generates:
       #
       #    def allocated_disk_storage
       #      if disks.loaded?
-      #        disks.blank? ? nil : disks.map(&:size).compact.sum
+      #        disks.map(&:size).compact.sum
       #      else
       #        disks.sum(:size) || 0
       #      end
@@ -53,10 +74,8 @@ module VirtualAttributes
       #    # arel => (SELECT sum("disks"."size") where "hardware"."id" = "disks"."hardware_id")
 
       def virtual_aggregate(name, relation, method_name = :sum, column = nil, options = {})
-        return define_virtual_total(name, relation, options) if method_name == :size
-
-        define_virtual_aggregate_method(name, relation, method_name, column)
-        define_virtual_aggregate_attribute(name, relation, method_name, column, options)
+        return virtual_total(name, relation, options) if method_name == :size
+        return virtual_sum(name, relation, column, options) if method_name == :sum
       end
 
       def define_virtual_aggregate_attribute(name, relation, method_name, column, options)
@@ -77,20 +96,19 @@ module VirtualAttributes
         end
       end
 
-      def define_virtual_size_method(name, relation)
-        define_method(name) do
-          (has_attribute?(name) ? self[name] : send(relation).try(:size)) || 0
-        end
-      end
-
-      def define_virtual_aggregate_method(name, relation, method_name, column)
+      def define_virtual_aggregate_method(name, relation, column, ruby_method_name, arel_method_name = ruby_method_name)
         define_method(name) do
-          if attribute_present?(name)
-            self[name]
+          if has_attribute?(name)
+            self[name] || 0
           elsif (rel = send(relation)).loaded?
-            rel.blank? ? nil : rel.map { |t| t.send(column) }.compact.send(method_name)
+            values = rel.map { |t| t.send(column) }.compact
+            if block_given?
+              yield values
+            else
+              values.blank? ? nil : values.send(ruby_method_name)
+            end
           else
-            rel.try(method_name, column) || 0
+            rel.try(arel_method_name, column) || 0
           end
         end
       end
@@ -101,7 +119,7 @@ module VirtualAttributes
         # need db access for the reflection join_keys, so delaying all this key lookup until call time
         lambda do |t|
           # strings and symbols are converted across, arel objects are not
-          column = reflection.klass.arel_attribute(column) unless column.respond_to?(:count)
+          column = reflection.klass.arel_table[column] unless column.respond_to?(:count)
 
           # query: SELECT COUNT(*) FROM main_table JOIN foreign_table ON main_table.id = foreign_table.id JOIN ...
           relation_query   = joins(reflection.name).select(column.send(method_name))
@@ -121,18 +139,16 @@ module VirtualAttributes
 
           # convert bind variables from ? to actual values. otherwise, sql is incomplete
           conn = connection
-          sql  = if ActiveRecord.version.to_s >= "5.2"
-                   conn.unprepared_statement { conn.to_sql(query) }
-                 else
-                   conn.unprepared_statement { conn.to_sql(query, relation_query.bound_attributes) }
-                 end
+          sql = conn.unprepared_statement { conn.to_sql(query) }
 
           # add () around query
-          t.grouping(Arel::Nodes::SqlLiteral.new(sql))
+          query = t.grouping(Arel::Nodes::SqlLiteral.new(sql))
+          # add coalesce to ensure correct value comes out
+          t.grouping(Arel::Nodes::NamedFunction.new('COALESCE', [query, Arel::Nodes::SqlLiteral.new("0")]))
         end
       end
     end
   end
 end
 
-ActiveRecord::Base.send(:include, VirtualAttributes::VirtualTotal)
+ActiveRecord::Base.include VirtualAttributes::VirtualTotal

data/lib/active_record/virtual_attributes.rb

@@ -48,13 +48,9 @@ module ActiveRecord
       #
 
       # Compatibility method: `virtual_attribute` is a more accurate name
-      def virtual_column(name, type_or_options, **options)
-        if type_or_options.kind_of?(Hash)
-          options = options.merge(type_or_options)
-          type = options.delete(:type)
-        else
-          type = type_or_options
-        end
+      def virtual_column(name, **options)
+        type = options.delete(:type)
+        raise ArgumentError, "missing :type attribute" unless type
 
         virtual_attribute(name, type, **options)
       end
@@ -90,14 +86,7 @@ module ActiveRecord
       def attributes_builder # :nodoc:
         unless defined?(@attributes_builder) && @attributes_builder
           defaults = _default_attributes.except(*(column_names - [primary_key]))
-          # change necessary for rails 5.0 and 5.1 - (changed/introduced in https://github.com/rails/rails/pull/31894)
-          defaults = defaults.except(*virtual_attribute_names)
-          # end change
-          @attributes_builder = if ActiveRecord.version.to_s >= "5.2"
-                                  ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
-                                else
-                                  ActiveRecord::AttributeSet::Builder.new(attribute_types, defaults)
-                                end
+          @attributes_builder = ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
         end
         @attributes_builder
       end
@@ -134,22 +123,7 @@ require "active_record/virtual_attributes/virtual_fields"
 # Class extensions
 #
 
-# this patch is no longer necessary for 5.2
-if ActiveRecord.version.to_s < "5.2"
-  require "active_record/attribute"
-  module ActiveRecord
-    # This is a bug in rails 5.0 and 5.1, but it is made much worse by virtual attributes
-    class Attribute
-      def with_value_from_database(value)
-        # self.class.from_database(name, value, type)
-        initialized? ? self.class.from_database(name, value, type) : self
-      end
-    end
-  end
-end
-
 require "active_record/virtual_attributes/virtual_total"
-require "active_record/virtual_attributes/arel_groups"
 
 # legacy support for sql types
 module VirtualAttributes