activefacts 0.7.2 → 0.7.3

data/lib/activefacts/generate/ordered.rb

@@ -10,8 +10,6 @@ module ActiveFacts
   module Generate #:nodoc:
     class OrderedDumper #:nodoc:
       # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
-      include Metamodel
-
       def initialize(vocabulary, *options)
         @vocabulary = vocabulary
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
@@ -49,13 +47,13 @@ module ActiveFacts
 
         @vocabulary.all_constraint.each { |c|
             case c
-            when PresenceConstraint
+            when ActiveFacts::Metamodel::PresenceConstraint
               fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq  # All fact types spanned by this constraint
               if fact_types.size == 1     # There's only one, save it:
                 # debug "Single-fact constraint on #{fact_types[0].fact_type_id}: #{c.name}"
                 (@presence_constraints_by_fact[fact_types[0]] ||= []) << c
               end
-            when RingConstraint
+            when ActiveFacts::Metamodel::RingConstraint
               (@ring_constraints_by_fact[c.role.fact_type] ||= []) << c
             else
               # debug "Found unhandled constraint #{c.class} #{c.name}"
@@ -66,18 +64,27 @@ module ActiveFacts
 
       def value_types_dump
         done_banner = false
+        @value_type_dumped = {}
         @vocabulary.all_feature.sort_by{|o| o.name}.each{|o|
-            next unless ValueType === o
+            next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
 
             value_type_banner unless done_banner
             done_banner = true
 
-            value_type_dump(o)
+            value_type_chain_dump(o)
             @concept_types_dumped[o] = true
           }
         value_type_end if done_banner
       end
 
+      # Ensure that supertype gets dumped first
+      def value_type_chain_dump(o)
+        return if @value_type_dumped[o]
+        value_type_chain_dump(o.supertype) if (o.supertype && !@value_type_dumped[o.supertype])
+        value_type_dump(o)
+        @value_type_dumped[o] = true
+      end
+
       # Try to dump entity types in order of name, but we need
       # to dump ETs before they're referenced in preferred ids
       # if possible (it's not always, there may be loops!)
@@ -86,7 +93,9 @@ module ActiveFacts
         precursors, followers = *build_entity_dependencies
 
         done_banner = false
-        sorted = @vocabulary.all_feature.select{|o| EntityType === o and !o.fact_type }.sort_by{|o| o.name}
+        sorted = @vocabulary.all_feature.select{|o|
+          o.is_a?(ActiveFacts::Metamodel::EntityType) and !o.fact_type
+        }.sort_by{|o| o.name}
         panic = nil
         while true do
           count_this_pass = 0
@@ -154,7 +163,7 @@ module ActiveFacts
         supers = o.supertypes
         if (supers.size > 0)
           # Ignore identification by a supertype:
-          pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(TypeInheritance) }
+          pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) }
           subtype_dump(o, supers, pi)
         else
           non_subtype_dump(o, pi)
@@ -222,7 +231,7 @@ module ActiveFacts
 
             constraint = fact_constraints.find{|c|  # Find a UC that spans all other Roles
                 # internal uniqueness constraints span all roles but one, the residual:
-                PresenceConstraint === c &&
+                c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) &&
                   !@constraints_used[c] &&  # Already verbalised
                   roles-c.role_sequence.all_role_ref.map(&:role) == [role]
               }
@@ -271,7 +280,7 @@ module ActiveFacts
       # The values of each hash entry are the precursors and followers (respectively) of that entity.
       def build_entity_dependencies
         @vocabulary.all_feature.inject([{},{}]) { |a, o|
-            if EntityType === o && !o.fact_type
+            if o.is_a?(ActiveFacts::Metamodel::EntityType) && !o.fact_type
               precursor = a[0]
               follower = a[1]
               blocked = false
@@ -280,7 +289,7 @@ module ActiveFacts
                 pi.role_sequence.all_role_ref.each{|rr|
                     role = rr.role
                     player = role.concept
-                    next unless EntityType === player
+                    next unless player.is_a?(ActiveFacts::Metamodel::EntityType)
                     # player is a precursor of o
                     (precursor[o] ||= []) << player if (player != o)
                     (follower[player] ||= []) << o if (player != o)
@@ -324,7 +333,7 @@ module ActiveFacts
         # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
         # These will come up as un-handled constraints:
         pcs = @presence_constraints_by_fact[f]
-        TypeInheritance === f ||
+        f.is_a?(ActiveFacts::Metamodel::TypeInheritance) ||
           (pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] })
       end
 
