through_hierarchy 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ff191d3b67d67e1cdf99ba283b12873aa36624a
-  data.tar.gz: 879a24e56dec39d507381d20a57b89080d09453c
+  metadata.gz: 24802dbaa712d4bce228409d6559bd95e8d07088
+  data.tar.gz: 94bc36b57d75022bcd256dae8edfd4710652aedf
 SHA512:
-  metadata.gz: 8f0e6ed2807d23ebbb68813605bd34314ddba1c5a920e6c9d8d9684d2ff9eb529d5236698b439afc9430ef1ca8dd8f1144c10c9a8fc0add31c28bb48c9eb1cc3
-  data.tar.gz: 6397865dcf63f039c3ade88eb8ce90bbbf8ba639480872a8f54f59fea59d43d9edfce07357da808b61407a0cb87fdd80cf39d6a476144caa2c3a44fdfa0cb066
+  metadata.gz: af92986a50caae9db2e72c5fd5e2999ed13130faef98e66fe63c97ae6281673b095a82e2a3012909bb94beabe677cd89e7e6aa518272a82554efb5fa9f77c312
+  data.tar.gz: efac0a679e68aae89833613b84cd1b4f636e8de80c1ef9546dc7c87386f1bd0d64516eea522936709289ea73737abe45c206788ee883c372402956ea78c22d6e

data/lib/through_hierarchy/associations/association.rb

@@ -5,34 +5,23 @@ module ThroughHierarchy
         @name = name
         @model = model
         @members = members
-        @as = options[:as].to_s
-        @scope = options[:scope]
-        @foreign_class_name = options[:class_name] || @name.to_s.classify
-        @uniq = options[:uniq]
 
+        set_options(options)
         validate_options
+
+        @associated = Hierarchicals::Hierarchical.new(foreign_arel_table, model, members, as: @polymorphic_name)
       end
 
       def find(instance)
-        return uniq_find(instance) if @uniq.present?
-
-        results = foreign_class.where(arel_instance_filters(instance))
+        results = get_matches(instance)
         results = results.instance_exec(&@scope) if @scope.present?
         return results
       end
 
-      def joins
-        # TODO: make this work
-        # joins = @model.arel_table.join(foreign_arel_table).on(arel_model_filters)
-
-        # joins = joins.join(arel_uniq_subquery).on(
-        #   arel_hierarchy_rank.eq(uniq_subquery_arel_table[best_hierarchy_match_name]).
-        #   and(foreign_arel_table[@uniq].eq(uniq_subquery_arel_table[@uniq]))
-        # ) if @uniq.present?
-
-        # results = @model.joins(joins.join_sources)
-        # results = results.merge(foreign_class.instance_exec(&@scope)) if @scope.present?
-        # return results
+      def join
+        results = get_joins
+        results = results.merge(foreign_class.instance_exec(&@scope)) if @scope.present?
+        return results
       end
 
       def create(member, attributes)
@@ -41,132 +30,43 @@ module ThroughHierarchy
 
       private
 
+      def set_options(options)
+        @polymorphic_name = options[:as].to_s
+        @scope = options[:scope]
+        @foreign_class_name = options[:class_name] || @name.to_s.classify
+      end
+
       def validate_options
-        @as.present? or raise ThroughHierarchyDefinitionError, "Must provide polymorphic `:as` options for through_hierarchy"
+        @polymorphic_name.present? or raise ThroughHierarchyDefinitionError, "Must provide polymorphic `:as` options for through_hierarchy"
         @model.is_a?(Class) or raise ThroughHierarchyDefinitionError, "Expected: class, got: #{@model.class}"
         @model < ActiveRecord::Base or raise ThroughHierarchyDefinitionError, "Expected: ActiveRecord::Base descendant, got: #{@model}"
         @scope.blank? || @scope.is_a?(Proc) or raise ThroughHierarchyDefinitionError, "Expected scope to be a Proc, got #{@scope.class}"
       end
 
