empty_eye 0.4.0

data/lib/empty_eye/primary_view_extension.rb

@@ -0,0 +1,137 @@
+module EmptyEye
+  class PrimaryViewExtension
+    
+    #primary extension for parent class
+    #manages associations for database updates
+    #has many of the same interfaces as view extensions
+
+    def initialize(table_name, parent)
+      @table = table_name
+      @parent = parent
+      create_shard
+    end
+
+    def self.connection
+      ActiveRecord::Base.connection
+    end
+    
+    #never include the type field as it shouldnt be needed and cant be updated anyway
+    def self.exclude_always
+      ['type']
+    end
+    
+    #class to which this extension belongs
+    def parent
+      @parent
+    end
+    
+    #to let the outside word know it is primary
+    def primary
+      true
+    end
+    
+    #class that will mimic the associations of the parent for updating db
+    def shard
+      @shard
+    end
+    
+    # the tablename
+    def table
+      @table
+    end
+    
+    # the alias for the table; for primary we just use the table name
+    def name
+      @table
+    end
+    
+    # arel table for generating the view
+    def arel_table
+      @arel_table ||= Arel::Table.new(table)
+    end
+    
+    #this may change but for now the key is the primary id of the parent and shard
+    def key
+      arel_table[:id]
+    end
+    
+    def foreign_key
+      "id"
+    end
+    
+    def sti_also?
+      !parent.descends_from_active_record?
+    end
+    
+    #arel column of type field
+    def type_column
+      if sti_also? 
+        arel_table[parent.inheritance_column.to_sym]
+      end
+    end
+    
+    #value of the polymorphic column
+    def type_value
+      parent.name if type_column
+    end
+    
+    #always null for primary
+    def polymorphic_type
+      nil
+    end
+
+    #table columns
+    def table_columns
+      self.class.connection.columns(table).collect(&:name)
+    end
+    
+    def exclude
+      self.class.exclude_always
+    end
+
+    #the table columns that will be extended in sql
+    def columns
+      table_columns - exclude
+    end
+    
+    #create associations for shard class to mimic parent
+    def have_one(ext)
+      #this is myself; dont associate
+      return if ext.primary
+      mimic = ext.association
+      return if shard.reflect_on_association(mimic.name)
+      options = mimic.options.dup
+      options.merge!(default_has_one_options)
+      options.merge!(:foreign_key => ext.foreign_key)
+      shard.send(mimic.macro, mimic.name, options)
+    end
+    
+    #delegate setters to appropriate associations
+    def delegate_to(col, ext)
+      return if ext.primary
+      shard.send(:delegate, "#{col}=", {:to => ext.name})
+    end
+    
+    private
+    
+    #MTI wouldnt make any sense if these were not forced in the associations
+    def default_has_one_options
+      {:autosave => true, :validate => true, :dependent => :destroy}
+    end
+
+    #if possible shard inherits from the superclass
+    def shard_inherit_from
+      parent.base_class == parent ? ActiveRecord::Base : parent.send(:superclass)
+    end
+    
+    #create a class to manage the parents associations
+    def create_shard
+      new_class = Class.new(shard_inherit_from)
+      new_class.send(:include, Shard)
+      new_class.table_name = table
+      new_class.mti_master_class = parent
+      @shard = EmptyEye.const_set("#{parent.to_s}Shard", new_class)
+    end
+    
+  end
+end

data/lib/empty_eye/relation.rb

