activefacts 1.6.0 → 1.7.1

data/lib/activefacts/persistence/foreignkey.rb

@@ -1,187 +0,0 @@
-#
-#       ActiveFacts Relational mapping and persistence.
-#       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 Persistence
-    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::Persistence::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/persistence/index.rb

@@ -1,240 +0,0 @@
-#
-#       ActiveFacts Relational mapping and persistence.
-#       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 Persistence
-    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::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 || 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::Persistence::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
-          all_object_type.each do |object_type|
-            next unless object_type.is_table
-            trace :index, "Populating indices for #{object_type.name}" do
-              object_type.populate_indices
-            end
-          end
-        end
-        trace :index, "Finished object_type indices" do
-          all_object_type.each do |object_type|
-            next unless object_type.is_table
-            next unless object_type.indices.size > 0
-            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/persistence/object_type.rb

@@ -1,198 +0,0 @@
-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 :persistence, "Calculating columns for #{basename}" do
-          @columns = (
-            if superclass.is_entity_type
-              # REVISIT: Need keys to secondary supertypes as well, but no duplicates.
-              trace :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "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 :persistence, "=== #{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 :persistence, "new_prefix is #{new_prefix*"."}"
-
-        trace :persistence, "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