-      def foreign_class
-        @foreign_class_name.constantize
-      end
-
-      def foreign_arel_table
-        foreign_class.arel_table
-      end
-
-      def sql_hierarchy_rank
-        "CASE `#{foreign_class.table_name}`.`#{foreign_type_field}` " +
-          hierarchy_models.map.with_index{|m, ii| "WHEN #{@model.sanitize(model_type_constraint(m))} THEN #{ii} "}.join +
-          "END"
-      end
-
-      def arel_hierarchy_rank
-        Arel.sql(sql_hierarchy_rank)
-      end
-
-      # TODO: generate this dynamically based on existing columns and selects
-      def best_hierarchy_match_name
-        "through_hierarchy_match"
-      end
-
-      def arel_best_hierarchy_member
-        arel_hierarchy_rank.minimum.as(best_hierarchy_match_name)
-      end
-
-      # TODO: for model level joins, subquery needs to join to all hierarchy tables
-      def arel_uniq_subquery(instance = nil)
-        foreign_arel_table.
-          project(foreign_arel_table[Arel.star], arel_best_hierarchy_member).
-          where(instance.present? ? arel_instance_filters(instance) : arel_model_filters).
-          group(foreign_arel_table[@uniq]).
-          as(uniq_subquery_alias)
-      end
-
-      def uniq_subquery_alias
-        "through_hierarchy_subtable"
-      end
-
-      def uniq_subquery_arel_table
-        Arel::Table.new(uniq_subquery_alias)
-      end
-
-      # TODO: build join sources for model-level query
-      def uniq_subquery_join_sources(instance = nil)
-        foreign_arel_table.
-          join(arel_uniq_subquery(instance)).
-          on(
-            arel_hierarchy_rank.eq(uniq_subquery_arel_table[best_hierarchy_match_name]).
-            and(foreign_arel_table[@uniq].eq(uniq_subquery_arel_table[@uniq]))
-          ).join_sources
-      end
-
-      def uniq_find(instance)
-        join_sources = uniq_subquery_join_sources(instance)
-
-        return foreign_class.
-          joins(uniq_subquery_join_sources(instance)).
-          where(arel_instance_filters(instance)).
-          order(foreign_arel_table[@uniq])
-      end
-
-      def hierarchy_models
-        [@model] + @members.map{|m| @model.reflect_on_association(m).klass}
-      end
-
-      def hierarchy_instances(instance)
-        [instance] + @members.map{|m| instance.association(m).load_target}
-      end
-
-      def foreign_key_field
-        @as.foreign_key
-      end
-
-      def foreign_type_field
-        @as + "_type"
-      end
-
-      def arel_foreign_key_field
-        foreign_arel_table[foreign_key_field]
-      end
-
-      def arel_foreign_type_field
-        foreign_arel_table[foreign_type_field]
-      end
-
-      def arel_model_filters
-        hierarchy_models.map{|model| arel_model_filter(model)}.reduce{|q, cond| q.or(cond)}
-      end
-
-      def arel_instance_filters(instance)
-        hierarchy_instances(instance).map{|instance| arel_instance_filter(instance)}.reduce{|q, cond| q.or(cond)}
+      def associated_instance(instance)
+        @associated.with_instance(instance)
       end
 
-      def arel_model_filter(model)
-        arel_foreign_type_field.eq(model_type_constraint(model)).
-          and(arel_foreign_key_field.eq(model_key_constraint(model)))        
+      def get_matches(instance)
+        return foreign_class.where(associated_instance(instance).filters)
       end
 
-      def arel_instance_filter(instance)
-        arel_foreign_type_field.eq(instance_type_constraint(instance)).
-          and(arel_foreign_key_field.eq(instance_key_constraint(instance)))
+      # TODO: we might generate fewer join sources if we figure out which members
+      # are :through associations. Currently those generate redundant joins.
+      def get_joins
+        join_sources = @model.arel_table.
+          join(@associated.source).
+          on(@associated.filters).
+          join_sources
+        return @model.joins(@members + join_sources)
       end
 
-      def instance_type_constraint(resource)
-        resource.class.base_class.to_s
-      end
-
-      def instance_key_constraint(resource)
-        resource.attributes[resource.class.primary_key]
-      end
-
-      def model_type_constraint(model_class)
-        model_class.base_class.to_s
+      def foreign_class
+        @foreign_class_name.constantize
       end
 
-      def model_key_constraint(model_class)
-        model_class.arel_table[model_class.primary_key]
+      def foreign_arel_table
+        foreign_class.arel_table
       end
     end
   end

data/lib/through_hierarchy/associations/has_one.rb

@@ -2,9 +2,20 @@ module ThroughHierarchy
   module Associations
     class HasOne < Association
       def find(instance)
-        q = super
-        q.reorder(sql_hierarchy_rank).order(q.order_values).first
+        matches = super
+        # ensure we order by hierarchy rank, but preserve scope orders
+        matches.reorder(@associated.hierarchy_rank).order(matches.orders).first
       end