@@ -395,10 +404,10 @@ module ActiveFacts
         fact_collection = @vocabulary.constellation.FactType
         fact_collection.keys.select{|fact_id|
                 fact_type = fact_collection[fact_id] and
-                !(TypeInheritance === fact_type) and
+                !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
                 !@fact_types_dumped[fact_type] and
                 !skip_fact_type(fact_type) and
-                !fact_type.all_role.detect{|r| r.concept.is_a?(EntityType) }
+                !fact_type.all_role.detect{|r| r.concept.is_a?(ActiveFacts::Metamodel::EntityType) }
             }.sort_by{|fact_id|
                 fact_type = fact_collection[fact_id]
                 fact_type_key(fact_type)
@@ -412,7 +421,7 @@ module ActiveFacts
 
         # REVISIT: Find out why some fact types are missed during entity dumping:
         @vocabulary.constellation.FactType.values.select{|fact_type|
-            !(TypeInheritance === fact_type)
+            !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
           }.sort_by{|fact_type|
             fact_type_key(fact_type)
           }.each{|fact_type|
@@ -442,13 +451,13 @@ module ActiveFacts
 
       def constraint_sort_key(c)
         case c
-        when RingConstraint
+        when ActiveFacts::Metamodel::RingConstraint
           [1, c.ring_type, c.role.concept.name, c.other_role.concept.name, c.name||""]
-        when SetComparisonConstraint
+        when ActiveFacts::Metamodel::SetComparisonConstraint
           [2, c.all_set_comparison_roles.map{|scrs| scrs.role_sequence.all_role_ref.map{|rr| role_ref_key(rr)}}, c.name||""]
-        when SubsetConstraint
+        when ActiveFacts::Metamodel::SubsetConstraint
           [3, [c.superset_role_sequence, c.subset_role_sequence].map{|rs| rs.all_role_ref.map{|rr| role_ref_key(rr)}}, c.name||""]
-        when PresenceConstraint
+        when ActiveFacts::Metamodel::PresenceConstraint
           [4, c.role_sequence.all_role_ref.map{|rr| role_ref_key(rr)}, c.name||""]
         end
       end
@@ -457,7 +466,7 @@ module ActiveFacts
         heading = false
         @vocabulary.all_constraint.reject{|c| except[c]}.sort_by{ |c| constraint_sort_key(c) }.each do|c|
           # Skip some PresenceConstraints:
-          if PresenceConstraint === c
+          if c.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
             # Skip uniqueness constraints that cover all roles of a fact type, they're implicit
             fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
             next if fact_types.size == 1 &&
@@ -466,7 +475,7 @@ module ActiveFacts
 
             # Skip internal PresenceConstraints over TypeInheritances:
             next if c.role_sequence.all_role_ref.size == 1 &&
-              TypeInheritance === fact_types[0]
+              fact_types[0].is_a?(ActiveFacts::Metamodel::TypeInheritance)
           end
 
           constraint_banner unless heading

data/lib/activefacts/generate/ruby.rb

@@ -37,7 +37,7 @@ module ActiveFacts
           puts "require 'activefacts/persistence'\n"
           @tables = vocabulary.tables
         end
-        puts "\nmodule #{vocabulary.name}\n\n"
+        puts "\nmodule ::#{vocabulary.name}\n\n"
       end
 
       def vocabulary_end
@@ -45,26 +45,37 @@ module ActiveFacts
       end
 
       def value_type_dump(o)
-        return if !o.supertype
-        if o.name == o.supertype.name
-            # In ActiveFacts, parameterising a ValueType will create a new datatype
-            # throw Can't handle parameterized value type of same name as its datatype" if ...
+        is_special_supertype = !o.supertype && %w{Date Time DateAndTime}.include?(o.name)
+
+        # We map DateAndTime to DateTime; if such a ValueType exists, don't dump this one
+        return if is_special_supertype && o.name == 'DateAndTime' && o.constellation.ValueType[[[o.vocabulary.name], 'DateTime']]
+
+        return if !o.supertype && !is_special_supertype
+        if o.supertype && o.name == o.supertype.name
+          # In ActiveFacts, parameterising a ValueType will create a new datatype
+          # throw Can't handle parameterized value type of same name as its datatype" if ...
         end
 
         length = (l = o.length) && l > 0 ? ":length => #{l}" : nil
         scale = (s = o.scale) && s > 0 ? ":scale => #{s}" : nil
         params = [length,scale].compact * ", "
 
+        name = o.name
         ruby_type_name =
-          case o.supertype.name
+          case o.supertype ? o.supertype.name : o.name
             when "VariableLengthText"; "String"
             when "Date"; "::Date"
+            when "DateAndTime"; "::DateTime"
+            when "Time"; "::Time"
             else o.supertype.name
           end
 
-        puts "  class #{o.name} < #{ruby_type_name}\n" +
+        name = name.sub(/^[a-z]/) {|i| i.upcase}
+        puts "  class #{name} < #{ruby_type_name}\n" +
              "    value_type #{params}\n"
-        puts "    table" if @sql and o.is_table
+        if @sql and o.is_table
+          puts "    table"
+        end
         puts "    \# REVISIT: #{o.name} has restricted values\n" if o.value_restriction
         puts "    \# REVISIT: #{o.name} is in units of #{o.unit.name}\n" if o.unit
         roles_dump(o)
@@ -78,7 +89,9 @@ module ActiveFacts
         puts "  class #{o.name} < #{ primary_supertype.name }"
         puts "    identified_by #{identified_by(o, pi)}" if pi
         puts "    supertypes "+secondary_supertypes.map(&:name)*", " if secondary_supertypes.size > 0
-        puts "    table" if @sql and o.is_table
+        if @sql and o.is_table
+          puts "    table"
+        end
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -87,8 +100,12 @@ module ActiveFacts
 
       def non_subtype_dump(o, pi)
         puts "  class #{o.name}"
+
+        # We want to name the absorption role only when it's absorbed along its single identifying role.
         puts "    identified_by #{identified_by(o, pi)}"
-        puts "    table" if @sql and o.is_table
+        if @sql and o.is_table
+          puts "    table"
+        end
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -122,7 +139,7 @@ module ActiveFacts
 
       def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
         identifying_roles.map{|role|
-            ":"+preferred_role_name(role)
+            ":"+preferred_role_name(role, entity_type)
           }*", "
       end
 
@@ -132,13 +149,11 @@ module ActiveFacts
 
       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
+        if role_name.camelcase(true) == role_player.name.sub(/^[a-z]/) {|i| i.upcase}
           # 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
+          role_reference = concept_reference(role_player)
         end
         other_role_name = ":"+other_role_name if other_role_name
 
@@ -154,6 +169,14 @@ module ActiveFacts
         puts "    \# REVISIT: #{other_role_name} has restricted values\n" if role.role_value_restriction
       end
 
+      def concept_reference concept
+        if !@concept_types_dumped[concept]
+          '"'+concept.name+'"'
+        else
+          role_reference = concept.name
+        end
+      end
+
     end
   end
 end

data/lib/activefacts/generate/sql/mysql.rb

@@ -0,0 +1,257 @@
+#
+#       ActiveFacts Generators.
+#       Generate SQL for MySQL from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Daniel Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/persistence'
+
+module ActiveFacts
+  module Generate
+    class SQL #:nodoc:
+      # Generate SQL for MySQL for an ActiveFacts vocabulary.
+      # Invoke as
+      #   afgen --sql/mysql[=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
+      # * norma Translate datatypes from NORMA to SQL Server
+      class MYSQL
+      private
+        include Persistence
+        ColumnNameMax = 63
+        DefaultCharColLength = 63
+
+        RESERVED_WORDS = %w{
+          ACCESSIBLE ADD ALL ALTER ANALYZE AND AS ASC ASENSITIVE
+          BEFORE BETWEEN BIGINT BINARY BLOB BOTH BY CALL CASCADE
+          CASE CHANGE CHAR CHARACTER CHECK COLLATE COLUMN CONNECTION
+          CONDITION CONSTRAINT CONTINUE CONVERT CREATE CROSS
+          CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER
+          CURSOR DATABASE DATABASES DAY_HOUR DAY_MICROSECOND
+          DAY_MINUTE DAY_SECOND DEC DECIMAL DECLARE DEFAULT DELAYED
+          DELETE DESC DESCRIBE DETERMINISTIC DISTINCT DISTINCTROW
+          DIV DOUBLE DROP DUAL EACH ELSE ELSEIF ENCLOSED ESCAPED
+          EXISTS EXIT EXPLAIN FALSE FETCH FLOAT FLOAT4 FLOAT8 FOR
+          FORCE FOREIGN FROM FULLTEXT GRANT GROUP HAVING HIGH_PRIORITY
+          HOUR_MICROSECOND HOUR_MINUTE HOUR_SECOND IF IGNORE IN
+          INDEX INFILE INNER INOUT INSENSITIVE INSERT INT INT1 INT2
+          INT3 INT4 INT8 INTEGER INTERVAL INTO IS ITERATE JOIN KEY
+          KEYS KILL LEADING LEAVE LEFT LIKE LIMIT LINEAR LINES LOAD
+          LOCALTIME LOCALTIMESTAMP LOCK LONG LONGBLOB LONGTEXT LOOP
+          LOW_PRIORITY MASTER_SSL_VERIFY_SERVER_CERT MATCH MEDIUMBLOB
+          MEDIUMINT MEDIUMTEXT MIDDLEINT MINUTE_MICROSECOND
+          MINUTE_SECOND MOD MODIFIES NATURAL NOT NO_WRITE_TO_BINLOG
+          NULL NUMERIC ON OPTIMIZE OPTION OPTIONALLY OR ORDER OUT
+          OUTER OUTFILE PRECISION PRIMARY PROCEDURE PURGE RANGE
+          READ READ_ONLY READS READ_WRITE READ_WRITE REAL REFERENCES
+          REGEXP RELEASE RENAME REPEAT REPLACE REQUIRE RESTRICT
+          RETURN REVOKE RIGHT RLIKE SCHEMA SCHEMAS SECOND_MICROSECOND
+          SELECT SENSITIVE SEPARATOR SET SHOW SMALLINT SPATIAL
+          SPECIFIC SQL SQL_BIG_RESULT SQL_CALC_FOUND_ROWS SQLEXCEPTION
+          SQL_SMALL_RESULT SQLSTATE SQLWARNING SSL STARTING
+          STRAIGHT_JOIN TABLE TERMINATED THEN TINYBLOB TINYINT
+          TINYTEXT TO TRAILING TRIGGER TRUE UNDO UNION UNIQUE UNLOCK
+          UNSIGNED UPDATE UPGRADE USAGE USE USING UTC_DATE UTC_TIME
+          UTC_TIMESTAMP VALUES VARBINARY VARCHAR VARCHARACTER VARYING
+          WHEN WHERE WHILE WITH WRITE XOR YEAR_MONTH ZEROFILL
+        }.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"
+          @norma = options.include? "norma"
+        end
+
+        def puts s
+          @out.puts s
+        end
+
+        def go s
+          puts s + ";\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 NORMA base type
+        def norma_type(type, length)
+          sql_type = case type
+            when "AutoCounter"; "INT"
+            when "SignedInteger",
+              "SignedSmallInteger"
+              s = case
+                when length <= 8; "TINYINT UNSIGNED"
+                when length <= 16; "SMALLINT UNSIGNED"
+                when length <= 24; "MEDIUMINT UNSIGNED"
+                else "INT UNSIGNED"
+                end
+              length = nil
+              s
+            when "UnsignedInteger",
+              "UnsignedSmallInteger",
+              "UnsignedTinyInteger"
+              s = case
+                when length <= 8; "TINYINT"
+                when length <= 16; "SMALLINT"
+                when length <= 24; "MEDIUMINT"
+                when length <= 32; "INT"
+                else "BIGINT"
+                end
+              length = nil
+              s
+            when "Decimal"; "DECIMAL"
+
+            when "FixedLengthText"; 
+                length ||= DefaultCharColLength
+                "CHAR"
+            when "VariableLengthText"; 
+                length ||= DefaultCharColLength
+                "VARCHAR"
+            # There are several large length text types; If you need to store more than 65k chars, look at using MEDIUMTEXT or LONGTEXT
+            # CQL does not yet allow you to specify a length for LargeLengthText.
+            when "LargeLengthText"; "TEXT"
+
+            when "DateAndTime"; "DATETIME"
+            when "Date"; "DATE" 
+            when "Time"; "TIME"
+            when "AutoTimestamp"; "TIMESTAMP"
+
+            when "Money"; "DECIMAL"
+            # Warning: Max 65 kbytes. To use larger types, try MediumBlob (16mb) or LongBlob (4gb)
+            when "PictureRawData"; "BLOB"
+            when "VariableLengthRawData"; "BLOB"
+            # Assuming you only want a boolean out of this. Should we specify length instead?
+            when "BIT"; "BIT"
+            else raise "SQL type unknown for NORMA 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} ("
+
+            pk = table.identifier_columns
+            identity_column = pk[0] if pk.size == 1 && 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 persistence layer, because it affects
+            # the ordering of columns in an index :-(.
+            columns = table.columns.sort_by { |column| column.name(nil) }.map do |column|
+              name = escape column.name("")
+              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
+              type, params, restrictions = column.type
+              restrictions = [] if (fk_columns.include?(column))  # Don't enforce VT restrictions on FK columns
+              length = params[:length]
+              length &&= length.to_i
+              scale = params[:scale]
+              scale &&= scale.to_i
+              type, length = norma_type(type, length) if @norma
+              sql_type = "#{type}#{
+                if !length
+                  ""
+                else
+                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
+                end
+                }"
+              identity = column == identity_column ? " AUTO_INCREMENT" : ""
+              null = (column.is_mandatory ? "NOT " : "") + "NULL"
+              check = check_clause(name, restrictions)
+              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("")}*", " +
+                ")"
+
+            inline_fks = []
+            table.foreign_keys.each do |fk|
+              fk_text = "FOREIGN KEY (" +
+                fk.from_columns.map{|column| column.name}*", " +
+                ") REFERENCES #{escape fk.to.name} (" +
+                fk.to_columns.map{|column| column.name}*", " +
+                ")"
+              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}\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*""
+              column_names = index.column_names
+              column_name_list = column_names.map{|n| escape(n)}*", "
+              inline_indices << "UNIQUE(#{column_name_list})"
+            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 check_clause(column_name, restrictions)
+          return "" if restrictions.empty?
+          # REVISIT: Merge all restrictions (later; now just use the first)
+          " CHECK(" +
+            restrictions[0].all_allowed_range.sort_by do |ar|
+              # Put the allowed ranges into a defined order:
+              ((min = ar.value_range.minimum_bound) && min.value) ||
+                ((max = ar.value_range.maximum_bound) && max.value)
+            end.map do |ar|
+              vr = ar.value_range
+              min = vr.minimum_bound
+              max = vr.maximum_bound
+              if (min && max && max.value == min.value)
+                "#{column_name} = #{min.value}"
+              else
+                inequalities = [
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{min.value}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{max.value}"
+                ].compact
+                inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
+              end
+            end*" OR " +
+          ")"
+        end
+      end
+    end
+  end
+end