activefacts-rmap 1.7.1

data/lib/activefacts/rmap/foreignkey.rb

@@ -0,0 +1,187 @@
+#
+#       ActiveFacts Relational mapping
+#       A ForeignKey exists for every Reference from a ObjectType to another ObjectType that's a table.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module RMap
+    class ForeignKey
+      # What table (ObjectType) is the FK from?
+      def from; @from; end
+
+      # What table (ObjectType) is the FK to?
+      def to; @to; end
+
+      # What reference created the FK?
+      def references; @references; end
+
+      # What columns in the *from* table form the FK
+      def from_columns; @from_columns; end
+
+      # What columns in the *to* table form the identifier
+      def to_columns; @to_columns; end
+
+      def initialize(from, to, references, from_columns, to_columns) #:nodoc:
+        @from, @to, @references, @from_columns, @to_columns =
+          from, to, references, from_columns, to_columns
+      end
+
+      def describe
+	"foreign key from #{from.name}(#{from_columns.map{|c| c.name}*', '}) to #{to.name}(#{to_columns.map{|c| c.name}*', '})"
+      end
+
+      def verbalised_path reverse = false
+	# REVISIT: This should be a proper join path verbalisation:
+	refs = reverse ? references.reverse : references
+	refs.map do |r|
+	  r.verbalised_path reverse
+	end * ' and '
+      end
+
+      # Which references are absorbed into the "from" table?
+      def precursor_references
+	fk_jump = @references.detect(&:fk_jump)
+	jump_index = @references.index(fk_jump)
+	@references[0, jump_index]
+      end
+
+      # Which references are absorbed into the "to" table?
+      def following_references
+	fk_jump = @references.detect(&:fk_jump)
+	jump_index = @references.index(fk_jump)
+	fk_jump != @references.last ? @references[jump_index+1..-1] : []
+      end
+
+      def jump_reference
+	@references.detect(&:fk_jump)
+      end
+
+      def to_name
+	p = precursor_references
+	f = following_references
+	j = jump_reference
+
+	@references.last.to_names +
+	  (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
+      end
+
+      # The from_name is the role name of the table with the FK, viewed from the other end
+      # When there are no precursor_references or following_references, it's the jump_reference.from_names
+      # REVISIT: I'm still working out what to do with precursor_references and following_references
+      def from_name
+	p = precursor_references
+	f = following_references
+	j = jump_reference
+
+	# pluralise unless j.is_one_to_one
+
+	# REVISIT: references[0].from_names is where the FK lives; but the object of interest may be an absorbed subclass which we should use here instead:
+	# REVISIT: Should crunch superclasses in subtype traversals
+	# REVISIT: Need to add "_as_rolename" where rolename is not to.name
+
+	[
+	  @references[0].from_names,
+	  (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
+	]
+      end
+
+    end
+  end
+
+  module Metamodel    #:nodoc:
+    class ObjectType
+      # When an EntityType is fully absorbed, its foreign keys are too.
+      # Return an Array of Reference paths for such absorbed FKs
+      def all_absorbed_foreign_key_reference_path
+        references_from.inject([]) do |array, ref|
+          if ref.is_simple_reference
+            if TypeInheritance === ref.fact_type
+              # Ignore references to secondary supertypes, when absorption is through primary.
+              next array if absorbed_via && TypeInheritance === absorbed_via.fact_type
+              # Ignore the case where a subtype is absorbed elsewhere:
+              # REVISIT: Disabled, as this should never happen.
+              # next array if ref.to.absorbed_via != ref.fact_type
+            end
+	    ref.fk_jump = true
+            array << [ref]
+          elsif ref.is_absorbing or (ref.to && !ref.to.is_table)
+	    trace :fk, "getting fks absorbed into #{name} via #{ref}" do
+	      ref.to.all_absorbed_foreign_key_reference_path.each do |aref|
+		array << aref.insert(0, ref)
+	      end
+	    end
+          end
+          array
+        end
+      end
+
+      def foreign_keys_to
+	@foreign_keys_to ||= []
+      end
+
+      # Return an array of all the foreign keys from this table
+      def foreign_keys
+
+        # Get the ForeignKey object for each absorbed reference path
+	@foreign_keys ||=
+	  begin
+	    fk_ref_paths = all_absorbed_foreign_key_reference_path
+	    fk_ref_paths.map do |fk_ref_path|
+	      trace :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
+
+		from_columns = (columns||all_columns({})).select{|column|
+		  column.references[0...fk_ref_path.size] == fk_ref_path
+		}
+		trace :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
+
+		# Figure out absorption on the target end:
+		to = fk_ref_path.last.to
+		if to.absorbed_via
+		  trace :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
+		    while (r = to.absorbed_via)
+		      m = r.reversed
+		      trace :fk, "#{m.reading}"
+		      fk_ref_path << m
+		      to = m.from == to ? m.to : m.from
+		    end
+		    trace :fk, "Absorption ends at #{to.name}"
+		  end
+		end
+
+		# REVISIT: This test may no longer be necessary
+		raise "REVISIT: #{fk_ref_path.inspect} is bad" unless to and to.columns
+
+		# REVISIT: This fails for absorbed subtypes having their own identification.
+		# Check the CompanyDirectorEmployee model for example, EmployeeManagerNr -> Person (should reference EmployeeNr)
+		# Need to use the absorbed identifier_columns of the subtype,
+		# not the columns of the supertype that absorbs it.
+		# But in general, that isn't going to work because in most DBMS
+		# there's no suitable uniquen index on the subtype's identifier_columns
+
+		to_columns = fk_ref_path[-1].to.identifier_columns
+
+		# Put the column pairs in the correct order. They MUST be in the order they appear in the primary key
+		froms, tos = from_columns.zip(to_columns).sort_by { |pair|
+		  to_columns.index(pair[1])
+		}.transpose
+
+		fk = ActiveFacts::RMap::ForeignKey.new(self, to, fk_ref_path, froms, tos)
+		to.foreign_keys_to << fk
+		fk
+	      end
+	    end.
+	    sort_by do |fk|
+	      # Put the foreign keys in a defined order:
+#	      debugger if !fk.to_columns || fk.to_columns.include?(nil) || !fk.from_columns || fk.from_columns.include?(nil)
+	      [ fk.to.name,
+		fk.to_columns.map{|col| col.name(nil).sort},
+		fk.from_columns.map{|col| col.name(nil).sort}
+	      ]
+	    end
+	  end
+
+      end
+    end
+  end
+end

data/lib/activefacts/rmap/index.rb

@@ -0,0 +1,237 @@
+#
+#       ActiveFacts Relational mapping
+#       An Index on a ObjectType is used to represent a unique constraint across roles absorbed
+#       into that object_type's table.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+module ActiveFacts
+  module RMap
+    class Index
+      # The UniquenessConstraint that created this index
+      def uniqueness_constraint; @uniqueness_constraint; end
+
+      # The table that the index is on
+      def on; @on; end
+
+      # If a non-mandatory reference was absorbed, only the non-nil instances are unique.
+      # Return the ObjectType that was absorbed, which might differ from this Index's table.
+      def over; @over; end
+
+      # Return the array of columns in this index
+      def columns; @columns; end
+
+      # Is this index the primary key for this table?
+      def is_primary; @is_primary; end
+
+      # Is this index unique?
+      def is_unique; @is_unique; end
+
+      # An Index arises from a uniqueness constraint and applies to a table,
+      # but because the UC may actually be over an object absorbed into the table,
+      # we must record that object also.
+      # We record the columns it's over, whether it's primary (for 'over'),
+      # and whether it's unique (always, at present)
+      def initialize(uc, on, over, columns, is_primary, is_unique = true)   #:nodoc:
+        @uniqueness_constraint, @on, @over, @columns, @is_primary, @is_unique =
+          uc, on, over, columns, is_primary, is_unique
+      end
+
+      # The name that was assigned (perhaps implicitly by NORMA)
+      def real_name
+        @uniqueness_constraint.name && @uniqueness_constraint.name != '' ? @uniqueness_constraint.name.gsub(' ','') : nil
+      end
+
+      # This name is either the name explicitly assigned (if any) or is constructed to form a unique index name.
+      def name
+        uc = @uniqueness_constraint
+        r = real_name
+        return r if r && r !~ /^(Ex|In)ternalUniquenessConstraint[0-9]+$/
+        (uc.is_preferred_identifier ? "PK_" : "IX_") +
+          view_name +
+          (uc.is_preferred_identifier ? "" : "By"+column_names*"")
+      end
+
+      # An array of the names of the columns this index covers
+      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(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
+      def view_name
+        "#{over.name.gsub(' ','')}#{on == over ? "" : "In"+on.name.gsub(' ','')}"
+      end
+
+      def to_s  #:nodoc:
+	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)*", "
+        "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::RMap::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 || populate_indices
+      end
+
+      def clear_indices     #:nodoc:
+        # Clear any previous indices
+        @indices = nil
+      end
+
+      def populate_indices     #:nodoc:
+        # The absorption path of a column indicates how it came to be in this table.
+        # It might be a direct many:one valuetype relationship, or it might be in such
+        # a relationship to an entity that was absorbed into this table (and so on).
+        # The reference path is the set of absorption references and one past it.
+        # Stopping here means we don't dig into the definitions of FK column counterparts.
+        # Note that many columns of an object may have the same ref_path.
+        #
+        # REVISIT:
+        # Note also that this produces columns ordered for each refpath the same as the
+        # 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 =
+          trace :index2, "Indexing columns by ref_path" do
+            columns.inject({}) do |hash, column|
+              trace :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?
+                (hash[ref_path] ||= []) << column
+                trace :index2, "#{column.name} involves #{ref_path.map(&:to_s)*" and "}"
+              end
+              hash
+            end
+          end
+
+        columns_by_unique_constraint = {}
+        all_column_by_role_ref =
+          all_column_by_ref_path.
+            keys.                       # Go through all refpaths and find uniqueness constraints
+            inject({}) do |hash, ref_path|
+              ref_path.each do |ref|
+                next unless ref.to_role
+                # trace :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
+                  pcs = all_pcs.
+                    reject do |pc|
+                      !pc.max_frequency or      # No maximum freq; cannot be a uniqueness constraint
+                      pc.max_frequency != 1 or  # maximum is not 1
+                                                # Constraint is not over a unary fact type role (NORMA does this)
+                      pc.role_sequence.all_role_ref.size == 1 && ref_path[-1].to_role.fact_type.all_role.size == 1
+                    end
+                  next unless pcs.size > 0
+                  # The columns for this ref_path support the UCs in "pcs".
+                  pcs.each do |pc|
+                    ref_columns = all_column_by_ref_path[ref_path]
+                    ordinal = role_ref.ordinal  # Position in priority order
+                    ref_columns.each_with_index do |column, index|
+                      #puts "Adding index column #{column.name} in rank[#{ordinal},#{index}]"
+                      # REVISIT: the "index" here might be a duplicate in some cases: change sort_by below to just sort and run the SeparateSubtypes CQL model for example.
+                      (columns_by_unique_constraint[pc] ||= []) << [ordinal, index, column]
+                    end
+                  end
+                  hash[role_ref] = all_column_by_ref_path[ref_path]
+                end
+              end
+              hash
+            end
+
+        trace :index, "All Indices in #{name}:" do
+          @indices = columns_by_unique_constraint.map do |uc, columns_with_ordinal|
+            trace :index, "Index due to uc #{uc.concept.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:
+	    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::RMap::Index.new(
+              uc,
+              self,
+              over,
+              columns,
+              uc.is_preferred_identifier
+            )
+            trace :index, index
+            index
+          end.
+          compact.
+          sort_by do |index|
+            # Put the indices in a defined order:
+            index.columns.map(&:name)+['', index.over.name]
+          end
+        end
+	si = self_index
+	@indices.unshift(si) if si
+	@indices
+      end
+
+    end
+
+    class Vocabulary
+      def populate_all_indices  #:nodoc:
+        trace :index, "Populating all object_type indices" do
+          all_object_type.each do |object_type|
+            object_type.clear_indices
+          end
+          tables.each do |object_type|
+            trace :index, "Populating indices for #{object_type.name}" do
+              object_type.populate_indices
+            end
+          end
+        end
+        trace :index, "Finished object_type indices" do
+          tables.each do |object_type|
+            trace :index?, "#{object_type.name}:" do
+              object_type.indices.each do |index|
+                trace :index, index
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/activefacts/rmap/object_type.rb

@@ -0,0 +1,198 @@
+require 'activefacts/support'
+
+module ActiveFacts
+  module API
+    module ObjectType
+      def table
+        @is_table = true
+      end
+
+      def is_table
+        @is_table
+      end
+
+      def columns
+raise "This method is no longer in use"
+=begin
+        return @columns if @columns
+        trace :rmap, "Calculating columns for #{basename}" do
+          @columns = (
+            if superclass.is_entity_type
+              # REVISIT: Need keys to secondary supertypes as well, but no duplicates.
+              trace :rmap, "Separate subtype has a foreign key to its supertype" do
+                superclass.__absorb([[superclass.basename]], self)
+              end
+            else
+              []
+            end +
+            # Then absorb all normal roles:
+            roles.values.select do |role|
+              role.unique && !role.counterpart_unary_has_precedence
+            end.inject([]) do |columns, role|
+              rn = role.name.to_s.split(/_/)
+              trace :rmap, "Role #{rn*'.'}" do
+                columns += role.counterpart_object_type.__absorb([rn], role.counterpart)
+              end
+            end +
+            # And finally all absorbed subtypes:
+            subtypes.
+              select{|subtype| !subtype.is_table}.    # Don't absorb separate subtypes
+              inject([]) do |columns, subtype|
+                # Pass self as 2nd param here, not a role, standing for the supertype role
+                subtype_name = subtype.basename
+                trace :rmap, "Absorbing subtype #{subtype_name}" do
+                  columns += subtype.__absorb([[subtype_name]], self)
+                end
+              end
+            ).map do |col_names|
+              last = nil
+              col_names.flatten.map do |name|
+                name.downcase.sub(/^[a-z]/){|c| c.upcase}
+              end.
+              reject do |n|
+                # Remove sequential duplicates:
+                dup = last == n
+                last = n
+                dup
+              end*"."
+            end
+        end
+=end
+      end
+
+      # Return an array of the absorbed columns, using prefix for name truncation
+      def __absorb(prefix, except_role = nil)
+        # also considered a table if the superclass isn't excluded and is (transitively) a table
+        if !@is_table && (except_role == superclass || !is_table_subtype)
+          if is_entity_type
+            if (role = fully_absorbed) && role != except_role
+              # If this non-table is fully absorbed into another table (not our caller!)
+              # (another table plays its single identifying role), then absorb that role only.
+              # counterpart_object_type = role.counterpart_object_type
+              # This omission matches the one in columns.rb, see EntityType#reference_columns
+              # new_prefix = prefix + [role.name.to_s.split(/_/)]
+              trace :rmap, "Reference to #{role.name} (absorbed elsewhere)" do
+                role.counterpart_object_type.__absorb(prefix, role.counterpart)
+              end
+            else
+              # Not a table -> all roles are absorbed
+              roles.
+                  values.
+                  select do |role|
+                    role.unique && role != except_role && !role.counterpart_unary_has_precedence
+                  end.
+                  inject([]) do |columns, role|
+                columns += __absorb_role(prefix, role)
+              end +
+              subtypes.          # Absorb subtype roles too!
+                select{|subtype| !subtype.is_table}.    # Don't absorb separate subtypes
+                inject([]) do |columns, subtype|
+                  # Pass self as 2nd param here, not a role, standing for the supertype role
+                  new_prefix = prefix[0..-2] + [[subtype.basename]]
+                  trace :rmap, "Absorbed subtype #{subtype.basename}" do
+                    columns += subtype.__absorb(new_prefix, self)
+                  end
+                end
+            end
+          else
+            [prefix]
+          end
+        else
+          # Create a foreign key to the table
+          if is_entity_type
+            ir = identifying_role_names.map{|role_name| roles(role_name) }
+            trace :rmap, "Reference to #{basename} with #{prefix.inspect}" do
+              ic = identifying_role_names.map{|role_name| role_name.to_s.split(/_/)}
+              ir.inject([]) do |columns, role|
+                columns += __absorb_role(prefix, role)
+              end
+            end
+          else
+            # Reference to value type which is a table
+            col = prefix.clone
+            trace :rmap, "Self-value #{col[-1]}.Value"
+            col[-1] += ["Value"]
+            col
+          end
+        end
+      end
+
+      def __absorb_role(prefix, role)
+        if prefix.size > 0 and
+            (c = role.owner).is_entity_type and
+            c.identifying_roles == [role] and
+            (irn = c.identifying_role_names).size == 1 and
+            (n = irn[0].to_s.split(/_/)).size > 1 and
+            (owner = role.owner.basename.snakecase.split(/_/)) and
+            n[0...owner.size] == owner
+          trace :rmap, "truncating transitive identifying role #{n.inspect}"
+          owner.size.times { n.shift }
+          new_prefix = prefix + [n]
+        elsif (c = role.counterpart_object_type).is_entity_type and
+            (irn = c.identifying_role_names).size == 1 and
+            #irn[0].to_s.split(/_/)[0] == role.owner.basename.downcase
+            irn[0] == role.counterpart.name
+          #trace :rmap, "=== #{irn[0].to_s.split(/_/)[0]} elided ==="
+          new_prefix = prefix
+        elsif (fa_role = fully_absorbed) && fa_role == role
+          new_prefix = prefix
+        else
+          new_prefix = prefix + [role.name.to_s.split(/_/)]
+        end
+        #trace :rmap, "new_prefix is #{new_prefix*"."}"
+
+        trace :rmap, "Absorbing role #{role.name} as #{new_prefix[prefix.size..-1]*"."}" do
+          role.counterpart_object_type.__absorb(new_prefix, role.counterpart)
+        end
+      end
+
+      def is_table_subtype
+        return true if is_table
+        klass = superclass
+        while klass.is_entity_type
+          return true if klass.is_table
+          klass = klass.superclass
+        end
+        return false
+      end
+    end
+
+    module Entity
+      module ClassMethods
+        def fully_absorbed
+          return false unless (ir = identifying_role_names) && ir.size == 1
+          role = roles(ir[0])
+          return role if ((cp = role.counterpart_object_type).is_table ||
+              (cp.is_entity_type && cp.fully_absorbed))
+          return superclass if superclass.is_entity_type  # Absorbed subtype
+          nil
+        end
+      end
+    end
+
+    # A one-to-one can be absorbed into either table. We decide which by comparing
+    # the names, just as happens in ObjectType.populate_reference (see reference.rb)
+    class Role
+      def counterpart_unary_has_precedence
+        counterpart_object_type.is_table_subtype and
+          counterpart.unique and
+          owner.name.downcase < counterpart.owner.name.downcase
+      end
+    end
+
+  end
+end
+
+class TrueClass
+  def self.__absorb(prefix, except_role = nil)
+    [prefix]
+  end
+
+  def self.is_table
+    false
+  end
+
+  def self.is_table_subtype
+    false
+  end
+end