activefacts 0.8.6 → 0.8.8

data/examples/CQL/JoinEquality.cql

@@ -0,0 +1,35 @@
+vocabulary JoinEquality;
+
+/*
+ * Value Types
+ */
+Event Id is written as Auto Counter;
+Number is written as Unsigned Integer(16);
+Reserve is written as String(20);
+Row is written as Char(2);
+Venue Id is written as Auto Counter;
+
+/*
+ * Entity Types
+ */
+Event is identified by its Id;
+
+Venue is identified by its Id [independent];
+Event is held at one Venue;
+
+Seat is identified by Venue and Reserve and Row and Number [independent] where
+	Seat is at one Venue,
+	Seat is in one Reserve,
+	Seat is in one Row,
+	Seat has one Number;
+
+Ticket is identified by Event and Seat where
+	Ticket is for one Event,
+	Ticket is for one Seat;
+
+/*
+ * Constraints:
+ */
+Ticket is for Seat that is at Venue
+	if and only if
+	Ticket is for Event that is held at Venue;

data/examples/CQL/Marriage.cql

@@ -3,7 +3,7 @@ vocabulary Marriage;
 /*
  * Value Types
  */
-Name is written as VariableLengthText;
+Name is written as String;
 
 /*
  * Entity Types

data/examples/CQL/Metamodel.cql

@@ -3,117 +3,161 @@ vocabulary Metamodel;
 /*
  * Value Types
  */
-Adjective is written as VariableLengthText(64);
-Assimilation is written as VariableLengthText restricted to {'partitioned', 'separate'};
-ConstraintId is written as AutoCounter;
-ContextNoteId is written as AutoCounter;
-ContextNoteKind is written as VariableLengthText restricted to {'as_opposed_to', 'because', 'so_that', 'to_avoid'};
-Denominator is written as UnsignedInteger(32);
-Discussion is written as VariableLengthText;
-Enforcement is written as VariableLengthText(16);
-Exponent is written as SignedSmallInteger(32);
-FactId is written as AutoCounter;
-FactTypeId is written as AutoCounter;
-Frequency is written as UnsignedInteger(32);
-InstanceId is written as AutoCounter;
-Length is written as UnsignedInteger(32);
-Literal is written as VariableLengthText;
-Name is written as VariableLengthText(64);
+Adjective is written as String(64);
+Agent Name is written as String;
+Assimilation is written as String restricted to {'partitioned', 'separate'};
+Constraint Id is written as Auto Counter;
+Context Note Id is written as Auto Counter;
+Context Note Kind is written as String restricted to {'as_opposed_to', 'because', 'so_that', 'to_avoid'};
+Date is written as Date;
+Denominator is written as Unsigned Integer(32);
+Discussion is written as String;
+Display Role Names Setting is written as String restricted to {'false', 'true'};
+Enforcement Code is written as String(16);
+Ephemera URL is written as String;
+Exponent is written as Signed Integer(16);
+Fact Id is written as Auto Counter;
+Fact Type Id is written as Auto Counter;
+Frequency is written as Unsigned Integer(32);
+Instance Id is written as Auto Counter;
+Join Id is written as Auto Counter;
+Length is written as Unsigned Integer(32);
+Literal is written as String;
+Name is written as String(64);
 Numerator is written as Decimal;
 Offset is written as Decimal;
-Ordinal is written as UnsignedSmallInteger(32);
-PersonName is written as VariableLengthText;
-Pronoun is written as VariableLengthText(20) restricted to {'feminine', 'masculine', 'neuter', 'personal'};
-RingType is written as VariableLengthText;
-RoleSequenceId is written as AutoCounter;
-Scale is written as UnsignedInteger(32);
-Text is written as VariableLengthText(256);
-UnitId is written as AutoCounter;
-ValueRestrictionId is written as AutoCounter;
+Ordinal is written as Unsigned Integer(16);
+Pronoun is written as String(20) restricted to {'feminine', 'masculine', 'neuter', 'personal'};
+Ring Type is written as String;
+Role Sequence Id is written as Auto Counter;
+Rotation Setting is written as String restricted to {'left', 'right'};
+Scale is written as Unsigned Integer(32);
+Shape Id is written as Auto Counter;
+Text is written as String(256);
+Unit Id is written as Auto Counter;
+X is written as Signed Integer(32);
+Y is written as Signed Integer(32);
 
 /*
  * Entity Types
  */
