activefacts 0.6.0 → 0.7.0

data/Manifest.txt

@@ -33,7 +33,6 @@ lib/activefacts/api/support.rb
 lib/activefacts/api/value.rb
 lib/activefacts/api/vocabulary.rb
 lib/activefacts/cql.rb
-lib/activefacts/cql/Rakefile
 lib/activefacts/cql/CQLParser.treetop
 lib/activefacts/cql/Concepts.treetop
 lib/activefacts/cql/DataTypes.treetop
@@ -41,11 +40,13 @@ lib/activefacts/cql/Expressions.treetop
 lib/activefacts/cql/FactTypes.treetop
 lib/activefacts/cql/Language/English.treetop
 lib/activefacts/cql/LexicalRules.treetop
+lib/activefacts/cql/Rakefile
 lib/activefacts/cql/parser.rb
 lib/activefacts/generate/absorption.rb
 lib/activefacts/generate/cql.rb
 lib/activefacts/generate/cql/html.rb
 lib/activefacts/generate/null.rb
+lib/activefacts/generate/oo.rb
 lib/activefacts/generate/ordered.rb
 lib/activefacts/generate/ruby.rb
 lib/activefacts/generate/sql/server.rb
@@ -53,7 +54,11 @@ lib/activefacts/generate/text.rb
 lib/activefacts/input/cql.rb
 lib/activefacts/input/orm.rb
 lib/activefacts/persistence.rb
-lib/activefacts/persistence/composition.rb
+lib/activefacts/persistence/columns.rb
+lib/activefacts/persistence/foreignkey.rb
+lib/activefacts/persistence/index.rb
+lib/activefacts/persistence/reference.rb
+lib/activefacts/persistence/tables.rb
 lib/activefacts/support.rb
 lib/activefacts/version.rb
 lib/activefacts/vocabulary.rb

data/examples/CQL/Address.cql

@@ -42,5 +42,3 @@ Person lives at at most one Address;
  */
 Street includes third-StreetLine
 	only if Street includes second-StreetLine;
-Street includes second-StreetLine
-	only if Street includes first-StreetLine;

data/examples/CQL/Blog.cql

@@ -27,14 +27,14 @@ Content is identified by Style and Text where
 	Content is of at most one Style,
 	Content has one Text,
 	Text is of Content;
-Content provides text of at most one Comment,
+Content provides text of Comment,
 	Comment consists of one text-Content;
 
 Post is identified by its Id;
 Post was written by one Author;
 Paragraph is where
 	Post includes Ordinal paragraph;
-Content is of at most one Paragraph,
+Content is of Paragraph,
 	Paragraph contains one Content;
 Paragraph has Comment,
 	Comment is on one Paragraph;

data/examples/CQL/CompanyDirectorEmployee.cql

@@ -1,4 +1,4 @@
-vocabulary CompanyDirector;
+vocabulary CompanyDirectorEmployee;
 
 /*
  * Value Types

data/examples/CQL/Death.cql

@@ -1,4 +1,4 @@
-vocabulary DeathAsUnary;
+vocabulary Death;
 
 /*
  * Value Types

data/examples/CQL/Metamodel.cql

@@ -16,10 +16,10 @@ Length is defined as UnsignedInteger(32);
 Name is defined as VariableLengthText(64);
 Numerator is defined as Decimal();
 Ordinal is defined as UnsignedSmallInteger(32);
-ReadingText is defined as VariableLengthText(256);
 RingType is defined as VariableLengthText();
 RoleSequenceId is defined as AutoCounter();
 Scale is defined as UnsignedInteger(32);
+Text is defined as VariableLengthText(256);
 UnitId is defined as AutoCounter();
 Value is defined as VariableLengthText(256);
 ValueRestrictionId is defined as AutoCounter();
@@ -60,9 +60,9 @@ PresenceConstraint is preferred identifier;
 Reading is identified by FactType and Ordinal where
 	FactType has at least one Reading,
 	Reading is for one FactType,
-	Reading is in at most one Ordinal position,
+	Reading is in one Ordinal position,
 	Ordinal reading for fact type is Reading;
-Reading has one ReadingText;
+Reading has one Text;
 
 RingConstraint is a kind of Constraint;
 RingConstraint is of one RingType;
@@ -89,9 +89,9 @@ Name is of Unit,
 	Unit is called one Name;
 Unit has at most one Coefficient;
 Unit is fundamental;
-UnitBasis is where
+Derivation is where
 	Unit (as DerivedUnit) is derived from base-Unit (as BaseUnit) [acyclic, intransitive];
-UnitBasis has at most one Exponent;
+Derivation has at most one Exponent;
 
 ValueRange is identified by minimum-Bound and maximum-Bound where
 	ValueRange has at most one minimum-Bound,

data/examples/CQL/MultiInheritance.cql

@@ -5,6 +5,7 @@ vocabulary MultiInheritance;
  */
 EmployeeID is defined as AutoCounter();
 PersonName is defined as VariableLengthText();
