activefacts-compositions 1.9.6 → 1.9.8

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

@@ -15,45 +15,106 @@ module ActiveFacts
     # * underscore 
     class SQL
       class Server < SQL
-	def boolean_type
-	  'BOOLEAN'
-	end
-
-	def surrogate_type
-	  'BIGINT IDENTITY NOT NULL'
-	end
-
-	def reserved_words
-	  @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
-	  }
-	end
-
-	def go s = ''
-	  "#{s}\nGO\n"  # REVISIT: This is an SQL-Serverism. Move it to a subclass.
-	end
+        def self.options
+          super.merge({
+            # no: [String, "no new options defined here"]
+          })
+        end
+
+        def table_name_max
+          128
+        end
+
+        def data_type_context
+          SQLServerDataTypeContext.new
+        end
+
+        def auto_assign_type
+          ' IDENTITY'
+        end
+
+        def normalise_type(type_name, length, value_constraint)
+          return ['UNIQUEIDENTIFIER', 16] if type_name =~ /^(guid|uuid)$/i
+
+          type = MM::DataType.normalise(type_name)
+          case type
+          when MM::DataType::TYPE_Money;    'MONEY'
+          when MM::DataType::TYPE_DateTime; 'DATETIME'
+          when MM::DataType::TYPE_Timestamp;'DATETIME'
+          when MM::DataType::TYPE_Binary;
+            if length && length <= 8192
+              super
+            else
+              'IMAGE'
+            end
+          else
+            super
+          end
+        end
+
+        def reserved_words
+          @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
+          }
+        end
+
+        def go s = ''
+          "#{s}\nGO\n"
+        end
+
+        class SQLServerDataTypeContext < SQLDataTypeContext
+          def integer_ranges
+            [
+              ['BIT', 0, 1],
+              ['TINYINT', -2**7, 2**7-1],
+            ] +
+            super
+          end
+
+          def boolean_type
+            'BIT'
+          end
+
+          def valid_from_type
+            'DATETIME'
+          end
+
+          def default_char_type
+            (@unicode ? 'N' : '') +
+            'CHAR'
+          end
+
+          def default_varchar_type
+            (@unicode ? 'N' : '') +
+            'VARCHAR'
+          end
+
+          def date_time_type
+            'DATETIME'
+          end
+        end
       end
 
     end

data/lib/activefacts/generator/summary.rb

@@ -12,85 +12,93 @@ module ActiveFacts
   module Metamodel
     class Composition
       def summary
-	classify_constraints
-	"Summary of #{name}\n" +
-	all_composite.
-	sort_by{|composite| composite.mapping.name}.
-	flat_map do |composite|
-	  composite.summary
-	end*''
+        classify_constraints
+        "Summary of #{name}\n" +
+        all_composite.
+        sort_by{|composite| composite.mapping.name}.
+        flat_map do |composite|
+          composite.summary
+        end*''
       end
     end
 
     class Composite
       def summary
-	indices = self.all_indices_by_rank
+        indices = self.all_indices_by_rank
 