@@ -0,0 +1,85 @@
+module EmptyEye
+  module Relation
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      
+      def delete_all(conditions = nil)
+        return super unless mti_class?
+        mti_clear_identity_map
+        affected = 0
+        #if something goes wrong forget it all
+        transaction do
+          if conditions
+            #batch up ids
+            ids = select("`#{table_name}`.`#{primary_key}`").where(conditions).collect(&:id)
+            #delete all the shards of the mti class matching ids
+            mti_batch_perform(ids) do |ext, batch|
+              if ext.polymorphic_type
+                ext.shard.delete_all(ext.foreign_key => batch, ext.polymorphic_type => ext.type_value)
+              else
+                ext.shard.delete_all(ext.foreign_key => batch)
+              end
+            end
+          else
+            #way simpler if there are no conditions; kill everyone
+            extended_with.each do |ext|
+              affected = [affected, ext.shard.delete_all].max
+            end
+          end
+        end
+        affected
+      end
+      
+      def update_all(updates, conditions = nil, options = {})
+        return super unless mti_class?
+        raise(EmptyEye::InvalidUpdate, "update values for a MTI class must be a hash") unless updates.is_a?(Hash)
+        mti_clear_identity_map
+        stringified_updates = updates.stringify_keys
+        affected = 0
+        transaction do
+          if conditions
+            #batch up ids
+            ids = select(arel_table[primary_key.to_sym]).where(conditions).apply_finder_options(options.slice(:limit, :order)).collect(&:id)
+            #update all the shards of the mti class matching ids
+            affected = mti_batch_perform(ids) do |ext, batch|
+              #delegate map ingests the update hash and regurgitates a smaller hash of the values the shard can handle
+              cols = extended_with.delegate_map(ext.name, stringified_updates)
+              cols.empty? ? 0 : ext.shard.update_all(cols, ext.foreign_key => batch)
+            end
+          else
+            #way simpler if there are no conditions; change the world!
+            extended_with.each do |ext|
+              cols = extended_with.delegate_map(ext.name, stringified_updates)
+              affected = [(cols.empty? ? 0 : ext.shard.update_all(cols)), affected].max
+            end
+          end
+        end
+        affected
+      end
+      
+      private
+      
+      def mti_clear_identity_map
+        ActiveRecord::IdentityMap.repository[symbolized_base_class].clear if ActiveRecord::IdentityMap.enabled?
+      end
+      
+      #lets do 10000 at a time
+      def mti_batch_perform(ids)
+        affected = 0
+        until ids.to_a.empty?
+          current_ids =  ids.pop(10000)
+          extended_with.each do |ext|
+            rtn = yield(ext, current_ids)
+            affected = [affected,rtn].max
+          end
+        end
+        affected
+      end
+    
+    end
+  end
+end

data/lib/empty_eye/shard.rb

@@ -0,0 +1,130 @@
+module EmptyEye
+  module Shard
+    
+    #a module that extendd the class that serves as a pointer to the primary table
+    #when there is a superclass the will inherit from that else it will inherit from ActiveRecord
+    #the primary shard manages all the MTI associated tables for the master class
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    #the instance that owns this primary shard
+    def mti_instance
+      @mti_instance
+    end
+    
+    #setter used to associate the primary shard with the master instance
+    def mti_instance=(instance)
+      @mti_instance = instance
+    end
+    
+    #special save so that the primary shard can keep the master instances tables consistent
+    def cascade_save
+      #make sure all the shards are there
+      cascade_build_associations 
+      #this will propagate setters to the appropriate shards
+      assign_attributes(mti_safe_attributes)
+      self.type = mti_master_class.name if respond_to?("type=")
+      #this will autosave shards
+      save
+      #reset the id and then reload
+      mti_instance.id = id
+      mti_instance.reload
+    end
+    
+    #reflection on master class; this should never change
+    def mti_master_class
+      self.class.mti_master_class
+    end
+  
+    private
+  
+    #make sure the primary shard only tries to update what he should
+    def mti_safe_attributes
+      mti_instance.attributes.except(
+        *self.mti_master_class.extended_with.primary.exclude
+      )
+    end
+  
+    #all the instance shards should exist but lets be certain
+    #using an autobuild would be more efficient here
+    #we shouldnt load associations we dont need to
+    def cascade_build_associations
+      #go through each extension making sure it is exists and is loaded
+      mti_instance.class.extended_with.each do |ext|
+        next if ext.primary
+        assoc = send(ext.name)
+        assoc ||= send("build_#{ext.name}")
+        send("#{ext.name}=", assoc)
+      end
+    end
+    
+    module ClassMethods
+      
+      #the shard uses special reflection; overriden here
+      def create_reflection(macro, name, options, active_record)
+        raise(EmptyEye::NotYetSupported, "through associations are not yet spported") if options[:through]
+        klass = options[:through] ? ShardThroughReflection : ShardAssociationReflection
+        reflection = klass.new(macro, name, options, active_record)
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      #finder methods should use the master classes base class not the shards
+      def type_condition(table = arel_table)
+        sti_column = table[inheritance_column.to_sym]
+
+        sti_column.eq(mti_master_class.name)
+      end
+      
+      #overriding find_by_id
+      #this is used to retrieve the shard instance for the master instance
+      #the type column is removed
+      def find_by_id(val)
+        query = columns_except_type
+        query = query.where(arel_table[:id].eq(val))
+        find_by_sql(query.to_sql).first
+      end
+      
+      #the shard uses a special association builder
+      def has_one(name, options = {})
+        Associations::Builder::ShardHasOne.build(self, name, options)
+      end
+
+      #reflection on master class; this should never change
+      def mti_master_class
+        @mti_master_class
+      end
+
+      #the mti_master_class value is set with this setter; should happen only once
+      def mti_master_class=(klass)
+        @mti_master_class = klass
+      end
+      
+      #overriding to reset the special instance variable
+      def reset_column_information
+        @columns_except_type = nil
+        super
+      end
+      
+      private
+      
+      #build the arel query once and memoize it
+      #this is essentially the select to remove type column
+      def columns_except_type
+        @columns_except_type ||= begin
+          query = arel_table
+          (column_names - [inheritance_column]).each do |c|
+            query = query.project(arel_table[c.to_sym])
+          end
+          query
+        end
+        @columns_except_type.dup
+      end
+    
+
+    end
+  end
+end