+
+      private
+
+      def get_joins
+        arel = @associated.join_best_rank
+        result = @model.joins(arel.join_sources).order(arel.orders)
+        arel.constraints.each{|cc| result = result.where(cc)}
+        return result
+      end
+
     end
   end
 end

data/lib/through_hierarchy/associations/has_uniq.rb

@@ -0,0 +1,33 @@
+module ThroughHierarchy
+  module Associations
+    class HasUniq < Association
+      private
+
+      def set_options(options)
+        super
+        @uniq = options[:uniq]
+      end
+
+      # Use subquery method to select best hierarchy match for each @uniq
+      # Order by @uniq can result in better performance than default order (id)
+      def get_matches(instance)
+        associated_instance = @associated.with_instance(instance)
+        arel = @associated.with_instance(instance).select_best_rank(group_by: @uniq)
+        result = foreign_class.
+          where(associated_instance.filters).
+          joins(arel.join_sources).
+          order(arel.orders)
+        arel.constraints.each{|cc| result = result.where(cc)}
+        return result
+      end
+
+      def get_joins
+        arel = @associated.join_best_rank(group_by: @uniq)
+        result = @model.joins(arel.join_sources).order(arel.orders)
+        arel.constraints.each{|cc| result = result.where(cc)}
+        return result
+      end
+
+    end
+  end
+end

data/lib/through_hierarchy/base.rb

@@ -17,6 +17,13 @@ module ThroughHierarchy
       def through_hierarchy(members, &blk)
         Hierarchy.new(self, members).instance_eval(&blk)
       end
+
+      def joins_through_hierarchy(name)
+        hierarchical_associations.key?(name) or raise ThroughHierarchyAssociationMissingError, "No association named #{name} was found. Perhaps you misspelled it?"
+        hierarchical_associations[name].join
+      end
+
+      # TODO: create_through_hierarchy(member = self, attributes)
     end
   end
 end

data/lib/through_hierarchy/builder.rb

@@ -18,11 +18,6 @@ module ThroughHierarchy
           return @hierarchical_association_cache[name] if !reload && @hierarchical_association_cache.key?(name)
           @hierarchical_association_cache[name] = self.hierarchical_associations[name].find(self)
         end
-
-        # TODO: join_through_hierarchy
-
-        # TODO: create_from_hierarchy(member, attributes)
-        
       end
     end
   end

data/lib/through_hierarchy/exceptions.rb

@@ -4,4 +4,13 @@ module ThroughHierarchy
 
   class ThroughHierarchyDefinitionError < ThroughHierarchyError
   end
-end
+
+  class ThroughHierarchyAssociationMissingError < ThroughHierarchyError
+  end
+
+  class ThroughHierarchySourceError < ThroughHierarchyError
+  end
+
+  class ThroughHierarchyInstanceError < ThroughHierarchyError
+  end
+end

data/lib/through_hierarchy/hierarchicals/hierarchical.rb