+TFN is defined as FixedLengthText(9);
 
 /*
  * Entity Types
@@ -12,6 +13,7 @@ PersonName is defined as VariableLengthText();
 Person is identified by its Name;
 
 Australian is a kind of Person;
+Australian has at most one TFN;
 
 Employee is a kind of Person identified by its ID;
 

data/examples/CQL/PersonPlaysGame.cql

@@ -1,4 +1,4 @@
-vocabulary AbsorbViaObjFact;
+vocabulary PersonPlaysGame;
 
 /*
  * Value Types

data/lib/activefacts/cql/Concepts.treetop

@@ -20,14 +20,30 @@ module ActiveFacts
         }
       end
 
+      rule basetype
+        is s
+	# independency?
+	identification
+        { def supers; [] end
+          def identifier; identification.value; end
+        }
+      end
+
       rule subtype
-        subtype_prefix supertype_list ident:identification?
+        subtype_prefix
+	# independency?
+	supertype_list ident:identification?
         {
           def supers; supertype_list.value; end
           def identifier; ident.empty? ? nil : ident.value; end
         }
       end
 
+      # REVISIT: This doesn't work, and I don't know why.
+      rule independency
+	 ('independent' S / 'separate' S / 'partitioned' S)
+      end
+
       rule supertype_list
         primary:id s
         alternate_supertypes:( ',' s !identified_by name:id s )*
@@ -37,13 +53,6 @@ module ActiveFacts
         }
       end
 
-      rule basetype
-        is s identification
-        { def supers; [] end
-          def identifier; identification.value; end
-        }
-      end
-
       rule identification
 	# REVISIT: Consider distinguishing "-Id" from just "Id", and not prepending the entity type name if no "-"
         identified_by its s id s	  # Reference Mode

data/lib/activefacts/cql/Language/English.treetop

@@ -3,8 +3,7 @@ module ActiveFacts
     grammar Language
 
       rule subtype_prefix
-        defined_as 'subtype' S 'of' S
-        / 'is' s 'a' s ('kind'/'subtype') s 'of' S
+        'is' s 'a' s ('kind'/'subtype') s 'of' S
       end
 
       rule defined_as

data/lib/activefacts/generate/absorption.rb

@@ -13,7 +13,7 @@ module ActiveFacts
 
       def initialize(vocabulary, *options)
         @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::Constellation === @vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
         @no_columns = options.include? "no_columns"
         @dependent = options.include? "dependent"
         @paths = options.include? "paths"

data/lib/activefacts/generate/null.rb

@@ -4,14 +4,21 @@
 # Copyright (c) 2007 Clifford Heath. Read the LICENSE file.
 # Author: Clifford Heath.
 #
+require 'activefacts/persistence'
+
 module ActiveFacts
   module Generate
     class NULL
-      def initialize(vocabulary)
+      def initialize(vocabulary, *options)
         @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+        @tables = options.include? "tables"
+        @columns = options.include? "columns"
+        @indices = options.include? "indices"
       end
 
       def generate(out = $>)
+        @vocabulary.tables if @tables || @columns || @indices
       end
     end
   end

data/lib/activefacts/generate/oo.rb

@@ -0,0 +1,174 @@
+#
+# OO Generation support for the ActiveFacts API from an ActiveFacts vocabulary.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/generate/ordered'
+
+module ActiveFacts
+
+  module Generate
+    class OO < OrderedDumper
+      include Metamodel
+
+      def constraints_dump(constraints_used)
+        # Stub, not needed.
+      end
+
+      def value_type_banner
+      end
+
+      def value_type_end
+      end
+
+      def roles_dump(o)
+        o.all_role.
+          sort_by{|role|
+            other_role = role.fact_type.all_role[role.fact_type.all_role[0] != role ? 0 : -1]
+            other_role ? preferred_role_name(other_role) : ""
+            #puts "\t#{role.fact_type.describe(other_role)} by #{p}"
+          }.each{|role| 
+            fact_type = role.fact_type
+            next if fact_type.all_role.size > 2
+            role_dump(role)
+          }
+      end
+
+      def role_dump(role)
+        fact_type = role.fact_type
+        if fact_type.all_role.size == 1
+          unary_dump(role, preferred_role_name(role))
+          return
+        elsif fact_type.all_role.size != 2
+          return  # ternaries and higher are always objectified
+        end
+
+        # REVISIT: TypeInheritance
+        if TypeInheritance === fact_type
+          # debug "Ignoring role #{role} in #{fact_type}, subtype fact type"
+          return
+        end
+
+        other_role_number = fact_type.all_role[0] == role ? 1 : 0
+        other_role = fact_type.all_role[other_role_number]
+        other_role_name = preferred_role_name(other_role)
+        other_player = other_role.concept
+
+        # Find any uniqueness constraint over this role:
+        fact_constraints = @presence_constraints_by_fact[fact_type]
+        #debug "Considering #{fact_constraints.size} fact constraints over fact role #{role.concept.name}"
+        ucs = fact_constraints.select{|c| PresenceConstraint === c && c.max_frequency == 1 }
+        # Emit "has_one/one_to_one..." only for functional roles here:
+        #debug "Considering #{ucs.size} unique constraints over role #{role.concept.name}"
+        unless ucs.find {|c|
+              roles = c.role_sequence.all_role_ref.map(&:role)
+              #debug "Unique constraint over role #{role.concept.name} has roles #{roles.map{|r| describe_fact_type(r.fact_type, r)}*", "}"
+              roles == [role]
+          }
+          #debug "No uniqueness constraint found for #{role} in #{fact_type}"
+          return
+        end
+
+        if ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] } &&
+            !@concept_types_dumped[other_role.concept]
+          #debug "Will dump 1:1 later for #{role} in #{fact_type}"
+          return
+        end
+
+        # It's a one_to_one if there's a uniqueness constraint on the other role:
+        one_to_one = ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] }
+
+        # Find role name:
+        role_method = preferred_role_name(role)
+        by = other_role_name != other_player.name.snakecase ? "_by_#{other_role_name}" : ""
+        other_role_method = one_to_one ? role_method : "all_"+role_method
+        other_role_method += by
+
+        role_name = role_method
+        role_name = nil if role_name == role.concept.name.snakecase
+
+        binary_dump(role, other_role_name, other_player, one_to_one, nil, role_name, other_role_method)
+      end
+
+      def preferred_role_name(role)
+        return "" if TypeInheritance === role.fact_type
+        # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
+        reading = role.fact_type.preferred_reading
+        preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
+            reading_rr.role == role
+          }
+
+        # Unaries are a hack, with only one role for what is effectively a binary:
+        if (role.fact_type.all_role.size == 1)
+          return (role.role_name && role.role_name.snakecase) ||
+            reading.reading_text.gsub(/ *\{0\} */,'').gsub(' ','_').downcase
+        end
+
+        # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.concept.name}, trailing_adjective=#{p.trailing_adjective}"
+        role_words = []
+        role_name = role.role_name
+        role_name = nil if role_name == ""
+
+        # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
+        la = preferred_role_ref.leading_adjective
+        role_words << la.gsub(/ /,'_') if la && la != "" and !role.role_name
+
+        role_words << (role_name || role.concept.name)
+        # REVISIT: Same when trailing_adjective is a suffix of the role_name
+        ta = preferred_role_ref.trailing_adjective
+        role_words << ta.gsub(/ /,'_') if ta && ta != "" and !role_name
+        n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
+        # debug "\tresult=#{n}"
+        n
+      end
+
+      def skip_fact_type(f)
+        # REVISIT: There might be constraints we have to merge into the nested entity or subtype.  These will come up as un-handled constraints.
+        !f.entity_type ||
+          TypeInheritance === f
+      end
+
+      # An objectified fact type has internal roles that are always "has_one":
+      def fact_roles_dump(fact)
+        fact.all_role.sort_by{|role|
+            preferred_role_name(role)
+          }.each{|role| 
+            role_name = preferred_role_name(role)
+            by = role_name != role.concept.name.snakecase ? "_by_#{role_name}" : ""
+            raise "Fact #{fact.describe} type is not objectified" unless fact.entity_type
+            other_role_method = "all_"+fact.entity_type.name.snakecase+by
+            binary_dump(role, role_name, role.concept, false, nil, nil, other_role_method)
+          }
+      end
+
+      def entity_type_banner
+      end
+
+      def entity_type_group_end
+      end
+
+      def append_ring_to_reading(reading, ring)
+        # REVISIT: debug "Should override append_ring_to_reading"
+      end
+
+      def fact_type_banner
+      end
+
+      def fact_type_end
+      end
+
+      def constraint_banner
+        # debug "Should override constraint_banner"
+      end
+
+      def constraint_end
+        # debug "Should override constraint_end"
+      end
+
+      def constraint_dump(c)
+        # debug "Should override constraint_dump"
+      end
+
+    end
+  end
+end

