Package2Database_Lazy.atl

module Package2Database;
create OUT : Relational from IN : Class;

-- uses strings;
-- if there is a configuration problem with the library string,
-- delete the two firstToLower() operations and you no longer need the library "strings"
-- the transfomarion will execute 


-- inheritance not supported yet

-- issue: choose an object-id Type (Integer, String?).
-- We choose Integer here, assuming this type is defined in the source model.

-- global variable
-- context 
helper def: objectIdType : Relational!Type =
	Class!DataType.allInstances()->select(e | e.name = 'Integer')->first();


rule Package2Database {
	from
		p : Class!Package
	to
		out : Relational!Database (
			name <- p.name,
			-- Columns are generated from Attributes in another rule not explicitly called here !
			tables <- 
				p.classifiers->select(c | c.oclIsKindOf(Class!Class)) 
					-> collect( c | thisModule.Class2Table( c ) )
				-> union(
					p.classifiers
						-> select(c | c.oclIsKindOf(Class!Class)) -> collect( c | c.attr ) -> flatten()  
						-> select( a | a.type.oclIsKindOf(Class!DataType) and a.multiValued ) 
						-> collect( a | thisModule.MultiValuedDataTypeAttribute2Column(a) )
				)
				-> union (
					p.classifiers
						->select(c | c.oclIsKindOf(Class!Class)) -> collect( c | c.attr ) -> flatten()
						-> select( a | a.type.oclIsKindOf(Class!Class) and a.multiValued ) 
						-> collect( a | thisModule.MultiValuedClassAttribute2Column(a) )
				)
		)
}

unique lazy rule Class2Table {
	from
		c : Class!Class
	to
		out : Relational!Table (
			name <- c.name,
			-- Columns are generated from Attributes in another rule not explicitly called here !
			col <- Sequence {key}
					-> union(
						c.attr
						-> select( a | a.type.oclIsKindOf(Class!DataType) and not a.multiValued ) 
						-> collect( a | thisModule.DataTypeAttribute2Column(a) )
					)
					-> union (
						c.attr
						-> select( a | a.type.oclIsKindOf(Class!Class) and not a.multiValued ) 
						-> collect( a | thisModule.ClassAttribute2Column(a) )
					),
			key <- Set {key}
		),
		key : Relational!Column (
			name <- 'objectId',
			type <- thisModule.objectIdType
		)
}

rule DataType2Type {
	from
		dt : Class!DataType
	to
		out : Relational!Type (
			name <- dt.name
		)
}

unique lazy rule DataTypeAttribute2Column {
	from
		a : Class!Attribute (
			a.type.oclIsKindOf(Class!DataType) and not a.multiValued
		)
	to
		out : Relational!Column (
			name <- a.name,
			type <- a.type
-- explicit use of implicit tracking links (first expected syntax, then present actual syntax)
--			owner <- [Class2Type.key]a.owner
--			owner <- thisModule.resolveTemp(a.owner, 'key')
		)
}

unique lazy rule MultiValuedDataTypeAttribute2Column {
	from
		a : Class!Attribute (
			a.type.oclIsKindOf(Class!DataType) and a.multiValued
		)
	to
		out : Relational!Table (
			name <- a.owner.name + '_' + a.name,
			col <- Sequence {id, value}
		),
		id : Relational!Column (
			-- name <- a.owner.name.firstToLower() + 'Id',
			name <- a.owner.name + 'Id',
			type <- thisModule.objectIdType
		),
		value : Relational!Column (
			name <- a.name,
			type <- a.type
		)
}

unique lazy rule ClassAttribute2Column {
	from
		a : Class!Attribute (
			a.type.oclIsKindOf(Class!Class) and not a.multiValued
		)
	to
		foreignKey : Relational!Column (
			name <- a.name + 'Id',
			type <- thisModule.objectIdType
		)
}

unique lazy rule MultiValuedClassAttribute2Column {
	from
		a : Class!Attribute (
			a.type.oclIsKindOf(Class!Class) and a.multiValued
		)
	to
		t : Relational!Table (
			name <- a.owner.name + '_' + a.name,
			col <- Sequence {id, foreignKey}
		),
		id : Relational!Column (
			-- name <- a.owner.name.firstToLower() + 'Id',
			name <- a.owner.name + 'Id',
			type <- thisModule.objectIdType
		),
		foreignKey : Relational!Column (
			name <- a.name + 'Id',
			type <- thisModule.objectIdType
		)
}