+Agent is identified by its Name;
+
 Coefficient is identified by Numerator and Denominator and Coefficient is precise where
 	Coefficient has one Numerator,
 	Coefficient has one Denominator,
 	Coefficient is precise;
 
 Constraint is identified by its Id;
-Constraint requires at most one Enforcement,
-	Enforcement applies to Constraint;
 Name is of Constraint,
 	Constraint is called at most one Name;
 
-ContextNote is identified by its Id;
-Constraint has ContextNote,
-	ContextNote applies to at most one Constraint;
-ContextNote has one ContextNoteKind,
-	ContextNoteKind is of ContextNote;
-ContextNote has one Discussion,
-	Discussion is for ContextNote;
+Context Note is identified by its Id;
+Constraint has Context Note,
+	Context Note applies to at most one Constraint;
+Context Note has one Context Note Kind,
+	Context Note Kind is of Context Note;
+Context Note has one Discussion,
+	Discussion is for Context Note;
+
+Enforcement is identified by Constraint where
+	Constraint requires at most one Enforcement,
+	Enforcement applies to one Constraint;
+Enforcement notifies at most one Agent;
+Enforcement has one Enforcement Code,
+	Enforcement Code is of Enforcement;
 
 Fact is identified by its Id;
 
-FactType is identified by its Id;
-Fact is of one FactType;
-FactType has ContextNote,
-	ContextNote applies to at most one FactType;
-
-Instance is identified by its Id;
-Instance objectifies at most one Fact;
+Fact Type is identified by its Id;
+Fact is of one Fact Type;
+Fact Type has Context Note,
+	Context Note applies to at most one Fact Type;
 
-Person is identified by its Name;
+Implicit Fact Type is a kind of Fact Type;
 
-PresenceConstraint is a kind of Constraint;
-PresenceConstraint has at most one max-Frequency restricted to {1..};
-PresenceConstraint has at most one min-Frequency restricted to {2..};
-PresenceConstraint is mandatory;
-PresenceConstraint is preferred identifier;
-
-Reading is identified by FactType and Ordinal where
-	FactType has at least one Reading,
-	Reading is for one FactType,
+Instance is identified by its Id;
+Instance objectifies at most one Fact,
+	Fact is objectified as at most one Instance;
+
+Join is identified by its Id;
+
+Join Node is identified by Join and Ordinal where
+	Join includes Join Node,
+	Join Node is in one Join,
+	Join Node has one Ordinal position;
+
+Join Step is identified by input-Join Node and output-Join Node where
+	Join Step has one input-Join Node,
+	Join Step has one output-Join Node;
+Join Step traverses one Fact Type;
+is anti Join Step;
+Join Step is outer;
+
+Position is identified by X and Y where
+	Position is at one X,
+	Position is at one Y;
+
+Presence Constraint is a kind of Constraint;
+Presence Constraint has at most one max-Frequency restricted to {1..};
+Presence Constraint has at most one min-Frequency restricted to {2..};
+Presence Constraint is mandatory;
+Presence Constraint is preferred identifier;
+
+Reading is identified by Fact Type and Ordinal where
+	Fact Type has Reading,
+	Reading is for one Fact Type,
 	Reading is in one Ordinal position,
 	Ordinal reading for fact type is Reading;
 Reading has one Text;
 
-RingConstraint is a kind of Constraint;
-RingConstraint is of one RingType;
+Ring Constraint is a kind of Constraint;
+Ring Constraint is of one Ring Type;
 
 Role is where
