activefacts 0.8.16 → 0.8.18

data/lib/activefacts/persistence/index.rb

@@ -54,13 +54,13 @@ module ActiveFacts
       end
 
       # An array of the names of the columns this index covers
-      def column_names(joiner = "")
-        columns.map{|column| column.name(joiner)}
+      def column_names(separator = "")
+        columns.map{|column| column.name(separator)}
       end
 
       # An array of the names of the columns this index covers, with some lexical truncations.
-      def abbreviated_column_names(joiner = "")
-        columns.map{|column| column.name(joiner).sub(/^#{over.name}/,'')}
+      def abbreviated_column_names(separator = "")
+        columns.map{|column| column.name(separator).sub(/^#{over.name}/,'')}
       end
 
       # The name of a view that can be created to enforce uniqueness over non-null key values
@@ -69,18 +69,43 @@ module ActiveFacts
       end
 
       def to_s  #:nodoc:
-        name = @uniqueness_constraint.name
+	if @uniqueness_constraint
+	  name = @uniqueness_constraint.name
+	  preferred = @uniqueness_constraint.is_preferred_identifier ? " (preferred)" : ""
+	else
+	  name = "#{@on.name}IsUnique"
+	  preferred = !@on.injected_surrogate_role ? " (preferred)" : ""
+	end
         colnames = @columns.map(&:name)*", "
-        preferred = @uniqueness_constraint.is_preferred_identifier ? " (preferred)" : ""
         "Index #{name} on #{@on.name} over #{@over.name}(#{colnames})#{preferred}"
       end
     end
   end
 
   module Metamodel    #:nodoc:
+    class EntityType
+      def self_index
+	nil
+      end
+    end
+
+    class ValueType
+      def self_index
+	ActiveFacts::Persistence::Index.new(
+	  nil,	  # The implied uniqueness constraint is not created
+	  self,	  # ValueType being indexed
+	  self,	  # Absorbed object being indexed
+	  columns.select{|c| c.references[0].is_self_value},
+	  injected_surrogate_role ? false : true
+	)
+      end
+    end
+
     class ObjectType
       # An array of each Index for this table
-      def indices; @indices; end
+      def indices
+	@indices || populate_indices
+      end
 
       def clear_indices     #:nodoc:
         # Clear any previous indices
@@ -100,7 +125,7 @@ module ActiveFacts
         # order of the columns, not the same as the columns in the PK for which they might be an FK.
         all_column_by_ref_path =
           debug :index2, "Indexing columns by ref_path" do
-            @columns.inject({}) do |hash, column|
+            columns.inject({}) do |hash, column|
               debug :index2, "References in column #{name}.#{column.name}" do
                 ref_path = column.absorption_references
                 raise "No absorption_references for #{column.name} from #{column.references.map(&:to_s)*" and "}" if !ref_path || ref_path.empty?
@@ -118,10 +143,10 @@ module ActiveFacts
             inject({}) do |hash, ref_path|
               ref_path.each do |ref|
                 next unless ref.to_role
-                #debug :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name(".")}*", "}"
+                # debug :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name('.')}*", "}"
                 ref.to_role.all_role_ref.each do |role_ref|
                   all_pcs = role_ref.role_sequence.all_presence_constraint
-    #puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*"."}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
+		  # puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*'.'}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
                   pcs = all_pcs.
                     reject do |pc|
                       !pc.max_frequency or      # No maximum freq; cannot be a uniqueness constraint
@@ -148,16 +173,18 @@ module ActiveFacts
 
         debug :index, "All Indices in #{name}:" do
           @indices = columns_by_unique_constraint.map do |uc, columns_with_ordinal|
-            #puts "Index on #{name} over (#{columns_with_ordinal.sort.map{|ca| [ca[0], ca[1], ca[2].name].inspect}})"
+            debug :index, "Index due to uc #{uc.guid} on #{name} over (#{columns_with_ordinal.sort_by{|onc|onc[0]}.map{|ca| ca[2].name}.inspect})"
             columns = columns_with_ordinal.sort_by{|ca| [ca[0,2], ca[2].name]}.map{|ca| ca[2]}
             absorption_level = columns.map(&:absorption_level).min
             over = columns[0].references[absorption_level].from
 
             # Absorption through a one-to-one forms a UC that we don't need to enforce using an index:
-            next nil if over != self and
+	    if over != self and
               over.absorbed_via == columns[0].references[absorption_level-1] and
               (rr = uc.role_sequence.all_role_ref.single) and
               over.absorbed_via.fact_type.all_role.include?(rr.role)
+	      next nil
+	    end
 
             index = ActiveFacts::Persistence::Index.new(
               uc,
@@ -175,6 +202,9 @@ module ActiveFacts
             index.columns.map(&:name)+['', index.over.name]
           end
         end
+	si = self_index
+	@indices.unshift(si) if si
+	@indices
       end
 
     end

data/lib/activefacts/persistence/reference.rb

@@ -39,9 +39,11 @@ module ActiveFacts
       attr_reader :from, :to            # A "from" instance is related to one "to" instance
       attr_reader :from_role, :to_role  # For objectified facts, one role will be nil (a phantom)
       attr_reader :fact_type
+      attr_accessor :fk_jump            # True if this reference links a table to another in an FK (between absorbed references)
 
       # A Reference is created from a object_type in regard to a role it plays
       def initialize(from, role)
+        @fk_jump = false
         @from = from
         return unless role              # All done if it's a self-value reference for a ValueType
         @fact_type = role.fact_type
@@ -73,7 +75,6 @@ module ActiveFacts
       # Is this Reference covered by a mandatory constraint (implicitly or explicitly)
       def is_mandatory
         !@from_role ||        # All phantom roles of fact types are mandatory
-        is_unary ||           # Unary fact types become booleans, which must be true or false
         @from_role.is_mandatory
       end
 
@@ -111,10 +112,10 @@ module ActiveFacts
       end
 
       # Return the array of names for the (perhaps implicit) *to_role* of this Reference
-      def to_names
+      def to_names(is_prefix = true)
         case
         when is_unary
-          if @to && @to.fact_type
+          if @to && @to.fact_type && is_prefix
             @to.name.camelwords
           else
             @to_role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.camelwords
@@ -134,14 +135,14 @@ module ActiveFacts
       # Return the array of names for the (perhaps implicit) *from_role* of this Reference
       def from_names
         case
+        when @from && !@from_role           # @from is an objectified fact type so @from_role is a phantom
+          @from.name.camelwords
         when is_unary
           if @from && @from.fact_type
             @from.name.camelwords
           else
             @from_role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.camelwords
           end
-        when @from && !@from_role           # @from is an objectified fact type so @from_role is a phantom
-          @from.name.camelwords
         when !@from_role                  # Self-value role of an independent ValueType
           @from.name.camelwords + ["Value"]
         when @from_role.role_name         # Named role
@@ -152,12 +153,21 @@ module ActiveFacts
         end
       end
 
+      def is_one_to_one
+        [:one_one, :subtype, :supertype].include?(role_type)
+      end
+
       # For a one-to-one (or a subtyping fact type), reverse the direction.
       def flip                          #:nodoc:
-        raise "Illegal flip of #{self}" unless @to and [:one_one, :subtype, :supertype].include?(role_type)
+        raise "Illegal flip of #{self}" unless @to and is_one_to_one
 
         detabulate
+        mirror
+        tabulate
+      end
 
+      # Create a (non-tabulated) flipped version of this Reference. Careful not to tabulate it!
+      def mirror
         if @to.absorbed_via == self
           @to.absorbed_via = nil
           @from.absorbed_via = self
@@ -166,8 +176,11 @@ module ActiveFacts
         # Flip the reference
         @to, @from = @from, @to
         @to_role, @from_role = @from_role, @to_role
+        self
+      end
 
-        tabulate
+      def reversed
+        clone.mirror
       end
 
       def tabulate        #:nodoc:
@@ -188,7 +201,8 @@ module ActiveFacts
       end
 
       def to_s              #:nodoc:
-        "reference from #{@from.name}#{@to ? " to #{@to.name}" : ""}" + (@fact_type ? " in '#{@fact_type.default_reading}'" : "")
+        ref_type = fk_jump ? "jumping to" : (is_absorbing ? "absorbing" : "to")
+        "reference from #{@from.name}#{@to ? " #{ref_type} #{@to.name}" : ""}" + (@fact_type ? " in '#{@fact_type.default_reading}'" : "")
       end
 
       # The reading for the fact type underlying this Reference
@@ -258,8 +272,8 @@ module ActiveFacts
       def populate_references           #:nodoc:
         all_role.each do |role|
           # It's possible that this role is in an implicit or derived fact type. Skip it if so.
-          next if role.fact_type.is_a?(ImplicitFactType) or
-            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].join_role
+          next if role.fact_type.is_a?(LinkFactType) or
+            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play
           
           populate_reference role
         end
@@ -296,7 +310,6 @@ module ActiveFacts
           end
 
         when :subtype    # This object is a supertype, which can absorb the subtype unless that's independent
-          raise hell unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
           if role.fact_type.assimilation
             ActiveFacts::Persistence::Reference.new(self, role).tabulate
             # If partitioned, the supertype is absorbed into *each* subtype; a reference to the supertype needs to know which
@@ -351,7 +364,7 @@ module ActiveFacts
       end
     end
 
-    class EntityType < ObjectType
+    class EntityType < DomainObjectType
       def populate_references          #:nodoc:
         if fact_type && fact_type.all_role.size > 1
           # NOT: fact_type.all_role.each do |role|  # Place roles in the preferred order instead:
@@ -366,23 +379,24 @@ module ActiveFacts
     class Vocabulary
       def populate_all_references #:nodoc:
         debug :references, "Populating all object_type references" do
-          all_object_type.each do |object_type|
-            object_type.clear_references
-            object_type.is_table = nil      # Undecided; force an attempt to decide
-            object_type.tentative = true    # Uncertain
-          end
           all_object_type.each do |object_type|
             debug :references, "Populating references for #{object_type.name}" do
               object_type.populate_references
             end
           end
         end
-        debug :references, "Finished object_type references" do
-          all_object_type.each do |object_type|
-            next unless object_type.references_from.size > 0
-            debug :references, "#{object_type.name}:" do
-              object_type.references_from.each do |ref|
-                debug :references, "#{ref}"
+        show_all_references
+      end
+
+      def show_all_references
+        if debug :references
+          debug :references, "Finished object_type references" do
+            all_object_type.each do |object_type|
+              next unless object_type.references_from.size > 0
+              debug :references, "#{object_type.name}:" do
+                object_type.references_from.each do |ref|
+                  debug :references, "#{ref}"
+                end
               end
             end
           end

data/lib/activefacts/persistence/tables.rb

@@ -17,7 +17,7 @@ require 'activefacts/persistence/reference'
 module ActiveFacts
   module Metamodel
 
-    class ValueType < ObjectType
+    class ValueType < DomainObjectType
       def absorbed_via  #:nodoc:
         # ValueTypes aren't absorbed in the way EntityTypes are
         nil
@@ -35,7 +35,7 @@ module ActiveFacts
         end
 
         # Only a table if it has references (to another ValueType)
-        if !references_from.empty?
+        if !references_from.empty? && !is_auto_assigned
           debug :absorption, "#{name} is a table because it has #{references_from.size} references to it"
           @is_table = true
         else
@@ -55,7 +55,7 @@ module ActiveFacts
       end
     end
 
-    class EntityType < ObjectType
+    class EntityType < DomainObjectType
       # A Reference from an entity type that fully absorbs this one
       def absorbed_via; @absorbed_via; end
       def absorbed_via=(r) #:nodoc:
@@ -85,12 +85,25 @@ module ActiveFacts
           return @is_table = true
         end
 
-        # Subtypes are not a table unless partitioned or separate
-        # REVISIT: Support partitioned subtypes here
+        # Subtypes may be partitioned or separate, in which case they're definitely tables.
+        # Otherwise, if their identification is inherited from a supertype, they're definitely absorbed.
+        # If theey have separate identification, it might absorb them.
         if (!supertypes.empty?)
           as_ti = all_supertype_inheritance.detect{|ti| ti.assimilation}
-          debug :absorption, "EntityType #{name} is #{as_ti ? as_ti.assimilation+' from' : 'absorbed into'} supertype #{(as_ti ? as_ti.supertype : supertypes[0]).name}"
-          return @is_table = all_supertype_inheritance.detect{|ti| ti.assimilation} != nil
+          @is_table = as_ti != nil
+          if @is_table
+            debug :absorption, "EntityType #{name} is #{as_ti.assimilation} from supertype #{as_ti.supertype}"
+          else
+            identifying_fact_type = preferred_identifier.role_sequence.all_role_ref.to_a[0].role.fact_type
+            if identifying_fact_type.is_a?(TypeInheritance)
+              debug :absorption, "EntityType #{name} is absorbed into supertype #{supertypes[0].name}"
+              @is_table = false
+            else
+              # Possibly absorbed, we'll have to see how that pans out
+              @tentative = true
+            end
+          end
+          return @is_table
         end
 
         # If the preferred_identifier includes an auto_assigned ValueType
@@ -168,12 +181,20 @@ module ActiveFacts
       end
 
       def self.relational_transform &block
-        # Add this block to the additional transformations which wil be applied
+        # Add this block to the additional transformations which will be applied
         # to the relational schema after the initial absorption.
         # For example, to perform injection of surrogate keys to replace composite keys...
         @@relational_transforms << block
       end
 
+      def wipe_existing_mapping
+        all_object_type.each do |object_type|
+          object_type.clear_references
+          object_type.is_table = nil      # Undecided; force an attempt to decide
+          object_type.tentative = true    # Uncertain
+        end
+      end
+
       def decide_tables #:nodoc:
         # Strategy:
         # 1) Populate references for all ObjectTypes
@@ -181,7 +202,7 @@ module ActiveFacts
         #  a. ObjectTypes labelled is_independent are tables (See the is_table methods above)
         #  b. Entity types having no references to them must be tables
         #  c. subtypes are not tables unless marked with assimilation = separate or partitioned
-        #  d. ValueTypes are never tables unless they can have references (to other ValueTypes)
+        #  d. ValueTypes are never tables unless they independent or can have references (to other ValueTypes)
         #  e. An EntityType having an identifying AutoInc field must be a table unless it has exactly one reference
         #  f. An EntityType whose only reference is through its single preferred_identifier role gets absorbed
         #  g. An EntityType that must has references other than its PI must be a table (unless it has exactly one reference to it)
@@ -190,6 +211,8 @@ module ActiveFacts
         #    - subtype extension where supertype has only PI roles and no AutoInc
         # 3) any ValueType that has references from it must become a table if not already
 
+        wipe_existing_mapping
+
         populate_all_references
 
         debug :absorption, "Calculating relational composition" do
@@ -218,7 +241,7 @@ module ActiveFacts
               undecided.select do |object_type|
                 debug :absorption, "Considering #{object_type.name}:" do
                   debug :absorption, "refs to #{object_type.name} are from #{object_type.references_to.map{|ref| ref.from.name}*", "}" if object_type.references_to.size > 0
-                  debug :absorption, "refs from #{object_type.name} are to #{object_type.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if object_type.references_from.size > 0
+                  debug :absorption, "refs from #{object_type.name} are to #{object_type.references_from.map{|ref| ref.to ? ref.to.name : ref.fact_type.default_reading}*", "}" if object_type.references_from.size > 0
 
                   # Always absorb an objectified unary into its role player:
                   if object_type.fact_type && object_type.fact_type.all_role.size == 1
@@ -247,11 +270,21 @@ module ActiveFacts
                     }
                   debug :absorption, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
 
+=begin
+                  # This is kinda arbitrary. We need a policy for evaluating optional flips, so we can decide if they "improve" things.
+                  # The flipping that occurs below always eliminates a table by absorption, but this doesn't.
+
                   # If all non-identifying functional roles are one-to-ones that can be flipped, do that:
                   if non_identifying_refs_from.all? { |ref| ref.role_type == :one_one && (ref.to.is_table || ref.to.tentative) }
-                    non_identifying_refs_from.each { |ref| ref.flip }
+                    debug :absorption, "Flipping references from #{object_type.name}" do
+                      non_identifying_refs_from.each do |ref|
+                        debug :absorption, "Flipping #{ref}"
+                        ref.flip
+                      end
+                    end
                     non_identifying_refs_from = []
                   end
+=end
 
                   if object_type.references_to.size > 1 and
                       non_identifying_refs_from.size > 0
@@ -266,8 +299,7 @@ module ActiveFacts
                         !ref.to or ref.to.absorbed_via == ref
                       end+object_type.references_to
                     ).reject do |ref|
-                      next true if !ref.to.is_table or
-                        ![:one_one, :supertype, :subtype].include?(ref.role_type)
+                      next true if !ref.to.is_table or !ref.is_one_to_one
 
                       # Don't absorb an object along a non-mandatory role (otherwise if it doesn't play that role, it can't exist either)
                       from_is_mandatory = !!ref.is_mandatory
@@ -282,7 +314,7 @@ module ActiveFacts
                   if absorption_paths.size > 0
                     debug :absorption, "#{object_type.name} is fully absorbed through #{absorption_paths.inspect}"
                     absorption_paths.each do |ref|
-                      debug :absorption, "flip #{ref} so #{object_type.name} can be absorbed"
+                      debug :absorption, "Flipping #{ref} so #{object_type.name} can be absorbed"
                       ref.flip if object_type == ref.from
                     end
                     object_type.definitely_not_table
@@ -310,8 +342,13 @@ module ActiveFacts
           # unless it should absorb something else (another ValueType is all it could be):
           all_object_type.each do |object_type|
             if (!object_type.is_table and object_type.references_to.size == 0 and object_type.references_from.size > 0)
-              debug :absorption, "Making #{object_type.name} a table; it has nowhere else to go and needs to absorb things"
-              object_type.probably_table
+              if !object_type.references_from.detect{|r| !r.is_one_to_one || !r.to.is_table}
+                debug :absorption, "Flipping references from #{object_type.name}; they're all to tables"
+                object_type.references_from.map(&:flip)
+              else
+                debug :absorption, "Making #{object_type.name} a table; it has nowhere else to go and needs to absorb things"
+                object_type.probably_table
+              end
             end
           end
 
@@ -324,9 +361,6 @@ module ActiveFacts
           end
         end
 
-        populate_all_columns
-        populate_all_indices
-
         @tables =
           all_object_type.
           select { |f| f.is_table }.

data/lib/activefacts/registry.rb

@@ -0,0 +1,11 @@
+module ActiveFacts
+  module Registry
+    def self.generator(name, klass)
+      generators[name] = klass
+    end
+
+    def self.generators
+      @@generators ||= {}
+    end
+  end
+end