@@ -0,0 +1,157 @@
+module ThroughHierarchy
+  module Hierarchicals
+    class Hierarchical
+      attr_reader :source
+
+      # source should be an Arel::Table or Arel::TableAlias
+      # TODO: parent only on derived tables. Make that a separate class or module.
+      def initialize(source, target, hierarchy, as:, parent: nil)
+        @source = source
+        set_target(target)
+        @hierarchy = hierarchy
+        @polymorphic_name = as.to_s
+        @parent = parent
+      end
+
+      def set_target(target)
+        @target = target
+        @model = @target
+      end
+
+      # Initialize a new copy of self bound to a specific instance
+      def with_instance(instance)
+        instance.is_a?(@model) or raise ThroughHierarchyInstanceError, "#{instance} is not an instance of #{@model}"
+        Instance.new(@source, instance, @hierarchy, as: @polymorphic_name)
+      end
+
+      # Intialize a copy of self with a new / derived source table
+      def spawn(source)
+        return self.class.new(source, @target, @hierarchy, as: @polymorphic_name, parent: self)
+      end
+
+      def hierarchy_models
+        [@model] + @hierarchy.map{|m| @model.reflect_on_association(m).klass}
+      end
+
+      # TODO: some of these may be :through others, so this may generate redundant joins
+      def hierarchy_joins
+        @hierarchy
+      end
+
+      def and_conditions(conditions)
+        conditions.reduce{|q, cond| q.and(cond)}
+      end
+
+      def or_conditions(conditions)
+        conditions.reduce{|q, cond| q.or(cond)}
+      end
+
+      def filters
+        or_conditions(hierarchy_models.map{|model| filter(model)})
+      end
+
+      def filter(model)
+        foreign_type_column.eq(model_type(model)).
+          and(foreign_key_column.eq(model_key(model)))
+      end
+
+      # Sort order for hierarchy shadowing queries
+      def hierarchy_rank
+        Arel.sql(
+          "CASE `#{@source.name}`.`#{foreign_type_name}` " +
+          hierarchy_models.map.with_index do |model, ii|
+            "WHEN #{model.sanitize(model.base_class.to_s)} THEN #{ii} "
+          end.join +
+          "END"
+        )
+      end
+
+      def foreign_key_name
+        @polymorphic_name.foreign_key
+      end
+
+      def foreign_type_name
+        @polymorphic_name + "_type"
+      end
+
+      def foreign_key_column
+        @source[foreign_key_name]
+      end
+
+      def foreign_type_column
+        @source[foreign_type_name]
+      end
+
+      def model_type(model)
+        model.base_class.to_s
+      end
+
+      def model_key(model)
+        model.arel_table[model.primary_key]
+      end
+
+      # Join @model to @source only on best hierarchy matches
+      ### FASTER METHOD: join source to source alias on source.rank < alias.rank where alias does not exist
+      # This performs OK.
+      def join_best_rank(group_by: nil)
+        better_rank = spawn(@source.alias("better_hierarchy"))
+        @model.joins(@hierarchy).arel.
+          join(@source).on(filters).
+          join(better_rank.source, Arel::Nodes::OuterJoin).
+          on(
+            better_rank.filters.
+              and(better_rank.hierarchy_rank.lt(hierarchy_rank))
+          ).
+          where(better_rank.source[:id].eq(nil))
+      end
+
+      # # TODO: generate this dynamically based on existing columns and selects
+      # def best_rank_column_name
+      #   "through_hierarchy_best_rank"
+      # end
+
+      # def best_rank_column
+      #   @source[best_rank_column_name]
+      # end
+
+      # def best_rank
+      #   hierarchy_rank.minimum.as(best_rank_column_name)
+      # end
+
+      # def best_rank_table_name
+      #   "through_hierarchy_best_rank"
+      # end
+
+      # SLOW METHOD: subquery, gorup, min(priority). This performs abysmally.
+      # # TODO: replace model_key(@model) with target_key?
+      # def join_best_rank(group_by: nil)
+      #   sub = best_rank_subquery(*group_by)
+      #   @model.joins(@hierarchy).arel.
+      #     join(sub.source).
+      #     on(sub.source["model_key"].eq(model_key(@model))).
+      #     join(@source).on(
+      #       and_conditions([
+      #         filters,
+      #         hierarchy_rank.eq(sub.best_rank_column),
+      #         *[*group_by].map{|gg| @source[gg].eq(sub.source[gg])}
+      #       ])
+      #     ).
+      #     order(model_key(@model), *group_by)
+      # end
+
+      # # TODO: does ordering the subquery increase performance?
+      # # TODO: override model_key in spawn to refer to projected column
+      # def best_rank_subquery(*group_bys)
+      #   @source.respond_to?(:project) or raise ThroughHierarchySourceError, "#{@source} cannot be converted into a subquery"
+      #   group_nodes = group_bys.map{|gg|@source[gg]}
+      #   subq = @model.joins(@hierarchy).arel.
+      #     project(model_key(@model).as("model_key"), *group_nodes, best_rank).
+      #     join(@source).on(filters).
+      #     group(model_key(@model), *group_nodes).
+      #     as(best_rank_table_name)
+      #   spawn(subq)
+      # end
+
+    end
+  end
+end

data/lib/through_hierarchy/hierarchicals/instance.rb

