activefacts 1.1.0 → 1.2.0

data/lib/activefacts/cql/compiler/fact_type.rb

@@ -12,6 +12,20 @@ module ActiveFacts
           @returning = returning || []
         end
 
+	def to_s
+	  inspect
+	end
+
+        def inspect
+          "Query: " +
+	    if @conditions.empty?
+	      ''
+	    else
+	      'where ' + @conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.inspect}*' '
+	    end
+          # REVISIT: @returning = returning
+        end
+
         def prepare_roles clauses = nil
           trace :binding, "preparing roles" do
             @context ||= CompilationContext.new(@vocabulary)
@@ -27,8 +41,8 @@ module ActiveFacts
           match_condition_fact_types
 
           # Build the query:
-          unless @conditions.empty? and !@returning
-            trace :query, "building query for derived fact type" do
+          unless @conditions.empty? and @returning.empty?
+            trace :query, "building query for derived fact type (returning #{@returning}) with #{@conditions.size} conditions: (#{@conditions.map{|c|c.inspect}*', '})" do
               @query = build_variables(@conditions.flatten)
               @roles_by_binding = build_all_steps(@conditions)
               @query.validate
@@ -41,12 +55,10 @@ module ActiveFacts
 
         def match_condition_fact_types
           @conditions.each do |condition|
-            next if condition.is_naked_object_type
-            # REVISIT: Many conditions will imply a number of different steps, which need to be handled (similar to nested_clauses).
-            trace :projection, "matching condition fact_type #{condition.inspect}" do
-              fact_type = condition.match_existing_fact_type @context
-              raise "Unrecognised fact type #{condition.inspect} in #{self.class}" unless fact_type
-            end
+	    trace :projection, "matching condition fact_type #{condition.inspect}" do
+	      fact_type = condition.match_existing_fact_type @context
+	      raise "Unrecognised fact type #{condition.inspect} in #{self.class}" unless fact_type
+	    end
           end
         end
 
@@ -105,8 +117,6 @@ module ActiveFacts
           # REVISIT: Compiling the conditions here make it impossible to define a self-referential (transitive) query.
           return super if @clauses.empty?  # It's a query
 
-          # Ignore any useless clauses:
-          @clauses.reject!{|clause| clause.is_existential_type }
           return true unless @clauses.size > 0   # Nothing interesting was said.
 
 	  if @entity_type
@@ -396,16 +406,9 @@ module ActiveFacts
           end
         end
 
-        def to_s
-          if @conditions.size > 0
-            true
-          end
-          "FactType: #{(s = super and !s.empty?) ? "#{s} " : '' }#{@clauses.inspect}" +
-            if @conditions && !@conditions.empty?
-              " where "+@conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.to_s}*' '
-            else
-              ''
-            end +
+        def inspect
+	  s = super
+          "FactType: #{@conditions.size > 0 ? super+' ' : '' }#{@clauses.inspect}" +
             (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.flatten.sort*','}]" : '')
 
           # REVISIT: @returning = returning

data/lib/activefacts/cql/compiler/query.rb

@@ -27,139 +27,67 @@ module ActiveFacts
           roles_by_binding = {}
           trace :query, "Building steps" do
             clauses_list.each do |clause|
-              next if clause.is_naked_object_type
-              build_steps(clause, roles_by_binding)
+              build_step(clause, roles_by_binding)
             end
           end
           roles_by_binding
         end
 
-        def build_steps clause, roles_by_binding = {}, objectification_node = nil
-          plays = []
-          incidental_roles = []
-          trace :query, "Creating Role Sequence for #{clause.inspect} with #{clause.refs.size} role refs" do
-            objectification_step = nil
-            clause.refs.each do |ref|
-              # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
-              # but we need to create Plays for those roles.
-              # REVISIT: Plays may need to save residual_adjectives
-              binding = ref.binding
-              role = (ref && ref.role) || (ref.role_ref && ref.role_ref.role)
-              play = nil
+        def build_step clause, roles_by_binding = {}, parent_variable = nil
+	  return unless clause.refs.size > 0  # Empty clause... really?
 