-	FactType has at least one Ordinal role;
-Role is of RingConstraint,
-	RingConstraint has at most one Role;
+	Fact Type has at least one Ordinal role;
+Implicit Fact Type is implied by one Role,
+	Role implies at most one Implicit Fact Type;
+Ring Constraint has at most one other-Role;
+Ring Constraint has other-Role,
+	other-Role is of Ring Constraint;
+Role is of Ring Constraint,
+	Ring Constraint has at most one Role;
 Role has at most one role-Name,
 	role-Name is name of at least one Role;
-other-Role is of RingConstraint,
-	RingConstraint has at most one other-Role;
 
-RoleSequence is identified by its Id;
-PresenceConstraint covers one RoleSequence;
-Reading is in one RoleSequence,
-	RoleSequence is for Reading;
+Role Sequence is identified by its Id;
+Join projects one Role Sequence;
+Presence Constraint covers one Role Sequence;
+Reading is in one Role Sequence,
+	Role Sequence is for Reading;
+Role Sequence has unused dependency to force table in norma;
 
-RoleValue is identified by Instance and Fact where
-	Instance plays RoleValue,
-	RoleValue is of one Instance,
-	RoleValue fulfils one Fact,
-	Fact includes at least one RoleValue;
-RoleValue is of one Role;
+Role Value is identified by Instance and Fact where
+	Instance plays Role Value,
+	Role Value is of one Instance,
+	Role Value fulfils one Fact,
+	Fact includes at least one Role Value;
+Role Value is of one Role;
 
-SetConstraint is a kind of Constraint;
+Set Constraint is a kind of Constraint;
 
-SubsetConstraint is a kind of SetConstraint;
-SubsetConstraint covers one subset-RoleSequence;
-SubsetConstraint covers one superset-RoleSequence;
+Shape is identified by its Id;
+Shape is at at most one Position;
+Shape is expanded;
+
+Subset Constraint is a kind of Set Constraint;
+Subset Constraint covers one subset-Role Sequence;
+Subset Constraint covers one superset-Role Sequence;
 
 Unit is identified by its Id;
+Ephemera URL provides Unit coefficient,
+	Unit uses coefficient from at most one Ephemera URL;
 Name is of Unit,
 	Unit is called one Name;
 Unit has at most one Coefficient;
 Unit has at most one Offset;
-Unit is ephemeral;
+Unit has at most one plural-Name;
 Unit is fundamental;
 
 Value is identified by Literal and Value is a string and Unit where
@@ -124,9 +168,9 @@ Value is identified by Literal and Value is a string and Unit where
 	Unit is of Value;
 Instance has at most one Value;
 
-ValueRestriction is identified by its Id;
-Role has at most one role-ValueRestriction,
-	ValueRestriction applies to Role;
+Value Constraint is a kind of Constraint;
+Role has at most one role-Value Constraint,
+	Value Constraint applies to at most one Role;
 
 Vocabulary is identified by Name where
 	Vocabulary is called one Name;
@@ -135,10 +179,11 @@ Vocabulary contains Constraint,
 Vocabulary includes Unit,
 	Unit is in one Vocabulary;
 
-Agreement is identified by ContextNote where
-	ContextNote was added by at most one Agreement,
-	Agreement covers one ContextNote;
-Agreement was on at most one Date;
+Agreement is identified by Context Note where
+	Context Note was added by at most one Agreement,
+	Agreement covers one Context Note;
+Agreement was on at most one Date,
+	Date is of Agreement;
 
 Bound is identified by Value and Bound is inclusive where
 	Bound has one Value,
@@ -149,29 +194,61 @@ Concept is identified by Vocabulary and Name where
 	Concept belongs to one Vocabulary,
 	Vocabulary contains Concept,
 	Concept is called one Name;
-Concept has ContextNote,
-	ContextNote applies to at most one Concept;
+Concept has Context Note,
+	Context Note applies to at most one Concept;
 Concept uses at most one Pronoun;
 Concept plays Role,
 	Role is played by one Concept;
 Concept is independent;
 Instance is of one Concept;
+Join Node is for one Concept,
+	Concept is referenced in Join Node;
+
+Constraint Shape is a kind of Shape;
+Constraint Shape is for one Constraint;
 