data/lib/activefacts/generate/ruby.rb

@@ -3,17 +3,20 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/vocabulary'
-require 'activefacts/generate/ordered'
+require 'activefacts/generate/oo'
 
 module ActiveFacts
 
   module Generate
-    class RUBY < OrderedDumper
-      include Metamodel
+    class RUBY < OO
 
       def set_option(option)
         @sql ||= false
         case option
+        when 'help', '?'
+          $stderr.puts "Usage:\t\tafgen --ruby[=option,option] input_file.cql\n"+
+              "options:\tsql\tEmit data to enable mappings to SQL"
+          exit 0
         when 'sql'; @sql = true
         else super
         end
@@ -28,20 +31,10 @@ module ActiveFacts
         puts "module #{vocabulary.name}\n\n"
       end
 
-      def constraints_dump(constraints_used)
-        # Stub, not needed.
-      end
-
       def vocabulary_end
         puts "end"
       end
 
-      def value_type_banner
-      end
-
-      def value_type_end
-      end
-
       def value_type_dump(o)
         return if !o.supertype
         if o.name == o.supertype.name
@@ -69,124 +62,6 @@ module ActiveFacts
         puts "  end\n\n"
       end
 
-      def roles_dump(o)
-        ar_by_role = nil
-        if @sql and @tables.include?(o)
-          ar = o.absorbed_roles
-          ar_by_role = ar.all_role_ref.inject({}){|h,rr|
-            input_role = (j=rr.all_join_path).size > 0 ? j[0].input_role : rr.role
-            (h[input_role] ||= []) << rr
-            h
-          }
-          #puts ar.all_role_ref.map{|rr| "\t"+rr.describe}*"\n"
-        end
-        o.all_role.
-          sort_by{|role|
-            other_role = role.fact_type.all_role[role.fact_type.all_role[0] != role ? 0 : -1]
-            other_role ? preferred_role_name(other_role) : ""
-            #puts "\t#{role.fact_type.describe(other_role)} by #{p}"
-          }.each{|role| 
-            other_role = role.fact_type.all_role[role.fact_type.all_role[0] != role ? 0 : -1]
-            if ar_by_role and ar_by_role[other_role]
-              puts "    # role #{role.fact_type.describe(role)}: absorbs in through #{preferred_role_name(other_role)}: "+ar_by_role[other_role].map(&:column_name)*", "
-            end
-            role_dump(role)
-          }
-      end
-
-      def preferred_role_name(role)
-        return "" if TypeInheritance === role.fact_type
-        # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
-        reading = role.fact_type.preferred_reading
-        preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
-            reading_rr.role == role
-          }
-
-        # Unaries are a hack, with only one role for what is effectively a binary:
-        if (role.fact_type.all_role.size == 1)
-          return (role.role_name && role.role_name.snakecase) ||
-            reading.reading_text.gsub(/ *\{0\} */,'').gsub(' ','_').downcase
-        end
-
-        # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.concept.name}, trailing_adjective=#{p.trailing_adjective}"
-        role_words = []
-        role_name = role.role_name
-        role_name = nil if role_name == ""
-
-        # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
-        la = preferred_role_ref.leading_adjective
-        role_words << la.gsub(/ /,'_') if la && la != "" and !role.role_name
-
-        role_words << (role_name || role.concept.name)
-        # REVISIT: Same when trailing_adjective is a suffix of the role_name
-        ta = preferred_role_ref.trailing_adjective
-        role_words << ta.gsub(/ /,'_') if ta && ta != "" and !role_name
-        n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
-        # debug "\tresult=#{n}"
-        n
-      end
-
-      def role_dump(role)
-        fact_type = role.fact_type
-        if fact_type.all_role.size == 1
-          # Handle Unary Roles here
-          puts "    maybe :"+preferred_role_name(role)
-          return
-        elsif fact_type.all_role.size != 2
-          return  # ternaries and higher are always objectified
-        end
-
-        # REVISIT: TypeInheritance
-        if TypeInheritance === fact_type
-          # debug "Ignoring role #{role} in #{fact_type}, subtype fact type"
-          return
-        end
-
-        other_role_number = fact_type.all_role[0] == role ? 1 : 0
-        other_role = fact_type.all_role[other_role_number]
-        other_role_name = preferred_role_name(other_role)
-        #other_role_name = ruby_role_name(other_role)
-        other_player = other_role.concept
-
-        # Find any uniqueness constraint over this role:
-        fact_constraints = @presence_constraints_by_fact[fact_type]
-        #debug "Considering #{fact_constraints.size} fact constraints over fact role #{role.concept.name}"
-        ucs = fact_constraints.select{|c| PresenceConstraint === c && c.max_frequency == 1 }
-        # Emit "has_one/one_to_one..." only for functional roles here:
-        #debug "Considering #{ucs.size} unique constraints over role #{role.concept.name}"
-        unless ucs.find {|c|
-              roles = c.role_sequence.all_role_ref.map(&:role)
-              #debug "Unique constraint over role #{role.concept.name} has roles #{roles.map{|r| describe_fact_type(r.fact_type, r)}*", "}"
-              roles == [role]
-          }
-          #debug "No uniqueness constraint found for #{role} in #{fact_type}"
-          return
-        end
-
-        if ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] } &&
-            !@concept_types_dumped[other_role.concept]
-          #debug "Will dump 1:1 later for #{role} in #{fact_type}"
-          return
-        end
-
-        # It's a one_to_one if there's a uniqueness constraint on the other role:
-        one_to_one = ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] }
-
-        # REVISIT: Add readings
-
-        # Find role name:
-        role_method = preferred_role_name(role)
-        by = other_role_name != other_player.name.snakecase ? "_by_#{other_role_name}" : ""
-        other_role_method = one_to_one ? role_method : "all_"+role_method
-        other_role_method += by
-
-        role_name = role_method
-        role_name = nil if role_name == role.concept.name.snakecase
-
-        binary_dump(other_role_name, other_player, one_to_one, nil, role_name, other_role_method)
-        puts "    \# REVISIT: #{other_role_name} has restricted values\n" if role.role_value_restriction
-      end
-
       def subtype_dump(o, supertypes, pi = nil)
         puts "  class #{o.name} < #{ supertypes[0].name }"
         puts "    identified_by #{identified_by(o, pi)}" if pi