-              debugger unless clause.fact_type
-              if (clause.fact_type.entity_type)
-                # This clause is of an objectified fact type.
-                # We need a step from this role to the phantom role, but not
-                # for a role that has only one ref (this one) in their binding.
-                # Create the Variable and Play in any case though.
-                refs_count = binding.refs.size
-                objectification_ref_count = 0
-                if ref.nested_clauses
-                  ref.nested_clauses.each do |ojc|
-                    objectification_ref_count += ojc.refs.select{|ref| ref.binding.refs.size > 1}.size
-                  end
-                end
-                refs_count += objectification_ref_count
+	  step = @constellation.Step(
+	      :guid => :new,
+	      :fact_type => clause.fact_type,
+	      :alternative_set => nil,
+	      :is_disallowed => clause.certainty == false,
+	      :is_optional => clause.certainty == nil
+	    )
 
-                trace :query, "Creating Variable #{ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Step for #{ref.inspect}" do
+	  trace :query, "Creating Plays for #{clause.inspect} with #{clause.refs.size} refs" do
+	    is_input = true
+	    clause.refs.each do |ref|
+	      # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
+	      # but we need to create Plays for those roles.
+	      # REVISIT: Plays may need to save residual_adjectives
+	      binding = ref.binding
+	      role = (ref && ref.role) || (ref.role_ref && ref.role_ref.role)
 
-                  raise "Internal error: Trying to add role of #{role.object_type.name} to variable for #{binding.variable.object_type.name}" unless binding.variable.object_type == role.object_type
-                  play = @constellation.Play(binding.variable, role)
+	      objectification_step = nil
+	      if ref.nested_clauses
+		ref.nested_clauses.each do |nested_clause|
+		  objectification_step = build_step nested_clause, roles_by_binding
+		  if ref.binding.player.is_a?(ActiveFacts::Metamodel::EntityType) and
+		      ref.binding.player.fact_type == nested_clause.fact_type
+		    objectification_step.objectification_variable = binding.variable
+		  end
+		end
+	      end
+	      if clause.is_naked_object_type
+		raise "#{self} lacks a proper objectification" if clause.refs[0].nested_clauses and !objectification_step
+		return objectification_step
+	      end
 
-                  if (refs_count <= 1)   # Our work here is done if there are no other refs
-                    if objectification_step
-                      play.step = objectification_step
-                    else
-                      incidental_roles << play
-                    end
-                    next
-                  end
+	      if binding.variable.object_type != role.object_type	  # Type mismatch
+		if binding.variable.object_type.common_supertype(role.object_type)
+		  # REVISIT: there's an implicit subtyping step here, create it; then always raise the error here.
+		  # I don't want to do this for now because the verbaliser will always verbalise all steps.
+		  raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+		end
+		raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+	      end
 
-                  plays << play
-                  unless objectification_node
-                    # This is an implicit objectification, just the FT clause, not ET(where ...clause...)
-                    # We need to create a Variable for this object, even though it has no References
-                    query = binding.variable.query
-                    trace :query, "Creating JN#{query.all_variable.size} for #{clause.fact_type.entity_type.name} in objectification"
-                    objectification_node = @constellation.Variable(query, query.all_variable.size, :object_type => clause.fact_type.entity_type)
-                  end
-                  raise "Internal error: Trying to add role of #{role.link_fact_type.all_role.single.object_type.name} to variable for #{objectification_node.object_type.name}" unless objectification_node.object_type == role.link_fact_type.all_role.single.object_type
+	      trace :query, "Creating Play for #{ref.inspect}"
+	      play = @constellation.Play(:step => step, :role => role, :variable => binding.variable)
+	      play.is_input = is_input
+	      is_input = false
 