-ContextAccordingTo is where
-	ContextNote is according to Person,
-	Person claims ContextNote;
+Context According To is where
+	Context Note is according to Agent,
+	Agent claims Context Note;
+Context According To was lodged on at most one Date;
 
-ContextAgreedBy is where
-	Agreement was reached by Person,
-	Person agreed on Agreement;
+Context Agreed By is where
+	Agreement was reached by Agent,
+	Agent agreed on Agreement;
 
 Derivation is where
-	Unit (as DerivedUnit) is derived from base-Unit (as BaseUnit) [acyclic, intransitive];
+	Unit (as Derived Unit) is derived from base-Unit (as Base Unit) [acyclic, intransitive];
 Derivation has at most one Exponent;
 
-EntityType is a kind of Concept;
-EntityType nests at most one FactType,
-	FactType is nested as at most one EntityType;
+Diagram is identified by Vocabulary and Name where
+	Diagram is for one Vocabulary,
+	Vocabulary contains Diagram,
+	Diagram is called one Name,
+	Name is of Diagram;
+Shape is in one Diagram,
+	Diagram includes Shape;
+
+Entity Type is a kind of Concept;
+Entity Type nests at most one Fact Type,
+	Fact Type is nested as at most one Entity Type;
+
+Fact Type Shape is a kind of Shape;
+Fact Type Shape has at most one Display Role Names Setting;
+Fact Type Shape is for one Fact Type,
+	Fact Type has Fact Type Shape;
+Fact Type Shape has at most one Rotation Setting;
+
+Model Note Shape is a kind of Shape;
+Model Note Shape is for one Context Note;
+
+Object Type Shape is a kind of Shape;
+Object Type Shape is for one Concept,
+	Concept has Object Type Shape;
+Object Type Shape has expanded reference mode;
+
+Objectified Fact Type Name Shape is a kind of Shape identified by Fact Type Shape where
+	Objectified Fact Type Name Shape is for one Fact Type Shape,
+	Fact Type Shape has at most one Objectified Fact Type Name Shape;
 
 Population is identified by Vocabulary and Name where
 	Vocabulary includes Population,
@@ -182,112 +259,140 @@ Population includes Fact,
 	Fact belongs to one Population;
 Population includes Instance,
 	Instance belongs to one Population;
-Population includes RoleValue,
-	RoleValue belongs to one Population;
-
-RoleRef is where
-	RoleSequence in Ordinal position includes at most one Role,
-	Role is in RoleSequence in at most one Ordinal place,
-	RoleSequence includes Role in Ordinal place,
-	Role has Ordinal place in RoleSequence;
-RoleRef has at most one leading-Adjective;
-RoleRef has at most one trailing-Adjective;
-
-SetComparisonConstraint is a kind of SetConstraint;
-
-SetComparisonRoles is where
-	SetComparisonConstraint has in Ordinal position at most one RoleSequence,
-	RoleSequence is Ordinal in SetComparisonConstraint,
-	in Ordinal position SetComparisonConstraint has RoleSequence,
-	SetComparisonConstraint has RoleSequence in at most one Ordinal position;
-
-SetEqualityConstraint is a kind of SetComparisonConstraint;
-
-SetExclusionConstraint is a kind of SetComparisonConstraint;
-SetExclusionConstraint is mandatory;
-
-TypeInheritance is a kind of FactType identified by Subtype and Supertype where
-	EntityType (as Subtype) is subtype of super-EntityType (as Supertype) [acyclic],
+Population includes Role Value,
+	Role Value belongs to one Population;
+
+Reading Shape is a kind of Shape identified by Fact Type Shape where
+	Fact Type Shape has at most one Reading Shape,
+	Reading Shape is for one Fact Type Shape;
+Reading Shape is for one Reading,
+	Reading has Reading Shape;
+
+Ring Constraint Shape is a kind of Constraint Shape;
+Ring Constraint Shape is attached to one Fact Type;
+
+Role Display is where
+	Fact Type Shape displays Role in Ordinal position,
+	Fact Type Shape displays in Ordinal position at most one Role;
+
+Role Name Shape is a kind of Shape;
+Role Name Shape is for one Role Display,
+	Role Display has at most one Role Name Shape;
+
+Role Ref is where
+	Role Sequence in Ordinal position includes at most one Role,
+	Role is in Role Sequence in at most one Ordinal place,
+	Role Sequence includes Role in Ordinal place,
+	Role has Ordinal place in Role Sequence;
+Role Ref connects to at most one Join Node,
+	Join Node includes Role Ref;
+Role Ref has at most one leading-Adjective;
+Role Ref has at most one trailing-Adjective;
+
+Set Comparison Constraint is a kind of Set Constraint;
+
+Set Comparison Roles is where
+	Set Comparison Constraint has in Ordinal position at most one Role Sequence,
+	Role Sequence is Ordinal in Set Comparison Constraint,
+	in Ordinal position Set Comparison Constraint has Role Sequence,
+	Set Comparison Constraint has Role Sequence in at most one Ordinal position;
+
+Set Equality Constraint is a kind of Set Comparison Constraint;
+
+Set Exclusion Constraint is a kind of Set Comparison Constraint;
+Set Exclusion Constraint is mandatory;
+
+Type Inheritance is a kind of Fact Type identified by Subtype and Supertype where
+	Entity Type (as Subtype) is subtype of super-Entity Type (as Supertype) [acyclic],
 	Supertype is supertype of Subtype;