data/lib/empty_eye/shard_association_reflection.rb

@@ -0,0 +1,28 @@
+module EmptyEye
+  class ShardAssociationReflection < ActiveRecord::Reflection::AssociationReflection
+    #special reflection for shard
+    #very verbose but will be easier to update later
+    #better than monkey patching
+    
+    def association_class
+      EmptyEye::Associations::ShardHasOneAssociation
+      #later we will support all singular associations; for now only has one
+      
+      # case macro
+      # when :belongs_to
+      #   if options[:polymorphic]
+      #     EmptyEye::Associations::ShardBelongsToPolymorphicAssociation
+      #   else
+      #     EmptyEye::Associations::ShardBelongsToAssociation
+      #   end
+      # when :has_one
+      #   if options[:through]
+      #     EmptyEye::Associations::ShardHasOneThroughAssociation
+      #   else
+      #     EmptyEye::Associations::ShardHasOneAssociation
+      #   end
+      # end
+    end
+    
+  end
+end

data/lib/empty_eye/version.rb

@@ -0,0 +1,9 @@
+module EmptyEye
+  module VERSION
+    MAJOR = 0
+    MINOR = 4
+    TINY = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/empty_eye/view_extension.rb

@@ -0,0 +1,115 @@
+module EmptyEye
+  class ViewExtension
+    
+    #extension for parent class
+    #tracks associations for database updates managed by primary extension
+    #has many of the same interfaces as primary view extension
+
+    def initialize(association)
+      @association = association
+    end
+    
+    #exclude from view generation always
+    def self.exclude_always
+      ['id','created_at','updated_at','deleted_at', 'type']
+    end
+    
+    #association that this extension will build upon
+    def association
+      @association
+    end
+    
+    #the table columns that will be extended in sql
+    def columns
+      restrictions - exclude
+    end
+
+    #never the primary
+    def primary
+      false
+    end
+    
+    #table of the shard
+    def table
+      association.table_name
+    end
+    
+    #name of the association
+    def name
+      association.name
+    end
+    
+    #used to create view
+    def arel_table
+      @arel_table ||= begin
+        t= Arel::Table.new(table)
+        t.table_alias = alias_name if alias_name != table
+        t
+      end
+    end
+
+    #foreign key of the shard; used in view generation and database updates
+    def foreign_key
+      association.foreign_key 
+    end
+
+    #the shard is simply the class of the association
+    def shard
+      association.klass
+    end
+    
+    #arel column of polymorphic type field
+    def type_column
+      arel_table[polymorphic_type.to_sym] if polymorphic_type
+    end
+    
+    #value of the polymorphic column
+    def type_value
+      parent.base_class.name if polymorphic_type
+    end
+
+    #value computed to remove this from column map; no need for the view to have it
+    def polymorphic_type
+      return unless association.options[:as]
+      "#{association.options[:as]}_type"
+    end
+    
+    private
+    
+    #class to whom this extension belongs
+    def parent
+      association.active_record
+    end
+    
+    #class of the extension table
+    def klass
+      association.klass
+    end
+    
+    #uses association name to create alias to prevent non unique aliases
+    def alias_name
+      name.to_s.pluralize
+    end
+    
+    #user declared exceptions ... exclude these columns from the parent inheritance
+    def exceptions
+      association.options[:except].to_a.collect(&:to_s)
+    end
+    
+    #user declared restrictions ... restrict parent inheritance columns to these
+    def restrictions
+      only = association.options[:only].to_a.collect(&:to_s)
+      only.empty? ? table_columns : only
+    end
+
+    #we want to omit these columns
+    def exclude
+      [exceptions, self.class.exclude_always, foreign_key, polymorphic_type].flatten.uniq
+    end
+
+    #all the columns of the extensions table
+    def table_columns
+      klass.column_names
+    end
+  end
+end