-                  irole = role.link_fact_type.all_role.single
-                  raise "Internal error: Trying to add role of #{irole.object_type.name} to variable for #{objectification_node.object_type.name}" unless objectification_node.object_type == irole.object_type
-                  objectification_role = @constellation.Play(objectification_node, role.link_fact_type.all_role.single)
-                  objectification_step = @constellation.Step(
-		      objectification_role,
-		      play,
-		      :fact_type => role.link_fact_type,
-		      :is_optional => false,
-		      :is_disallowed => clause.certainty == false
-		    )
-		  if clause.certainty == nil
-		    objectification_step.is_optional = true
-		  end
-                  trace :query, "New #{objectification_step.describe}"
-                  trace :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
-                  incidental_roles.each { |jr| jr.step = objectification_step }
-                  incidental_roles = []
-                  plays = []
-                end
-              else
-                trace :query, "Creating Reference for #{ref.inspect}" do
-                    # REVISIT: If there's an implicit subtyping step here, create it; then always raise the error here.
-                    # I don't want to do this for now because the verbaliser will always verbalise all steps.
-                  if binding.variable.object_type != role.object_type and
-                    0 == (binding.variable.object_type.supertypes_transitive & role.object_type.supertypes_transitive).size
-                    raise "Internal error: Trying to add role of #{role.object_type.name} to variable #{binding.variable.ordinal} for #{binding.variable.object_type.name} in '#{clause.fact_type.default_reading}'"
-                  end
-                  raise "Internal error: Trying to add role of #{role.object_type.name} to variable #{binding.variable.ordinal} for #{binding.variable.object_type.name}" unless binding.variable.object_type == role.object_type
-                  begin
-                    play = @constellation.Play(binding.variable, role)
-                  rescue ArgumentError => e
-                    play = @constellation.Play(binding.variable, role)
-                  end
-                  plays << play
-                end
-              end
+	      roles_by_binding[binding] = [role, play]
+	    end
+	  end
 
-              if ref.nested_clauses
-                # We are looking at a role whose player is an objectification of a fact type,
-                # which will have ImplicitFactTypes for each role.
-                # Each of these ImplicitFactTypes has a single phantom role played by the objectifying entity type
-                # One of these phantom roles is likely to be the subject of an objectification step.
-                ref.nested_clauses.each do |r|
-                  trace :query, "Building objectification step for #{ref.nested_clauses.inspect}" do
-                    build_steps r, roles_by_binding, binding.variable
-                  end
-                end
-              end
-              roles_by_binding[binding] = [role, play]
-            end
-          end
-
-          if plays.size > 0
-            end_node = plays[-1].variable
-            if !clause.fact_type.entity_type and role = clause.fact_type.all_role.single
-              # Don't give the ImplicitBoolean a variable. We can live without one, for now.
-              # The Step will have a duplicate node, and the fact type will tell us what's happening
-              plays << plays[0]
-            end
-            # We aren't talking about objectification here, so there must be exactly two roles.
-            raise "REVISIT: Internal error constructing step for #{clause.inspect}" if plays.size != 2
-            js = @constellation.Step(
-		plays[0],
-		plays[1],
-		:fact_type => clause.fact_type,
-		:is_disallowed => clause.certainty == false,
-		:is_optional => clause.certainty == nil
-	      )
-            trace :query, "New #{js.describe}"
-            trace :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
-            incidental_roles.each { |jr| jr.step = js }
-          end
-          roles_by_binding
-        end
+	  step
+	end
 
         # Return the unique array of all bindings in these clauses, including in objectification steps
         def all_bindings_in_clauses clauses

data/lib/activefacts/cql/compiler/shared.rb

@@ -15,7 +15,7 @@ module ActiveFacts
         attr_reader :refs               # an array of the References
         attr_reader :role_name
         attr_accessor :rebound_to       # Loose binding may set this to another binding
-        attr_accessor :variable
+        attr_reader :variable
         attr_accessor :instance         # When binding fact instances, the instance goes here
 
         def initialize player, role_name = nil
@@ -35,6 +35,10 @@ module ActiveFacts
         def <=>(other)
           key <=> other.key
         end
+        
+	def variable= v
+	  @variable = v	  # A place for a breakpoint :)
+	end
 
 	def add_ref ref
 	  @refs << ref

data/lib/activefacts/cql/compiler/value_type.rb

