activefacts-generators 1.7.1

data/lib/activefacts/generators/sql/server.rb

@@ -0,0 +1,274 @@
+#
+#       ActiveFacts Generators.
+#       Generate SQL for SQL Server from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/rmap'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    module SQL #:nodoc:
+      # Generate SQL for SQL Server for an ActiveFacts vocabulary.
+      # Invoke as
+      #   afgen --sql/server[=options] <file>.cql
+      # Options are comma or space separated:
+      # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
+      class SERVER
+      private
+        include RMap
+        ColumnNameMax = 40
+
+        RESERVED_WORDS = %w{
+          ADD ALL ALTER AND ANY AS ASC AUTHORIZATION BACKUP BEGIN BETWEEN
+          BREAK BROWSE BULK BY CASCADE CASE CHECK CHECKPOINT CLOSE CLUSTERED
+          COALESCE COLLATE COLUMN COMMIT COMPUTE CONSTRAINT CONTAINS CONTAINSTABLE
+          CONTINUE CONVERT CREATE CROSS CURRENT CURRENT_DATE CURRENT_TIME
+          CURRENT_TIMESTAMP CURRENT_USER CURSOR DATABASE DBCC DEALLOCATE
+          DECLARE DEFAULT DELETE DENY DESC DISK DISTINCT DISTRIBUTED DOUBLE
+          DROP DUMMY DUMP ELSE END ERRLVL ESCAPE EXCEPT EXEC EXECUTE EXISTS
+          EXIT FETCH FILE FILLFACTOR FOR FOREIGN FREETEXT FREETEXTTABLE FROM
+          FULL FUNCTION GOTO GRANT GROUP HAVING HOLDLOCK IDENTITY IDENTITYCOL
+          IDENTITY_INSERT IF IN INDEX INNER INSERT INTERSECT INTO IS JOIN KEY
+          KILL LEFT LIKE LINENO LOAD NATIONAL NOCHECK NONCLUSTERED NOT NULL
+          NULLIF OF OFF OFFSETS ON OPEN OPENDATASOURCE OPENQUERY OPENROWSET
+          OPENXML OPTION OR ORDER OUTER OVER PERCENT PLAN PRECISION PRIMARY
+          PRINT PROC PROCEDURE PUBLIC RAISERROR READ READTEXT RECONFIGURE
+          REFERENCES REPLICATION RESTORE RESTRICT RETURN REVOKE RIGHT ROLLBACK
+          ROWCOUNT ROWGUIDCOL RULE SAVE SCHEMA SELECT SESSION_USER SET SETUSER
+          SHUTDOWN SOME STATISTICS SYSTEM_USER TABLE TEXTSIZE THEN TO TOP
+          TRAN TRANSACTION TRIGGER TRUNCATE TSEQUAL UNION UNIQUE UPDATE
+          UPDATETEXT USE USER VALUES VARYING VIEW WAITFOR WHEN WHERE WHILE
+          WITH WRITETEXT
+        }.inject({}){ |h,w| h[w] = true; h }
+
+        def initialize(vocabulary, *options)
+          @vocabulary = vocabulary
+          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+          @delay_fks = options.include? "delay_fks"
+          @underscore = options.include?("underscore") ? "_" : ""
+        end
+
+        def puts s
+          @out.puts s
+        end
+
+        def go s
+          puts s
+          puts "GO\n\n"
+        end
+
+        def escape s
+          # Escape SQL keywords and non-identifiers
+          s = s[0...120]
+          if s =~ /[^A-Za-z0-9_]/ || RESERVED_WORDS[s.upcase]
+            "[#{s}]"
+          else
+            s
+          end
+        end
+
+        # Return SQL type and (modified?) length for the passed base type
+        def normalise_type(type, length)
+          sql_type = case type
+            when /^Auto ?Counter$/
+              'int'
+
+            when /^Unsigned ?Integer$/,
+              /^Signed ?Integer$/,
+              /^Unsigned ?Small ?Integer$/,
+              /^Signed ?Small ?Integer$/,
+              /^Unsigned ?Tiny ?Integer$/
+              s = case
+                when length <= 8
+                  'tinyint'
+                when length <= 16
+                  'smallint'
+                when length <= 32
+                  'int'
+                else
+                  'bigint'
+                end
+              length = nil
+              s
+
+            when /^Decimal$/
+              'decimal'
+
+            when /^Fixed ?Length ?Text$/, /^Char$/
+              'char'
+            when /^Variable ?Length ?Text$/, /^String$/
+              'varchar'
+            when /^Large ?Length ?Text$/, /^Text$/
+              'text'
+
+            when /^Date ?And ?Time$/, /^Date ?Time$/
+              'datetime'
+            when /^Date$/
+              'datetime' # SQLSVR 2K5: 'date'
+            when /^Time$/
+              'datetime' # SQLSVR 2K5: 'time'
+            when /^Auto ?Time ?Stamp$/
+              'timestamp'
+
+            when /^Guid$/
+              'uniqueidentifier'
+            when /^Money$/
+              'decimal'
+            when /^Picture ?Raw ?Data$/, /^Image$/
+              'image'
+            when /^Variable ?Length ?Raw ?Data$/, /^Blob$/
+              'varbinary'
+            when /^BIT$/
+              'bit'
+            else type # raise "SQL type unknown for standard type #{type}"
+            end
+          [sql_type, length]
+        end
+
+      public
+        def generate(out = $>)      #:nodoc:
+          @out = out
+          #go "CREATE SCHEMA #{@vocabulary.name}"
+
+          tables_emitted = {}
+          delayed_foreign_keys = []
+
+          @vocabulary.tables.each do |table|
+            puts "CREATE TABLE #{escape table.name.gsub(' ',@underscore)} ("
+
+            pk = table.identifier_columns
+            identity_column = pk[0] if pk[0].is_auto_assigned
+
+            fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
+            fk_columns = table.columns.select do |column|
+              column.references[0].is_simple_reference
+            end
+
+            # We sort the columns here, not in the rmap layer, because it affects
+            # the ordering of columns in an index :-(.
+            columns = table.columns.sort_by { |column| column.name(@underscore) }.map do |column|
+              name = escape column.name(@underscore)
+              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
+              type, params, constraints = column.type
+              constraints = [] if (fk_columns.include?(column))  # Don't enforce VT constraints on FK columns
+              length = params[:length]
+              length &&= length.to_i
+              scale = params[:scale]
+              scale &&= scale.to_i
+              type, length = normalise_type(type, length)
+              sql_type = "#{type}#{
+                if !length
+                  ""
+                else
+                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
+                end
+                }"
+	      # Emit IDENTITY for auto-assigned columns, unless it's assigned at assert:
+              identity = column == identity_column && column.references[-1].to.transaction_phase != 'assert' ? " IDENTITY" : ""
+              null = (column.is_mandatory ? "NOT " : "") + "NULL"
+              check = check_clause(name, constraints)
+              comment = column.comment
+              [ "-- #{comment}", "#{name}#{padding}#{sql_type}#{identity} #{null}#{check}" ]
+            end.flatten
+
+            pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
+                pk.map{|column| escape column.name(@underscore)}*", " +
+                ")"
+
+            inline_fks = []
+            table.foreign_keys.each do |fk|
+              fk_text = "FOREIGN KEY (" +
+                fk.from_columns.map{|column| column.name(@underscore)}*", " +
+                ") REFERENCES #{escape fk.to.name.gsub(' ',@underscore)} (" +
+                fk.to_columns.map{|column| column.name(@underscore)}*", " +
+                ")"
+              if !@delay_fks and              # We don't want to delay all Fks
+                (tables_emitted[fk.to] or     # The target table has been emitted
+                fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
+                inline_fks << fk_text
+              else
+                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name.gsub(' ',@underscore)}\n\tADD " + fk_text)
+              end
+            end
+
+            indices = table.indices
+            inline_indices = []
+            delayed_indices = []
+            indices.each do |index|
+              next if index.over == table && index.is_primary   # Already did the primary keys
+              abbreviated_column_names = index.abbreviated_column_names(@underscore)*""
+              column_names = index.column_names(@underscore)
+              column_name_list = column_names.map{|n| escape(n)}*", "
+              if index.columns.all?{|column| column.is_mandatory}
+                inline_indices << "UNIQUE(#{column_name_list})"
+              else
+                view_name = escape "#{index.view_name}_#{abbreviated_column_names}"
+                delayed_indices <<
+%Q{CREATE VIEW dbo.#{view_name} (#{column_name_list}) WITH SCHEMABINDING AS
+\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name.gsub(' ',@underscore)}
+\tWHERE\t#{
+  index.columns.
+    select{|column| !column.is_mandatory }.
+    map{|column|
+      escape(column.name(@underscore)) + " IS NOT NULL"
+    }*"\n\t  AND\t"
+}
+GO
+
+CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.columns.map{|column| column.name(@underscore)}*", "})
+}
+              end
+            end
+
+            tables_emitted[table] = true
+
+            puts("\t" + (columns + [pk_def] + inline_indices + inline_fks)*",\n\t")
+            go ")"
+            delayed_indices.each {|index_text|
+              go index_text
+            }
+          end
+
+          delayed_foreign_keys.each do |fk|
+            go fk
+          end
+        end
+
+      private
+        def sql_value(value)
+          value.is_literal_string ? sql_string(value.literal) : value.literal
+        end
+
+        def sql_string(str)
+          "'" + str.gsub(/'/,"''") + "'"
+        end
+
+        def check_clause(column_name, constraints)
+          return "" if constraints.empty?
+          # REVISIT: Merge all constraints (later; now just use the first)
+          " CHECK(" +
+            constraints[0].all_allowed_range_sorted.map do |ar|
+              vr = ar.value_range
+              min = vr.minimum_bound
+              max = vr.maximum_bound
+              if (min && max && max.value.literal == min.value.literal)
+                "#{column_name} = #{sql_value(min.value)}"
+              else
+                inequalities = [
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{sql_value(min.value)}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{sql_value(max.value)}"
+                ].compact
+                inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
+              end
+            end*" OR " +
+          ")"
+        end
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('sql/server', ActiveFacts::Generators::SQL::SERVER)

data/lib/activefacts/generators/stats.rb

@@ -0,0 +1,70 @@
+#
+#       ActiveFacts Generators.
+#       Generate metamodel statistics fora compiled vocabulary
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/rmap'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --text <file>.cql
+    class Statistics
+    private
+      def initialize(vocabulary)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+      end
+
+    public
+      def generate(out = $>)
+	constellation = @vocabulary.constellation
+	object_types = constellation.ObjectType.values
+	fact_types = constellation.FactType.values
+
+	# All metamodel object types:
+	object_count = 0
+	populated_object_type_count = 0
+	fact_types_processed = {}
+	fact_count = 0
+	role_played_count = 0
+	constellation.vocabulary.object_type.map do |object_type_name, object_type|
+	  objects = constellation.send(object_type_name)
+	  next unless objects.size > 0
+	  puts "\t#{object_type_name}: #{objects.size} instances (which play #{object_type.all_role.size} roles)"
+	  populated_object_type_count += 1
+	  object_count += objects.size
+
+	  #puts "#{object_type_name} has #{object_type.all_role.size} roles"
+	  object_type.all_role.each do |name, role|
+	    next unless role.unique
+	    next if fact_types_processed[role.fact_type]
+	    next if role.fact_type.is_a?(ActiveFacts::API::TypeInheritanceFactType)
+	    role_population_count =
+	      objects.values.inject(0) do |count, object|
+		count += 1 if object.send(role.name) != nil
+		count
+	      end
+	    puts "\t\t#{object_type_name}.#{role.name} has #{role_population_count} instances" if role_population_count > 0
+	    fact_count += role_population_count
+	    role_played_count += role_population_count*role.fact_type.all_role.size
+
+	    fact_types_processed[role.fact_type] = true
+	  end
+
+	end
+	puts "#{@vocabulary.name} has"
+	puts "\t#{object_types.size} object types"
+	puts "\t#{fact_types.size} fact types"
+	puts "\tcompiles to #{object_count} objects in total, of #{populated_object_type_count} metamodel types"
+	puts "\tcompiles to #{fact_count} facts in total, of #{fact_types_processed.size} metamodel fact types"
+	puts "\tcompiles to #{role_played_count} role instances in total"
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('records', ActiveFacts::Generators::Statistics)

data/lib/activefacts/generators/text.rb

@@ -0,0 +1,29 @@
+#
+#       ActiveFacts Generators.
+#       Generate text output (verbalise the meta-vocabulary) for ActiveFacts vocabularies.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --text <file>.cql
+    class TEXT
+    private
+      def initialize(vocabulary)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+      end
+
+    public
+      def generate(out = $>)
+        out.puts @vocabulary.constellation.verbalise
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('text', ActiveFacts::Generators::TEXT)

data/lib/activefacts/generators/traits/datavault.rb

@@ -0,0 +1,241 @@
+#
+#	ActiveFacts Schema Transform
+#	Transform a loaded ActiveFacts vocabulary to suit ActiveRecord
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/generators/helpers/inject'
+
+module ActiveFacts
+  module Generators
+    module DataVaultTraits
+
+      module ObjectType
+
+	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
+	  # Find or assert the surrogate value type
+	  auto_counter = vocabulary.valid_value_type_name(type_name) ||
+	    constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
+
+	  # Create a subtype to identify this entity type:
+	  vt_name = self.name + ' '+suffix
+	  my_id = @vocabulary.valid_value_type_name(vt_name) ||
+	    constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
+
+	  # Create a fact type
+	  identifying_fact_type = constellation.FactType(:concept => :new)
+	  my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+	  self.injected_surrogate_role = my_role
+	  id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+
+	  # Create a reading (which needs a RoleSequence)
+	  reading = constellation.Reading(
+	    :fact_type => identifying_fact_type,
+	    :ordinal => 0,
+	    :role_sequence => [:new],
+	    :text => "{0} has {1}"
+	  )
+	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
+	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
+
+	  # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
+	  one_id = constellation.PresenceConstraint(
+	      :concept => :new,
+	      :vocabulary => vocabulary,
+	      :name => self.name+'HasOne'+suffix,
+	      :role_sequence => [:new],
+	      :is_mandatory => true,
+	      :min_frequency => 1,
+	      :max_frequency => 1,
+	      :is_preferred_identifier => false
+	    )
+	  @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
+
+	  one_me = constellation.PresenceConstraint(
+	      :concept => :new,
+	      :vocabulary => vocabulary,
+	      :name => self.name+suffix+'IsOfOne'+self.name,
+	      :role_sequence => [:new],
+	      :is_mandatory => false,
+	      :min_frequency => 0,
+	      :max_frequency => 1,
+	      :is_preferred_identifier => true
+	    )
+	  @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
+	end
+      end
+
+      module ValueType
+	def dv_needs_surrogate
+	  !is_auto_assigned
+	end
+
+	def dv_inject_surrogate
+	  trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
+	  add_surrogate('Auto Counter', 'ID')
+	end
+      end
+
+      module EntityType
+	def dv_identifying_refs_from
+	  pi = preferred_identifier
+	  rrs = pi.role_sequence.all_role_ref
+
+  #	  REVISIT: This is actually a ref to us, not from
+  #	  if absorbed_via
+  #	    return [absorbed_via]
+  #	  end
+
+	  rrs.map do |rr|
+	    r = references_from.detect{|ref| rr.role == ref.to_role }
+	    unless r
+	      debugger
+	      raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}"
+	    end
+	    r
+	  end
+	end
+
+	def dv_needs_surrogate
+
+	  # A recursive proc to replace any reference to an Entity Type by its identifying references:
+	  trace :transform_surrogate_expansion, "Expanding key for #{name}"
+	  substitute_identifying_refs = proc do |object|
+	    if ref = object.absorbed_via
+	      # This shouldn't be necessary, but see the absorbed_via comment above.
+	      absorbed_into = ref.from
+	      trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
+	      [substitute_identifying_refs.call(absorbed_into)]
+	    else
+	      irf = object.dv_identifying_refs_from
+	      trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
+		irf.each_with_index do |ref, i|
+		  next if ref.is_unary
+		  next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
+		  recurse_to = ref.to_role.object_type
+
+		  trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
+		    irf[i] = substitute_identifying_refs.call(recurse_to)
+		  end
+		end
+	      end
+	      irf
+	    end
+	  end
+	  irf = substitute_identifying_refs.call(self)
+
+	  trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
+
+	    pk_fks = dv_identifying_refs_from.map do |ref|
+	      ref.to && ref.to.is_table ? ref.to : nil
+	    end
+
+	    irf.flatten!
+
+	    # Multi-part identifiers are only allowed if:
+	    # * each part is a foreign key (i.e. it's a join table),
+	    # * there are no other columns (that might require updating) and
+	    # * the object is not the target of a foreign key:
+	    if irf.size >= 2
+	      if pk_fks.include?(nil)
+		trace :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
+		return true
+	      elsif references_to.size != 0
+		trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
+		return true
+	      elsif (references_from-dv_identifying_refs_from).size > 0
+		# There are other attributes to worry about
+		return true
+	      else
+		trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect}"
+		return false
+	      end
+	      return true
+	    end
+
+	    # Single-part key. It must be an Auto Counter, or we will add a surrogate
+
+	    identifying_type = irf[0].to
+	    if identifying_type.dv_needs_surrogate
+	      trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
+	      return true
+	    end
+
+	    false
+	  end
+	end
+
+	def dv_inject_surrogate
+	  trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
+
+	  # Disable the preferred identifier:
+	  pi = preferred_identifier
+	  trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
+	  pi.is_preferred_identifier = false
+	  @preferred_identifier = nil	# Kill the cache
+
+	  dv_add_surrogate
+
+	  trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
+	end
+
+	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
+	 # Find or assert the surrogate value type
+	 auto_counter = vocabulary.valid_value_type_name(type_name) ||
+	   constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
+
+	 # Create a subtype to identify this entity type:
+	 vt_name = self.name + ' '+suffix
+	 my_id = @vocabulary.valid_value_type_name(vt_name) ||
+	   constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
+
+	 # Create a fact type
+	 identifying_fact_type = constellation.FactType(:concept => :new)
+	 my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+	 @injected_surrogate_role = my_role
+	 id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+
+	 # Create a reading (which needs a RoleSequence)
+	 reading = constellation.Reading(
+	   :fact_type => identifying_fact_type,
+	   :ordinal => 0,
+	   :role_sequence => [:new],
+	   :text => "{0} has {1}"
+	 )
+	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
+	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
+
+	 # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
+	 one_id = constellation.PresenceConstraint(
+	     :concept => :new,
+	     :vocabulary => vocabulary,
+	     :name => self.name+'HasOne'+suffix,
+	     :role_sequence => [:new],
+	     :is_mandatory => true,
+	     :min_frequency => 1,
+	     :max_frequency => 1,
+	     :is_preferred_identifier => false
+	   )
+	 @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
+
+	 one_me = constellation.PresenceConstraint(
+	     :concept => :new,
+	     :vocabulary => vocabulary,
+	     :name => self.name+suffix+'IsOfOne'+self.name,
+	     :role_sequence => [:new],
+	     :is_mandatory => false,
+	     :min_frequency => 0,
+	     :max_frequency => 1,
+	     :is_preferred_identifier => true
+	   )
+	 @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
+
+	 return my_id
+	end
+
+      end
+
+      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
+    end
+  end
+end