-	(
-	  [mapping.name+"\n"] +
-	  mapping.
-	  leaves.
-	  reject{|leaf| leaf.is_a?(Absorption) && leaf.forward_absorption}.
-	  flat_map do |leaf|
+        (
+          [mapping.name+"\n"] +
+          mapping.
+          all_leaf.
+          reject{|leaf| leaf.is_a?(Absorption) && leaf.forward_absorption}.
+          flat_map do |leaf|
 
-	    # Build a display of the names in this absorption path, with FK and optional indicators
-	    path_names = leaf.path.map do |component|
-		is_mandatory = case component
-		  when Indicator
-		    false
-		  when Absorption
-		    component.parent_role.is_mandatory
-		  else
-		    true
-		  end
+            # Build a display of the names in this absorption path, with FK and optional indicators
+            path_names = leaf.path.map do |component|
+                is_mandatory = case component
+                  when Indicator
+                    false
+                  when Absorption
+                    component.parent_role.is_mandatory
+                  else
+                    true
+                  end
 
-		if component.is_a?(Absorption) && component.foreign_key
-		  "[#{component.name}]"
-		else
-		  component.name
-		end +
-		  (is_mandatory ? '' : '?')
-	      end*'->' 
+                if component.all_foreign_key_field.size > 0
+                  "[#{component.name}]"
+                elsif component.is_a?(Absorption) && component.foreign_key
+                  "{#{component.name}}"
+                else
+                  component.name
+                end +
+                  (is_mandatory ? '' : '?')
+              end*'->' 
 
-	    # Build a symbolic representation of the index participation of this leaf
-	    pos = 0
-	    indexing = indices.inject([]) do |a, index|
-	      pos += 1
-	      if part = index.position_in_index(leaf)
-		a << "#{pos}.#{part}"
-	      end
-	      a
-	    end
-	    if indexing.empty? 
-	      indexing = '' 
-	    else
-	      indexing = "[#{indexing*','}]"
-	    end
+            # Build a symbolic representation of the index participation of this leaf
+            pos = 0
+            indexing = indices.inject([]) do |a, index|
+              pos += 1
+              if part = index.position_in_index(leaf)
+                a << "#{pos}.#{part}"
+              end
+              a
+            end
+            if indexing.empty? 
+              indexing = '' 
+            else
+              indexing = "[#{indexing*','}]"
+            end
 
-	    column_name = leaf.column_name.capwords*' '
-	    ["\t#{path_names}#{indexing} as #{column_name.inspect}\n"] +
-	    leaf.all_leaf_constraint.map{|leaf_constraint| "\t\t### #{leaf_constraint.leaf_constraint.describe}\n"}
-	  end +
-	  all_local_constraint.map do |local_constraint|
-	    "\t### #{local_constraint.local_constraint.describe}\n"
-	  end.sort +
-	  all_spanning_constraint.map do |spanning_constraint|
-	    "### #{spanning_constraint.spanning_constraint.describe}\n"
-	  end.sort
+            column_name = leaf.column_name.capwords*' '
+            ["\t#{path_names}#{indexing} as #{column_name.inspect}\n"] +
+            leaf.all_leaf_constraint.map{|leaf_constraint| "\t\t### #{leaf_constraint.leaf_constraint.describe}\n"}.sort
+          end +
+          all_local_constraint.map do |local_constraint|
+            "\t### #{local_constraint.local_constraint.describe}\n"
+          end.sort +
+          all_spanning_constraint.map do |spanning_constraint|
+            "### #{spanning_constraint.spanning_constraint.describe}\n"
+          end.sort
 
-	)*''
+        )*''
       end
     end
   end
 
   module Generators
     class Summary
-      def initialize composition
-	@composition = composition
+      def self.options
+        {
+        }
+      end
+
+      def initialize composition, options = {}
+        @composition = composition
+        @options = options
       end
 
       def generate
-	@composition.summary
+        @composition.summary
       end
     end
     publish_generator Summary

data/lib/activefacts/generator/validate.rb

@@ -7,152 +7,37 @@
 # Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
 #
 require "activefacts/metamodel"
+require "activefacts/metamodel/validate/composition"
 require "activefacts/compositions/compositor"
 require "activefacts/generator"
 
 module ActiveFacts
   module Generators
     class Validate
-      def initialize composition, options = {}
-	@composition = composition
-	@options = options
-      end
-
-      def generate &b
-	@composition.validate &b
-	nil
-      end
-    end
-    publish_generator Validate
-  end
-
-  module Metamodel
-    class Composition
-      def validate &report
-        trace.enable 'composition_validator'
-	report ||= proc do |component, problem|
-	  trace :composition_validator, "!!PROBLEM!! #{component.inspect}: #{problem}"
-	end
-
-	all_composite.each do |composite|
-	  composite.validate &report
-	end
-      end
-    end
-
-    class Composite
-      def validate &report
-	trace :composition_validator?, "Validating #{inspect}" do
-	  report.call(self, "Has no Mapping") unless mapping
-	  report.call(self, "Mapping is not a mapping") unless mapping.class == Mapping
-	  report.call(mapping, "Has no ObjectType") unless mapping.object_type
-	  report.call(mapping, "Has no Name") unless mapping.name
-	  report.call(mapping, "Should not have an Ordinal rank") if mapping.ordinal
-	  report.call(mapping, "Should not have a parent mapping") if mapping.parent
-	  report.call(mapping, "Should be the root of its mapping") if mapping.root != self
-
-	  mapping.validate_members &report
-	  validate_access_paths &report
-	end
-      end
-
-      def validate_access_paths &report
-	all_access_path.each do |access_path|
-	  report.call(access_path, "Must contain at least one IndexField") unless access_path.all_index_field.size > 0
-	  access_path.all_index_field.each do |index_field|
-	    report.call(access_path, "#{index_field.inspect} must be an Indicator or played by a ValueType") unless index_field.component.is_a?(Indicator) || index_field.component.object_type.is_a?(ValueType)
-	    report.call(access_path, "#{index_field.inspect} must be within its composite") unless index_field.component.root == self
-	  end
-	  if ForeignKey === access_path
-	    if access_path.all_index_field.size == access_path.all_foreign_key_field.size
-	      access_path.all_index_field.to_a.zip(access_path.all_foreign_key_field.to_a).each do |index_field, foreign_key_field|
-		report.call(access_path, "#{index_field.inspect} must have matching target type") unless index_field.component.class == foreign_key_field.component.class
-		unless index_field.component.class == foreign_key_field.component.class
-		  report.call(access_path, "#{index_field.inspect} must have component type matching #{foreign_key_field.inspect}")
-		else
-		  report.call(access_path, "#{index_field.inspect} must have matching target type") unless !index_field.component.is_a?(Absorption) or index_field.component.object_type == foreign_key_field.component.object_type
-		end
-		report.call(access_path, "#{foreign_key_field.inspect} must be within the target composite") unless foreign_key_field.component.root == access_path.source_composite
-	      end
-	    else
-	      report.call(access_path, "has #{access_path.all_index_field.size} index fields but #{access_path.all_foreign_key_field.size} ForeignKeyField")
-	    end
-	  end
-	end
+      def self.options
+        {
+        }
       end
-    end
-
-    class Mapping
-      def validate_members &report
-	# Names (except of subtype/supertype absorption) must be unique:
-	names = all_member.
-	  reject{|m| m.is_a?(Absorption) && m.parent_role.fact_type.is_a?(TypeInheritance)}.
-	  map(&:name).
-	  compact
-	duplicate_names = names.select{|name| names.count(name) > 1}.uniq
-	report.call(self, "Contains duplicated names #{duplicate_names.map(&:inspect)*', '}") unless duplicate_names.empty?
-
-	all_member.each do |member|
-	  trace :composition_validator?, "Validating #{member.inspect}" do
-	    report.call(member, "Requires a name") unless Absorption === member && member.flattens or member.name && !member.name.empty?
-	    case member
-	    when Absorption
-	      p = member.parent_role
-	      c = member.child_role
-	      report.call(member, "Roles should belong to the same fact type, but instead we have #{p.name} in #{p.fact_type.default_reading} and #{c.name} in #{c.fact_type.default_reading}") unless p.fact_type == c.fact_type
-	      report.call(member, "Object type #{member.object_type.name} should play the child role #{c.name}") unless member.object_type == c.object_type
-	      report.call(member, "Parent mapping object type #{object_type.name} should play the parent role #{p.name}") unless object_type == p.object_type
-
-	      member.validate_reverse &report
-	      member.validate_nesting &report if member.all_nesting.size > 0
-	      member.validate_members &report
-
-	    when Scoping
-	      report.call(member, "REVISIT: Unexpected and unchecked Scoping")
-
-	    when ValueField
-	      # Nothing to check here
-
-	    when SurrogateKey
-	      # Nothing to check here
-
-	    when Injection
-	      report.call(member, "REVISIT: Unexpected and unchecked Injection")
 
-	    when Mapping
-	      report.call(member, "A child Component should not be a bare Mapping")
-
-	    when Indicator
-	      report.call(member, "Indicator requires a Role") unless member.role
-
-	    when Discriminator
-	      report.call(member, "Discriminator requires at least one Discriminated Role") if member.all_discriminated_role.empty?
-	      member.all_discriminated_role.each do |role|
-		report.call(member, "Discriminated Role #{role.name} is not played by parent object type #{object_type.name}") unless role.object_type == object_type
-	      end
-	      # REVISIT: Discriminated Roles must have distinct values matching the type of the Role
-	    end
-	  end
-	end
+      def initialize composition, options = {}
+        @composition = composition
+        @options = options
       end
-    end
 
-    class Absorption
-      def validate_reverse &report
-	reverse = forward_absorption || reverse_absorption
-	return unless reverse
-	report.call(self, "Opposite absorption's child role #{reverse.child_role.name} should match parent role #{parent_role.name}") unless reverse.child_role == parent_role
-	report.call(self, "Opposite absorption's parent role #{reverse.parent_role.name} should match child role #{child_role.name}") unless reverse.parent_role == child_role
-      end
+      def generate &report
+        if !report
+          trace.enable 'composition_validator'
+          report ||= proc do |component, problem|
+            trace :composition_validator, "!!PROBLEM!! #{component.inspect}: #{problem}"
+            debugger if trace :composition_validator_debug
+            component
+          end
+        end
 
-      def validate_nesting &report
-	report.call(self, "REVISIT: Unexpected and unchecked Nesting")
-	report.call(self, "Nesting Mode must be specified") unless self.nesting_mode
-	# REVISIT: Nesting names must be unique
-	# REVISIT: Nesting roles must be played by...
-	# REVISIT: Nesting roles must be value types
+        @composition.validate &report
+        nil
       end
     end
-
+    publish_generator Validate
   end
 end