@@ -87,7 +87,7 @@ module ActiveFacts
       end
 
       class ValueType < ObjectType
-        def initialize name, base, parameters, unit, value_constraint, pragmas, context_note
+        def initialize name, base, parameters, unit, value_constraint, pragmas, context_note, auto_assigned_at
           super name
           @base_type_name = base
           @parameters = parameters
@@ -95,6 +95,7 @@ module ActiveFacts
           @value_constraint = value_constraint
           @pragmas = pragmas
 	  @context_note = context_note
+	  @auto_assigned_at = auto_assigned_at
         end
 
         def compile
@@ -116,11 +117,12 @@ module ActiveFacts
           vt.supertype = base_type if base_type
           vt.length = length if length
           vt.scale = scale if scale
+          vt.transaction_phase = @auto_assigned_at
 
           unless @unit.empty?
             unit_name, exponent = *@unit[0]
             unit = @constellation.Name[unit_name].unit ||
-              @constellation.Name[unit_name].unit_as_plural_name
+              @constellation.Name[unit_name].plural_named_unit
             raise "Unit #{unit_name} for value type #{@name} is not defined" unless unit
             if exponent != 1
               base_unit = unit

data/lib/activefacts/generate/rails/schema.rb

@@ -30,7 +30,7 @@ module ActiveFacts
 	def help
 	  @helping = true
 	  warn %Q{Options for --rails/schema:
-	exclude_fks		Don't generate foreign key definitions for use with the foreigner gem
+	exclude_fks		Don't generate foreign key definitions for use with Rails 4 or the foreigner gem
 	include_comments	Generate a comment for each column showing the absorption path
 	closed_world		Set this if your DBMS only allows one null in a unique index (MS SQL)
 }
@@ -45,128 +45,158 @@ module ActiveFacts
 	end
 
       public
-	def generate(out = $>)      #:nodoc:
-	  return if @helping
-	  @out = out
 
-	  foreign_keys = []
+	# We sort the columns here, not in the persistence layer, because it affects
+	# the ordering of columns in an index :-(.
+	def sorted_columns table, pk, fk_columns
+	  table.columns.sort_by do |column|
+	    [ # Emit columns alphabetically, but PK first, then FKs, then others
+	      case
+	      when i = pk.index(column)
+		i
+	      when fk_columns.include?(column)
+		pk.size+1
+	      else
+		pk.size+2
+	      end,
+	      column.rails_name
+	    ]
+	  end
+	end
 
-	  # If we get index names that need to be truncated, add a counter to ensure uniqueness
-	  dup_id = 0
+	def generate_column table, pk, column
+	  name = column.rails_name
+	  type, params, constraints = *column.type
+	  length = params[:length]
+	  length &&= length.to_i
+	  scale = params[:scale]
+	  scale &&= scale.to_i
+	  rails_type, length = *column.rails_type
+ 
+	  length_name = rails_type == 'decimal' ? 'precision' : 'limit'
+	  length_option = length ? ", :#{length_name} => #{length}" : ''
+	  scale_option = scale ? ", :scale => #{scale}" : ''
+
+	  comment = column.comment
+	  null_option = ", :null => #{!column.is_mandatory}"
+	  if pk.size == 1 && pk[0] == column
+	    case rails_type
+	    when 'serial'
+	      rails_type = "primary_key"
+	    when 'uuid'
+	      rails_type = "uuid, :default => 'gen_random_uuid()', :primary_key => true"
+	    end
+	  else
+	    case rails_type
+	    when 'serial'
+	      rails_type = 'integer'	    # An integer foreign key
+	    end
+	  end
 