@@ -207,54 +82,10 @@ module ActiveFacts
         @constraints_used[pi] = true
       end
 
-      def skip_fact_type(f)
-        # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
-        # These will come up as un-handled constraints:
-        #debug "Skipping objectified fact type #{f.entity_type.name}" if f.entity_type
-        #f.entity_type ||
-          TypeInheritance === f
-      end
-
-      # An objectified fact type has internal roles that are always "has_one":
-      def fact_roles_dump(fact)
-        fact.all_role.sort_by{|role|
-            preferred_role_name(role)
-          }.each{|role| 
-            role_name = preferred_role_name(role)
-            by = role_name != role.concept.name.snakecase ? "_by_#{role_name}" : ""
-            raise "Fact #{fact.describe} type is not objectified" unless fact.entity_type
-            other_role_method = "all_"+fact.entity_type.name.snakecase+by
-            binary_dump(role_name, role.concept, false, nil, nil, other_role_method)
-          }
-      end
-
-      def binary_dump(role_name, role_player, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
-        # Find whether we need the name of the other role player, and whether it's defined yet:
-        if role_name.camelcase(true) == role_player.name
-          # Don't use Class name if implied by rolename
-          role_reference = nil
-        elsif !@concept_types_dumped[role_player]
-          role_reference = '"'+role_player.name+'"'
-        else
-          role_reference = role_player.name
-        end
-        other_role_name = ":"+other_role_name if other_role_name
-
-        line = "    #{one_to_one ? "one_to_one" : "has_one" } " +
-                [ ":"+role_name,
-                  role_reference,
-                  readings,
-                  other_role_name
-                ].compact*", "+"  "
-        line += " "*(48-line.length) if line.length < 48
-        line += "\# See #{role_player.name}.#{other_method_name}" if other_method_name
-        puts line
-      end
-
       # Dump one fact type.
-      # Include as many as possible internal constraints in the fact type readings.
       def fact_type_dump(fact_type, name)
-        return if skip_fact_type(fact_type) || !(o = fact_type.entity_type)
+        return if skip_fact_type(fact_type)
+        o = fact_type.entity_type
 
         primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
         secondary_supertypes = o.supertypes-[primary_supertype]
@@ -275,52 +106,62 @@ module ActiveFacts
         @fact_types_dumped[fact_type] = true
       end
 
-      def ruby_role_name(role_name)
-        if Role === role_name
-          role_name = role_name.role_name || role_name.concept.name
-        end
-        role_name.snakecase.gsub("-",'_')
-      end
-
       def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
         identifying_roles.map{|role|
             ":"+preferred_role_name(role)
           }*", "
       end
 
-      def show_role(r)
-        puts "Role player #{r.concept.name} facttype #{r.fact_type.name} lead_adj #{r.leading_adjective} trail_adj #{r.trailing_adjective} allows #{r.allowed_values.inspect}"
-      end
-
-      def entity_type_banner
-      end
-
-      def entity_type_group_end
-      end
-
-      def append_ring_to_reading(reading, ring)
-        # REVISIT: debug "Should override append_ring_to_reading"
-      end
-
-      def fact_type_banner
+      def roles_dump(o)
+        @ar_by_role = nil
+        if @sql and @tables.include?(o)
+          ar = o.absorbed_roles
+          @ar_by_role = ar.all_role_ref.inject({}){|h,rr|
+            input_role = (j=rr.all_join_path).size > 0 ? j[0].input_role : rr.role
+            (h[input_role] ||= []) << rr
+            h
+          }
+          #puts ar.all_role_ref.map{|rr| "\t"+rr.describe}*"\n"
+        end
+        super
       end
 
-      def fact_type_end
+      def unary_dump(role, role_name)
+        puts "    maybe :"+role_name
       end
 
-      def constraint_banner
-        # debug "Should override constraint_banner"
+      def role_dump(role)
+        other_role = role.fact_type.all_role[role.fact_type.all_role[0] != role ? 0 : -1]
+        if @ar_by_role and @ar_by_role[other_role] and @sql
+          puts "    # role #{role.fact_type.describe(role)}: absorbs in through #{preferred_role_name(other_role)}: "+@ar_by_role[other_role].map(&:column_name)*", "
+        end
+        super
       end
 
-      def constraint_end
-        # debug "Should override constraint_end"
-      end
+      def binary_dump(role, role_name, role_player, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
+        # Find whether we need the name of the other role player, and whether it's defined yet:
+        if role_name.camelcase(true) == role_player.name
+          # Don't use Class name if implied by rolename
+          role_reference = nil
+        elsif !@concept_types_dumped[role_player]
+          role_reference = '"'+role_player.name+'"'
+        else
+          role_reference = role_player.name
+        end
+        other_role_name = ":"+other_role_name if other_role_name
 
-      def constraint_dump(c)
-        # debug "Should override constraint_dump"
+        line = "    #{one_to_one ? "one_to_one" : "has_one" } " +
+                [ ":"+role_name,
+                  role_reference,
+                  readings,
+                  other_role_name
+                ].compact*", "+"  "
+        line += " "*(48-line.length) if line.length < 48
+        line += "\# See #{role_player.name}.#{other_method_name}" if other_method_name
+        puts line
+        puts "    \# REVISIT: #{other_role_name} has restricted values\n" if role.role_value_restriction
       end
 
     end
-
   end
 end