-Assimilation applies to TypeInheritance,
-	TypeInheritance uses at most one Assimilation;
-TypeInheritance provides identification;
-
-ValueRange is identified by minimum-Bound and maximum-Bound where
-	ValueRange has at most one minimum-Bound,
-	ValueRange has at most one maximum-Bound;
-
-ValueType is a kind of Concept;
-ValueType has at most one Length,
-	Length is of ValueType;
-ValueType has at most one Scale,
-	Scale is of ValueType;
-ValueType is of at most one Unit;
-ValueType has at most one ValueRestriction;
-ValueType is subtype of at most one super-ValueType (as Supertype) [acyclic],
-	Supertype is supertype of ValueType;
-
-AllowedRange is where
-	ValueRestriction allows at least one ValueRange;
-
-Join is where
-	RoleRef has Ordinal (as JoinStep) join;
-Join traverses at most one Concept,
-	Concept is traversed by Join;
-Join has at most one input-Role;
-Join has at most one output-Role;
+Assimilation applies to Type Inheritance,
+	Type Inheritance uses at most one Assimilation;
+Type Inheritance provides identification;
+
+Value Constraint Shape is a kind of Constraint Shape;
+Role Display has at most one Value Constraint Shape,
+	Value Constraint Shape is for at most one Role Display;
+Value Constraint Shape is for at most one Object Type Shape,
+	Object Type Shape has Value Constraint Shape;
+
+Value Range is identified by minimum-Bound and maximum-Bound where
+	Value Range has at most one minimum-Bound,
+	Value Range has at most one maximum-Bound;
+
+Value Type is a kind of Concept;
+Value Type has at most one Length,
+	Length is of Value Type;
+Value Type has at most one Scale,
+	Scale is of Value Type;
+Value Type is of at most one Unit;
+Value Type has at most one Value Constraint,
+	Value Constraint constrains at most one Value Type;
+Value Type is subtype of at most one super-Value Type (as Supertype) [acyclic],
+	Supertype is supertype of Value Type;
+Value Type is auto-assigned;
+
+Allowed Range is where
+	Value Constraint allows at least one Value Range;
+
+ImplicitBooleanValueType is a kind of Value Type;
 
 Parameter is where
-	Name is a parameter of ValueType,
-	ValueType has parameter called Name;
+	Name is a parameter of Value Type,
+	Value Type has parameter called Name;
 
-ParamValue is where
-	Value for Parameter applies to at most one ValueType;
+Param Value is where
+	Value for Parameter applies to at most one Value Type;
 
 /*
  * Constraints:
  */
-either Concept is an EntityType or Concept is a ValueType but not both;
+either Concept is an Entity Type or Concept is a Value Type but not both;
 for each Constraint exactly one of these holds:
-	PresenceConstraint is a kind of Constraint,
-	SetConstraint is a kind of Constraint,
-	RingConstraint is a kind of Constraint;
-for each ContextNote exactly one of these holds:
-	Concept has ContextNote,
-	FactType has ContextNote,
-	Constraint has ContextNote;
+	Constraint is a Presence Constraint,
+	Constraint is a Set Constraint,
+	Constraint is a Ring Constraint;
+for each Context Note exactly one of these holds:
+	Context Note applies to Concept,
+	Context Note applies to Fact Type,
+	Context Note applies to Constraint;
+either Set Comparison Constraint is a Set Exclusion Constraint or Set Comparison Constraint is a Set Equality Constraint but not both;
+either Set Constraint is a Set Comparison Constraint or Set Constraint is a Subset Constraint but not both;
+either Unit uses coefficient from Ephemera URL or Unit has Coefficient but not both;
+either Unit is fundamental or Unit is derived from base-Unit but not both;
+either Value Constraint Shape is for Object Type Shape or Value Constraint Shape is for Role Display but not both;
+either Value Constraint constrains Value Type or Value Constraint applies to Role but not both;
 for each Instance at most one of these holds:
 	Instance has Value,
 	Instance objectifies Fact;
-Instance plays RoleValue and Instance is of Concept
+Role Value is of Instance that is of Concept
 	if and only if
-	RoleValue is of Role and Concept plays Role;
-RoleValue fulfils Fact and Fact is of FactType
+	Role Value is of Role that is played by Concept;
+Role Value fulfils Fact that is of Fact Type
 	if and only if
-	RoleValue is of Role and FactType has Ordinal role;
-either SetComparisonConstraint is a SetExclusionConstraint or SetComparisonConstraint is a SetEqualityConstraint but not both;
-either SetConstraint is a SetComparisonConstraint or SetConstraint is a SubsetConstraint but not both;
-either Unit is fundamental or that Unit is derived from some base-Unit but not both;
-PresenceConstraint is preferred identifier
-	only if PresenceConstraint has max-Frequency;
-ValueType has Scale
-	only if ValueType has Length;
-each combination EntityType, TypeInheritance occurs at most one time in
-	EntityType is subtype of super-EntityType,
-	TypeInheritance provides identification;
-each Fact occurs at most one time in
-	Instance objectifies Fact;
-either Join has input-Role or Join has output-Role;
-each PresenceConstraint occurs at least one time in
-	PresenceConstraint has min-Frequency,
-	PresenceConstraint has max-Frequency,
-	PresenceConstraint is mandatory;
-each RoleSequence occurs at least one time in
-	RoleSequence in Ordinal position includes Role;
-either ValueRange has minimum-Bound or ValueRange has maximum-Bound;
+	Role Value is of Role (where Fact Type has Ordinal role);
+Presence Constraint is preferred identifier
+	only if Presence Constraint has max Frequency;
+Value Type has Scale
+	only if Value Type has Length;
+either Agreement was reached by Agent or Agreement was on Date;
+each combination Diagram, Position occurs at most one time in
+	Shape is in Diagram,
+	Shape is at Position;
+each combination Entity Type, Type Inheritance occurs at most one time in
+	Entity Type is subtype of super Entity Type,
+	Type Inheritance provides identification;
+each Presence Constraint occurs at least one time in
+	Presence Constraint has min Frequency,
+	Presence Constraint has max Frequency,
+	Presence Constraint is mandatory;
+each Role Sequence occurs at least one time in
+	Role Sequence in Ordinal position includes Role;
+each Set Comparison Constraint occurs at least 2 times in
+	Set Comparison Constraint has in Ordinal position Role Sequence;
+either Value Range has minimum Bound or Value Range has maximum Bound;
 each combination Vocabulary, Name occurs at most one time in
-	Vocabulary contains Constraint,
-	Name is of Constraint;
+	Constraint belongs to Vocabulary,
+	Constraint is called Name;
 each combination Vocabulary, Name occurs at most one time in
-	Vocabulary includes Unit,
-	Name is of Unit;
+	Unit is in Vocabulary,
+	Unit is called Name;