-	  puts "#\n# schema.rb auto-generated using ActiveFacts for #{@vocabulary.name} on #{Date.today}\n#\n\n"
-	  puts "ActiveRecord::Schema.define(:version => #{Time.now.strftime('%Y%m%d%H%M%S')}) do"
+	  (@include_comments ? ["    \# #{comment}"] : []) +
+	  [
+	    %Q{    t.column "#{name}", :#{rails_type}#{length_option}#{scale_option}#{null_option}}
+	  ]
+	end
 
-	  @vocabulary.tables.each do |table|
-	    ar_table_name = table.rails_name
+	def generate_columns table, pk, fk_columns
+	  sc = sorted_columns(table, pk, fk_columns)
+	  lines = sc.map do |column|
+	    generate_column table, pk, column
+	  end
+	  lines.flatten
+	end
 
-	    pk = table.identifier_columns
-	    identity_column = pk[0] if pk[0].is_auto_assigned
+	def generate_table table, foreign_keys
+	  ar_table_name = table.rails_name
+
+	  pk = table.identifier_columns
+	  if pk[0].is_auto_assigned
+	    identity_column = pk[0]
+	    warn "Warning: redundant column(s) after #{identity_column.name} in primary key of #{ar_table_name}" if pk.size > 1
+	  end
+
+	  # Get the list of references that give rise to foreign keys:
+	  fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
+
+	  # Get the list of columns that embody the foreign keys:
+	  fk_columns = table.columns.select do |column|
+	    column.references[0].is_simple_reference
+	  end
 
-	    fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-	    fk_columns = table.columns.select do |column|
-	      column.references[0].is_simple_reference
+	  # Detect if this table is a join table.
+	  # Join tables have multi-part primary keys that are made up only of foreign keys
+	  is_join_table = pk.length > 1 and
+	    !pk.detect do |pk_column|
+	      !fk_columns.include?(pk_column)
 	    end
+	  warn "Warning: #{table.name} has a multi-part primary key" if pk.length > 1 and !is_join_table
 
-	    # Detect if this table is a join table.
-	    # Join tables have multi-part primary keys that are made up only of foreign keys
-	    is_join_table = pk.length > 1 and
-	      !pk.detect do |pk_column|
-		!fk_columns.include?(pk_column)
-	      end
-	    warn "Warning: #{table.name} has a multi-part primary key" if pk.length > 1 and !is_join_table
-
-	    needs_rails_id_field = (pk.length > 1) && !is_join_table
-	    move_pk_to_create_table_call = !needs_rails_id_field &&
-		pk.length == 1 &&
-		(to = pk[0].references[-1].to) &&
-		to.supertypes_transitive.detect{|t| t.name == 'Auto Counter'}
-
-	    identity =
-	      if move_pk_to_create_table_call
-		":primary_key => :#{pk[0].rails_name}"
-	      else
-		":id => #{needs_rails_id_field}"
-	      end
-
-	    puts %Q{  create_table "#{ar_table_name}", #{identity}, :force => true do |t|}
-
-	    # We sort the columns here, not in the persistence layer, because it affects
-	    # the ordering of columns in an index :-(.
-
-	    columns = table.
-		columns.
-		sort_by do |column|
-		  [ # Emit columns alphabetically, but PK first, then FKs, then others
-		    case
-		    when column == identity_column
-		      0
-		    when fk_columns.include?(column)
-		      1
-		    else
-		      2
-		    end,
-		    column.rails_name
+	  puts %Q{  create_table "#{ar_table_name}", :id => false, :force => true do |t|}
+
+	  columns = generate_columns table, pk, fk_columns
+
+	  unless @exclude_fks
+	    table.foreign_keys.each do |fk|
+	      from_columns = fk.from_columns.map{|column| column.rails_name}
+	      to_columns = fk.to_columns.map{|column| column.rails_name}
+
+	      foreign_keys.concat(
+		if (from_columns.length == 1)
+		  [
+		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :on_delete => :cascade"
+		  ]+
+		  Array(
+		    # Index it non-uniquely only if it's not unique already:
+		    fk.jump_reference.to_role.unique ? nil :
+		      "    add_index :#{fk.from.rails_name}, [:#{from_columns[0]}], :unique => false"
+		  )
+		else
+		  # This probably isn't going to work without Dr Nic's CPK gem:
+		  [
+		    "    add_foreign_key :#{fk.to.rails_name}, :#{fk.from.rails_name}, :column => [:#{from_columns.join(':, ')}], :primary_key => [:#{to_columns.join(':, ')}], :on_delete => :cascade"
 		  ]
-		end.
-		map do |column|
-	      next [] if move_pk_to_create_table_call and column == pk[0]
-	      name = column.rails_name
-	      type, params, constraints = column.type
-	      length = params[:length]
-	      length &&= length.to_i
-	      scale = params[:scale]
-	      scale &&= scale.to_i
-	      type, length = Persistence::rails_type(type, length)
-
-	      length_name = type == 'decimal' ? 'precision' : 'limit'
-
-	      primary = (!is_join_table && pk.include?(column)) ? ", :primary => true" : ''
-	      comment = column.comment
-	      (@include_comments ? ["    \# #{comment}"] : []) +
-	      [
-		%Q{    t.#{type}\t"#{name}"#{
-		    length ? ", :#{length_name} => #{length}" : ''
-		  }#{
-		    scale ? ", :scale => #{scale}" : ''
-		  }#{
-		    column.is_mandatory ? ', :null => false' : ''
-		  }#{primary}}
-	      ]
-	    end.flatten
-
-	    unless @exclude_fks
-	      table.foreign_keys.each do |fk|
-		from_columns = fk.from_columns.map{|column| column.rails_name}
-		to_columns = fk.to_columns.map{|column| column.rails_name}
-		foreign_keys <<
-		  if (from_columns.length == 1)
-		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :dependent => :cascade"
-		  else
-		    # This probably isn't going to work without Dr Nic's CPK gem:
-		    "    add_foreign_key :#{fk.to.rails_name}, :#{fk.from.rails_name}, :column => [:#{from_columns.join(':, ')}], :primary_key => [:#{to_columns.join(':, ')}], :dependent => :cascade"
-		  end
-	      end
+		end
+	      )
 	    end
+	  end
 
-	    indices = table.indices
-	    index_text = []
-	    indices.each do |index|
-	      next if move_pk_to_create_table_call and index.is_primary	  # We've handled this already
+	  indices = table.indices
+	  index_text = []
+	  indices.each do |index|
+	    next if index.is_primary && index.columns.size == 1	  # We've handled this already
 
-	      index_name = index.rails_name
+	    index_name = index.rails_name
 
-	      unique = !index.columns.detect{|column| !column.is_mandatory} and !@closed_world
-	      index_text << %Q{  add_index "#{ar_table_name}", ["#{index.columns.map{|c| c.rails_name}*'", "'}"], :name => :#{index_name}#{
-		unique ? ", :unique => true" : ''
-	      }}
-	    end
+	    unique = !index.columns.detect{|column| !column.is_mandatory} and !@closed_world
+	    index_text << %Q{  add_index "#{ar_table_name}", ["#{index.columns.map{|c| c.rails_name}*'", "'}"], :name => :#{index_name}#{
+	      unique ? ", :unique => true" : ''
+	    }}
+	  end
+
+	  puts columns.join("\n")
+	  puts "  end\n\n"
+
+	  puts index_text.join("\n")
+	  puts "\n" unless index_text.empty?
+	end
+
+	def generate(out = $>)      #:nodoc:
+	  return if @helping
+	  @out = out
 
-	    puts columns.join("\n")
-	    puts "  end\n\n"
+	  foreign_keys = []
 
-	    puts index_text.join("\n")
-	    puts "\n" unless index_text.empty?
+	  # If we get index names that need to be truncated, add a counter to ensure uniqueness
+	  dup_id = 0
+
+	  puts "#\n# schema.rb auto-generated using ActiveFacts for #{@vocabulary.name} on #{Date.today}\n#\n\n"
+	  puts "ActiveRecord::Base.logger = Logger.new(STDOUT)\n"
+	  puts "ActiveRecord::Schema.define(:version => #{Time.now.strftime('%Y%m%d%H%M%S')}) do"
+	  puts "  enable_extension 'pgcrypto' unless extension_enabled?('pgcrypto')\n"
+
+	  @vocabulary.tables.each do |table|
+	    generate_table table, foreign_keys
 	  end
 
 	  unless @exclude_fks