From 39b287f37e611e317528f7835c939ca349ab9345 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Tue, 29 Jan 2019 23:59:50 +0300
Subject: [PATCH 01/22] Added Exlusion constraint as described at
 https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-EXCLUSION

---
 .../instance/isExclusionConstraint.st                 |  3 +++
 .../properties.json                                   |  3 +++
 .../instance/asFmxSQLEntityIn.withMappingdict..st     |  9 +++++++++
 .../SqlExclusionConstraint.extension/properties.json  |  3 +++
 .../FmxSQLExclusionConstraint.class/README.md         | 10 ++++++++++
 .../class/annotation.st                               |  7 +++++++
 .../class/generatedSlotNames.st                       |  5 +++++
 .../class/generatedTraitNames.st                      |  4 ++++
 .../class/requirements.st                             |  5 +++++
 .../FmxSQLExclusionConstraint.class/properties.json   | 11 +++++++++++
 10 files changed, 60 insertions(+)
 create mode 100644 repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/instance/isExclusionConstraint.st
 create mode 100644 repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/properties.json
 create mode 100644 repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/instance/asFmxSQLEntityIn.withMappingdict..st
 create mode 100644 repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/properties.json
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/README.md
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/annotation.st
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedSlotNames.st
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedTraitNames.st
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/requirements.st
 create mode 100644 repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/properties.json

diff --git a/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/instance/isExclusionConstraint.st b/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/instance/isExclusionConstraint.st
new file mode 100644
index 00000000..1e44fe7f
--- /dev/null
+++ b/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/instance/isExclusionConstraint.st
@@ -0,0 +1,3 @@
+*FamixNGSQL-Extensions
+isExclusionConstraint
+	^ true
\ No newline at end of file
diff --git a/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/properties.json b/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/properties.json
new file mode 100644
index 00000000..869ced2b
--- /dev/null
+++ b/repository/FamixNGSQL-Extensions.package/FmxSQLExclusionConstraint.extension/properties.json
@@ -0,0 +1,3 @@
+{
+	"name" : "FmxSQLExclusionConstraint"
+}
\ No newline at end of file
diff --git a/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/instance/asFmxSQLEntityIn.withMappingdict..st b/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/instance/asFmxSQLEntityIn.withMappingdict..st
new file mode 100644
index 00000000..caa4c4e2
--- /dev/null
+++ b/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/instance/asFmxSQLEntityIn.withMappingdict..st
@@ -0,0 +1,9 @@
+*FamixNGSQL-Importer
+asFmxSQLEntityIn: aMooseModel withMappingdict: pgToFamixEntities
+	^ FmxSQLExclusionConstraint new
+			name: self name;
+			columns: (self constrainedColumns collect: [ :pgColumn | pgToFamixEntities at: pgColumn ]);
+			table: (pgToFamixEntities at: self constrainedColumns anyOne) columnsContainer;
+			source: self code;
+			mooseModel: aMooseModel;
+			yourself
\ No newline at end of file
diff --git a/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/properties.json b/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/properties.json
new file mode 100644
index 00000000..492b7000
--- /dev/null
+++ b/repository/FamixNGSQL-Importer.package/SqlExclusionConstraint.extension/properties.json
@@ -0,0 +1,3 @@
+{
+	"name" : "SqlExclusionConstraint"
+}
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/README.md b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/README.md
new file mode 100644
index 00000000..6aa1925f
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/README.md
@@ -0,0 +1,10 @@
+I represent a EXCLUDE constraint as defined in SQL standard.
+
+Example:
+
+ALTER TABLE vcp.attachments
+ADD CONSTRAINT unique_vcp_attachment_task_constr
+EXCLUDE USING gist (dataset_id WITH =, metric_id WITH =, location_id WITH =,
+   period_type WITH =, user_id WITH =, assignee_id WITH =,
+  tstzrange(start_time, expiration_time, '()') WITH &&)
+WHERE (attachment_type = 'vcp-task');
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/annotation.st b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/annotation.st
new file mode 100644
index 00000000..24611ee3
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/annotation.st
@@ -0,0 +1,7 @@
+meta
+annotation
+
+	<MSEClass: #ExclusionConstraint super: #FmxSQLConstraint>
+	<package: #FamixNGSQL>
+	<generated>
+	^self
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedSlotNames.st b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedSlotNames.st
new file mode 100644
index 00000000..0dd42f4a
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedSlotNames.st
@@ -0,0 +1,5 @@
+generator
+generatedSlotNames
+	<generated>
+	'FmxSQLExclusionConstraint class>>#generatedSlotNames'.
+	^ #()
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedTraitNames.st b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedTraitNames.st
new file mode 100644
index 00000000..6d7d0cbf
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/generatedTraitNames.st
@@ -0,0 +1,4 @@
+generator
+generatedTraitNames
+	<generated>
+	^ #()
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/requirements.st b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/requirements.st
new file mode 100644
index 00000000..49f56ca8
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/class/requirements.st
@@ -0,0 +1,5 @@
+meta
+requirements
+
+	<generated>
+	^ {  }
\ No newline at end of file
diff --git a/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/properties.json b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/properties.json
new file mode 100644
index 00000000..25f31f51
--- /dev/null
+++ b/repository/FamixNGSQL.package/FmxSQLExclusionConstraint.class/properties.json
@@ -0,0 +1,11 @@
+{
+	"commentStamp" : "DmitryDorofeev 1/29/2019 23:51",
+	"super" : "FmxSQLConstraint",
+	"category" : "FamixNGSQL-Entities",
+	"classinstvars" : [ ],
+	"pools" : [ ],
+	"classvars" : [ ],
+	"instvars" : [ ],
+	"name" : "FmxSQLExclusionConstraint",
+	"type" : "normal"
+}
\ No newline at end of file

From 325f6b748064007ad468735bd314d9302948b61c Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Sun, 21 Feb 2021 16:17:03 +0300
Subject: [PATCH 02/22] Added ExclusionConstraint to the MetaModel generation
 process.

---
 ...mxSQLStructuralMetamodelGenerator.class.st | 15 +++++++++++-
 src/FamixNGSQL/FmxSQLEntity.class.st          |  7 ++++++
 .../FmxSQLExclusionConstraint.class.st        | 24 +++++++++++++++++++
 src/FamixNGSQL/FmxSQLTable.class.st           |  5 ++++
 4 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 src/FamixNGSQL/FmxSQLExclusionConstraint.class.st

diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index cc60f926..03e366c3 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -24,7 +24,8 @@ Class {
 		'tWithColumnReference',
 		'tWithTableReference',
 		'namespaceReference',
-		'tWithNamespaceReference'
+		'tWithNamespaceReference',
+		'exclusionConstraint'
 	],
 	#category : #FAMIXNGSQLMetamodelGenerator
 }
@@ -107,6 +108,11 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralEntities [
 		newClassNamed: #CheckConstraint
 		comment: self checkConstraintComment.
 	checkConstraint withTesting.
+	exclusionConstraint := builder
+		newClassNamed: #ExclusionConstraint
+		comment: self exclusionConstraintComment.
+	exclusionConstraint withTesting.
+	
 	primaryKeyConstraint := builder
 		newClassNamed: #PrimaryKeyConstraint
 		comment: self primaryKeyConstraintComment.
@@ -181,6 +187,8 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralHierarchy [
 	type --|> structuralEntity.
 	type --|> tAbstractType.
 	
+	checkConstraint --|> constraint.
+	exclusionConstraint --|> constraint.
 	primaryKeyConstraint --|> constraint.
 	foreignKeyConstraint --|> constraint.
 	notNullConstraint --|> constraint.
@@ -261,6 +269,11 @@ FmxSQLStructuralMetamodelGenerator >> entityInNamespaceComment [
 	^ 'I am a trait that any entity which can be part of a namespace use.'
 ]
 
+{ #category : #'comments - SQL' }
+FmxSQLStructuralMetamodelGenerator >> exclusionConstraintComment [
+	^ 'I represent an EXCLUSION constraint as defined in SQL standard.'
+]
+
 { #category : #'comments - SQL' }
 FmxSQLStructuralMetamodelGenerator >> foreignKeyConstraintComment [
 	^ 'I represent a FOREIGN KEY constraint as defined in SQL standard.'
diff --git a/src/FamixNGSQL/FmxSQLEntity.class.st b/src/FamixNGSQL/FmxSQLEntity.class.st
index 9aaf79e4..48ab4cd2 100644
--- a/src/FamixNGSQL/FmxSQLEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLEntity.class.st
@@ -102,6 +102,13 @@ FmxSQLEntity >> isExceptClause [
 	^ false
 ]
 
+{ #category : #testing }
+FmxSQLEntity >> isExclusionConstraint [
+
+	<generated>
+	^ false
+]
+
 { #category : #testing }
 FmxSQLEntity >> isForeignKey [
 	self deprecated: 'Use #isForeignKeyConstraint instead.' transformWith: '`@receiver isForeignKey' -> '`@receiver isForeignKeyConstraint'.
diff --git a/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
new file mode 100644
index 00000000..cfbe0057
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
@@ -0,0 +1,24 @@
+"
+I represent a EXCLUSION constraint as defined in SQL standard.
+"
+Class {
+	#name : #FmxSQLExclusionConstraint,
+	#superclass : #FmxSQLConstraint,
+	#category : #'FamixNGSQL-Entities'
+}
+
+{ #category : #meta }
+FmxSQLExclusionConstraint class >> annotation [
+
+	<MSEClass: #ExclusionConstraint super: #FmxSQLConstraint>
+	<package: #FamixNGSQL>
+	<generated>
+	^self
+]
+
+{ #category : #testing }
+FmxSQLExclusionConstraint >> isExclusionConstraint [
+
+	<generated>
+	^ true
+]
diff --git a/src/FamixNGSQL/FmxSQLTable.class.st b/src/FamixNGSQL/FmxSQLTable.class.st
index eff41a86..1b8a1bd2 100644
--- a/src/FamixNGSQL/FmxSQLTable.class.st
+++ b/src/FamixNGSQL/FmxSQLTable.class.st
@@ -87,6 +87,11 @@ FmxSQLTable >> constraintsSatisfying: aBlock [
 	^ self constraints select: aBlock
 ]
 
+{ #category : #accessing }
+FmxSQLTable >> exclusionConstraints [
+	^ self constraintsSatisfying: [ :c | c class = FmxSQLExclusionConstraint ]
+]
+
 { #category : #accessing }
 FmxSQLTable >> foreignKeyConstraints [
 	^ self constraintsSatisfying: [ :c | c class = FmxSQLForeignKeyConstraint ]

From 7af7700305360d03f4af5292c3f73418979ec434 Mon Sep 17 00:00:00 2001
From: Dmitriy Dorofeev <dima@yasp.com>
Date: Sun, 21 Feb 2021 16:20:42 +0300
Subject: [PATCH 03/22] Fix the update metamodel help text

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d450eebe..c1bbe125 100644
--- a/README.md
+++ b/README.md
@@ -19,4 +19,4 @@ meta-model.
 If you modified the generator and want to re-generate the meta-model, you have
 to:
 1. Ensure that no more instances of the meta-model exist in the system.
-2. Run `FmxNewSQLMetamodelGenerator class>>#regenerateMetaModel`
+2. Run `FmxSQLMetamodelGenerator generate.`

From 2d12fc5efcf24b6a36b2cb76a29a5a2ca3c492e7 Mon Sep 17 00:00:00 2001
From: Dmitriy Dorofeev <dima@yasp.com>
Date: Mon, 30 May 2022 00:08:28 +0300
Subject: [PATCH 04/22] Update BaselineOfFAMIXNGSQL.class.st

---
 src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
index af320210..f0ca8911 100644
--- a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
+++ b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
@@ -25,7 +25,7 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 			spec
 				baseline: 'Famix'
 				with: [ spec
-						repository: 'github://jecisc/Famix:v4.x.x/src';
+						repository: 'github://moosetechnology/Famix:development/src';
 						loads: #('Core' 'Basic') ].
 			spec
 				baseline: 'SymbolResolver'

From af698ac68135b8bd318bec48549d53e35054c32e Mon Sep 17 00:00:00 2001
From: Dmitriy Dorofeev <dima@yasp.com>
Date: Mon, 30 May 2022 01:17:09 +0300
Subject: [PATCH 05/22] Reflect Moose changes for TNamespaceEntity ->
 TNamedEntity

---
 .../FmxSQLStructuralMetamodelGenerator.class.st                 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index 03e366c3..937fc0af 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -168,7 +168,7 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralEntitiesRelations [
 FmxSQLStructuralMetamodelGenerator >> defineStructuralHierarchy [
 	"Abstract entities inheritance relations."
 	structuralEntity --|> namedEntity.
-	structuralEntity --|> #TNamespaceEntity.
+	structuralEntity --|> #TNamedEntity.
 	
 	constraint --|> structuralEntity.
 	constraint --|> tWithColumnReference.

From 89be4fb394a0daf3f08dd249d42cf1cd8b6faa55 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Mon, 30 May 2022 01:34:20 +0300
Subject: [PATCH 06/22]  fix trait TNamespaceEntity

---
 .../FmxSQLMetamodelGenerator.class.st                       | 6 +++---
 src/FamixNGSQL/FmxSQLStoredProcedure.class.st               | 4 ++--
 src/FamixNGSQL/FmxSQLStructuralEntity.class.st              | 4 ++--
 src/FamixNGSQL/FmxSQLTrigger.class.st                       | 4 ++--
 src/FamixNGSQL/FmxSQLView.class.st                          | 4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index 92662a2c..e340cf12 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -309,7 +309,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	view --|> tAbstractType.
 	view --|> tColumnsContainer.
 	view --|> tQueryContainer.
-	view --|> #TNamespaceEntity.
+	view --|> #TNamedEntity.
 	view --|> #TWithImmediateSource.
 	view --|> namedEntity.
 	
@@ -321,7 +321,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	storedProcedure --|> behaviouralEntity.
 	storedProcedure --|> tQueryContainer.
 	storedProcedure --|> namedEntity.
-	storedProcedure--|> #TNamespaceEntity.
+	storedProcedure--|> #TNamedEntity.
 	storedProcedure --|> #TWithReferences.
 	storedProcedure --|> #TInvocable.
 	storedProcedure --|> #TWithInvocations.
@@ -341,7 +341,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	
 	trigger --|> namedEntity.
 	trigger --|> behaviouralEntity.
-	trigger --|> #TNamespaceEntity.
+	trigger --|> #TNamedEntity.
 	
 	selectQuery --|> crudQuery.
 	selectQuery --|> tDefiningDerivedTables.
diff --git a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
index ea981f4d..2c711242 100644
--- a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
+++ b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
@@ -4,8 +4,8 @@ I am a stored procedure. That is to say, a function that is defined inside the d
 Class {
 	#name : #FmxSQLStoredProcedure,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTInvocable + FamixTNamespaceEntity + FamixTWithAccesses + FamixTWithImmediateSource + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTQueryContainer + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTInvocable classTrait + FamixTNamespaceEntity classTrait + FamixTWithAccesses classTrait + FamixTWithImmediateSource classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTInvocable + FamixTNamedEntity + FamixTWithAccesses + FamixTWithImmediateSource + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTQueryContainer + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTInvocable classTrait + FamixTNamedEntity classTrait + FamixTWithAccesses classTrait + FamixTWithImmediateSource classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#instVars : [
 		'#checkConstraintsCalling => FMMany type: #FmxSQLCheckConstraint opposite: #storedProceduresCalled',
 		'#returnType => FMOne type: #FmxSQLAbstractType opposite: #storedProceduresReturning'
diff --git a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
index aa7be260..2fadd361 100644
--- a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
@@ -4,8 +4,8 @@ I am an abstract superclass for structural entities. A structural entity is an e
 Class {
 	#name : #FmxSQLStructuralEntity,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamespaceEntity',
-	#classTraits : 'FamixTNamespaceEntity classTrait',
+	#traits : 'FamixTNamedEntity',
+	#classTraits : 'FamixTNamedEntity classTrait',
 	#category : 'FamixNGSQL-Entities'
 }
 
diff --git a/src/FamixNGSQL/FmxSQLTrigger.class.st b/src/FamixNGSQL/FmxSQLTrigger.class.st
index c42e2732..4be74326 100644
--- a/src/FamixNGSQL/FmxSQLTrigger.class.st
+++ b/src/FamixNGSQL/FmxSQLTrigger.class.st
@@ -4,8 +4,8 @@ I am a trigger. A trigger allows to define actions to performs when a specific e
 Class {
 	#name : #FmxSQLTrigger,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamespaceEntity + FmxSQLBehaviouralEntity',
-	#classTraits : 'FamixTNamespaceEntity classTrait + FmxSQLBehaviouralEntity classTrait',
+	#traits : 'FamixTNamedEntity + FmxSQLBehaviouralEntity',
+	#classTraits : 'FamixTNamedEntity classTrait + FmxSQLBehaviouralEntity classTrait',
 	#instVars : [
 		'#firingAction => FMProperty',
 		'#when => FMProperty',
diff --git a/src/FamixNGSQL/FmxSQLView.class.st b/src/FamixNGSQL/FmxSQLView.class.st
index 7556c9b5..2e8a717a 100644
--- a/src/FamixNGSQL/FmxSQLView.class.st
+++ b/src/FamixNGSQL/FmxSQLView.class.st
@@ -4,8 +4,8 @@ I am a view. I can be used transparently as a table but I do not hold data. My d
 Class {
 	#name : #FmxSQLView,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamespaceEntity + FamixTWithImmediateSource + FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTQueryContainer',
-	#classTraits : 'FamixTNamespaceEntity classTrait + FamixTWithImmediateSource classTrait + FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTQueryContainer classTrait',
+	#traits : 'FamixTNamedEntity + FamixTWithImmediateSource + FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTQueryContainer',
+	#classTraits : 'FamixTNamedEntity classTrait + FamixTWithImmediateSource classTrait + FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTQueryContainer classTrait',
 	#instVars : [
 		'#query => FMOne type: #FmxSQLSelectQuery opposite: #viewDefining',
 		'#references => FMMany type: #FmxSQLViewReference opposite: #view'

From 83d53793d4509965f47d4c12def300a55fd26750 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 27 Jul 2023 23:42:12 +0300
Subject: [PATCH 07/22] Model is generated under Pharo 10, but there are some
 issues with traits. Also, we can not import data into model, due to wrong
 things with #TNamespace etc...

---
 .../FmxSQLMetamodelGenerator.class.st         |  75 +++++-----
 ...mxSQLStructuralMetamodelGenerator.class.st |  16 ++-
 src/FamixNGSQL/FmxSQLAbstractType.trait.st    |  34 ++++-
 src/FamixNGSQL/FmxSQLAlias.class.st           |  24 +---
 src/FamixNGSQL/FmxSQLAliasAccess.class.st     |   2 +-
 src/FamixNGSQL/FmxSQLAssociation.class.st     |   8 +-
 .../FmxSQLBehaviouralEntity.trait.st          |   2 +-
 src/FamixNGSQL/FmxSQLCRUDQuery.class.st       |  56 ++------
 src/FamixNGSQL/FmxSQLCheckConstraint.class.st |  16 ++-
 src/FamixNGSQL/FmxSQLClause.class.st          |  44 +-----
 src/FamixNGSQL/FmxSQLColumn.class.st          |  56 +-------
 src/FamixNGSQL/FmxSQLColumnAlias.class.st     |  28 +---
 .../FmxSQLColumnAliasAccess.class.st          |   2 +-
 src/FamixNGSQL/FmxSQLColumnReference.class.st |  45 +-----
 .../FmxSQLColumnsContainer.trait.st           |  15 +-
 .../FmxSQLColumnsContainerAlias.class.st      |  12 +-
 ...FmxSQLColumnsContainerAliasAccess.class.st |   2 +-
 src/FamixNGSQL/FmxSQLComment.class.st         |   4 +-
 src/FamixNGSQL/FmxSQLConstraint.class.st      |  30 +---
 src/FamixNGSQL/FmxSQLCursor.class.st          |  32 +----
 src/FamixNGSQL/FmxSQLCursorParameter.class.st |  38 +----
 .../FmxSQLCursorParameterAccess.class.st      |   2 +-
 src/FamixNGSQL/FmxSQLCursorReference.class.st |   8 +-
 src/FamixNGSQL/FmxSQLDeleteQuery.class.st     |   4 +-
 src/FamixNGSQL/FmxSQLDerivedTable.class.st    |  43 +-----
 .../FmxSQLDerivedTableReference.class.st      |   4 +-
 src/FamixNGSQL/FmxSQLEntity.class.st          |  23 +---
 .../FmxSQLEntitySourceAnchor.class.st         |  31 +----
 src/FamixNGSQL/FmxSQLExceptClause.class.st    |   2 +-
 .../FmxSQLExclusionConstraint.class.st        |   4 +-
 .../FmxSQLForeignKeyConstraint.class.st       |  46 +------
 src/FamixNGSQL/FmxSQLForeignTable.class.st    |   2 +-
 src/FamixNGSQL/FmxSQLFromClause.class.st      |   6 +-
 src/FamixNGSQL/FmxSQLGroupByClause.class.st   |  11 +-
 src/FamixNGSQL/FmxSQLHavingClause.class.st    |   6 +-
 src/FamixNGSQL/FmxSQLInsertQuery.class.st     |   4 +-
 src/FamixNGSQL/FmxSQLIntersectClause.class.st |   2 +-
 src/FamixNGSQL/FmxSQLIntoClause.class.st      |   2 +-
 src/FamixNGSQL/FmxSQLJoinClause.class.st      |   2 +-
 src/FamixNGSQL/FmxSQLLimitClause.class.st     |   2 +-
 src/FamixNGSQL/FmxSQLLocalVariable.class.st   |  38 +----
 .../FmxSQLLocalVariableAccess.class.st        |   3 +-
 src/FamixNGSQL/FmxSQLModel.class.st           |  18 +++
 src/FamixNGSQL/FmxSQLMooseModel.class.st      |  17 ---
 src/FamixNGSQL/FmxSQLNamedEntity.class.st     |  10 +-
 src/FamixNGSQL/FmxSQLNamespace.class.st       |  10 +-
 .../FmxSQLNamespaceReference.class.st         |   8 +-
 .../FmxSQLNewLocalVariable.class.st           |   4 +-
 src/FamixNGSQL/FmxSQLNoSourceAnchor.class.st  |  25 ----
 .../FmxSQLNotNullConstraint.class.st          |  14 +-
 .../FmxSQLOldLocalVariable.class.st           |   4 +-
 .../FmxSQLOnConflictClause.class.st           |   2 +-
 src/FamixNGSQL/FmxSQLOrderByClause.class.st   |  11 +-
 src/FamixNGSQL/FmxSQLParameter.class.st       |  43 +-----
 src/FamixNGSQL/FmxSQLParameterAccess.class.st |   9 +-
 .../FmxSQLPrimaryKeyConstraint.class.st       |  16 +--
 .../FmxSQLQualifiedReference.class.st         |  10 +-
 .../FmxSQLRecordLocalVariable.class.st        |   5 +-
 src/FamixNGSQL/FmxSQLReference.class.st       |  87 +-----------
 src/FamixNGSQL/FmxSQLReferencesGroup.class.st |  20 ++-
 .../FmxSQLReferencesGroupReference.class.st   |  41 +-----
 src/FamixNGSQL/FmxSQLReturningClause.class.st |  13 +-
 src/FamixNGSQL/FmxSQLSelectClause.class.st    |  11 +-
 src/FamixNGSQL/FmxSQLSelectQuery.class.st     |  20 +--
 src/FamixNGSQL/FmxSQLSetClause.class.st       |  13 +-
 src/FamixNGSQL/FmxSQLSourceAnchor.class.st    |   2 +-
 src/FamixNGSQL/FmxSQLSourceLanguage.class.st  |   4 +-
 .../FmxSQLSourceTextAnchor.class.st           |   8 +-
 src/FamixNGSQL/FmxSQLSourcedEntity.class.st   |   6 +-
 src/FamixNGSQL/FmxSQLStoredProcedure.class.st |  83 +----------
 .../FmxSQLStoredProcedureCall.class.st        |  17 +--
 .../FmxSQLStructuralEntity.class.st           |   8 +-
 src/FamixNGSQL/FmxSQLTArgument.trait.st       |   2 +-
 src/FamixNGSQL/FmxSQLTColumn.trait.st         |   7 +-
 .../FmxSQLTDefiningDerivedTables.trait.st     |   8 +-
 src/FamixNGSQL/FmxSQLTNamedEntity.trait.st    |  13 ++
 src/FamixNGSQL/FmxSQLTQueryContainer.trait.st |  10 +-
 .../FmxSQLTReferencesGroupReference.trait.st  |   6 +-
 src/FamixNGSQL/FmxSQLTWithAccesses.trait.st   |  13 ++
 src/FamixNGSQL/FmxSQLTWithAlias.trait.st      |  10 +-
 .../FmxSQLTWithColumnReference.trait.st       |  12 +-
 src/FamixNGSQL/FmxSQLTWithCursor.trait.st     |  10 +-
 .../FmxSQLTWithCursorReference.trait.st       |  12 +-
 .../FmxSQLTWithDerivedTableReference.trait.st |  12 +-
 .../FmxSQLTWithEntitySourceAnchor.trait.st    |  12 +-
 .../FmxSQLTWithImmediateSource.trait.st       |  13 ++
 .../FmxSQLTWithNamespaceReference.trait.st    |  10 +-
 .../FmxSQLTWithQualifiedReference.trait.st    |   3 +-
 ...xSQLTWithReferencesGroupReference.trait.st |  10 +-
 .../FmxSQLTWithTableReference.trait.st        |  12 +-
 .../FmxSQLTWithViewReference.trait.st         |  12 +-
 src/FamixNGSQL/FmxSQLTable.class.st           |  92 ++++---------
 src/FamixNGSQL/FmxSQLTableReference.class.st  |   4 +-
 src/FamixNGSQL/FmxSQLTrigger.class.st         |  51 +------
 .../FmxSQLTriggerStoredProcedure.class.st     |  21 ++-
 src/FamixNGSQL/FmxSQLType.class.st            |  20 ++-
 src/FamixNGSQL/FmxSQLTypeReference.class.st   |   5 +-
 src/FamixNGSQL/FmxSQLUnionClause.class.st     |   2 +-
 .../FmxSQLUniqueConstraint.class.st           |  16 +--
 .../FmxSQLUnknownSourceLanguage.class.st      |   6 +-
 src/FamixNGSQL/FmxSQLUpdateQuery.class.st     |   5 +-
 src/FamixNGSQL/FmxSQLUsingClause.class.st     |   2 +-
 src/FamixNGSQL/FmxSQLValuesClause.class.st    |   8 +-
 src/FamixNGSQL/FmxSQLValuesQuery.class.st     |   2 +-
 src/FamixNGSQL/FmxSQLView.class.st            | 130 ++----------------
 src/FamixNGSQL/FmxSQLViewReference.class.st   |   4 +-
 src/FamixNGSQL/FmxSQLWhereClause.class.st     |  11 +-
 src/FamixNGSQL/FmxSQLWithClause.class.st      |   2 +-
 108 files changed, 552 insertions(+), 1341 deletions(-)
 create mode 100644 src/FamixNGSQL/FmxSQLModel.class.st
 delete mode 100644 src/FamixNGSQL/FmxSQLMooseModel.class.st
 delete mode 100644 src/FamixNGSQL/FmxSQLNoSourceAnchor.class.st
 create mode 100644 src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
 create mode 100644 src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
 create mode 100644 src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st

diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index e340cf12..c011e9bd 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -67,7 +67,9 @@ Class {
 		'tWithEntitySourceAnchor',
 		'tDefiningDerivedTables',
 		'qualifiedReference',
-		'tWithQualifiedReference'
+		'tWithQualifiedReference',
+		'tWithImmediateSource',
+		'tWithAccesses'
 	],
 	#category : #FAMIXNGSQLMetamodelGenerator
 }
@@ -77,18 +79,18 @@ FmxSQLMetamodelGenerator class >> generate [
 	"This method is just there to make regeneration of the MM easy."
 	<script>
 	[ super generate ] on: Warning do: [ :warning |
-		warning logCr.
-		warning resume ]
+		Transcript show: warning; cr.
+		warning resume]
 ]
 
 { #category : #accessing }
 FmxSQLMetamodelGenerator class >> packageName [
-	^ 'FamixNGSQL'
+	^ #'FamixNGSQL'
 ]
 
 { #category : #accessing }
 FmxSQLMetamodelGenerator class >> prefix [
-	^ 'FmxSQL'
+	^ #'FmxSQL'
 ]
 
 { #category : #'comments - SQL' }
@@ -297,20 +299,20 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	"Abstract entities inheritance relations."
 	behaviouralEntity --|> tWithEntitySourceAnchor.
-	crudQuery --|> entity.
-	crudQuery --|> #TWithSourceAnchor.
+	"crudQuery --|> entity." "FamixTEntity is deprecated"
+	crudQuery --|> #TSourceAnchor.
 	crudQuery --|> #TEntityMetaLevelDependency.
-	crudQuery --|> #TDependencyQueries.
+	"crudQuery --|> #TDependencyQueries." "Now you only need to use TEntityMetaLevelDependency"
 	"Concrete structural entities inheritance relations."
 	checkConstraint --|> constraint.
-	checkConstraint --|> #TWithImmediateSource.
+	checkConstraint --|> tWithImmediateSource.
 	"Concrete behavioural entities inheritance relations."
 	view --|> behaviouralEntity.
 	view --|> tAbstractType.
 	view --|> tColumnsContainer.
 	view --|> tQueryContainer.
-	view --|> #TNamedEntity.
-	view --|> #TWithImmediateSource.
+	view --|> tNamedEntity .
+	view --|> tWithImmediateSource.
 	view --|> namedEntity.
 	
 	derivedTable --|> namedEntity.
@@ -321,27 +323,27 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	storedProcedure --|> behaviouralEntity.
 	storedProcedure --|> tQueryContainer.
 	storedProcedure --|> namedEntity.
-	storedProcedure--|> #TNamedEntity.
+	storedProcedure--|> tNamedEntity.
 	storedProcedure --|> #TWithReferences.
 	storedProcedure --|> #TInvocable.
 	storedProcedure --|> #TWithInvocations.
 	storedProcedure --|> #TWithParameters.
 	storedProcedure --|> #TWithLocalVariables.
-	storedProcedure --|> #TWithAccesses.
+	storedProcedure --|> tWithAccesses.
 	storedProcedure --|> tWithTableReference.
 	storedProcedure --|> tWithAlias.
 	storedProcedure --|> tWithCursor.
 	storedProcedure --|> tWithCursorReference.
 	storedProcedure --|> tWithColumnReference. "For COPY TYPE feature of Postgres."
 	storedProcedure --|> tWithViewReference.
-	storedProcedure --|> #TWithImmediateSource.
+	storedProcedure --|> tWithImmediateSource.
 	storedProcedure --|> tWithNamespaceReference.
 	
 	triggerStoredProcedure --|> storedProcedure.
 	
 	trigger --|> namedEntity.
 	trigger --|> behaviouralEntity.
-	trigger --|> #TNamedEntity.
+	trigger --|> tNamedEntity.
 	
 	selectQuery --|> crudQuery.
 	selectQuery --|> tDefiningDerivedTables.
@@ -394,14 +396,14 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	columnAlias --|> tWithReferencesGroupReference.
 	columnAlias --|> tColumn.
 	
-	referencesGroup --|> entity.
-	referencesGroup --|> #TWithSourceAnchor.
+	"referencesGroup --|> entity." "FamixTEntity is deprecated"
+	referencesGroup --|> #TSourceAnchor.
 	referencesGroup --|> #TEntityMetaLevelDependency.
-	referencesGroup --|> #TDependencyQueries.
+	"referencesGroup --|> #TDependencyQueries."
 	
 	foreignTable --|> table.
 	
-	entitySourceAnchor --|> entity.
+	"entitySourceAnchor --|> entity." "FamixTEntity is deprecated"
 	entitySourceAnchor --|> #TSourceAnchor
 ]
 
@@ -473,8 +475,8 @@ FmxSQLMetamodelGenerator >> defineBehaviouralReferencesHierarchy [
 	referencesGroupReference --|> reference.
 	referencesGroupReference --|> tReferencesGroupReference.
 	referencesGroupReference  --|> #TEntityMetaLevelDependency.
-	referencesGroupReference --|> #TDependencyQueries.
-	qualifiedReference --|> entity.
+	"referencesGroupReference --|> #TDependencyQueries."
+	"qualifiedReference --|> entity." "FamixTEntity is deprecated"
 	qualifiedReference --|> #TSourceEntity.
 	namespaceReference --|> tWithQualifiedReference
 ]
@@ -484,6 +486,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralTraits [
 	tWithDerivedTableReference := builder
 		newTraitNamed: #TWithDerivedTableReference.
 	tWithViewReference := builder newTraitNamed: #TWithViewReference.
+	tWithImmediateSource := builder newTraitNamed: #TWithImmediateSource.
 	tWithAlias := builder newTraitNamed: #TWithAlias.
 	tWithCursor := builder newTraitNamed: #TWithCursor.
 	tWithCursorReference := builder newTraitNamed: #TWithCursorReference.
@@ -496,7 +499,11 @@ FmxSQLMetamodelGenerator >> defineBehaviouralTraits [
 	tDefiningDerivedTables := builder
 		newTraitNamed: #TDefiningDerivedTables.
 	tWithQualifiedReference := builder
-		newTraitNamed: #TWithQualifiedReference
+		newTraitNamed: #TWithQualifiedReference.
+	
+"model is generated, but missed some traits. They are defined in Generator class, but we are not inherited from it :-("
+    tWithAccesses := builder newTraitNamed: #TWithAccesses.
+
 ]
 
 { #category : #'definition - behavioural' }
@@ -615,11 +622,11 @@ FmxSQLMetamodelGenerator >> defineClausesEntities [
 { #category : #'definition - behavioural' }
 FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	"Defining all kinds of clauses"
-	clause --|> entity.
+	"clause --|> entity." "FamixTEntity is deprecated"
 	clause --|> tWithAlias.
-	clause --|> #TWithSourceAnchor.
+	clause --|> #TSourceAnchor.
 	clause --|> #TEntityMetaLevelDependency.
-	clause --|> #TDependencyQueries.
+	"clause --|> #TDependencyQueries."
 	
 	fromClause --|> clause.
 	fromClause --|> tWithTableReference.
@@ -627,13 +634,13 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	fromClause --|> tWithDerivedTableReference.
 	fromClause --|> tWithColumnReference. "Because of join clause"
 	fromClause --|> tWithReferencesGroupReference.
-	fromClause --|> #TWithAccesses. "Because of join clause"
+	fromClause --|> tWithAccesses. "Because of join clause"
 	fromClause --|> #TWithInvocations. "Because of join clause"
 	fromClause --|> tWithNamespaceReference.
 	
 	whereClause --|> clause.
 	whereClause --|> tWithColumnReference.
-	whereClause --|> #TWithAccesses.
+	whereClause --|> tWithAccesses.
 	whereClause --|> #TWithInvocations.
 	whereClause --|> tWithTableReference. "For table.column ref."
 	whereClause --|> tWithViewReference. "For view.column ref."
@@ -644,18 +651,18 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	returningClause --|> clause.
 	returningClause --|> tWithColumnReference.
 	returningClause --|> tWithReferencesGroupReference.
-	returningClause --|> #TWithAccesses.
+	returningClause --|> tWithAccesses.
 	returningClause --|> #TWithInvocations.
 	
 	setClause --|> clause.
 	setClause --|> tWithDerivedTableReference.
 	setClause --|> tWithColumnReference.
-	setClause --|> #TWithAccesses.
+	setClause --|> tWithAccesses.
 	setClause --|> #TWithInvocations.
 	
 	selectClause --|> clause.
 	selectClause --|> tWithColumnReference.
-	selectClause --|> #TWithAccesses.
+	selectClause --|> tWithAccesses.
 	selectClause --|> #TWithInvocations.
 	selectClause --|> tWithTableReference. "Through table.column ref."
 	selectClause --|> tWithDerivedTableReference. "For aliased_derived_table.column ref."
@@ -667,7 +674,7 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	groupByClause --|> tWithTableReference. "For table.column ref."
 	groupByClause --|> tWithViewReference. "For view.column ref."
 	groupByClause --|> tWithReferencesGroupReference.
-	groupByClause --|> #TWithAccesses.
+	groupByClause --|> tWithAccesses.
 	groupByClause --|> #TWithInvocations.
 	groupByClause --|> tWithNamespaceReference.
 	
@@ -676,7 +683,7 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	havingClause --|> tWithTableReference. "For table.column ref."
 	havingClause --|> tWithViewReference. "For view.column ref."
 	havingClause --|> tWithReferencesGroupReference.
-	havingClause --|> #TWithAccesses.
+	havingClause --|> tWithAccesses.
 	havingClause --|> #TWithInvocations.
 	havingClause --|> tWithNamespaceReference.
 	
@@ -685,7 +692,7 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	orderByClause --|> tWithTableReference. "For table.column ref."
 	orderByClause --|> tWithViewReference. "For view.column ref."
 	orderByClause --|> tWithReferencesGroupReference.
-	orderByClause --|> #TWithAccesses.
+	orderByClause --|> tWithAccesses.
 	orderByClause --|> #TWithInvocations.
 	orderByClause --|> tWithNamespaceReference.
 	
@@ -716,7 +723,7 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	valuesClause --|> clause.
 	valuesClause --|> tWithDerivedTableReference.
 	valuesClause --|> tWithColumnReference.
-	valuesClause --|> #TWithAccesses.
+	valuesClause --|> tWithAccesses.
 	valuesClause --|> #TWithInvocations.
 	
 	usingClause --|> clause.
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index 937fc0af..315d902b 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -2,6 +2,7 @@ Class {
 	#name : #FmxSQLStructuralMetamodelGenerator,
 	#superclass : #FamixBasicInfrastructureGenerator,
 	#instVars : [
+		'association',
 		'uniqueConstraint',
 		'constraint',
 		'reference',
@@ -21,11 +22,13 @@ Class {
 		'tColumnsContainer',
 		'tAbstractType',
 		'tColumn',
+		'tArgument',
 		'tWithColumnReference',
 		'tWithTableReference',
 		'namespaceReference',
 		'tWithNamespaceReference',
-		'exclusionConstraint'
+		'exclusionConstraint',
+		'tNamedEntity'
 	],
 	#category : #FAMIXNGSQLMetamodelGenerator
 }
@@ -86,6 +89,8 @@ FmxSQLStructuralMetamodelGenerator >> defineRelations [
 
 { #category : #'definition - structural' }
 FmxSQLStructuralMetamodelGenerator >> defineStructuralEntities [
+	self flag: #TODO. "Add comment for association"
+	association := builder newClassNamed: #Association.
 	structuralEntity := builder
 		newClassNamed: #StructuralEntity
 		comment: self structuralEntityComment.
@@ -168,7 +173,7 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralEntitiesRelations [
 FmxSQLStructuralMetamodelGenerator >> defineStructuralHierarchy [
 	"Abstract entities inheritance relations."
 	structuralEntity --|> namedEntity.
-	structuralEntity --|> #TNamedEntity.
+	structuralEntity --|> tNamedEntity.
 	
 	constraint --|> structuralEntity.
 	constraint --|> tWithColumnReference.
@@ -222,7 +227,7 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralReferenceProperties [
 { #category : #'definition - structural' }
 FmxSQLStructuralMetamodelGenerator >> defineStructuralReferencesHierarchy [
 	reference --|> association.
-	reference --|> #TArgument.
+	reference --|> tArgument.
 	tableReference --|> reference.
 	columnReference --|> reference.
 	typeReference --|> reference.
@@ -232,6 +237,7 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralReferencesHierarchy [
 { #category : #'definition - structural' }
 FmxSQLStructuralMetamodelGenerator >> defineStructuralTraits [
 	tAbstractType := builder newTraitNamed: #AbstractType.
+	tArgument := builder newTraitNamed: #TArgument.
 	tColumn := builder newTraitNamed: #TColumn.
 	tColumnsContainer := builder
 		newTraitNamed: #ColumnsContainer
@@ -242,7 +248,9 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralTraits [
 	tQueryContainer withTesting.
 	tWithColumnReference := builder newTraitNamed: #TWithColumnReference.
 	tWithTableReference := builder newTraitNamed: #TWithTableReference.
-	tWithNamespaceReference := builder newTraitNamed: #TWithNamespaceReference
+	tWithNamespaceReference := builder newTraitNamed: #TWithNamespaceReference.
+	
+   tNamedEntity := builder newTraitNamed: #TNamedEntity.
 ]
 
 { #category : #'definition - structural' }
diff --git a/src/FamixNGSQL/FmxSQLAbstractType.trait.st b/src/FamixNGSQL/FmxSQLAbstractType.trait.st
index 203a5f59..161829d7 100644
--- a/src/FamixNGSQL/FmxSQLAbstractType.trait.st
+++ b/src/FamixNGSQL/FmxSQLAbstractType.trait.st
@@ -12,17 +12,42 @@ Trait {
 { #category : #meta }
 FmxSQLAbstractType classSide >> annotation [
 
-	<MSEClass: #AbstractType super: #Trait>
+	<FMClass: #AbstractType super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLAbstractType >> addCursorParameter: anObject [
+	<generated>
+	^ self cursorParameters add: anObject
+]
+
+{ #category : #adding }
+FmxSQLAbstractType >> addLocalVariable: anObject [
+	<generated>
+	^ self localVariables add: anObject
+]
+
+{ #category : #adding }
+FmxSQLAbstractType >> addParameter: anObject [
+	<generated>
+	^ self parameters add: anObject
+]
+
+{ #category : #adding }
+FmxSQLAbstractType >> addStoredProceduresReturning: anObject [
+	<generated>
+	^ self storedProceduresReturning add: anObject
+]
+
 { #category : #accessing }
 FmxSQLAbstractType >> cursorParameters [
 	"Relation named: #cursorParameters type: #FmxSQLCursorParameter opposite: #type"
 
 	<generated>
+	<derived>
 	^ cursorParameters
 ]
 
@@ -31,7 +56,6 @@ FmxSQLAbstractType >> cursorParameters: anObject [
 
 	<generated>
 	cursorParameters value: anObject
-
 ]
 
 { #category : #accessing }
@@ -39,6 +63,7 @@ FmxSQLAbstractType >> localVariables [
 	"Relation named: #localVariables type: #FmxSQLLocalVariable opposite: #type"
 
 	<generated>
+	<derived>
 	^ localVariables
 ]
 
@@ -47,7 +72,6 @@ FmxSQLAbstractType >> localVariables: anObject [
 
 	<generated>
 	localVariables value: anObject
-
 ]
 
 { #category : #accessing }
@@ -55,6 +79,7 @@ FmxSQLAbstractType >> parameters [
 	"Relation named: #parameters type: #FmxSQLParameter opposite: #type"
 
 	<generated>
+	<derived>
 	^ parameters
 ]
 
@@ -63,7 +88,6 @@ FmxSQLAbstractType >> parameters: anObject [
 
 	<generated>
 	parameters value: anObject
-
 ]
 
 { #category : #accessing }
@@ -71,6 +95,7 @@ FmxSQLAbstractType >> storedProceduresReturning [
 	"Relation named: #storedProceduresReturning type: #FmxSQLStoredProcedure opposite: #returnType"
 
 	<generated>
+	<derived>
 	^ storedProceduresReturning
 ]
 
@@ -79,5 +104,4 @@ FmxSQLAbstractType >> storedProceduresReturning: anObject [
 
 	<generated>
 	storedProceduresReturning value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLAlias.class.st b/src/FamixNGSQL/FmxSQLAlias.class.st
index 14ab1dc8..cbaff601 100644
--- a/src/FamixNGSQL/FmxSQLAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLAlias.class.st
@@ -9,25 +9,18 @@ Class {
 	#instVars : [
 		'#parentBehaviouralEntity => FMOne type: #FmxSQLTWithAlias opposite: #aliases'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLAlias class >> annotation [
 
-	<MSEClass: #Alias super: #FmxSQLNamedEntity>
+	<FMClass: #Alias super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLAlias class >> requirements [
-
-	<generated>
-	^ { FmxSQLClause. FmxSQLStoredProcedure }
-]
-
 { #category : #testing }
 FmxSQLAlias >> isAlias [
 
@@ -35,11 +28,6 @@ FmxSQLAlias >> isAlias [
 	^ true
 ]
 
-{ #category : #testing }
-FmxSQLAlias >> isAnyBelongerSourced [
-	^ self parentBehaviouralEntity isAnyBelongerSourced
-]
-
 { #category : #accessing }
 FmxSQLAlias >> parentBehaviouralEntity [
 	"Relation named: #parentBehaviouralEntity type: #FmxSQLTWithAlias opposite: #aliases"
@@ -54,17 +42,11 @@ FmxSQLAlias >> parentBehaviouralEntity: anObject [
 
 	<generated>
 	parentBehaviouralEntity := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLAlias >> parentBehaviouralEntityGroup [
 	<generated>
 	<navigation: 'ParentBehaviouralEntity'>
-	^ MooseGroup with: self parentBehaviouralEntity
-]
-
-{ #category : #accessing }
-FmxSQLAlias >> sourcedBelonger [
-	^ self parentBehaviouralEntity sourcedBelonger
+	^ MooseSpecializedGroup with: self parentBehaviouralEntity
 ]
diff --git a/src/FamixNGSQL/FmxSQLAliasAccess.class.st b/src/FamixNGSQL/FmxSQLAliasAccess.class.st
index 9494be3c..6490d3df 100644
--- a/src/FamixNGSQL/FmxSQLAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLAliasAccess.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLAliasAccess class >> annotation [
 
-	<MSEClass: #AliasAccess super: #FmxSQLReference>
+	<FMClass: #AliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLAssociation.class.st b/src/FamixNGSQL/FmxSQLAssociation.class.st
index f875772e..f0def881 100644
--- a/src/FamixNGSQL/FmxSQLAssociation.class.st
+++ b/src/FamixNGSQL/FmxSQLAssociation.class.st
@@ -1,15 +1,13 @@
 Class {
 	#name : #FmxSQLAssociation,
-	#superclass : #FmxSQLSourcedEntity,
-	#traits : 'FamixTAssociation + TAssociationMetaLevelDependency',
-	#classTraits : 'FamixTAssociation classTrait + TAssociationMetaLevelDependency classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#superclass : #FmxSQLEntity,
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLAssociation class >> annotation [
 
-	<MSEClass: #Association super: #FmxSQLSourcedEntity>
+	<FMClass: #Association super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st b/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
index f658e662..8d619b86 100644
--- a/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
+++ b/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
@@ -8,7 +8,7 @@ Trait {
 { #category : #meta }
 FmxSQLBehaviouralEntity classSide >> annotation [
 
-	<MSEClass: #BehaviouralEntity super: #Trait>
+	<FMClass: #BehaviouralEntity super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
index 86ab9fa0..d45f2290 100644
--- a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
@@ -14,8 +14,8 @@ My subclasses represent these four queries.
 Class {
 	#name : #FmxSQLCRUDQuery,
 	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTWithSourceAnchor + TDependencyQueries + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTWithSourceAnchor classTrait + TDependencyQueries classTrait + TEntityMetaLevelDependency classTrait',
+	#traits : 'FamixTSourceAnchor + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceAnchor classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
 		'#derivedTableDefining => FMOne type: #FmxSQLDerivedTable opposite: #query',
 		'#clauses => FMMany type: #FmxSQLClause opposite: #query',
@@ -27,46 +27,24 @@ Class {
 { #category : #meta }
 FmxSQLCRUDQuery class >> annotation [
 
-	<MSEClass: #CRUDQuery super: #FmxSQLEntity>
+	<FMClass: #CRUDQuery super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLCRUDQuery class >> requirements [
-
-	<generated>
-	^ { FmxSQLCursor. FmxSQLDerivedTable. FmxSQLStoredProcedure. FmxSQLView }
-]
-
 { #category : #adding }
-FmxSQLCRUDQuery >> addClauses: anObject [
+FmxSQLCRUDQuery >> addClause: anObject [
 	<generated>
 	^ self clauses add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLCRUDQuery >> belongsTo [
-
-	<generated>
-	^ self container
-
-]
-
-{ #category : #accessing }
-FmxSQLCRUDQuery >> belongsTo: anObject [
-
-	<generated>
-	self container: anObject
-
-]
-
 { #category : #accessing }
 FmxSQLCRUDQuery >> clauses [
 	"Relation named: #clauses type: #FmxSQLClause opposite: #query"
 
 	<generated>
+	<derived>
 	^ clauses
 ]
 
@@ -75,14 +53,13 @@ FmxSQLCRUDQuery >> clauses: anObject [
 
 	<generated>
 	clauses value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLCRUDQuery >> clausesGroup [
 	<generated>
 	<navigation: 'Clauses'>
-	^ MooseGroup withAll: self clauses asSet
+	^ MooseSpecializedGroup withAll: self clauses asSet
 ]
 
 { #category : #accessing }
@@ -99,14 +76,13 @@ FmxSQLCRUDQuery >> container: anObject [
 
 	<generated>
 	container := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLCRUDQuery >> containerGroup [
 	<generated>
 	<navigation: 'Container'>
-	^ MooseGroup with: self container
+	^ MooseSpecializedGroup with: self container
 ]
 
 { #category : #accessing }
@@ -115,6 +91,7 @@ FmxSQLCRUDQuery >> derivedTableDefining [
 
 	<generated>
 	<container>
+	<derived>
 	^ derivedTableDefining
 ]
 
@@ -123,26 +100,11 @@ FmxSQLCRUDQuery >> derivedTableDefining: anObject [
 
 	<generated>
 	derivedTableDefining := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLCRUDQuery >> derivedTableDefiningGroup [
 	<generated>
 	<navigation: 'DerivedTableDefining'>
-	^ MooseGroup with: self derivedTableDefining
-]
-
-{ #category : #testing }
-FmxSQLCRUDQuery >> isAnyBelongerSourced [
-	^ ({ FmxSQLView . FmxSQLStoredProcedure } anySatisfy: [ :any | self container isKindOf: any ])
-			or: [ (self derivedTableDefining ifNotNil: #isAnyBelongerSourced ifNil: [ false ])
-				or: [ self container isCursor and: [ { FmxSQLView . FmxSQLStoredProcedure } anySatisfy: [ :any | self container parentBehaviouralEntity isKindOf: any ] ] ] ]
-]
-
-{ #category : #accessing }
-FmxSQLCRUDQuery >> sourcedBelonger [
-	(self container isNotNil and: [ self container isCursor ])
-		ifTrue: [ ^ self container parentBehaviouralEntity ].
-	^ self container ifNil: [ self derivedTableDefining sourcedBelonger ]
+	^ MooseSpecializedGroup with: self derivedTableDefining
 ]
diff --git a/src/FamixNGSQL/FmxSQLCheckConstraint.class.st b/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
index 7892299b..395663fd 100644
--- a/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
@@ -4,23 +4,29 @@ I represent a CHECK constraint as defined in SQL standard.
 Class {
 	#name : #FmxSQLCheckConstraint,
 	#superclass : #FmxSQLConstraint,
-	#traits : 'FamixTWithImmediateSource',
-	#classTraits : 'FamixTWithImmediateSource classTrait',
+	#traits : 'FmxSQLTWithImmediateSource',
+	#classTraits : 'FmxSQLTWithImmediateSource classTrait',
 	#instVars : [
 		'#storedProceduresCalled => FMMany type: #FmxSQLStoredProcedure opposite: #checkConstraintsCalling'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLCheckConstraint class >> annotation [
 
-	<MSEClass: #CheckConstraint super: #FmxSQLConstraint>
+	<FMClass: #CheckConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLCheckConstraint >> addStoredProceduresCalled: anObject [
+	<generated>
+	^ self storedProceduresCalled add: anObject
+]
+
 { #category : #testing }
 FmxSQLCheckConstraint >> isCheckConstraint [
 
@@ -33,6 +39,7 @@ FmxSQLCheckConstraint >> storedProceduresCalled [
 	"Relation named: #storedProceduresCalled type: #FmxSQLStoredProcedure opposite: #checkConstraintsCalling"
 
 	<generated>
+	<derived>
 	^ storedProceduresCalled
 ]
 
@@ -41,5 +48,4 @@ FmxSQLCheckConstraint >> storedProceduresCalled: anObject [
 
 	<generated>
 	storedProceduresCalled value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLClause.class.st b/src/FamixNGSQL/FmxSQLClause.class.st
index a521d471..47bda169 100644
--- a/src/FamixNGSQL/FmxSQLClause.class.st
+++ b/src/FamixNGSQL/FmxSQLClause.class.st
@@ -4,51 +4,23 @@ I am an abstract clause
 Class {
 	#name : #FmxSQLClause,
 	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTWithSourceAnchor + FmxSQLTWithAlias + TDependencyQueries + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTWithSourceAnchor classTrait + FmxSQLTWithAlias classTrait + TDependencyQueries classTrait + TEntityMetaLevelDependency classTrait',
+	#traits : 'FamixTSourceAnchor + FmxSQLTWithAlias + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceAnchor classTrait + FmxSQLTWithAlias classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
 		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #clauses'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLClause class >> annotation [
 
-	<MSEClass: #Clause super: #FmxSQLEntity>
+	<FMClass: #Clause super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLClause class >> requirements [
-
-	<generated>
-	^ { FmxSQLCRUDQuery }
-]
-
-{ #category : #accessing }
-FmxSQLClause >> belongsTo [
-
-	<generated>
-	^ self query
-
-]
-
-{ #category : #accessing }
-FmxSQLClause >> belongsTo: anObject [
-
-	<generated>
-	self query: anObject
-
-]
-
-{ #category : #testing }
-FmxSQLClause >> isAnyBelongerSourced [
-	^ self query isAnyBelongerSourced
-]
-
 { #category : #accessing }
 FmxSQLClause >> query [
 	"Relation named: #query type: #FmxSQLCRUDQuery opposite: #clauses"
@@ -63,17 +35,11 @@ FmxSQLClause >> query: anObject [
 
 	<generated>
 	query := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLClause >> queryGroup [
 	<generated>
 	<navigation: 'Query'>
-	^ MooseGroup with: self query
-]
-
-{ #category : #accessing }
-FmxSQLClause >> sourcedBelonger [
-	^ self query sourcedBelonger
+	^ MooseSpecializedGroup with: self query
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumn.class.st b/src/FamixNGSQL/FmxSQLColumn.class.st
index 39ed510c..bc67faa7 100644
--- a/src/FamixNGSQL/FmxSQLColumn.class.st
+++ b/src/FamixNGSQL/FmxSQLColumn.class.st
@@ -16,54 +16,16 @@ Class {
 { #category : #meta }
 FmxSQLColumn class >> annotation [
 
-	<MSEClass: #Column super: #FmxSQLStructuralEntity>
+	<FMClass: #Column super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLColumn class >> requirements [
-
-	<generated>
-	^ { FmxSQLDerivedTable. FmxSQLNewLocalVariable. FmxSQLOldLocalVariable. FmxSQLRecordLocalVariable. FmxSQLTable. FmxSQLView }
-]
-
-{ #category : #accessing }
-FmxSQLColumn >> belongsTo [
-
+{ #category : #adding }
+FmxSQLColumn >> addReference: anObject [
 	<generated>
-	^ self columnsContainer
-
-]
-
-{ #category : #accessing }
-FmxSQLColumn >> belongsTo: anObject [
-
-	<generated>
-	self columnsContainer: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLColumn >> foreignKeyConstraintsReferencing [
-	^ (self queryIncoming: FmxSQLColumnReference) select: [ :ref | ref from class = FmxSQLForeignKeyConstraint and: [ ref from referencedColumns includes: self ] ]
-]
-
-{ #category : #testing }
-FmxSQLColumn >> hasPrimaryKey [
-	"Returns true if a Primary Key constraint is applied on the column.
-	 Note that the column might not be the only one concerned by the the PK.
-	"
-	^ (self queryIncoming: FmxSQLColumnReference) anySatisfy: [ :ref | ref from class = FmxSQLPrimaryKeyConstraint ]
-]
-
-{ #category : #testing }
-FmxSQLColumn >> hasUniqueConstraint [
-	"Returns true if a Unique constraint is applied on the column.
-	 Note that the column might not be the only one concerned by the the PK.
-	"
-	^ (self queryIncoming: FmxSQLColumnReference) anySatisfy: [ :ref | ref from class = FmxSQLUniqueConstraint ]
+	^ self references add: anObject
 ]
 
 { #category : #testing }
@@ -73,18 +35,12 @@ FmxSQLColumn >> isColumn [
 	^ true
 ]
 
-{ #category : #accessing }
-FmxSQLColumn >> primaryKey [
-	^ (self queryIncoming: FmxSQLColumnReference)
-		detect: [ :ref | ref from class = FmxSQLPrimaryKeyConstraint ]
-		ifNone: [ self error: 'No primary key applied on this column.' ]
-]
-
 { #category : #accessing }
 FmxSQLColumn >> references [
 	"Relation named: #references type: #FmxSQLColumnReference opposite: #column"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -93,7 +49,6 @@ FmxSQLColumn >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
 
 { #category : #accessing }
@@ -109,5 +64,4 @@ FmxSQLColumn >> type: anObject [
 
 	<generated>
 	type := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnAlias.class.st b/src/FamixNGSQL/FmxSQLColumnAlias.class.st
index c31a3b32..45478e95 100644
--- a/src/FamixNGSQL/FmxSQLColumnAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnAlias.class.st
@@ -9,41 +9,18 @@ Class {
 	#instVars : [
 		'#columnsContainerAlias => FMOne type: #FmxSQLColumnsContainerAlias opposite: #columnAliases'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLColumnAlias class >> annotation [
 
-	<MSEClass: #ColumnAlias super: #FmxSQLAlias>
+	<FMClass: #ColumnAlias super: #FmxSQLAlias>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLColumnAlias class >> requirements [
-
-	<generated>
-	^ { FmxSQLDerivedTable. FmxSQLNewLocalVariable. FmxSQLOldLocalVariable. FmxSQLRecordLocalVariable. FmxSQLTable. FmxSQLView }
-]
-
-{ #category : #accessing }
-FmxSQLColumnAlias >> belongsTo [
-
-	<generated>
-	^ self columnsContainer
-
-]
-
-{ #category : #accessing }
-FmxSQLColumnAlias >> belongsTo: anObject [
-
-	<generated>
-	self columnsContainer: anObject
-
-]
-
 { #category : #accessing }
 FmxSQLColumnAlias >> columnsContainerAlias [
 	"Relation named: #columnsContainerAlias type: #FmxSQLColumnsContainerAlias opposite: #columnAliases"
@@ -57,5 +34,4 @@ FmxSQLColumnAlias >> columnsContainerAlias: anObject [
 
 	<generated>
 	columnsContainerAlias := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st b/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
index c9657101..66f68735 100644
--- a/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
@@ -9,7 +9,7 @@ Class {
 { #category : #meta }
 FmxSQLColumnAliasAccess class >> annotation [
 
-	<MSEClass: #ColumnAliasAccess super: #FmxSQLReference>
+	<FMClass: #ColumnAliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLColumnReference.class.st b/src/FamixNGSQL/FmxSQLColumnReference.class.st
index d83e710e..26582f31 100644
--- a/src/FamixNGSQL/FmxSQLColumnReference.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnReference.class.st
@@ -7,11 +7,11 @@ Class {
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#column => FMOne type: #FmxSQLColumn opposite: #references',
-		'#foreignKeyConstraintSource => FMOne type: #FmxSQLForeignKeyConstraint opposite: #outgoingForeignKeyColumnReferences',
-		'#isCertain => FMProperty',
 		'#isWildCardReference => FMProperty',
+		'#isCertain => FMProperty',
+		'#foreignKeyConstraintSource => FMOne type: #FmxSQLForeignKeyConstraint opposite: #outgoingForeignKeyColumnReferences',
 		'#source => FMOne type: #FmxSQLTWithColumnReference opposite: #outgoingColumnReferences',
+		'#column => FMOne type: #FmxSQLColumn opposite: #references',
 		'#triggerStoredProceduresReferencing => FMOne type: #FmxSQLTriggerStoredProcedure opposite: #columnsReferenced'
 	],
 	#category : #'FamixNGSQL-Entities'
@@ -20,35 +20,12 @@ Class {
 { #category : #meta }
 FmxSQLColumnReference class >> annotation [
 
-	<MSEClass: #ColumnReference super: #FmxSQLReference>
+	<FMClass: #ColumnReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLColumnReference class >> requirements [
-
-	<generated>
-	^ { FmxSQLTriggerStoredProcedure }
-]
-
-{ #category : #accessing }
-FmxSQLColumnReference >> belongsTo [
-
-	<generated>
-	^ self triggerStoredProceduresReferencing
-
-]
-
-{ #category : #accessing }
-FmxSQLColumnReference >> belongsTo: anObject [
-
-	<generated>
-	self triggerStoredProceduresReferencing: anObject
-
-]
-
 { #category : #accessing }
 FmxSQLColumnReference >> column [
 	"Relation named: #column type: #FmxSQLColumn opposite: #references"
@@ -63,7 +40,6 @@ FmxSQLColumnReference >> column: anObject [
 
 	<generated>
 	column := anObject
-
 ]
 
 { #category : #accessing }
@@ -80,23 +56,20 @@ FmxSQLColumnReference >> foreignKeyConstraintSource: anObject [
 
 	<generated>
 	foreignKeyConstraintSource := anObject
-
 ]
 
 { #category : #accessing }
 FmxSQLColumnReference >> isCertain [
 
-	<MSEProperty: #isCertain type: #Boolean>
+	<FMProperty: #isCertain type: #Boolean>
 	<generated>
 	^ isCertain
 ]
 
 { #category : #accessing }
 FmxSQLColumnReference >> isCertain: anObject [
-
 	<generated>
 	isCertain := anObject
-
 ]
 
 { #category : #testing }
@@ -109,17 +82,15 @@ FmxSQLColumnReference >> isColumnReference [
 { #category : #accessing }
 FmxSQLColumnReference >> isWildCardReference [
 
-	<MSEProperty: #isWildCardReference type: #Boolean>
+	<FMProperty: #isWildCardReference type: #Boolean>
 	<generated>
 	^ isWildCardReference
 ]
 
 { #category : #accessing }
 FmxSQLColumnReference >> isWildCardReference: anObject [
-
 	<generated>
 	isWildCardReference := anObject
-
 ]
 
 { #category : #accessing }
@@ -136,7 +107,6 @@ FmxSQLColumnReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
 
 { #category : #accessing }
@@ -153,12 +123,11 @@ FmxSQLColumnReference >> triggerStoredProceduresReferencing: anObject [
 
 	<generated>
 	triggerStoredProceduresReferencing := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLColumnReference >> triggerStoredProceduresReferencingGroup [
 	<generated>
 	<navigation: 'TriggerStoredProceduresReferencing'>
-	^ MooseGroup with: self triggerStoredProceduresReferencing
+	^ MooseSpecializedGroup with: self triggerStoredProceduresReferencing
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st b/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
index 5a3fa379..6de50e15 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
@@ -6,34 +6,30 @@ Trait {
 	#instVars : [
 		'#columns => FMMany type: #FmxSQLTColumn opposite: #columnsContainer'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLColumnsContainer classSide >> annotation [
 
-	<MSEClass: #ColumnsContainer super: #Trait>
+	<FMClass: #ColumnsContainer super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLColumnsContainer >> addColumns: anObject [
+FmxSQLColumnsContainer >> addColumn: anObject [
 	<generated>
 	^ self columns add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLColumnsContainer >> columnNamed: aString [
-	^ self columns detect: [ :column | column name = aString ]
-]
-
 { #category : #accessing }
 FmxSQLColumnsContainer >> columns [
 	"Relation named: #columns type: #FmxSQLTColumn opposite: #columnsContainer"
 
 	<generated>
+	<derived>
 	^ columns
 ]
 
@@ -42,12 +38,11 @@ FmxSQLColumnsContainer >> columns: anObject [
 
 	<generated>
 	columns value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLColumnsContainer >> columnsGroup [
 	<generated>
 	<navigation: 'Columns'>
-	^ MooseGroup withAll: self columns asSet
+	^ MooseSpecializedGroup withAll: self columns asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st b/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
index d7ddeccc..f008e836 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
@@ -9,23 +9,30 @@ Class {
 	#instVars : [
 		'#columnAliases => FMMany type: #FmxSQLColumnAlias opposite: #columnsContainerAlias'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLColumnsContainerAlias class >> annotation [
 
-	<MSEClass: #ColumnsContainerAlias super: #FmxSQLAlias>
+	<FMClass: #ColumnsContainerAlias super: #FmxSQLAlias>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLColumnsContainerAlias >> addColumnAliase: anObject [
+	<generated>
+	^ self columnAliases add: anObject
+]
+
 { #category : #accessing }
 FmxSQLColumnsContainerAlias >> columnAliases [
 	"Relation named: #columnAliases type: #FmxSQLColumnAlias opposite: #columnsContainerAlias"
 
 	<generated>
+	<derived>
 	^ columnAliases
 ]
 
@@ -34,5 +41,4 @@ FmxSQLColumnsContainerAlias >> columnAliases: anObject [
 
 	<generated>
 	columnAliases value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st b/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
index bc74a26f..1c520178 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
@@ -9,7 +9,7 @@ Class {
 { #category : #meta }
 FmxSQLColumnsContainerAliasAccess class >> annotation [
 
-	<MSEClass: #ColumnsContainerAliasAccess super: #FmxSQLReference>
+	<FMClass: #ColumnsContainerAliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLComment.class.st b/src/FamixNGSQL/FmxSQLComment.class.st
index 2d1bcb61..fab39136 100644
--- a/src/FamixNGSQL/FmxSQLComment.class.st
+++ b/src/FamixNGSQL/FmxSQLComment.class.st
@@ -3,13 +3,13 @@ Class {
 	#superclass : #FmxSQLSourcedEntity,
 	#traits : 'FamixTComment',
 	#classTraits : 'FamixTComment classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLComment class >> annotation [
 
-	<MSEClass: #Comment super: #FmxSQLSourcedEntity>
+	<FMClass: #Comment super: #FmxSQLSourcedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLConstraint.class.st b/src/FamixNGSQL/FmxSQLConstraint.class.st
index 46022147..247f8fa0 100644
--- a/src/FamixNGSQL/FmxSQLConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLConstraint.class.st
@@ -9,41 +9,18 @@ Class {
 	#instVars : [
 		'#table => FMOne type: #FmxSQLTable opposite: #constraints'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLConstraint class >> annotation [
 
-	<MSEClass: #Constraint super: #FmxSQLStructuralEntity>
+	<FMClass: #Constraint super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLConstraint class >> requirements [
-
-	<generated>
-	^ { FmxSQLTable }
-]
-
-{ #category : #accessing }
-FmxSQLConstraint >> belongsTo [
-
-	<generated>
-	^ self table
-
-]
-
-{ #category : #accessing }
-FmxSQLConstraint >> belongsTo: anObject [
-
-	<generated>
-	self table: anObject
-
-]
-
 { #category : #testing }
 FmxSQLConstraint >> isConstraint [
 
@@ -65,12 +42,11 @@ FmxSQLConstraint >> table: anObject [
 
 	<generated>
 	table := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLConstraint >> tableGroup [
 	<generated>
 	<navigation: 'Table'>
-	^ MooseGroup with: self table
+	^ MooseSpecializedGroup with: self table
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursor.class.st b/src/FamixNGSQL/FmxSQLCursor.class.st
index 3ebee8cb..9584e136 100644
--- a/src/FamixNGSQL/FmxSQLCursor.class.st
+++ b/src/FamixNGSQL/FmxSQLCursor.class.st
@@ -10,39 +10,22 @@ Class {
 		'#parentBehaviouralEntity => FMOne type: #FmxSQLTWithCursor opposite: #cursors',
 		'#references => FMMany type: #FmxSQLCursorReference opposite: #cursor'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLCursor class >> annotation [
 
-	<MSEClass: #Cursor super: #FmxSQLNamedEntity>
+	<FMClass: #Cursor super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLCursor class >> requirements [
-
-	<generated>
-	^ { FmxSQLStoredProcedure }
-]
-
-{ #category : #accessing }
-FmxSQLCursor >> belongsTo [
-
-	<generated>
-	^ self parentBehaviouralEntity
-
-]
-
-{ #category : #accessing }
-FmxSQLCursor >> belongsTo: anObject [
-
+{ #category : #adding }
+FmxSQLCursor >> addReference: anObject [
 	<generated>
-	self parentBehaviouralEntity: anObject
-
+	^ self references add: anObject
 ]
 
 { #category : #testing }
@@ -66,14 +49,13 @@ FmxSQLCursor >> parentBehaviouralEntity: anObject [
 
 	<generated>
 	parentBehaviouralEntity := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLCursor >> parentBehaviouralEntityGroup [
 	<generated>
 	<navigation: 'ParentBehaviouralEntity'>
-	^ MooseGroup with: self parentBehaviouralEntity
+	^ MooseSpecializedGroup with: self parentBehaviouralEntity
 ]
 
 { #category : #accessing }
@@ -81,6 +63,7 @@ FmxSQLCursor >> references [
 	"Relation named: #references type: #FmxSQLCursorReference opposite: #cursor"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -89,5 +72,4 @@ FmxSQLCursor >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursorParameter.class.st b/src/FamixNGSQL/FmxSQLCursorParameter.class.st
index aa823899..d292a90a 100644
--- a/src/FamixNGSQL/FmxSQLCursorParameter.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorParameter.class.st
@@ -9,51 +9,18 @@ Class {
 	#instVars : [
 		'#type => FMOne type: #FmxSQLAbstractType opposite: #cursorParameters'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLCursorParameter class >> annotation [
 
-	<MSEClass: #CursorParameter super: #FmxSQLNamedEntity>
+	<FMClass: #CursorParameter super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLCursorParameter class >> requirements [
-
-	<generated>
-	^ { FmxSQLCursor. FmxSQLStoredProcedure }
-]
-
-{ #category : #accessing }
-FmxSQLCursorParameter >> belongsTo [
-
-	<generated>
-	^ self parentBehaviouralEntity
-
-]
-
-{ #category : #accessing }
-FmxSQLCursorParameter >> belongsTo: anObject [
-
-	<generated>
-	self parentBehaviouralEntity: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLCursorParameter >> cursor [
-	^ self parentBehaviouralEntity
-]
-
-{ #category : #accessing }
-FmxSQLCursorParameter >> cursor: anObject [
-	self parentBehaviouralEntity: anObject
-]
-
 { #category : #accessing }
 FmxSQLCursorParameter >> type [
 	"Relation named: #type type: #FmxSQLAbstractType opposite: #cursorParameters"
@@ -67,5 +34,4 @@ FmxSQLCursorParameter >> type: anObject [
 
 	<generated>
 	type := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st b/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
index 95c85aeb..ad0e2aa3 100644
--- a/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLCursorParameterAccess class >> annotation [
 
-	<MSEClass: #CursorParameterAccess super: #FmxSQLReference>
+	<FMClass: #CursorParameterAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLCursorReference.class.st b/src/FamixNGSQL/FmxSQLCursorReference.class.st
index a3a4820c..f0b73c87 100644
--- a/src/FamixNGSQL/FmxSQLCursorReference.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorReference.class.st
@@ -7,8 +7,8 @@ Class {
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#cursor => FMOne type: #FmxSQLCursor opposite: #references',
-		'#source => FMOne type: #FmxSQLTWithCursorReference opposite: #outgoingCursorReferences'
+		'#source => FMOne type: #FmxSQLTWithCursorReference opposite: #outgoingCursorReferences',
+		'#cursor => FMOne type: #FmxSQLCursor opposite: #references'
 	],
 	#category : #'FamixNGSQL-Entities'
 }
@@ -16,7 +16,7 @@ Class {
 { #category : #meta }
 FmxSQLCursorReference class >> annotation [
 
-	<MSEClass: #CursorReference super: #FmxSQLReference>
+	<FMClass: #CursorReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -36,7 +36,6 @@ FmxSQLCursorReference >> cursor: anObject [
 
 	<generated>
 	cursor := anObject
-
 ]
 
 { #category : #accessing }
@@ -53,5 +52,4 @@ FmxSQLCursorReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLDeleteQuery.class.st b/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
index d4ac3951..ebeb2edc 100644
--- a/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
@@ -6,13 +6,13 @@ Class {
 	#superclass : #FmxSQLCRUDQuery,
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLDeleteQuery class >> annotation [
 
-	<MSEClass: #DeleteQuery super: #FmxSQLCRUDQuery>
+	<FMClass: #DeleteQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLDerivedTable.class.st b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
index 5c0bb00d..e4f63a6c 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTable.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
@@ -17,38 +17,16 @@ Class {
 { #category : #meta }
 FmxSQLDerivedTable class >> annotation [
 
-	<MSEClass: #DerivedTable super: #FmxSQLNamedEntity>
+	<FMClass: #DerivedTable super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLDerivedTable class >> requirements [
-
-	<generated>
-	^ { FmxSQLDeleteQuery. FmxSQLInsertQuery. FmxSQLSelectQuery. FmxSQLUpdateQuery }
-]
-
-{ #category : #accessing }
-FmxSQLDerivedTable >> belongsTo [
-
-	<generated>
-	^ self parentQuery
-
-]
-
-{ #category : #accessing }
-FmxSQLDerivedTable >> belongsTo: anObject [
-
+{ #category : #adding }
+FmxSQLDerivedTable >> addReference: anObject [
 	<generated>
-	self parentQuery: anObject
-
-]
-
-{ #category : #testing }
-FmxSQLDerivedTable >> isAnyBelongerSourced [
-	^ self parentQuery isAnyBelongerSourced
+	^ self references add: anObject
 ]
 
 { #category : #accessing }
@@ -65,14 +43,13 @@ FmxSQLDerivedTable >> parentQuery: anObject [
 
 	<generated>
 	parentQuery := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLDerivedTable >> parentQueryGroup [
 	<generated>
 	<navigation: 'ParentQuery'>
-	^ MooseGroup with: self parentQuery
+	^ MooseSpecializedGroup with: self parentQuery
 ]
 
 { #category : #accessing }
@@ -88,14 +65,13 @@ FmxSQLDerivedTable >> query: anObject [
 
 	<generated>
 	query := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLDerivedTable >> queryGroup [
 	<generated>
 	<navigation: 'Query'>
-	^ MooseGroup with: self query
+	^ MooseSpecializedGroup with: self query
 ]
 
 { #category : #accessing }
@@ -103,6 +79,7 @@ FmxSQLDerivedTable >> references [
 	"Relation named: #references type: #FmxSQLDerivedTableReference opposite: #derivedTable"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -111,10 +88,4 @@ FmxSQLDerivedTable >> references: anObject [
 
 	<generated>
 	references value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLDerivedTable >> sourcedBelonger [
-	^ self parentQuery sourcedBelonger
 ]
diff --git a/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st b/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
index 294e62a9..a6265592 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
@@ -14,7 +14,7 @@ Class {
 { #category : #meta }
 FmxSQLDerivedTableReference class >> annotation [
 
-	<MSEClass: #DerivedTableReference super: #FmxSQLReference>
+	<FMClass: #DerivedTableReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -34,7 +34,6 @@ FmxSQLDerivedTableReference >> derivedTable: anObject [
 
 	<generated>
 	derivedTable := anObject
-
 ]
 
 { #category : #accessing }
@@ -51,5 +50,4 @@ FmxSQLDerivedTableReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLEntity.class.st b/src/FamixNGSQL/FmxSQLEntity.class.st
index 48ab4cd2..bcff2999 100644
--- a/src/FamixNGSQL/FmxSQLEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLEntity.class.st
@@ -1,13 +1,13 @@
 Class {
 	#name : #FmxSQLEntity,
 	#superclass : #MooseEntity,
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLEntity class >> annotation [
 
-	<MSEClass: #Entity super: #MooseEntity>
+	<FMClass: #Entity super: #MooseEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -17,7 +17,7 @@ FmxSQLEntity class >> annotation [
 FmxSQLEntity class >> metamodel [
 
 	<generated>
-	^ (self class environment at: #FmxSQLMetamodelGenerator) metamodel
+	^ FmxSQLModel metamodel
 ]
 
 { #category : #testing }
@@ -41,11 +41,6 @@ FmxSQLEntity >> isAliasAccess [
 	^ false
 ]
 
-{ #category : #testing }
-FmxSQLEntity >> isAnyBelongerSourced [
-	^ false
-]
-
 { #category : #testing }
 FmxSQLEntity >> isAssociation [
 
@@ -109,12 +104,6 @@ FmxSQLEntity >> isExclusionConstraint [
 	^ false
 ]
 
-{ #category : #testing }
-FmxSQLEntity >> isForeignKey [
-	self deprecated: 'Use #isForeignKeyConstraint instead.' transformWith: '`@receiver isForeignKey' -> '`@receiver isForeignKeyConstraint'.
-	^ self isForeignKeyConstraint
-]
-
 { #category : #testing }
 FmxSQLEntity >> isForeignKeyConstraint [
 
@@ -213,12 +202,6 @@ FmxSQLEntity >> isParameterAccess [
 	^ false
 ]
 
-{ #category : #testing }
-FmxSQLEntity >> isPrimaryKey [
-	self deprecated: 'Use #isPrimaryKeyConstraint instead.' transformWith: '`@receiver isPrimaryKey' -> '`@receiver isPrimaryKeyConstraint'.
-	^ self isPrimaryKeyConstraint
-]
-
 { #category : #testing }
 FmxSQLEntity >> isPrimaryKeyConstraint [
 
diff --git a/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st b/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
index 29295013..fc86333a 100644
--- a/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
@@ -17,7 +17,7 @@ Class {
 { #category : #meta }
 FmxSQLEntitySourceAnchor class >> annotation [
 
-	<MSEClass: #EntitySourceAnchor super: #FmxSQLEntity>
+	<FMClass: #EntitySourceAnchor super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -26,17 +26,15 @@ FmxSQLEntitySourceAnchor class >> annotation [
 { #category : #accessing }
 FmxSQLEntitySourceAnchor >> end [
 
-	<MSEProperty: #end type: #Number>
+	<FMProperty: #end type: #Number>
 	<generated>
 	^ end
 ]
 
 { #category : #accessing }
 FmxSQLEntitySourceAnchor >> end: anObject [
-
 	<generated>
 	end := anObject
-
 ]
 
 { #category : #accessing }
@@ -52,17 +50,6 @@ FmxSQLEntitySourceAnchor >> entity: anObject [
 
 	<generated>
 	entity := anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLEntitySourceAnchor >> extractString [
-	^ self entity source copyFrom: self start to: self end
-]
-
-{ #category : #accessing }
-FmxSQLEntitySourceAnchor >> interval [
-	^ self start to: self end
 ]
 
 { #category : #testing }
@@ -72,28 +59,16 @@ FmxSQLEntitySourceAnchor >> isEntitySourceAnchor [
 	^ true
 ]
 
-{ #category : #accessing }
-FmxSQLEntitySourceAnchor >> sourceAnchor [
-	^ self
-]
-
-{ #category : #accessing }
-FmxSQLEntitySourceAnchor >> sourceAnchorOrReferenceGroupSourceAnchor [
-	^ self
-]
-
 { #category : #accessing }
 FmxSQLEntitySourceAnchor >> start [
 
-	<MSEProperty: #start type: #Number>
+	<FMProperty: #start type: #Number>
 	<generated>
 	^ start
 ]
 
 { #category : #accessing }
 FmxSQLEntitySourceAnchor >> start: anObject [
-
 	<generated>
 	start := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLExceptClause.class.st b/src/FamixNGSQL/FmxSQLExceptClause.class.st
index ab77fe8b..b2536cc6 100644
--- a/src/FamixNGSQL/FmxSQLExceptClause.class.st
+++ b/src/FamixNGSQL/FmxSQLExceptClause.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLExceptClause class >> annotation [
 
-	<MSEClass: #ExceptClause super: #FmxSQLClause>
+	<FMClass: #ExceptClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
index cfbe0057..2ac4b958 100644
--- a/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
@@ -1,5 +1,5 @@
 "
-I represent a EXCLUSION constraint as defined in SQL standard.
+I represent an EXCLUSION constraint as defined in SQL standard.
 "
 Class {
 	#name : #FmxSQLExclusionConstraint,
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLExclusionConstraint class >> annotation [
 
-	<MSEClass: #ExclusionConstraint super: #FmxSQLConstraint>
+	<FMClass: #ExclusionConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st b/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
index 6a0262c2..aaeb2ec8 100644
--- a/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
@@ -7,21 +7,22 @@ Class {
 	#instVars : [
 		'#outgoingForeignKeyColumnReferences => FMMany type: #FmxSQLColumnReference opposite: #foreignKeyConstraintSource'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLForeignKeyConstraint class >> annotation [
 
-	<MSEClass: #ForeignKeyConstraint super: #FmxSQLConstraint>
+	<FMClass: #ForeignKeyConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #accessing }
-FmxSQLForeignKeyConstraint >> foreignKeyColumns [
-	^ self outgoingColumnReferences collect: #column
+{ #category : #adding }
+FmxSQLForeignKeyConstraint >> addOutgoingForeignKeyColumnReference: anObject [
+	<generated>
+	^ self outgoingForeignKeyColumnReferences add: anObject
 ]
 
 { #category : #testing }
@@ -31,29 +32,12 @@ FmxSQLForeignKeyConstraint >> isForeignKeyConstraint [
 	^ true
 ]
 
-{ #category : #printing }
-FmxSQLForeignKeyConstraint >> mooseNameOn: aStream [
-	aStream
-		<< $".
-	super mooseNameOn: aStream.
-	aStream << '" FK ('.
-	self foreignKeyColumns do: [ :c | aStream << c name ] separatedBy: [ aStream << ', ' ].
-	aStream
-		<< ') REFERENCES ';
-		<< self referencedColumnsTable name;
-		<< $(.
-	self referencedColumns do: [ :c |
-		aStream << c name ] separatedBy: [ aStream << ', ' ].
-	aStream
-		<< ') #';
-		<< self mooseID.
-]
-
 { #category : #accessing }
 FmxSQLForeignKeyConstraint >> outgoingForeignKeyColumnReferences [
 	"Relation named: #outgoingForeignKeyColumnReferences type: #FmxSQLColumnReference opposite: #foreignKeyConstraintSource"
 
 	<generated>
+	<derived>
 	^ outgoingForeignKeyColumnReferences
 ]
 
@@ -62,20 +46,4 @@ FmxSQLForeignKeyConstraint >> outgoingForeignKeyColumnReferences: anObject [
 
 	<generated>
 	outgoingForeignKeyColumnReferences value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLForeignKeyConstraint >> referencedColumns [
-	^ self outgoingForeignKeyColumnReferences collect: #column
-]
-
-{ #category : #accessing }
-FmxSQLForeignKeyConstraint >> referencedColumnsTable [
-	^ self outgoingForeignKeyColumnReferences anyOne column columnsContainer
-]
-
-{ #category : #accessing }
-FmxSQLForeignKeyConstraint >> referencingColumnsTable [
-	^ self foreignKeyColumns anyOne columnsContainer
 ]
diff --git a/src/FamixNGSQL/FmxSQLForeignTable.class.st b/src/FamixNGSQL/FmxSQLForeignTable.class.st
index c02ae48e..ea4fbd4b 100644
--- a/src/FamixNGSQL/FmxSQLForeignTable.class.st
+++ b/src/FamixNGSQL/FmxSQLForeignTable.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLForeignTable class >> annotation [
 
-	<MSEClass: #ForeignTable super: #FmxSQLTable>
+	<FMClass: #ForeignTable super: #FmxSQLTable>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLFromClause.class.st b/src/FamixNGSQL/FmxSQLFromClause.class.st
index 6c37d791..64e82fba 100644
--- a/src/FamixNGSQL/FmxSQLFromClause.class.st
+++ b/src/FamixNGSQL/FmxSQLFromClause.class.st
@@ -4,15 +4,15 @@ I am a from clause
 Class {
 	#name : #FmxSQLFromClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLFromClause class >> annotation [
 
-	<MSEClass: #FromClause super: #FmxSQLClause>
+	<FMClass: #FromClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLGroupByClause.class.st b/src/FamixNGSQL/FmxSQLGroupByClause.class.st
index 78ddb1dd..43498d2a 100644
--- a/src/FamixNGSQL/FmxSQLGroupByClause.class.st
+++ b/src/FamixNGSQL/FmxSQLGroupByClause.class.st
@@ -4,25 +4,20 @@ I am a group by clause
 Class {
 	#name : #FmxSQLGroupByClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLGroupByClause class >> annotation [
 
-	<MSEClass: #GroupByClause super: #FmxSQLClause>
+	<FMClass: #GroupByClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLGroupByClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLGroupByClause >> isGroupByClause [
 
diff --git a/src/FamixNGSQL/FmxSQLHavingClause.class.st b/src/FamixNGSQL/FmxSQLHavingClause.class.st
index ea3bf49f..86c5d1a3 100644
--- a/src/FamixNGSQL/FmxSQLHavingClause.class.st
+++ b/src/FamixNGSQL/FmxSQLHavingClause.class.st
@@ -4,15 +4,15 @@ I am a having clause
 Class {
 	#name : #FmxSQLHavingClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLHavingClause class >> annotation [
 
-	<MSEClass: #HavingClause super: #FmxSQLClause>
+	<FMClass: #HavingClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLInsertQuery.class.st b/src/FamixNGSQL/FmxSQLInsertQuery.class.st
index c121e3a0..bcff2091 100644
--- a/src/FamixNGSQL/FmxSQLInsertQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLInsertQuery.class.st
@@ -6,13 +6,13 @@ Class {
 	#superclass : #FmxSQLCRUDQuery,
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLInsertQuery class >> annotation [
 
-	<MSEClass: #InsertQuery super: #FmxSQLCRUDQuery>
+	<FMClass: #InsertQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLIntersectClause.class.st b/src/FamixNGSQL/FmxSQLIntersectClause.class.st
index e6a0d90f..8d63d2f4 100644
--- a/src/FamixNGSQL/FmxSQLIntersectClause.class.st
+++ b/src/FamixNGSQL/FmxSQLIntersectClause.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLIntersectClause class >> annotation [
 
-	<MSEClass: #IntersectClause super: #FmxSQLClause>
+	<FMClass: #IntersectClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLIntoClause.class.st b/src/FamixNGSQL/FmxSQLIntoClause.class.st
index 7ff68bcc..ff6684c0 100644
--- a/src/FamixNGSQL/FmxSQLIntoClause.class.st
+++ b/src/FamixNGSQL/FmxSQLIntoClause.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLIntoClause class >> annotation [
 
-	<MSEClass: #IntoClause super: #FmxSQLClause>
+	<FMClass: #IntoClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLJoinClause.class.st b/src/FamixNGSQL/FmxSQLJoinClause.class.st
index 18bbdc7a..be9fdb33 100644
--- a/src/FamixNGSQL/FmxSQLJoinClause.class.st
+++ b/src/FamixNGSQL/FmxSQLJoinClause.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLJoinClause class >> annotation [
 
-	<MSEClass: #JoinClause super: #FmxSQLClause>
+	<FMClass: #JoinClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLLimitClause.class.st b/src/FamixNGSQL/FmxSQLLimitClause.class.st
index 8cc99cfb..34e78fe9 100644
--- a/src/FamixNGSQL/FmxSQLLimitClause.class.st
+++ b/src/FamixNGSQL/FmxSQLLimitClause.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLLimitClause class >> annotation [
 
-	<MSEClass: #LimitClause super: #FmxSQLClause>
+	<FMClass: #LimitClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLLocalVariable.class.st b/src/FamixNGSQL/FmxSQLLocalVariable.class.st
index 343ebb0e..7c33b940 100644
--- a/src/FamixNGSQL/FmxSQLLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLLocalVariable.class.st
@@ -16,24 +16,18 @@ Class {
 { #category : #meta }
 FmxSQLLocalVariable class >> annotation [
 
-	<MSEClass: #LocalVariable super: #FmxSQLNamedEntity>
+	<FMClass: #LocalVariable super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLLocalVariable class >> requirements [
-
-	<generated>
-	^ { FmxSQLStoredProcedure }
-]
-
 { #category : #accessing }
 FmxSQLLocalVariable >> accesses [
 	"Relation named: #accesses type: #FmxSQLLocalVariableAccess opposite: #localVariable"
 
 	<generated>
+	<derived>
 	^ accesses
 ]
 
@@ -42,33 +36,12 @@ FmxSQLLocalVariable >> accesses: anObject [
 
 	<generated>
 	accesses value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLLocalVariable >> belongsTo [
-
-	<generated>
-	^ self parentBehaviouralEntity
-
 ]
 
-{ #category : #accessing }
-FmxSQLLocalVariable >> belongsTo: anObject [
-
+{ #category : #adding }
+FmxSQLLocalVariable >> addAccess: anObject [
 	<generated>
-	self parentBehaviouralEntity: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLLocalVariable >> storedProcedure [
-	^ self parentBehaviouralEntity
-]
-
-{ #category : #accessing }
-FmxSQLLocalVariable >> storedProcedure: anObject [
-	self parentBehaviouralEntity: anObject
+	^ self accesses add: anObject
 ]
 
 { #category : #accessing }
@@ -84,5 +57,4 @@ FmxSQLLocalVariable >> type: anObject [
 
 	<generated>
 	type := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st b/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
index 4ff364e1..3fa1b9d8 100644
--- a/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
@@ -15,7 +15,7 @@ Class {
 { #category : #meta }
 FmxSQLLocalVariableAccess class >> annotation [
 
-	<MSEClass: #LocalVariableAccess super: #FmxSQLReference>
+	<FMClass: #LocalVariableAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -42,5 +42,4 @@ FmxSQLLocalVariableAccess >> localVariable: anObject [
 
 	<generated>
 	localVariable := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLModel.class.st b/src/FamixNGSQL/FmxSQLModel.class.st
new file mode 100644
index 00000000..80ec13ed
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLModel.class.st
@@ -0,0 +1,18 @@
+Class {
+	#name : #FmxSQLModel,
+	#superclass : #MooseModel,
+	#category : #'FamixNGSQL-Model'
+}
+
+{ #category : #accessing }
+FmxSQLModel class >> allSubmetamodelsPackagesNames [
+	<generated>
+	^ #(#'Moose-Query' #'Famix-Traits')
+]
+
+{ #category : #meta }
+FmxSQLModel class >> annotation [
+	<FMClass: #FmxSQLModel super: #MooseModel>
+	<package: #FamixNGSQL>
+	<generated>
+]
diff --git a/src/FamixNGSQL/FmxSQLMooseModel.class.st b/src/FamixNGSQL/FmxSQLMooseModel.class.st
deleted file mode 100644
index 0973bb93..00000000
--- a/src/FamixNGSQL/FmxSQLMooseModel.class.st
+++ /dev/null
@@ -1,17 +0,0 @@
-Class {
-	#name : #FmxSQLMooseModel,
-	#superclass : #MooseModel,
-	#category : #FamixNGSQL
-}
-
-{ #category : #'as yet unclassified' }
-FmxSQLMooseModel >> gtEntitiesIn: composite [
-	"To not show all entities in model inspector"
-]
-
-{ #category : #initialization }
-FmxSQLMooseModel >> initialize [
-		<generated>
-		super initialize.
-		self metamodel: (self class environment at: #FmxSQLMetamodelGenerator) metamodel
-]
diff --git a/src/FamixNGSQL/FmxSQLNamedEntity.class.st b/src/FamixNGSQL/FmxSQLNamedEntity.class.st
index 25cba4ca..cf738b6f 100644
--- a/src/FamixNGSQL/FmxSQLNamedEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLNamedEntity.class.st
@@ -1,15 +1,15 @@
 Class {
 	#name : #FmxSQLNamedEntity,
-	#superclass : #FmxSQLSourcedEntity,
-	#traits : 'FamixTNamed + TDependencyQueries + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTNamed classTrait + TDependencyQueries classTrait + TEntityMetaLevelDependency classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#superclass : #FmxSQLEntity,
+	#traits : 'FamixTNamedEntity',
+	#classTraits : 'FamixTNamedEntity classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLNamedEntity class >> annotation [
 
-	<MSEClass: #NamedEntity super: #FmxSQLSourcedEntity>
+	<FMClass: #NamedEntity super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLNamespace.class.st b/src/FamixNGSQL/FmxSQLNamespace.class.st
index 8550c608..9aa4dabf 100644
--- a/src/FamixNGSQL/FmxSQLNamespace.class.st
+++ b/src/FamixNGSQL/FmxSQLNamespace.class.st
@@ -15,17 +15,24 @@ Class {
 { #category : #meta }
 FmxSQLNamespace class >> annotation [
 
-	<MSEClass: #Namespace super: #FmxSQLStructuralEntity>
+	<FMClass: #Namespace super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLNamespace >> addReference: anObject [
+	<generated>
+	^ self references add: anObject
+]
+
 { #category : #accessing }
 FmxSQLNamespace >> references [
 	"Relation named: #references type: #FmxSQLNamespaceReference opposite: #namespace"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -34,5 +41,4 @@ FmxSQLNamespace >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLNamespaceReference.class.st b/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
index 2d3fdc4a..8dca074f 100644
--- a/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
+++ b/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
@@ -7,8 +7,8 @@ Class {
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#namespace => FMOne type: #FmxSQLNamespace opposite: #references',
-		'#source => FMOne type: #FmxSQLTWithNamespaceReference opposite: #outgoingNamespaceReference'
+		'#source => FMOne type: #FmxSQLTWithNamespaceReference opposite: #outgoingNamespaceReference',
+		'#namespace => FMOne type: #FmxSQLNamespace opposite: #references'
 	],
 	#category : #'FamixNGSQL-Entities'
 }
@@ -16,7 +16,7 @@ Class {
 { #category : #meta }
 FmxSQLNamespaceReference class >> annotation [
 
-	<MSEClass: #NamespaceReference super: #FmxSQLReference>
+	<FMClass: #NamespaceReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -36,7 +36,6 @@ FmxSQLNamespaceReference >> namespace: anObject [
 
 	<generated>
 	namespace := anObject
-
 ]
 
 { #category : #accessing }
@@ -52,5 +51,4 @@ FmxSQLNamespaceReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st b/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
index e8f375ee..36b1cee0 100644
--- a/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
@@ -6,13 +6,13 @@ Class {
 	#superclass : #FmxSQLLocalVariable,
 	#traits : 'FmxSQLColumnsContainer',
 	#classTraits : 'FmxSQLColumnsContainer classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLNewLocalVariable class >> annotation [
 
-	<MSEClass: #NewLocalVariable super: #FmxSQLLocalVariable>
+	<FMClass: #NewLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLNoSourceAnchor.class.st b/src/FamixNGSQL/FmxSQLNoSourceAnchor.class.st
deleted file mode 100644
index 3ec0d449..00000000
--- a/src/FamixNGSQL/FmxSQLNoSourceAnchor.class.st
+++ /dev/null
@@ -1,25 +0,0 @@
-Class {
-	#name : #FmxSQLNoSourceAnchor,
-	#superclass : #Error,
-	#instVars : [
-		'entityWithoutSourceAnchor'
-	],
-	#category : #FamixNGSQL
-}
-
-{ #category : #'instance creation' }
-FmxSQLNoSourceAnchor class >> signalForEntityWithoutSourceAnchor: entityWithoutSourceAnchor [
-	^ self new
-		entityWithoutSourceAnchor: entityWithoutSourceAnchor;
-		signal
-]
-
-{ #category : #accessing }
-FmxSQLNoSourceAnchor >> entityWithoutSourceAnchor [
-	^ entityWithoutSourceAnchor
-]
-
-{ #category : #accessing }
-FmxSQLNoSourceAnchor >> entityWithoutSourceAnchor: anObject [
-	entityWithoutSourceAnchor := anObject
-]
diff --git a/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st b/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
index f97b349d..97ce21c2 100644
--- a/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
@@ -4,13 +4,13 @@ I represent a NOT NULL constraint as defined in SQL standard.
 Class {
 	#name : #FmxSQLNotNullConstraint,
 	#superclass : #FmxSQLConstraint,
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLNotNullConstraint class >> annotation [
 
-	<MSEClass: #NotNullConstraint super: #FmxSQLConstraint>
+	<FMClass: #NotNullConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -22,13 +22,3 @@ FmxSQLNotNullConstraint >> isNotNullConstraint [
 	<generated>
 	^ true
 ]
-
-{ #category : #printing }
-FmxSQLNotNullConstraint >> mooseNameOn: aStream [
-	aStream << 'NOT NULL ('.
-	(self outgoingColumnReferences collect: #column) do: [ :c |
-		aStream << c name ] separatedBy: [ aStream << ', ' ].
-	aStream
-		<< ') #';
-		<< self mooseID.
-]
diff --git a/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st b/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
index 1a282951..05065ee7 100644
--- a/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
@@ -6,13 +6,13 @@ Class {
 	#superclass : #FmxSQLLocalVariable,
 	#traits : 'FmxSQLColumnsContainer',
 	#classTraits : 'FmxSQLColumnsContainer classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLOldLocalVariable class >> annotation [
 
-	<MSEClass: #OldLocalVariable super: #FmxSQLLocalVariable>
+	<FMClass: #OldLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLOnConflictClause.class.st b/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
index e9b341af..90f0229e 100644
--- a/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
+++ b/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLOnConflictClause class >> annotation [
 
-	<MSEClass: #OnConflictClause super: #FmxSQLClause>
+	<FMClass: #OnConflictClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLOrderByClause.class.st b/src/FamixNGSQL/FmxSQLOrderByClause.class.st
index 154c8067..55590999 100644
--- a/src/FamixNGSQL/FmxSQLOrderByClause.class.st
+++ b/src/FamixNGSQL/FmxSQLOrderByClause.class.st
@@ -4,25 +4,20 @@ I am an order by clause
 Class {
 	#name : #FmxSQLOrderByClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLOrderByClause class >> annotation [
 
-	<MSEClass: #OrderByClause super: #FmxSQLClause>
+	<FMClass: #OrderByClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLOrderByClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLOrderByClause >> isOrderByClause [
 
diff --git a/src/FamixNGSQL/FmxSQLParameter.class.st b/src/FamixNGSQL/FmxSQLParameter.class.st
index b3a75853..4bfca554 100644
--- a/src/FamixNGSQL/FmxSQLParameter.class.st
+++ b/src/FamixNGSQL/FmxSQLParameter.class.st
@@ -9,56 +9,18 @@ Class {
 	#instVars : [
 		'#type => FMOne type: #FmxSQLAbstractType opposite: #parameters'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLParameter class >> annotation [
 
-	<MSEClass: #Parameter super: #FmxSQLNamedEntity>
+	<FMClass: #Parameter super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLParameter class >> requirements [
-
-	<generated>
-	^ { FmxSQLCursor. FmxSQLStoredProcedure }
-]
-
-{ #category : #accessing }
-FmxSQLParameter >> belongsTo [
-
-	<generated>
-	^ self parentBehaviouralEntity
-
-]
-
-{ #category : #accessing }
-FmxSQLParameter >> belongsTo: anObject [
-
-	<generated>
-	self parentBehaviouralEntity: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLParameter >> maximalImpactSet [
-	^ self query: #in with: FmxSQLParameterAccess 
-]
-
-{ #category : #accessing }
-FmxSQLParameter >> storedProcedure [
-	^ self parentBehaviouralEntity
-]
-
-{ #category : #accessing }
-FmxSQLParameter >> storedProcedure: anObject [
-	self parentBehaviouralEntity: anObject
-]
-
 { #category : #accessing }
 FmxSQLParameter >> type [
 	"Relation named: #type type: #FmxSQLAbstractType opposite: #parameters"
@@ -72,5 +34,4 @@ FmxSQLParameter >> type: anObject [
 
 	<generated>
 	type := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLParameterAccess.class.st b/src/FamixNGSQL/FmxSQLParameterAccess.class.st
index 29979576..08c14302 100644
--- a/src/FamixNGSQL/FmxSQLParameterAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLParameterAccess.class.st
@@ -6,13 +6,13 @@ Class {
 	#superclass : #FmxSQLReference,
 	#traits : 'FamixTAccess',
 	#classTraits : 'FamixTAccess classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLParameterAccess class >> annotation [
 
-	<MSEClass: #ParameterAccess super: #FmxSQLReference>
+	<FMClass: #ParameterAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -24,8 +24,3 @@ FmxSQLParameterAccess >> isParameterAccess [
 	<generated>
 	^ true
 ]
-
-{ #category : #accessing }
-FmxSQLParameterAccess >> source [
-	^ self from
-]
diff --git a/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st b/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
index 3d229ad0..06bc972b 100644
--- a/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
@@ -4,13 +4,13 @@ I represent a PRIMARY KEY constraint as defined in SQL standard.
 Class {
 	#name : #FmxSQLPrimaryKeyConstraint,
 	#superclass : #FmxSQLConstraint,
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLPrimaryKeyConstraint class >> annotation [
 
-	<MSEClass: #PrimaryKeyConstraint super: #FmxSQLConstraint>
+	<FMClass: #PrimaryKeyConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -22,15 +22,3 @@ FmxSQLPrimaryKeyConstraint >> isPrimaryKeyConstraint [
 	<generated>
 	^ true
 ]
-
-{ #category : #printing }
-FmxSQLPrimaryKeyConstraint >> mooseNameOn: aStream [
-	aStream << $".
-	super mooseNameOn: aStream.
-	aStream << '" PK ('.
-	(self outgoingColumnReferences collect: #column) do: [ :c |
-		aStream << c name ] separatedBy: [ aStream << ', ' ].
-	aStream
-		<< ') #';
-		<< self mooseID.
-]
diff --git a/src/FamixNGSQL/FmxSQLQualifiedReference.class.st b/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
index be32f92f..0d1d430d 100644
--- a/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
+++ b/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
@@ -24,17 +24,24 @@ Class {
 { #category : #meta }
 FmxSQLQualifiedReference class >> annotation [
 
-	<MSEClass: #QualifiedReference super: #FmxSQLEntity>
+	<FMClass: #QualifiedReference super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLQualifiedReference >> addReference: anObject [
+	<generated>
+	^ self references add: anObject
+]
+
 { #category : #accessing }
 FmxSQLQualifiedReference >> references [
 	"Relation named: #references type: #FmxSQLTWithQualifiedReference opposite: #qualifiedReference"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -43,5 +50,4 @@ FmxSQLQualifiedReference >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st b/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
index 4ea88d33..ff343d00 100644
--- a/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
@@ -9,13 +9,13 @@ Class {
 	#instVars : [
 		'#queryBoundTo => FMOne type: #FmxSQLSelectQuery opposite: #recordLocalVariables'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLRecordLocalVariable class >> annotation [
 
-	<MSEClass: #RecordLocalVariable super: #FmxSQLLocalVariable>
+	<FMClass: #RecordLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -34,5 +34,4 @@ FmxSQLRecordLocalVariable >> queryBoundTo: anObject [
 
 	<generated>
 	queryBoundTo := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLReference.class.st b/src/FamixNGSQL/FmxSQLReference.class.st
index b2a259cb..16f2bec0 100644
--- a/src/FamixNGSQL/FmxSQLReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReference.class.st
@@ -10,41 +10,18 @@ Class {
 		'#belongsToGroup => FMOne type: #FmxSQLReferencesGroup opposite: #references',
 		'#storedProcedureContainer => FMOne type: #FmxSQLStoredProcedureCall opposite: #arguments'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLReference class >> annotation [
 
-	<MSEClass: #Reference super: #FmxSQLAssociation>
+	<FMClass: #Reference super: #FmxSQLAssociation>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLReference class >> requirements [
-
-	<generated>
-	^ { FmxSQLReferencesGroup. FmxSQLStoredProcedureCall }
-]
-
-{ #category : #accessing }
-FmxSQLReference >> belongsTo [
-
-	<generated>
-	^ self belongsToGroup
-
-]
-
-{ #category : #accessing }
-FmxSQLReference >> belongsTo: anObject [
-
-	<generated>
-	self belongsToGroup: anObject
-
-]
-
 { #category : #accessing }
 FmxSQLReference >> belongsToGroup [
 	"Relation named: #belongsToGroup type: #FmxSQLReferencesGroup opposite: #references"
@@ -59,68 +36,13 @@ FmxSQLReference >> belongsToGroup: anObject [
 
 	<generated>
 	belongsToGroup := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLReference >> belongsToGroupGroup [
 	<generated>
 	<navigation: 'BelongsToGroup'>
-	^ MooseGroup with: self belongsToGroup
-]
-
-{ #category : #testing }
-FmxSQLReference >> isInReferencesGroup [
-	^ self belongsToGroup isNotNil
-]
-
-{ #category : #testing }
-FmxSQLReference >> isReference [
-	^ true
-]
-
-{ #category : #testing }
-FmxSQLReference >> isWildCardReference [
-	^ false
-]
-
-{ #category : #accessing }
-FmxSQLReference >> sourceAnchor [
-	^ super sourceAnchor
-		ifNil: [ 
-			self belongsToGroup
-				ifNil: [ FmxSQLNoSourceAnchor signalForEntityWithoutSourceAnchor: self ]
-				ifNotNil: #sourceAnchor ]
-]
-
-{ #category : #accessing }
-FmxSQLReference >> sourceAnchorIfNone: aBlock [
-	^ [ self sourceAnchor ]
-		on: FmxSQLNoSourceAnchor
-		do: [ aBlock value ]
-]
-
-{ #category : #accessing }
-FmxSQLReference >> sourceAnchorOrReferenceGroupSourceAnchor [
-	^ self sourceAnchor
-		ifNil: [ 
-			self belongsToGroup
-				ifNotNil: #sourceAnchor
-				ifNil: [ nil ] ]
-]
-
-{ #category : #accessing }
-FmxSQLReference >> start [
-	"Returns the first position of myself in the source code.
-	 I simply return the result of #start method sent to my #sourceAnchor."
-	^ self sourceAnchor start
-]
-
-{ #category : #accessing }
-FmxSQLReference >> stop [
-	"Returns the last position of myself in the source code.
-	 I return the result of #stop method sent to my #sourceAnchor except for the stored procedure call (see method)."
-	^ self sourceAnchor end
+	^ MooseSpecializedGroup with: self belongsToGroup
 ]
 
 { #category : #accessing }
@@ -137,12 +59,11 @@ FmxSQLReference >> storedProcedureContainer: anObject [
 
 	<generated>
 	storedProcedureContainer := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLReference >> storedProcedureContainerGroup [
 	<generated>
 	<navigation: 'StoredProcedureContainer'>
-	^ MooseGroup with: self storedProcedureContainer
+	^ MooseSpecializedGroup with: self storedProcedureContainer
 ]
diff --git a/src/FamixNGSQL/FmxSQLReferencesGroup.class.st b/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
index d56dbe4f..f908e424 100644
--- a/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
+++ b/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
@@ -11,8 +11,8 @@ FROM table
 Class {
 	#name : #FmxSQLReferencesGroup,
 	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTWithSourceAnchor + TDependencyQueries + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTWithSourceAnchor classTrait + TDependencyQueries classTrait + TEntityMetaLevelDependency classTrait',
+	#traits : 'FamixTSourceAnchor + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceAnchor classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
 		'#references => FMMany type: #FmxSQLReference opposite: #belongsToGroup',
 		'#incomingReferencesGroupReference => FMMany type: #FmxSQLTReferencesGroupReference opposite: #referencesGroup'
@@ -23,14 +23,20 @@ Class {
 { #category : #meta }
 FmxSQLReferencesGroup class >> annotation [
 
-	<MSEClass: #ReferencesGroup super: #FmxSQLEntity>
+	<FMClass: #ReferencesGroup super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLReferencesGroup >> addReferences: anObject [
+FmxSQLReferencesGroup >> addIncomingReferencesGroupReference: anObject [
+	<generated>
+	^ self incomingReferencesGroupReference add: anObject
+]
+
+{ #category : #adding }
+FmxSQLReferencesGroup >> addReference: anObject [
 	<generated>
 	^ self references add: anObject
 ]
@@ -40,6 +46,7 @@ FmxSQLReferencesGroup >> incomingReferencesGroupReference [
 	"Relation named: #incomingReferencesGroupReference type: #FmxSQLTReferencesGroupReference opposite: #referencesGroup"
 
 	<generated>
+	<derived>
 	^ incomingReferencesGroupReference
 ]
 
@@ -48,7 +55,6 @@ FmxSQLReferencesGroup >> incomingReferencesGroupReference: anObject [
 
 	<generated>
 	incomingReferencesGroupReference value: anObject
-
 ]
 
 { #category : #accessing }
@@ -56,6 +62,7 @@ FmxSQLReferencesGroup >> references [
 	"Relation named: #references type: #FmxSQLReference opposite: #belongsToGroup"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -64,12 +71,11 @@ FmxSQLReferencesGroup >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLReferencesGroup >> referencesGroup [
 	<generated>
 	<navigation: 'References'>
-	^ MooseGroup withAll: self references asSet
+	^ MooseSpecializedGroup withAll: self references asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
index 2dde6f84..b0813d82 100644
--- a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
@@ -4,49 +4,16 @@ TODO
 Class {
 	#name : #FmxSQLReferencesGroupReference,
 	#superclass : #FmxSQLReference,
-	#traits : 'FmxSQLTReferencesGroupReference + TDependencyQueries + TEntityMetaLevelDependency',
-	#classTraits : 'FmxSQLTReferencesGroupReference classTrait + TDependencyQueries classTrait + TEntityMetaLevelDependency classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FmxSQLTReferencesGroupReference + TEntityMetaLevelDependency',
+	#classTraits : 'FmxSQLTReferencesGroupReference classTrait + TEntityMetaLevelDependency classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLReferencesGroupReference class >> annotation [
 
-	<MSEClass: #ReferencesGroupReference super: #FmxSQLReference>
+	<FMClass: #ReferencesGroupReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
-
-{ #category : #meta }
-FmxSQLReferencesGroupReference class >> requirements [
-
-	<generated>
-	^ { FmxSQLColumnAlias. FmxSQLFromClause. FmxSQLGroupByClause. FmxSQLHavingClause. FmxSQLOrderByClause. FmxSQLReturningClause. FmxSQLWhereClause }
-]
-
-{ #category : #accessing }
-FmxSQLReferencesGroupReference >> belongsTo [
-
-	<generated>
-	^ self source
-
-]
-
-{ #category : #accessing }
-FmxSQLReferencesGroupReference >> belongsTo: anObject [
-
-	<generated>
-	self source: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLReferencesGroupReference >> from [
-	^ self source
-]
-
-{ #category : #accessing }
-FmxSQLReferencesGroupReference >> to [
-	^ self referencesGroup
-]
diff --git a/src/FamixNGSQL/FmxSQLReturningClause.class.st b/src/FamixNGSQL/FmxSQLReturningClause.class.st
index 56186b27..68500014 100644
--- a/src/FamixNGSQL/FmxSQLReturningClause.class.st
+++ b/src/FamixNGSQL/FmxSQLReturningClause.class.st
@@ -4,25 +4,20 @@ I am a returning clause
 Class {
 	#name : #FmxSQLReturningClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithReferencesGroupReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithReferencesGroupReference classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithReferencesGroupReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithReferencesGroupReference classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLReturningClause class >> annotation [
 
-	<MSEClass: #ReturningClause super: #FmxSQLClause>
+	<FMClass: #ReturningClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLReturningClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLReturningClause >> isReturningClause [
 
diff --git a/src/FamixNGSQL/FmxSQLSelectClause.class.st b/src/FamixNGSQL/FmxSQLSelectClause.class.st
index f657f44a..460db120 100644
--- a/src/FamixNGSQL/FmxSQLSelectClause.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectClause.class.st
@@ -4,25 +4,20 @@ I am a select clause
 Class {
 	#name : #FmxSQLSelectClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLSelectClause class >> annotation [
 
-	<MSEClass: #SelectClause super: #FmxSQLClause>
+	<FMClass: #SelectClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLSelectClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLSelectClause >> isSelectClause [
 
diff --git a/src/FamixNGSQL/FmxSQLSelectQuery.class.st b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
index 75eb4d29..552b9ca5 100644
--- a/src/FamixNGSQL/FmxSQLSelectQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
@@ -16,17 +16,16 @@ Class {
 { #category : #meta }
 FmxSQLSelectQuery class >> annotation [
 
-	<MSEClass: #SelectQuery super: #FmxSQLCRUDQuery>
+	<FMClass: #SelectQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLSelectQuery class >> requirements [
-
+{ #category : #adding }
+FmxSQLSelectQuery >> addRecordLocalVariable: anObject [
 	<generated>
-	^ { FmxSQLView }
+	^ self recordLocalVariables add: anObject
 ]
 
 { #category : #accessing }
@@ -34,6 +33,7 @@ FmxSQLSelectQuery >> recordLocalVariables [
 	"Relation named: #recordLocalVariables type: #FmxSQLRecordLocalVariable opposite: #queryBoundTo"
 
 	<generated>
+	<derived>
 	^ recordLocalVariables
 ]
 
@@ -42,12 +42,6 @@ FmxSQLSelectQuery >> recordLocalVariables: anObject [
 
 	<generated>
 	recordLocalVariables value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLSelectQuery >> selectClause [
-	^ self clauses detect: [ :clause | clause class = FmxSQLSelectClause ]
 ]
 
 { #category : #accessing }
@@ -56,6 +50,7 @@ FmxSQLSelectQuery >> viewDefining [
 
 	<generated>
 	<container>
+	<derived>
 	^ viewDefining
 ]
 
@@ -64,12 +59,11 @@ FmxSQLSelectQuery >> viewDefining: anObject [
 
 	<generated>
 	viewDefining := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLSelectQuery >> viewDefiningGroup [
 	<generated>
 	<navigation: 'ViewDefining'>
-	^ MooseGroup with: self viewDefining
+	^ MooseSpecializedGroup with: self viewDefining
 ]
diff --git a/src/FamixNGSQL/FmxSQLSetClause.class.st b/src/FamixNGSQL/FmxSQLSetClause.class.st
index 9f77169e..d07d3dde 100644
--- a/src/FamixNGSQL/FmxSQLSetClause.class.st
+++ b/src/FamixNGSQL/FmxSQLSetClause.class.st
@@ -4,25 +4,20 @@ I am a set clause
 Class {
 	#name : #FmxSQLSetClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLSetClause class >> annotation [
 
-	<MSEClass: #SetClause super: #FmxSQLClause>
+	<FMClass: #SetClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLSetClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLSetClause >> isSetClause [
 
diff --git a/src/FamixNGSQL/FmxSQLSourceAnchor.class.st b/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
index 85930b86..516ef8ee 100644
--- a/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
@@ -9,7 +9,7 @@ Class {
 { #category : #meta }
 FmxSQLSourceAnchor class >> annotation [
 
-	<MSEClass: #SourceAnchor super: #FmxSQLEntity>
+	<FMClass: #SourceAnchor super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLSourceLanguage.class.st b/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
index a68da8d6..99b53d2b 100644
--- a/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
@@ -3,13 +3,13 @@ Class {
 	#superclass : #FmxSQLEntity,
 	#traits : 'FamixTSourceLanguage',
 	#classTraits : 'FamixTSourceLanguage classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLSourceLanguage class >> annotation [
 
-	<MSEClass: #SourceLanguage super: #FmxSQLEntity>
+	<FMClass: #SourceLanguage super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st b/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
index a7f1138d..ce5d3d65 100644
--- a/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
@@ -1,15 +1,15 @@
 Class {
 	#name : #FmxSQLSourceTextAnchor,
 	#superclass : #FmxSQLSourceAnchor,
-	#traits : 'FamixTWithImmediateSource',
-	#classTraits : 'FamixTWithImmediateSource classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FamixTHasImmediateSource',
+	#classTraits : 'FamixTHasImmediateSource classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLSourceTextAnchor class >> annotation [
 
-	<MSEClass: #SourceTextAnchor super: #FmxSQLSourceAnchor>
+	<FMClass: #SourceTextAnchor super: #FmxSQLSourceAnchor>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLSourcedEntity.class.st b/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
index c680f99a..68b64409 100644
--- a/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
@@ -1,15 +1,15 @@
 Class {
 	#name : #FmxSQLSourcedEntity,
 	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTSourceEntity + FamixTWithComments',
-	#classTraits : 'FamixTSourceEntity classTrait + FamixTWithComments classTrait',
+	#traits : 'FamixTSourceEntity',
+	#classTraits : 'FamixTSourceEntity classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLSourcedEntity class >> annotation [
 
-	<MSEClass: #SourcedEntity super: #FmxSQLEntity>
+	<FMClass: #SourcedEntity super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
index 2c711242..92e78413 100644
--- a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
+++ b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
@@ -4,8 +4,8 @@ I am a stored procedure. That is to say, a function that is defined inside the d
 Class {
 	#name : #FmxSQLStoredProcedure,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTInvocable + FamixTNamedEntity + FamixTWithAccesses + FamixTWithImmediateSource + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTQueryContainer + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTInvocable classTrait + FamixTNamedEntity classTrait + FamixTWithAccesses classTrait + FamixTWithImmediateSource classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTInvocable + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithAccesses + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithImmediateSource + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTInvocable classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithImmediateSource classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#instVars : [
 		'#checkConstraintsCalling => FMMany type: #FmxSQLCheckConstraint opposite: #storedProceduresCalled',
 		'#returnType => FMOne type: #FmxSQLAbstractType opposite: #storedProceduresReturning'
@@ -16,44 +16,16 @@ Class {
 { #category : #meta }
 FmxSQLStoredProcedure class >> annotation [
 
-	<MSEClass: #StoredProcedure super: #FmxSQLNamedEntity>
+	<FMClass: #StoredProcedure super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allDependencies [
-	^ self viewsDependencies , self storedProceduresDependencies
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allDepending [
-	^ self viewsDepending , self storedProceduresDepending
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allStoredProceduresDependencies [
-	"Returns the stored procedures that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #storedProceduresDependencies) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allStoredProceduresDepending [
-	"Returns the stored procedures that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #storedProceduresDepending) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allViewsDependencies [
-	"Returns the views that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #viewsDependencies) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> allViewsDepending [
-	"Returns the views that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #viewsDepending) allButFirst
+{ #category : #adding }
+FmxSQLStoredProcedure >> addCheckConstraintsCalling: anObject [
+	<generated>
+	^ self checkConstraintsCalling add: anObject
 ]
 
 { #category : #accessing }
@@ -69,12 +41,6 @@ FmxSQLStoredProcedure >> checkConstraintsCalling: anObject [
 
 	<generated>
 	checkConstraintsCalling value: anObject
-
-]
-
-{ #category : #testing }
-FmxSQLStoredProcedure >> isAnyBelongerSourced [
-	^ true
 ]
 
 { #category : #testing }
@@ -97,39 +63,4 @@ FmxSQLStoredProcedure >> returnType: anObject [
 
 	<generated>
 	returnType := anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> sourceCodeAsText [
-	^ PostgreSQLHighlighter highlightSelectQuery: self source
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> sourcedBelonger [
-	^ self
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> storedProceduresDependencies [
-	"Returns the stored procedures that I depend on directly (I call them directly)."
-	^ ((self queryOutgoing: FmxSQLStoredProcedureCall) collect: [ :ref | ref to ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> storedProceduresDepending [
-	"Returns the views that depends on myself directly (reference myself directly)."
-	^ ((self queryLocalIncoming: FmxSQLStoredProcedureCall) collect: [ :ref | ref from sourcedBelonger ] thenSelect: [ :sourcedBelonger | sourcedBelonger isNotNil and: [ sourcedBelonger isStoredProcedure ] ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> viewsDependencies [
-	"Returns the views that I depend on directly (I reference them directly)."
-	^ ((self queryOutgoing: FmxSQLViewReference) collect: [ :ref | ref to ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLStoredProcedure >> viewsDepending [
-	"Returns the views that depends on myself directly (reference myself directly)."
-	^ ((self queryLocalIncoming: FmxSQLStoredProcedureCall) collect: [ :ref | ref from sourcedBelonger ] thenSelect: [ :sourcedBelonger | sourcedBelonger isNotNil and: [ sourcedBelonger isView ] ]) asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st b/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
index 635aa614..49c5340e 100644
--- a/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
+++ b/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
@@ -15,14 +15,14 @@ Class {
 { #category : #meta }
 FmxSQLStoredProcedureCall class >> annotation [
 
-	<MSEClass: #StoredProcedureCall super: #FmxSQLReference>
+	<FMClass: #StoredProcedureCall super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLStoredProcedureCall >> addArguments: anObject [
+FmxSQLStoredProcedureCall >> addArgument: anObject [
 	<generated>
 	^ self arguments add: anObject
 ]
@@ -32,6 +32,7 @@ FmxSQLStoredProcedureCall >> arguments [
 	"Relation named: #arguments type: #FmxSQLReference opposite: #storedProcedureContainer"
 
 	<generated>
+	<derived>
 	^ arguments
 ]
 
@@ -40,14 +41,13 @@ FmxSQLStoredProcedureCall >> arguments: anObject [
 
 	<generated>
 	arguments value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLStoredProcedureCall >> argumentsGroup [
 	<generated>
 	<navigation: 'Arguments'>
-	^ MooseGroup withAll: self arguments asSet
+	^ MooseSpecializedGroup withAll: self arguments asSet
 ]
 
 { #category : #testing }
@@ -56,12 +56,3 @@ FmxSQLStoredProcedureCall >> isStoredProcedureCall [
 	<generated>
 	^ true
 ]
-
-{ #category : #accessing }
-FmxSQLStoredProcedureCall >> stop [
-	"Returns the last position of the stored procedure name in the source code (without parentheses and args)."
-	| sourceCode |
-	sourceCode := self source sourcedBelonger source copyFrom: self start to: sourceCode size.
-	self flag: #TODO. "This heuristic might be wrong. We need more data in the model..."
-	^ self start + sourceCode detectIndex: [ :c | c = $( ]
-]
diff --git a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
index 2fadd361..230325a4 100644
--- a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
@@ -4,15 +4,15 @@ I am an abstract superclass for structural entities. A structural entity is an e
 Class {
 	#name : #FmxSQLStructuralEntity,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamedEntity',
-	#classTraits : 'FamixTNamedEntity classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FmxSQLTNamedEntity',
+	#classTraits : 'FmxSQLTNamedEntity classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLStructuralEntity class >> annotation [
 
-	<MSEClass: #StructuralEntity super: #FmxSQLNamedEntity>
+	<FMClass: #StructuralEntity super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLTArgument.trait.st b/src/FamixNGSQL/FmxSQLTArgument.trait.st
index 216311d7..3ed3573e 100644
--- a/src/FamixNGSQL/FmxSQLTArgument.trait.st
+++ b/src/FamixNGSQL/FmxSQLTArgument.trait.st
@@ -6,7 +6,7 @@ Trait {
 { #category : #meta }
 FmxSQLTArgument classSide >> annotation [
 
-	<MSEClass: #TArgument super: #Trait>
+	<FMClass: #TArgument super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLTColumn.trait.st b/src/FamixNGSQL/FmxSQLTColumn.trait.st
index 519bcdae..3b14bb26 100644
--- a/src/FamixNGSQL/FmxSQLTColumn.trait.st
+++ b/src/FamixNGSQL/FmxSQLTColumn.trait.st
@@ -3,13 +3,13 @@ Trait {
 	#instVars : [
 		'#columnsContainer => FMOne type: #FmxSQLColumnsContainer opposite: #columns'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTColumn classSide >> annotation [
 
-	<MSEClass: #TColumn super: #Trait>
+	<FMClass: #TColumn super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -29,12 +29,11 @@ FmxSQLTColumn >> columnsContainer: anObject [
 
 	<generated>
 	columnsContainer := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTColumn >> columnsContainerGroup [
 	<generated>
 	<navigation: 'ColumnsContainer'>
-	^ MooseGroup with: self columnsContainer
+	^ MooseSpecializedGroup with: self columnsContainer
 ]
diff --git a/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st b/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
index 038d5c6d..6380966c 100644
--- a/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
+++ b/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
@@ -3,13 +3,13 @@ Trait {
 	#instVars : [
 		'#derivedTablesDefined => FMMany type: #FmxSQLDerivedTable opposite: #parentQuery'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTDefiningDerivedTables classSide >> annotation [
 
-	<MSEClass: #TDefiningDerivedTables super: #Trait>
+	<FMClass: #TDefiningDerivedTables super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -26,6 +26,7 @@ FmxSQLTDefiningDerivedTables >> derivedTablesDefined [
 	"Relation named: #derivedTablesDefined type: #FmxSQLDerivedTable opposite: #parentQuery"
 
 	<generated>
+	<derived>
 	^ derivedTablesDefined
 ]
 
@@ -34,12 +35,11 @@ FmxSQLTDefiningDerivedTables >> derivedTablesDefined: anObject [
 
 	<generated>
 	derivedTablesDefined value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTDefiningDerivedTables >> derivedTablesDefinedGroup [
 	<generated>
 	<navigation: 'DerivedTablesDefined'>
-	^ MooseGroup withAll: self derivedTablesDefined asSet
+	^ MooseSpecializedGroup withAll: self derivedTablesDefined asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st b/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
new file mode 100644
index 00000000..ae2a0dd8
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
@@ -0,0 +1,13 @@
+Trait {
+	#name : #FmxSQLTNamedEntity,
+	#category : #'FamixNGSQL-Traits'
+}
+
+{ #category : #meta }
+FmxSQLTNamedEntity classSide >> annotation [
+
+	<FMClass: #TNamedEntity super: #Object>
+	<package: #FamixNGSQL>
+	<generated>
+	^self
+]
diff --git a/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st b/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
index badaa2c1..b4c5ecc6 100644
--- a/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
+++ b/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
@@ -6,20 +6,20 @@ Trait {
 	#instVars : [
 		'#queries => FMMany type: #FmxSQLCRUDQuery opposite: #container'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTQueryContainer classSide >> annotation [
 
-	<MSEClass: #TQueryContainer super: #Trait>
+	<FMClass: #TQueryContainer super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLTQueryContainer >> addQueries: anObject [
+FmxSQLTQueryContainer >> addQuery: anObject [
 	<generated>
 	^ self queries add: anObject
 ]
@@ -36,6 +36,7 @@ FmxSQLTQueryContainer >> queries [
 	"Relation named: #queries type: #FmxSQLCRUDQuery opposite: #container"
 
 	<generated>
+	<derived>
 	^ queries
 ]
 
@@ -44,12 +45,11 @@ FmxSQLTQueryContainer >> queries: anObject [
 
 	<generated>
 	queries value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTQueryContainer >> queriesGroup [
 	<generated>
 	<navigation: 'Queries'>
-	^ MooseGroup withAll: self queries asSet
+	^ MooseSpecializedGroup withAll: self queries asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st b/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
index a0e11066..85b8ca21 100644
--- a/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
@@ -10,7 +10,7 @@ Trait {
 { #category : #meta }
 FmxSQLTReferencesGroupReference classSide >> annotation [
 
-	<MSEClass: #TReferencesGroupReference super: #Trait>
+	<FMClass: #TReferencesGroupReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -29,7 +29,6 @@ FmxSQLTReferencesGroupReference >> referencesGroup: anObject [
 
 	<generated>
 	referencesGroup := anObject
-
 ]
 
 { #category : #accessing }
@@ -46,12 +45,11 @@ FmxSQLTReferencesGroupReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTReferencesGroupReference >> sourceGroup [
 	<generated>
 	<navigation: 'Source'>
-	^ MooseGroup with: self source
+	^ MooseSpecializedGroup with: self source
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st b/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
new file mode 100644
index 00000000..02070d14
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
@@ -0,0 +1,13 @@
+Trait {
+	#name : #FmxSQLTWithAccesses,
+	#category : #'FamixNGSQL-Traits'
+}
+
+{ #category : #meta }
+FmxSQLTWithAccesses classSide >> annotation [
+
+	<FMClass: #TWithAccesses super: #Object>
+	<package: #FamixNGSQL>
+	<generated>
+	^self
+]
diff --git a/src/FamixNGSQL/FmxSQLTWithAlias.trait.st b/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
index eee36829..ac80563c 100644
--- a/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
@@ -3,20 +3,20 @@ Trait {
 	#instVars : [
 		'#aliases => FMMany type: #FmxSQLAlias opposite: #parentBehaviouralEntity'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithAlias classSide >> annotation [
 
-	<MSEClass: #TWithAlias super: #Trait>
+	<FMClass: #TWithAlias super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLTWithAlias >> addAliases: anObject [
+FmxSQLTWithAlias >> addAliase: anObject [
 	<generated>
 	^ self aliases add: anObject
 ]
@@ -26,6 +26,7 @@ FmxSQLTWithAlias >> aliases [
 	"Relation named: #aliases type: #FmxSQLAlias opposite: #parentBehaviouralEntity"
 
 	<generated>
+	<derived>
 	^ aliases
 ]
 
@@ -34,12 +35,11 @@ FmxSQLTWithAlias >> aliases: anObject [
 
 	<generated>
 	aliases value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTWithAlias >> aliasesGroup [
 	<generated>
 	<navigation: 'Aliases'>
-	^ MooseGroup withAll: self aliases asSet
+	^ MooseSpecializedGroup withAll: self aliases asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st b/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
index 919d0dca..9c3752e9 100644
--- a/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#outgoingColumnReferences => FMMany type: #FmxSQLColumnReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithColumnReference classSide >> annotation [
 
-	<MSEClass: #TWithColumnReference super: #Trait>
+	<FMClass: #TWithColumnReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithColumnReference >> addOutgoingColumnReference: anObject [
+	<generated>
+	^ self outgoingColumnReferences add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithColumnReference >> outgoingColumnReferences [
 	"Relation named: #outgoingColumnReferences type: #FmxSQLColumnReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingColumnReferences
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithColumnReference >> outgoingColumnReferences: anObject [
 
 	<generated>
 	outgoingColumnReferences value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithCursor.trait.st b/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
index 59f67dc5..59b3a9c9 100644
--- a/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
@@ -3,20 +3,20 @@ Trait {
 	#instVars : [
 		'#cursors => FMMany type: #FmxSQLCursor opposite: #parentBehaviouralEntity'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithCursor classSide >> annotation [
 
-	<MSEClass: #TWithCursor super: #Trait>
+	<FMClass: #TWithCursor super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLTWithCursor >> addCursors: anObject [
+FmxSQLTWithCursor >> addCursor: anObject [
 	<generated>
 	^ self cursors add: anObject
 ]
@@ -26,6 +26,7 @@ FmxSQLTWithCursor >> cursors [
 	"Relation named: #cursors type: #FmxSQLCursor opposite: #parentBehaviouralEntity"
 
 	<generated>
+	<derived>
 	^ cursors
 ]
 
@@ -34,12 +35,11 @@ FmxSQLTWithCursor >> cursors: anObject [
 
 	<generated>
 	cursors value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTWithCursor >> cursorsGroup [
 	<generated>
 	<navigation: 'Cursors'>
-	^ MooseGroup withAll: self cursors asSet
+	^ MooseSpecializedGroup withAll: self cursors asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st b/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
index f3858fc5..e48ecbe6 100644
--- a/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#outgoingCursorReferences => FMMany type: #FmxSQLCursorReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithCursorReference classSide >> annotation [
 
-	<MSEClass: #TWithCursorReference super: #Trait>
+	<FMClass: #TWithCursorReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithCursorReference >> addOutgoingCursorReference: anObject [
+	<generated>
+	^ self outgoingCursorReferences add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithCursorReference >> outgoingCursorReferences [
 	"Relation named: #outgoingCursorReferences type: #FmxSQLCursorReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingCursorReferences
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithCursorReference >> outgoingCursorReferences: anObject [
 
 	<generated>
 	outgoingCursorReferences value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st b/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
index 377ed09a..4df9e76f 100644
--- a/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#outgoingDerivedTableReferences => FMMany type: #FmxSQLDerivedTableReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithDerivedTableReference classSide >> annotation [
 
-	<MSEClass: #TWithDerivedTableReference super: #Trait>
+	<FMClass: #TWithDerivedTableReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithDerivedTableReference >> addOutgoingDerivedTableReference: anObject [
+	<generated>
+	^ self outgoingDerivedTableReferences add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithDerivedTableReference >> outgoingDerivedTableReferences [
 	"Relation named: #outgoingDerivedTableReferences type: #FmxSQLDerivedTableReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingDerivedTableReferences
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithDerivedTableReference >> outgoingDerivedTableReferences: anObject [
 
 	<generated>
 	outgoingDerivedTableReferences value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st b/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
index b0ea2f92..a7e75613 100644
--- a/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#anchorsOnIntervalsOfCode => FMMany type: #FmxSQLEntitySourceAnchor opposite: #entity'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithEntitySourceAnchor classSide >> annotation [
 
-	<MSEClass: #TWithEntitySourceAnchor super: #Trait>
+	<FMClass: #TWithEntitySourceAnchor super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithEntitySourceAnchor >> addAnchorsOnIntervalsOfCode: anObject [
+	<generated>
+	^ self anchorsOnIntervalsOfCode add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithEntitySourceAnchor >> anchorsOnIntervalsOfCode [
 	"Relation named: #anchorsOnIntervalsOfCode type: #FmxSQLEntitySourceAnchor opposite: #entity"
 
 	<generated>
+	<derived>
 	^ anchorsOnIntervalsOfCode
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithEntitySourceAnchor >> anchorsOnIntervalsOfCode: anObject [
 
 	<generated>
 	anchorsOnIntervalsOfCode value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st b/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st
new file mode 100644
index 00000000..4bcb162b
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st
@@ -0,0 +1,13 @@
+Trait {
+	#name : #FmxSQLTWithImmediateSource,
+	#category : #'FamixNGSQL-Traits'
+}
+
+{ #category : #meta }
+FmxSQLTWithImmediateSource classSide >> annotation [
+
+	<FMClass: #TWithImmediateSource super: #Object>
+	<package: #FamixNGSQL>
+	<generated>
+	^self
+]
diff --git a/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st b/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
index ed64299f..a3af6779 100644
--- a/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
@@ -9,17 +9,24 @@ Trait {
 { #category : #meta }
 FmxSQLTWithNamespaceReference classSide >> annotation [
 
-	<MSEClass: #TWithNamespaceReference super: #Trait>
+	<FMClass: #TWithNamespaceReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithNamespaceReference >> addOutgoingNamespaceReference: anObject [
+	<generated>
+	^ self outgoingNamespaceReference add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithNamespaceReference >> outgoingNamespaceReference [
 	"Relation named: #outgoingNamespaceReference type: #FmxSQLNamespaceReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingNamespaceReference
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithNamespaceReference >> outgoingNamespaceReference: anObject [
 
 	<generated>
 	outgoingNamespaceReference value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st b/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
index 847b06d8..7e8f6e2a 100644
--- a/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
@@ -9,7 +9,7 @@ Trait {
 { #category : #meta }
 FmxSQLTWithQualifiedReference classSide >> annotation [
 
-	<MSEClass: #TWithQualifiedReference super: #Trait>
+	<FMClass: #TWithQualifiedReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -28,5 +28,4 @@ FmxSQLTWithQualifiedReference >> qualifiedReference: anObject [
 
 	<generated>
 	qualifiedReference := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st b/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
index 96aa79dd..8e2dcb94 100644
--- a/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
@@ -3,20 +3,20 @@ Trait {
 	#instVars : [
 		'#outgoingReferencesGroupReferences => FMMany type: #FmxSQLTReferencesGroupReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithReferencesGroupReference classSide >> annotation [
 
-	<MSEClass: #TWithReferencesGroupReference super: #Trait>
+	<FMClass: #TWithReferencesGroupReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLTWithReferencesGroupReference >> addOutgoingReferencesGroupReferences: anObject [
+FmxSQLTWithReferencesGroupReference >> addOutgoingReferencesGroupReference: anObject [
 	<generated>
 	^ self outgoingReferencesGroupReferences add: anObject
 ]
@@ -26,6 +26,7 @@ FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferences [
 	"Relation named: #outgoingReferencesGroupReferences type: #FmxSQLTReferencesGroupReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingReferencesGroupReferences
 ]
 
@@ -34,12 +35,11 @@ FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferences: anObje
 
 	<generated>
 	outgoingReferencesGroupReferences value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferencesGroup [
 	<generated>
 	<navigation: 'OutgoingReferencesGroupReferences'>
-	^ MooseGroup withAll: self outgoingReferencesGroupReferences asSet
+	^ MooseSpecializedGroup withAll: self outgoingReferencesGroupReferences asSet
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st b/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
index 5b07c186..adb78f45 100644
--- a/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#outgoingTableReferences => FMMany type: #FmxSQLTableReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithTableReference classSide >> annotation [
 
-	<MSEClass: #TWithTableReference super: #Trait>
+	<FMClass: #TWithTableReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithTableReference >> addOutgoingTableReference: anObject [
+	<generated>
+	^ self outgoingTableReferences add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithTableReference >> outgoingTableReferences [
 	"Relation named: #outgoingTableReferences type: #FmxSQLTableReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingTableReferences
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithTableReference >> outgoingTableReferences: anObject [
 
 	<generated>
 	outgoingTableReferences value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st b/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
index 3035847c..cd9341b2 100644
--- a/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
@@ -3,23 +3,30 @@ Trait {
 	#instVars : [
 		'#outgoingViewReferences => FMMany type: #FmxSQLViewReference opposite: #source'
 	],
-	#category : 'FamixNGSQL-Traits'
+	#category : #'FamixNGSQL-Traits'
 }
 
 { #category : #meta }
 FmxSQLTWithViewReference classSide >> annotation [
 
-	<MSEClass: #TWithViewReference super: #Trait>
+	<FMClass: #TWithViewReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLTWithViewReference >> addOutgoingViewReference: anObject [
+	<generated>
+	^ self outgoingViewReferences add: anObject
+]
+
 { #category : #accessing }
 FmxSQLTWithViewReference >> outgoingViewReferences [
 	"Relation named: #outgoingViewReferences type: #FmxSQLViewReference opposite: #source"
 
 	<generated>
+	<derived>
 	^ outgoingViewReferences
 ]
 
@@ -28,5 +35,4 @@ FmxSQLTWithViewReference >> outgoingViewReferences: anObject [
 
 	<generated>
 	outgoingViewReferences value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTable.class.st b/src/FamixNGSQL/FmxSQLTable.class.st
index 1b8a1bd2..362231af 100644
--- a/src/FamixNGSQL/FmxSQLTable.class.st
+++ b/src/FamixNGSQL/FmxSQLTable.class.st
@@ -20,43 +20,40 @@ Class {
 { #category : #meta }
 FmxSQLTable class >> annotation [
 
-	<MSEClass: #Table super: #FmxSQLStructuralEntity>
+	<FMClass: #Table super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
 { #category : #adding }
-FmxSQLTable >> addConstraints: anObject [
+FmxSQLTable >> addConstraint: anObject [
 	<generated>
 	^ self constraints add: anObject
 ]
 
 { #category : #adding }
-FmxSQLTable >> addTriggers: anObject [
+FmxSQLTable >> addReference: anObject [
 	<generated>
-	^ self triggers add: anObject
-]
-
-{ #category : #accessing }
-FmxSQLTable >> checkConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLCheckConstraint ]
+	^ self references add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLTable >> columnsWithUniqueConstraint [
-	^ ((self constraintsSatisfying: [ :c | c isUniqueConstraint ])
-			flatCollect: [ :c | (c queryOutgoing: FmxSQLColumnReference) collect: #column ]) asSet asArray
+{ #category : #adding }
+FmxSQLTable >> addSubTable: anObject [
+	<generated>
+	^ self subTables add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLTable >> conceptId [
-	^ self conceptIdIfAbsent: [ self error: 'Table has no concept.' ]
+{ #category : #adding }
+FmxSQLTable >> addTrigger: anObject [
+	<generated>
+	^ self triggers add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLTable >> conceptIdIfAbsent: aBlock [
-	^ self privateState attributeAt: #concept ifAbsent: aBlock
+{ #category : #adding }
+FmxSQLTable >> addUpdateQuery: anObject [
+	<generated>
+	^ self updateQueries add: anObject
 ]
 
 { #category : #accessing }
@@ -64,6 +61,7 @@ FmxSQLTable >> constraints [
 	"Relation named: #constraints type: #FmxSQLConstraint opposite: #table"
 
 	<generated>
+	<derived>
 	^ constraints
 ]
 
@@ -72,51 +70,13 @@ FmxSQLTable >> constraints: anObject [
 
 	<generated>
 	constraints value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTable >> constraintsGroup [
 	<generated>
 	<navigation: 'Constraints'>
-	^ MooseGroup withAll: self constraints asSet
-]
-
-{ #category : #accessing }
-FmxSQLTable >> constraintsSatisfying: aBlock [
-	^ self constraints select: aBlock
-]
-
-{ #category : #accessing }
-FmxSQLTable >> exclusionConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLExclusionConstraint ]
-]
-
-{ #category : #accessing }
-FmxSQLTable >> foreignKeyConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLForeignKeyConstraint ]
-]
-
-{ #category : #testing }
-FmxSQLTable >> hasSuperTable [
-	^ self superTable isNotNil
-]
-
-{ #category : #accessing }
-FmxSQLTable >> incomingForeignKeyConstraints [
-	^ ((self columns
-		select: [ :c | c hasUniqueConstraint or: [ c hasPrimaryKey ] ])
-		flatCollect: [ :c | c foreignKeyConstraintsReferencing collect: #from ]) asSet asArray
-]
-
-{ #category : #accessing }
-FmxSQLTable >> notNullConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLNotNullConstraint ]
-]
-
-{ #category : #accessing }
-FmxSQLTable >> primaryKeyConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLPrimaryKeyConstraint ]
+	^ MooseSpecializedGroup withAll: self constraints asSet
 ]
 
 { #category : #accessing }
@@ -124,6 +84,7 @@ FmxSQLTable >> references [
 	"Relation named: #references type: #FmxSQLTableReference opposite: #table"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -132,7 +93,6 @@ FmxSQLTable >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
 
 { #category : #accessing }
@@ -140,6 +100,7 @@ FmxSQLTable >> subTables [
 	"Relation named: #subTables type: #FmxSQLTable opposite: #superTable"
 
 	<generated>
+	<derived>
 	^ subTables
 ]
 
@@ -148,7 +109,6 @@ FmxSQLTable >> subTables: anObject [
 
 	<generated>
 	subTables value: anObject
-
 ]
 
 { #category : #accessing }
@@ -164,7 +124,6 @@ FmxSQLTable >> superTable: anObject [
 
 	<generated>
 	superTable := anObject
-
 ]
 
 { #category : #accessing }
@@ -172,6 +131,7 @@ FmxSQLTable >> triggers [
 	"Relation named: #triggers type: #FmxSQLTrigger opposite: #table"
 
 	<generated>
+	<derived>
 	^ triggers
 ]
 
@@ -180,19 +140,13 @@ FmxSQLTable >> triggers: anObject [
 
 	<generated>
 	triggers value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTable >> triggersGroup [
 	<generated>
 	<navigation: 'Triggers'>
-	^ MooseGroup withAll: self triggers asSet
-]
-
-{ #category : #accessing }
-FmxSQLTable >> uniqueConstraints [
-	^ self constraintsSatisfying: [ :c | c class = FmxSQLUniqueConstraint ]
+	^ MooseSpecializedGroup withAll: self triggers asSet
 ]
 
 { #category : #accessing }
@@ -200,6 +154,7 @@ FmxSQLTable >> updateQueries [
 	"Relation named: #updateQueries type: #FmxSQLUpdateQuery opposite: #table"
 
 	<generated>
+	<derived>
 	^ updateQueries
 ]
 
@@ -208,5 +163,4 @@ FmxSQLTable >> updateQueries: anObject [
 
 	<generated>
 	updateQueries value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTableReference.class.st b/src/FamixNGSQL/FmxSQLTableReference.class.st
index ad5e1ad5..defd9c7a 100644
--- a/src/FamixNGSQL/FmxSQLTableReference.class.st
+++ b/src/FamixNGSQL/FmxSQLTableReference.class.st
@@ -16,7 +16,7 @@ Class {
 { #category : #meta }
 FmxSQLTableReference class >> annotation [
 
-	<MSEClass: #TableReference super: #FmxSQLReference>
+	<FMClass: #TableReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -36,7 +36,6 @@ FmxSQLTableReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
 
 { #category : #accessing }
@@ -53,5 +52,4 @@ FmxSQLTableReference >> table: anObject [
 
 	<generated>
 	table := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTrigger.class.st b/src/FamixNGSQL/FmxSQLTrigger.class.st
index 4be74326..1465dda2 100644
--- a/src/FamixNGSQL/FmxSQLTrigger.class.st
+++ b/src/FamixNGSQL/FmxSQLTrigger.class.st
@@ -4,8 +4,8 @@ I am a trigger. A trigger allows to define actions to performs when a specific e
 Class {
 	#name : #FmxSQLTrigger,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamedEntity + FmxSQLBehaviouralEntity',
-	#classTraits : 'FamixTNamedEntity classTrait + FmxSQLBehaviouralEntity classTrait',
+	#traits : 'FmxSQLBehaviouralEntity + FmxSQLTNamedEntity',
+	#classTraits : 'FmxSQLBehaviouralEntity classTrait + FmxSQLTNamedEntity classTrait',
 	#instVars : [
 		'#firingAction => FMProperty',
 		'#when => FMProperty',
@@ -18,59 +18,24 @@ Class {
 { #category : #meta }
 FmxSQLTrigger class >> annotation [
 
-	<MSEClass: #Trigger super: #FmxSQLNamedEntity>
+	<FMClass: #Trigger super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #meta }
-FmxSQLTrigger class >> requirements [
-
-	<generated>
-	^ { FmxSQLTable }
-]
-
-{ #category : #accessing }
-FmxSQLTrigger >> allDependencies [
-	^ { self storedProcedure }
-]
-
-{ #category : #accessing }
-FmxSQLTrigger >> allDepending [
-	^ { }
-]
-
-{ #category : #accessing }
-FmxSQLTrigger >> belongsTo [
-
-	<generated>
-	^ self table
-
-]
-
-{ #category : #accessing }
-FmxSQLTrigger >> belongsTo: anObject [
-
-	<generated>
-	self table: anObject
-
-]
-
 { #category : #accessing }
 FmxSQLTrigger >> firingAction [
 
-	<MSEProperty: #firingAction type: #String>
+	<FMProperty: #firingAction type: #String>
 	<generated>
 	^ firingAction
 ]
 
 { #category : #accessing }
 FmxSQLTrigger >> firingAction: anObject [
-
 	<generated>
 	firingAction := anObject
-
 ]
 
 { #category : #accessing }
@@ -86,7 +51,6 @@ FmxSQLTrigger >> storedProcedure: anObject [
 
 	<generated>
 	storedProcedure := anObject
-
 ]
 
 { #category : #accessing }
@@ -103,28 +67,25 @@ FmxSQLTrigger >> table: anObject [
 
 	<generated>
 	table := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTrigger >> tableGroup [
 	<generated>
 	<navigation: 'Table'>
-	^ MooseGroup with: self table
+	^ MooseSpecializedGroup with: self table
 ]
 
 { #category : #accessing }
 FmxSQLTrigger >> when [
 
-	<MSEProperty: #when type: #String>
+	<FMProperty: #when type: #String>
 	<generated>
 	^ when
 ]
 
 { #category : #accessing }
 FmxSQLTrigger >> when: anObject [
-
 	<generated>
 	when := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st b/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
index e847ff0c..219be8dd 100644
--- a/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
+++ b/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
@@ -16,7 +16,7 @@ Class {
 { #category : #meta }
 FmxSQLTriggerStoredProcedure class >> annotation [
 
-	<MSEClass: #TriggerStoredProcedure super: #FmxSQLStoredProcedure>
+	<FMClass: #TriggerStoredProcedure super: #FmxSQLStoredProcedure>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -28,9 +28,10 @@ FmxSQLTriggerStoredProcedure >> addColumnsReferenced: anObject [
 	^ self columnsReferenced add: anObject
 ]
 
-{ #category : #accessing }
-FmxSQLTriggerStoredProcedure >> allDepending [
-	^ super allDepending , self triggersDepending
+{ #category : #adding }
+FmxSQLTriggerStoredProcedure >> addTrigger: anObject [
+	<generated>
+	^ self triggers add: anObject
 ]
 
 { #category : #accessing }
@@ -38,6 +39,7 @@ FmxSQLTriggerStoredProcedure >> columnsReferenced [
 	"Relation named: #columnsReferenced type: #FmxSQLColumnReference opposite: #triggerStoredProceduresReferencing"
 
 	<generated>
+	<derived>
 	^ columnsReferenced
 ]
 
@@ -46,14 +48,13 @@ FmxSQLTriggerStoredProcedure >> columnsReferenced: anObject [
 
 	<generated>
 	columnsReferenced value: anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLTriggerStoredProcedure >> columnsReferencedGroup [
 	<generated>
 	<navigation: 'ColumnsReferenced'>
-	^ MooseGroup withAll: self columnsReferenced asSet
+	^ MooseSpecializedGroup withAll: self columnsReferenced asSet
 ]
 
 { #category : #testing }
@@ -68,6 +69,7 @@ FmxSQLTriggerStoredProcedure >> triggers [
 	"Relation named: #triggers type: #FmxSQLTrigger opposite: #storedProcedure"
 
 	<generated>
+	<derived>
 	^ triggers
 ]
 
@@ -76,11 +78,4 @@ FmxSQLTriggerStoredProcedure >> triggers: anObject [
 
 	<generated>
 	triggers value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLTriggerStoredProcedure >> triggersDepending [
-	"Returns the triggers that depends on myself directly (they call me directly)."
-	^ self triggers
 ]
diff --git a/src/FamixNGSQL/FmxSQLType.class.st b/src/FamixNGSQL/FmxSQLType.class.st
index 0c7e598a..f38521be 100644
--- a/src/FamixNGSQL/FmxSQLType.class.st
+++ b/src/FamixNGSQL/FmxSQLType.class.st
@@ -10,23 +10,36 @@ Class {
 		'#columns => FMMany type: #FmxSQLColumn opposite: #type',
 		'#references => FMMany type: #FmxSQLTypeReference opposite: #type'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLType class >> annotation [
 
-	<MSEClass: #Type super: #FmxSQLStructuralEntity>
+	<FMClass: #Type super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
+{ #category : #adding }
+FmxSQLType >> addColumn: anObject [
+	<generated>
+	^ self columns add: anObject
+]
+
+{ #category : #adding }
+FmxSQLType >> addReference: anObject [
+	<generated>
+	^ self references add: anObject
+]
+
 { #category : #accessing }
 FmxSQLType >> columns [
 	"Relation named: #columns type: #FmxSQLColumn opposite: #type"
 
 	<generated>
+	<derived>
 	^ columns
 ]
 
@@ -35,7 +48,6 @@ FmxSQLType >> columns: anObject [
 
 	<generated>
 	columns value: anObject
-
 ]
 
 { #category : #accessing }
@@ -43,6 +55,7 @@ FmxSQLType >> references [
 	"Relation named: #references type: #FmxSQLTypeReference opposite: #type"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -51,5 +64,4 @@ FmxSQLType >> references: anObject [
 
 	<generated>
 	references value: anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLTypeReference.class.st b/src/FamixNGSQL/FmxSQLTypeReference.class.st
index e75e35c0..c4d20216 100644
--- a/src/FamixNGSQL/FmxSQLTypeReference.class.st
+++ b/src/FamixNGSQL/FmxSQLTypeReference.class.st
@@ -7,13 +7,13 @@ Class {
 	#instVars : [
 		'#type => FMOne type: #FmxSQLType opposite: #references'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLTypeReference class >> annotation [
 
-	<MSEClass: #TypeReference super: #FmxSQLReference>
+	<FMClass: #TypeReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -33,5 +33,4 @@ FmxSQLTypeReference >> type: anObject [
 
 	<generated>
 	type := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLUnionClause.class.st b/src/FamixNGSQL/FmxSQLUnionClause.class.st
index 3648c402..363d77c6 100644
--- a/src/FamixNGSQL/FmxSQLUnionClause.class.st
+++ b/src/FamixNGSQL/FmxSQLUnionClause.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLUnionClause class >> annotation [
 
-	<MSEClass: #UnionClause super: #FmxSQLClause>
+	<FMClass: #UnionClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st b/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
index 753bc940..fcb2afb6 100644
--- a/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
@@ -4,13 +4,13 @@ I represent a UNIQUE constraint as defined in SQL standard.
 Class {
 	#name : #FmxSQLUniqueConstraint,
 	#superclass : #FmxSQLConstraint,
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLUniqueConstraint class >> annotation [
 
-	<MSEClass: #UniqueConstraint super: #FmxSQLConstraint>
+	<FMClass: #UniqueConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -22,15 +22,3 @@ FmxSQLUniqueConstraint >> isUniqueConstraint [
 	<generated>
 	^ true
 ]
-
-{ #category : #printing }
-FmxSQLUniqueConstraint >> mooseNameOn: aStream [
-	aStream << $".
-	super mooseNameOn: aStream.
-	aStream << '" UNIQUE ('.
-	(self outgoingColumnReferences collect: #column) do: [ :c |
-		aStream << c name ] separatedBy: [ aStream << ', ' ].
-	aStream
-		<< ') #';
-		<< self mooseID.
-]
diff --git a/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st b/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st
index f7168056..3c8fe1d3 100644
--- a/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st
+++ b/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st
@@ -1,15 +1,15 @@
 Class {
 	#name : #FmxSQLUnknownSourceLanguage,
 	#superclass : #FmxSQLSourceLanguage,
-	#traits : 'FamixTSourceLanguage',
-	#classTraits : 'FamixTSourceLanguage classTrait',
+	#traits : 'FamixTUnknownSourceLanguage',
+	#classTraits : 'FamixTUnknownSourceLanguage classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLUnknownSourceLanguage class >> annotation [
 
-	<MSEClass: #UnknownSourceLanguage super: #FmxSQLSourceLanguage>
+	<FMClass: #UnknownSourceLanguage super: #FmxSQLSourceLanguage>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLUpdateQuery.class.st b/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
index b1b18bb8..66478349 100644
--- a/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
@@ -9,13 +9,13 @@ Class {
 	#instVars : [
 		'#table => FMOne type: #FmxSQLTable opposite: #updateQueries'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLUpdateQuery class >> annotation [
 
-	<MSEClass: #UpdateQuery super: #FmxSQLCRUDQuery>
+	<FMClass: #UpdateQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -34,5 +34,4 @@ FmxSQLUpdateQuery >> table: anObject [
 
 	<generated>
 	table := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLUsingClause.class.st b/src/FamixNGSQL/FmxSQLUsingClause.class.st
index 7c085fe8..545d5f14 100644
--- a/src/FamixNGSQL/FmxSQLUsingClause.class.st
+++ b/src/FamixNGSQL/FmxSQLUsingClause.class.st
@@ -12,7 +12,7 @@ Class {
 { #category : #meta }
 FmxSQLUsingClause class >> annotation [
 
-	<MSEClass: #UsingClause super: #FmxSQLClause>
+	<FMClass: #UsingClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLValuesClause.class.st b/src/FamixNGSQL/FmxSQLValuesClause.class.st
index 00739512..369bea60 100644
--- a/src/FamixNGSQL/FmxSQLValuesClause.class.st
+++ b/src/FamixNGSQL/FmxSQLValuesClause.class.st
@@ -4,15 +4,15 @@ I am a Values clause
 Class {
 	#name : #FmxSQLValuesClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
-	#category : 'FamixNGSQL-Entities'
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLValuesClause class >> annotation [
 
-	<MSEClass: #ValuesClause super: #FmxSQLClause>
+	<FMClass: #ValuesClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLValuesQuery.class.st b/src/FamixNGSQL/FmxSQLValuesQuery.class.st
index 4255f5d9..24d23e8d 100644
--- a/src/FamixNGSQL/FmxSQLValuesQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLValuesQuery.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLValuesQuery class >> annotation [
 
-	<MSEClass: #ValuesQuery super: #FmxSQLCRUDQuery>
+	<FMClass: #ValuesQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
diff --git a/src/FamixNGSQL/FmxSQLView.class.st b/src/FamixNGSQL/FmxSQLView.class.st
index 2e8a717a..5ec3ccd7 100644
--- a/src/FamixNGSQL/FmxSQLView.class.st
+++ b/src/FamixNGSQL/FmxSQLView.class.st
@@ -4,96 +4,28 @@ I am a view. I can be used transparently as a table but I do not hold data. My d
 Class {
 	#name : #FmxSQLView,
 	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTNamedEntity + FamixTWithImmediateSource + FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTQueryContainer',
-	#classTraits : 'FamixTNamedEntity classTrait + FamixTWithImmediateSource classTrait + FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTQueryContainer classTrait',
+	#traits : 'FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithImmediateSource',
+	#classTraits : 'FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithImmediateSource classTrait',
 	#instVars : [
 		'#query => FMOne type: #FmxSQLSelectQuery opposite: #viewDefining',
 		'#references => FMMany type: #FmxSQLViewReference opposite: #view'
 	],
-	#category : 'FamixNGSQL-Entities'
+	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLView class >> annotation [
 
-	<MSEClass: #View super: #FmxSQLNamedEntity>
+	<FMClass: #View super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #accessing }
-FmxSQLView >> allDependencies [
-	^ self viewsDependencies , self storedProceduresDependencies
-]
-
-{ #category : #accessing }
-FmxSQLView >> allDepending [
-	^ self viewsDepending , self storedProceduresDepending
-]
-
-{ #category : #accessing }
-FmxSQLView >> allStoredProceduresDependencies [
-	"Returns the stored procedures that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #storedProceduresDependencies) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLView >> allStoredProceduresDepending [
-	"Returns the stored procedures that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #storedProceduresDepending) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLView >> allViewsDependencies [
-	"Returns the views that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #viewsDependencies) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLView >> allViewsDepending [
-	"Returns the views that I depend on directly and indirectly."
-	^ (self anyTreeIterator: #viewsDepending) allButFirst
-]
-
-{ #category : #accessing }
-FmxSQLView >> columnsToColumnReferences [
-	| mapping |
-	mapping := Dictionary new.
-	(self query selectClause outgoingColumnReferences groupedBy: [ :ref | ref belongsToGroup ifNil: [ ref ] ]) keys do: [ :outgoingRef |
-		mapping
-			at: (self query selectClause aliases
-					detect: [ :alias | (outgoingRef isColumnReference and: [ alias outgoingColumnReferences anySatisfy: [ :ref | (ref sourceAnchor interval includesAll: outgoingRef sourceAnchor interval) or: [ outgoingRef sourceAnchor interval includesAll: ref sourceAnchor interval ] ] ]) or: [ alias outgoingReferencesGroupReferences includes: outgoingRef ] ]
-					ifFound: [ :alias | self columnNamed: alias name ]
-					ifNone: [ 
-						outgoingRef class = FmxSQLReferencesGroup
-							ifTrue: [ self columnNamed: outgoingRef incomingReferencesGroupReference first source name ]
-							ifFalse: [ self columnNamed: outgoingRef column name ] ])
-			ifPresent: [ self halt ]
-			ifAbsentPut: outgoingRef ].
-	^ mapping
-]
-
-{ #category : #testing }
-FmxSQLView >> dependsDirectlyOn: aFmxSQLView [
-	^ aFmxSQLView viewsDepending includes: self
-]
-
-{ #category : #testing }
-FmxSQLView >> dependsOn: aFmxSQLView [
-	^ TreeQuery breadthFirst matchAnywhere
-		predicate: self asTQPredicate;
-		runOn: aFmxSQLView childrenBlock: #viewsDepending
-]
-
-{ #category : #testing }
-FmxSQLView >> doesNameOfColumnComesFromAlias: aFmxSQLColumn [
-	| referenceOrReferenceGroup |
-	referenceOrReferenceGroup := (self columnsToColumnReferences at: aFmxSQLColumn).
-	referenceOrReferenceGroup class = FmxSQLReferencesGroup
-		ifTrue: [ ^ true ].
-	
-	^ referenceOrReferenceGroup column name ~= aFmxSQLColumn name
+{ #category : #adding }
+FmxSQLView >> addReference: anObject [
+	<generated>
+	^ self references add: anObject
 ]
 
 { #category : #testing }
@@ -116,14 +48,13 @@ FmxSQLView >> query: anObject [
 
 	<generated>
 	query := anObject
-
 ]
 
 { #category : #navigation }
 FmxSQLView >> queryGroup [
 	<generated>
 	<navigation: 'Query'>
-	^ MooseGroup with: self query
+	^ MooseSpecializedGroup with: self query
 ]
 
 { #category : #accessing }
@@ -131,6 +62,7 @@ FmxSQLView >> references [
 	"Relation named: #references type: #FmxSQLViewReference opposite: #view"
 
 	<generated>
+	<derived>
 	^ references
 ]
 
@@ -139,46 +71,4 @@ FmxSQLView >> references: anObject [
 
 	<generated>
 	references value: anObject
-
-]
-
-{ #category : #accessing }
-FmxSQLView >> sourceCodeAsText [
-	^ PostgreSQLHighlighter highlightSelectQuery: self source
-]
-
-{ #category : #accessing }
-FmxSQLView >> storedProceduresDependencies [
-	"Returns the stored procedures that I depend on directly (I call them directly)."
-	^ ((self queryOutgoing: FmxSQLStoredProcedureCall) collect: [ :ref | ref to ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLView >> storedProceduresDepending [
-	"Returns the views that depends on myself directly (reference myself directly)."
-	^ ((self queryLocalIncoming: FmxSQLViewReference) collect: [ :ref | ref from sourcedBelonger ] thenSelect: [ :sourcedBelonger | sourcedBelonger isNotNil and: [ sourcedBelonger isStoredProcedure ] ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLView >> tablesReferenced [
-	^ (self queryOutgoing: FmxSQLTableReference)
-			collect: #table
-]
-
-{ #category : #accessing }
-FmxSQLView >> viewsDependencies [
-	"Returns the views that I depend on directly (I reference them directly)."
-	^ ((self queryOutgoing: FmxSQLViewReference) collect: [ :ref | ref to ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLView >> viewsDepending [
-	"Returns the views that depends on myself directly (reference myself directly)."
-	^ ((self queryLocalIncoming: FmxSQLViewReference) collect: [ :ref | ref source sourcedBelonger ] thenSelect: [ :sourcedBelonger | sourcedBelonger isNotNil and: [ sourcedBelonger isView ] ]) asSet
-]
-
-{ #category : #accessing }
-FmxSQLView >> viewsReferenced [
-	^ (self queryOutgoing: FmxSQLViewReference)
-			collect: #view
 ]
diff --git a/src/FamixNGSQL/FmxSQLViewReference.class.st b/src/FamixNGSQL/FmxSQLViewReference.class.st
index 41ff8026..4f63d53c 100644
--- a/src/FamixNGSQL/FmxSQLViewReference.class.st
+++ b/src/FamixNGSQL/FmxSQLViewReference.class.st
@@ -16,7 +16,7 @@ Class {
 { #category : #meta }
 FmxSQLViewReference class >> annotation [
 
-	<MSEClass: #ViewReference super: #FmxSQLReference>
+	<FMClass: #ViewReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
@@ -36,7 +36,6 @@ FmxSQLViewReference >> source: anObject [
 
 	<generated>
 	source := anObject
-
 ]
 
 { #category : #accessing }
@@ -53,5 +52,4 @@ FmxSQLViewReference >> view: anObject [
 
 	<generated>
 	view := anObject
-
 ]
diff --git a/src/FamixNGSQL/FmxSQLWhereClause.class.st b/src/FamixNGSQL/FmxSQLWhereClause.class.st
index c2174f03..df93bc15 100644
--- a/src/FamixNGSQL/FmxSQLWhereClause.class.st
+++ b/src/FamixNGSQL/FmxSQLWhereClause.class.st
@@ -4,25 +4,20 @@ I am a where clause
 Class {
 	#name : #FmxSQLWhereClause,
 	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#category : #'FamixNGSQL-Entities'
 }
 
 { #category : #meta }
 FmxSQLWhereClause class >> annotation [
 
-	<MSEClass: #WhereClause super: #FmxSQLClause>
+	<FMClass: #WhereClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self
 ]
 
-{ #category : #testing }
-FmxSQLWhereClause >> isClauseAbleToReferenceColumn [
-	^ true
-]
-
 { #category : #testing }
 FmxSQLWhereClause >> isWhereClause [
 
diff --git a/src/FamixNGSQL/FmxSQLWithClause.class.st b/src/FamixNGSQL/FmxSQLWithClause.class.st
index 747f3743..24e61ad2 100644
--- a/src/FamixNGSQL/FmxSQLWithClause.class.st
+++ b/src/FamixNGSQL/FmxSQLWithClause.class.st
@@ -10,7 +10,7 @@ Class {
 { #category : #meta }
 FmxSQLWithClause class >> annotation [
 
-	<MSEClass: #WithClause super: #FmxSQLClause>
+	<FMClass: #WithClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
 	^self

From 93e93e342c90dad32f773a8d4e24e72f7ed89f10 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 21:42:41 +0300
Subject: [PATCH 08/22] Restore SQL metamodel relations on Moose 13 and report
 source analysis coverage

---
 .gitignore                                    |   1 +
 README.md                                     |  86 +-
 docs/pharo13-migration-audit.md               |  99 ++
 .../BaselineOfFAMIXNGSQL.class.st             |  22 +-
 .../FmxSQLMetamodelGenerator.class.st         |  47 +-
 ...mxSQLStructuralMetamodelGenerator.class.st |   6 +
 .../FmxSQLAnalysisReportingTest.class.st      |  53 ++
 .../FmxSQLDatabaseImportTest.class.st         |  46 +
 ...FmxSQLSymbolResolutionVisitorTest.class.st |  22 +-
 src/FamixNGSQL-Importer-Tests/package.st      |   1 +
 .../FmxEntityParsingError.class.st            |   5 +
 .../FmxSQLColumnsContainer.extension.st       |   5 +
 .../FmxSQLEntitySourceAnchor.extension.st     |  16 +
 .../FmxSQLModel.extension.st                  |  64 ++
 .../FmxSQLModelBuilder.class.st               | 150 ++-
 .../FmxSQLMooseModel.extension.st             |  30 -
 .../FmxSQLParameter.extension.st              |   5 +
 .../FmxSQLReference.extension.st              |  10 +
 .../FmxSQLStoredProcedure.extension.st        |   6 +
 .../FmxSQLSymbolResolutionVisitor.class.st    |  51 +-
 .../SqlCheckConstraint.extension.st           |   2 +-
 .../SqlExclusionConstraint.extension.st       |  22 +
 .../SqlFunction.extension.st                  |  10 +
 .../SqlTriggerConstraint.extension.st         |   2 +-
 src/FamixNGSQL/FmxSQLAbstractType.trait.st    |  69 +-
 src/FamixNGSQL/FmxSQLAlias.class.st           |  49 +-
 src/FamixNGSQL/FmxSQLAliasAccess.class.st     |  45 +-
 src/FamixNGSQL/FmxSQLAssociation.class.st     |  28 +-
 .../FmxSQLBehaviouralEntity.trait.st          |  22 +-
 src/FamixNGSQL/FmxSQLCRUDQuery.class.st       |  92 +-
 src/FamixNGSQL/FmxSQLCheckConstraint.class.st |  47 +-
 src/FamixNGSQL/FmxSQLClause.class.st          |  50 +-
 src/FamixNGSQL/FmxSQLColumn.class.st          |  56 +-
 src/FamixNGSQL/FmxSQLColumnAlias.class.st     |  45 +-
 .../FmxSQLColumnAliasAccess.class.st          |  43 +-
 src/FamixNGSQL/FmxSQLColumnReference.class.st |  98 +-
 .../FmxSQLColumnsContainer.trait.st           |  38 +-
 .../FmxSQLColumnsContainerAlias.class.st      |  41 +-
 ...FmxSQLColumnsContainerAliasAccess.class.st |  43 +-
 src/FamixNGSQL/FmxSQLComment.class.st         |  29 +-
 src/FamixNGSQL/FmxSQLConstraint.class.st      |  44 +-
 src/FamixNGSQL/FmxSQLCursor.class.st          |  65 +-
 src/FamixNGSQL/FmxSQLCursorParameter.class.st |  52 +-
 .../FmxSQLCursorParameterAccess.class.st      |  42 +-
 src/FamixNGSQL/FmxSQLCursorReference.class.st |  49 +-
 src/FamixNGSQL/FmxSQLDeleteQuery.class.st     |  23 +-
 src/FamixNGSQL/FmxSQLDerivedTable.class.st    |  78 +-
 .../FmxSQLDerivedTableReference.class.st      |  44 +-
 src/FamixNGSQL/FmxSQLEntity.class.st          | 198 +++-
 .../FmxSQLEntitySourceAnchor.class.st         |  56 +-
 src/FamixNGSQL/FmxSQLExceptClause.class.st    |  33 +-
 .../FmxSQLExclusionConstraint.class.st        |  64 +-
 .../FmxSQLForeignKeyConstraint.class.st       |  36 +-
 src/FamixNGSQL/FmxSQLForeignTable.class.st    |  14 +-
 src/FamixNGSQL/FmxSQLFromClause.class.st      |  46 +-
 src/FamixNGSQL/FmxSQLGroupByClause.class.st   |  45 +-
 src/FamixNGSQL/FmxSQLHavingClause.class.st    |  45 +-
 src/FamixNGSQL/FmxSQLInsertQuery.class.st     |  23 +-
 src/FamixNGSQL/FmxSQLIntersectClause.class.st |  33 +-
 src/FamixNGSQL/FmxSQLIntoClause.class.st      |  29 +-
 src/FamixNGSQL/FmxSQLJoinClause.class.st      |  17 +-
 src/FamixNGSQL/FmxSQLLimitClause.class.st     |  17 +-
 src/FamixNGSQL/FmxSQLLocalVariable.class.st   |  67 +-
 .../FmxSQLLocalVariableAccess.class.st        |  52 +-
 src/FamixNGSQL/FmxSQLModel.class.st           |  20 +-
 src/FamixNGSQL/FmxSQLNamedEntity.class.st     |  52 +-
 src/FamixNGSQL/FmxSQLNamespace.class.st       |  77 +-
 .../FmxSQLNamespaceReference.class.st         |  45 +-
 .../FmxSQLNewLocalVariable.class.st           |  23 +-
 .../FmxSQLNotNullConstraint.class.st          |  17 +-
 .../FmxSQLOldLocalVariable.class.st           |  23 +-
 .../FmxSQLOnConflictClause.class.st           |  17 +-
 src/FamixNGSQL/FmxSQLOrderByClause.class.st   |  45 +-
 src/FamixNGSQL/FmxSQLParameter.class.st       |  88 +-
 src/FamixNGSQL/FmxSQLParameterAccess.class.st |  44 +-
 .../FmxSQLPrimaryKeyConstraint.class.st       |  17 +-
 .../FmxSQLQualifiedReference.class.st         |  36 +-
 .../FmxSQLRecordLocalVariable.class.st        |  34 +-
 src/FamixNGSQL/FmxSQLReference.class.st       |  59 +-
 src/FamixNGSQL/FmxSQLReferencesGroup.class.st |  68 +-
 .../FmxSQLReferencesGroupReference.class.st   |  33 +-
 src/FamixNGSQL/FmxSQLReturningClause.class.st |  38 +-
 src/FamixNGSQL/FmxSQLSelectClause.class.st    |  40 +-
 src/FamixNGSQL/FmxSQLSelectQuery.class.st     |  60 +-
 src/FamixNGSQL/FmxSQLSetClause.class.st       |  33 +-
 src/FamixNGSQL/FmxSQLSourceAnchor.class.st    |  33 +-
 src/FamixNGSQL/FmxSQLSourceLanguage.class.st  |  24 +-
 .../FmxSQLSourceTextAnchor.class.st           |  30 +-
 src/FamixNGSQL/FmxSQLSourcedEntity.class.st   |  33 +-
 src/FamixNGSQL/FmxSQLStoredProcedure.class.st | 149 ++-
 .../FmxSQLStoredProcedureCall.class.st        |  68 +-
 .../FmxSQLStructuralEntity.class.st           |  23 +-
 src/FamixNGSQL/FmxSQLTArgument.trait.st       |  10 +-
 src/FamixNGSQL/FmxSQLTColumn.trait.st         |  35 +-
 .../FmxSQLTDefiningDerivedTables.trait.st     |  39 +-
 src/FamixNGSQL/FmxSQLTEntityCreator.trait.st  | 853 ++++++++++++++++++
 src/FamixNGSQL/FmxSQLTNamedEntity.trait.st    |  43 +-
 src/FamixNGSQL/FmxSQLTQueryContainer.trait.st |  41 +-
 .../FmxSQLTReferencesGroupReference.trait.st  |  57 +-
 src/FamixNGSQL/FmxSQLTWithAccesses.trait.st   |  13 -
 src/FamixNGSQL/FmxSQLTWithAlias.trait.st      |  41 +-
 .../FmxSQLTWithColumnReference.trait.st       |  32 +-
 src/FamixNGSQL/FmxSQLTWithCursor.trait.st     |  39 +-
 .../FmxSQLTWithCursorReference.trait.st       |  32 +-
 .../FmxSQLTWithDerivedTableReference.trait.st |  32 +-
 .../FmxSQLTWithEntitySourceAnchor.trait.st    |  32 +-
 .../FmxSQLTWithImmediateSource.trait.st       |  13 -
 .../FmxSQLTWithNamespaceReference.trait.st    |  32 +-
 .../FmxSQLTWithQualifiedReference.trait.st    |  28 +-
 ...xSQLTWithReferencesGroupReference.trait.st |  44 +-
 .../FmxSQLTWithTableReference.trait.st        |  32 +-
 src/FamixNGSQL/FmxSQLTWithTriggers.trait.st   |  56 ++
 .../FmxSQLTWithViewReference.trait.st         |  32 +-
 src/FamixNGSQL/FmxSQLTable.class.st           | 132 +--
 src/FamixNGSQL/FmxSQLTableReference.class.st  |  45 +-
 src/FamixNGSQL/FmxSQLTrigger.class.st         |  74 +-
 .../FmxSQLTriggerStoredProcedure.class.st     |  58 +-
 src/FamixNGSQL/FmxSQLType.class.st            |  52 +-
 src/FamixNGSQL/FmxSQLTypeReference.class.st   |  29 +-
 src/FamixNGSQL/FmxSQLUnionClause.class.st     |  33 +-
 .../FmxSQLUniqueConstraint.class.st           |  17 +-
 .../FmxSQLUnknownSourceLanguage.class.st      |  16 -
 src/FamixNGSQL/FmxSQLUpdateQuery.class.st     |  34 +-
 src/FamixNGSQL/FmxSQLUsingClause.class.st     |  32 +-
 src/FamixNGSQL/FmxSQLValuesClause.class.st    |  33 +-
 src/FamixNGSQL/FmxSQLValuesQuery.class.st     |  14 +-
 src/FamixNGSQL/FmxSQLView.class.st            | 100 +-
 src/FamixNGSQL/FmxSQLViewReference.class.st   |  45 +-
 src/FamixNGSQL/FmxSQLWhereClause.class.st     |  46 +-
 src/FamixNGSQL/FmxSQLWithClause.class.st      |  17 +-
 src/FamixNGSQL/package.st                     |   2 +-
 131 files changed, 5020 insertions(+), 1252 deletions(-)
 create mode 100644 docs/pharo13-migration-audit.md
 create mode 100644 src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
 create mode 100644 src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
 rename src/{FamixNGSQL-Importer => FamixNGSQL-Importer-Tests}/FmxSQLSymbolResolutionVisitorTest.class.st (96%)
 create mode 100644 src/FamixNGSQL-Importer-Tests/package.st
 create mode 100644 src/FamixNGSQL-Importer/FmxSQLEntitySourceAnchor.extension.st
 create mode 100644 src/FamixNGSQL-Importer/FmxSQLModel.extension.st
 delete mode 100644 src/FamixNGSQL-Importer/FmxSQLMooseModel.extension.st
 create mode 100644 src/FamixNGSQL-Importer/SqlExclusionConstraint.extension.st
 create mode 100644 src/FamixNGSQL-Importer/SqlFunction.extension.st
 create mode 100644 src/FamixNGSQL/FmxSQLTEntityCreator.trait.st
 delete mode 100644 src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
 delete mode 100644 src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st
 create mode 100644 src/FamixNGSQL/FmxSQLTWithTriggers.trait.st
 delete mode 100644 src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st

diff --git a/.gitignore b/.gitignore
index e43b0f98..61d9ba06 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 .DS_Store
+artifacts/
diff --git a/README.md b/README.md
index c1bbe125..b9e845e8 100644
--- a/README.md
+++ b/README.md
@@ -1,22 +1,78 @@
-# FAMIXNGSQL [![Build Status](https://travis-ci.org/juliendelplanque/FAMIXNGSQL.svg?branch=master)](https://travis-ci.org/juliendelplanque/FAMIXNGSQL)
-A meta-model for SQL databases using FAMIXNG with its generator.
+# FAMIXNGSQL
 
-## Install
-In a Pharo 7.0 image, open a playground and execute the following script:
+A FAMIX model of PostgreSQL databases, including schemas, tables, views,
+constraints, routines, triggers, and source-level references.
 
-```
+## Pharo 13 / Moose 13 integration
+
+The `pharo13-pgmetadata-integration` branch restores the original metamodel
+relationships on current Moose and integrates the updated PgMetadata and parser.
+See [the migration audit](docs/pharo13-migration-audit.md) for changes and limits.
+
+The current validation uses an existing Moose 13 image on Pharo 13 and
+PostgreSQL 15.14. A fresh-image Metacello installation has not yet been validated.
+The core avoids the old GT/Telescope UI dependencies; `LegacyUI` is optional
+and has not been ported or validated.
+
+```smalltalk
 Metacello new
-  repository: 'github://juliendelplanque/FAMIXNGSQL/src';
+  repository: 'github://deem0n/FAMIXNGSQL:pharo13-pgmetadata-integration/src';
   baseline: 'FAMIXNGSQL';
-  load
+  load: 'Core'.
+```
+
+## Build a model
+
+```smalltalk
+model := (FmxSQLModelBuilder new
+  databaseName: 'mi';
+  connection: (PgConnection hostname: 'localhost' port: 5435
+    database: 'mi' user: 'bi' password: nil);
+  analysisTimeout: 5 seconds;
+  yourself) buildModel.
+model inspect.
+model analysisReport inspect.
+```
+
+Metadata extraction reads all application schemas, excluding `pg_*` and
+`information_schema`. It uses a read-only repeatable-read transaction. Internal
+routine stubs remain available for reference resolution.
+
+SQL and PL/pgSQL source is parsed with the corresponding grammar. All routine
+source is retained, including unsupported languages. Analysis is bounded per
+entity and records `visited`, `partial`, `failed`, `timedOut`,
+`unsupportedLanguage`, or `catalogOnly`. **`visited` means the parser and visitor
+finished without a recorded issue, not proof that every SQL construct is modeled.**
+Dynamic SQL is reported as partial; its runtime targets are not inferred.
+Ambiguous routine overloads retain multiple invocation candidates. Unqualified
+names still need more accurate PostgreSQL `search_path` handling.
+
+Export both the model and its diagnostics (analysis caches are not serialized
+by MSE):
+
+```smalltalk
+'mi.mse' asFileReference writeStreamDo: [ :stream |
+  model exportToMSEStream: stream ].
+'mi-analysis.json' asFileReference writeStreamDo: [ :stream |
+  stream nextPutAll: (NeoJSONWriter toString: model analysisReport) ].
+```
+
+## Tests and regeneration
+
+Load the `Tests` group. Run database scenarios only against a disposable database:
+
+```smalltalk
+PgScenarioTest connectionParameters:
+  (PgConnection hostname: 'localhost' port: 5435
+    database: 'pgmetadata_validation_20260917' user: 'bi' password: nil).
 ```
 
-## Developing the meta-model generator
-This section presents some tips and tricks that help in the development of the
-meta-model.
+Load `Generator` to modify the metamodel. Release references to existing models
+before regenerating; live class migration of large models can take minutes.
+Use `FmxSQLMetamodelGenerator new generateWithCleaning`, then export the package
+to an empty directory and replace the old generated package. Overlaying files
+can leave obsolete classes behind, including `FmxSQLUnknownSourceLanguage`,
+whose old trait no longer exists in Moose 13.
 
-### Modifying the meta-model generator
-If you modified the generator and want to re-generate the meta-model, you have
-to:
-1. Ensure that no more instances of the meta-model exist in the system.
-2. Run `FmxSQLMetamodelGenerator generate.`
+The original Pharo 7 code is available from the upstream repository/history.
+Installing modern Genie in that old image is not required for this migration.
diff --git a/docs/pharo13-migration-audit.md b/docs/pharo13-migration-audit.md
new file mode 100644
index 00000000..d8051b5c
--- /dev/null
+++ b/docs/pharo13-migration-audit.md
@@ -0,0 +1,99 @@
+# Pharo 13 / Moose 13 migration audit
+
+## Reference sources
+
+- Original upstream cached revision: `d8c6427245ff8fbae6401e956db2b0759bb5a2d0`.
+- User fork before Moose migration: `7af7700305360d03f4af5292c3f73418979ec434`.
+- Existing incomplete Moose 10 migration: `83d53793d4509965f47d4c12def300a55fd26750`.
+- The requested exclusion-constraint/routine relation is an explicit requirement,
+  even though it is absent from these checked-in behavioural generator versions.
+
+## Invariants to preserve
+
+Namespaces own named SQL objects; tables/views own columns; routines own ordered
+parameters, local variables and queries; queries own clauses; references retain
+source ranges and source/target direction. Trigger entities retain their owning
+table or view and the invoked routine. CHECK and exclusion constraints retain
+called routines with inverse links from each routine. Unsupported code remains
+available as source and failures must be reported, never treated as successful
+analysis.
+
+## Compatibility changes reviewed
+
+- Regenerate the checked-in `FamixNGSQL` package on current Moose. Its old
+  `FmxSQLUnknownSourceLanguage` definition referenced the removed
+  `FamixTUnknownSourceLanguage` trait and caused a post-mortem load warning.
+  Current generation does not emit that class. Remove stale generated files
+  when exporting; exporting over an existing directory alone leaves them behind.
+- Empty `TNamedEntity`, `TWithImmediateSource`, and `TWithAccesses` placeholders
+  from the Moose 10 migration lost namespace, source and access behaviour.
+  Restore the namespace relation and use current source/access traits.
+- `TSourceAnchor` describes an anchor, not the query/clause holding an anchor.
+  Restore source-entity behaviour on queries, clauses and reference groups.
+- Restore association and entity dependency-query traits. Use `FmxSQLModel`
+  consistently so source/target metadata comes from the SQL metamodel.
+- Remove the duplicate CheckConstraint superclass declaration; it is already
+  defined by the structural generator.
+- Moose 13 no longer has `withoutPrimaryContainer`. Preserve both relation
+  endpoints and composition through the existing `<>-`/`<>-*` commands.
+  There is no replacement that disables the relation or drops its inverse.
+- Use a trigger-owner trait shared by tables and views, preserving the public
+  `table` / `triggers` relation names.
+- Keep the CHECK/routine relation and add the requested exclusion/routine
+  relation. Populate both from catalog dependencies, including exclusion index
+  expressions, with OID-based identity.
+- Preserve materialized views and source definitions, routine OIDs/languages,
+  unnamed parameters, argument order/modes, and SQL-standard routine bodies.
+- Dispatch SQL and PL/pgSQL bodies to their respective grammar entry points.
+  Parsing must preserve original source offsets, including semicolons in strings.
+
+## Validation scope
+
+Tests and live coverage results are recorded separately. Passing structural tests
+is not proof of complete parsing of real database source. A full-model build must
+report failed/partial analysis and retain the corresponding original source.
+
+## Measured validation (2026-09-17)
+
+Validated in the running Pharo 13 / Moose 13 image against PostgreSQL 15.14.
+P3 master was fast-forwarded to upstream `d45f0d358f41ff809fd85f26046a63630a3a7bef`
+and pushed; its 95 tests passed against a disposable database. PgMetadata's 24
+tests passed, including constraint/routine links and the read-only extraction
+transaction. PostgreSQLParser passed 133 grammar tests, 103 AST-builder tests,
+7 facade tests, and 3 AST tests. The importer has 38 passing tests (including a
+real PostgreSQL integration scenario and MSE source-anchor export).
+
+The regenerated metamodel was exported to an empty directory and reloaded
+successfully. No generated definition refers to `FamixTUnknownSourceLanguage`.
+The production importer and its tests now have separate packages.
+
+The full local database build produced 81,488 model entities. Application catalog
+counts were independently checked with SQL: 47 schemas, 359 tables, 5 foreign
+tables, 85 ordinary/materialized views, 2,461 routines, and 569 triggers.
+Generated system stubs are additional model entities.
+
+Routine statuses: 938 visited, 286 partial, 717 failed, 7 timed out, 511 in
+unsupported languages, and 2 aggregate catalog objects. View statuses: 42
+visited, 12 partial, 31 failed. Syntax failures across routines/views fell from
+799 to 520 after the schema-qualified call, declaration, and EXECUTE repairs.
+The larger model exposes more unresolved references; there are 1,833 recorded
+errors and 346 warnings overall. These counts are observations, not a claim of
+complete PostgreSQL semantics or dependency coverage.
+
+The MSE artifact retains source and structural/reference relations. A separate
+JSON report records per-entity status and diagnostics. Local database artifacts
+are ignored by Git. No fresh-image Metacello install or legacy UI validation has
+been performed.
+
+## Remaining work
+
+- CTEs, recursive queries, set-returning functions, and other modern PostgreSQL
+  syntax still exceed the old grammar/visitor in many cases.
+- Resolve unqualified object names with the actual PostgreSQL search_path and
+  overload rules. Calls currently retain all matching overload candidates.
+- Model composite/record type fields and more PL/pgSQL statement semantics.
+- Analyse constant dynamic SQL where possible; runtime-dependent SQL is reported
+  explicitly and its targets are not guessed.
+- Remove remaining visitor Halts with supported semantics and regression tests;
+  the importer currently records them as failures and continues.
+- Pin/validate the complete dependency stack in a fresh image before a release.
diff --git a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
index f0ca8911..d80b7c63 100644
--- a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
+++ b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
@@ -14,7 +14,9 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 					with: [ spec requires: #('Famix') ];
 				package: #'FamixNGSQL-Importer'
 					with: [ spec
-						requires: #('PostgreSQLParser' 'PgMetadata' 'SymbolResolver' 'PetitParser') ];
+						requires: #('FamixNGSQL' 'PostgreSQLParser' 'PgMetadata' 'SymbolResolver' 'PetitParser') ];
+				package: #'FamixNGSQL-Importer-Tests'
+					with: [ spec requires: #('FamixNGSQL-Importer' 'PgMetadata-Tests') ];
 				package: #'FamixNGSQL-GTInspectorExtension'
 					with: [ spec requires: #('FamixNGSQL-Importer') ];
 				package: #FAMIXNGSQLAnalysis
@@ -33,8 +35,8 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 			spec
 				baseline: 'PostgreSQLParser'
 				with: [ spec
-						repository: 'github://juliendelplanque/PostgreSQLParser/src';
-						loads: #('core') ].
+						repository: 'github://deem0n/PostgreSQLParser:f9d1b0850cb7cde2839760d87f54f04ba9de315e/src';
+						loads: #('core-no-gui') ].
 			spec
 				baseline: 'PetitParser'
 				with: [ spec
@@ -42,7 +44,11 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 						repository: 'github://moosetechnology/PetitParser/src' ].
 			spec
 				baseline: 'PgMetadata'
-				with: [ spec repository: 'github://olivierauverlot/PgMetadata' ].
+				with: [ spec
+					repository: 'github://deem0n/PgMetadata:5abe3134238b4f84f7d1e02e28d9aee45aee5c61';
+					loads: #('Core') ].
+			spec project: 'PgMetadata-Tests' copyFrom: 'PgMetadata'
+				with: [ spec loads: #('Tests') ].
 			spec
 				baseline: 'DBConnectionsManager'
 				with: [ spec
@@ -51,5 +57,11 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 			spec
 				baseline: 'TelescopeCytoscape'
 				with: [ spec
-						repository: 'github://TelescopeSt/TelescopeCytoscape:v2.x.x/src' ] ]
+						repository: 'github://TelescopeSt/TelescopeCytoscape:v2.x.x/src' ].
+			spec
+				group: 'default' with: #('Core');
+				group: 'Core' with: #('FamixNGSQL' 'FamixNGSQL-Importer');
+				group: 'Generator' with: #('Core' 'FAMIXNGSQLMetamodelGenerator');
+				group: 'Tests' with: #('Core' 'FamixNGSQL-Importer-Tests');
+				group: 'LegacyUI' with: #('Core' 'FamixNGSQL-GTInspectorExtension' 'FAMIXNGSQLAnalysis' 'FAMIXNGSQLAnalysis-ConnectionsManager') ]
 ]
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index c011e9bd..4c0910b6 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -69,7 +69,8 @@ Class {
 		'qualifiedReference',
 		'tWithQualifiedReference',
 		'tWithImmediateSource',
-		'tWithAccesses'
+		'tWithAccesses',
+		'tWithTriggers'
 	],
 	#category : #FAMIXNGSQLMetamodelGenerator
 }
@@ -211,6 +212,13 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntities [
 
 { #category : #'definition - behavioural' }
 FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesProperties [
+	storedProcedure
+		property: #postgresOid type: #Number;
+		property: #languageName type: #String.
+	parameter
+		property: #position type: #Number;
+		property: #mode type: #String.
+	view property: #isMaterialized type: #Boolean.
 	trigger
 		property: #firingAction type: #String;
 		property: #when type: #String.
@@ -230,15 +238,19 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 		*-*
 	(storedProcedure property: #checkConstraintsCalling).
 	
+	"An ExclusionConstraint can call StoredProcedures."
+	(exclusionConstraint property: #storedProceduresCalled)
+		*-* (storedProcedure property: #exclusionConstraintsCalling).
+
 	"A View is defined as a SelectQuery."
 	((view property: #query)
 		<>-
-	(selectQuery property: #viewDefining)) withoutPrimaryContainer.
+	(selectQuery property: #viewDefining)).
 	
 	"A DerivedTable is defined as a CRUD query."
 	((derivedTable property: #query)
 		<>-
-	(crudQuery property: #derivedTableDefining)) withoutPrimaryContainer.
+	(crudQuery property: #derivedTableDefining)).
 	
 	"A SelectQuery can define multiple derived tables."
 	(tDefiningDerivedTables property: #derivedTablesDefined)
@@ -280,7 +292,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 	"A Trigger is contained in a Table. This is composition because, if the Table is removed,
 	 the Trigger should be as well because it makes no sense to have a a trigger reacting to
 	events of a non-existing table."
-	(table property: #triggers)
+	(tWithTriggers property: #triggers)
 		<>-*
 	(trigger property: #table).
 	
@@ -299,13 +311,18 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	"Abstract entities inheritance relations."
 	behaviouralEntity --|> tWithEntitySourceAnchor.
+	table --|> tWithTriggers.
+	view --|> tWithTriggers.
 	"crudQuery --|> entity." "FamixTEntity is deprecated"
-	crudQuery --|> #TSourceAnchor.
+	crudQuery --|> #TSourceEntity.
 	crudQuery --|> #TEntityMetaLevelDependency.
+	crudQuery --|> tWithNamespaceReference.
+	crudQuery --|> tWithTableReference.
+	crudQuery --|> tWithViewReference.
 	"crudQuery --|> #TDependencyQueries." "Now you only need to use TEntityMetaLevelDependency"
 	"Concrete structural entities inheritance relations."
-	checkConstraint --|> constraint.
 	checkConstraint --|> tWithImmediateSource.
+	exclusionConstraint --|> tWithImmediateSource.
 	"Concrete behavioural entities inheritance relations."
 	view --|> behaviouralEntity.
 	view --|> tAbstractType.
@@ -397,7 +414,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralHierarchy [
 	columnAlias --|> tColumn.
 	
 	"referencesGroup --|> entity." "FamixTEntity is deprecated"
-	referencesGroup --|> #TSourceAnchor.
+	referencesGroup --|> #TSourceEntity.
 	referencesGroup --|> #TEntityMetaLevelDependency.
 	"referencesGroup --|> #TDependencyQueries."
 	
@@ -419,7 +436,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralReferenceRelations [
 		
 	"A stored procedure call can contain other references (in its arguments)."
 	((storedProcedureCall property: #arguments)
-		<>-* (reference property: #storedProcedureContainer)) withoutPrimaryContainer.
+		<>-* (reference property: #storedProcedureContainer)).
 
 	"A Local variable access must point a local variable."
 	(localVariableAccess property: #localVariable) target
@@ -486,7 +503,8 @@ FmxSQLMetamodelGenerator >> defineBehaviouralTraits [
 	tWithDerivedTableReference := builder
 		newTraitNamed: #TWithDerivedTableReference.
 	tWithViewReference := builder newTraitNamed: #TWithViewReference.
-	tWithImmediateSource := builder newTraitNamed: #TWithImmediateSource.
+	tWithImmediateSource := #THasImmediateSource.
+	tWithTriggers := builder newTraitNamed: #TWithTriggers.
 	tWithAlias := builder newTraitNamed: #TWithAlias.
 	tWithCursor := builder newTraitNamed: #TWithCursor.
 	tWithCursorReference := builder newTraitNamed: #TWithCursorReference.
@@ -502,7 +520,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralTraits [
 		newTraitNamed: #TWithQualifiedReference.
 	
 "model is generated, but missed some traits. They are defined in Generator class, but we are not inherited from it :-("
-    tWithAccesses := builder newTraitNamed: #TWithAccesses.
+    tWithAccesses := #TWithAccesses.
 
 ]
 
@@ -515,14 +533,13 @@ FmxSQLMetamodelGenerator >> defineBehaviouralTraitsRelations [
 	(tWithCursorReference property: #outgoingCursorReferences)
 		-* (cursorReference property: #source) source.
 	((tWithAlias property: #aliases)
-		<>-* (alias property: #parentBehaviouralEntity))
-		withoutPrimaryContainer.
+		<>-* (alias property: #parentBehaviouralEntity)).
 	(tWithCursor property: #cursors)
 		<>-* (cursor property: #parentBehaviouralEntity).
 	(tWithReferencesGroupReference
 		property: #outgoingReferencesGroupReferences)
-		<>-* (tReferencesGroupReference property: #source).
-	(tReferencesGroupReference property: #referencesGroup)
+		<>-* (tReferencesGroupReference property: #source) source.
+	(tReferencesGroupReference property: #referencesGroup) target
 		*- (referencesGroup property: #incomingReferencesGroupReference).
 	(entitySourceAnchor property: #entity)
 		*- (tWithEntitySourceAnchor property: #anchorsOnIntervalsOfCode).
@@ -624,7 +641,7 @@ FmxSQLMetamodelGenerator >> defineClausesHierarchy [
 	"Defining all kinds of clauses"
 	"clause --|> entity." "FamixTEntity is deprecated"
 	clause --|> tWithAlias.
-	clause --|> #TSourceAnchor.
+	clause --|> #TSourceEntity.
 	clause --|> #TEntityMetaLevelDependency.
 	"clause --|> #TDependencyQueries."
 	
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index 315d902b..332ccc2c 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -174,6 +174,8 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralHierarchy [
 	"Abstract entities inheritance relations."
 	structuralEntity --|> namedEntity.
 	structuralEntity --|> tNamedEntity.
+	namedEntity --|> #TCanBeStub.
+	namedEntity --|> #TEntityMetaLevelDependency.
 	
 	constraint --|> structuralEntity.
 	constraint --|> tWithColumnReference.
@@ -226,7 +228,9 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralReferenceProperties [
 
 { #category : #'definition - structural' }
 FmxSQLStructuralMetamodelGenerator >> defineStructuralReferencesHierarchy [
+	association --|> #TAssociation.
 	reference --|> association.
+	reference --|> #TSourceEntity.
 	reference --|> tArgument.
 	tableReference --|> reference.
 	columnReference --|> reference.
@@ -255,6 +259,8 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralTraits [
 
 { #category : #'definition - structural' }
 FmxSQLStructuralMetamodelGenerator >> defineStructuralTraitsRelations [
+	(namespace property: #namespaceEntities)
+		<>-* (tNamedEntity property: #parentNamespace).
 	"A columns container contains columns."
 	(tColumnsContainer property: #columns)
 		<>-* (tColumn property: #columnsContainer).
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
new file mode 100644
index 00000000..68202556
--- /dev/null
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
@@ -0,0 +1,53 @@
+Class {
+	#name : #FmxSQLAnalysisReportingTest,
+	#superclass : #TestCase,
+	#category : #'FamixNGSQL-Importer-Tests'
+}
+
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testSourceAnchorCanBeExported [
+	| model routine anchor serialized |
+	model := FmxSQLModel new.
+	FmxSQLStoredProcedure new name: 'synthetic'; isStub: true; mooseModel: model.
+	routine := FmxSQLStoredProcedure new name: 'f'; source: 'SELECT 42'; mooseModel: model; yourself.
+	anchor := FmxSQLEntitySourceAnchor new entity: routine; start: 8; end: 9; mooseModel: model; yourself.
+	self assert: anchor sourceText equals: '42'.
+	serialized := String streamContents: [ :stream | model exportToMSEStream: stream ].
+	self assert: (serialized includesSubstring: 'SELECT 42').
+	self assert: (serialized includesSubstring: 'EntitySourceAnchor')
+]
+
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testTimeoutPreservesSourceAndAllowsNextEntity [
+	| builder slow next |
+	builder := FmxSQLModelBuilder new analysisTimeout: 10 milliSeconds.
+	slow := FmxSQLStoredProcedure new source: 'original source'.
+	next := FmxSQLStoredProcedure new.
+	self assert: (builder analyse: slow during: [ Semaphore new wait ]) equals: #timedOut.
+	self assert: slow source equals: 'original source'.
+	self assert: (slow cacheAt: #analysisDiagnostics) size equals: 1.
+	self assert: (builder analyse: next during: [ 1 + 1 ]) equals: #visited.
+	self assert: (next cacheAt: #analysisDiagnostics) isEmpty
+]
+
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testWarningsMarkPartialAnalysisAndResume [
+	| builder entity resumed |
+	builder := FmxSQLModelBuilder new.
+	entity := FmxSQLStoredProcedure new.
+	resumed := false.
+	self assert: (builder analyse: entity during: [ Warning signal: 'unresolved'. resumed := true ]) equals: #partial.
+	self assert: resumed.
+	self assert: builder errorReport warnings size equals: 1.
+	self assert: (entity cacheAt: #analysisDiagnostics) first second equals: 'unresolved'
+]
+
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testFailureIsAttributedToItsEntity [
+	| builder entity |
+	builder := FmxSQLModelBuilder new.
+	entity := FmxSQLStoredProcedure new.
+	self assert: (builder analyse: entity during: [ Error signal: 'analysis failed' ]) equals: #failed.
+	self assert: (entity cacheAt: #analysisStatus ifAbsent: [ nil ]) equals: #failed.
+	self assert: (entity cacheAt: #analysisDiagnostics) first second equals: 'analysis failed'
+]
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
new file mode 100644
index 00000000..87669626
--- /dev/null
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
@@ -0,0 +1,46 @@
+Class {
+	#name : #FmxSQLDatabaseImportTest,
+	#superclass : #PgScenarioTest,
+	#category : #'FamixNGSQL-Importer-Tests'
+}
+
+{ #category : #tests }
+FmxSQLDatabaseImportTest >> testRichModel [
+	| model namespace table view check exclusion positive span routine trigger |
+	client execute: ('
+CREATE FUNCTION {1}.positive(integer) RETURNS boolean LANGUAGE sql IMMUTABLE AS $body$ SELECT $1 > 0 $body$;
+CREATE FUNCTION {1}.span(integer) RETURNS int4range LANGUAGE sql IMMUTABLE AS $body$ SELECT int4range($1,$1+1) $body$;
+CREATE TABLE {1}.accounts (id integer, amount integer, CONSTRAINT positive CHECK ({1}.positive(amount)), CONSTRAINT nonoverlap EXCLUDE USING gist ({1}.span(id) WITH &&));
+CREATE VIEW {1}.account_view AS SELECT id,amount FROM {1}.accounts;
+CREATE FUNCTION {1}.bump(requested_id integer) RETURNS integer LANGUAGE plpgsql AS $body$ BEGIN UPDATE {1}.accounts SET amount = amount + 1 WHERE id = requested_id; RETURN requested_id; END; $body$;
+CREATE FUNCTION {1}.view_insert() RETURNS trigger LANGUAGE plpgsql AS $body$ BEGIN INSERT INTO {1}.accounts (id,amount) VALUES (NEW.id,NEW.amount); RETURN NEW; END; $body$;
+CREATE TRIGGER view_insert INSTEAD OF INSERT ON {1}.account_view FOR EACH ROW EXECUTE FUNCTION {1}.view_insert();
+' format: { schemaName }).
+	model := (FmxSQLModelBuilder new
+		databaseName: self class connectionParameters database;
+		connection: self class connectionParameters) buildModel.
+	namespace := (model allWithType: FmxSQLNamespace) detect: [ :n | n name = schemaName ].
+	table := namespace namespaceEntities detect: [ :e | e name = 'accounts' ].
+	view := namespace namespaceEntities detect: [ :e | e name = 'account_view' ].
+	positive := namespace namespaceEntities detect: [ :e | e name = 'positive' and: [ e isStoredProcedure ] ].
+	span := namespace namespaceEntities detect: [ :e | e name = 'span' ].
+	check := table constraints detect: [ :c | c name = 'positive' ].
+	exclusion := table constraints detect: [ :c | c name = 'nonoverlap' ].
+	self assert: (check storedProceduresCalled includes: positive).
+	self assert: (positive checkConstraintsCalling includes: check).
+	self assert: (exclusion storedProceduresCalled includes: span).
+	self assert: (span exclusionConstraintsCalling includes: exclusion).
+	routine := namespace namespaceEntities detect: [ :e | e name = 'bump' ].
+	self assert: routine languageName equals: 'plpgsql'.
+	self assert: routine postgresOid isNotNil.
+	self assert: routine queries isNotEmpty.
+	self assert: routine parameters size equals: 1.
+	self assert: routine parameters anyOne position equals: 1.
+	self assert: (routine source includesSubstring: 'UPDATE').
+	self assert: view query isNotNil.
+	trigger := view triggers anyOne.
+	self assert: trigger table identicalTo: view.
+	self assert: trigger storedProcedure queries isNotEmpty.
+	self assert: (trigger storedProcedure triggers includes: trigger).
+	self assert: model errorReport errors isEmpty
+]
diff --git a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitorTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
similarity index 96%
rename from src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitorTest.class.st
rename to src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
index eff55a39..defe018f 100644
--- a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitorTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
@@ -98,9 +98,7 @@ FmxSQLSymbolResolutionVisitorTest >> parseAndVisitView: aViewCode [
 { #category : #running }
 FmxSQLSymbolResolutionVisitorTest >> setUp [
 	super setUp.
-	model := MooseModel new
-					metamodel: FmxSQLMetamodelGenerator metamodel;
-					yourself.
+	model := FmxSQLModel new.
 	function := FmxSQLStoredProcedure new.
 	function mooseModel: model.
 	function name: 'currentFunction'.
@@ -588,7 +586,7 @@ FmxSQLSymbolResolutionVisitorTest >> testSelectWithSubqueryAliasing2 [
 
 { #category : #parsing }
 FmxSQLSymbolResolutionVisitorTest >> testStoredProcedureInvocation [
-	self createStoredProcedure: 'myFunction'.
+	self createStoredProcedure: 'myfunction'.
 	self
 		parseAndVisitFunction:
 			' DECLARE
@@ -681,3 +679,19 @@ BEGIN
 	c := line.c1 + line.c2;
 END;'.
 ]
+
+{ #category : #tests }
+FmxSQLSymbolResolutionVisitorTest >> testQualifiedCallPreservesOverloadCandidates [
+	| namespace otherNamespace one two unrelated call |
+	namespace := FmxSQLNamespace new name: 'app'; mooseModel: model; yourself.
+	otherNamespace := FmxSQLNamespace new name: 'other'; mooseModel: model; yourself.
+	one := (self createStoredProcedure: 'f') parentNamespace: namespace.
+	two := (self createStoredProcedure: 'f') parentNamespace: namespace.
+	unrelated := (self createStoredProcedure: 'f') parentNamespace: otherNamespace.
+	self parseAndVisitFunction: 'BEGIN app.f(1); END;'.
+	call := (model allWithType: FmxSQLStoredProcedureCall) anyOne.
+	self assert: call candidates size equals: 2.
+	self assert: (call candidates includes: one).
+	self assert: (call candidates includes: two).
+	self deny: (call candidates includes: unrelated)
+]
diff --git a/src/FamixNGSQL-Importer-Tests/package.st b/src/FamixNGSQL-Importer-Tests/package.st
new file mode 100644
index 00000000..497fed72
--- /dev/null
+++ b/src/FamixNGSQL-Importer-Tests/package.st
@@ -0,0 +1 @@
+Package { #name : #'FamixNGSQL-Importer-Tests' }
diff --git a/src/FamixNGSQL-Importer/FmxEntityParsingError.class.st b/src/FamixNGSQL-Importer/FmxEntityParsingError.class.st
index e763247f..2ca8317a 100644
--- a/src/FamixNGSQL-Importer/FmxEntityParsingError.class.st
+++ b/src/FamixNGSQL-Importer/FmxEntityParsingError.class.st
@@ -8,6 +8,11 @@ Class {
 	#category : 'FamixNGSQL-Importer-Errors'
 }
 
+{ #category : #accessing }
+FmxEntityParsingError >> messageText [
+	^ parseError ifNil: [ super messageText ] ifNotNil: [ parseError messageText ]
+]
+
 { #category : #accessing }
 FmxEntityParsingError >> entity [
 	^ entity
diff --git a/src/FamixNGSQL-Importer/FmxSQLColumnsContainer.extension.st b/src/FamixNGSQL-Importer/FmxSQLColumnsContainer.extension.st
index 91da3d20..36c00beb 100644
--- a/src/FamixNGSQL-Importer/FmxSQLColumnsContainer.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLColumnsContainer.extension.st
@@ -9,3 +9,8 @@ FmxSQLColumnsContainer >> isColumnsContainer [
 FmxSQLColumnsContainer >> reachableEntities [
 	^ self columns
 ]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLColumnsContainer >> columnNamed: aName [
+	^ self columns detect: [ :column | column name = aName ]
+]
diff --git a/src/FamixNGSQL-Importer/FmxSQLEntitySourceAnchor.extension.st b/src/FamixNGSQL-Importer/FmxSQLEntitySourceAnchor.extension.st
new file mode 100644
index 00000000..dd63d96c
--- /dev/null
+++ b/src/FamixNGSQL-Importer/FmxSQLEntitySourceAnchor.extension.st
@@ -0,0 +1,16 @@
+Extension { #name : #FmxSQLEntitySourceAnchor }
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLEntitySourceAnchor >> hasSourceText [
+	^ self entity notNil and: [ self entity source notNil and: [
+		self start isInteger and: [ self end isInteger and: [
+			self start > 0 and: [ self end >= self start and: [ self end <= self entity source size ] ] ] ] ] ]
+]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLEntitySourceAnchor >> sourceText [
+	"An incomplete AST may have no valid interval; the owner still retains its full source."
+	^ self hasSourceText
+		ifTrue: [ self entity source copyFrom: self start to: self end ]
+		ifFalse: [ '' ]
+]
diff --git a/src/FamixNGSQL-Importer/FmxSQLModel.extension.st b/src/FamixNGSQL-Importer/FmxSQLModel.extension.st
new file mode 100644
index 00000000..58321161
--- /dev/null
+++ b/src/FamixNGSQL-Importer/FmxSQLModel.extension.st
@@ -0,0 +1,64 @@
+Extension { #name : #FmxSQLModel }
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLModel >> analysisReport [
+	"Serializable companion to MSE: analysis caches are not part of the metamodel."
+	| describe routines views counts |
+	describe := [ :entity |
+		Dictionary new
+			at: 'name' put: entity name;
+			at: 'schema' put: (entity parentNamespace ifNotNil: #name);
+			at: 'kind' put: entity class name;
+			at: 'status' put: (entity cacheAt: #analysisStatus ifAbsent: [ #untracked ]) asString;
+			at: 'diagnostics' put: (entity cacheAt: #analysisDiagnostics ifAbsent: [ #() ]);
+			yourself ].
+	routines := ((self allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) collect: [ :routine |
+		(describe value: routine)
+			at: 'oid' put: routine postgresOid;
+			at: 'language' put: routine languageName;
+			yourself ].
+	views := (self allWithType: FmxSQLView) collect: describe.
+	counts := [ :entries | | result |
+		result := Dictionary new.
+		entries do: [ :entry | result at: (entry at: 'status') update: [ :count | count + 1 ] initial: [ 1 ] ].
+		result ].
+	^ Dictionary new
+		at: 'database' put: self name;
+		at: 'entityCount' put: self size;
+		at: 'errorCount' put: self errorReport errors size;
+		at: 'warningCount' put: self errorReport warnings size;
+		at: 'routineCounts' put: (counts value: routines);
+		at: 'viewCounts' put: (counts value: views);
+		at: 'routines' put: routines asArray;
+		at: 'views' put: views asArray;
+		yourself
+]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLModel >> errorReport [
+	^ self cacheAt: #errorReport
+]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLModel >> errorReport: anErrorReport [
+	^ self cacheAt: #errorReport put: anErrorReport
+]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLModel >> gtInspectorErrorReportIn: composite [
+	<gtInspectorPresentationOrder: 20>
+	^ composite fastTable
+		title: 'Importation errors';
+		display: [ self errorReport errors ];
+		beMultiple;
+		enableElementIndex;
+		wantsAutomaticRefresh: true;
+		column: 'Index' evaluated: [ :value :ibdex | ibdex asString ] width: 50;
+		column: 'Errors' evaluated: [ :value | GTObjectPrinter asTruncatedTextFrom: value ];
+		send: [ :result | 
+			result isNil
+				ifTrue: [ nil ]
+				ifFalse: [ result size = 1 
+					ifTrue: [result anyOne ]  
+					ifFalse: [self species withAll: result]]]
+]
diff --git a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
index 8183e086..0a036bb2 100644
--- a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
@@ -11,7 +11,8 @@ Class {
 		'connection',
 		'metadata',
 		'pgToFamixEntities',
-		'errorReport'
+		'errorReport',
+		'analysisTimeout'
 	],
 	#category : #'FamixNGSQL-Importer-Metadata'
 }
@@ -58,10 +59,11 @@ FmxSQLModelBuilder >> addStubColumns: columnsNames toTable: aFmxSQLTable [
 FmxSQLModelBuilder >> buildModel [
 	"Build an instance of MooseModel from the connection to the database and returns it."
 	| mooseModel |
-	mooseModel := FmxSQLMooseModel new
+	mooseModel := FmxSQLModel new
 						name: self databaseName;
 						yourself.
 	pgToFamixEntities := Dictionary new.
+	errorReport := SRParsingReport new.
 	self
 		addSpecialTables: mooseModel;
 		addSpecialFunctions: mooseModel;
@@ -74,7 +76,8 @@ FmxSQLModelBuilder >> buildModel [
 		createViewsIn: mooseModel;
 		createStoredProceduresIn: mooseModel;
 		createTriggerStoredProceduresIn: mooseModel;
-		createTriggersIn: mooseModel.
+		createTriggersIn: mooseModel;
+		linkConstraintRoutines.
 	"Need to do it in 2 steps because views can reference each others."
 	self
 		createTableInheritanceRelationsFor: mooseModel;
@@ -102,7 +105,9 @@ FmxSQLModelBuilder >> connection: anObject [
 { #category : #'model building - entities' }
 FmxSQLModelBuilder >> createConstraintsIn: aMooseModel [
 	metadata getConstraints
-		do: [ :o | o asFmxSQLEntityIn: aMooseModel withMappingdict: pgToFamixEntities ]
+		do: [ :o |
+			(o asFmxSQLEntityIn: aMooseModel withMappingdict: pgToFamixEntities)
+				ifNotNil: [ :constraint | pgToFamixEntities at: o put: constraint ] ]
 		displayingProgress: 'Creating constraints'
 ]
 
@@ -158,7 +163,9 @@ FmxSQLModelBuilder >> createNamespacesIn: aMooseModel [
 
 { #category : #'model building - linking entities' }
 FmxSQLModelBuilder >> createSourceAnchorsOfQualifiedNamesFor: model [
-	(model allWithType: FmxSQLQualifiedReference) do: #computeSourceAnchor
+	(model allWithType: FmxSQLQualifiedReference) do: [ :reference |
+		[ reference computeSourceAnchor ] on: Error do: [ :error |
+			self recordLinkingError: error for: reference ] ]
 ]
 
 { #category : #'model building - entities' }
@@ -169,11 +176,13 @@ FmxSQLModelBuilder >> createStoredProceduresIn: aMooseModel [
 			| function visitor |
 			function := FmxSQLStoredProcedure new
 				name: pgFunction name;
+				postgresOid: pgFunction oid;
+				languageName: pgFunction language name;
 				parentNamespace: (pgToFamixEntities at: pgFunction namespace);
 				returnType: (pgToFamixEntities at: pgFunction returnType);
 				source: pgFunction code;
 				mooseModel: aMooseModel;
-				isStub: (pgFunction isStub or: [ (#('plpgsql' 'sql') includes: pgFunction language name) not ]);
+				isStub: pgFunction isStub;
 				yourself.
 			visitor := FmxSQLSymbolResolutionVisitor
 				model: aMooseModel
@@ -185,6 +194,8 @@ FmxSQLModelBuilder >> createStoredProceduresIn: aMooseModel [
 						do: [ :anArgument | 
 							FmxSQLParameter new
 								name: anArgument name;
+								position: anArgument position;
+								mode: anArgument mode;
 								mooseModel: aMooseModel;
 								parentBehaviouralEntity: function;
 								type: (visitor findTypeNamed: anArgument datatype name) ] ].
@@ -248,7 +259,10 @@ FmxSQLModelBuilder >> createTriggerStoredProceduresIn: aMooseModel [
 		do: [ :pgFunction | 
 			| function |
 			function := FmxSQLTriggerStoredProcedure new
+				isStub: pgFunction isStub;
 				name: pgFunction name;
+				postgresOid: pgFunction oid;
+				languageName: pgFunction language name;
 				parentNamespace: (pgToFamixEntities at: pgFunction namespace);
 				returnType: (pgToFamixEntities at: pgFunction returnType);
 				source: pgFunction code;
@@ -290,11 +304,12 @@ FmxSQLModelBuilder >> createTypesIn: aMooseModel [
 
 { #category : #'model building - entities' }
 FmxSQLModelBuilder >> createViewsIn: aMooseModel [
-	metadata getViews
+	(metadata getViews , metadata getMaterializedViews)
 		do: [ :pgView | 
 			| view |
 			view := FmxSQLView new
 				name: pgView name;
+				isMaterialized: pgView isSqlMaterializedView;
 				parentNamespace: (pgToFamixEntities at: pgView namespace);
 				source: pgView code;
 				mooseModel: aMooseModel;
@@ -349,7 +364,19 @@ FmxSQLModelBuilder >> linkColumnReferencesToNewAndOldLocalVariableFor: model [
 							sourceAnchor: copiedSourceAnchor;
 							isCertain: false;
 							mooseModel: newLocalVariable mooseModel ] ]
-				ifNone: [ self error: 'Reference to non-existing column.' ] ] ] ]
+				ifNone: [ self recordLinkingError: (Error new
+					messageText: 'Trigger column ', varCol name, ' not found in ', table name)
+					for: newLocalVariable parentBehaviouralEntity ] ] ] ]
+]
+
+{ #category : #'model building - diagnostics' }
+FmxSQLModelBuilder >> recordLinkingError: error for: entity [
+	| diagnostics |
+	self errorReport addError: error.
+	diagnostics := entity cacheAt: #analysisDiagnostics ifAbsent: [ #() ].
+	entity cacheAt: #analysisDiagnostics put: (diagnostics, { { error class name. error messageText } }).
+	((entity cacheAt: #analysisStatus ifAbsent: [ nil ]) = #visited or: [ (entity cacheAt: #analysisStatus ifAbsent: [ nil ]) isNil ])
+		ifTrue: [ entity cacheAt: #analysisStatus put: #partial ]
 ]
 
 { #category : #private }
@@ -360,47 +387,76 @@ FmxSQLModelBuilder >> loadMetaData [
 
 { #category : #'model building - linking entities' }
 FmxSQLModelBuilder >> visitStoredProceduresFor: aMooseModel [
-	metadata getFunctions
-		do: [ :pgFunction | 
-			| function visitor |
-			function := pgToFamixEntities at: pgFunction.
-			visitor := FmxSQLSymbolResolutionVisitor
-				model: aMooseModel
-				function: function
-				errorReport: self errorReport.
-			(pgFunction isStub or: [ pgFunction isSqlAggregateFunction or: [ function isStub ] ])
-					ifFalse: [ 
-						self errorReport
-							catch: SRReferencesNotFound, SRReferencesInconsistencies , FmxEntityParsingError , MessageNotUnderstood , Warning , NotFound
-							during: [ 
-								[ pgFunction ast acceptVisitor: visitor ]
-									on: PSQLParseError
-									do: [ :e | 
-										FmxEntityParsingError new
-											entity: function;
-											parseError: e;
-											signal ] ] ] ] displayingProgress: 'Symbol resolution for stored procedures'
+	metadata getFunctions do: [ :pgFunction |
+		| function visitor |
+		function := pgToFamixEntities at: pgFunction.
+		(pgFunction isStub or: [ pgFunction isSqlAggregateFunction ])
+			ifTrue: [ function cacheAt: #analysisStatus put: #catalogOnly ]
+			ifFalse: [
+				(#('plpgsql' 'sql') includes: pgFunction language name)
+					ifFalse: [ function cacheAt: #analysisStatus put: #unsupportedLanguage ]
+					ifTrue: [
+						visitor := FmxSQLSymbolResolutionVisitor
+							model: aMooseModel function: function errorReport: self errorReport.
+						self analyse: function during: [ pgFunction ast acceptVisitor: visitor ] ] ]
+	] displayingProgress: 'Symbol resolution for stored procedures'
 ]
 
 { #category : #'model building - linking entities' }
 FmxSQLModelBuilder >> visitViewsDefinitionsFor: aMooseModel [
-	metadata getViews
-		do: [ :pgView | 
-			| visitor |
-			visitor := FmxSQLSymbolResolutionVisitor
-				model: aMooseModel
-				view: (pgToFamixEntities at: pgView)
-				errorReport: self errorReport.
-			
-			self errorReport
-				catch: SRReferencesNotFound, SRReferencesInconsistencies , FmxEntityParsingError , Warning , NotFound
-				during: [ 
-					[ (pgToFamixEntities at: pgView)
-						query: (pgView ast acceptVisitor: visitor) entity query
-					] on: PSQLParseError
-									do: [ :e | 
-										FmxEntityParsingError new
-											entity: (pgToFamixEntities at: pgView);
-											parseError: e;
-											signal ] ] ] displayingProgress: 'Symbol resolution for views'
+	(metadata getViews , metadata getMaterializedViews) do: [ :pgView |
+		| view visitor |
+		view := pgToFamixEntities at: pgView.
+		visitor := FmxSQLSymbolResolutionVisitor
+			model: aMooseModel view: view errorReport: self errorReport.
+		self analyse: view during: [ view query: (pgView ast acceptVisitor: visitor) entity query ]
+	] displayingProgress: 'Symbol resolution for views'
+]
+
+{ #category : #accessing }
+FmxSQLModelBuilder >> analysisTimeout [
+	"Bound each entity independently; retain its source and partial model on failure."
+	^ analysisTimeout ifNil: [ 5 seconds ]
+]
+
+{ #category : #accessing }
+FmxSQLModelBuilder >> analysisTimeout: aDuration [
+	analysisTimeout := aDuration
+]
+
+{ #category : #'model building - diagnostics' }
+FmxSQLModelBuilder >> analyse: entity during: aBlock [
+	| previousErrors previousWarnings status diagnostics |
+	previousErrors := self errorReport errors size.
+	previousWarnings := self errorReport warnings size.
+	status := #failed.
+	[ [ aBlock value. status := #visited ]
+		valueWithin: self analysisTimeout
+		onTimeout: [
+			status := #timedOut.
+			self errorReport addError: (Error new messageText: 'Source analysis exceeded ', self analysisTimeout printString) ]
+	] on: Error, Halt, Warning do: [ :error |
+		(error isKindOf: Warning)
+			ifTrue: [ self errorReport addWarning: error. error resume ]
+			ifFalse: [
+				self errorReport addError: ((error isKindOf: PSQLParseError)
+					ifTrue: [ FmxEntityParsingError new entity: entity; parseError: error; yourself ]
+					ifFalse: [ error ]) ] ].
+	diagnostics := ((self errorReport errors allButFirst: previousErrors),
+		(self errorReport warnings allButFirst: previousWarnings)) collect: [ :error |
+		{ error class name. error messageText } ].
+	(status = #visited and: [ diagnostics isNotEmpty ]) ifTrue: [ status := #partial ].
+	entity cacheAt: #analysisStatus put: status.
+	entity cacheAt: #analysisDiagnostics put: diagnostics.
+	^ status
+]
+
+{ #category : #'model building - linking entities' }
+FmxSQLModelBuilder >> linkConstraintRoutines [
+	metadata getConstraints do: [ :pgConstraint |
+		pgConstraint calledFunctions ifNotEmpty: [ :functions |
+			| constraint |
+			constraint := pgToFamixEntities at: pgConstraint.
+			functions do: [ :function |
+				constraint storedProceduresCalled add: (pgToFamixEntities at: function) ] ] ]
 ]
diff --git a/src/FamixNGSQL-Importer/FmxSQLMooseModel.extension.st b/src/FamixNGSQL-Importer/FmxSQLMooseModel.extension.st
deleted file mode 100644
index c74aba8a..00000000
--- a/src/FamixNGSQL-Importer/FmxSQLMooseModel.extension.st
+++ /dev/null
@@ -1,30 +0,0 @@
-Extension { #name : #FmxSQLMooseModel }
-
-{ #category : #'*FamixNGSQL-Importer' }
-FmxSQLMooseModel >> errorReport [
-	^ self propertyNamed: #errorReport
-]
-
-{ #category : #'*FamixNGSQL-Importer' }
-FmxSQLMooseModel >> errorReport: anErrorReport [
-	^ self propertyNamed: #errorReport put: anErrorReport
-]
-
-{ #category : #'*FamixNGSQL-Importer' }
-FmxSQLMooseModel >> gtInspectorErrorReportIn: composite [
-	<gtInspectorPresentationOrder: 20>
-	^ composite fastTable
-		title: 'Importation errors';
-		display: [ self errorReport errors ];
-		beMultiple;
-		enableElementIndex;
-		wantsAutomaticRefresh: true;
-		column: 'Index' evaluated: [ :value :ibdex | ibdex asString ] width: 50;
-		column: 'Errors' evaluated: [ :value | GTObjectPrinter asTruncatedTextFrom: value ];
-		send: [ :result | 
-			result isNil
-				ifTrue: [ nil ]
-				ifFalse: [ result size = 1 
-					ifTrue: [result anyOne ]  
-					ifFalse: [self species withAll: result]]]
-]
diff --git a/src/FamixNGSQL-Importer/FmxSQLParameter.extension.st b/src/FamixNGSQL-Importer/FmxSQLParameter.extension.st
index de67d99e..3ade8976 100644
--- a/src/FamixNGSQL-Importer/FmxSQLParameter.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLParameter.extension.st
@@ -1,5 +1,10 @@
 Extension { #name : #FmxSQLParameter }
 
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLParameter >> reachableEntities [
+	^ self type ifNil: [ #() ] ifNotNil: [ :aType | aType reachableEntities ]
+]
+
 { #category : #'*FamixNGSQL-Importer' }
 FmxSQLParameter >> createReferenceEntityFrom: aFmxSQLEntity [
 	^ FmxSQLParameterAccess new
diff --git a/src/FamixNGSQL-Importer/FmxSQLReference.extension.st b/src/FamixNGSQL-Importer/FmxSQLReference.extension.st
index 9ff94d67..871a70d9 100644
--- a/src/FamixNGSQL-Importer/FmxSQLReference.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLReference.extension.st
@@ -9,3 +9,13 @@ FmxSQLReference >> reference [
 FmxSQLReference >> resolveAsPartOfTheQuery: aFmxSQLInsertQuery [ 
 	self shouldBeImplemented.
 ]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLReference >> from [
+	^ self source
+]
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLReference >> to [
+	^ self target
+]
diff --git a/src/FamixNGSQL-Importer/FmxSQLStoredProcedure.extension.st b/src/FamixNGSQL-Importer/FmxSQLStoredProcedure.extension.st
index b15b19e2..ec72895f 100644
--- a/src/FamixNGSQL-Importer/FmxSQLStoredProcedure.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLStoredProcedure.extension.st
@@ -1,5 +1,11 @@
 Extension { #name : #FmxSQLStoredProcedure }
 
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLStoredProcedure >> sourceText [
+	"Synthetic catalog stubs need not have source, including during MSE export."
+	^ self source ifNil: [ '' ]
+]
+
 { #category : #'*FamixNGSQL-Importer' }
 FmxSQLStoredProcedure >> createReferenceEntityFrom: aFmxSQLEntity [
 	aFmxSQLEntity class = PSQLASTIgnoredLocalVariableNullObject
diff --git a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
index 43d7339e..481e3069 100644
--- a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
@@ -39,7 +39,7 @@ FmxSQLSymbolResolutionVisitor class >> model: aMooseModel view: aFmxSQLView [
 
 { #category : #'instance creation' }
 FmxSQLSymbolResolutionVisitor class >> model: aMooseModel view: aFmxSQLView errorReport: aPSQParsingReport [
-	^ (self model: aMooseModel function: aFmxSQLView)
+	^ (self model: aMooseModel view: aFmxSQLView)
 		errorReport: aPSQParsingReport;
 		yourself
 ]
@@ -203,6 +203,7 @@ FmxSQLSymbolResolutionVisitor >> findStoredProcedureNamed: anIdentifier [
 
 { #category : #finding }
 FmxSQLSymbolResolutionVisitor >> findTableNamed: anIdentifier [ 
+	(anIdentifier isKindOf: FmxSQLTable) ifTrue: [ ^ anIdentifier ].
 	^ (self model allWithType: FmxSQLTable) detect: [ :table | table name = anIdentifier ]  .
 ]
 
@@ -224,6 +225,7 @@ FmxSQLSymbolResolutionVisitor >> findTypeNamed: aName [
 
 { #category : #finding }
 FmxSQLSymbolResolutionVisitor >> findViewNamed: anIdentifier [
+	(anIdentifier isKindOf: FmxSQLView) ifTrue: [ ^ anIdentifier ].
 	^ (self model allWithType: FmxSQLView) detect: [ :table | table name = anIdentifier ]
 ]
 
@@ -445,7 +447,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTAttributeAccess: aPSQLASTAttributeA
 				ifTrue: [ 
 					(self createEntity: FmxSQLLocalVariable)
 						name: identifiers identifier;
-						storedProcedure: self function.
+						parentBehaviouralEntity: self function.
 					self resolveAndLinkSilently: identifiers ]
 				ifFalse: [ self errorReport addError: anError ] ].
 	
@@ -510,7 +512,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTCursorParameter: aPSQLASTCursorPara
 	parameter
 		name: (self visit: aPSQLASTCursorParameter parameterName);
 		type: (self findTypeNamed: (self visit: aPSQLASTCursorParameter type));
-		cursor: self currentEntity.
+		parentBehaviouralEntity: self currentEntity.
 	^ parameter
 ]
 
@@ -655,10 +657,27 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTFromClauseItemType7: aPSQLASTFromCl
 ]
 
 { #category : #visiting }
-FmxSQLSymbolResolutionVisitor >> visitPSQLASTFunctionCall: aPSQLASTFunctionCall [
-	self createReferenceTo: (self findStoredProcedureNamed: (self visit: aPSQLASTFunctionCall functionIdentifier)) from: aPSQLASTFunctionCall.
-	self visitAll: aPSQLASTFunctionCall argumentsList.
-	Halt if: aPSQLASTFunctionCall argumentsDictionary notEmpty
+FmxSQLSymbolResolutionVisitor >> visitPSQLASTFunctionCall: aNode [
+	| identifier namespaceName routineName candidates call |
+	identifier := aNode functionIdentifier.
+	(identifier isKindOf: PSQLASTAttributeAccess)
+		ifTrue: [
+			namespaceName := self visit: identifier accessed.
+			routineName := self visit: identifier attributeIdentifier ]
+		ifFalse: [ routineName := self visit: identifier ].
+	candidates := (self model allWithSubTypesOf: FmxSQLStoredProcedure) select: [ :routine |
+		routine name = routineName and: [ namespaceName isNil or: [
+			routine parentNamespace notNil and: [ routine parentNamespace name = namespaceName ] ] ] ].
+	candidates ifEmpty: [
+		self errorReport addError: (Error new messageText: 'Unresolved routine call: ', routineName) ]
+	ifNotEmpty: [
+		call := self createReferenceTo: candidates first from: aNode.
+		call candidates: candidates asArray.
+		candidates size > 1 ifTrue: [
+			self errorReport addWarning: (Warning new messageText:
+				'Unresolved overload or search_path for ', routineName, ': ', candidates size asString, ' candidates') ] ].
+	self visitAll: aNode argumentsList.
+	self visitAll: aNode argumentsDictionary values
 ]
 
 { #category : #visiting }
@@ -1015,7 +1034,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLPlpgSQLASTClassicDeclaration: aPSQLPlp
 	variable := self createEntity: variableClass from: aPSQLPlpgSQLASTClassicDeclaration identifier.
 	variable type: type.
 	variable parentBehaviouralEntity: self function.
-	self visit: aPSQLPlpgSQLASTClassicDeclaration defaultExpression thenDo: [ :e | Halt now ].
+	self visit: aPSQLPlpgSQLASTClassicDeclaration defaultExpression.
 	self
 		visit: aPSQLPlpgSQLASTClassicDeclaration identifier
 		thenDo: [ :name | variable name: name ].
@@ -1181,7 +1200,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLPlpgSQLASTRowTypeDeclaration: aPSQLPlp
 	^ FmxSQLLocalVariable new
 		name: (aPSQLPlpgSQLASTRowTypeDeclaration identifier acceptVisitor: self);
 		type: (self findTableOrViewNamed: (aPSQLPlpgSQLASTRowTypeDeclaration tableIdentifier acceptVisitor: self));
-		storedProcedure: function;
+		parentBehaviouralEntity: function;
 		mooseModel: model;
 		yourself
 ]
@@ -1216,3 +1235,17 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLPlpgSQLCursorUpdate: aPSQLPlpgSQLCurso
 FmxSQLSymbolResolutionVisitor >> visitPSQPlpgSQLASTExit: aPSQLPlpgSQLASTExit [
 	^ self visit: aPSQLPlpgSQLASTExit booleanExpression thenDo: [ :res |  ]
 ]
+
+{ #category : #visiting }
+FmxSQLSymbolResolutionVisitor >> visitPSQLPlpgSQLASTCursorOpenForExecute: aNode [
+	self errorReport addWarning: (Warning new messageText: 'Dynamic cursor SQL requires runtime values; query text was not analysed').
+	self visit: aNode cursorIdentifier.
+	self visit: aNode executeStatement.
+	self visitAll: aNode usingExpressions
+]
+
+{ #category : #visiting }
+FmxSQLSymbolResolutionVisitor >> visitPSQLPlpgSQLASTExecuteStatement: aNode [
+	self errorReport addWarning: (Warning new messageText: 'Dynamic SQL requires runtime values; query text was not analysed').
+	aNode childrenDo: [ :child | child acceptVisitor: self ]
+]
diff --git a/src/FamixNGSQL-Importer/SqlCheckConstraint.extension.st b/src/FamixNGSQL-Importer/SqlCheckConstraint.extension.st
index 49493a21..75eb7630 100644
--- a/src/FamixNGSQL-Importer/SqlCheckConstraint.extension.st
+++ b/src/FamixNGSQL-Importer/SqlCheckConstraint.extension.st
@@ -5,7 +5,7 @@ SqlCheckConstraint >> asFmxSQLEntityIn: aMooseModel withMappingdict: pgToFamixEn
 	| constraint |
 	constraint :=  FmxSQLCheckConstraint new
 			name: self name;
-			table: (pgToFamixEntities at: self constrainedColumns anyOne) columnsContainer;
+			table: (pgToFamixEntities at: self owner);
 			source: self code;
 			mooseModel: aMooseModel;
 			yourself.
diff --git a/src/FamixNGSQL-Importer/SqlExclusionConstraint.extension.st b/src/FamixNGSQL-Importer/SqlExclusionConstraint.extension.st
new file mode 100644
index 00000000..00dd631d
--- /dev/null
+++ b/src/FamixNGSQL-Importer/SqlExclusionConstraint.extension.st
@@ -0,0 +1,22 @@
+Extension { #name : #SqlExclusionConstraint }
+
+{ #category : #'*FamixNGSQL-Importer' }
+SqlExclusionConstraint >> asFmxSQLEntityIn: aMooseModel withMappingdict: pgToFamixEntities [
+	| constraint |
+	constraint :=  FmxSQLExclusionConstraint new
+			name: self name;
+			table: (pgToFamixEntities at: self owner);
+			source: self code;
+			mooseModel: aMooseModel;
+			yourself.
+	self constrainedColumns
+		collect: [ :pgColumn | pgToFamixEntities at: pgColumn ]
+		thenDo: [ :fmxColumn |
+			FmxSQLColumnReference new
+				source: constraint;
+				column: fmxColumn;
+				isWildCardReference: false;
+				isCertain: true;
+				mooseModel: aMooseModel ].
+	^ constraint
+]
diff --git a/src/FamixNGSQL-Importer/SqlFunction.extension.st b/src/FamixNGSQL-Importer/SqlFunction.extension.st
new file mode 100644
index 00000000..11f9cd7f
--- /dev/null
+++ b/src/FamixNGSQL-Importer/SqlFunction.extension.st
@@ -0,0 +1,10 @@
+Extension { #name : #SqlFunction }
+
+{ #category : #'*FamixNGSQL-Importer' }
+SqlFunction >> ast [
+	self language name = 'sql' ifTrue: [
+		^ PostgreSQLParser parseSQLFunctionBody: self code ].
+	self language name = 'plpgsql' ifTrue: [
+		^ PostgreSQLParser parseStoredProcedureBody: self code ].
+	^ nil
+]
diff --git a/src/FamixNGSQL-Importer/SqlTriggerConstraint.extension.st b/src/FamixNGSQL-Importer/SqlTriggerConstraint.extension.st
index 67b09444..2e1caa58 100644
--- a/src/FamixNGSQL-Importer/SqlTriggerConstraint.extension.st
+++ b/src/FamixNGSQL-Importer/SqlTriggerConstraint.extension.st
@@ -2,5 +2,5 @@ Extension { #name : #SqlTriggerConstraint }
 
 { #category : #'*FamixNGSQL-Importer' }
 SqlTriggerConstraint >> asFmxSQLEntityIn: aMooseModel withMappingdict: aCollection [ 
-	self flag: #TODO. "Should we do something here? Because triggers are handled later..."
+	^ nil "Triggers are imported by createTriggersIn:."
 ]
diff --git a/src/FamixNGSQL/FmxSQLAbstractType.trait.st b/src/FamixNGSQL/FmxSQLAbstractType.trait.st
index 161829d7..1c9fabda 100644
--- a/src/FamixNGSQL/FmxSQLAbstractType.trait.st
+++ b/src/FamixNGSQL/FmxSQLAbstractType.trait.st
@@ -1,107 +1,140 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `cursorParameters` | `FmxSQLAbstractType` | `type` | `FmxSQLCursorParameter` | |
+| `localVariables` | `FmxSQLAbstractType` | `type` | `FmxSQLLocalVariable` | |
+| `parameters` | `FmxSQLAbstractType` | `type` | `FmxSQLParameter` | |
+| `storedProceduresReturning` | `FmxSQLAbstractType` | `returnType` | `FmxSQLStoredProcedure` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLAbstractType,
+	#name : 'FmxSQLAbstractType',
 	#instVars : [
-		'#storedProceduresReturning => FMMany type: #FmxSQLStoredProcedure opposite: #returnType',
+		'#cursorParameters => FMMany type: #FmxSQLCursorParameter opposite: #type',
 		'#localVariables => FMMany type: #FmxSQLLocalVariable opposite: #type',
 		'#parameters => FMMany type: #FmxSQLParameter opposite: #type',
-		'#cursorParameters => FMMany type: #FmxSQLCursorParameter opposite: #type'
+		'#storedProceduresReturning => FMMany type: #FmxSQLStoredProcedure opposite: #returnType'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLAbstractType classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #AbstractType super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLAbstractType >> addCursorParameter: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self cursorParameters add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLAbstractType >> addLocalVariable: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self localVariables add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLAbstractType >> addParameter: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self parameters add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLAbstractType >> addStoredProceduresReturning: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self storedProceduresReturning add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> cursorParameters [
 	"Relation named: #cursorParameters type: #FmxSQLCursorParameter opposite: #type"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ cursorParameters
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> cursorParameters: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	cursorParameters value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> localVariables [
 	"Relation named: #localVariables type: #FmxSQLLocalVariable opposite: #type"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ localVariables
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> localVariables: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	localVariables value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> parameters [
 	"Relation named: #parameters type: #FmxSQLParameter opposite: #type"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ parameters
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> parameters: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	parameters value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> storedProceduresReturning [
 	"Relation named: #storedProceduresReturning type: #FmxSQLStoredProcedure opposite: #returnType"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ storedProceduresReturning
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAbstractType >> storedProceduresReturning: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	storedProceduresReturning value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLAlias.class.st b/src/FamixNGSQL/FmxSQLAlias.class.st
index cbaff601..99e4bc66 100644
--- a/src/FamixNGSQL/FmxSQLAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLAlias.class.st
@@ -1,52 +1,71 @@
 "
 I am an Alias
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentBehaviouralEntity` | `FmxSQLAlias` | `aliases` | `FmxSQLTWithAlias` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `incomingAccesses` | `FamixTAccessible` | `candidates` | `FamixTAccess` | All Famix accesses pointing to this structural entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLAlias,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLAlias',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FamixTAccessible + FmxSQLTWithDerivedTableReference',
 	#classTraits : 'FamixTAccessible classTrait + FmxSQLTWithDerivedTableReference classTrait',
 	#instVars : [
 		'#parentBehaviouralEntity => FMOne type: #FmxSQLTWithAlias opposite: #aliases'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLAlias class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Alias super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLAlias >> isAlias [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAlias >> parentBehaviouralEntity [
 	"Relation named: #parentBehaviouralEntity type: #FmxSQLTWithAlias opposite: #aliases"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ parentBehaviouralEntity
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLAlias >> parentBehaviouralEntity: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	parentBehaviouralEntity := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLAlias >> parentBehaviouralEntityGroup [
-	<generated>
-	<navigation: 'ParentBehaviouralEntity'>
-	^ MooseSpecializedGroup with: self parentBehaviouralEntity
-]
diff --git a/src/FamixNGSQL/FmxSQLAliasAccess.class.st b/src/FamixNGSQL/FmxSQLAliasAccess.class.st
index 6490d3df..5eed8b5c 100644
--- a/src/FamixNGSQL/FmxSQLAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLAliasAccess.class.st
@@ -1,26 +1,59 @@
 "
 I am an access to an alias.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
 "
 Class {
-	#name : #FmxSQLAliasAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLAliasAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTAccess classTrait + FmxSQLTWithQualifiedReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLAliasAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #AliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLAliasAccess >> isAliasAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLAssociation.class.st b/src/FamixNGSQL/FmxSQLAssociation.class.st
index f0def881..0927c28a 100644
--- a/src/FamixNGSQL/FmxSQLAssociation.class.st
+++ b/src/FamixNGSQL/FmxSQLAssociation.class.st
@@ -1,14 +1,32 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
+"
 Class {
-	#name : #FmxSQLAssociation,
-	#superclass : #FmxSQLEntity,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLAssociation',
+	#superclass : 'FmxSQLEntity',
+	#traits : 'FamixTAssociation',
+	#classTraits : 'FamixTAssociation classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLAssociation class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Association super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st b/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
index 8d619b86..8f018f45 100644
--- a/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
+++ b/src/FamixNGSQL/FmxSQLBehaviouralEntity.trait.st
@@ -1,15 +1,29 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLBehaviouralEntity,
+	#name : 'FmxSQLBehaviouralEntity',
 	#traits : 'FmxSQLTWithEntitySourceAnchor',
 	#classTraits : 'FmxSQLTWithEntitySourceAnchor classTrait',
-	#category : 'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLBehaviouralEntity classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #BehaviouralEntity super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
index d45f2290..45479658 100644
--- a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
@@ -10,101 +10,119 @@ The Update query is the UPDATE query in SQL.
 The Delete query is the DELETE query in SQL.
 
 My subclasses represent these four queries.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `container` | `FmxSQLCRUDQuery` | `queries` | `FmxSQLTQueryContainer` | |
+| `derivedTableDefining` | `FmxSQLCRUDQuery` | `query` | `FmxSQLDerivedTable` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `clauses` | `FmxSQLCRUDQuery` | `query` | `FmxSQLClause` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLCRUDQuery,
-	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTSourceAnchor + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTSourceAnchor classTrait + TEntityMetaLevelDependency classTrait',
+	#name : 'FmxSQLCRUDQuery',
+	#superclass : 'FmxSQLEntity',
+	#traits : 'FamixTSourceEntity + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
-		'#derivedTableDefining => FMOne type: #FmxSQLDerivedTable opposite: #query',
 		'#clauses => FMMany type: #FmxSQLClause opposite: #query',
-		'#container => FMOne type: #FmxSQLTQueryContainer opposite: #queries'
+		'#container => FMOne type: #FmxSQLTQueryContainer opposite: #queries',
+		'#derivedTableDefining => FMOne type: #FmxSQLDerivedTable opposite: #query'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCRUDQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #CRUDQuery super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLCRUDQuery >> addClause: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self clauses add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> clauses [
 	"Relation named: #clauses type: #FmxSQLClause opposite: #query"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ clauses
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> clauses: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	clauses value: anObject
 ]
 
-{ #category : #navigation }
-FmxSQLCRUDQuery >> clausesGroup [
-	<generated>
-	<navigation: 'Clauses'>
-	^ MooseSpecializedGroup withAll: self clauses asSet
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> container [
 	"Relation named: #container type: #FmxSQLTQueryContainer opposite: #queries"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ container
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> container: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	container := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLCRUDQuery >> containerGroup [
-	<generated>
-	<navigation: 'Container'>
-	^ MooseSpecializedGroup with: self container
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> derivedTableDefining [
 	"Relation named: #derivedTableDefining type: #FmxSQLDerivedTable opposite: #query"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	<derived>
 	^ derivedTableDefining
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCRUDQuery >> derivedTableDefining: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	derivedTableDefining := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLCRUDQuery >> derivedTableDefiningGroup [
-	<generated>
-	<navigation: 'DerivedTableDefining'>
-	^ MooseSpecializedGroup with: self derivedTableDefining
-]
diff --git a/src/FamixNGSQL/FmxSQLCheckConstraint.class.st b/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
index 395663fd..e9804796 100644
--- a/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLCheckConstraint.class.st
@@ -1,51 +1,76 @@
 "
 I represent a CHECK constraint as defined in SQL standard.
+
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+| `storedProceduresCalled` | `FmxSQLCheckConstraint` | `checkConstraintsCalling` | `FmxSQLStoredProcedure` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `source` | `String` | nil | Actual source code of the source entity|
+
 "
 Class {
-	#name : #FmxSQLCheckConstraint,
-	#superclass : #FmxSQLConstraint,
-	#traits : 'FmxSQLTWithImmediateSource',
-	#classTraits : 'FmxSQLTWithImmediateSource classTrait',
+	#name : 'FmxSQLCheckConstraint',
+	#superclass : 'FmxSQLConstraint',
+	#traits : 'FamixTHasImmediateSource',
+	#classTraits : 'FamixTHasImmediateSource classTrait',
 	#instVars : [
 		'#storedProceduresCalled => FMMany type: #FmxSQLStoredProcedure opposite: #checkConstraintsCalling'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCheckConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #CheckConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLCheckConstraint >> addStoredProceduresCalled: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self storedProceduresCalled add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLCheckConstraint >> isCheckConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCheckConstraint >> storedProceduresCalled [
 	"Relation named: #storedProceduresCalled type: #FmxSQLStoredProcedure opposite: #checkConstraintsCalling"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ storedProceduresCalled
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCheckConstraint >> storedProceduresCalled: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	storedProceduresCalled value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLClause.class.st b/src/FamixNGSQL/FmxSQLClause.class.st
index 47bda169..097ea0ce 100644
--- a/src/FamixNGSQL/FmxSQLClause.class.st
+++ b/src/FamixNGSQL/FmxSQLClause.class.st
@@ -1,45 +1,63 @@
 "
 I am an abstract clause
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `query` | `FmxSQLClause` | `clauses` | `FmxSQLCRUDQuery` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `aliases` | `FmxSQLTWithAlias` | `parentBehaviouralEntity` | `FmxSQLAlias` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLClause,
-	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTSourceAnchor + FmxSQLTWithAlias + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTSourceAnchor classTrait + FmxSQLTWithAlias classTrait + TEntityMetaLevelDependency classTrait',
+	#name : 'FmxSQLClause',
+	#superclass : 'FmxSQLEntity',
+	#traits : 'FamixTSourceEntity + FmxSQLTWithAlias + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTWithAlias classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
 		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #clauses'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Clause super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLClause >> query [
 	"Relation named: #query type: #FmxSQLCRUDQuery opposite: #clauses"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ query
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLClause >> query: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	query := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLClause >> queryGroup [
-	<generated>
-	<navigation: 'Query'>
-	^ MooseSpecializedGroup with: self query
-]
diff --git a/src/FamixNGSQL/FmxSQLColumn.class.st b/src/FamixNGSQL/FmxSQLColumn.class.st
index bc67faa7..d1cc4a75 100644
--- a/src/FamixNGSQL/FmxSQLColumn.class.st
+++ b/src/FamixNGSQL/FmxSQLColumn.class.st
@@ -1,67 +1,97 @@
 "
 I represent a Column in the relational model.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnsContainer` | `FmxSQLTColumn` | `columns` | `FmxSQLColumnsContainer` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLColumn` | `column` | `FmxSQLColumnReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `type` | `FmxSQLColumn` | `columns` | `FmxSQLType` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLColumn,
-	#superclass : #FmxSQLStructuralEntity,
+	#name : 'FmxSQLColumn',
+	#superclass : 'FmxSQLStructuralEntity',
 	#traits : 'FmxSQLTColumn',
 	#classTraits : 'FmxSQLTColumn classTrait',
 	#instVars : [
-		'#type => FMOne type: #FmxSQLType opposite: #columns',
-		'#references => FMMany type: #FmxSQLColumnReference opposite: #column'
+		'#references => FMMany type: #FmxSQLColumnReference opposite: #column',
+		'#type => FMOne type: #FmxSQLType opposite: #columns'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumn class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Column super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLColumn >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLColumn >> isColumn [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumn >> references [
 	"Relation named: #references type: #FmxSQLColumnReference opposite: #column"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumn >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumn >> type [
 	"Relation named: #type type: #FmxSQLType opposite: #columns"
 
+	<ignoreForCoverage>
 	<generated>
 	^ type
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumn >> type: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	type := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnAlias.class.st b/src/FamixNGSQL/FmxSQLColumnAlias.class.st
index 45478e95..473175c0 100644
--- a/src/FamixNGSQL/FmxSQLColumnAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnAlias.class.st
@@ -1,37 +1,68 @@
 "
 I am an alias for a column.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnsContainer` | `FmxSQLTColumn` | `columns` | `FmxSQLColumnsContainer` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnsContainerAlias` | `FmxSQLColumnAlias` | `columnAliases` | `FmxSQLColumnsContainerAlias` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLColumnAlias,
-	#superclass : #FmxSQLAlias,
+	#name : 'FmxSQLColumnAlias',
+	#superclass : 'FmxSQLAlias',
 	#traits : 'FmxSQLTColumn + FmxSQLTWithColumnReference + FmxSQLTWithReferencesGroupReference',
 	#classTraits : 'FmxSQLTColumn classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithReferencesGroupReference classTrait',
 	#instVars : [
 		'#columnsContainerAlias => FMOne type: #FmxSQLColumnsContainerAlias opposite: #columnAliases'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnAlias class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnAlias super: #FmxSQLAlias>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnAlias >> columnsContainerAlias [
 	"Relation named: #columnsContainerAlias type: #FmxSQLColumnsContainerAlias opposite: #columnAliases"
 
+	<ignoreForCoverage>
 	<generated>
 	^ columnsContainerAlias
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnAlias >> columnsContainerAlias: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columnsContainerAlias := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st b/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
index 66f68735..fa116365 100644
--- a/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnAliasAccess.class.st
@@ -1,16 +1,49 @@
+"
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
+"
 Class {
-	#name : #FmxSQLColumnAliasAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLColumnAliasAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTAccess classTrait + FmxSQLTWithQualifiedReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnAliasAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnAliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnReference.class.st b/src/FamixNGSQL/FmxSQLColumnReference.class.st
index 26582f31..9476bd33 100644
--- a/src/FamixNGSQL/FmxSQLColumnReference.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnReference.class.st
@@ -1,133 +1,175 @@
 "
 I am reference to a column in a table of the model.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `triggerStoredProceduresReferencing` | `FmxSQLColumnReference` | `columnsReferenced` | `FmxSQLTriggerStoredProcedure` | |
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `foreignKeyConstraintSource` | `FmxSQLColumnReference` | `outgoingForeignKeyColumnReferences` | `FmxSQLForeignKeyConstraint` | |
+| `source` | `FmxSQLColumnReference` | `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `column` | `FmxSQLColumnReference` | `references` | `FmxSQLColumn` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isCertain` | `Boolean` | nil | |
+| `isWildCardReference` | `Boolean` | nil | |
+
 "
 Class {
-	#name : #FmxSQLColumnReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLColumnReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#isWildCardReference => FMProperty',
-		'#isCertain => FMProperty',
+		'#column => FMOne type: #FmxSQLColumn opposite: #references',
 		'#foreignKeyConstraintSource => FMOne type: #FmxSQLForeignKeyConstraint opposite: #outgoingForeignKeyColumnReferences',
+		'#isCertain => FMProperty',
+		'#isWildCardReference => FMProperty',
 		'#source => FMOne type: #FmxSQLTWithColumnReference opposite: #outgoingColumnReferences',
-		'#column => FMOne type: #FmxSQLColumn opposite: #references',
 		'#triggerStoredProceduresReferencing => FMOne type: #FmxSQLTriggerStoredProcedure opposite: #columnsReferenced'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> column [
 	"Relation named: #column type: #FmxSQLColumn opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ column
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> column: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	column := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> foreignKeyConstraintSource [
 	"Relation named: #foreignKeyConstraintSource type: #FmxSQLForeignKeyConstraint opposite: #outgoingForeignKeyColumnReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ foreignKeyConstraintSource
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> foreignKeyConstraintSource: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	foreignKeyConstraintSource := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> isCertain [
 
 	<FMProperty: #isCertain type: #Boolean>
+	<ignoreForCoverage>
 	<generated>
 	^ isCertain
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> isCertain: anObject [
+	<ignoreForCoverage>
 	<generated>
 	isCertain := anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLColumnReference >> isColumnReference [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> isWildCardReference [
 
 	<FMProperty: #isWildCardReference type: #Boolean>
+	<ignoreForCoverage>
 	<generated>
 	^ isWildCardReference
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> isWildCardReference: anObject [
+	<ignoreForCoverage>
 	<generated>
 	isWildCardReference := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> source [
 	"Relation named: #source type: #FmxSQLTWithColumnReference opposite: #outgoingColumnReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> triggerStoredProceduresReferencing [
 	"Relation named: #triggerStoredProceduresReferencing type: #FmxSQLTriggerStoredProcedure opposite: #columnsReferenced"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ triggerStoredProceduresReferencing
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnReference >> triggerStoredProceduresReferencing: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	triggerStoredProceduresReferencing := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLColumnReference >> triggerStoredProceduresReferencingGroup [
-	<generated>
-	<navigation: 'TriggerStoredProceduresReferencing'>
-	^ MooseSpecializedGroup with: self triggerStoredProceduresReferencing
-]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st b/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
index 6de50e15..a67893c1 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainer.trait.st
@@ -1,48 +1,58 @@
 "
 I am an abstract super class for entities that contain columns. Two of my well-known subclasses are the table and the view.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+
+
+
 "
 Trait {
-	#name : #FmxSQLColumnsContainer,
+	#name : 'FmxSQLColumnsContainer',
 	#instVars : [
 		'#columns => FMMany type: #FmxSQLTColumn opposite: #columnsContainer'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnsContainer classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnsContainer super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLColumnsContainer >> addColumn: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self columns add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnsContainer >> columns [
 	"Relation named: #columns type: #FmxSQLTColumn opposite: #columnsContainer"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ columns
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnsContainer >> columns: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columns value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLColumnsContainer >> columnsGroup [
-	<generated>
-	<navigation: 'Columns'>
-	^ MooseSpecializedGroup withAll: self columns asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st b/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
index f008e836..d4b072b4 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainerAlias.class.st
@@ -1,44 +1,67 @@
 "
 I am an alias for a table. Eventually I also contain alias to columns.
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnAliases` | `FmxSQLColumnsContainerAlias` | `columnsContainerAlias` | `FmxSQLColumnAlias` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLColumnsContainerAlias,
-	#superclass : #FmxSQLAlias,
+	#name : 'FmxSQLColumnsContainerAlias',
+	#superclass : 'FmxSQLAlias',
 	#traits : 'FmxSQLTWithTableReference + FmxSQLTWithViewReference',
 	#classTraits : 'FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#instVars : [
 		'#columnAliases => FMMany type: #FmxSQLColumnAlias opposite: #columnsContainerAlias'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnsContainerAlias class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnsContainerAlias super: #FmxSQLAlias>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
-FmxSQLColumnsContainerAlias >> addColumnAliase: anObject [
+{ #category : 'adding' }
+FmxSQLColumnsContainerAlias >> addColumnAlias: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self columnAliases add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnsContainerAlias >> columnAliases [
 	"Relation named: #columnAliases type: #FmxSQLColumnAlias opposite: #columnsContainerAlias"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ columnAliases
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLColumnsContainerAlias >> columnAliases: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columnAliases value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st b/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
index 1c520178..99905a88 100644
--- a/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLColumnsContainerAliasAccess.class.st
@@ -1,16 +1,49 @@
+"
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
+"
 Class {
-	#name : #FmxSQLColumnsContainerAliasAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLColumnsContainerAliasAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTAccess classTrait + FmxSQLTWithQualifiedReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLColumnsContainerAliasAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ColumnsContainerAliasAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLComment.class.st b/src/FamixNGSQL/FmxSQLComment.class.st
index fab39136..992f46de 100644
--- a/src/FamixNGSQL/FmxSQLComment.class.st
+++ b/src/FamixNGSQL/FmxSQLComment.class.st
@@ -1,16 +1,35 @@
+"
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `commentedEntity` | `FamixTComment` | `comments` | `FamixTWithComments` | Source code commented by the comment|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
+"
 Class {
-	#name : #FmxSQLComment,
-	#superclass : #FmxSQLSourcedEntity,
+	#name : 'FmxSQLComment',
+	#superclass : 'FmxSQLSourcedEntity',
 	#traits : 'FamixTComment',
 	#classTraits : 'FamixTComment classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLComment class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Comment super: #FmxSQLSourcedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLConstraint.class.st b/src/FamixNGSQL/FmxSQLConstraint.class.st
index 247f8fa0..0766002e 100644
--- a/src/FamixNGSQL/FmxSQLConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLConstraint.class.st
@@ -1,52 +1,66 @@
 "
 I am an abstract superclass for constraints. A constraint restrict the possible values that can be stored in a column of a table.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `table` | `FmxSQLConstraint` | `constraints` | `FmxSQLTable` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLConstraint,
-	#superclass : #FmxSQLStructuralEntity,
+	#name : 'FmxSQLConstraint',
+	#superclass : 'FmxSQLStructuralEntity',
 	#traits : 'FmxSQLTWithColumnReference',
 	#classTraits : 'FmxSQLTWithColumnReference classTrait',
 	#instVars : [
 		'#table => FMOne type: #FmxSQLTable opposite: #constraints'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Constraint super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLConstraint >> isConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLConstraint >> table [
 	"Relation named: #table type: #FmxSQLTable opposite: #constraints"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ table
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLConstraint >> table: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	table := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLConstraint >> tableGroup [
-	<generated>
-	<navigation: 'Table'>
-	^ MooseSpecializedGroup with: self table
-]
diff --git a/src/FamixNGSQL/FmxSQLCursor.class.st b/src/FamixNGSQL/FmxSQLCursor.class.st
index 9584e136..77442fe2 100644
--- a/src/FamixNGSQL/FmxSQLCursor.class.st
+++ b/src/FamixNGSQL/FmxSQLCursor.class.st
@@ -1,75 +1,104 @@
 "
 I am a cursor, a local iterator that can have parameters
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentBehaviouralEntity` | `FmxSQLCursor` | `cursors` | `FmxSQLTWithCursor` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parameters` | `FamixTWithParameters` | `parentBehaviouralEntity` | `FamixTParameter` | List of formal parameters declared by this behaviour.|
+| `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLCursor` | `cursor` | `FmxSQLCursorReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLCursor,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLCursor',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FamixTWithParameters + FmxSQLBehaviouralEntity + FmxSQLTQueryContainer',
 	#classTraits : 'FamixTWithParameters classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTQueryContainer classTrait',
 	#instVars : [
 		'#parentBehaviouralEntity => FMOne type: #FmxSQLTWithCursor opposite: #cursors',
 		'#references => FMMany type: #FmxSQLCursorReference opposite: #cursor'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCursor class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Cursor super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLCursor >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLCursor >> isCursor [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursor >> parentBehaviouralEntity [
 	"Relation named: #parentBehaviouralEntity type: #FmxSQLTWithCursor opposite: #cursors"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ parentBehaviouralEntity
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursor >> parentBehaviouralEntity: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	parentBehaviouralEntity := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLCursor >> parentBehaviouralEntityGroup [
-	<generated>
-	<navigation: 'ParentBehaviouralEntity'>
-	^ MooseSpecializedGroup with: self parentBehaviouralEntity
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursor >> references [
 	"Relation named: #references type: #FmxSQLCursorReference opposite: #cursor"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursor >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursorParameter.class.st b/src/FamixNGSQL/FmxSQLCursorParameter.class.st
index d292a90a..e5369ff8 100644
--- a/src/FamixNGSQL/FmxSQLCursorParameter.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorParameter.class.st
@@ -1,37 +1,75 @@
 "
 I am a cursor parameter
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentBehaviouralEntity` | `FamixTParameter` | `parameters` | `FamixTWithParameters` | Behavioural entity containing this parameter. belongsTo implementation|
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `typing` | `FamixTTypedEntity` | `typedEntity` | `FamixTEntityTyping` | Association linking this entity to its declared type.|
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `incomingAccesses` | `FamixTAccessible` | `candidates` | `FamixTAccess` | All Famix accesses pointing to this structural entity|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+| `type` | `FmxSQLCursorParameter` | `cursorParameters` | `FmxSQLAbstractType` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isStub` | `Boolean` | false | Flag true if the entity attributes are incomplete, either because the entity is missing or not imported.|
+| `name` | `String` | nil | Basic name of the entity, not full reference.|
+
 "
 Class {
-	#name : #FmxSQLCursorParameter,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLCursorParameter',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FamixTAccessible + FamixTParameter',
 	#classTraits : 'FamixTAccessible classTrait + FamixTParameter classTrait',
 	#instVars : [
 		'#type => FMOne type: #FmxSQLAbstractType opposite: #cursorParameters'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCursorParameter class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #CursorParameter super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorParameter >> type [
 	"Relation named: #type type: #FmxSQLAbstractType opposite: #cursorParameters"
 
+	<ignoreForCoverage>
 	<generated>
 	^ type
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorParameter >> type: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	type := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st b/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
index ad0e2aa3..e41e5ea3 100644
--- a/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorParameterAccess.class.st
@@ -1,19 +1,51 @@
 "
 I am an access to a cursor parameter.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
 "
 Class {
-	#name : #FmxSQLCursorParameterAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLCursorParameterAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTAccess classTrait + FmxSQLTWithQualifiedReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCursorParameterAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #CursorParameterAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLCursorReference.class.st b/src/FamixNGSQL/FmxSQLCursorReference.class.st
index f0b73c87..be3f0c2f 100644
--- a/src/FamixNGSQL/FmxSQLCursorReference.class.st
+++ b/src/FamixNGSQL/FmxSQLCursorReference.class.st
@@ -1,55 +1,82 @@
 "
 I am a reference to a cursor
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLCursorReference` | `outgoingCursorReferences` | `FmxSQLTWithCursorReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `cursor` | `FmxSQLCursorReference` | `references` | `FmxSQLCursor` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLCursorReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLCursorReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#source => FMOne type: #FmxSQLTWithCursorReference opposite: #outgoingCursorReferences',
-		'#cursor => FMOne type: #FmxSQLCursor opposite: #references'
+		'#cursor => FMOne type: #FmxSQLCursor opposite: #references',
+		'#source => FMOne type: #FmxSQLTWithCursorReference opposite: #outgoingCursorReferences'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLCursorReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #CursorReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorReference >> cursor [
 	"Relation named: #cursor type: #FmxSQLCursor opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ cursor
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorReference >> cursor: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	cursor := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorReference >> source [
 	"Relation named: #source type: #FmxSQLTWithCursorReference opposite: #outgoingCursorReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLCursorReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLDeleteQuery.class.st b/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
index ebeb2edc..091dc48d 100644
--- a/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLDeleteQuery.class.st
@@ -1,19 +1,32 @@
 "
 I am an DELETE query.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | `parentQuery` | `FmxSQLDerivedTable` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLDeleteQuery,
-	#superclass : #FmxSQLCRUDQuery,
+	#name : 'FmxSQLDeleteQuery',
+	#superclass : 'FmxSQLCRUDQuery',
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLDeleteQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #DeleteQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLDerivedTable.class.st b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
index e4f63a6c..5215f0fa 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTable.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
@@ -1,91 +1,115 @@
 "
 I am a derived table. A derived table is a temporary table created to store temporarily the results of a sub-select query in a select query. Such tables are not globally named as a Tableor a View because they can not be accessed outside the query in which they are computed (which is also the query defining them). Nonetheless, they can get an alias to be referenced inside the query. .
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentQuery` | `FmxSQLDerivedTable` | `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+| `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
+| `query` | `FmxSQLDerivedTable` | `derivedTableDefining` | `FmxSQLCRUDQuery` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLDerivedTable` | `derivedTable` | `FmxSQLDerivedTableReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLDerivedTable,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLDerivedTable',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTQueryContainer',
 	#classTraits : 'FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTQueryContainer classTrait',
 	#instVars : [
-		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #derivedTableDefining',
 		'#parentQuery => FMOne type: #FmxSQLTDefiningDerivedTables opposite: #derivedTablesDefined',
+		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #derivedTableDefining',
 		'#references => FMMany type: #FmxSQLDerivedTableReference opposite: #derivedTable'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLDerivedTable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #DerivedTable super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLDerivedTable >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> parentQuery [
 	"Relation named: #parentQuery type: #FmxSQLTDefiningDerivedTables opposite: #derivedTablesDefined"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ parentQuery
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> parentQuery: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	parentQuery := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLDerivedTable >> parentQueryGroup [
-	<generated>
-	<navigation: 'ParentQuery'>
-	^ MooseSpecializedGroup with: self parentQuery
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> query [
 	"Relation named: #query type: #FmxSQLCRUDQuery opposite: #derivedTableDefining"
 
+	<ignoreForCoverage>
 	<generated>
 	^ query
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> query: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	query := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLDerivedTable >> queryGroup [
-	<generated>
-	<navigation: 'Query'>
-	^ MooseSpecializedGroup with: self query
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> references [
 	"Relation named: #references type: #FmxSQLDerivedTableReference opposite: #derivedTable"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTable >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st b/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
index a6265592..abbdd460 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTableReference.class.st
@@ -1,53 +1,75 @@
 "
 I am a reference to a derived table.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLDerivedTableReference` | `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTable` | `FmxSQLDerivedTableReference` | `references` | `FmxSQLDerivedTable` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLDerivedTableReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLDerivedTableReference',
+	#superclass : 'FmxSQLReference',
 	#instVars : [
-		'#source => FMOne type: #FmxSQLTWithDerivedTableReference opposite: #outgoingDerivedTableReferences',
-		'#derivedTable => FMOne type: #FmxSQLDerivedTable opposite: #references'
+		'#derivedTable => FMOne type: #FmxSQLDerivedTable opposite: #references',
+		'#source => FMOne type: #FmxSQLTWithDerivedTableReference opposite: #outgoingDerivedTableReferences'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLDerivedTableReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #DerivedTableReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTableReference >> derivedTable [
 	"Relation named: #derivedTable type: #FmxSQLDerivedTable opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ derivedTable
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTableReference >> derivedTable: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	derivedTable := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTableReference >> source [
 	"Relation named: #source type: #FmxSQLTWithDerivedTableReference opposite: #outgoingDerivedTableReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLDerivedTableReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLEntity.class.st b/src/FamixNGSQL/FmxSQLEntity.class.st
index bcff2999..43493c72 100644
--- a/src/FamixNGSQL/FmxSQLEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLEntity.class.st
@@ -1,315 +1,417 @@
 Class {
-	#name : #FmxSQLEntity,
-	#superclass : #MooseEntity,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLEntity',
+	#superclass : 'MooseEntity',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLEntity class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Entity super: #MooseEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
+	<abstract>
 ]
 
-{ #category : #meta }
+{ #category : 'testing' }
+FmxSQLEntity class >> isAbstract [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self == FmxSQLEntity
+]
+
+{ #category : 'meta' }
 FmxSQLEntity class >> metamodel [
 
+	<ignoreForCoverage>
 	<generated>
 	^ FmxSQLModel metamodel
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
+FmxSQLEntity >> canBeStub [
+
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
+FmxSQLEntity >> hasImmediateSource [
+
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
 FmxSQLEntity >> isAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isAlias [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isAliasAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isAssociation [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isCheckConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isColumn [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isColumnReference [
 
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
+FmxSQLEntity >> isComment [
+
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isCursor [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isEntitySourceAnchor [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isExceptClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isExclusionConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isForeignKeyConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isFromClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isGroupByClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isHavingClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isIntersectClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isInvocation [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isJoinClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isLimitClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
+FmxSQLEntity >> isLocalVariable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
 FmxSQLEntity >> isLocalVariableAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
+FmxSQLEntity >> isNamedEntity [
+
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
 FmxSQLEntity >> isNamespace [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isNotNullConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isOnConflictClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isOrderByClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isParameterAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isPrimaryKeyConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isQueryContainer [
 
+	<ignoreForCoverage>
+	<generated>
+	^ false
+]
+
+{ #category : 'testing' }
+FmxSQLEntity >> isQueryable [
+
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isReturningClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isSelectClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isSetClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isStoredProcedure [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isStoredProcedureCall [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isStructuralEntity [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isTriggerStoredProcedure [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isUnionClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isUniqueConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isUsingClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isValuesClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isView [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isWhereClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntity >> isWithClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ false
 ]
diff --git a/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st b/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
index fc86333a..9cbad1f1 100644
--- a/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLEntitySourceAnchor.class.st
@@ -1,74 +1,102 @@
 "
 I am a source anchor which anchor source code held by an entity with immediate source.
+
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+| `entity` | `FmxSQLEntitySourceAnchor` | `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `end` | `Number` | nil | |
+| `start` | `Number` | nil | |
+
 "
 Class {
-	#name : #FmxSQLEntitySourceAnchor,
-	#superclass : #FmxSQLEntity,
+	#name : 'FmxSQLEntitySourceAnchor',
+	#superclass : 'FmxSQLEntity',
 	#traits : 'FamixTSourceAnchor',
 	#classTraits : 'FamixTSourceAnchor classTrait',
 	#instVars : [
-		'#start => FMProperty',
 		'#end => FMProperty',
-		'#entity => FMOne type: #FmxSQLTWithEntitySourceAnchor opposite: #anchorsOnIntervalsOfCode'
+		'#entity => FMOne type: #FmxSQLTWithEntitySourceAnchor opposite: #anchorsOnIntervalsOfCode',
+		'#start => FMProperty'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLEntitySourceAnchor class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #EntitySourceAnchor super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> end [
 
 	<FMProperty: #end type: #Number>
+	<ignoreForCoverage>
 	<generated>
 	^ end
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> end: anObject [
+	<ignoreForCoverage>
 	<generated>
 	end := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> entity [
 	"Relation named: #entity type: #FmxSQLTWithEntitySourceAnchor opposite: #anchorsOnIntervalsOfCode"
 
+	<ignoreForCoverage>
 	<generated>
 	^ entity
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> entity: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	entity := anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLEntitySourceAnchor >> isEntitySourceAnchor [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> start [
 
 	<FMProperty: #start type: #Number>
+	<ignoreForCoverage>
 	<generated>
 	^ start
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLEntitySourceAnchor >> start: anObject [
+	<ignoreForCoverage>
 	<generated>
 	start := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLExceptClause.class.st b/src/FamixNGSQL/FmxSQLExceptClause.class.st
index b2536cc6..29f2bf69 100644
--- a/src/FamixNGSQL/FmxSQLExceptClause.class.st
+++ b/src/FamixNGSQL/FmxSQLExceptClause.class.st
@@ -1,26 +1,47 @@
 "
 I am an except clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLExceptClause,
-	#superclass : #FmxSQLClause,
+	#name : 'FmxSQLExceptClause',
+	#superclass : 'FmxSQLClause',
 	#traits : 'FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
 	#classTraits : 'FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLExceptClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ExceptClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLExceptClause >> isExceptClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
index 2ac4b958..33aa4382 100644
--- a/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLExclusionConstraint.class.st
@@ -1,24 +1,76 @@
 "
 I represent an EXCLUSION constraint as defined in SQL standard.
+
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+| `storedProceduresCalled` | `FmxSQLExclusionConstraint` | `exclusionConstraintsCalling` | `FmxSQLStoredProcedure` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `source` | `String` | nil | Actual source code of the source entity|
+
 "
 Class {
-	#name : #FmxSQLExclusionConstraint,
-	#superclass : #FmxSQLConstraint,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLExclusionConstraint',
+	#superclass : 'FmxSQLConstraint',
+	#traits : 'FamixTHasImmediateSource',
+	#classTraits : 'FamixTHasImmediateSource classTrait',
+	#instVars : [
+		'#storedProceduresCalled => FMMany type: #FmxSQLStoredProcedure opposite: #exclusionConstraintsCalling'
+	],
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLExclusionConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ExclusionConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'adding' }
+FmxSQLExclusionConstraint >> addStoredProceduresCalled: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self storedProceduresCalled add: anObject
+]
+
+{ #category : 'testing' }
 FmxSQLExclusionConstraint >> isExclusionConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
+
+{ #category : 'accessing' }
+FmxSQLExclusionConstraint >> storedProceduresCalled [
+	"Relation named: #storedProceduresCalled type: #FmxSQLStoredProcedure opposite: #exclusionConstraintsCalling"
+
+	<ignoreForCoverage>
+	<generated>
+	<derived>
+	^ storedProceduresCalled
+]
+
+{ #category : 'accessing' }
+FmxSQLExclusionConstraint >> storedProceduresCalled: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	storedProceduresCalled value: anObject
+]
diff --git a/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st b/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
index aaeb2ec8..18a64777 100644
--- a/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLForeignKeyConstraint.class.st
@@ -1,49 +1,67 @@
 "
 I represent a FOREIGN KEY constraint as defined in SQL standard.
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingForeignKeyColumnReferences` | `FmxSQLForeignKeyConstraint` | `foreignKeyConstraintSource` | `FmxSQLColumnReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLForeignKeyConstraint,
-	#superclass : #FmxSQLConstraint,
+	#name : 'FmxSQLForeignKeyConstraint',
+	#superclass : 'FmxSQLConstraint',
 	#instVars : [
 		'#outgoingForeignKeyColumnReferences => FMMany type: #FmxSQLColumnReference opposite: #foreignKeyConstraintSource'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLForeignKeyConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ForeignKeyConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLForeignKeyConstraint >> addOutgoingForeignKeyColumnReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingForeignKeyColumnReferences add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLForeignKeyConstraint >> isForeignKeyConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLForeignKeyConstraint >> outgoingForeignKeyColumnReferences [
 	"Relation named: #outgoingForeignKeyColumnReferences type: #FmxSQLColumnReference opposite: #foreignKeyConstraintSource"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingForeignKeyColumnReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLForeignKeyConstraint >> outgoingForeignKeyColumnReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingForeignKeyColumnReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLForeignTable.class.st b/src/FamixNGSQL/FmxSQLForeignTable.class.st
index ea4fbd4b..71c1e324 100644
--- a/src/FamixNGSQL/FmxSQLForeignTable.class.st
+++ b/src/FamixNGSQL/FmxSQLForeignTable.class.st
@@ -1,17 +1,21 @@
 "
 I am a foreign table, that is to say, my data source is not inside the database.
+
+
 "
 Class {
-	#name : #FmxSQLForeignTable,
-	#superclass : #FmxSQLTable,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLForeignTable',
+	#superclass : 'FmxSQLTable',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLForeignTable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ForeignTable super: #FmxSQLTable>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLFromClause.class.st b/src/FamixNGSQL/FmxSQLFromClause.class.st
index 64e82fba..224c5bf6 100644
--- a/src/FamixNGSQL/FmxSQLFromClause.class.st
+++ b/src/FamixNGSQL/FmxSQLFromClause.class.st
@@ -1,26 +1,56 @@
 "
 I am a from clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLFromClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLFromClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLFromClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #FromClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLFromClause >> isFromClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLGroupByClause.class.st b/src/FamixNGSQL/FmxSQLGroupByClause.class.st
index 43498d2a..118a6354 100644
--- a/src/FamixNGSQL/FmxSQLGroupByClause.class.st
+++ b/src/FamixNGSQL/FmxSQLGroupByClause.class.st
@@ -1,26 +1,55 @@
 "
 I am a group by clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLGroupByClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLGroupByClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLGroupByClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #GroupByClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLGroupByClause >> isGroupByClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLHavingClause.class.st b/src/FamixNGSQL/FmxSQLHavingClause.class.st
index 86c5d1a3..87f329c1 100644
--- a/src/FamixNGSQL/FmxSQLHavingClause.class.st
+++ b/src/FamixNGSQL/FmxSQLHavingClause.class.st
@@ -1,26 +1,55 @@
 "
 I am a having clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLHavingClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLHavingClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLHavingClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #HavingClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLHavingClause >> isHavingClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLInsertQuery.class.st b/src/FamixNGSQL/FmxSQLInsertQuery.class.st
index bcff2091..02097c93 100644
--- a/src/FamixNGSQL/FmxSQLInsertQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLInsertQuery.class.st
@@ -1,19 +1,32 @@
 "
 I am an INSERT query.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | `parentQuery` | `FmxSQLDerivedTable` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLInsertQuery,
-	#superclass : #FmxSQLCRUDQuery,
+	#name : 'FmxSQLInsertQuery',
+	#superclass : 'FmxSQLCRUDQuery',
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLInsertQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #InsertQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLIntersectClause.class.st b/src/FamixNGSQL/FmxSQLIntersectClause.class.st
index 8d63d2f4..11b99fe9 100644
--- a/src/FamixNGSQL/FmxSQLIntersectClause.class.st
+++ b/src/FamixNGSQL/FmxSQLIntersectClause.class.st
@@ -1,26 +1,47 @@
 "
 I am an intersect clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLIntersectClause,
-	#superclass : #FmxSQLClause,
+	#name : 'FmxSQLIntersectClause',
+	#superclass : 'FmxSQLClause',
 	#traits : 'FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
 	#classTraits : 'FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLIntersectClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #IntersectClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLIntersectClause >> isIntersectClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLIntoClause.class.st b/src/FamixNGSQL/FmxSQLIntoClause.class.st
index ff6684c0..868f19d4 100644
--- a/src/FamixNGSQL/FmxSQLIntoClause.class.st
+++ b/src/FamixNGSQL/FmxSQLIntoClause.class.st
@@ -1,19 +1,38 @@
 "
 I am an into clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLIntoClause,
-	#superclass : #FmxSQLClause,
+	#name : 'FmxSQLIntoClause',
+	#superclass : 'FmxSQLClause',
 	#traits : 'FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference',
 	#classTraits : 'FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLIntoClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #IntoClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLJoinClause.class.st b/src/FamixNGSQL/FmxSQLJoinClause.class.st
index be9fdb33..b33a1e60 100644
--- a/src/FamixNGSQL/FmxSQLJoinClause.class.st
+++ b/src/FamixNGSQL/FmxSQLJoinClause.class.st
@@ -1,24 +1,29 @@
 "
 I am a join clause
+
+
 "
 Class {
-	#name : #FmxSQLJoinClause,
-	#superclass : #FmxSQLClause,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLJoinClause',
+	#superclass : 'FmxSQLClause',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLJoinClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #JoinClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLJoinClause >> isJoinClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLLimitClause.class.st b/src/FamixNGSQL/FmxSQLLimitClause.class.st
index 34e78fe9..b83d2536 100644
--- a/src/FamixNGSQL/FmxSQLLimitClause.class.st
+++ b/src/FamixNGSQL/FmxSQLLimitClause.class.st
@@ -1,24 +1,29 @@
 "
 I am a limit clause
+
+
 "
 Class {
-	#name : #FmxSQLLimitClause,
-	#superclass : #FmxSQLClause,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLLimitClause',
+	#superclass : 'FmxSQLClause',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLLimitClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #LimitClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLLimitClause >> isLimitClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLLocalVariable.class.st b/src/FamixNGSQL/FmxSQLLocalVariable.class.st
index 7c33b940..eb17eb1a 100644
--- a/src/FamixNGSQL/FmxSQLLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLLocalVariable.class.st
@@ -1,60 +1,103 @@
 "
 I am a local variable of a stored procedure. I have a type.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentBehaviouralEntity` | `FamixTLocalVariable` | `localVariables` | `FamixTWithLocalVariables` | Behavioural entity declaring this local variable. belongsTo implementation|
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `typing` | `FamixTTypedEntity` | `typedEntity` | `FamixTEntityTyping` | Association linking this entity to its declared type.|
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FmxSQLLocalVariable` | `localVariable` | `FmxSQLLocalVariableAccess` | |
+| `incomingAccesses` | `FamixTAccessible` | `candidates` | `FamixTAccess` | All Famix accesses pointing to this structural entity|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+| `type` | `FmxSQLLocalVariable` | `localVariables` | `FmxSQLAbstractType` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isStub` | `Boolean` | false | Flag true if the entity attributes are incomplete, either because the entity is missing or not imported.|
+| `name` | `String` | nil | Basic name of the entity, not full reference.|
+
 "
 Class {
-	#name : #FmxSQLLocalVariable,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLLocalVariable',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FamixTAccessible + FamixTLocalVariable',
 	#classTraits : 'FamixTAccessible classTrait + FamixTLocalVariable classTrait',
 	#instVars : [
-		'#type => FMOne type: #FmxSQLAbstractType opposite: #localVariables',
-		'#accesses => FMMany type: #FmxSQLLocalVariableAccess opposite: #localVariable'
+		'#accesses => FMMany type: #FmxSQLLocalVariableAccess opposite: #localVariable',
+		'#type => FMOne type: #FmxSQLAbstractType opposite: #localVariables'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLLocalVariable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #LocalVariable super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariable >> accesses [
 	"Relation named: #accesses type: #FmxSQLLocalVariableAccess opposite: #localVariable"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ accesses
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariable >> accesses: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	accesses value: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLLocalVariable >> addAccess: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self accesses add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariable >> type [
 	"Relation named: #type type: #FmxSQLAbstractType opposite: #localVariables"
 
+	<ignoreForCoverage>
 	<generated>
 	^ type
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariable >> type: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	type := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st b/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
index 3fa1b9d8..cfb1c390 100644
--- a/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLLocalVariableAccess.class.st
@@ -1,45 +1,81 @@
 "
 I am an access to a local variable in a procedure.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+| `localVariable` | `FmxSQLLocalVariableAccess` | `accesses` | `FmxSQLLocalVariable` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
 "
 Class {
-	#name : #FmxSQLLocalVariableAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLLocalVariableAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTAccess classTrait + FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
 		'#localVariable => FMOne type: #FmxSQLLocalVariable opposite: #accesses'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLLocalVariableAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #LocalVariableAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLLocalVariableAccess >> isLocalVariableAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariableAccess >> localVariable [
 	"Relation named: #localVariable type: #FmxSQLLocalVariable opposite: #accesses"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ localVariable
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLLocalVariableAccess >> localVariable: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	localVariable := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLModel.class.st b/src/FamixNGSQL/FmxSQLModel.class.st
index 80ec13ed..c40fe116 100644
--- a/src/FamixNGSQL/FmxSQLModel.class.st
+++ b/src/FamixNGSQL/FmxSQLModel.class.st
@@ -1,18 +1,26 @@
 Class {
-	#name : #FmxSQLModel,
-	#superclass : #MooseModel,
-	#category : #'FamixNGSQL-Model'
+	#name : 'FmxSQLModel',
+	#superclass : 'MooseModel',
+	#traits : 'FmxSQLTEntityCreator',
+	#classTraits : 'FmxSQLTEntityCreator classTrait',
+	#category : 'FamixNGSQL-Model',
+	#package : 'FamixNGSQL',
+	#tag : 'Model'
 }
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLModel class >> allSubmetamodelsPackagesNames [
+
+	<ignoreForCoverage>
 	<generated>
 	^ #(#'Moose-Query' #'Famix-Traits')
 ]
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLModel class >> annotation [
-	<FMClass: #FmxSQLModel super: #MooseModel>
+
+	<ignoreForCoverage>
+	<FMClass: #Model super: #MooseModel>
 	<package: #FamixNGSQL>
 	<generated>
 ]
diff --git a/src/FamixNGSQL/FmxSQLNamedEntity.class.st b/src/FamixNGSQL/FmxSQLNamedEntity.class.st
index cf738b6f..15c77015 100644
--- a/src/FamixNGSQL/FmxSQLNamedEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLNamedEntity.class.st
@@ -1,16 +1,54 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isStub` | `Boolean` | false | Flag true if the entity attributes are incomplete, either because the entity is missing or not imported.|
+| `name` | `String` | nil | Basic name of the entity, not full reference.|
+
+"
 Class {
-	#name : #FmxSQLNamedEntity,
-	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTNamedEntity',
-	#classTraits : 'FamixTNamedEntity classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLNamedEntity',
+	#superclass : 'FmxSQLEntity',
+	#traits : 'FamixTCanBeStub + FamixTNamedEntity + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTCanBeStub classTrait + FamixTNamedEntity classTrait + TEntityMetaLevelDependency classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLNamedEntity class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #NamedEntity super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
+	<abstract>
+]
+
+{ #category : 'testing' }
+FmxSQLNamedEntity class >> isAbstract [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self == FmxSQLNamedEntity
+]
+
+{ #category : 'testing' }
+FmxSQLNamedEntity >> isNamedEntity [
+
+	<ignoreForCoverage>
+	<generated>
+	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLNamespace.class.st b/src/FamixNGSQL/FmxSQLNamespace.class.st
index 9aa4dabf..0c699118 100644
--- a/src/FamixNGSQL/FmxSQLNamespace.class.st
+++ b/src/FamixNGSQL/FmxSQLNamespace.class.st
@@ -1,44 +1,105 @@
 "
 I am a namespace. I hold entities to define a name scope where name duplicates are forbidden.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `namespaceEntities` | `FmxSQLNamespace` | `parentNamespace` | `FmxSQLTNamedEntity` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLNamespace` | `namespace` | `FmxSQLNamespaceReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isStub` | `Boolean` | false | Flag true if the entity attributes are incomplete, either because the entity is missing or not imported.|
+| `name` | `String` | nil | Basic name of the entity, not full reference.|
+
 "
 Class {
-	#name : #FmxSQLNamespace,
-	#superclass : #FmxSQLStructuralEntity,
+	#name : 'FmxSQLNamespace',
+	#superclass : 'FmxSQLStructuralEntity',
 	#traits : 'FamixTNamespace',
 	#classTraits : 'FamixTNamespace classTrait',
 	#instVars : [
+		'#namespaceEntities => FMMany type: #FmxSQLTNamedEntity opposite: #parentNamespace',
 		'#references => FMMany type: #FmxSQLNamespaceReference opposite: #namespace'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLNamespace class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Namespace super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
+FmxSQLNamespace >> addNamespaceEntity: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self namespaceEntities add: anObject
+]
+
+{ #category : 'adding' }
 FmxSQLNamespace >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
+FmxSQLNamespace >> namespaceEntities [
+	"Relation named: #namespaceEntities type: #FmxSQLTNamedEntity opposite: #parentNamespace"
+
+	<ignoreForCoverage>
+	<generated>
+	<derived>
+	^ namespaceEntities
+]
+
+{ #category : 'accessing' }
+FmxSQLNamespace >> namespaceEntities: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	namespaceEntities value: anObject
+]
+
+{ #category : 'accessing' }
 FmxSQLNamespace >> references [
 	"Relation named: #references type: #FmxSQLNamespaceReference opposite: #namespace"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLNamespace >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLNamespaceReference.class.st b/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
index 8dca074f..4557c282 100644
--- a/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
+++ b/src/FamixNGSQL/FmxSQLNamespaceReference.class.st
@@ -1,54 +1,77 @@
 "
 I model a reference made to a namespace from source code.
+
+## Relations
+======================
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `namespace` | `FmxSQLNamespaceReference` | `references` | `FmxSQLNamespace` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `source` | `FmxSQLNamespaceReference` | `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLNamespaceReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLNamespaceReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
-		'#source => FMOne type: #FmxSQLTWithNamespaceReference opposite: #outgoingNamespaceReference',
-		'#namespace => FMOne type: #FmxSQLNamespace opposite: #references'
+		'#namespace => FMOne type: #FmxSQLNamespace opposite: #references',
+		'#source => FMOne type: #FmxSQLTWithNamespaceReference opposite: #outgoingNamespaceReference'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLNamespaceReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #NamespaceReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLNamespaceReference >> namespace [
 	"Relation named: #namespace type: #FmxSQLNamespace opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ namespace
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLNamespaceReference >> namespace: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	namespace := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLNamespaceReference >> source [
 	"Relation named: #source type: #FmxSQLTWithNamespaceReference opposite: #outgoingNamespaceReference"
 
+	<ignoreForCoverage>
 	<generated>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLNamespaceReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st b/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
index 36b1cee0..186948d6 100644
--- a/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLNewLocalVariable.class.st
@@ -1,19 +1,32 @@
 "
 I model the special NEW local variable accessible from inside trigger stored procedure.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLNewLocalVariable,
-	#superclass : #FmxSQLLocalVariable,
+	#name : 'FmxSQLNewLocalVariable',
+	#superclass : 'FmxSQLLocalVariable',
 	#traits : 'FmxSQLColumnsContainer',
 	#classTraits : 'FmxSQLColumnsContainer classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLNewLocalVariable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #NewLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st b/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
index 97ce21c2..47334dd9 100644
--- a/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLNotNullConstraint.class.st
@@ -1,24 +1,29 @@
 "
 I represent a NOT NULL constraint as defined in SQL standard.
+
+
 "
 Class {
-	#name : #FmxSQLNotNullConstraint,
-	#superclass : #FmxSQLConstraint,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLNotNullConstraint',
+	#superclass : 'FmxSQLConstraint',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLNotNullConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #NotNullConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLNotNullConstraint >> isNotNullConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st b/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
index 05065ee7..3e1e7ef3 100644
--- a/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLOldLocalVariable.class.st
@@ -1,19 +1,32 @@
 "
 I model the special OLD local variable accessible from inside trigger stored procedure.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLOldLocalVariable,
-	#superclass : #FmxSQLLocalVariable,
+	#name : 'FmxSQLOldLocalVariable',
+	#superclass : 'FmxSQLLocalVariable',
 	#traits : 'FmxSQLColumnsContainer',
 	#classTraits : 'FmxSQLColumnsContainer classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLOldLocalVariable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #OldLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLOnConflictClause.class.st b/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
index 90f0229e..4bc214a1 100644
--- a/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
+++ b/src/FamixNGSQL/FmxSQLOnConflictClause.class.st
@@ -1,24 +1,29 @@
 "
 I am a on conflict clause
+
+
 "
 Class {
-	#name : #FmxSQLOnConflictClause,
-	#superclass : #FmxSQLClause,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLOnConflictClause',
+	#superclass : 'FmxSQLClause',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLOnConflictClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #OnConflictClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLOnConflictClause >> isOnConflictClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLOrderByClause.class.st b/src/FamixNGSQL/FmxSQLOrderByClause.class.st
index 55590999..30db8b87 100644
--- a/src/FamixNGSQL/FmxSQLOrderByClause.class.st
+++ b/src/FamixNGSQL/FmxSQLOrderByClause.class.st
@@ -1,26 +1,55 @@
 "
 I am an order by clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLOrderByClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLOrderByClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLOrderByClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #OrderByClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLOrderByClause >> isOrderByClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLParameter.class.st b/src/FamixNGSQL/FmxSQLParameter.class.st
index 4bfca554..ce653164 100644
--- a/src/FamixNGSQL/FmxSQLParameter.class.st
+++ b/src/FamixNGSQL/FmxSQLParameter.class.st
@@ -1,37 +1,111 @@
 "
 I am a parameter of a stored procedure. I have a type.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentBehaviouralEntity` | `FamixTParameter` | `parameters` | `FamixTWithParameters` | Behavioural entity containing this parameter. belongsTo implementation|
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `typing` | `FamixTTypedEntity` | `typedEntity` | `FamixTEntityTyping` | Association linking this entity to its declared type.|
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `incomingAccesses` | `FamixTAccessible` | `candidates` | `FamixTAccess` | All Famix accesses pointing to this structural entity|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+| `type` | `FmxSQLParameter` | `parameters` | `FmxSQLAbstractType` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isStub` | `Boolean` | false | Flag true if the entity attributes are incomplete, either because the entity is missing or not imported.|
+| `mode` | `String` | nil | |
+| `name` | `String` | nil | Basic name of the entity, not full reference.|
+| `position` | `Number` | nil | |
+
 "
 Class {
-	#name : #FmxSQLParameter,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLParameter',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FamixTAccessible + FamixTParameter',
 	#classTraits : 'FamixTAccessible classTrait + FamixTParameter classTrait',
 	#instVars : [
+		'#mode => FMProperty',
+		'#position => FMProperty',
 		'#type => FMOne type: #FmxSQLAbstractType opposite: #parameters'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLParameter class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Parameter super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
+FmxSQLParameter >> mode [
+
+	<FMProperty: #mode type: #String>
+	<ignoreForCoverage>
+	<generated>
+	^ mode
+]
+
+{ #category : 'accessing' }
+FmxSQLParameter >> mode: anObject [
+	<ignoreForCoverage>
+	<generated>
+	mode := anObject
+]
+
+{ #category : 'accessing' }
+FmxSQLParameter >> position [
+
+	<FMProperty: #position type: #Number>
+	<ignoreForCoverage>
+	<generated>
+	^ position
+]
+
+{ #category : 'accessing' }
+FmxSQLParameter >> position: anObject [
+	<ignoreForCoverage>
+	<generated>
+	position := anObject
+]
+
+{ #category : 'accessing' }
 FmxSQLParameter >> type [
 	"Relation named: #type type: #FmxSQLAbstractType opposite: #parameters"
 
+	<ignoreForCoverage>
 	<generated>
 	^ type
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLParameter >> type: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	type := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLParameterAccess.class.st b/src/FamixNGSQL/FmxSQLParameterAccess.class.st
index 08c14302..e7de2756 100644
--- a/src/FamixNGSQL/FmxSQLParameterAccess.class.st
+++ b/src/FamixNGSQL/FmxSQLParameterAccess.class.st
@@ -1,26 +1,58 @@
 "
 I am an access to a stored procedure parameter.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accessor` | `FamixTAccess` | `accesses` | `FamixTWithAccesses` | Behavioural entity making the access to the variable. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTAccess` | `incomingAccesses` | `FamixTAccessible` | Variables that cas be the accessed variable. to-side of the association. Most of the time it will be only one variable, but some languages might have candidates such as Python.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isWrite` | `Boolean` | false | Write access|
+
 "
 Class {
-	#name : #FmxSQLParameterAccess,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLParameterAccess',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTAccess',
 	#classTraits : 'FamixTAccess classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLParameterAccess class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ParameterAccess super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLParameterAccess >> isParameterAccess [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st b/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
index 06bc972b..37476acd 100644
--- a/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLPrimaryKeyConstraint.class.st
@@ -1,24 +1,29 @@
 "
 I represent a PRIMARY KEY constraint as defined in SQL standard.
+
+
 "
 Class {
-	#name : #FmxSQLPrimaryKeyConstraint,
-	#superclass : #FmxSQLConstraint,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLPrimaryKeyConstraint',
+	#superclass : 'FmxSQLConstraint',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLPrimaryKeyConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #PrimaryKeyConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLPrimaryKeyConstraint >> isPrimaryKeyConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLQualifiedReference.class.st b/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
index 0d1d430d..b28e268c 100644
--- a/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
+++ b/src/FamixNGSQL/FmxSQLQualifiedReference.class.st
@@ -9,45 +9,55 @@ For example, namespace.table.column is modeled as 3 references:
 together grouped in a QualifiedReference.
 
 One can ask the #qualifiedReference to any reference in the system, it will be set if it has one.
+
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLQualifiedReference` | `qualifiedReference` | `FmxSQLTWithQualifiedReference` | |
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLQualifiedReference,
-	#superclass : #FmxSQLEntity,
+	#name : 'FmxSQLQualifiedReference',
+	#superclass : 'FmxSQLEntity',
 	#traits : 'FamixTSourceEntity',
 	#classTraits : 'FamixTSourceEntity classTrait',
 	#instVars : [
 		'#references => FMMany type: #FmxSQLTWithQualifiedReference opposite: #qualifiedReference'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLQualifiedReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #QualifiedReference super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
-]
-
-{ #category : #adding }
-FmxSQLQualifiedReference >> addReference: anObject [
-	<generated>
-	^ self references add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLQualifiedReference >> references [
 	"Relation named: #references type: #FmxSQLTWithQualifiedReference opposite: #qualifiedReference"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLQualifiedReference >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st b/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
index ff343d00..73a21d87 100644
--- a/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
+++ b/src/FamixNGSQL/FmxSQLRecordLocalVariable.class.st
@@ -1,37 +1,57 @@
 "
 I am local variable of type record. I can contain columns. These columns are set when a SELECT INTO is encountered.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `queryBoundTo` | `FmxSQLRecordLocalVariable` | `recordLocalVariables` | `FmxSQLSelectQuery` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLRecordLocalVariable,
-	#superclass : #FmxSQLLocalVariable,
+	#name : 'FmxSQLRecordLocalVariable',
+	#superclass : 'FmxSQLLocalVariable',
 	#traits : 'FmxSQLColumnsContainer',
 	#classTraits : 'FmxSQLColumnsContainer classTrait',
 	#instVars : [
 		'#queryBoundTo => FMOne type: #FmxSQLSelectQuery opposite: #recordLocalVariables'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLRecordLocalVariable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #RecordLocalVariable super: #FmxSQLLocalVariable>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLRecordLocalVariable >> queryBoundTo [
 	"Relation named: #queryBoundTo type: #FmxSQLSelectQuery opposite: #recordLocalVariables"
 
+	<ignoreForCoverage>
 	<generated>
 	^ queryBoundTo
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLRecordLocalVariable >> queryBoundTo: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	queryBoundTo := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLReference.class.st b/src/FamixNGSQL/FmxSQLReference.class.st
index 16f2bec0..9c85d08c 100644
--- a/src/FamixNGSQL/FmxSQLReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReference.class.st
@@ -1,69 +1,78 @@
 "
 I am an abstract object that represent a reference made to another entity in the source code a behavioural entity.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `belongsToGroup` | `FmxSQLReference` | `references` | `FmxSQLReferencesGroup` | |
+| `storedProcedureContainer` | `FmxSQLReference` | `arguments` | `FmxSQLStoredProcedureCall` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLReference,
-	#superclass : #FmxSQLAssociation,
-	#traits : 'FmxSQLTArgument',
-	#classTraits : 'FmxSQLTArgument classTrait',
+	#name : 'FmxSQLReference',
+	#superclass : 'FmxSQLAssociation',
+	#traits : 'FamixTSourceEntity + FmxSQLTArgument',
+	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTArgument classTrait',
 	#instVars : [
 		'#belongsToGroup => FMOne type: #FmxSQLReferencesGroup opposite: #references',
 		'#storedProcedureContainer => FMOne type: #FmxSQLStoredProcedureCall opposite: #arguments'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Reference super: #FmxSQLAssociation>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReference >> belongsToGroup [
 	"Relation named: #belongsToGroup type: #FmxSQLReferencesGroup opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ belongsToGroup
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReference >> belongsToGroup: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	belongsToGroup := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLReference >> belongsToGroupGroup [
-	<generated>
-	<navigation: 'BelongsToGroup'>
-	^ MooseSpecializedGroup with: self belongsToGroup
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReference >> storedProcedureContainer [
 	"Relation named: #storedProcedureContainer type: #FmxSQLStoredProcedureCall opposite: #arguments"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ storedProcedureContainer
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReference >> storedProcedureContainer: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	storedProcedureContainer := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLReference >> storedProcedureContainerGroup [
-	<generated>
-	<navigation: 'StoredProcedureContainer'>
-	^ MooseSpecializedGroup with: self storedProcedureContainer
-]
diff --git a/src/FamixNGSQL/FmxSQLReferencesGroup.class.st b/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
index f908e424..402cb953 100644
--- a/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
+++ b/src/FamixNGSQL/FmxSQLReferencesGroup.class.st
@@ -7,75 +7,99 @@ For example I can appear in select query like:
 
 SELECT fct1(id)+fct2(id) AS id -- <-- Here a reference group is created containing ref to fct1, fct2
 FROM table
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLReferencesGroup` | `belongsToGroup` | `FmxSQLReference` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `incomingReferencesGroupReference` | `FmxSQLReferencesGroup` | `referencesGroup` | `FmxSQLTReferencesGroupReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
 "
 Class {
-	#name : #FmxSQLReferencesGroup,
-	#superclass : #FmxSQLEntity,
-	#traits : 'FamixTSourceAnchor + TEntityMetaLevelDependency',
-	#classTraits : 'FamixTSourceAnchor classTrait + TEntityMetaLevelDependency classTrait',
+	#name : 'FmxSQLReferencesGroup',
+	#superclass : 'FmxSQLEntity',
+	#traits : 'FamixTSourceEntity + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceEntity classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
-		'#references => FMMany type: #FmxSQLReference opposite: #belongsToGroup',
-		'#incomingReferencesGroupReference => FMMany type: #FmxSQLTReferencesGroupReference opposite: #referencesGroup'
+		'#incomingReferencesGroupReference => FMMany type: #FmxSQLTReferencesGroupReference opposite: #referencesGroup',
+		'#references => FMMany type: #FmxSQLReference opposite: #belongsToGroup'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLReferencesGroup class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ReferencesGroup super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLReferencesGroup >> addIncomingReferencesGroupReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self incomingReferencesGroupReference add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLReferencesGroup >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReferencesGroup >> incomingReferencesGroupReference [
 	"Relation named: #incomingReferencesGroupReference type: #FmxSQLTReferencesGroupReference opposite: #referencesGroup"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ incomingReferencesGroupReference
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReferencesGroup >> incomingReferencesGroupReference: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	incomingReferencesGroupReference value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReferencesGroup >> references [
 	"Relation named: #references type: #FmxSQLReference opposite: #belongsToGroup"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLReferencesGroup >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLReferencesGroup >> referencesGroup [
-	<generated>
-	<navigation: 'References'>
-	^ MooseSpecializedGroup withAll: self references asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
index b0813d82..92ee7d95 100644
--- a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
@@ -1,19 +1,42 @@
 "
 TODO
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLTReferencesGroupReference` | `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | |
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLTReferencesGroupReference` | `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `referencesGroup` | `FmxSQLTReferencesGroupReference` | `incomingReferencesGroupReference` | `FmxSQLReferencesGroup` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLReferencesGroupReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLReferencesGroupReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTReferencesGroupReference + TEntityMetaLevelDependency',
 	#classTraits : 'FmxSQLTReferencesGroupReference classTrait + TEntityMetaLevelDependency classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLReferencesGroupReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ReferencesGroupReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLReturningClause.class.st b/src/FamixNGSQL/FmxSQLReturningClause.class.st
index 68500014..5d914167 100644
--- a/src/FamixNGSQL/FmxSQLReturningClause.class.st
+++ b/src/FamixNGSQL/FmxSQLReturningClause.class.st
@@ -1,26 +1,48 @@
 "
 I am a returning clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLReturningClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithReferencesGroupReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithReferencesGroupReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLReturningClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithReferencesGroupReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithReferencesGroupReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLReturningClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ReturningClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLReturningClause >> isReturningClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLSelectClause.class.st b/src/FamixNGSQL/FmxSQLSelectClause.class.st
index 460db120..c4bda1a5 100644
--- a/src/FamixNGSQL/FmxSQLSelectClause.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectClause.class.st
@@ -1,26 +1,50 @@
 "
 I am a select clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLSelectClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLSelectClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSelectClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SelectClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLSelectClause >> isSelectClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLSelectQuery.class.st b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
index 552b9ca5..746cd587 100644
--- a/src/FamixNGSQL/FmxSQLSelectQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
@@ -1,69 +1,91 @@
 "
 I am a SELECT query.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `viewDefining` | `FmxSQLSelectQuery` | `query` | `FmxSQLView` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | `parentQuery` | `FmxSQLDerivedTable` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `recordLocalVariables` | `FmxSQLSelectQuery` | `queryBoundTo` | `FmxSQLRecordLocalVariable` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLSelectQuery,
-	#superclass : #FmxSQLCRUDQuery,
+	#name : 'FmxSQLSelectQuery',
+	#superclass : 'FmxSQLCRUDQuery',
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
 	#instVars : [
-		'#viewDefining => FMOne type: #FmxSQLView opposite: #query',
-		'#recordLocalVariables => FMMany type: #FmxSQLRecordLocalVariable opposite: #queryBoundTo'
+		'#recordLocalVariables => FMMany type: #FmxSQLRecordLocalVariable opposite: #queryBoundTo',
+		'#viewDefining => FMOne type: #FmxSQLView opposite: #query'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSelectQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SelectQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLSelectQuery >> addRecordLocalVariable: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self recordLocalVariables add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLSelectQuery >> recordLocalVariables [
 	"Relation named: #recordLocalVariables type: #FmxSQLRecordLocalVariable opposite: #queryBoundTo"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ recordLocalVariables
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLSelectQuery >> recordLocalVariables: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	recordLocalVariables value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLSelectQuery >> viewDefining [
 	"Relation named: #viewDefining type: #FmxSQLView opposite: #query"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	<derived>
 	^ viewDefining
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLSelectQuery >> viewDefining: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	viewDefining := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLSelectQuery >> viewDefiningGroup [
-	<generated>
-	<navigation: 'ViewDefining'>
-	^ MooseSpecializedGroup with: self viewDefining
-]
diff --git a/src/FamixNGSQL/FmxSQLSetClause.class.st b/src/FamixNGSQL/FmxSQLSetClause.class.st
index d07d3dde..ac10917c 100644
--- a/src/FamixNGSQL/FmxSQLSetClause.class.st
+++ b/src/FamixNGSQL/FmxSQLSetClause.class.st
@@ -1,26 +1,43 @@
 "
 I am a set clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+
+
+
 "
 Class {
-	#name : #FmxSQLSetClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLSetClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSetClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SetClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLSetClause >> isSetClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLSourceAnchor.class.st b/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
index 516ef8ee..1129bc2f 100644
--- a/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceAnchor.class.st
@@ -1,16 +1,39 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+
+
+
+"
 Class {
-	#name : #FmxSQLSourceAnchor,
-	#superclass : #FmxSQLEntity,
+	#name : 'FmxSQLSourceAnchor',
+	#superclass : 'FmxSQLEntity',
 	#traits : 'FamixTSourceAnchor',
 	#classTraits : 'FamixTSourceAnchor classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSourceAnchor class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SourceAnchor super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
+	<abstract>
+]
+
+{ #category : 'testing' }
+FmxSQLSourceAnchor class >> isAbstract [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self == FmxSQLSourceAnchor
 ]
diff --git a/src/FamixNGSQL/FmxSQLSourceLanguage.class.st b/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
index 99b53d2b..9c7200f3 100644
--- a/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceLanguage.class.st
@@ -1,16 +1,30 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourcedEntities` | `FamixTSourceLanguage` | `declaredSourceLanguage` | `FamixTWithSourceLanguages` | References to the entities saying explicitly that are written in this language.|
+
+
+
+"
 Class {
-	#name : #FmxSQLSourceLanguage,
-	#superclass : #FmxSQLEntity,
+	#name : 'FmxSQLSourceLanguage',
+	#superclass : 'FmxSQLEntity',
 	#traits : 'FamixTSourceLanguage',
 	#classTraits : 'FamixTSourceLanguage classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSourceLanguage class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SourceLanguage super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st b/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
index ce5d3d65..1deba38e 100644
--- a/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
+++ b/src/FamixNGSQL/FmxSQLSourceTextAnchor.class.st
@@ -1,16 +1,36 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `source` | `String` | nil | Actual source code of the source entity|
+
+"
 Class {
-	#name : #FmxSQLSourceTextAnchor,
-	#superclass : #FmxSQLSourceAnchor,
+	#name : 'FmxSQLSourceTextAnchor',
+	#superclass : 'FmxSQLSourceAnchor',
 	#traits : 'FamixTHasImmediateSource',
 	#classTraits : 'FamixTHasImmediateSource classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSourceTextAnchor class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SourceTextAnchor super: #FmxSQLSourceAnchor>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLSourcedEntity.class.st b/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
index 68b64409..0643db9b 100644
--- a/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLSourcedEntity.class.st
@@ -1,16 +1,39 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+
+"
 Class {
-	#name : #FmxSQLSourcedEntity,
-	#superclass : #FmxSQLEntity,
+	#name : 'FmxSQLSourcedEntity',
+	#superclass : 'FmxSQLEntity',
 	#traits : 'FamixTSourceEntity',
 	#classTraits : 'FamixTSourceEntity classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLSourcedEntity class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #SourcedEntity super: #FmxSQLEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
+	<abstract>
+]
+
+{ #category : 'testing' }
+FmxSQLSourcedEntity class >> isAbstract [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self == FmxSQLSourcedEntity
 ]
diff --git a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
index 92e78413..1e88fc78 100644
--- a/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
+++ b/src/FamixNGSQL/FmxSQLStoredProcedure.class.st
@@ -1,66 +1,189 @@
 "
 I am a stored procedure. That is to say, a function that is defined inside the database.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentNamespace` | `FmxSQLTNamedEntity` | `namespaceEntities` | `FmxSQLNamespace` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `aliases` | `FmxSQLTWithAlias` | `parentBehaviouralEntity` | `FmxSQLAlias` | |
+| `cursors` | `FmxSQLTWithCursor` | `parentBehaviouralEntity` | `FmxSQLCursor` | |
+| `localVariables` | `FamixTWithLocalVariables` | `parentBehaviouralEntity` | `FamixTLocalVariable` | Variables locally defined by this behaviour.|
+| `parameters` | `FamixTWithParameters` | `parentBehaviouralEntity` | `FamixTParameter` | List of formal parameters declared by this behaviour.|
+| `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingCursorReferences` | `FmxSQLTWithCursorReference` | `source` | `FmxSQLCursorReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferences` | `FamixTWithReferences` | `referencer` | `FamixTReference` | References from this entity to other entities.|
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `incomingInvocations` | `FamixTInvocable` | `candidates` | `FamixTInvocation` | Incoming invocations from other behaviours computed by the candidate operator.|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+| `checkConstraintsCalling` | `FmxSQLStoredProcedure` | `storedProceduresCalled` | `FmxSQLCheckConstraint` | |
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+| `exclusionConstraintsCalling` | `FmxSQLStoredProcedure` | `storedProceduresCalled` | `FmxSQLExclusionConstraint` | |
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+| `returnType` | `FmxSQLStoredProcedure` | `storedProceduresReturning` | `FmxSQLAbstractType` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `languageName` | `String` | nil | |
+| `postgresOid` | `Number` | nil | |
+| `source` | `String` | nil | Actual source code of the source entity|
+
 "
 Class {
-	#name : #FmxSQLStoredProcedure,
-	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FamixTInvocable + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithAccesses + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithImmediateSource + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTInvocable classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithImmediateSource classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#name : 'FmxSQLStoredProcedure',
+	#superclass : 'FmxSQLNamedEntity',
+	#traits : 'FamixTHasImmediateSource + FamixTInvocable + FamixTWithAccesses + FamixTWithInvocations + FamixTWithLocalVariables + FamixTWithParameters + FamixTWithReferences + FmxSQLBehaviouralEntity + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithAlias + FmxSQLTWithColumnReference + FmxSQLTWithCursor + FmxSQLTWithCursorReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTHasImmediateSource classTrait + FamixTInvocable classTrait + FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FamixTWithLocalVariables classTrait + FamixTWithParameters classTrait + FamixTWithReferences classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithAlias classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithCursor classTrait + FmxSQLTWithCursorReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
 	#instVars : [
 		'#checkConstraintsCalling => FMMany type: #FmxSQLCheckConstraint opposite: #storedProceduresCalled',
+		'#exclusionConstraintsCalling => FMMany type: #FmxSQLExclusionConstraint opposite: #storedProceduresCalled',
+		'#languageName => FMProperty',
+		'#postgresOid => FMProperty',
 		'#returnType => FMOne type: #FmxSQLAbstractType opposite: #storedProceduresReturning'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLStoredProcedure class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #StoredProcedure super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLStoredProcedure >> addCheckConstraintsCalling: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self checkConstraintsCalling add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'adding' }
+FmxSQLStoredProcedure >> addExclusionConstraintsCalling: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self exclusionConstraintsCalling add: anObject
+]
+
+{ #category : 'accessing' }
 FmxSQLStoredProcedure >> checkConstraintsCalling [
 	"Relation named: #checkConstraintsCalling type: #FmxSQLCheckConstraint opposite: #storedProceduresCalled"
 
+	<ignoreForCoverage>
 	<generated>
 	^ checkConstraintsCalling
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLStoredProcedure >> checkConstraintsCalling: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	checkConstraintsCalling value: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> exclusionConstraintsCalling [
+	"Relation named: #exclusionConstraintsCalling type: #FmxSQLExclusionConstraint opposite: #storedProceduresCalled"
+
+	<ignoreForCoverage>
+	<generated>
+	^ exclusionConstraintsCalling
+]
+
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> exclusionConstraintsCalling: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	exclusionConstraintsCalling value: anObject
+]
+
+{ #category : 'testing' }
 FmxSQLStoredProcedure >> isStoredProcedure [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> languageName [
+
+	<FMProperty: #languageName type: #String>
+	<ignoreForCoverage>
+	<generated>
+	^ languageName
+]
+
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> languageName: anObject [
+	<ignoreForCoverage>
+	<generated>
+	languageName := anObject
+]
+
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> postgresOid [
+
+	<FMProperty: #postgresOid type: #Number>
+	<ignoreForCoverage>
+	<generated>
+	^ postgresOid
+]
+
+{ #category : 'accessing' }
+FmxSQLStoredProcedure >> postgresOid: anObject [
+	<ignoreForCoverage>
+	<generated>
+	postgresOid := anObject
+]
+
+{ #category : 'accessing' }
 FmxSQLStoredProcedure >> returnType [
 	"Relation named: #returnType type: #FmxSQLAbstractType opposite: #storedProceduresReturning"
 
+	<ignoreForCoverage>
 	<generated>
 	^ returnType
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLStoredProcedure >> returnType: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	returnType := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st b/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
index 49c5340e..5a5d6a34 100644
--- a/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
+++ b/src/FamixNGSQL/FmxSQLStoredProcedureCall.class.st
@@ -1,58 +1,94 @@
 "
 I am a call to a stored procedure of the model.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `arguments` | `FmxSQLStoredProcedureCall` | `storedProcedureContainer` | `FmxSQLReference` | |
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `sender` | `FamixTInvocation` | `outgoingInvocations` | `FamixTWithInvocations` | Behavioural entity making the call. from-side of the association|
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `candidates` | `FamixTInvocation` | `incomingInvocations` | `FamixTInvocable` | List of candidate behavioural entities for receiving the invocation|
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `next` | `FamixTAssociation` | `previous` | `FamixTAssociation` | Next association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `previous` | `FamixTAssociation` | `next` | `FamixTAssociation` | Previous association in an ordered collection of associations. Currently not supported by the Moose importer|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+| `receiver` | `FamixTInvocation` | `receivingInvocations` | `FamixTInvocationsReceiver` | Named entity (variable, class...) receiving the invocation. to-side of the association|
+| `sourceAnchor` | `FamixTSourceEntity` | `element` | `FamixTSourceAnchor` | SourceAnchor entity linking to the original source code for this entity|
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `signature` | `String` | nil | Signature of the message being sent|
+
 "
 Class {
-	#name : #FmxSQLStoredProcedureCall,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLStoredProcedureCall',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FamixTInvocation + FmxSQLTWithQualifiedReference',
 	#classTraits : 'FamixTInvocation classTrait + FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
 		'#arguments => FMMany type: #FmxSQLReference opposite: #storedProcedureContainer'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLStoredProcedureCall class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #StoredProcedureCall super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLStoredProcedureCall >> addArgument: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self arguments add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLStoredProcedureCall >> arguments [
 	"Relation named: #arguments type: #FmxSQLReference opposite: #storedProcedureContainer"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ arguments
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLStoredProcedureCall >> arguments: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	arguments value: anObject
 ]
 
-{ #category : #navigation }
-FmxSQLStoredProcedureCall >> argumentsGroup [
-	<generated>
-	<navigation: 'Arguments'>
-	^ MooseSpecializedGroup withAll: self arguments asSet
-]
-
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLStoredProcedureCall >> isStoredProcedureCall [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
index 230325a4..6488448e 100644
--- a/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
+++ b/src/FamixNGSQL/FmxSQLStructuralEntity.class.st
@@ -1,19 +1,32 @@
 "
 I am an abstract superclass for structural entities. A structural entity is an entity that defines how data are structured by the database.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentNamespace` | `FmxSQLTNamedEntity` | `namespaceEntities` | `FmxSQLNamespace` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLStructuralEntity,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLStructuralEntity',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FmxSQLTNamedEntity',
 	#classTraits : 'FmxSQLTNamedEntity classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLStructuralEntity class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #StructuralEntity super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLTArgument.trait.st b/src/FamixNGSQL/FmxSQLTArgument.trait.st
index 3ed3573e..179a778d 100644
--- a/src/FamixNGSQL/FmxSQLTArgument.trait.st
+++ b/src/FamixNGSQL/FmxSQLTArgument.trait.st
@@ -1,13 +1,15 @@
 Trait {
-	#name : #FmxSQLTArgument,
-	#category : 'FamixNGSQL-Traits'
+	#name : 'FmxSQLTArgument',
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTArgument classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TArgument super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLTColumn.trait.st b/src/FamixNGSQL/FmxSQLTColumn.trait.st
index 3b14bb26..e90442b8 100644
--- a/src/FamixNGSQL/FmxSQLTColumn.trait.st
+++ b/src/FamixNGSQL/FmxSQLTColumn.trait.st
@@ -1,39 +1,48 @@
+"
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnsContainer` | `FmxSQLTColumn` | `columns` | `FmxSQLColumnsContainer` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTColumn,
+	#name : 'FmxSQLTColumn',
 	#instVars : [
 		'#columnsContainer => FMOne type: #FmxSQLColumnsContainer opposite: #columns'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTColumn classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TColumn super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTColumn >> columnsContainer [
 	"Relation named: #columnsContainer type: #FmxSQLColumnsContainer opposite: #columns"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ columnsContainer
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTColumn >> columnsContainer: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columnsContainer := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTColumn >> columnsContainerGroup [
-	<generated>
-	<navigation: 'ColumnsContainer'>
-	^ MooseSpecializedGroup with: self columnsContainer
-]
diff --git a/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st b/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
index 6380966c..b789b92b 100644
--- a/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
+++ b/src/FamixNGSQL/FmxSQLTDefiningDerivedTables.trait.st
@@ -1,45 +1,56 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | `parentQuery` | `FmxSQLDerivedTable` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTDefiningDerivedTables,
+	#name : 'FmxSQLTDefiningDerivedTables',
 	#instVars : [
 		'#derivedTablesDefined => FMMany type: #FmxSQLDerivedTable opposite: #parentQuery'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTDefiningDerivedTables classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TDefiningDerivedTables super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTDefiningDerivedTables >> addDerivedTablesDefined: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self derivedTablesDefined add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTDefiningDerivedTables >> derivedTablesDefined [
 	"Relation named: #derivedTablesDefined type: #FmxSQLDerivedTable opposite: #parentQuery"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ derivedTablesDefined
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTDefiningDerivedTables >> derivedTablesDefined: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	derivedTablesDefined value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTDefiningDerivedTables >> derivedTablesDefinedGroup [
-	<generated>
-	<navigation: 'DerivedTablesDefined'>
-	^ MooseSpecializedGroup withAll: self derivedTablesDefined asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLTEntityCreator.trait.st b/src/FamixNGSQL/FmxSQLTEntityCreator.trait.st
new file mode 100644
index 00000000..6144174b
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLTEntityCreator.trait.st
@@ -0,0 +1,853 @@
+"
+This trait is used by Famix models.
+It provides an API for creating entities and adding them to the model.
+
+
+"
+Trait {
+	#name : 'FmxSQLTEntityCreator',
+	#category : 'FamixNGSQL-Model',
+	#package : 'FamixNGSQL',
+	#tag : 'Model'
+}
+
+{ #category : 'meta' }
+FmxSQLTEntityCreator classSide >> annotation [
+
+	<ignoreForCoverage>
+	<FMClass: #TEntityCreator super: #Object>
+	<package: #FamixNGSQL>
+	<generated>
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newAlias [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLAlias new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newAliasAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLAliasAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newAliasNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLAlias named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newAssociation [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLAssociation new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCRUDQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCRUDQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCheckConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCheckConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCheckConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLCheckConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumn [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumn new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnAlias [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumnAlias new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnAliasAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumnAliasAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnAliasNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLColumnAlias named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLColumn named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumnReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnsContainerAlias [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumnsContainerAlias new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnsContainerAliasAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLColumnsContainerAliasAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newColumnsContainerAliasNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLColumnsContainerAlias named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newComment [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLComment new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursor [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCursor new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursorNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLCursor named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursorParameter [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCursorParameter new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursorParameterAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCursorParameterAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursorParameterNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLCursorParameter named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newCursorReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLCursorReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newDeleteQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLDeleteQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newDerivedTable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLDerivedTable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newDerivedTableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLDerivedTable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newDerivedTableReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLDerivedTableReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newEntitySourceAnchor [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLEntitySourceAnchor new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newExceptClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLExceptClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newExclusionConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLExclusionConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newExclusionConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLExclusionConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newForeignKeyConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLForeignKeyConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newForeignKeyConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLForeignKeyConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newForeignTable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLForeignTable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newForeignTableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLForeignTable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newFromClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLFromClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newGroupByClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLGroupByClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newHavingClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLHavingClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newInsertQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLInsertQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newIntersectClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLIntersectClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newIntoClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLIntoClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newJoinClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLJoinClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newLimitClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLLimitClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newLocalVariable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLLocalVariable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newLocalVariableAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLLocalVariableAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newLocalVariableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLLocalVariable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNamespace [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLNamespace new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNamespaceNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLNamespace named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNamespaceReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLNamespaceReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNewLocalVariable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLNewLocalVariable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNewLocalVariableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLNewLocalVariable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNotNullConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLNotNullConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newNotNullConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLNotNullConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newOldLocalVariable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLOldLocalVariable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newOldLocalVariableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLOldLocalVariable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newOnConflictClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLOnConflictClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newOrderByClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLOrderByClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newParameter [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLParameter new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newParameterAccess [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLParameterAccess new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newParameterNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLParameter named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newPrimaryKeyConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLPrimaryKeyConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newPrimaryKeyConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLPrimaryKeyConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newQualifiedReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLQualifiedReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newRecordLocalVariable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLRecordLocalVariable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newRecordLocalVariableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLRecordLocalVariable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newReferencesGroup [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLReferencesGroup new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newReferencesGroupReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLReferencesGroupReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newReturningClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLReturningClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newSelectClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLSelectClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newSelectQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLSelectQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newSetClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLSetClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newSourceLanguage [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLSourceLanguage new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newSourceTextAnchor [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLSourceTextAnchor new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newStoredProcedure [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLStoredProcedure new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newStoredProcedureCall [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLStoredProcedureCall new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newStoredProcedureNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLStoredProcedure named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newStructuralEntity [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLStructuralEntity new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newStructuralEntityNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLStructuralEntity named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTable [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLTable new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTableNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLTable named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTableReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLTableReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTrigger [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLTrigger new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTriggerNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLTrigger named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTriggerStoredProcedure [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLTriggerStoredProcedure new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTriggerStoredProcedureNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLTriggerStoredProcedure named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newType [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLType new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTypeNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLType named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newTypeReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLTypeReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newUnionClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLUnionClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newUniqueConstraint [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLUniqueConstraint new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newUniqueConstraintNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLUniqueConstraint named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newUpdateQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLUpdateQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newUsingClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLUsingClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newValuesClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLValuesClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newValuesQuery [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLValuesQuery new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newView [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLView new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newViewNamed: aName [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: (FmxSQLView named: aName)
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newViewReference [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLViewReference new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newWhereClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLWhereClause new
+]
+
+{ #category : 'entity creation' }
+FmxSQLTEntityCreator >> newWithClause [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self add: FmxSQLWithClause new
+]
diff --git a/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st b/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
index ae2a0dd8..e0a75ebe 100644
--- a/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
+++ b/src/FamixNGSQL/FmxSQLTNamedEntity.trait.st
@@ -1,13 +1,48 @@
+"
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentNamespace` | `FmxSQLTNamedEntity` | `namespaceEntities` | `FmxSQLNamespace` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTNamedEntity,
-	#category : #'FamixNGSQL-Traits'
+	#name : 'FmxSQLTNamedEntity',
+	#instVars : [
+		'#parentNamespace => FMOne type: #FmxSQLNamespace opposite: #namespaceEntities'
+	],
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTNamedEntity classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TNamedEntity super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
+]
+
+{ #category : 'accessing' }
+FmxSQLTNamedEntity >> parentNamespace [
+	"Relation named: #parentNamespace type: #FmxSQLNamespace opposite: #namespaceEntities"
+
+	<ignoreForCoverage>
+	<generated>
+	<container>
+	^ parentNamespace
+]
+
+{ #category : 'accessing' }
+FmxSQLTNamedEntity >> parentNamespace: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	parentNamespace := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st b/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
index b4c5ecc6..a6477ed0 100644
--- a/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
+++ b/src/FamixNGSQL/FmxSQLTQueryContainer.trait.st
@@ -1,55 +1,66 @@
 "
 I am an abstract super class for behavioural entities that can contain queries in their source code.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
+
+
+
 "
 Trait {
-	#name : #FmxSQLTQueryContainer,
+	#name : 'FmxSQLTQueryContainer',
 	#instVars : [
 		'#queries => FMMany type: #FmxSQLCRUDQuery opposite: #container'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTQueryContainer classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TQueryContainer super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTQueryContainer >> addQuery: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self queries add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLTQueryContainer >> isQueryContainer [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTQueryContainer >> queries [
 	"Relation named: #queries type: #FmxSQLCRUDQuery opposite: #container"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ queries
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTQueryContainer >> queries: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	queries value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTQueryContainer >> queriesGroup [
-	<generated>
-	<navigation: 'Queries'>
-	^ MooseSpecializedGroup withAll: self queries asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st b/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
index 85b8ca21..14da3ea5 100644
--- a/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTReferencesGroupReference.trait.st
@@ -1,55 +1,78 @@
+"
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLTReferencesGroupReference` | `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | |
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLTReferencesGroupReference` | `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `referencesGroup` | `FmxSQLTReferencesGroupReference` | `incomingReferencesGroupReference` | `FmxSQLReferencesGroup` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTReferencesGroupReference,
+	#name : 'FmxSQLTReferencesGroupReference',
 	#instVars : [
-		'#source => FMOne type: #FmxSQLTWithReferencesGroupReference opposite: #outgoingReferencesGroupReferences',
-		'#referencesGroup => FMOne type: #FmxSQLReferencesGroup opposite: #incomingReferencesGroupReference'
+		'#referencesGroup => FMOne type: #FmxSQLReferencesGroup opposite: #incomingReferencesGroupReference',
+		'#source => FMOne type: #FmxSQLTWithReferencesGroupReference opposite: #outgoingReferencesGroupReferences'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTReferencesGroupReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TReferencesGroupReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTReferencesGroupReference >> referencesGroup [
 	"Relation named: #referencesGroup type: #FmxSQLReferencesGroup opposite: #incomingReferencesGroupReference"
 
+	<ignoreForCoverage>
 	<generated>
+	<target>
 	^ referencesGroup
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTReferencesGroupReference >> referencesGroup: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	referencesGroup := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTReferencesGroupReference >> source [
 	"Relation named: #source type: #FmxSQLTWithReferencesGroupReference opposite: #outgoingReferencesGroupReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
+	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTReferencesGroupReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTReferencesGroupReference >> sourceGroup [
-	<generated>
-	<navigation: 'Source'>
-	^ MooseSpecializedGroup with: self source
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st b/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
deleted file mode 100644
index 02070d14..00000000
--- a/src/FamixNGSQL/FmxSQLTWithAccesses.trait.st
+++ /dev/null
@@ -1,13 +0,0 @@
-Trait {
-	#name : #FmxSQLTWithAccesses,
-	#category : #'FamixNGSQL-Traits'
-}
-
-{ #category : #meta }
-FmxSQLTWithAccesses classSide >> annotation [
-
-	<FMClass: #TWithAccesses super: #Object>
-	<package: #FamixNGSQL>
-	<generated>
-	^self
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithAlias.trait.st b/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
index ac80563c..1cd303e1 100644
--- a/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithAlias.trait.st
@@ -1,45 +1,56 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `aliases` | `FmxSQLTWithAlias` | `parentBehaviouralEntity` | `FmxSQLAlias` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithAlias,
+	#name : 'FmxSQLTWithAlias',
 	#instVars : [
 		'#aliases => FMMany type: #FmxSQLAlias opposite: #parentBehaviouralEntity'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithAlias classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithAlias super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
-FmxSQLTWithAlias >> addAliase: anObject [
+{ #category : 'adding' }
+FmxSQLTWithAlias >> addAlias: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self aliases add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithAlias >> aliases [
 	"Relation named: #aliases type: #FmxSQLAlias opposite: #parentBehaviouralEntity"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ aliases
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithAlias >> aliases: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	aliases value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTWithAlias >> aliasesGroup [
-	<generated>
-	<navigation: 'Aliases'>
-	^ MooseSpecializedGroup withAll: self aliases asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st b/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
index 9c3752e9..b7e1def3 100644
--- a/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithColumnReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithColumnReference,
+	#name : 'FmxSQLTWithColumnReference',
 	#instVars : [
 		'#outgoingColumnReferences => FMMany type: #FmxSQLColumnReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithColumnReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithColumnReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithColumnReference >> addOutgoingColumnReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingColumnReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithColumnReference >> outgoingColumnReferences [
 	"Relation named: #outgoingColumnReferences type: #FmxSQLColumnReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingColumnReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithColumnReference >> outgoingColumnReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingColumnReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithCursor.trait.st b/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
index 59b3a9c9..6a6ae2e0 100644
--- a/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithCursor.trait.st
@@ -1,45 +1,56 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `cursors` | `FmxSQLTWithCursor` | `parentBehaviouralEntity` | `FmxSQLCursor` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithCursor,
+	#name : 'FmxSQLTWithCursor',
 	#instVars : [
 		'#cursors => FMMany type: #FmxSQLCursor opposite: #parentBehaviouralEntity'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithCursor classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithCursor super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithCursor >> addCursor: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self cursors add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithCursor >> cursors [
 	"Relation named: #cursors type: #FmxSQLCursor opposite: #parentBehaviouralEntity"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ cursors
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithCursor >> cursors: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	cursors value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTWithCursor >> cursorsGroup [
-	<generated>
-	<navigation: 'Cursors'>
-	^ MooseSpecializedGroup withAll: self cursors asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st b/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
index e48ecbe6..55e60f94 100644
--- a/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithCursorReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingCursorReferences` | `FmxSQLTWithCursorReference` | `source` | `FmxSQLCursorReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithCursorReference,
+	#name : 'FmxSQLTWithCursorReference',
 	#instVars : [
 		'#outgoingCursorReferences => FMMany type: #FmxSQLCursorReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithCursorReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithCursorReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithCursorReference >> addOutgoingCursorReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingCursorReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithCursorReference >> outgoingCursorReferences [
 	"Relation named: #outgoingCursorReferences type: #FmxSQLCursorReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingCursorReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithCursorReference >> outgoingCursorReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingCursorReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st b/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
index 4df9e76f..6e32130a 100644
--- a/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithDerivedTableReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithDerivedTableReference,
+	#name : 'FmxSQLTWithDerivedTableReference',
 	#instVars : [
 		'#outgoingDerivedTableReferences => FMMany type: #FmxSQLDerivedTableReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithDerivedTableReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithDerivedTableReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithDerivedTableReference >> addOutgoingDerivedTableReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingDerivedTableReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithDerivedTableReference >> outgoingDerivedTableReferences [
 	"Relation named: #outgoingDerivedTableReferences type: #FmxSQLDerivedTableReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingDerivedTableReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithDerivedTableReference >> outgoingDerivedTableReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingDerivedTableReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st b/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
index a7e75613..4f1b271a 100644
--- a/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithEntitySourceAnchor.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithEntitySourceAnchor,
+	#name : 'FmxSQLTWithEntitySourceAnchor',
 	#instVars : [
 		'#anchorsOnIntervalsOfCode => FMMany type: #FmxSQLEntitySourceAnchor opposite: #entity'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithEntitySourceAnchor classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithEntitySourceAnchor super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithEntitySourceAnchor >> addAnchorsOnIntervalsOfCode: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self anchorsOnIntervalsOfCode add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithEntitySourceAnchor >> anchorsOnIntervalsOfCode [
 	"Relation named: #anchorsOnIntervalsOfCode type: #FmxSQLEntitySourceAnchor opposite: #entity"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ anchorsOnIntervalsOfCode
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithEntitySourceAnchor >> anchorsOnIntervalsOfCode: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	anchorsOnIntervalsOfCode value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st b/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st
deleted file mode 100644
index 4bcb162b..00000000
--- a/src/FamixNGSQL/FmxSQLTWithImmediateSource.trait.st
+++ /dev/null
@@ -1,13 +0,0 @@
-Trait {
-	#name : #FmxSQLTWithImmediateSource,
-	#category : #'FamixNGSQL-Traits'
-}
-
-{ #category : #meta }
-FmxSQLTWithImmediateSource classSide >> annotation [
-
-	<FMClass: #TWithImmediateSource super: #Object>
-	<package: #FamixNGSQL>
-	<generated>
-	^self
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st b/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
index a3af6779..0b0a791c 100644
--- a/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithNamespaceReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithNamespaceReference,
+	#name : 'FmxSQLTWithNamespaceReference',
 	#instVars : [
 		'#outgoingNamespaceReference => FMMany type: #FmxSQLNamespaceReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithNamespaceReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithNamespaceReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithNamespaceReference >> addOutgoingNamespaceReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingNamespaceReference add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithNamespaceReference >> outgoingNamespaceReference [
 	"Relation named: #outgoingNamespaceReference type: #FmxSQLNamespaceReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingNamespaceReference
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithNamespaceReference >> outgoingNamespaceReference: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingNamespaceReference value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st b/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
index 7e8f6e2a..a708bf2a 100644
--- a/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithQualifiedReference.trait.st
@@ -1,31 +1,47 @@
+"
+## Relations
+======================
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithQualifiedReference,
+	#name : 'FmxSQLTWithQualifiedReference',
 	#instVars : [
 		'#qualifiedReference => FMOne type: #FmxSQLQualifiedReference opposite: #references'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithQualifiedReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithQualifiedReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithQualifiedReference >> qualifiedReference [
 	"Relation named: #qualifiedReference type: #FmxSQLQualifiedReference opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	^ qualifiedReference
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithQualifiedReference >> qualifiedReference: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	qualifiedReference := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st b/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
index 8e2dcb94..5b09c370 100644
--- a/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithReferencesGroupReference.trait.st
@@ -1,45 +1,61 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithReferencesGroupReference,
+	#name : 'FmxSQLTWithReferencesGroupReference',
 	#instVars : [
 		'#outgoingReferencesGroupReferences => FMMany type: #FmxSQLTReferencesGroupReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithReferencesGroupReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithReferencesGroupReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithReferencesGroupReference >> addOutgoingReferencesGroupReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingReferencesGroupReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferences [
 	"Relation named: #outgoingReferencesGroupReferences type: #FmxSQLTReferencesGroupReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingReferencesGroupReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingReferencesGroupReferences value: anObject
 ]
-
-{ #category : #navigation }
-FmxSQLTWithReferencesGroupReference >> outgoingReferencesGroupReferencesGroup [
-	<generated>
-	<navigation: 'OutgoingReferencesGroupReferences'>
-	^ MooseSpecializedGroup withAll: self outgoingReferencesGroupReferences asSet
-]
diff --git a/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st b/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
index adb78f45..9552a5fe 100644
--- a/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithTableReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithTableReference,
+	#name : 'FmxSQLTWithTableReference',
 	#instVars : [
 		'#outgoingTableReferences => FMMany type: #FmxSQLTableReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithTableReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithTableReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithTableReference >> addOutgoingTableReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingTableReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithTableReference >> outgoingTableReferences [
 	"Relation named: #outgoingTableReferences type: #FmxSQLTableReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingTableReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithTableReference >> outgoingTableReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingTableReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTWithTriggers.trait.st b/src/FamixNGSQL/FmxSQLTWithTriggers.trait.st
new file mode 100644
index 00000000..eaa1addb
--- /dev/null
+++ b/src/FamixNGSQL/FmxSQLTWithTriggers.trait.st
@@ -0,0 +1,56 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `triggers` | `FmxSQLTWithTriggers` | `table` | `FmxSQLTrigger` | |
+
+
+
+"
+Trait {
+	#name : 'FmxSQLTWithTriggers',
+	#instVars : [
+		'#triggers => FMMany type: #FmxSQLTrigger opposite: #table'
+	],
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
+}
+
+{ #category : 'meta' }
+FmxSQLTWithTriggers classSide >> annotation [
+
+	<ignoreForCoverage>
+	<FMClass: #TWithTriggers super: #Object>
+	<package: #FamixNGSQL>
+	<generated>
+]
+
+{ #category : 'adding' }
+FmxSQLTWithTriggers >> addTrigger: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	^ self triggers add: anObject
+]
+
+{ #category : 'accessing' }
+FmxSQLTWithTriggers >> triggers [
+	"Relation named: #triggers type: #FmxSQLTrigger opposite: #table"
+
+	<ignoreForCoverage>
+	<generated>
+	<derived>
+	^ triggers
+]
+
+{ #category : 'accessing' }
+FmxSQLTWithTriggers >> triggers: anObject [
+
+	<ignoreForCoverage>
+	<generated>
+	triggers value: anObject
+]
diff --git a/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st b/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
index cd9341b2..98b0d947 100644
--- a/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
+++ b/src/FamixNGSQL/FmxSQLTWithViewReference.trait.st
@@ -1,38 +1,56 @@
+"
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+
+
+"
 Trait {
-	#name : #FmxSQLTWithViewReference,
+	#name : 'FmxSQLTWithViewReference',
 	#instVars : [
 		'#outgoingViewReferences => FMMany type: #FmxSQLViewReference opposite: #source'
 	],
-	#category : #'FamixNGSQL-Traits'
+	#category : 'FamixNGSQL-Traits',
+	#package : 'FamixNGSQL',
+	#tag : 'Traits'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTWithViewReference classSide >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TWithViewReference super: #Object>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTWithViewReference >> addOutgoingViewReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self outgoingViewReferences add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithViewReference >> outgoingViewReferences [
 	"Relation named: #outgoingViewReferences type: #FmxSQLViewReference opposite: #source"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ outgoingViewReferences
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTWithViewReference >> outgoingViewReferences: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	outgoingViewReferences value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTable.class.st b/src/FamixNGSQL/FmxSQLTable.class.st
index 362231af..c2687546 100644
--- a/src/FamixNGSQL/FmxSQLTable.class.st
+++ b/src/FamixNGSQL/FmxSQLTable.class.st
@@ -1,166 +1,178 @@
 "
 I represent a Table in the relational model.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+| `constraints` | `FmxSQLTable` | `table` | `FmxSQLConstraint` | |
+| `triggers` | `FmxSQLTWithTriggers` | `table` | `FmxSQLTrigger` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLTable` | `table` | `FmxSQLTableReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `cursorParameters` | `FmxSQLAbstractType` | `type` | `FmxSQLCursorParameter` | |
+| `localVariables` | `FmxSQLAbstractType` | `type` | `FmxSQLLocalVariable` | |
+| `parameters` | `FmxSQLAbstractType` | `type` | `FmxSQLParameter` | |
+| `storedProceduresReturning` | `FmxSQLAbstractType` | `returnType` | `FmxSQLStoredProcedure` | |
+| `subTables` | `FmxSQLTable` | `superTable` | `FmxSQLTable` | |
+| `superTable` | `FmxSQLTable` | `subTables` | `FmxSQLTable` | |
+| `updateQueries` | `FmxSQLTable` | `table` | `FmxSQLUpdateQuery` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLTable,
-	#superclass : #FmxSQLStructuralEntity,
-	#traits : 'FmxSQLAbstractType + FmxSQLColumnsContainer',
-	#classTraits : 'FmxSQLAbstractType classTrait + FmxSQLColumnsContainer classTrait',
+	#name : 'FmxSQLTable',
+	#superclass : 'FmxSQLStructuralEntity',
+	#traits : 'FmxSQLAbstractType + FmxSQLColumnsContainer + FmxSQLTWithTriggers',
+	#classTraits : 'FmxSQLAbstractType classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTWithTriggers classTrait',
 	#instVars : [
 		'#constraints => FMMany type: #FmxSQLConstraint opposite: #table',
-		'#superTable => FMOne type: #FmxSQLTable opposite: #subTables',
-		'#subTables => FMMany type: #FmxSQLTable opposite: #superTable',
 		'#references => FMMany type: #FmxSQLTableReference opposite: #table',
-		'#triggers => FMMany type: #FmxSQLTrigger opposite: #table',
+		'#subTables => FMMany type: #FmxSQLTable opposite: #superTable',
+		'#superTable => FMOne type: #FmxSQLTable opposite: #subTables',
 		'#updateQueries => FMMany type: #FmxSQLUpdateQuery opposite: #table'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTable class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Table super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTable >> addConstraint: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self constraints add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTable >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTable >> addSubTable: anObject [
-	<generated>
-	^ self subTables add: anObject
-]
 
-{ #category : #adding }
-FmxSQLTable >> addTrigger: anObject [
+	<ignoreForCoverage>
 	<generated>
-	^ self triggers add: anObject
+	^ self subTables add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTable >> addUpdateQuery: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self updateQueries add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> constraints [
 	"Relation named: #constraints type: #FmxSQLConstraint opposite: #table"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ constraints
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> constraints: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	constraints value: anObject
 ]
 
-{ #category : #navigation }
-FmxSQLTable >> constraintsGroup [
-	<generated>
-	<navigation: 'Constraints'>
-	^ MooseSpecializedGroup withAll: self constraints asSet
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> references [
 	"Relation named: #references type: #FmxSQLTableReference opposite: #table"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> subTables [
 	"Relation named: #subTables type: #FmxSQLTable opposite: #superTable"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ subTables
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> subTables: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	subTables value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> superTable [
 	"Relation named: #superTable type: #FmxSQLTable opposite: #subTables"
 
+	<ignoreForCoverage>
 	<generated>
 	^ superTable
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> superTable: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	superTable := anObject
 ]
 
-{ #category : #accessing }
-FmxSQLTable >> triggers [
-	"Relation named: #triggers type: #FmxSQLTrigger opposite: #table"
-
-	<generated>
-	<derived>
-	^ triggers
-]
-
-{ #category : #accessing }
-FmxSQLTable >> triggers: anObject [
-
-	<generated>
-	triggers value: anObject
-]
-
-{ #category : #navigation }
-FmxSQLTable >> triggersGroup [
-	<generated>
-	<navigation: 'Triggers'>
-	^ MooseSpecializedGroup withAll: self triggers asSet
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> updateQueries [
 	"Relation named: #updateQueries type: #FmxSQLUpdateQuery opposite: #table"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ updateQueries
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTable >> updateQueries: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	updateQueries value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTableReference.class.st b/src/FamixNGSQL/FmxSQLTableReference.class.st
index defd9c7a..38ebd1b1 100644
--- a/src/FamixNGSQL/FmxSQLTableReference.class.st
+++ b/src/FamixNGSQL/FmxSQLTableReference.class.st
@@ -1,55 +1,82 @@
 "
 I am a reference to a table.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLTableReference` | `outgoingTableReferences` | `FmxSQLTWithTableReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `table` | `FmxSQLTableReference` | `references` | `FmxSQLTable` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLTableReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLTableReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
 		'#source => FMOne type: #FmxSQLTWithTableReference opposite: #outgoingTableReferences',
 		'#table => FMOne type: #FmxSQLTable opposite: #references'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTableReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TableReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTableReference >> source [
 	"Relation named: #source type: #FmxSQLTWithTableReference opposite: #outgoingTableReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTableReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTableReference >> table [
 	"Relation named: #table type: #FmxSQLTable opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ table
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTableReference >> table: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	table := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTrigger.class.st b/src/FamixNGSQL/FmxSQLTrigger.class.st
index 1465dda2..941452cd 100644
--- a/src/FamixNGSQL/FmxSQLTrigger.class.st
+++ b/src/FamixNGSQL/FmxSQLTrigger.class.st
@@ -1,91 +1,119 @@
 "
 I am a trigger. A trigger allows to define actions to performs when a specific event occurs on a table. Because a trigger can not exist without the table to which it listens to events, a trigger is contained in a table.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentNamespace` | `FmxSQLTNamedEntity` | `namespaceEntities` | `FmxSQLNamespace` | |
+| `table` | `FmxSQLTrigger` | `triggers` | `FmxSQLTWithTriggers` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+| `storedProcedure` | `FmxSQLTrigger` | `triggers` | `FmxSQLTriggerStoredProcedure` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `firingAction` | `String` | nil | |
+| `when` | `String` | nil | |
+
 "
 Class {
-	#name : #FmxSQLTrigger,
-	#superclass : #FmxSQLNamedEntity,
+	#name : 'FmxSQLTrigger',
+	#superclass : 'FmxSQLNamedEntity',
 	#traits : 'FmxSQLBehaviouralEntity + FmxSQLTNamedEntity',
 	#classTraits : 'FmxSQLBehaviouralEntity classTrait + FmxSQLTNamedEntity classTrait',
 	#instVars : [
 		'#firingAction => FMProperty',
-		'#when => FMProperty',
 		'#storedProcedure => FMOne type: #FmxSQLTriggerStoredProcedure opposite: #triggers',
-		'#table => FMOne type: #FmxSQLTable opposite: #triggers'
+		'#table => FMOne type: #FmxSQLTWithTriggers opposite: #triggers',
+		'#when => FMProperty'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTrigger class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Trigger super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> firingAction [
 
 	<FMProperty: #firingAction type: #String>
+	<ignoreForCoverage>
 	<generated>
 	^ firingAction
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> firingAction: anObject [
+	<ignoreForCoverage>
 	<generated>
 	firingAction := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> storedProcedure [
 	"Relation named: #storedProcedure type: #FmxSQLTriggerStoredProcedure opposite: #triggers"
 
+	<ignoreForCoverage>
 	<generated>
 	^ storedProcedure
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> storedProcedure: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	storedProcedure := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> table [
-	"Relation named: #table type: #FmxSQLTable opposite: #triggers"
+	"Relation named: #table type: #FmxSQLTWithTriggers opposite: #triggers"
 
+	<ignoreForCoverage>
 	<generated>
 	<container>
 	^ table
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> table: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	table := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLTrigger >> tableGroup [
-	<generated>
-	<navigation: 'Table'>
-	^ MooseSpecializedGroup with: self table
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> when [
 
 	<FMProperty: #when type: #String>
+	<ignoreForCoverage>
 	<generated>
 	^ when
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTrigger >> when: anObject [
+	<ignoreForCoverage>
 	<generated>
 	when := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st b/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
index 219be8dd..d557ac70 100644
--- a/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
+++ b/src/FamixNGSQL/FmxSQLTriggerStoredProcedure.class.st
@@ -2,80 +2,100 @@
 I am a special stored procedure used to define the actions a trigger perform.
 
 This concept does not exists in all DBMS (for example, in MySQL a trigger has a body directly defined when defining the trigger). Nevertheless, it allows to unify the different approach take by different DBMS. In the meta-model, a trigger is always defined as referencing a trigger stored procedure. For DBMS where it is not implemented like that in reality, the trigger stored procedure as no name because it is virtual.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columnsReferenced` | `FmxSQLTriggerStoredProcedure` | `triggerStoredProceduresReferencing` | `FmxSQLColumnReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `triggers` | `FmxSQLTriggerStoredProcedure` | `storedProcedure` | `FmxSQLTrigger` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLTriggerStoredProcedure,
-	#superclass : #FmxSQLStoredProcedure,
+	#name : 'FmxSQLTriggerStoredProcedure',
+	#superclass : 'FmxSQLStoredProcedure',
 	#instVars : [
 		'#columnsReferenced => FMMany type: #FmxSQLColumnReference opposite: #triggerStoredProceduresReferencing',
 		'#triggers => FMMany type: #FmxSQLTrigger opposite: #storedProcedure'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTriggerStoredProcedure class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TriggerStoredProcedure super: #FmxSQLStoredProcedure>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTriggerStoredProcedure >> addColumnsReferenced: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self columnsReferenced add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLTriggerStoredProcedure >> addTrigger: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self triggers add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTriggerStoredProcedure >> columnsReferenced [
 	"Relation named: #columnsReferenced type: #FmxSQLColumnReference opposite: #triggerStoredProceduresReferencing"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ columnsReferenced
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTriggerStoredProcedure >> columnsReferenced: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columnsReferenced value: anObject
 ]
 
-{ #category : #navigation }
-FmxSQLTriggerStoredProcedure >> columnsReferencedGroup [
-	<generated>
-	<navigation: 'ColumnsReferenced'>
-	^ MooseSpecializedGroup withAll: self columnsReferenced asSet
-]
-
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLTriggerStoredProcedure >> isTriggerStoredProcedure [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTriggerStoredProcedure >> triggers [
 	"Relation named: #triggers type: #FmxSQLTrigger opposite: #storedProcedure"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ triggers
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTriggerStoredProcedure >> triggers: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	triggers value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLType.class.st b/src/FamixNGSQL/FmxSQLType.class.st
index f38521be..9d3c31d9 100644
--- a/src/FamixNGSQL/FmxSQLType.class.st
+++ b/src/FamixNGSQL/FmxSQLType.class.st
@@ -1,67 +1,97 @@
 "
 I represent a Type in the database. I can be used for a column, a local variable, a parameter, etc...
+
+## Relations
+======================
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLType` | `type` | `FmxSQLTypeReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLType` | `type` | `FmxSQLColumn` | |
+| `cursorParameters` | `FmxSQLAbstractType` | `type` | `FmxSQLCursorParameter` | |
+| `localVariables` | `FmxSQLAbstractType` | `type` | `FmxSQLLocalVariable` | |
+| `parameters` | `FmxSQLAbstractType` | `type` | `FmxSQLParameter` | |
+| `storedProceduresReturning` | `FmxSQLAbstractType` | `returnType` | `FmxSQLStoredProcedure` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLType,
-	#superclass : #FmxSQLStructuralEntity,
+	#name : 'FmxSQLType',
+	#superclass : 'FmxSQLStructuralEntity',
 	#traits : 'FmxSQLAbstractType',
 	#classTraits : 'FmxSQLAbstractType classTrait',
 	#instVars : [
 		'#columns => FMMany type: #FmxSQLColumn opposite: #type',
 		'#references => FMMany type: #FmxSQLTypeReference opposite: #type'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLType class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #Type super: #FmxSQLStructuralEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLType >> addColumn: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self columns add: anObject
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLType >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLType >> columns [
 	"Relation named: #columns type: #FmxSQLColumn opposite: #type"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ columns
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLType >> columns: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	columns value: anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLType >> references [
 	"Relation named: #references type: #FmxSQLTypeReference opposite: #type"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLType >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLTypeReference.class.st b/src/FamixNGSQL/FmxSQLTypeReference.class.st
index c4d20216..9762bf48 100644
--- a/src/FamixNGSQL/FmxSQLTypeReference.class.st
+++ b/src/FamixNGSQL/FmxSQLTypeReference.class.st
@@ -1,36 +1,51 @@
 "
 I am reference to a type of the model.
+
+## Relations
+======================
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `type` | `FmxSQLTypeReference` | `references` | `FmxSQLType` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLTypeReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLTypeReference',
+	#superclass : 'FmxSQLReference',
 	#instVars : [
 		'#type => FMOne type: #FmxSQLType opposite: #references'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLTypeReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #TypeReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTypeReference >> type [
 	"Relation named: #type type: #FmxSQLType opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ type
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLTypeReference >> type: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	type := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLUnionClause.class.st b/src/FamixNGSQL/FmxSQLUnionClause.class.st
index 363d77c6..24299593 100644
--- a/src/FamixNGSQL/FmxSQLUnionClause.class.st
+++ b/src/FamixNGSQL/FmxSQLUnionClause.class.st
@@ -1,26 +1,47 @@
 "
 I am an union clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLUnionClause,
-	#superclass : #FmxSQLClause,
+	#name : 'FmxSQLUnionClause',
+	#superclass : 'FmxSQLClause',
 	#traits : 'FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
 	#classTraits : 'FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLUnionClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #UnionClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLUnionClause >> isUnionClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st b/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
index fcb2afb6..f436fae8 100644
--- a/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
+++ b/src/FamixNGSQL/FmxSQLUniqueConstraint.class.st
@@ -1,24 +1,29 @@
 "
 I represent a UNIQUE constraint as defined in SQL standard.
+
+
 "
 Class {
-	#name : #FmxSQLUniqueConstraint,
-	#superclass : #FmxSQLConstraint,
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLUniqueConstraint',
+	#superclass : 'FmxSQLConstraint',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLUniqueConstraint class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #UniqueConstraint super: #FmxSQLConstraint>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLUniqueConstraint >> isUniqueConstraint [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st b/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st
deleted file mode 100644
index 3c8fe1d3..00000000
--- a/src/FamixNGSQL/FmxSQLUnknownSourceLanguage.class.st
+++ /dev/null
@@ -1,16 +0,0 @@
-Class {
-	#name : #FmxSQLUnknownSourceLanguage,
-	#superclass : #FmxSQLSourceLanguage,
-	#traits : 'FamixTUnknownSourceLanguage',
-	#classTraits : 'FamixTUnknownSourceLanguage classTrait',
-	#category : #'FamixNGSQL-Entities'
-}
-
-{ #category : #meta }
-FmxSQLUnknownSourceLanguage class >> annotation [
-
-	<FMClass: #UnknownSourceLanguage super: #FmxSQLSourceLanguage>
-	<package: #FamixNGSQL>
-	<generated>
-	^self
-]
diff --git a/src/FamixNGSQL/FmxSQLUpdateQuery.class.st b/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
index 66478349..54c0ffdf 100644
--- a/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLUpdateQuery.class.st
@@ -1,37 +1,57 @@
 "
 I am an UPDATE query.
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `derivedTablesDefined` | `FmxSQLTDefiningDerivedTables` | `parentQuery` | `FmxSQLDerivedTable` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `table` | `FmxSQLUpdateQuery` | `updateQueries` | `FmxSQLTable` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLUpdateQuery,
-	#superclass : #FmxSQLCRUDQuery,
+	#name : 'FmxSQLUpdateQuery',
+	#superclass : 'FmxSQLCRUDQuery',
 	#traits : 'FmxSQLTDefiningDerivedTables',
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
 	#instVars : [
 		'#table => FMOne type: #FmxSQLTable opposite: #updateQueries'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLUpdateQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #UpdateQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLUpdateQuery >> table [
 	"Relation named: #table type: #FmxSQLTable opposite: #updateQueries"
 
+	<ignoreForCoverage>
 	<generated>
 	^ table
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLUpdateQuery >> table: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	table := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLUsingClause.class.st b/src/FamixNGSQL/FmxSQLUsingClause.class.st
index 545d5f14..f573fdfb 100644
--- a/src/FamixNGSQL/FmxSQLUsingClause.class.st
+++ b/src/FamixNGSQL/FmxSQLUsingClause.class.st
@@ -1,26 +1,46 @@
 "
 I am an using clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLUsingClause,
-	#superclass : #FmxSQLClause,
+	#name : 'FmxSQLUsingClause',
+	#superclass : 'FmxSQLClause',
 	#traits : 'FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference',
 	#classTraits : 'FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLUsingClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #UsingClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLUsingClause >> isUsingClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLValuesClause.class.st b/src/FamixNGSQL/FmxSQLValuesClause.class.st
index 369bea60..2bba1af2 100644
--- a/src/FamixNGSQL/FmxSQLValuesClause.class.st
+++ b/src/FamixNGSQL/FmxSQLValuesClause.class.st
@@ -1,26 +1,43 @@
 "
 I am a Values clause
+
+## Relations
+======================
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+
+
+
 "
 Class {
-	#name : #FmxSQLValuesClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLValuesClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLValuesClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ValuesClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLValuesClause >> isValuesClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLValuesQuery.class.st b/src/FamixNGSQL/FmxSQLValuesQuery.class.st
index 24d23e8d..5ca0db90 100644
--- a/src/FamixNGSQL/FmxSQLValuesQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLValuesQuery.class.st
@@ -1,17 +1,21 @@
 "
 I am a VALUES query.
+
+
 "
 Class {
-	#name : #FmxSQLValuesQuery,
-	#superclass : #FmxSQLCRUDQuery,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLValuesQuery',
+	#superclass : 'FmxSQLCRUDQuery',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLValuesQuery class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ValuesQuery super: #FmxSQLCRUDQuery>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
diff --git a/src/FamixNGSQL/FmxSQLView.class.st b/src/FamixNGSQL/FmxSQLView.class.st
index 5ec3ccd7..acc6f7e3 100644
--- a/src/FamixNGSQL/FmxSQLView.class.st
+++ b/src/FamixNGSQL/FmxSQLView.class.st
@@ -1,74 +1,134 @@
 "
 I am a view. I can be used transparently as a table but I do not hold data. My data are fetched by the SELECT query which defines myself.
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentNamespace` | `FmxSQLTNamedEntity` | `namespaceEntities` | `FmxSQLNamespace` | |
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
+| `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
+| `query` | `FmxSQLView` | `viewDefining` | `FmxSQLSelectQuery` | |
+| `triggers` | `FmxSQLTWithTriggers` | `table` | `FmxSQLTrigger` | |
+
+### Incoming dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `references` | `FmxSQLView` | `view` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `anchorsOnIntervalsOfCode` | `FmxSQLTWithEntitySourceAnchor` | `entity` | `FmxSQLEntitySourceAnchor` | |
+| `cursorParameters` | `FmxSQLAbstractType` | `type` | `FmxSQLCursorParameter` | |
+| `element` | `FamixTSourceAnchor` | `sourceAnchor` | `FamixTSourceEntity` | Enable the accessibility to the famix entity that this class is a source pointer for|
+| `localVariables` | `FmxSQLAbstractType` | `type` | `FmxSQLLocalVariable` | |
+| `parameters` | `FmxSQLAbstractType` | `type` | `FmxSQLParameter` | |
+| `storedProceduresReturning` | `FmxSQLAbstractType` | `returnType` | `FmxSQLStoredProcedure` | |
+
+
+## Properties
+======================
+
+| Name | Type | Default value | Comment |
+|---|
+| `isMaterialized` | `Boolean` | nil | |
+| `source` | `String` | nil | Actual source code of the source entity|
+
 "
 Class {
-	#name : #FmxSQLView,
-	#superclass : #FmxSQLNamedEntity,
-	#traits : 'FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithImmediateSource',
-	#classTraits : 'FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithImmediateSource classTrait',
+	#name : 'FmxSQLView',
+	#superclass : 'FmxSQLNamedEntity',
+	#traits : 'FamixTHasImmediateSource + FmxSQLAbstractType + FmxSQLBehaviouralEntity + FmxSQLColumnsContainer + FmxSQLTNamedEntity + FmxSQLTQueryContainer + FmxSQLTWithTriggers',
+	#classTraits : 'FamixTHasImmediateSource classTrait + FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithTriggers classTrait',
 	#instVars : [
+		'#isMaterialized => FMProperty',
 		'#query => FMOne type: #FmxSQLSelectQuery opposite: #viewDefining',
 		'#references => FMMany type: #FmxSQLViewReference opposite: #view'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLView class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #View super: #FmxSQLNamedEntity>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #adding }
+{ #category : 'adding' }
 FmxSQLView >> addReference: anObject [
+
+	<ignoreForCoverage>
 	<generated>
 	^ self references add: anObject
 ]
 
-{ #category : #testing }
+{ #category : 'accessing' }
+FmxSQLView >> isMaterialized [
+
+	<FMProperty: #isMaterialized type: #Boolean>
+	<ignoreForCoverage>
+	<generated>
+	^ isMaterialized
+]
+
+{ #category : 'accessing' }
+FmxSQLView >> isMaterialized: anObject [
+	<ignoreForCoverage>
+	<generated>
+	isMaterialized := anObject
+]
+
+{ #category : 'testing' }
 FmxSQLView >> isView [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLView >> query [
 	"Relation named: #query type: #FmxSQLSelectQuery opposite: #viewDefining"
 
+	<ignoreForCoverage>
 	<generated>
 	^ query
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLView >> query: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	query := anObject
 ]
 
-{ #category : #navigation }
-FmxSQLView >> queryGroup [
-	<generated>
-	<navigation: 'Query'>
-	^ MooseSpecializedGroup with: self query
-]
-
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLView >> references [
 	"Relation named: #references type: #FmxSQLViewReference opposite: #view"
 
+	<ignoreForCoverage>
 	<generated>
 	<derived>
 	^ references
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLView >> references: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	references value: anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLViewReference.class.st b/src/FamixNGSQL/FmxSQLViewReference.class.st
index 4f63d53c..1bd60336 100644
--- a/src/FamixNGSQL/FmxSQLViewReference.class.st
+++ b/src/FamixNGSQL/FmxSQLViewReference.class.st
@@ -1,55 +1,82 @@
 "
 I am a reference to a view.
+
+## Relations
+======================
+
+### Association source
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `source` | `FmxSQLViewReference` | `outgoingViewReferences` | `FmxSQLTWithViewReference` | |
+
+### Association target
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `view` | `FmxSQLViewReference` | `references` | `FmxSQLView` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `qualifiedReference` | `FmxSQLTWithQualifiedReference` | `references` | `FmxSQLQualifiedReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLViewReference,
-	#superclass : #FmxSQLReference,
+	#name : 'FmxSQLViewReference',
+	#superclass : 'FmxSQLReference',
 	#traits : 'FmxSQLTWithQualifiedReference',
 	#classTraits : 'FmxSQLTWithQualifiedReference classTrait',
 	#instVars : [
 		'#source => FMOne type: #FmxSQLTWithViewReference opposite: #outgoingViewReferences',
 		'#view => FMOne type: #FmxSQLView opposite: #references'
 	],
-	#category : #'FamixNGSQL-Entities'
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLViewReference class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #ViewReference super: #FmxSQLReference>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLViewReference >> source [
 	"Relation named: #source type: #FmxSQLTWithViewReference opposite: #outgoingViewReferences"
 
+	<ignoreForCoverage>
 	<generated>
 	<source>
 	^ source
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLViewReference >> source: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	source := anObject
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLViewReference >> view [
 	"Relation named: #view type: #FmxSQLView opposite: #references"
 
+	<ignoreForCoverage>
 	<generated>
 	<target>
 	^ view
 ]
 
-{ #category : #accessing }
+{ #category : 'accessing' }
 FmxSQLViewReference >> view: anObject [
 
+	<ignoreForCoverage>
 	<generated>
 	view := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLWhereClause.class.st b/src/FamixNGSQL/FmxSQLWhereClause.class.st
index df93bc15..c48bc428 100644
--- a/src/FamixNGSQL/FmxSQLWhereClause.class.st
+++ b/src/FamixNGSQL/FmxSQLWhereClause.class.st
@@ -1,26 +1,56 @@
 "
 I am a where clause
+
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+
+### Outgoing dependencies
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `accesses` | `FamixTWithAccesses` | `accessor` | `FamixTAccess` | Accesses to variables made by this behaviour.|
+| `outgoingColumnReferences` | `FmxSQLTWithColumnReference` | `source` | `FmxSQLColumnReference` | |
+| `outgoingDerivedTableReferences` | `FmxSQLTWithDerivedTableReference` | `source` | `FmxSQLDerivedTableReference` | |
+| `outgoingInvocations` | `FamixTWithInvocations` | `sender` | `FamixTInvocation` | Outgoing invocations sent by this behaviour.|
+| `outgoingReferencesGroupReferences` | `FmxSQLTWithReferencesGroupReference` | `source` | `FmxSQLTReferencesGroupReference` | |
+| `outgoingTableReferences` | `FmxSQLTWithTableReference` | `source` | `FmxSQLTableReference` | |
+| `outgoingViewReferences` | `FmxSQLTWithViewReference` | `source` | `FmxSQLViewReference` | |
+
+### Other
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `outgoingNamespaceReference` | `FmxSQLTWithNamespaceReference` | `source` | `FmxSQLNamespaceReference` | |
+
+
+
 "
 Class {
-	#name : #FmxSQLWhereClause,
-	#superclass : #FmxSQLClause,
-	#traits : 'FamixTWithInvocations + FmxSQLTWithAccesses + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
-	#classTraits : 'FamixTWithInvocations classTrait + FmxSQLTWithAccesses classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
-	#category : #'FamixNGSQL-Entities'
+	#name : 'FmxSQLWhereClause',
+	#superclass : 'FmxSQLClause',
+	#traits : 'FamixTWithAccesses + FamixTWithInvocations + FmxSQLTWithColumnReference + FmxSQLTWithDerivedTableReference + FmxSQLTWithNamespaceReference + FmxSQLTWithReferencesGroupReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference',
+	#classTraits : 'FamixTWithAccesses classTrait + FamixTWithInvocations classTrait + FmxSQLTWithColumnReference classTrait + FmxSQLTWithDerivedTableReference classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithReferencesGroupReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLWhereClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #WhereClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLWhereClause >> isWhereClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/FmxSQLWithClause.class.st b/src/FamixNGSQL/FmxSQLWithClause.class.st
index 24e61ad2..943a5110 100644
--- a/src/FamixNGSQL/FmxSQLWithClause.class.st
+++ b/src/FamixNGSQL/FmxSQLWithClause.class.st
@@ -1,24 +1,29 @@
 "
 I am a with clause
+
+
 "
 Class {
-	#name : #FmxSQLWithClause,
-	#superclass : #FmxSQLClause,
-	#category : 'FamixNGSQL-Entities'
+	#name : 'FmxSQLWithClause',
+	#superclass : 'FmxSQLClause',
+	#category : 'FamixNGSQL-Entities',
+	#package : 'FamixNGSQL',
+	#tag : 'Entities'
 }
 
-{ #category : #meta }
+{ #category : 'meta' }
 FmxSQLWithClause class >> annotation [
 
+	<ignoreForCoverage>
 	<FMClass: #WithClause super: #FmxSQLClause>
 	<package: #FamixNGSQL>
 	<generated>
-	^self
 ]
 
-{ #category : #testing }
+{ #category : 'testing' }
 FmxSQLWithClause >> isWithClause [
 
+	<ignoreForCoverage>
 	<generated>
 	^ true
 ]
diff --git a/src/FamixNGSQL/package.st b/src/FamixNGSQL/package.st
index 51e3be76..968235c6 100644
--- a/src/FamixNGSQL/package.st
+++ b/src/FamixNGSQL/package.st
@@ -1 +1 @@
-Package { #name : #FamixNGSQL }
+Package { #name : 'FamixNGSQL' }

From 9dedd5edfca93725423b6c3ab4a11b739fa99f0d Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 22:01:16 +0300
Subject: [PATCH 09/22] Preserve SQL entity identities and source anchors
 across MSE round trips

---
 docs/pharo13-migration-audit.md               | 33 +++++++++++++----
 .../FmxSQLMetamodelGenerator.class.st         | 15 ++++----
 .../FmxSQLAnalysisReportingTest.class.st      | 36 +++++++++++++++++++
 .../FmxSQLDatabaseImportTest.class.st         |  1 +
 .../FmxSQLModel.extension.st                  | 21 +++++++++++
 .../FmxSQLModelBuilder.class.st               |  9 +++--
 .../FmxSQLSymbolResolutionVisitor.class.st    |  1 -
 src/FamixNGSQL/FmxSQLCRUDQuery.class.st       |  1 -
 src/FamixNGSQL/FmxSQLDerivedTable.class.st    |  1 +
 src/FamixNGSQL/FmxSQLSelectQuery.class.st     |  1 -
 src/FamixNGSQL/FmxSQLView.class.st            |  1 +
 11 files changed, 103 insertions(+), 17 deletions(-)

diff --git a/docs/pharo13-migration-audit.md b/docs/pharo13-migration-audit.md
index d8051b5c..9a080cb0 100644
--- a/docs/pharo13-migration-audit.md
+++ b/docs/pharo13-migration-audit.md
@@ -37,6 +37,10 @@ analysis.
 - Moose 13 no longer has `withoutPrimaryContainer`. Preserve both relation
   endpoints and composition through the existing `<>-`/`<>-*` commands.
   There is no replacement that disables the relation or drops its inverse.
+  For the one-to-one view/query and derived-table/query relations, explicitly
+  mark the owner query property derived and its container inverse not derived.
+  This preserves composition while exporting each query once; retaining the
+  default direction produces duplicate MSE IDs.
 - Use a trigger-owner trait shared by tables and views, preserving the public
   `table` / `triggers` relation names.
 - Keep the CHECK/routine relation and add the requested exclusion/routine
@@ -60,24 +64,25 @@ P3 master was fast-forwarded to upstream `d45f0d358f41ff809fd85f26046a63630a3a7b
 and pushed; its 95 tests passed against a disposable database. PgMetadata's 24
 tests passed, including constraint/routine links and the read-only extraction
 transaction. PostgreSQLParser passed 133 grammar tests, 103 AST-builder tests,
-7 facade tests, and 3 AST tests. The importer has 38 passing tests (including a
+7 facade tests, and 3 AST tests. The importer has 40 passing tests (including a
 real PostgreSQL integration scenario and MSE source-anchor export).
 
 The regenerated metamodel was exported to an empty directory and reloaded
 successfully. No generated definition refers to `FamixTUnknownSourceLanguage`.
 The production importer and its tests now have separate packages.
 
-The full local database build produced 81,488 model entities. Application catalog
-counts were independently checked with SQL: 47 schemas, 359 tables, 5 foreign
+The final model contains 70,143 unique entities. The earlier raw count included
+duplicate registrations and has been superseded. Application catalog counts
+were independently checked with SQL: 47 schemas, 359 tables, 5 foreign
 tables, 85 ordinary/materialized views, 2,461 routines, and 569 triggers.
 Generated system stubs are additional model entities.
 
-Routine statuses: 938 visited, 286 partial, 717 failed, 7 timed out, 511 in
+Routine statuses: 937 visited, 286 partial, 718 failed, 7 timed out, 511 in
 unsupported languages, and 2 aggregate catalog objects. View statuses: 42
 visited, 12 partial, 31 failed. Syntax failures across routines/views fell from
 799 to 520 after the schema-qualified call, declaration, and EXECUTE repairs.
-The larger model exposes more unresolved references; there are 1,833 recorded
-errors and 346 warnings overall. These counts are observations, not a claim of
+The larger model exposes more unresolved references; there are 1,836 recorded
+errors and 347 warnings overall. These counts are observations, not a claim of
 complete PostgreSQL semantics or dependency coverage.
 
 The MSE artifact retains source and structural/reference relations. A separate
@@ -97,3 +102,19 @@ been performed.
 - Remove remaining visitor Halts with supported semantics and regression tests;
   the importer currently records them as failures and continues.
 - Pin/validate the complete dependency stack in a fresh image before a release.
+
+## Export integrity fixes
+
+Reference factories already register their entities in the model. Remove the
+second registration in the visitor and in trigger-column linking. Register
+synthetic tableoid columns and copied trigger source anchors as model members.
+A final relation-graph pass also includes entities linked before a visitor failed.
+Round-trip tests check query identity, inverse relationships, entity counts, and
+source-anchor text, beyond checking that the MSE parser accepts the file.
+
+Final MSE verification: 70,143 records, 70,143 distinct IDs, zero undefined
+reference IDs. Reloaded model counts match: 70,143 entities, 569 triggers,
+2,461 application routines, 18,457 source anchors, and 13,386 anchored references.
+Routine and view source text was checked for exact equality after reloading.
+The snapshots are `artifacts/mi-20260917.mse` and
+`artifacts/mi-20260917-analysis.json` in the local working repository.
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index 4c0910b6..f1fb1907 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -233,6 +233,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesProperties [
 
 { #category : #'definition - behavioural' }
 FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
+	| queryRelation |
 	"A CheckConstraint can call StoredProcedures"
 	(checkConstraint property: #storedProceduresCalled)
 		*-*
@@ -243,14 +244,16 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 		*-* (storedProcedure property: #exclusionConstraintsCalling).
 
 	"A View is defined as a SelectQuery."
-	((view property: #query)
-		<>-
-	(selectQuery property: #viewDefining)).
+	queryRelation := (view property: #query)
+		<>- (selectQuery property: #viewDefining).
+	queryRelation derived.
+	queryRelation oppositeSide notDerived.
 	
 	"A DerivedTable is defined as a CRUD query."
-	((derivedTable property: #query)
-		<>-
-	(crudQuery property: #derivedTableDefining)).
+	queryRelation := (derivedTable property: #query)
+		<>- (crudQuery property: #derivedTableDefining).
+	queryRelation derived.
+	queryRelation oppositeSide notDerived.
 	
 	"A SelectQuery can define multiple derived tables."
 	(tDefiningDerivedTables property: #derivedTablesDefined)
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
index 68202556..91f764d5 100644
--- a/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
@@ -17,6 +17,22 @@ FmxSQLAnalysisReportingTest >> testSourceAnchorCanBeExported [
 	self assert: (serialized includesSubstring: 'EntitySourceAnchor')
 ]
 
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testDetachedAnchorIsIncludedInMSERoundTrip [
+	| model routine query anchor restored |
+	model := FmxSQLModel new.
+	routine := FmxSQLStoredProcedure new source: 'SELECT 1'; mooseModel: model; yourself.
+	query := FmxSQLSelectQuery new container: routine; mooseModel: model; yourself.
+	anchor := FmxSQLEntitySourceAnchor new entity: routine; start: 1; end: 8; yourself.
+	query sourceAnchor: anchor.
+	model ensureRelationMembers.
+	self assert: anchor mooseModel identicalTo: model.
+	restored := FmxSQLModel importFromMSEStream:
+		(String streamContents: [ :stream | model exportToMSEStream: stream ]) readStream.
+	self assert: restored size equals: model size.
+	self assert: (restored allWithType: FmxSQLSelectQuery) anyOne sourceAnchor sourceText equals: 'SELECT 1'
+]
+
 { #category : #tests }
 FmxSQLAnalysisReportingTest >> testTimeoutPreservesSourceAndAllowsNextEntity [
 	| builder slow next |
@@ -51,3 +67,23 @@ FmxSQLAnalysisReportingTest >> testFailureIsAttributedToItsEntity [
 	self assert: (entity cacheAt: #analysisStatus ifAbsent: [ nil ]) equals: #failed.
 	self assert: (entity cacheAt: #analysisDiagnostics) first second equals: 'analysis failed'
 ]
+
+{ #category : #tests }
+FmxSQLAnalysisReportingTest >> testQueryRelationsSurviveMSERoundTripWithoutDuplicateEntities [
+	| model view derived viewQuery derivedQuery serialized restored |
+	model := FmxSQLModel new.
+	view := FmxSQLView new name: 'v'; source: 'SELECT 1'; mooseModel: model; yourself.
+	derived := FmxSQLDerivedTable new mooseModel: model; yourself.
+	viewQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
+	derivedQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
+	view query: viewQuery.
+	derived query: derivedQuery.
+	self assert: viewQuery viewDefining identicalTo: view.
+	self assert: derivedQuery derivedTableDefining identicalTo: derived.
+	serialized := String streamContents: [ :stream | model exportToMSEStream: stream ].
+	restored := FmxSQLModel importFromMSEStream: serialized readStream.
+	self assert: restored size equals: model size.
+	self assert: (restored allWithType: FmxSQLSelectQuery) size equals: 2.
+	self assert: (restored allWithType: FmxSQLView) anyOne query viewDefining identicalTo: (restored allWithType: FmxSQLView) anyOne.
+	self assert: (restored allWithType: FmxSQLDerivedTable) anyOne query derivedTableDefining identicalTo: (restored allWithType: FmxSQLDerivedTable) anyOne
+]
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
index 87669626..92308542 100644
--- a/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
@@ -42,5 +42,6 @@ CREATE TRIGGER view_insert INSTEAD OF INSERT ON {1}.account_view FOR EACH ROW EX
 	self assert: trigger table identicalTo: view.
 	self assert: trigger storedProcedure queries isNotEmpty.
 	self assert: (trigger storedProcedure triggers includes: trigger).
+	self assert: model entities size equals: model entities asIdentitySet size.
 	self assert: model errorReport errors isEmpty
 ]
diff --git a/src/FamixNGSQL-Importer/FmxSQLModel.extension.st b/src/FamixNGSQL-Importer/FmxSQLModel.extension.st
index 58321161..bd1bc716 100644
--- a/src/FamixNGSQL-Importer/FmxSQLModel.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLModel.extension.st
@@ -1,5 +1,26 @@
 Extension { #name : #FmxSQLModel }
 
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLModel >> ensureRelationMembers [
+	"Partial analysis can leave an entity linked before it is registered.
+	Include the complete relation graph so MSE does not lose anchors or targets."
+	| fame known pending |
+	fame := FMModel withMetamodel: self metamodel.
+	known := self entities asIdentitySet.
+	pending := self entities asOrderedCollection copy.
+	[ pending isEmpty ] whileFalse: [ | entity |
+		entity := pending removeLast.
+		(fame metaDescriptionOf: entity) allProperties do: [ :property |
+			property type isPrimitive ifFalse: [
+				(fame get: property element: entity) do: [ :related |
+					((related isKindOf: MooseEntity) and: [ (known includes: related) not ]) ifTrue: [
+						(related mooseModel notNil and: [ related mooseModel ~~ self ]) ifTrue: [
+							self error: 'SQL relation points to an entity in another model' ].
+						known add: related.
+						pending add: related.
+						related mooseModel: self ] ] ] ] ]
+]
+
 { #category : #'*FamixNGSQL-Importer' }
 FmxSQLModel >> analysisReport [
 	"Serializable companion to MSE: analysis caches are not part of the metamodel."
diff --git a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
index 0a036bb2..266cc13d 100644
--- a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
@@ -85,6 +85,7 @@ FmxSQLModelBuilder >> buildModel [
 		visitStoredProceduresFor: mooseModel;
 		linkColumnReferencesToNewAndOldLocalVariableFor: mooseModel;
 		createSourceAnchorsOfQualifiedNamesFor: mooseModel.
+	mooseModel ensureRelationMembers.
 	mooseModel
 		errorReport: self errorReport.
 	pgToFamixEntities := nil.
@@ -147,6 +148,8 @@ FmxSQLModelBuilder >> createForeignTablesIn: mooseModel [
 		"Add special columns."
 		FmxSQLColumn new
 			name: 'tableoid';
+			isStub: true;
+			mooseModel: mooseModel;
 			columnsContainer: table ] displayingProgress: 'Creating foreign tables'
 ]
 
@@ -250,6 +253,8 @@ FmxSQLModelBuilder >> createTablesIn: mooseModel [
 		"Add special columns."
 		FmxSQLColumn new
 			name: 'tableoid';
+			isStub: true;
+			mooseModel: mooseModel;
 			columnsContainer: table ] displayingProgress: 'Creating tables'
 ]
 
@@ -355,6 +360,7 @@ FmxSQLModelBuilder >> linkColumnReferencesToNewAndOldLocalVariableFor: model [
 					varCol references do: [ :varColRef |
 						|copiedSourceAnchor|
 						copiedSourceAnchor := FmxSQLEntitySourceAnchor new
+														mooseModel: model;
 														entity: varColRef sourceAnchor entity;
 														start: varColRef sourceAnchor start;
 														end: varColRef sourceAnchor end;
@@ -362,8 +368,7 @@ FmxSQLModelBuilder >> linkColumnReferencesToNewAndOldLocalVariableFor: model [
 						(tableCol createReferenceEntityFrom: varColRef source)
 							isWildCardReference: varColRef isWildCardReference;
 							sourceAnchor: copiedSourceAnchor;
-							isCertain: false;
-							mooseModel: newLocalVariable mooseModel ] ]
+							isCertain: false ] ]
 				ifNone: [ self recordLinkingError: (Error new
 					messageText: 'Trigger column ', varCol name, ' not found in ', table name)
 					for: newLocalVariable parentBehaviouralEntity ] ] ] ]
diff --git a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
index 481e3069..2eac8f99 100644
--- a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
@@ -126,7 +126,6 @@ FmxSQLSymbolResolutionVisitor >> createReferenceTo: anEntity from: aPSQLASTNode
 	anchor := self createSourceAnchorFrom: aPSQLASTNode.
 	reference := (anEntity value createReferenceEntityFrom: self currentEntity)
 		sourceAnchor: anchor;
-		mooseModel: self model;
 		yourself.
 		
 	reference isColumnReference
diff --git a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
index 45479658..0248ddc9 100644
--- a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
@@ -115,7 +115,6 @@ FmxSQLCRUDQuery >> derivedTableDefining [
 	<ignoreForCoverage>
 	<generated>
 	<container>
-	<derived>
 	^ derivedTableDefining
 ]
 
diff --git a/src/FamixNGSQL/FmxSQLDerivedTable.class.st b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
index 5215f0fa..3647774b 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTable.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
@@ -85,6 +85,7 @@ FmxSQLDerivedTable >> query [
 
 	<ignoreForCoverage>
 	<generated>
+	<derived>
 	^ query
 ]
 
diff --git a/src/FamixNGSQL/FmxSQLSelectQuery.class.st b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
index 746cd587..b9595228 100644
--- a/src/FamixNGSQL/FmxSQLSelectQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
@@ -78,7 +78,6 @@ FmxSQLSelectQuery >> viewDefining [
 	<ignoreForCoverage>
 	<generated>
 	<container>
-	<derived>
 	^ viewDefining
 ]
 
diff --git a/src/FamixNGSQL/FmxSQLView.class.st b/src/FamixNGSQL/FmxSQLView.class.st
index acc6f7e3..bc232746 100644
--- a/src/FamixNGSQL/FmxSQLView.class.st
+++ b/src/FamixNGSQL/FmxSQLView.class.st
@@ -104,6 +104,7 @@ FmxSQLView >> query [
 
 	<ignoreForCoverage>
 	<generated>
+	<derived>
 	^ query
 ]
 

From 1ca953523b44dc6a4a1af201f0ef22f9e4134ae2 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:02:24 +0300
Subject: [PATCH 10/22] Document Pharo 13 setup, model analysis and export
 workflows

---
 README.md | 384 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 336 insertions(+), 48 deletions(-)

diff --git a/README.md b/README.md
index b9e845e8..17ed5f81 100644
--- a/README.md
+++ b/README.md
@@ -1,78 +1,366 @@
 # FAMIXNGSQL
 
-A FAMIX model of PostgreSQL databases, including schemas, tables, views,
-constraints, routines, triggers, and source-level references.
+FAMIXNGSQL builds a FAMIX model of a PostgreSQL database: schemas, tables, views,
+constraints, routines, triggers, source code and references between entities.
+The current `master` includes the Pharo 13 / Moose 13 migration and the updated
+PgMetadata and PostgreSQLParser integrations.
 
-## Pharo 13 / Moose 13 integration
+The import has two stages:
 
-The `pharo13-pgmetadata-integration` branch restores the original metamodel
-relationships on current Moose and integrates the updated PgMetadata and parser.
-See [the migration audit](docs/pharo13-migration-audit.md) for changes and limits.
+1. [PgMetadata](https://github.com/deem0n/PgMetadata) reads PostgreSQL catalogs
+   through [P3](https://github.com/deem0n/P3) and builds a metadata model.
+2. FAMIXNGSQL creates `FmxSQL*` entities, parses supported SQL/PL/pgSQL source
+   with [PostgreSQLParser](https://github.com/deem0n/PostgreSQLParser), and resolves
+   references into the model. It records incomplete analysis explicitly.
 
-The current validation uses an existing Moose 13 image on Pharo 13 and
-PostgreSQL 15.14. A fresh-image Metacello installation has not yet been validated.
-The core avoids the old GT/Telescope UI dependencies; `LegacyUI` is optional
-and has not been ported or validated.
+Catalog extraction and source analysis have different coverage. A successful
+import preserves objects and source even when parts of their code cannot be
+parsed or resolved. See [the migration audit](docs/pharo13-migration-audit.md)
+for the original-model comparison, validation evidence and remaining work.
+
+## Compatibility and dependencies
+
+Validated on **2026-09-17**:
+
+| Component | Tested version or revision |
+| --- | --- |
+| Pharo | **13.1.0SNAPSHOT** |
+| Moose | **13.0.0** |
+| PostgreSQL | **15.14** (Postgres.app) |
+| PgMetadata | `5abe3134238b4f84f7d1e02e28d9aee45aee5c61`, included in `deem0n/PgMetadata:master` |
+| PostgreSQLParser | `f9d1b0850cb7cde2839760d87f54f04ba9de315e`, group `core-no-gui` |
+| SymbolResolver | `c6eb29c46cd36cabb8dff5d19329085ee8fa38c7` |
+| P3 | `d45f0d358f41ff809fd85f26046a63630a3a7bef`, synchronized with upstream `svenvc/P3` |
+
+Tests ran in an **existing Pharo 13/Moose 13 image**. A complete Metacello install
+in a fresh image has not yet been validated. Pharo 7, Pharo 10, other Moose
+versions and other PostgreSQL versions are not certified by this migration.
+Historical implementations remain available in Git history and the
+[original upstream repository](https://github.com/juliendelplanque/FAMIXNGSQL).
+
+PgMetadata alone does not require Moose, but the FAMIXNGSQL importer does.
+The baseline pins PgMetadata, PostgreSQLParser and SymbolResolver to commits.
+Famix (`development`), PetitParser and the transitive P3 dependency (`master`)
+still use moving branches, so this is not yet a fully pinned dependency stack.
+Deleting this repository's merged development branches does not remove the
+pinned dependency commits.
+
+## Installation
+
+In a Pharo 13/Moose 13 Playground:
 
 ```smalltalk
 Metacello new
-  repository: 'github://deem0n/FAMIXNGSQL:pharo13-pgmetadata-integration/src';
-  baseline: 'FAMIXNGSQL';
-  load: 'Core'.
+    baseline: 'FAMIXNGSQL';
+    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    load: 'Core'.
 ```
 
-## Build a model
+Keep `/src` in this repository URL. The default group also loads `Core`.
+
+| Group | Purpose |
+| --- | --- |
+| `Core` | Generated SQL metamodel and importer with their dependencies |
+| `Tests` | Core, importer tests and PgMetadata scenario-test support |
+| `Generator` | Core and the metamodel generator |
+| `LegacyUI` | Historical GT Inspector, analysis, Telescope and connection-manager packages |
+
+`LegacyUI` has not been ported or validated on the current image. Core usage does
+not require those UI packages or a Genie MCP server. Loading modern Genie in a
+historical Pharo 7 image is not part of the installation procedure.
+
+## Connect and build a model
+
+This example models **all application schemas** in the local `mi` database,
+using role `bi` on port `5435`:
 
 ```smalltalk
-model := (FmxSQLModelBuilder new
-  databaseName: 'mi';
-  connection: (PgConnection hostname: 'localhost' port: 5435
-    database: 'mi' user: 'bi' password: nil);
-  analysisTimeout: 5 seconds;
-  yourself) buildModel.
+| connection builder model |
+connection := PgConnection
+    hostname: 'localhost'
+    port: 5435
+    database: 'mi'
+    user: 'bi'
+    password: nil.
+
+builder := FmxSQLModelBuilder new
+    databaseName: 'mi';
+    connection: connection;
+    analysisTimeout: 5 seconds;
+    yourself.
+
+model := builder buildModel.
 model inspect.
-model analysisReport inspect.
 ```
 
-Metadata extraction reads all application schemas, excluding `pg_*` and
-`information_schema`. It uses a read-only repeatable-read transaction. Internal
-routine stubs remain available for reference resolution.
+Replace the connection parameters for another server and keep both database
+names consistent. `password: nil` works with the existing local authentication
+used for validation; provide a password when required. It does not automatically
+read `.pgpass`. The role must be able to connect and read the required catalogs.
+
+Metadata extraction uses a **read-only, repeatable-read transaction** and closes
+the connection afterwards. Parsing and reference resolution then operate on the
+extracted source. The importer does not execute application routine bodies.
+
+Application schemas exclude names beginning with `pg_` and
+`information_schema`. Non-system extension and test schemas, such as `pgtap`,
+are included. There is currently no schema-allowlist option on the builder.
+System types and routines needed for reference resolution can appear as stubs.
+
+`analysisTimeout:` limits source analysis **per routine or view**, not the whole
+import or its database connection. Five seconds is the default. A large model
+can take time to build; raising this value does not add missing parser support.
+
+## What the model contains
 
-SQL and PL/pgSQL source is parsed with the corresponding grammar. All routine
-source is retained, including unsupported languages. Analysis is bounded per
-entity and records `visited`, `partial`, `failed`, `timedOut`,
-`unsupportedLanguage`, or `catalogOnly`. **`visited` means the parser and visitor
-finished without a recorded issue, not proof that every SQL construct is modeled.**
-Dynamic SQL is reported as partial; its runtime targets are not inferred.
-Ambiguous routine overloads retain multiple invocation candidates. Unqualified
-names still need more accurate PostgreSQL `search_path` handling.
+| Area | Entities and relationships |
+| --- | --- |
+| Schemas | `FmxSQLNamespace namespaceEntities` and inverse `parentNamespace` |
+| Tables | Ordinary, partitioned and foreign tables; columns, types and table inheritance |
+| Views | Ordinary and materialized views, columns and original source; `isMaterialized` distinguishes the latter |
+| Constraints | Primary/foreign keys, unique, not-null, CHECK and exclusion constraints |
+| Constraint calls | CHECK/exclusion `storedProceduresCalled` and inverse routine relations, extracted from catalog dependencies |
+| Routines | Functions/procedures, PostgreSQL OIDs, language, source, ordered parameters and parameter modes |
+| Triggers | Owning table/view, invoked trigger routine, event/timing metadata and NEW/OLD references where analysis succeeds |
+| Source analysis | Queries, clauses, variables, calls and structural references for supported syntax |
+| Source anchors | Original source ranges attached to queries, clauses and references |
 
-Export both the model and its diagnostics (analysis caches are not serialized
-by MSE):
+`FmxSQLStoredProcedure` is the model's historical name for general routines; it
+also represents PostgreSQL functions. Trigger routines specialize it. Names
+alone do not identify overloads: retain `postgresOid` and parameter information.
+All generated class names use **`FmxSQL`**. A workspace variable referring to a
+model of `mi` does not introduce a separate class prefix.
+
+The model preserves original routine/view source independently of whether the
+visitor could build a complete semantic representation. Unsupported languages
+remain represented as catalog entities with source.
+
+## Explore an imported model
+
+The following snippets run in the model Inspector, with `self` bound to the
+`FmxSQLModel` returned by `buildModel`.
+
+Count selected entity kinds:
+
+```smalltalk
+Dictionary new
+    at: #entities put: self entities size;
+    at: #namespaces put: (self allWithType: FmxSQLNamespace) size;
+    at: #tables put: (self allWithType: FmxSQLTable) size;
+    at: #foreignTables put: (self allWithType: FmxSQLForeignTable) size;
+    at: #views put: (self allWithType: FmxSQLView) size;
+    at: #routines put:
+        ((self allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) size;
+    at: #triggers put: (self allWithType: FmxSQLTrigger) size;
+    yourself.
+```
+
+Model counts can include synthetic/system stubs; they need not equal a direct
+count of application catalog rows. `allWithType:` selects the exact class,
+whereas `allWithSubTypesOf:` includes specialized entities.
+
+Inspect routines, including trigger routines, with their source and parameters:
+
+```smalltalk
+((self allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub)
+    collect: [ :routine |
+        { routine parentNamespace name.
+          routine name.
+          routine postgresOid.
+          routine languageName.
+          routine source.
+          (routine parameters sorted: [ :a :b | a position < b position ]) } ].
+```
+
+Inspect each trigger's owner and invoked routine:
+
+```smalltalk
+(self allWithType: FmxSQLTrigger) collect: [ :trigger |
+    { trigger parentNamespace name.
+      trigger name.
+      trigger table name.
+      trigger storedProcedure name } ].
+```
+
+The `table` relation also accepts a view, including the owner of an
+`INSTEAD OF` trigger.
+
+## Understand analysis coverage
+
+In the model Inspector:
+
+```smalltalk
+| report |
+report := self analysisReport.
+{ report at: 'routineCounts'.
+  report at: 'viewCounts'.
+  report at: 'errorCount'.
+  report at: 'warningCount' }.
+```
+
+Inspect routines requiring further analysis:
+
+```smalltalk
+(self analysisReport at: 'routines') reject: [ :entry |
+    (entry at: 'status') = 'visited' ].
+```
+
+Each routine entry includes its schema, name, OID, language, status and
+individual diagnostics. Views have corresponding entries under `views`.
+
+| Status | Meaning |
+| --- | --- |
+| `visited` | Parser and visitor finished without a recorded issue; this does not prove all semantics were modeled |
+| `partial` | Analysis completed with recorded warnings/errors, including unresolved references or dynamic SQL |
+| `failed` | Parsing or visiting failed; the original source remains available |
+| `timedOut` | Analysis exceeded the per-entity time limit |
+| `unsupportedLanguage` | Routine language has no supported source-analysis path |
+| `catalogOnly` | Catalog entity intentionally not analyzed as a routine body, such as an aggregate |
+| `untracked` | No analysis status is present, for example on a manually created entity |
+
+Known limitations include incomplete PostgreSQL grammar coverage, CTE/recursive
+query handling, composite/record fields, accurate `search_path` resolution and
+routine overload selection. Ambiguous calls retain candidate routines instead
+of choosing one arbitrarily. Runtime-dependent dynamic SQL targets are not
+guessed. Visitor failures are recorded while the import continues.
+
+The measured `mi` run produced **70,143 unique entities** and retained **569
+triggers**, **2,461 application routines** and **85 views**. It still had **520
+syntax failures** in the Smalltalk parser. These are not PostgreSQL reporting
+invalid stored code. There were also other analysis errors and warnings; syntax
+failures alone are not the complete coverage report. See the
+[migration audit](docs/pharo13-migration-audit.md) for the dated status breakdown.
+
+## Export and reload
+
+Export both the model and its diagnostics from the model Inspector:
 
 ```smalltalk
 'mi.mse' asFileReference writeStreamDo: [ :stream |
-  model exportToMSEStream: stream ].
+    self exportToMSEStream: stream ].
 'mi-analysis.json' asFileReference writeStreamDo: [ :stream |
-  stream nextPutAll: (NeoJSONWriter toString: model analysisReport) ].
+    stream nextPutAll: (NeoJSONWriter toString: self analysisReport) ].
+```
+
+Files are written relative to the image's working directory. Choose new paths
+when retaining previous exports. `NeoJSONWriter` is available in the tested
+Moose image; the FAMIXNGSQL baseline does not separately declare NeoJSON.
+
+Reload the model in a Playground with the metamodel and importer loaded:
+
+```smalltalk
+| restored |
+restored := 'mi.mse' asFileReference readStreamDo: [ :stream |
+    FmxSQLModel importFromMSEStream: stream ].
+restored inspect.
 ```
 
-## Tests and regeneration
+Read the separate report:
+
+```smalltalk
+'mi-analysis.json' asFileReference readStreamDo: [ :stream |
+    NeoJSONReader fromString: stream contents ].
+```
+
+MSE preserves modeled source and relations, but the analysis/error caches are
+not serialized. Use the companion JSON to inspect the original import's
+coverage; do not expect `restored analysisReport` to reconstruct it.
+
+The validation export was checked for unique IDs and missing references and
+reloaded with matching entity, routine, trigger and anchor counts. Routine/view
+source text matched exactly. Database-derived files under `artifacts/` are
+ignored by Git and are **not published in this repository**.
+
+## Tests
+
+Load the importer tests and their PgMetadata fixture support:
+
+```smalltalk
+Metacello new
+    baseline: 'FAMIXNGSQL';
+    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    load: 'Tests'.
+```
 
-Load the `Tests` group. Run database scenarios only against a disposable database:
+The database scenario performs DDL. Create a **disposable database** in advance
+and configure it explicitly; do not use `mi` or another application database:
 
 ```smalltalk
 PgScenarioTest connectionParameters:
-  (PgConnection hostname: 'localhost' port: 5435
-    database: 'pgmetadata_validation_20260917' user: 'bi' password: nil).
+    (PgConnection
+        hostname: 'localhost'
+        port: 5435
+        database: 'pgmetadata_validation_20260917'
+        user: 'bi'
+        password: nil).
+```
+
+The role must be allowed to create schemas, tables, routines and triggers in
+that database. Each scenario creates a UUID-named schema and drops it during
+teardown. The database itself must already exist.
+
+Run all importer test classes:
+
+```smalltalk
+| suite result |
+suite := TestSuite named: 'FAMIXNGSQL importer'.
+{ FmxSQLSymbolResolutionVisitorTest.
+  FmxSQLAnalysisReportingTest.
+  FmxSQLDatabaseImportTest }
+    do: [ :testClass | suite addTest: testClass suite ].
+result := suite run.
+result inspect.
 ```
 
-Load `Generator` to modify the metamodel. Release references to existing models
-before regenerating; live class migration of large models can take minutes.
-Use `FmxSQLMetamodelGenerator new generateWithCleaning`, then export the package
-to an empty directory and replace the old generated package. Overlaying files
-can leave obsolete classes behind, including `FmxSQLUnknownSourceLanguage`,
-whose old trait no longer exists in Moose 13.
+All **40 importer tests** passed in the validated image. Coverage includes
+symbol resolution, overload candidates, a real PostgreSQL schema with triggers
+and constraint calls, timeouts, retained source, inverse relations, and MSE
+identity/source round trips. Dependency suites previously passed 24 PgMetadata,
+95 P3 and 246 PostgreSQLParser tests; see the audit for the validation scope.
+There is no established fresh-image/version CI matrix yet.
+
+## Metamodel development
+
+Generated entities live in `src/FamixNGSQL`; importer extensions live in
+`src/FamixNGSQL-Importer`. Change the generator in
+`src/FAMIXNGSQLMetamodelGenerator` when changing the metamodel, then regenerate
+and review the generated diff. Keep handwritten importer behavior separate.
+
+Load the generator:
+
+```smalltalk
+Metacello new
+    baseline: 'FAMIXNGSQL';
+    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    load: 'Generator'.
+```
+
+Construct its definitions without installing regenerated classes:
+
+```smalltalk
+FmxSQLMetamodelGenerator new define.
+```
+
+Perform actual regeneration in a disposable development image after releasing
+model instances. `FmxSQLMetamodelGenerator new generateWithCleaning` removes and
+recreates the generated package; reload the handwritten extensions afterwards.
+Live migration of a large model can take minutes. Extension-package ownership
+across regeneration still needs a regression check; it is tracked in
+[issue #8](https://github.com/deem0n/FAMIXNGSQL/issues/8).
+
+Export generated source to an empty directory and review replacement of the
+old generated package. Overlaying an export leaves stale definitions behind.
+In particular, `FmxSQLUnknownSourceLanguage` is obsolete: its former
+`FamixTUnknownSourceLanguage` trait no longer exists in the tested Moose image.
+Do not restore that class merely to silence an old-image load warning.
+
+The generator preserves namespace ownership, source-holder/anchor direction,
+CHECK/exclusion routine links and reciprocal associations. MSE regression tests
+must continue checking identity and inverse relations, not only whether an
+export can be parsed.
+
+## License and origins
 
-The original Pharo 7 code is available from the upstream repository/history.
-Installing modern Genie in that old image is not required for this migration.
+Distributed under the [MIT license](LICENSE). This fork builds on
+[Julien Delplanque's FAMIXNGSQL](https://github.com/juliendelplanque/FAMIXNGSQL),
+with updated metadata extraction, SQL parsing and Moose metamodel integration.

From 3ab3795ca91f6236c9a2ba32cf84de664f889170 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:04:22 +0300
Subject: [PATCH 11/22] Exclude abstract SQL base from global metamodel
 regeneration

---
 README.md                                      | 18 ++++++++++++++++++
 docs/pharo13-migration-audit.md                |  6 ++++++
 .../BaselineOfFAMIXNGSQL.class.st              |  3 +++
 .../FmxSQLMetamodelGeneratorTest.class.st      | 17 +++++++++++++++++
 .../package.st                                 |  1 +
 ...FmxSQLStructuralMetamodelGenerator.class.st |  5 +++++
 6 files changed, 50 insertions(+)
 create mode 100644 src/FAMIXNGSQLMetamodelGenerator-Tests/FmxSQLMetamodelGeneratorTest.class.st
 create mode 100644 src/FAMIXNGSQLMetamodelGenerator-Tests/package.st

diff --git a/README.md b/README.md
index 17ed5f81..57cb1ff6 100644
--- a/README.md
+++ b/README.md
@@ -63,6 +63,7 @@ Keep `/src` in this repository URL. The default group also loads `Core`.
 | `Core` | Generated SQL metamodel and importer with their dependencies |
 | `Tests` | Core, importer tests and PgMetadata scenario-test support |
 | `Generator` | Core and the metamodel generator |
+| `GeneratorTests` | Generator plus its global-regeneration selection regression test |
 | `LegacyUI` | Historical GT Inspector, analysis, Telescope and connection-manager packages |
 
 `LegacyUI` has not been ported or validated on the current image. Core usage does
@@ -341,6 +342,23 @@ Construct its definitions without installing regenerated classes:
 FmxSQLMetamodelGenerator new define.
 ```
 
+`FmxSQLStructuralMetamodelGenerator` is an abstract base, so Moose's global
+regeneration selects only the concrete `FmxSQLMetamodelGenerator`. If an older
+loaded version reports `SubclassResponsibility` for the base class's `prefix`,
+load the updated generator, abandon the failed regeneration, and start it again.
+Its already-created generator list still contains the abstract class; resuming
+that old operation does not rebuild the list.
+
+The selection regression can be checked without regenerating classes:
+
+```smalltalk
+Metacello new
+    baseline: 'FAMIXNGSQL';
+    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    load: 'GeneratorTests'.
+FmxSQLMetamodelGeneratorTest suite run inspect.
+```
+
 Perform actual regeneration in a disposable development image after releasing
 model instances. `FmxSQLMetamodelGenerator new generateWithCleaning` removes and
 recreates the generated package; reload the handwritten extensions afterwards.
diff --git a/docs/pharo13-migration-audit.md b/docs/pharo13-migration-audit.md
index 9a080cb0..0497e964 100644
--- a/docs/pharo13-migration-audit.md
+++ b/docs/pharo13-migration-audit.md
@@ -20,6 +20,12 @@ analysis.
 
 ## Compatibility changes reviewed
 
+- Mark `FmxSQLStructuralMetamodelGenerator` abstract while keeping its concrete
+  subclass `FmxSQLMetamodelGenerator` eligible for generation. Otherwise Moose's
+  global regeneration attempts to instantiate the structural base and signals
+  `SubclassResponsibility` for `prefix`. The `GeneratorTests` group verifies
+  selection without installing regenerated classes; its regression failed
+  before the fix and passed afterwards in the running Pharo 13 image.
 - Regenerate the checked-in `FamixNGSQL` package on current Moose. Its old
   `FmxSQLUnknownSourceLanguage` definition referenced the removed
   `FamixTUnknownSourceLanguage` trait and caused a post-mortem load warning.
diff --git a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
index d80b7c63..64a884a6 100644
--- a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
+++ b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
@@ -12,6 +12,8 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 		do: [ spec
 				package: #FAMIXNGSQLMetamodelGenerator
 					with: [ spec requires: #('Famix') ];
+				package: #'FAMIXNGSQLMetamodelGenerator-Tests'
+					with: [ spec requires: #('FAMIXNGSQLMetamodelGenerator') ];
 				package: #'FamixNGSQL-Importer'
 					with: [ spec
 						requires: #('FamixNGSQL' 'PostgreSQLParser' 'PgMetadata' 'SymbolResolver' 'PetitParser') ];
@@ -62,6 +64,7 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 				group: 'default' with: #('Core');
 				group: 'Core' with: #('FamixNGSQL' 'FamixNGSQL-Importer');
 				group: 'Generator' with: #('Core' 'FAMIXNGSQLMetamodelGenerator');
+				group: 'GeneratorTests' with: #('Generator' 'FAMIXNGSQLMetamodelGenerator-Tests');
 				group: 'Tests' with: #('Core' 'FamixNGSQL-Importer-Tests');
 				group: 'LegacyUI' with: #('Core' 'FamixNGSQL-GTInspectorExtension' 'FAMIXNGSQLAnalysis' 'FAMIXNGSQLAnalysis-ConnectionsManager') ]
 ]
diff --git a/src/FAMIXNGSQLMetamodelGenerator-Tests/FmxSQLMetamodelGeneratorTest.class.st b/src/FAMIXNGSQLMetamodelGenerator-Tests/FmxSQLMetamodelGeneratorTest.class.st
new file mode 100644
index 00000000..4cc2d201
--- /dev/null
+++ b/src/FAMIXNGSQLMetamodelGenerator-Tests/FmxSQLMetamodelGeneratorTest.class.st
@@ -0,0 +1,17 @@
+Class {
+	#name : #FmxSQLMetamodelGeneratorTest,
+	#superclass : #TestCase,
+	#category : #'FAMIXNGSQLMetamodelGenerator-Tests'
+}
+
+{ #category : #tests }
+FmxSQLMetamodelGeneratorTest >> testGlobalRegenerationSkipsStructuralBase [
+	| generators |
+	self assert: FmxSQLStructuralMetamodelGenerator isAbstract.
+	self deny: FmxSQLMetamodelGenerator isAbstract.
+	generators := FamixMetamodelGenerator metamodelsToGenerate.
+	self deny: (generators includes: FmxSQLStructuralMetamodelGenerator).
+	self assert: (generators includes: FmxSQLMetamodelGenerator).
+	self assert: FmxSQLMetamodelGenerator prefix equals: #FmxSQL.
+	self assert: FmxSQLMetamodelGenerator packageName equals: #FamixNGSQL
+]
diff --git a/src/FAMIXNGSQLMetamodelGenerator-Tests/package.st b/src/FAMIXNGSQLMetamodelGenerator-Tests/package.st
new file mode 100644
index 00000000..b5c21544
--- /dev/null
+++ b/src/FAMIXNGSQLMetamodelGenerator-Tests/package.st
@@ -0,0 +1 @@
+Package { #name : #'FAMIXNGSQLMetamodelGenerator-Tests' }
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index 332ccc2c..68dfe395 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -33,6 +33,11 @@ Class {
 	#category : #FAMIXNGSQLMetamodelGenerator
 }
 
+{ #category : #testing }
+FmxSQLStructuralMetamodelGenerator class >> isAbstract [
+	^ self = FmxSQLStructuralMetamodelGenerator
+]
+
 { #category : #'comments - SQL' }
 FmxSQLStructuralMetamodelGenerator >> checkConstraintComment [
 	^ 'I represent a CHECK constraint as defined in SQL standard.'

From 96b25de6b447462048554c295ef066cff9cfeac4 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:35:52 +0300
Subject: [PATCH 12/22] Test Pharo 13 and prebuilt Moose 13 with PostgreSQL in
 CI

---
 .github/workflows/tests.yml                   | 46 +++++++++++++++++++
 .smalltalk.ston                               | 12 ++++-
 .travis.yml                                   | 35 ++++++++------
 scripts/ci/configure-database.st              | 17 +++++++
 scripts/ci/wait-for-postgres.sh               | 13 ++++++
 .../BaselineOfFAMIXNGSQL.class.st             |  4 +-
 6 files changed, 111 insertions(+), 16 deletions(-)
 create mode 100644 .github/workflows/tests.yml
 create mode 100644 scripts/ci/configure-database.st
 create mode 100644 scripts/ci/wait-for-postgres.sh

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 00000000..3b8c32dc
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,46 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{ matrix.image }} / PostgreSQL 15
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        image: [Pharo64-13, Moose64-13]
+    services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_DB: famixngsql_ci
+          POSTGRES_USER: famixngsql_ci
+          POSTGRES_PASSWORD: famixngsql_ci
+        ports:
+          - 55432:5432
+        options: >-
+          --health-cmd "pg_isready -U famixngsql_ci -d famixngsql_ci"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 12
+    env:
+      FAMIXNGSQL_TEST_HOST: 127.0.0.1
+      FAMIXNGSQL_TEST_PORT: '55432'
+      FAMIXNGSQL_TEST_DATABASE: famixngsql_ci
+      FAMIXNGSQL_TEST_USER: famixngsql_ci
+      FAMIXNGSQL_TEST_PASSWORD: famixngsql_ci
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: hpi-swa/setup-smalltalkCI@c0a3a3b942ac515b6c3846ca2f65802d353757ef # v1
+        with:
+          smalltalk-image: ${{ matrix.image }}
+      - name: Load and test in a clean image
+        run: smalltalkci -s '${{ matrix.image }}' .smalltalk.ston
diff --git a/.smalltalk.ston b/.smalltalk.ston
index 94c2ab51..7449f786 100644
--- a/.smalltalk.ston
+++ b/.smalltalk.ston
@@ -1,9 +1,19 @@
 SmalltalkCISpec {
+    #name : 'FAMIXNGSQL 2 - Pharo 13 / Moose 13 core',
     #loading : [
         SCIMetacelloLoadSpec {
             #baseline : 'FAMIXNGSQL',
             #directory : 'src',
+            #load : [ 'Tests', 'GeneratorTests' ],
+            #onConflict : #useIncoming,
+            #onUpgrade : #useIncoming,
             #platforms : [ #pharo ]
         }
-    ]
+    ],
+    #preTesting : 'scripts/ci/configure-database.st',
+    #testing : {
+        #packages : [ 'FamixNGSQL-Importer-Tests', 'FAMIXNGSQLMetamodelGenerator-Tests', 'PgMetadata-tests' ],
+        #defaultTimeout : 120,
+        #failOnZeroTests : true
+    }
 }
diff --git a/.travis.yml b/.travis.yml
index ddc5dd78..48bd6311 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,18 +1,27 @@
 language: smalltalk
-sudo: false
-
+dist: jammy
+os: linux
+services:
+  - docker
+smalltalk:
+  - Pharo64-13
+  - Moose64-13
+smalltalk_edge:
+  source: hpi-swa/smalltalkCI
+  branch: master
+env:
+  global:
+    - FAMIXNGSQL_TEST_HOST=127.0.0.1
+    - FAMIXNGSQL_TEST_PORT=55432
+    - FAMIXNGSQL_TEST_DATABASE=famixngsql_ci
+    - FAMIXNGSQL_TEST_USER=famixngsql_ci
+    - FAMIXNGSQL_TEST_PASSWORD=famixngsql_ci
+before_script:
+  - docker run --detach --name famixngsql-postgres --publish 127.0.0.1:55432:5432 --env POSTGRES_DB=famixngsql_ci --env POSTGRES_USER=famixngsql_ci --env POSTGRES_PASSWORD=famixngsql_ci postgres:15
+  - bash scripts/ci/wait-for-postgres.sh
+script:
+  - smalltalkci .smalltalk.ston
 notifications:
     email:
         on_success: never
         on_failure: always
-
-os:
-    - linux
-    - osx
-
-smalltalk_edge:
-    source: peteruhnak/smalltalkCI
-    branch: master
-
-smalltalk:
-    - Pharo-7.0
diff --git a/scripts/ci/configure-database.st b/scripts/ci/configure-database.st
new file mode 100644
index 00000000..c6cb2aa7
--- /dev/null
+++ b/scripts/ci/configure-database.st
@@ -0,0 +1,17 @@
+"Only explicit CI settings are accepted: never fall back to an application database."
+| environment required value |
+environment := Smalltalk os environment.
+required := [ :name |
+	value := environment at: name ifAbsent: [ self error: 'Missing CI setting: ', name ].
+	value ifEmpty: [ self error: 'Empty CI setting: ', name ].
+	value ].
+PgScenarioTest connectionParameters:
+	(PgConnection
+		hostname: (required value: 'FAMIXNGSQL_TEST_HOST')
+		port: (required value: 'FAMIXNGSQL_TEST_PORT') asInteger
+		database: (required value: 'FAMIXNGSQL_TEST_DATABASE')
+		user: (required value: 'FAMIXNGSQL_TEST_USER')
+		password: (required value: 'FAMIXNGSQL_TEST_PASSWORD')).
+Transcript
+	show: 'Runtime: ', Smalltalk version; cr;
+	show: 'Database scenarios configured for a disposable CI database.'; cr.
diff --git a/scripts/ci/wait-for-postgres.sh b/scripts/ci/wait-for-postgres.sh
new file mode 100644
index 00000000..7af7ed83
--- /dev/null
+++ b/scripts/ci/wait-for-postgres.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+for attempt in {1..60}; do
+  if docker exec famixngsql-postgres pg_isready --username=famixngsql_ci --dbname=famixngsql_ci; then
+    exit 0
+  fi
+  sleep 1
+done
+
+docker logs famixngsql-postgres
+echo 'PostgreSQL did not become ready within 60 seconds.' >&2
+exit 1
diff --git a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
index 64a884a6..e7862502 100644
--- a/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
+++ b/src/BaselineOfFAMIXNGSQL/BaselineOfFAMIXNGSQL.class.st
@@ -29,7 +29,7 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 			spec
 				baseline: 'Famix'
 				with: [ spec
-						repository: 'github://moosetechnology/Famix:development/src';
+						repository: 'github://moosetechnology/Famix:4fd41546375e0ab86a4920eff547cc898e22db0b/src';
 						loads: #('Core' 'Basic') ].
 			spec
 				baseline: 'SymbolResolver'
@@ -43,7 +43,7 @@ BaselineOfFAMIXNGSQL >> baseline: spec [
 				baseline: 'PetitParser'
 				with: [ spec
 						loads: #('Preprocessor');
-						repository: 'github://moosetechnology/PetitParser/src' ].
+						repository: 'github://moosetechnology/PetitParser:5bdaf9f36793bf355e863c1accfbcc6162a6b034/src' ].
 			spec
 				baseline: 'PgMetadata'
 				with: [ spec

From ae51a39b4280bee7801e9c04c9ae5f1c1541315f Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:39:48 +0300
Subject: [PATCH 13/22] Use a filesystem-safe smalltalkCI report name

---
 .smalltalk.ston | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.smalltalk.ston b/.smalltalk.ston
index 7449f786..fd66e1a5 100644
--- a/.smalltalk.ston
+++ b/.smalltalk.ston
@@ -1,5 +1,5 @@
 SmalltalkCISpec {
-    #name : 'FAMIXNGSQL 2 - Pharo 13 / Moose 13 core',
+    #name : 'FAMIXNGSQL-2-Pharo13-Moose13',
     #loading : [
         SCIMetacelloLoadSpec {
             #baseline : 'FAMIXNGSQL',

From cf7792ccf2efcad62ed80aca8d631b02ae5780d4 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:43:31 +0300
Subject: [PATCH 14/22] Prepare v2.0.0 release notes and publish CI test
 reports

---
 .github/workflows/tests.yml      |  8 ++++
 CHANGELOG.md                     | 64 +++++++++++++++++++++++++++
 README.md                        | 76 ++++++++++++++++++++++++++------
 docs/pharo13-migration-audit.md  | 22 +++++++--
 scripts/ci/configure-database.st |  5 +++
 5 files changed, 158 insertions(+), 17 deletions(-)
 create mode 100644 CHANGELOG.md

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 3b8c32dc..5633c9c9 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -44,3 +44,11 @@ jobs:
           smalltalk-image: ${{ matrix.image }}
       - name: Load and test in a clean image
         run: smalltalkci -s '${{ matrix.image }}' .smalltalk.ston
+      - name: Upload JUnit results
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: ${{ matrix.image }}-test-results
+          path: FAMIXNGSQL-2-Pharo13-Moose13.xml
+          if-no-files-found: warn
+          retention-days: 14
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..ad62985b
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,64 @@
+# Changelog
+
+## 2.0.0 — 2026-09-17
+
+This is the Pharo 13 / Moose 13 migration of FAMIXNGSQL. It supersedes the
+historical Pharo 7 release; the `v1.0.0` tag remains unchanged.
+
+### Breaking changes
+
+- Use `github://deem0n/FAMIXNGSQL:v2.0.0/src` to install the release. Packages use
+  Tonel under `src`; historical `/repository` loading instructions do not apply.
+- Use `FmxSQLModel` in place of the historical `FmxSQLMooseModel`.
+- Generated classes and traits target the current Famix infrastructure. Pharo 7,
+  Pharo 10 and older Moose versions are not supported by this release's tests.
+- The default group is `Core`. Historical GT/Telescope/connection-manager UI
+  packages are isolated in `LegacyUI` and are not validated for this release.
+- Regenerated containment and source-anchor relations may differ from older
+  MSE exports. Cross-version import of historical MSE files is not guaranteed.
+
+### Model and importer
+
+- Restore namespace ownership, association direction and source-holder/anchor
+  relationships on the current metamodel builder.
+- Preserve CHECK and exclusion constraint calls to routines and inverse links.
+- Integrate updated PgMetadata extraction through upstream P3 code, including
+  materialized views, partitioned/foreign tables, routine OIDs/languages,
+  parameter order/modes and trigger ownership on tables or views.
+- Read catalogs in a read-only, repeatable-read transaction and close the
+  metadata connection after extraction.
+- Use separate SQL and PL/pgSQL parser entry points. Preserve source when
+  syntax, language or name resolution is unsupported.
+- Record per-object analysis status, diagnostics and timeouts. Ambiguous calls
+  retain candidate routines; runtime-dependent dynamic SQL targets are not guessed.
+- Preserve entity identity, inverse relations and source anchors through MSE
+  export/import. Export diagnostics separately as JSON.
+- Exclude the abstract structural base generator from global regeneration.
+
+### Tests and continuous integration
+
+- Share smalltalkCI configuration between Travis CI and GitHub Actions.
+- Test both a plain Pharo 13 image and the ready-made Moose 13 / Pharo 13 image
+  against a disposable PostgreSQL 15 service.
+- Run importer, metamodel-generator selection and PgMetadata suites. Fixtures
+  create unique schemas and clean them up after each scenario.
+
+### Known limits
+
+- SQL/PL/pgSQL parsing and semantic analysis are incomplete. The documented `mi`
+  import retained 70,143 unique entities but still reported 520 parser syntax
+  failures and additional reference-resolution errors. Consult the analysis
+  report rather than treating a completed import as complete source coverage.
+- The upstream Moose 13 image is a rolling development build. Other runtime
+  combinations and `LegacyUI` remain unvalidated.
+- Some transitive dependencies still follow upstream branches; the dependency
+  stack is not fully frozen by the FAMIXNGSQL tag alone.
+- Package ownership after metamodel regeneration remains tracked in issue #8.
+
+See [README](README.md) for installation and examples, and the
+[migration audit](docs/pharo13-migration-audit.md) for detailed evidence.
+
+## 1.0.0 — 2019-09-02
+
+Historical upstream release for Pharo 7:
+[release notes](https://github.com/juliendelplanque/FAMIXNGSQL/releases/tag/v1.0.0).
diff --git a/README.md b/README.md
index 57cb1ff6..6b35d52c 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,12 @@
 # FAMIXNGSQL
 
+[![Tests](https://github.com/deem0n/FAMIXNGSQL/actions/workflows/tests.yml/badge.svg)](https://github.com/deem0n/FAMIXNGSQL/actions/workflows/tests.yml)
+
 FAMIXNGSQL builds a FAMIX model of a PostgreSQL database: schemas, tables, views,
 constraints, routines, triggers, source code and references between entities.
-The current `master` includes the Pharo 13 / Moose 13 migration and the updated
-PgMetadata and PostgreSQLParser integrations.
+Version **2.0.0** includes the Pharo 13 / Moose 13 migration and the updated
+PgMetadata and PostgreSQLParser integrations. See the [changelog](CHANGELOG.md)
+for breaking changes from `v1.0.0`.
 
 The import has two stages:
 
@@ -31,32 +34,43 @@ Validated on **2026-09-17**:
 | PostgreSQLParser | `f9d1b0850cb7cde2839760d87f54f04ba9de315e`, group `core-no-gui` |
 | SymbolResolver | `c6eb29c46cd36cabb8dff5d19329085ee8fa38c7` |
 | P3 | `d45f0d358f41ff809fd85f26046a63630a3a7bef`, synchronized with upstream `svenvc/P3` |
+| Famix | `4fd41546375e0ab86a4920eff547cc898e22db0b`, the Moose 13 core used for validation |
+| PetitParser | `5bdaf9f36793bf355e863c1accfbcc6162a6b034` |
 
-Tests ran in an **existing Pharo 13/Moose 13 image**. A complete Metacello install
-in a fresh image has not yet been validated. Pharo 7, Pharo 10, other Moose
-versions and other PostgreSQL versions are not certified by this migration.
+Validation includes the existing Pharo 13/Moose 13 image and clean CI installs
+in **Pharo64-13** and **Moose64-13**, each with PostgreSQL 15. Pharo 7, Pharo 10,
+other Moose versions and other PostgreSQL versions are not certified by this
+migration.
 Historical implementations remain available in Git history and the
 [original upstream repository](https://github.com/juliendelplanque/FAMIXNGSQL).
 
 PgMetadata alone does not require Moose, but the FAMIXNGSQL importer does.
-The baseline pins PgMetadata, PostgreSQLParser and SymbolResolver to commits.
-Famix (`development`), PetitParser and the transitive P3 dependency (`master`)
-still use moving branches, so this is not yet a fully pinned dependency stack.
+The baseline specifies commit revisions for PgMetadata, PostgreSQLParser,
+SymbolResolver, Famix and PetitParser. Upstream baselines still reference
+moving branches, including Fame, P3 and other transitive dependencies, so this
+is not yet a fully frozen dependency stack. The table records the revisions
+observed during validation.
 Deleting this repository's merged development branches does not remove the
 pinned dependency commits.
 
 ## Installation
 
-In a Pharo 13/Moose 13 Playground:
+In a Pharo 13 or Moose 13/Pharo 13 Playground:
 
 ```smalltalk
 Metacello new
     baseline: 'FAMIXNGSQL';
-    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    repository: 'github://deem0n/FAMIXNGSQL:v2.0.0/src';
     load: 'Core'.
 ```
 
 Keep `/src` in this repository URL. The default group also loads `Core`.
+Use `:master/src` instead when intentionally testing unreleased development.
+
+To start with Moose preinstalled, download the official
+[Moose 13 / Pharo 13 image](https://github.com/moosetechnology/Moose/releases/download/continuous/Moose13-development-Pharo64-13.zip)
+or select it in Pharo Launcher. It is a rolling **development** image, not an
+immutable Moose 13 release. smalltalkCI selects it with `Moose64-13`.
 
 | Group | Purpose |
 | --- | --- |
@@ -279,7 +293,7 @@ Load the importer tests and their PgMetadata fixture support:
 ```smalltalk
 Metacello new
     baseline: 'FAMIXNGSQL';
-    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    repository: 'github://deem0n/FAMIXNGSQL:v2.0.0/src';
     load: 'Tests'.
 ```
 
@@ -318,7 +332,41 @@ symbol resolution, overload candidates, a real PostgreSQL schema with triggers
 and constraint calls, timeouts, retained source, inverse relations, and MSE
 identity/source round trips. Dependency suites previously passed 24 PgMetadata,
 95 P3 and 246 PostgreSQLParser tests; see the audit for the validation scope.
-There is no established fresh-image/version CI matrix yet.
+
+## Continuous integration
+
+[GitHub Actions](https://github.com/deem0n/FAMIXNGSQL/actions/workflows/tests.yml)
+and [.travis.yml](.travis.yml) use the same [.smalltalk.ston](.smalltalk.ston).
+Both test `Pharo64-13` and the ready-made `Moose64-13` image on Linux, against a
+disposable PostgreSQL 15 container. This is a two-image compatibility matrix;
+it does not establish support for other Pharo or Moose versions.
+
+Each job loads `Tests` and `GeneratorTests` from the checked-out source and runs
+**65 tests**: 40 importer, 1 generator-selection and 24 PgMetadata tests. Tests
+that need a database always use explicit `FAMIXNGSQL_TEST_*` settings. Missing
+settings fail the job instead of falling back to a local/application database.
+The container contains no application data and is discarded after the job.
+
+GitHub Actions runs on pushes, pull requests and manual **Run workflow**
+requests. JUnit XML reports are uploaded as artifacts for each image. Travis
+requires this repository to be enabled in the owner's Travis account; the YAML
+configuration alone does not activate that external service.
+
+To run the same suite locally with smalltalkCI and an existing disposable
+database, set the connection parameters explicitly:
+
+```sh
+export FAMIXNGSQL_TEST_HOST=127.0.0.1
+export FAMIXNGSQL_TEST_PORT=55432
+export FAMIXNGSQL_TEST_DATABASE=famixngsql_ci
+export FAMIXNGSQL_TEST_USER=famixngsql_ci
+export FAMIXNGSQL_TEST_PASSWORD=famixngsql_ci
+smalltalkci -s Moose64-13 .smalltalk.ston
+```
+
+Substitute your disposable database's settings. `Pharo64-13` selects the plain
+image installation path. The passwords in the CI configurations are only for
+the disposable service created inside each job.
 
 ## Metamodel development
 
@@ -332,7 +380,7 @@ Load the generator:
 ```smalltalk
 Metacello new
     baseline: 'FAMIXNGSQL';
-    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    repository: 'github://deem0n/FAMIXNGSQL:v2.0.0/src';
     load: 'Generator'.
 ```
 
@@ -354,7 +402,7 @@ The selection regression can be checked without regenerating classes:
 ```smalltalk
 Metacello new
     baseline: 'FAMIXNGSQL';
-    repository: 'github://deem0n/FAMIXNGSQL:master/src';
+    repository: 'github://deem0n/FAMIXNGSQL:v2.0.0/src';
     load: 'GeneratorTests'.
 FmxSQLMetamodelGeneratorTest suite run inspect.
 ```
diff --git a/docs/pharo13-migration-audit.md b/docs/pharo13-migration-audit.md
index 0497e964..d174279d 100644
--- a/docs/pharo13-migration-audit.md
+++ b/docs/pharo13-migration-audit.md
@@ -93,8 +93,8 @@ complete PostgreSQL semantics or dependency coverage.
 
 The MSE artifact retains source and structural/reference relations. A separate
 JSON report records per-entity status and diagnostics. Local database artifacts
-are ignored by Git. No fresh-image Metacello install or legacy UI validation has
-been performed.
+are ignored by Git. Legacy UI validation has not been performed. Fresh-image
+validation was added during release preparation; see the CI section below.
 
 ## Remaining work
 
@@ -107,7 +107,8 @@ been performed.
   explicitly and its targets are not guessed.
 - Remove remaining visitor Halts with supported semantics and regression tests;
   the importer currently records them as failures and continues.
-- Pin/validate the complete dependency stack in a fresh image before a release.
+- Freeze the remaining transitive dependency branches. Clean-image validation
+  now passes on the two CI targets described below.
 
 ## Export integrity fixes
 
@@ -124,3 +125,18 @@ reference IDs. Reloaded model counts match: 70,143 entities, 569 triggers,
 Routine and view source text was checked for exact equality after reloading.
 The snapshots are `artifacts/mi-20260917.mse` and
 `artifacts/mi-20260917-analysis.json` in the local working repository.
+
+## Release CI validation (2026-09-17)
+
+GitHub Actions run [35272163591](https://github.com/deem0n/FAMIXNGSQL/actions/runs/35272163591)
+loaded the checkout in both plain `Pharo64-13` and official prebuilt
+`Moose64-13` images. Both jobs passed all 65 tests: 40 importer tests, the
+generator-selection regression and 24 PgMetadata tests, against PostgreSQL 15
+in disposable containers. This supersedes the earlier fresh-image validation
+gap; it does not extend the supported matrix to older Pharo/Moose versions.
+
+Travis and GitHub Actions share `.smalltalk.ston`. Travis execution requires
+the repository's external Travis integration to be enabled separately.
+
+The first CI attempt passed the tests but failed writing JUnit XML because the
+suite name contained a slash. The suite name is now filesystem-safe.
diff --git a/scripts/ci/configure-database.st b/scripts/ci/configure-database.st
index c6cb2aa7..684f46c0 100644
--- a/scripts/ci/configure-database.st
+++ b/scripts/ci/configure-database.st
@@ -1,5 +1,10 @@
 "Only explicit CI settings are accepted: never fall back to an application database."
 | environment required value |
+(Smalltalk version beginsWith: 'Pharo13.') ifFalse: [
+	self error: 'This CI target requires Pharo 13' ].
+Smalltalk globals at: #MooseVersion ifPresent: [ :versionClass |
+	versionClass current major = 13 ifFalse: [
+		self error: 'The prebuilt Moose CI target requires Moose 13' ] ].
 environment := Smalltalk os environment.
 required := [ :name |
 	value := environment at: name ifAbsent: [ self error: 'Missing CI setting: ', name ].

From d5c7c69360fd91c99d303b8cd475f0227d7f4afd Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:46:35 +0300
Subject: [PATCH 15/22] Accept the string-valued Moose major version in CI

---
 scripts/ci/configure-database.st | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/ci/configure-database.st b/scripts/ci/configure-database.st
index 684f46c0..7f668e2d 100644
--- a/scripts/ci/configure-database.st
+++ b/scripts/ci/configure-database.st
@@ -3,7 +3,7 @@
 (Smalltalk version beginsWith: 'Pharo13.') ifFalse: [
 	self error: 'This CI target requires Pharo 13' ].
 Smalltalk globals at: #MooseVersion ifPresent: [ :versionClass |
-	versionClass current major = 13 ifFalse: [
+	versionClass current major asString = '13' ifFalse: [
 		self error: 'The prebuilt Moose CI target requires Moose 13' ] ].
 environment := Smalltalk os environment.
 required := [ :name |

From 55c0780d4771e22491bf6b6f8d732ceda8b93ddf Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Thu, 17 Sep 2026 23:50:25 +0300
Subject: [PATCH 16/22] Update GitHub Actions to Node.js 24 releases

---
 .github/workflows/tests.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 5633c9c9..e2804ef8 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -38,7 +38,7 @@ jobs:
       FAMIXNGSQL_TEST_USER: famixngsql_ci
       FAMIXNGSQL_TEST_PASSWORD: famixngsql_ci
     steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - uses: hpi-swa/setup-smalltalkCI@c0a3a3b942ac515b6c3846ca2f65802d353757ef # v1
         with:
           smalltalk-image: ${{ matrix.image }}
@@ -46,7 +46,7 @@ jobs:
         run: smalltalkci -s '${{ matrix.image }}' .smalltalk.ston
       - name: Upload JUnit results
         if: always()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: ${{ matrix.image }}-test-results
           path: FAMIXNGSQL-2-Pharo13-Moose13.xml

From 36902173cca85e10957b04f3ea99e74d9299ca81 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Fri, 18 Sep 2026 00:23:33 +0300
Subject: [PATCH 17/22] Display PostgreSQL as the SQL model source language

---
 .../FmxSQLSourceLanguage.extension.st                    | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/FamixNGSQL-Importer/FmxSQLSourceLanguage.extension.st

diff --git a/src/FamixNGSQL-Importer/FmxSQLSourceLanguage.extension.st b/src/FamixNGSQL-Importer/FmxSQLSourceLanguage.extension.st
new file mode 100644
index 00000000..4c768de6
--- /dev/null
+++ b/src/FamixNGSQL-Importer/FmxSQLSourceLanguage.extension.st
@@ -0,0 +1,9 @@
+Extension { #name : #FmxSQLSourceLanguage }
+
+{ #category : #'*FamixNGSQL-Importer' }
+FmxSQLSourceLanguage >> name [
+	<FMProperty: #name type: #String>
+	<derived>
+	<FMComment: 'The name of the language'>
+	^ 'PostgreSQL'
+]

From 492973484fac63ff41c83ac71b2004bb18c7fc65 Mon Sep 17 00:00:00 2001
From: Nicolas Anquetil <anquetil.nicolas@gmail.com>
Date: Sun, 20 Sep 2026 13:04:42 +0200
Subject: [PATCH 18/22] Update README.md

correcting Pharo script as it is not possible to assign a value to 'self'
---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 6b35d52c..c5b93ffb 100644
--- a/README.md
+++ b/README.md
@@ -152,21 +152,21 @@ remain represented as catalog entities with source.
 
 ## Explore an imported model
 
-The following snippets run in the model Inspector, with `self` bound to the
-`FmxSQLModel` returned by `buildModel`.
+The following snippets run in the model Inspector, with `model` bound to the
+`FmxSQLModel` returned by `buildModel` (see above [Connect and build a model](#connect-and-build-a-model)).
 
 Count selected entity kinds:
 
 ```smalltalk
 Dictionary new
-    at: #entities put: self entities size;
-    at: #namespaces put: (self allWithType: FmxSQLNamespace) size;
-    at: #tables put: (self allWithType: FmxSQLTable) size;
-    at: #foreignTables put: (self allWithType: FmxSQLForeignTable) size;
-    at: #views put: (self allWithType: FmxSQLView) size;
+    at: #entities put: model entities size;
+    at: #namespaces put: (model allWithType: FmxSQLNamespace) size;
+    at: #tables put: (model allWithType: FmxSQLTable) size;
+    at: #foreignTables put: (model allWithType: FmxSQLForeignTable) size;
+    at: #views put: (model allWithType: FmxSQLView) size;
     at: #routines put:
-        ((self allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) size;
-    at: #triggers put: (self allWithType: FmxSQLTrigger) size;
+        ((model allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) size;
+    at: #triggers put: (model allWithType: FmxSQLTrigger) size;
     yourself.
 ```
 

From 660aa7da31c8e918addc554f5da048c92c1b1a31 Mon Sep 17 00:00:00 2001
From: Nicolas Anquetil <anquetil.nicolas@gmail.com>
Date: Sun, 20 Sep 2026 13:15:29 +0200
Subject: [PATCH 19/22] Refactor entity count code in README.md

Cleaner way to create and populate a Dictionary
---
 README.md | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index c5b93ffb..52d3b6f5 100644
--- a/README.md
+++ b/README.md
@@ -158,16 +158,15 @@ The following snippets run in the model Inspector, with `model` bound to the
 Count selected entity kinds:
 
 ```smalltalk
-Dictionary new
-    at: #entities put: model entities size;
-    at: #namespaces put: (model allWithType: FmxSQLNamespace) size;
-    at: #tables put: (model allWithType: FmxSQLTable) size;
-    at: #foreignTables put: (model allWithType: FmxSQLForeignTable) size;
-    at: #views put: (model allWithType: FmxSQLView) size;
-    at: #routines put:
-        ((model allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) size;
-    at: #triggers put: (model allWithType: FmxSQLTrigger) size;
-    yourself.
+Dictionary newFrom: {
+    #entities   -> model entities size .
+    #namespaces -> (model allWithType: FmxSQLNamespace) size .
+    #tables     -> (model allWithType: FmxSQLTable) size .
+    #foreignTables -> (model allWithType: FmxSQLForeignTable) size .
+    #views      -> (model allWithType: FmxSQLView) size .
+    #routines   -> ((model allWithSubTypesOf: FmxSQLStoredProcedure) reject: #isStub) size .
+    #triggers   -> (model allWithType: FmxSQLTrigger) size
+	}
 ```
 
 Model counts can include synthetic/system stubs; they need not equal a direct

From 4b19ec1e4efb2867f3e33e821fd1b262f866cae0 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Sun, 20 Sep 2026 15:39:06 +0300
Subject: [PATCH 20/22] Rename SQL query relations to preserve Moose navigation

---
 README.md                                     | 30 +++++++
 .../FmxSQLMetamodelGenerator.class.st         |  6 +-
 .../FmxSQLAnalysisReportingTest.class.st      |  8 +-
 .../FmxSQLDatabaseImportTest.class.st         |  2 +-
 .../FmxSQLQueryCompatibilityTest.class.st     | 84 +++++++++++++++++++
 ...FmxSQLSymbolResolutionVisitorTest.class.st | 18 ++--
 .../FmxSQLCursor.extension.st                 |  2 +-
 .../FmxSQLDerivedTable.extension.st           |  2 +-
 .../FmxSQLModelBuilder.class.st               |  2 +-
 .../FmxSQLSymbolResolutionVisitor.class.st    | 22 ++---
 .../PSQLASTValuesNullObject.class.st          |  2 +-
 src/FamixNGSQL/FmxSQLCRUDQuery.class.st       | 12 +--
 src/FamixNGSQL/FmxSQLClause.class.st          | 14 ++--
 src/FamixNGSQL/FmxSQLDerivedTable.class.st    | 14 ++--
 src/FamixNGSQL/FmxSQLSelectQuery.class.st     |  6 +-
 src/FamixNGSQL/FmxSQLView.class.st            | 14 ++--
 16 files changed, 176 insertions(+), 62 deletions(-)
 create mode 100644 src/FamixNGSQL-Importer-Tests/FmxSQLQueryCompatibilityTest.class.st

diff --git a/README.md b/README.md
index 6b35d52c..f79ba8c3 100644
--- a/README.md
+++ b/README.md
@@ -200,6 +200,36 @@ Inspect each trigger's owner and invoked routine:
 The `table` relation also accepts a view, including the owner of an
 `INSTEAD OF` trigger.
 
+### SQL queries and Moose navigation (master after v2.0.0)
+
+SQL relations use `sqlQuery` so that `query` remains available for Moose's
+navigation API:
+
+| Entity | SQL accessor | Meaning |
+| --- | --- | --- |
+| `FmxSQLView` | `sqlQuery` / `sqlQuery:` | SELECT query defining the view |
+| `FmxSQLDerivedTable` | `sqlQuery` / `sqlQuery:` | Query defining the derived table |
+| `FmxSQLClause` and subclasses | `sqlQuery` / `sqlQuery:` | Query containing the clause |
+| `FmxSQLCursor` | `sqlQuery` | Single query in the cursor's `queries` collection |
+
+For example, in a view's Inspector:
+
+```smalltalk
+self sqlQuery. "Parsed SQL definition; can be nil after incomplete analysis"
+self query. "MooseQuery navigation object"
+self queryLocal: #in with: FmxSQLViewReference.
+```
+
+This is a breaking change from v2.0.0: update SQL-domain callers of `query`
+and `query:`. There are no compatibility aliases or MSE property translations.
+The parser AST API is unchanged. The metamodel generator defines the new names,
+including the opposite relations, so regeneration preserves them.
+
+Use a fresh image and rebuild models from PostgreSQL, or explicitly preserve
+and restore the old slot values when upgrading a populated image. Older MSE
+files that contain a clause's `query` property require migration before import;
+new exports use `sqlQuery`. Keep the old image/export until migration is verified.
+
 ## Understand analysis coverage
 
 In the model Inspector:
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index f1fb1907..37eede0d 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -244,13 +244,13 @@ FmxSQLMetamodelGenerator >> defineBehaviouralEntitiesRelations [
 		*-* (storedProcedure property: #exclusionConstraintsCalling).
 
 	"A View is defined as a SelectQuery."
-	queryRelation := (view property: #query)
+	queryRelation := (view property: #sqlQuery)
 		<>- (selectQuery property: #viewDefining).
 	queryRelation derived.
 	queryRelation oppositeSide notDerived.
 	
 	"A DerivedTable is defined as a CRUD query."
-	queryRelation := (derivedTable property: #query)
+	queryRelation := (derivedTable property: #sqlQuery)
 		<>- (crudQuery property: #derivedTableDefining).
 	queryRelation derived.
 	queryRelation oppositeSide notDerived.
@@ -447,7 +447,7 @@ FmxSQLMetamodelGenerator >> defineBehaviouralReferenceRelations [
 
 	"A query contains multiple clauses"
 	(crudQuery property: #clauses)
-		<>-* (clause property: #query).
+		<>-* (clause property: #sqlQuery).
 
 	"A QueryContainer contains multiple queries"
 	(tQueryContainer property: #queries)
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
index 91f764d5..65edf7ab 100644
--- a/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLAnalysisReportingTest.class.st
@@ -76,14 +76,14 @@ FmxSQLAnalysisReportingTest >> testQueryRelationsSurviveMSERoundTripWithoutDupli
 	derived := FmxSQLDerivedTable new mooseModel: model; yourself.
 	viewQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
 	derivedQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
-	view query: viewQuery.
-	derived query: derivedQuery.
+	view sqlQuery: viewQuery.
+	derived sqlQuery: derivedQuery.
 	self assert: viewQuery viewDefining identicalTo: view.
 	self assert: derivedQuery derivedTableDefining identicalTo: derived.
 	serialized := String streamContents: [ :stream | model exportToMSEStream: stream ].
 	restored := FmxSQLModel importFromMSEStream: serialized readStream.
 	self assert: restored size equals: model size.
 	self assert: (restored allWithType: FmxSQLSelectQuery) size equals: 2.
-	self assert: (restored allWithType: FmxSQLView) anyOne query viewDefining identicalTo: (restored allWithType: FmxSQLView) anyOne.
-	self assert: (restored allWithType: FmxSQLDerivedTable) anyOne query derivedTableDefining identicalTo: (restored allWithType: FmxSQLDerivedTable) anyOne
+	self assert: (restored allWithType: FmxSQLView) anyOne sqlQuery viewDefining identicalTo: (restored allWithType: FmxSQLView) anyOne.
+	self assert: (restored allWithType: FmxSQLDerivedTable) anyOne sqlQuery derivedTableDefining identicalTo: (restored allWithType: FmxSQLDerivedTable) anyOne
 ]
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
index 92308542..3e5d8782 100644
--- a/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLDatabaseImportTest.class.st
@@ -37,7 +37,7 @@ CREATE TRIGGER view_insert INSTEAD OF INSERT ON {1}.account_view FOR EACH ROW EX
 	self assert: routine parameters size equals: 1.
 	self assert: routine parameters anyOne position equals: 1.
 	self assert: (routine source includesSubstring: 'UPDATE').
-	self assert: view query isNotNil.
+	self assert: view sqlQuery isNotNil.
 	trigger := view triggers anyOne.
 	self assert: trigger table identicalTo: view.
 	self assert: trigger storedProcedure queries isNotEmpty.
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLQueryCompatibilityTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLQueryCompatibilityTest.class.st
new file mode 100644
index 00000000..948fcec2
--- /dev/null
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLQueryCompatibilityTest.class.st
@@ -0,0 +1,84 @@
+Class {
+	#name : #FmxSQLQueryCompatibilityTest,
+	#superclass : #TestCase,
+	#category : #'FamixNGSQL-Importer-Tests'
+}
+
+{ #category : #tests }
+FmxSQLQueryCompatibilityTest >> testSQLAccessorsLeaveMooseQueryAvailable [
+	| model sqlQuery view derived clause cursor |
+	model := FmxSQLModel new.
+	sqlQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
+	view := FmxSQLView new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	derived := FmxSQLDerivedTable new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	clause := FmxSQLSelectClause new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	cursor := FmxSQLCursor new mooseModel: model; yourself.
+	cursor addQuery: sqlQuery.
+	{ view. derived. clause. cursor } do: [ :entity |
+		self assert: entity sqlQuery identicalTo: sqlQuery.
+		self assert: (entity query isKindOf: MooseQuery).
+		self assert: (entity queryLocal: #in with: FmxSQLTableReference) isEmpty ]
+]
+
+{ #category : #tests }
+FmxSQLQueryCompatibilityTest >> testOppositesUpdateWhenSQLQueryChanges [
+	| first second view derived clause |
+	first := FmxSQLSelectQuery new.
+	second := FmxSQLSelectQuery new.
+	view := FmxSQLView new sqlQuery: first; yourself.
+	derived := FmxSQLDerivedTable new sqlQuery: first; yourself.
+	clause := FmxSQLWhereClause new sqlQuery: first; yourself.
+	self assert: first viewDefining identicalTo: view.
+	self assert: first derivedTableDefining identicalTo: derived.
+	self assert: (first clauses includes: clause).
+	view sqlQuery: second.
+	derived sqlQuery: second.
+	clause sqlQuery: second.
+	self assert: first viewDefining isNil.
+	self assert: first derivedTableDefining isNil.
+	self deny: (first clauses includes: clause).
+	self assert: second viewDefining identicalTo: view.
+	self assert: second derivedTableDefining identicalTo: derived.
+	self assert: (second clauses includes: clause)
+]
+
+{ #category : #tests }
+FmxSQLQueryCompatibilityTest >> testMooseNavigationFindsClauseDependencies [
+	| model view sqlQuery clause table |
+	model := FmxSQLModel new.
+	view := FmxSQLView new mooseModel: model; yourself.
+	sqlQuery := FmxSQLSelectQuery new viewDefining: view; mooseModel: model; yourself.
+	clause := FmxSQLFromClause new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	table := FmxSQLTable new mooseModel: model; yourself.
+	FmxSQLTableReference new source: clause; table: table; mooseModel: model; yourself.
+	self assert: (clause queryLocal: #out with: FmxSQLTableReference) size equals: 1.
+	self assert: (view queryLocal: #in with: FmxSQLViewReference) isEmpty.
+	self assert: (table queryLocal: #in with: FmxSQLTableReference) size equals: 1.
+	self assert: (view containedEntities includes: sqlQuery).
+	self assert: (sqlQuery containedEntities includes: clause)
+]
+
+{ #category : #tests }
+FmxSQLQueryCompatibilityTest >> testSQLQueryRelationsSurviveMSERoundTrip [
+	| model view derived clause sqlQuery serialized restored |
+	model := FmxSQLModel new.
+	sqlQuery := FmxSQLSelectQuery new mooseModel: model; yourself.
+	view := FmxSQLView new name: 'v'; source: 'SELECT 1'; sqlQuery: sqlQuery; mooseModel: model; yourself.
+	derived := FmxSQLDerivedTable new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	clause := FmxSQLSelectClause new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	serialized := String streamContents: [ :stream | model exportToMSEStream: stream ].
+	self assert: (serialized includesSubstring: '(sqlQuery (ref:').
+	self deny: (serialized includesSubstring: '(query (ref:').
+	restored := FmxSQLModel importFromMSEStream: serialized readStream.
+	self assert: restored size equals: 4.
+	sqlQuery := (restored allWithType: FmxSQLSelectQuery) anyOne.
+	view := (restored allWithType: FmxSQLView) anyOne.
+	derived := (restored allWithType: FmxSQLDerivedTable) anyOne.
+	clause := (restored allWithType: FmxSQLSelectClause) anyOne.
+	self assert: view sqlQuery identicalTo: sqlQuery.
+	self assert: derived sqlQuery identicalTo: sqlQuery.
+	self assert: clause sqlQuery identicalTo: sqlQuery.
+	self assert: sqlQuery viewDefining identicalTo: view.
+	self assert: sqlQuery derivedTableDefining identicalTo: derived.
+	self assert: (sqlQuery clauses includes: clause)
+]
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
index defe018f..50d3c358 100644
--- a/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLSymbolResolutionVisitorTest.class.st
@@ -285,11 +285,11 @@ END;'.
 	self assert: function outgoingCursorReferences size equals: 1.
 	self assert: function outgoingCursorReferences first class equals: FmxSQLCursorReference.
 	cursor := function outgoingCursorReferences first cursor.
-	self assert: cursor query class equals: FmxSQLSelectQuery.
-	self assert: cursor query clauses size equals: 2.
+	self assert: cursor sqlQuery class equals: FmxSQLSelectQuery.
+	self assert: cursor sqlQuery clauses size equals: 2.
 	self
 		find: FmxSQLFromClause
-		in: cursor query clauses
+		in: cursor sqlQuery clauses
 		thenDo: [ :fromClause | 
 			self assert: fromClause outgoingTableReferences size equals: 1.
 			self assert: fromClause outgoingTableReferences first class equals: FmxSQLTableReference.
@@ -315,10 +315,10 @@ END;'.
 	self assert: function accesses size equals: 1.
 	self assert: function accesses first class equals: FmxSQLLocalVariableAccess.
 	cursor := function outgoingCursorReferences first cursor.
-	self assert: cursor query class equals: FmxSQLSelectQuery.
+	self assert: cursor sqlQuery class equals: FmxSQLSelectQuery.
 	self
 		find: FmxSQLFromClause
-		in: cursor query clauses
+		in: cursor sqlQuery clauses
 		thenDo: [ :fromClause | 
 			self assert: fromClause outgoingTableReferences size equals: 1.
 			self assert: fromClause outgoingTableReferences first class equals: FmxSQLTableReference.
@@ -344,10 +344,10 @@ END;'.
 	self assert: cursor parameters size equals: 1.
 	self assert: cursor parameters first name equals: 'curs_param'.
 	self assert: cursor parameters first type name equals: 'integer'.
-	self assert: cursor query class equals: FmxSQLSelectQuery.
+	self assert: cursor sqlQuery class equals: FmxSQLSelectQuery.
 	self
 		find: FmxSQLFromClause
-		in: cursor query clauses
+		in: cursor sqlQuery clauses
 		thenDo: [ :fromClause | 
 			self assert: fromClause outgoingTableReferences size equals: 1.
 			self assert: fromClause outgoingTableReferences first class equals: FmxSQLTableReference.
@@ -365,10 +365,10 @@ FmxSQLSymbolResolutionVisitorTest >> testCursorWithParameterDeclarationAndAccess
 BEGIN
 END;'.
 	cursor := function outgoingCursorReferences first cursor.
-	self assert: cursor query clauses size equals: 2.
+	self assert: cursor sqlQuery clauses size equals: 2.
 	self
 		find: FmxSQLSelectClause
-		in: cursor query clauses
+		in: cursor sqlQuery clauses
 		thenDo: [ :selectClause | 
 			self assert: selectClause accesses size equals: 1.
 			self assert: selectClause accesses first class equals: FmxSQLCursorParameterAccess.
diff --git a/src/FamixNGSQL-Importer/FmxSQLCursor.extension.st b/src/FamixNGSQL-Importer/FmxSQLCursor.extension.st
index 1d21e20b..b925dc80 100644
--- a/src/FamixNGSQL-Importer/FmxSQLCursor.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLCursor.extension.st
@@ -10,7 +10,7 @@ FmxSQLCursor >> createReferenceEntityFrom: aFmxSQLEntity [
 ]
 
 { #category : #'*FamixNGSQL-Importer' }
-FmxSQLCursor >> query [
+FmxSQLCursor >> sqlQuery [
 	self assert: self queries size = 1.
 	^ self queries first
 ]
diff --git a/src/FamixNGSQL-Importer/FmxSQLDerivedTable.extension.st b/src/FamixNGSQL-Importer/FmxSQLDerivedTable.extension.st
index a160efb4..452041e0 100644
--- a/src/FamixNGSQL-Importer/FmxSQLDerivedTable.extension.st
+++ b/src/FamixNGSQL-Importer/FmxSQLDerivedTable.extension.st
@@ -18,7 +18,7 @@ FmxSQLDerivedTable >> createReferenceEntityFrom: aFmxSQLEntity [
 FmxSQLDerivedTable >> reachableEntities [
 	"This first part gets aliased columns defined by the query."
 	| selectClause |
-	selectClause := (self query ifNil: [ ^ #() ]) clauses detect: [ :c | c class = FmxSQLSelectClause ] ifNone: [ ^ #() ].
+	selectClause := (self sqlQuery ifNil: [ ^ #() ]) clauses detect: [ :c | c class = FmxSQLSelectClause ] ifNone: [ ^ #() ].
 	^ selectClause aliases , 
 	(selectClause columnsReferencedExceptNames: (selectClause aliases collect: #name))
 ]
diff --git a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
index 266cc13d..d06bf86b 100644
--- a/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLModelBuilder.class.st
@@ -414,7 +414,7 @@ FmxSQLModelBuilder >> visitViewsDefinitionsFor: aMooseModel [
 		view := pgToFamixEntities at: pgView.
 		visitor := FmxSQLSymbolResolutionVisitor
 			model: aMooseModel view: view errorReport: self errorReport.
-		self analyse: view during: [ view query: (pgView ast acceptVisitor: visitor) entity query ]
+		self analyse: view during: [ view sqlQuery: (pgView ast acceptVisitor: visitor) entity sqlQuery ]
 	] displayingProgress: 'Symbol resolution for views'
 ]
 
diff --git a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
index 2eac8f99..38754c54 100644
--- a/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
+++ b/src/FamixNGSQL-Importer/FmxSQLSymbolResolutionVisitor.class.st
@@ -47,7 +47,7 @@ FmxSQLSymbolResolutionVisitor class >> model: aMooseModel view: aFmxSQLView erro
 { #category : #'entity creation' }
 FmxSQLSymbolResolutionVisitor >> createClause: aClauseClass from: aPSQLASTClauseNode [
 	^ (self createEntity: aClauseClass from: aPSQLASTClauseNode)
-		query: self currentEntity;
+		sqlQuery: self currentEntity;
 		yourself
 ]
 
@@ -112,7 +112,7 @@ FmxSQLSymbolResolutionVisitor >> createQueryContainedByCurrentEntity: aClass fro
 		ifFalse: [ "Otherwise we need to create a reference to a DerivedTable"
 			|derivedTable|
 			derivedTable := (self createEntity: FmxSQLDerivedTable)
-									query: newQuery;
+									sqlQuery: newQuery;
 									parentQuery: (self solver detect: [ :scope | scope entity isKindOf: FmxSQLCRUDQuery ]) entity;
 									yourself.
 			self createReferenceTo: derivedTable from: anASTNode
@@ -384,9 +384,9 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTAliasDefinition: aPSQLASTAliasDefin
 		
 	visitResult class = SREntityScope "The definition is a derived table..."
 		ifTrue: [ |query derivedTable|
-			query := visitResult entity query.
+			query := visitResult entity sqlQuery.
 			derivedTable := (self createEntity: FmxSQLDerivedTable)
-									query: query;
+									sqlQuery: query;
 									parentQuery: (self solver peekScopeAtIndex: 3) entity;
 									yourself.
 			^ PSQLDerivedTableToBeAliasedByColumn alias: alias entity: derivedTable astNode: aPSQLASTAliasDefinition definition ].
@@ -537,7 +537,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTDeleteQuery: aPSQLASTDeleteQuery [
 				thenDo: [ :tableName | "Here we create manually the FROM clause because in the AST we do not model the FROM clause of a DELETE query with a node. We directly store the identifier of the table." 
 					| fromClause fromClauseScope |
 					fromClause := self createEntity: FmxSQLFromClause from: aPSQLASTDeleteQuery tableName.
-					fromClause query: self currentEntity.
+					fromClause sqlQuery: self currentEntity.
 					fromClauseScope := SREntityScope currentEntity: fromClause.
 					scopeManager pushScope: fromClauseScope andDoAsCurrentEntity: [ self createReferenceTo: (self findTableOrViewNamed: tableName) from: aPSQLASTDeleteQuery tableName ].
 					 ].
@@ -612,9 +612,9 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTFromClauseItemType1: aPSQLASTFromCl
 FmxSQLSymbolResolutionVisitor >> visitPSQLASTFromClauseItemType2: aPSQLASTFromClauseItemType2 [
 	| alias fmxAlias valueOrSelect derivedTable |
 	alias := self visit: aPSQLASTFromClauseItemType2 alias.
-	valueOrSelect := (self visit: aPSQLASTFromClauseItemType2 valuesOrSelect) entity query.
+	valueOrSelect := (self visit: aPSQLASTFromClauseItemType2 valuesOrSelect) entity sqlQuery.
 	derivedTable := (self createEntity: FmxSQLDerivedTable)
-							query: valueOrSelect;
+							sqlQuery: valueOrSelect;
 							parentQuery: (self solver peekScopeAtIndex: 2) entity;
 							yourself.
 	fmxAlias := self
@@ -795,7 +795,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTSelectIntoQuery: aPSQLASTSelectInto
 	recordLocalVariable class = FmxSQLRecordLocalVariable
 		ifFalse: [ ^ toReturn ].
 	recordLocalVariable
-		queryBoundTo: toReturn entity query.
+		queryBoundTo: toReturn entity sqlQuery.
 	^ toReturn
 ]
 
@@ -817,7 +817,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTSelectQuery: aPSQLASTSelectQuery [
 			self
 				useCurrentEntity:
 					((self createEntity: FmxSQLSelectClause)
-						query: selectQuery;
+						sqlQuery: selectQuery;
 						yourself)
 				during: [ |aliasesToBeDefined|
 					aliasesToBeDefined := OrderedCollection new.
@@ -849,7 +849,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTSelectQuery: aPSQLASTSelectQuery [
 FmxSQLSymbolResolutionVisitor >> visitPSQLASTSelectWhereClause: aPSQLASTSelectWhereClause [
 	| whereClause |
 	whereClause := self createEntity: FmxSQLWhereClause from: aPSQLASTSelectWhereClause.
-	whereClause query: self currentEntity.
+	whereClause sqlQuery: self currentEntity.
 	self
 		useCurrentEntity: whereClause
 		during: [ self visit: aPSQLASTSelectWhereClause condition ].
@@ -931,7 +931,7 @@ FmxSQLSymbolResolutionVisitor >> visitPSQLASTUpdateQuery: aPSQLASTUpdateQuery [
 			self flag: #TODO;
 				useCurrentEntity:
 					((self createEntity: FmxSQLSetClause)
-						query: self currentEntity;
+						sqlQuery: self currentEntity;
 						yourself)
 				during: [ self visit: aPSQLASTUpdateQuery setClause ].
 			self visit: aPSQLASTUpdateQuery whereClause.
diff --git a/src/FamixNGSQL-Importer/PSQLASTValuesNullObject.class.st b/src/FamixNGSQL-Importer/PSQLASTValuesNullObject.class.st
index 5972d78d..7f2bf25a 100644
--- a/src/FamixNGSQL-Importer/PSQLASTValuesNullObject.class.st
+++ b/src/FamixNGSQL-Importer/PSQLASTValuesNullObject.class.st
@@ -35,7 +35,7 @@ PSQLASTValuesNullObject >> mooseModel: aMooseModel [
 ]
 
 { #category : #'null pattern' }
-PSQLASTValuesNullObject >> query [
+PSQLASTValuesNullObject >> sqlQuery [
 	"Used in #visitPSQLASTFromClauseItemType2: method of the importer."
 	^ FmxSQLValuesQuery new
 		mooseModel: self mooseModel;
diff --git a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
index 0248ddc9..eb8b2570 100644
--- a/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLCRUDQuery.class.st
@@ -18,12 +18,12 @@ My subclasses represent these four queries.
 | Relation | Origin | Opposite | Type | Comment |
 |---|
 | `container` | `FmxSQLCRUDQuery` | `queries` | `FmxSQLTQueryContainer` | |
-| `derivedTableDefining` | `FmxSQLCRUDQuery` | `query` | `FmxSQLDerivedTable` | |
+| `derivedTableDefining` | `FmxSQLCRUDQuery` | `sqlQuery` | `FmxSQLDerivedTable` | |
 
 ### Children
 | Relation | Origin | Opposite | Type | Comment |
 |---|
-| `clauses` | `FmxSQLCRUDQuery` | `query` | `FmxSQLClause` | |
+| `clauses` | `FmxSQLCRUDQuery` | `sqlQuery` | `FmxSQLClause` | |
 
 ### Outgoing dependencies
 | Relation | Origin | Opposite | Type | Comment |
@@ -46,9 +46,9 @@ Class {
 	#traits : 'FamixTSourceEntity + FmxSQLTWithNamespaceReference + FmxSQLTWithTableReference + FmxSQLTWithViewReference + TEntityMetaLevelDependency',
 	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTWithNamespaceReference classTrait + FmxSQLTWithTableReference classTrait + FmxSQLTWithViewReference classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
-		'#clauses => FMMany type: #FmxSQLClause opposite: #query',
+		'#clauses => FMMany type: #FmxSQLClause opposite: #sqlQuery',
 		'#container => FMOne type: #FmxSQLTQueryContainer opposite: #queries',
-		'#derivedTableDefining => FMOne type: #FmxSQLDerivedTable opposite: #query'
+		'#derivedTableDefining => FMOne type: #FmxSQLDerivedTable opposite: #sqlQuery'
 	],
 	#category : 'FamixNGSQL-Entities',
 	#package : 'FamixNGSQL',
@@ -74,7 +74,7 @@ FmxSQLCRUDQuery >> addClause: anObject [
 
 { #category : 'accessing' }
 FmxSQLCRUDQuery >> clauses [
-	"Relation named: #clauses type: #FmxSQLClause opposite: #query"
+	"Relation named: #clauses type: #FmxSQLClause opposite: #sqlQuery"
 
 	<ignoreForCoverage>
 	<generated>
@@ -110,7 +110,7 @@ FmxSQLCRUDQuery >> container: anObject [
 
 { #category : 'accessing' }
 FmxSQLCRUDQuery >> derivedTableDefining [
-	"Relation named: #derivedTableDefining type: #FmxSQLDerivedTable opposite: #query"
+	"Relation named: #derivedTableDefining type: #FmxSQLDerivedTable opposite: #sqlQuery"
 
 	<ignoreForCoverage>
 	<generated>
diff --git a/src/FamixNGSQL/FmxSQLClause.class.st b/src/FamixNGSQL/FmxSQLClause.class.st
index 097ea0ce..85c3bff0 100644
--- a/src/FamixNGSQL/FmxSQLClause.class.st
+++ b/src/FamixNGSQL/FmxSQLClause.class.st
@@ -7,7 +7,7 @@ I am an abstract clause
 ### Parents
 | Relation | Origin | Opposite | Type | Comment |
 |---|
-| `query` | `FmxSQLClause` | `clauses` | `FmxSQLCRUDQuery` | |
+| `sqlQuery` | `FmxSQLClause` | `clauses` | `FmxSQLCRUDQuery` | |
 
 ### Children
 | Relation | Origin | Opposite | Type | Comment |
@@ -28,7 +28,7 @@ Class {
 	#traits : 'FamixTSourceEntity + FmxSQLTWithAlias + TEntityMetaLevelDependency',
 	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTWithAlias classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
-		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #clauses'
+		'#sqlQuery => FMOne type: #FmxSQLCRUDQuery opposite: #clauses'
 	],
 	#category : 'FamixNGSQL-Entities',
 	#package : 'FamixNGSQL',
@@ -45,19 +45,19 @@ FmxSQLClause class >> annotation [
 ]
 
 { #category : 'accessing' }
-FmxSQLClause >> query [
-	"Relation named: #query type: #FmxSQLCRUDQuery opposite: #clauses"
+FmxSQLClause >> sqlQuery [
+	"Relation named: #sqlQuery type: #FmxSQLCRUDQuery opposite: #clauses"
 
 	<ignoreForCoverage>
 	<generated>
 	<container>
-	^ query
+	^ sqlQuery
 ]
 
 { #category : 'accessing' }
-FmxSQLClause >> query: anObject [
+FmxSQLClause >> sqlQuery: anObject [
 
 	<ignoreForCoverage>
 	<generated>
-	query := anObject
+	sqlQuery := anObject
 ]
diff --git a/src/FamixNGSQL/FmxSQLDerivedTable.class.st b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
index 3647774b..0696e8f7 100644
--- a/src/FamixNGSQL/FmxSQLDerivedTable.class.st
+++ b/src/FamixNGSQL/FmxSQLDerivedTable.class.st
@@ -14,7 +14,7 @@ I am a derived table. A derived table is a temporary table created to store temp
 |---|
 | `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
 | `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
-| `query` | `FmxSQLDerivedTable` | `derivedTableDefining` | `FmxSQLCRUDQuery` | |
+| `sqlQuery` | `FmxSQLDerivedTable` | `derivedTableDefining` | `FmxSQLCRUDQuery` | |
 
 ### Incoming dependencies
 | Relation | Origin | Opposite | Type | Comment |
@@ -36,7 +36,7 @@ Class {
 	#classTraits : 'FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTQueryContainer classTrait',
 	#instVars : [
 		'#parentQuery => FMOne type: #FmxSQLTDefiningDerivedTables opposite: #derivedTablesDefined',
-		'#query => FMOne type: #FmxSQLCRUDQuery opposite: #derivedTableDefining',
+		'#sqlQuery => FMOne type: #FmxSQLCRUDQuery opposite: #derivedTableDefining',
 		'#references => FMMany type: #FmxSQLDerivedTableReference opposite: #derivedTable'
 	],
 	#category : 'FamixNGSQL-Entities',
@@ -80,21 +80,21 @@ FmxSQLDerivedTable >> parentQuery: anObject [
 ]
 
 { #category : 'accessing' }
-FmxSQLDerivedTable >> query [
-	"Relation named: #query type: #FmxSQLCRUDQuery opposite: #derivedTableDefining"
+FmxSQLDerivedTable >> sqlQuery [
+	"Relation named: #sqlQuery type: #FmxSQLCRUDQuery opposite: #derivedTableDefining"
 
 	<ignoreForCoverage>
 	<generated>
 	<derived>
-	^ query
+	^ sqlQuery
 ]
 
 { #category : 'accessing' }
-FmxSQLDerivedTable >> query: anObject [
+FmxSQLDerivedTable >> sqlQuery: anObject [
 
 	<ignoreForCoverage>
 	<generated>
-	query := anObject
+	sqlQuery := anObject
 ]
 
 { #category : 'accessing' }
diff --git a/src/FamixNGSQL/FmxSQLSelectQuery.class.st b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
index b9595228..e03e939b 100644
--- a/src/FamixNGSQL/FmxSQLSelectQuery.class.st
+++ b/src/FamixNGSQL/FmxSQLSelectQuery.class.st
@@ -7,7 +7,7 @@ I am a SELECT query.
 ### Parents
 | Relation | Origin | Opposite | Type | Comment |
 |---|
-| `viewDefining` | `FmxSQLSelectQuery` | `query` | `FmxSQLView` | |
+| `viewDefining` | `FmxSQLSelectQuery` | `sqlQuery` | `FmxSQLView` | |
 
 ### Children
 | Relation | Origin | Opposite | Type | Comment |
@@ -29,7 +29,7 @@ Class {
 	#classTraits : 'FmxSQLTDefiningDerivedTables classTrait',
 	#instVars : [
 		'#recordLocalVariables => FMMany type: #FmxSQLRecordLocalVariable opposite: #queryBoundTo',
-		'#viewDefining => FMOne type: #FmxSQLView opposite: #query'
+		'#viewDefining => FMOne type: #FmxSQLView opposite: #sqlQuery'
 	],
 	#category : 'FamixNGSQL-Entities',
 	#package : 'FamixNGSQL',
@@ -73,7 +73,7 @@ FmxSQLSelectQuery >> recordLocalVariables: anObject [
 
 { #category : 'accessing' }
 FmxSQLSelectQuery >> viewDefining [
-	"Relation named: #viewDefining type: #FmxSQLView opposite: #query"
+	"Relation named: #viewDefining type: #FmxSQLView opposite: #sqlQuery"
 
 	<ignoreForCoverage>
 	<generated>
diff --git a/src/FamixNGSQL/FmxSQLView.class.st b/src/FamixNGSQL/FmxSQLView.class.st
index bc232746..de355446 100644
--- a/src/FamixNGSQL/FmxSQLView.class.st
+++ b/src/FamixNGSQL/FmxSQLView.class.st
@@ -14,7 +14,7 @@ I am a view. I can be used transparently as a table but I do not hold data. My d
 |---|
 | `columns` | `FmxSQLColumnsContainer` | `columnsContainer` | `FmxSQLTColumn` | |
 | `queries` | `FmxSQLTQueryContainer` | `container` | `FmxSQLCRUDQuery` | |
-| `query` | `FmxSQLView` | `viewDefining` | `FmxSQLSelectQuery` | |
+| `sqlQuery` | `FmxSQLView` | `viewDefining` | `FmxSQLSelectQuery` | |
 | `triggers` | `FmxSQLTWithTriggers` | `table` | `FmxSQLTrigger` | |
 
 ### Incoming dependencies
@@ -49,7 +49,7 @@ Class {
 	#classTraits : 'FamixTHasImmediateSource classTrait + FmxSQLAbstractType classTrait + FmxSQLBehaviouralEntity classTrait + FmxSQLColumnsContainer classTrait + FmxSQLTNamedEntity classTrait + FmxSQLTQueryContainer classTrait + FmxSQLTWithTriggers classTrait',
 	#instVars : [
 		'#isMaterialized => FMProperty',
-		'#query => FMOne type: #FmxSQLSelectQuery opposite: #viewDefining',
+		'#sqlQuery => FMOne type: #FmxSQLSelectQuery opposite: #viewDefining',
 		'#references => FMMany type: #FmxSQLViewReference opposite: #view'
 	],
 	#category : 'FamixNGSQL-Entities',
@@ -99,21 +99,21 @@ FmxSQLView >> isView [
 ]
 
 { #category : 'accessing' }
-FmxSQLView >> query [
-	"Relation named: #query type: #FmxSQLSelectQuery opposite: #viewDefining"
+FmxSQLView >> sqlQuery [
+	"Relation named: #sqlQuery type: #FmxSQLSelectQuery opposite: #viewDefining"
 
 	<ignoreForCoverage>
 	<generated>
 	<derived>
-	^ query
+	^ sqlQuery
 ]
 
 { #category : 'accessing' }
-FmxSQLView >> query: anObject [
+FmxSQLView >> sqlQuery: anObject [
 
 	<ignoreForCoverage>
 	<generated>
-	query := anObject
+	sqlQuery := anObject
 ]
 
 { #category : 'accessing' }

From 6e1c636943796e1abba5c4a92b6e7270a6e2b00f Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Sun, 20 Sep 2026 17:44:43 +0300
Subject: [PATCH 21/22] Enable standard Moose maps for SQL reference
 containment

---
 README.md                                     | 25 +++++++
 .../FmxSQLMetamodelGenerator.class.st         |  2 -
 ...mxSQLStructuralMetamodelGenerator.class.st |  3 +
 .../FmxSQLMooseNavigationTest.class.st        | 66 +++++++++++++++++++
 src/FamixNGSQL/FmxSQLReference.class.st       |  4 +-
 .../FmxSQLReferencesGroupReference.class.st   |  4 +-
 6 files changed, 98 insertions(+), 6 deletions(-)
 create mode 100644 src/FamixNGSQL-Importer-Tests/FmxSQLMooseNavigationTest.class.st

diff --git a/README.md b/README.md
index f79ba8c3..cababc6b 100644
--- a/README.md
+++ b/README.md
@@ -230,6 +230,31 @@ and restore the old slot values when upgrading a populated image. Older MSE
 files that contain a clause's `query` property require migration before import;
 new exports use `sqlQuery`. Keep the old image/export until migration is verified.
 
+### Standard Moose Architectural Map (master after v2.0.0)
+
+In a Moose 13 image, execute this in the imported model's Inspector:
+
+```smalltalk
+| schemas browser |
+schemas := (self allWithType: FmxSQLNamespace) reject: [ :schema |
+    (schema name beginsWith: 'pg_') or: [ schema name = 'information_schema' ] ].
+browser := MiArchitecturalMapBrowser new.
+browser open.
+browser followEntity: schemas.
+browser beFrozen.
+```
+
+This uses the standard browser, model, builder and default containment query.
+SQL references implement Moose's dependency-query protocol because they can be
+contained in routine arguments and expression groups. The map can therefore
+discover association types and follow SQL bodies without custom map adapters.
+Double-click a schema to expand or collapse it. Freezing keeps the map on the
+selected schemas when another Moose browser changes its selection.
+
+The diagram reflects dependencies present in the imported model; incomplete
+source analysis still limits the relationships available to display. The plain
+Pharo `Core` installation does not include the Architectural Map UI.
+
 ## Understand analysis coverage
 
 In the model Inspector:
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
index 37eede0d..1f6a80ae 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLMetamodelGenerator.class.st
@@ -494,8 +494,6 @@ FmxSQLMetamodelGenerator >> defineBehaviouralReferencesHierarchy [
 	columnAliasAccess --|> tWithQualifiedReference.
 	referencesGroupReference --|> reference.
 	referencesGroupReference --|> tReferencesGroupReference.
-	referencesGroupReference  --|> #TEntityMetaLevelDependency.
-	"referencesGroupReference --|> #TDependencyQueries."
 	"qualifiedReference --|> entity." "FamixTEntity is deprecated"
 	qualifiedReference --|> #TSourceEntity.
 	namespaceReference --|> tWithQualifiedReference
diff --git a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
index 68dfe395..7d160356 100644
--- a/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
+++ b/src/FAMIXNGSQLMetamodelGenerator/FmxSQLStructuralMetamodelGenerator.class.st
@@ -236,6 +236,9 @@ FmxSQLStructuralMetamodelGenerator >> defineStructuralReferencesHierarchy [
 	association --|> #TAssociation.
 	reference --|> association.
 	reference --|> #TSourceEntity.
+	"References can be contained in argument lists and expression groups.
+	They must participate in Moose's containment and dependency queries."
+	reference --|> #TEntityMetaLevelDependency.
 	reference --|> tArgument.
 	tableReference --|> reference.
 	columnReference --|> reference.
diff --git a/src/FamixNGSQL-Importer-Tests/FmxSQLMooseNavigationTest.class.st b/src/FamixNGSQL-Importer-Tests/FmxSQLMooseNavigationTest.class.st
new file mode 100644
index 00000000..6dbc7531
--- /dev/null
+++ b/src/FamixNGSQL-Importer-Tests/FmxSQLMooseNavigationTest.class.st
@@ -0,0 +1,66 @@
+Class {
+	#name : #FmxSQLMooseNavigationTest,
+	#superclass : #TestCase,
+	#category : #'FamixNGSQL-Importer-Tests'
+}
+
+{ #category : #tests }
+FmxSQLMooseNavigationTest >> testReferencesSupportContainmentQueries [
+	| model call argument group |
+	model := FmxSQLModel new.
+	call := FmxSQLStoredProcedureCall new mooseModel: model; yourself.
+	argument := FmxSQLColumnReference new storedProcedureContainer: call; mooseModel: model; yourself.
+	group := FmxSQLReferencesGroup new mooseModel: model; yourself.
+	group addReference: call.
+	self assert: (group containedEntities includes: call).
+	self assert: (call containedEntities includes: argument).
+	{ group. call. argument } do: [ :entity |
+		self assert: entity isQueryable.
+		self assert: (entity query isKindOf: MooseQuery).
+		self assert: (entity queryLocal: #in with: FmxSQLColumnReference) isEmpty ]
+]
+
+{ #category : #tests }
+FmxSQLMooseNavigationTest >> testNamespaceDiscoversAssociationTypesThroughReferences [
+	| types |
+	types := FmxSQLNamespace allIncomingAssociationTypesIn: FmxSQLModel metamodel.
+	self assert: (types includes: FmxSQLColumnReference).
+	self assert: (types includes: FmxSQLTableReference).
+	self assert: (types includes: FmxSQLViewReference).
+	self assert: (types includes: FamixTInvocation)
+]
+
+{ #category : #tests }
+FmxSQLMooseNavigationTest >> testAllContainedTypesSupportAssociationDiscovery [
+	| metamodel classes |
+	metamodel := FmxSQLModel metamodel.
+	classes := (FmxSQLNamespace allContainedEntityTypesIn: metamodel)
+		flatCollectAsSet: [ :type | type implementingClassesIn: metamodel ].
+	classes do: [ :class |
+		self assert: (class respondsTo: #incomingAssociationTypesIn:).
+		self assert: (class incomingAssociationTypesIn: metamodel) isCollection ]
+]
+
+{ #category : #tests }
+FmxSQLMooseNavigationTest >> testStandardArchitecturalMapIncludesSQLBodyDependency [
+	"The Moose CI image exercises the real map without custom models or builders.
+	The plain Pharo CI image intentionally does not load the Moose UI."
+	| browserClass builderClass canvasClass model sourceSchema targetSchema view sqlQuery clause table canvas browser |
+	browserClass := Smalltalk globals at: #MiArchitecturalMapBrowser ifAbsent: [ self skip ].
+	builderClass := Smalltalk globals at: #MiArchitecturalMapBuilder.
+	canvasClass := Smalltalk globals at: #RSCanvas.
+	model := FmxSQLModel new.
+	sourceSchema := FmxSQLNamespace new name: 'reporting'; mooseModel: model; yourself.
+	targetSchema := FmxSQLNamespace new name: 'data'; mooseModel: model; yourself.
+	view := FmxSQLView new name: 'report'; parentNamespace: sourceSchema; mooseModel: model; yourself.
+	sqlQuery := FmxSQLSelectQuery new viewDefining: view; mooseModel: model; yourself.
+	clause := FmxSQLFromClause new sqlQuery: sqlQuery; mooseModel: model; yourself.
+	table := FmxSQLTable new name: 'records'; parentNamespace: targetSchema; mooseModel: model; yourself.
+	FmxSQLTableReference new source: clause; table: table; mooseModel: model.
+	browser := browserClass new.
+	browser specModel entities: { sourceSchema. targetSchema } asMooseGroup.
+	canvas := canvasClass new.
+	builderClass new mapModel: browser specModel; container: canvas; build.
+	self assert: canvas nodes size equals: 2.
+	self assert: canvas edges size equals: 1
+]
diff --git a/src/FamixNGSQL/FmxSQLReference.class.st b/src/FamixNGSQL/FmxSQLReference.class.st
index 9c85d08c..00f4c553 100644
--- a/src/FamixNGSQL/FmxSQLReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReference.class.st
@@ -21,8 +21,8 @@ I am an abstract object that represent a reference made to another entity in the
 Class {
 	#name : 'FmxSQLReference',
 	#superclass : 'FmxSQLAssociation',
-	#traits : 'FamixTSourceEntity + FmxSQLTArgument',
-	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTArgument classTrait',
+	#traits : 'FamixTSourceEntity + FmxSQLTArgument + TEntityMetaLevelDependency',
+	#classTraits : 'FamixTSourceEntity classTrait + FmxSQLTArgument classTrait + TEntityMetaLevelDependency classTrait',
 	#instVars : [
 		'#belongsToGroup => FMOne type: #FmxSQLReferencesGroup opposite: #references',
 		'#storedProcedureContainer => FMOne type: #FmxSQLStoredProcedureCall opposite: #arguments'
diff --git a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
index 92ee7d95..53b26434 100644
--- a/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
+++ b/src/FamixNGSQL/FmxSQLReferencesGroupReference.class.st
@@ -25,8 +25,8 @@ TODO
 Class {
 	#name : 'FmxSQLReferencesGroupReference',
 	#superclass : 'FmxSQLReference',
-	#traits : 'FmxSQLTReferencesGroupReference + TEntityMetaLevelDependency',
-	#classTraits : 'FmxSQLTReferencesGroupReference classTrait + TEntityMetaLevelDependency classTrait',
+	#traits : 'FmxSQLTReferencesGroupReference',
+	#classTraits : 'FmxSQLTReferencesGroupReference classTrait',
 	#category : 'FamixNGSQL-Entities',
 	#package : 'FamixNGSQL',
 	#tag : 'Entities'

From 0ed413165d34f4ffcbba0edd9ba421882bbd2aa3 Mon Sep 17 00:00:00 2001
From: Dmitry Dorofeev <dima@yasp.com>
Date: Sun, 20 Sep 2026 19:54:48 +0300
Subject: [PATCH 22/22] Clarify Playground and Inspector contexts after PR #10

---
 README.md | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index e668f5da..fa137cf6 100644
--- a/README.md
+++ b/README.md
@@ -152,10 +152,9 @@ remain represented as catalog entities with source.
 
 ## Explore an imported model
 
-The following snippets run in the model Inspector, with `model` bound to the
-`FmxSQLModel` returned by `buildModel` (see above [Connect and build a model](#connect-and-build-a-model)).
-
-Count selected entity kinds:
+In the same Playground used in [Connect and build a model](#connect-and-build-a-model),
+`model` refers to the `FmxSQLModel` returned by `buildModel`. Count selected entity
+kinds with:
 
 ```smalltalk
 Dictionary newFrom: {
@@ -173,6 +172,10 @@ Model counts can include synthetic/system stubs; they need not equal a direct
 count of application catalog rows. `allWithType:` selects the exact class,
 whereas `allWithSubTypesOf:` includes specialized entities.
 
+The remaining examples in this section run in the model Inspector, where `self`
+refers to the inspected model. To run the counting example there, replace `model`
+with `self`; do not assign to `self`.
+
 Inspect routines, including trigger routines, with their source and parameters:
 
 ```smalltalk