@@ -0,0 +1,76 @@
+module ThroughHierarchy
+  module Hierarchicals
+    class Instance < Hierarchical
+      def set_target(target)
+        @target = target
+        @instance = @target
+        @model = @target.class        
+      end
+
+      def hierarchy_instances
+        [@instance] + @hierarchy.map{|m| @instance.association(m).load_target}
+      end
+
+      def filters
+        or_conditions(hierarchy_instances.map{|instance| filter(instance)})
+      end
+
+      def filter(instance)
+        foreign_type_column.eq(instance_type(instance)).
+          and(foreign_key_column.eq(instance_key(instance)))
+      end
+
+      def instance_type(instance)
+        instance.class.base_class.to_s
+      end
+
+      def instance_key(instance)
+        instance.attributes[@model.primary_key]
+      end
+
+      def best_rank_column_name
+        "through_hierarchy_best_rank"
+      end
+
+      def best_rank_column
+        @source[best_rank_column_name]
+      end
+
+      def best_rank
+        hierarchy_rank.minimum.as(best_rank_column_name)
+      end
+
+      def best_rank_table_name
+        "through_hierarchy_best_rank"
+      end
+
+      # Select only sources with best hierarchy rank for target instance
+      # Uses subquery grouped by specified column to compute best rank
+      # TODO: experiment with the model-style double-join method instead
+      def select_best_rank(group_by:)
+        sub = best_rank_subquery(group_by)
+        @source.
+          join(sub.source).
+          on(
+            hierarchy_rank.eq(sub.best_rank_column).
+              and(@source[group_by].eq(sub.source[group_by]))
+          ).
+          order(@source[group_by])
+      end
+
+      # Return a new Hierarchical::Instance representing a subquery that contains
+      # only best-rank sources.
+      def best_rank_subquery(group_by)
+        @source.respond_to?(:project) or raise ThroughHierarchySourceError, "#{@source} cannot be converted into a subquery"
+        subq = source.
+          project(foreign_type_column, foreign_key_column, group_by, best_rank).
+          where(filters).
+          group(source[group_by]).
+          as(best_rank_table_name)
+
+        spawn(subq)
+      end
+
+    end
+  end
+end

data/lib/through_hierarchy/hierarchy.rb

@@ -4,7 +4,7 @@ module ThroughHierarchy
       @klass = klass
       @members = members
 
-      validate_members
+      validate_hierarchy
     end
 
     def has_one(name, scope = nil, **options)
@@ -15,15 +15,19 @@ module ThroughHierarchy
 
     def has_many(name, scope = nil, **options)
       options.merge!(scope: scope) if scope.present?
-      assoc = ::ThroughHierarchy::Associations::HasMany.new(name, @klass, @members, options)
+      if options.key?(:uniq)
+        assoc = ::ThroughHierarchy::Associations::HasUniq.new(name, @klass, @members, options)
+      else
+        assoc = ::ThroughHierarchy::Associations::HasMany.new(name, @klass, @members, options)
+      end
       ::ThroughHierarchy::Builder.new(@klass).add_association(name, assoc)
     end
 
     private
 
-    def validate_members
+    def validate_hierarchy
       @members.is_a?(::Array) or ::Kernel.raise ::ThroughHierarchy::ThroughHierarchyDefinitionError, "Hierarchy members: expected: Array, got: #{@members.class}"
-      @members.all?{|member| @klass.reflect_on_association(member).present?} or ::Kernel.raise ::ThroughHierarchy::ThroughHierarchyDefinitionError, "No association named #{member} was found. Perhaps you misspelled it?"
+      @members.all?{|member| @klass.reflect_on_association(member).present? or ::Kernel.raise ::ThroughHierarchy::ThroughHierarchyDefinitionError, "No association named #{member} was found. Perhaps you misspelled it?"}
     end
   end  
 end

data/lib/through_hierarchy.rb

@@ -4,6 +4,9 @@ require 'through_hierarchy/builder.rb'
 require 'through_hierarchy/associations/association.rb'
 require 'through_hierarchy/associations/has_one.rb'
 require 'through_hierarchy/associations/has_many.rb'
+require 'through_hierarchy/associations/has_uniq.rb'
 require 'through_hierarchy/exceptions.rb'
+require 'through_hierarchy/hierarchicals/hierarchical.rb'
+require 'through_hierarchy/hierarchicals/instance.rb'
 
 ActiveRecord::Base.include(ThroughHierarchy::Base)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: through_hierarchy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrew Schwartz
@@ -20,9 +20,12 @@ files:
 - lib/through_hierarchy/associations/association.rb
 - lib/through_hierarchy/associations/has_many.rb
 - lib/through_hierarchy/associations/has_one.rb
+- lib/through_hierarchy/associations/has_uniq.rb
 - lib/through_hierarchy/base.rb
 - lib/through_hierarchy/builder.rb
 - lib/through_hierarchy/exceptions.rb
+- lib/through_hierarchy/hierarchicals/hierarchical.rb
+- lib/through_hierarchy/hierarchicals/instance.rb
 - lib/through_hierarchy/hierarchy.rb
 homepage: https://github.com/ozydingo/through_hierarchy
 licenses: