[erdiag.git] / parser.js

// ER diagram description parser
class ErDiags
{
	constructor(description)
	{
		this.entities = { };
		this.inheritances = [ ];
		this.associations = [ ];
		this.tables = { };
		this.mcdParsing(description);
		this.mldParsing();
		// Cache SVG graphs returned by server (in addition to server cache = good perfs)
		this.mcdGraph = "";
		this.mldGraph = "";
		this.sqlText = "";
	}

	static CARDINAL(symbol)
	{
		let res = { "*": "0,n", "+": "1,n", "?": "0,1", "1": "1,1" } [ symbol[0] ];
		if (symbol.length >= 2)
		{
			if (symbol[1] == 'R')
				res = '(' + res + ')';
			else if (['>','<'].includes(symbol[1]))
				res += symbol[1];
		}
		return res;
	}

	///////////////////////////////
	// PARSING STAGE 1: text to MCD
	///////////////////////////////

	// Parse a textual description into a json object
	mcdParsing(text)
	{
		let lines = text.split("\n");
		lines.push(""); //easier parsing: always empty line at the end
		let start = -1;
		for (let i=0; i < lines.length; i++)
		{
			lines[i] = lines[i].trim();
			// Empty line ?
			if (lines[i].length == 0)
			{
				if (start >= 0) //there is some group of lines to parse
				{
					this.parseThing(lines, start, i);
					start = -1;
				}
			}
			else //not empty line: just register starting point
			{
				if (start < 0)
					start = i;
			}
		}
	}

	// Parse a group of lines into entity, association, ...
	parseThing(lines, start, end) //start included, end excluded
	{
		switch (lines[start].charAt(0))
		{
			case '[':
				// Entity = { name: { attributes, [weak] } }
				let name = lines[start].match(/[^\[\]"\s]+/)[0];
				let entity = { attributes: this.parseAttributes(lines, start+1, end) };
				if (lines[start].charAt(1) == '[')
					entity.weak = true;
				this.entities[name] = entity;
				break;
			case 'i': //inheritance (arrows)
				this.inheritances = this.inheritances.concat(this.parseInheritance(lines, start+1, end));
				break;
			case '{': //association
				// Association = { [name], [attributes], [weak], entities: ArrayOf entity indices }
				let relationship = { };
				let nameRes = lines[start].match(/[^{}"\s]+/);
				if (nameRes !== null)
					relationship.name = nameRes[0];
				if (lines[start].charAt(1) == '{')
					relationship.weak = true;
				this.associations.push(Object.assign({}, relationship, this.parseAssociation(lines, start+1, end)));
				break;
		}
	}

	// attributes: ArrayOf {name, [isKey], [type], [qualifiers]}
	parseAttributes(lines, start, end)
	{
		let attributes = [ ];
		for (let i=start; i<end; i++)
		{
			let field = { };
			let line = lines[i];
			if (line.charAt(0) == '+')
			{
				field.isKey = true;
				line = line.slice(1);
			}
			field.name = line.match(/[^"\s]+/)[0];
			let sqlClues = line.substring(field.name.length).trim();
			if (sqlClues.length > 0)
			{
				field.type = sqlClues.match(/[^\s]+/)[0]; //type is always the first indication (mandatory)
				field.qualifiers = sqlClues.substring(field.type.length);
			}
			attributes.push(field);
		}
		return attributes;
	}

	// GroupOf Inheritance: { parent, children: ArrayOf entity indices }
	parseInheritance(lines, start, end)
	{
		let inheritance = [];
		for (let i=start; i<end; i++)
		{
			let lineParts = lines[i].split(" ");
			let children = [];
			for (let j=1; j<lineParts.length; j++)
				children.push(lineParts[j]);
			inheritance.push({ parent:lineParts[0], children: children });
		}
		return inheritance;
	}

	// Association (parsed here): {
	//   entities: ArrayOf entity names + cardinality,
	//   [attributes: ArrayOf {name, [isKey], [type], [qualifiers]}]
	// }
	parseAssociation(lines, start, end)
	{
		let assoce = { };
		let entities = [];
		let i = start;
		while (i < end)
		{
			if (lines[i].charAt(0) == '-')
			{
				assoce.attributes = this.parseAttributes(lines, i+1, end);
				break;
			}
			else
			{
				// Read entity name + cardinality
				let lineParts = lines[i].split(" ");
				entities.push({ name:lineParts[0], card:lineParts[1] });
			}
			i++;
		}
		assoce.entities = entities;
		return assoce;
	}

	//////////////////////////////
	// PARSING STAGE 2: MCD to MLD
	//////////////////////////////

	// From entities + relationships to tables
	mldParsing()
	{
		// Pass 1: initialize tables
		Object.keys(this.entities).forEach( name => {
			let newTable = [ ]; //array of fields
			this.entities[name].attributes.forEach( attr => {
				let newField = {
					name: attr.name,
					type: attr.type,
					isKey: attr.isKey,
					qualifiers: attr.qualifiers,
				};
				if (!!attr.qualifiers && !!attr.qualifiers.match(/references/i))
				{
					Object.assign(newField, {ref: attr.qualifiers.match(/references ([^\s]+)/i)[1]});
					attr.qualifiers = attr.qualifiers.replace(/references [^\s]+/, "");
				}
				newTable.push(newField);
			});
			this.tables[name] = newTable;
		});
		// Add foreign keys information for children (inheritance). TODO: allow several levels
		// NOTE: modelisation assume each child has its own table, refering parent (other options exist)
		this.inheritances.forEach( inh => {
			let idx = this.tables[inh.parent].findIndex( item => { return item.isKey; });
			inh.children.forEach( c => {
				this.tables[c].push({
					name: inh.parent + "_id",
					type: this.tables[inh.parent][idx].type,
					isKey: true,
					qualifiers: this.tables[inh.parent][idx].qualifiers || "",
					ref: inh.parent + "(" + this.tables[inh.parent][idx].name + ")",
				});
			});
		});
		// Pass 2: parse associations, add foreign keys when cardinality is 0,1 or 1,1
		this.associations.forEach( a => {
			let newTableAttrs = [ ];
			let hasZeroOne = false;
			a.entities.forEach( e => {
				if (['?','1'].includes(e.card[0]))
				{
					hasZeroOne = true;
					// Foreign key apparition (for each entity in association minus current one, for each identifying attribute)
					a.entities.forEach( e2 => {
						if (e2.name == e.name)
							return;
						this.entities[e2.name].attributes.forEach( attr => {
							if (attr.isKey)
							{
								// For "weak tables", foreign keys become part of the key
								const isKey = e.card.length >= 2 && e.card[1] == 'R';
								this.tables[e.name].push({
									isKey: isKey,
									name: e2.name + "_" + attr.name,
									type: attr.type,
									qualifiers: !isKey && e.card[0]=='1' ? "not null" : "",
									ref: e2.name + "(" + attr.name + ")",
								});
							}
						});
					});
				}
				else
				{
					// Add all keys in current entity
					let fields = this.entities[e.name].attributes.filter( attr => { return attr.isKey; });
					newTableAttrs.push({
						fields: fields,
						entity: e.name,
					});
				}
			});
			if (!hasZeroOne && newTableAttrs.length > 1)
			{
				// Ok, really create a new table
				let newTable = {
					name: a.name || newTableAttrs.map( item => { return item.entity; }).join("_"),
					fields: [ ],
				};
				newTableAttrs.forEach( item => {
					item.fields.forEach( f => {
						newTable.fields.push({
							name: item.entity + "_" + f.name,
							isKey: true,
							type: f.type,
							qualifiers: f.qualifiers || "",
							ref: item.entity + "(" + f.name + ")",
						});
					});
				});
				// Check for duplicates (in case of self-relationship), rename if needed
				newTable.fields.forEach( (f,i) => {
					const idx = newTable.fields.findIndex( item => { return item.name == f.name; });
					if (idx < i)
					{
						// Current field is a duplicate
						let suffix = 2;
						let newName = f.name + suffix;
						while (newTable.fields.findIndex( item => { return item.name == newName; }) >= 0)
						{
							suffix++;
							newName = f.name + suffix;
						}
						f.name = newName;
					}
				});
				// Add relationship potential own attributes
				(a.attributes || [ ]).forEach( attr => {
					newTable.fields.push({
						name: attr.name,
						isKey: false,
						type: attr.type,
						qualifiers: attr.qualifiers,
					});
				});
				this.tables[newTable.name] = newTable.fields;
			}
		});
	}

	/////////////////////////////////
	// DRAWING + GET SQL FROM PARSING
	/////////////////////////////////

	static AjaxGet(dotInput, callback)
	{
		let xhr = new XMLHttpRequest();
		xhr.onreadystatechange = function() {
			if (this.readyState == 4 && this.status == 200)
				callback(this.responseText);
		};
		xhr.open("GET", "scripts/getGraphSvg.php?dot=" + encodeURIComponent(dotInput), true);
		xhr.send();
	}

	// "Modèle conceptuel des données". TODO: option for graph size
	// NOTE: randomizing helps to obtain better graphs (sometimes)
	drawMcd(id, mcdStyle) //mcdStyle: bubble, or compact
	{
		let element = document.getElementById(id);
		mcdStyle = mcdStyle || "compact";
		if (this.mcdGraph.length > 0)
		{
			element.innerHTML = this.mcdGraph;
			return;
		}
		// Build dot graph input
		let mcdDot = 'graph {\n';
		mcdDot += 'rankdir="LR";\n';
		// Nodes:
		if (mcdStyle == "compact")
			mcdDot += 'node [shape=plaintext];\n';
		_.shuffle(Object.keys(this.entities)).forEach( name => {
			if (mcdStyle == "bubble")
			{
				mcdDot += '"' + name + '" [shape=rectangle, label="' + name + '"';
				if (this.entities[name].weak)
					mcdDot += ', peripheries=2';
				mcdDot += '];\n';
				if (!!this.entities[name].attributes)
				{
					this.entities[name].attributes.forEach( a => {
						let label = (a.isKey ? '#' : '') + a.name;
						let attrName = name + '_' + a.name;
						mcdDot += '"' + attrName + '" [shape=ellipse, label="' + label + '"];\n';
						if (Math.random() < 0.5)
							mcdDot += '"' + attrName + '" -- "' + name + '";\n';
						else
							mcdDot += '"' + name + '" -- "' + attrName + '";\n';
					});
				}
			}
			else
			{
				mcdDot += '"' + name + '" [label=<';
				if (this.entities[name].weak)
				{
					mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="0" CELLSPACING="3" CELLBORDER="0">' +
						'<tr><td><table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
				}
				else
					mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
				mcdDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
				if (!!this.entities[name].attributes)
				{
					this.entities[name].attributes.forEach( a => {
						let label = (a.isKey ? '<u>' : '') + a.name + (a.isKey ? '</u>' : '');
						mcdDot += '<tr><td BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
					});
				}
				mcdDot += '</table>';
				if (this.entities[name].weak)
					mcdDot += '</td></tr></table>';
				mcdDot += '>];\n';
			}
		});
		// Inheritances:
		_.shuffle(this.inheritances).forEach( i => {
			// TODO: node shape = triangle fill yellow. See
			// https://merise.developpez.com/faq/?page=MCD#CIF-ou-dependance-fonctionnelle-de-A-a-Z
			// https://merise.developpez.com/faq/?page=MLD#Comment-transformer-un-MCD-en-MLD
			// https://www.developpez.net/forums/d1088964/general-developpement/alm/modelisation/structure-agregation-l-association-d-association/
			_.shuffle(i.children).forEach( c => {
				if (Math.random() < 0.5)
					mcdDot += '"' + c + '":name -- "' + i.parent + '":name [dir="forward",arrowhead="vee",';
				else
					mcdDot += '"' + i.parent + '":name -- "' + c + '":name [dir="back",arrowtail="vee",';
				mcdDot += 'style="dashed"];\n';
			});
		});
		// Relationships:
		if (mcdStyle == "compact")
			mcdDot += 'node [shape=rectangle, style=rounded];\n';
		let assoceCounter = 0;
		_.shuffle(this.associations).forEach( a => {
			let name = a.name || "_assoce" + assoceCounter++;
			if (mcdStyle == "bubble")
			{
				mcdDot += '"' + name + '" [shape="diamond", style="filled", color="lightgrey", label="' + name + '"';
				if (a.weak)
					mcdDot += ', peripheries=2';
				mcdDot += '];\n';
				if (!!a.attributes)
				{
					a.attributes.forEach( attr => {
						let label = (attr.isKey ? '#' : '') + attr.name;
						mcdDot += '"' + name + '_' + attr.name + '" [shape=ellipse, label="' + label + '"];\n';
						let attrName = name + '_' + attr.name;
						if (Math.random() < 0.5)
							mcdDot += '"' + attrName + '" -- "' + name + '";\n';
						else
							mcdDot += '"' + name + '" -- "' + attrName + '";\n';
					});
				}
			}
			else
			{
				let label = '<' + name + '>';
				if (!!a.attributes)
				{
					a.attributes.forEach( attr => {
						let attrLabel = (attr.isKey ? '#' : '') + attr.name;
						label += '\\n' + attrLabel;
					});
				}
				mcdDot += '"' + name + '" [color="lightgrey", label="' + label + '"';
				if (a.weak)
					mcdDot += ', peripheries=2';
				mcdDot += '];\n';
			}
			_.shuffle(a.entities).forEach( e => {
				if (Math.random() < 0.5)
					mcdDot += '"' + e.name + '":name -- "' + name + '"';
				else
					mcdDot += '"' + name + '" -- "' + e.name + '":name';
				mcdDot += '[label="' + ErDiags.CARDINAL(e.card) + '"];\n';
			});
		});
		mcdDot += '}';
		//console.log(mcdDot);
		ErDiags.AjaxGet(mcdDot, graphSvg => {
			this.mcdGraph = graphSvg;
			element.innerHTML = graphSvg;
		});
	}

	// "Modèle logique des données", from MCD without anomalies
	// TODO: this one should draw links from foreign keys to keys (port=... in <TD>)
	drawMld(id)
	{
		let element = document.getElementById(id);
		if (this.mldGraph.length > 0)
		{
			element.innerHTML = this.mcdGraph;
			return;
		}
		// Build dot graph input (assuming foreign keys not already present...)
		let mldDot = 'graph {\n';
		mldDot += 'rankdir="LR";\n';
		mldDot += 'node [shape=plaintext];\n';
		let links = "";
		_.shuffle(Object.keys(this.tables)).forEach( name => {
			mldDot += '"' + name + '" [label=<<table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
			mldDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
			this.tables[name].forEach( f => {
				let label = (f.isKey ? '<u>' : '') + (!!f.ref ? '#' : '') + f.name + (f.isKey ? '</u>' : '');
				mldDot += '<tr><td port="' + f.name + '"' + ' BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
				if (!!f.ref)
				{
					const refPort = f.ref.slice(0,-1).replace('(',':');
					if (Math.random() < 0.5)
						links += refPort + ' -- "' + name+'":"'+f.name + '" [dir="forward",arrowhead="dot"';
					else
						links += '"'+name+'":"'+f.name+'" -- ' + refPort + ' [dir="back",arrowtail="dot"';
					links += ']\n;';
				}
			});
			mldDot += '</table>>];\n';
		});
		mldDot += links + '\n';
		mldDot += '}\n';
		//console.log(mldDot);
		ErDiags.AjaxGet(mldDot, graphSvg => {
			this.mldGraph = graphSvg;
			element.innerHTML = graphSvg;
		});
	}

	fillSql(id)
	{
		let element = document.getElementById(id);
		if (this.sqlText.length > 0)
		{
			element.innerHTML = this.sqlText;
			return;
		}
		let sqlText = "";
		Object.keys(this.tables).forEach( name => {
			sqlText += "CREATE TABLE " + name + " (\n";
			let key = "";
			let foreignKey = [ ];
			this.tables[name].forEach( f => {
				let type = f.type || (f.isKey ? "INTEGER" : "TEXT");
				if (!!f.ref)
					foreignKey.push({name: f.name, ref: f.ref});
				sqlText += "\t" + f.name + " " + type + " " + (f.qualifiers || "") + ",\n";
				if (f.isKey)
					key += (key.length>0 ? "," : "") + f.name;
			});
			sqlText += "\tPRIMARY KEY (" + key + ")";
			foreignKey.forEach( f => {
				let refParts = f.ref.split("(");
				const table = refParts[0];
				const field = refParts[1].slice(0,-1); //remove last parenthesis
				sqlText += ",\n\tFOREIGN KEY (" + f.name + ") REFERENCES " + table + "(" + field + ")";
			});
			sqlText += "\n);\n";
		});
		//console.log(sqlText);
		this.sqlText = sqlText;
		element.innerHTML = "<pre><code>" + sqlText + "</code></pre>";
	}
}
Commit	Line	Data
525c4d2a BA	1	// ER diagram description parser
	2	class ErDiags
	3	{
	4	constructor(description)
	5	{
4ef6cded BA	6	this.entities = { };
	7	this.inheritances = [ ];
	8	this.associations = [ ];
19addd10 BA	9	this.tables = { };
	10	this.mcdParsing(description);
	11	this.mldParsing();
525c4d2a BA	12	// Cache SVG graphs returned by server (in addition to server cache = good perfs)
	13	this.mcdGraph = "";
	14	this.mldGraph = "";
	15	this.sqlText = "";
	16	}
	17
7a80e6db	18	static CARDINAL(symbol)
525c4d2a	19	{
7a80e6db BA	20	let res = { "*": "0,n", "+": "1,n", "?": "0,1", "1": "1,1" } [ symbol[0] ];
	21	if (symbol.length >= 2)
	22	{
	23	if (symbol[1] == 'R')
	24	res = '(' + res + ')';
	25	else if (['>','<'].includes(symbol[1]))
	26	res += symbol[1];
	27	}
	28	return res;
525c4d2a BA	29	}
525c4d2a BA	30
19addd10 BA	31	///////////////////////////////
	32	// PARSING STAGE 1: text to MCD
	33	///////////////////////////////
525c4d2a BA	34
525c4d2a BA	35	// Parse a textual description into a json object
19addd10	36	mcdParsing(text)
525c4d2a BA	37	{
	38	let lines = text.split("\n");
	39	lines.push(""); //easier parsing: always empty line at the end
	40	let start = -1;
	41	for (let i=0; i < lines.length; i++)
	42	{
	43	lines[i] = lines[i].trim();
	44	// Empty line ?
	45	if (lines[i].length == 0)
	46	{
	47	if (start >= 0) //there is some group of lines to parse
	48	{
	49	this.parseThing(lines, start, i);
	50	start = -1;
	51	}
	52	}
	53	else //not empty line: just register starting point
	54	{
	55	if (start < 0)
	56	start = i;
	57	}
	58	}
	59	}
	60
	61	// Parse a group of lines into entity, association, ...
	62	parseThing(lines, start, end) //start included, end excluded
	63	{
	64	switch (lines[start].charAt(0))
	65	{
	66	case '[':
	67	// Entity = { name: { attributes, [weak] } }
006d95a3	68	let name = lines[start].match(/[^\[\]"\s]+/)[0];
525c4d2a BA	69	let entity = { attributes: this.parseAttributes(lines, start+1, end) };
	70	if (lines[start].charAt(1) == '[')
	71	entity.weak = true;
	72	this.entities[name] = entity;
	73	break;
	74	case 'i': //inheritance (arrows)
	75	this.inheritances = this.inheritances.concat(this.parseInheritance(lines, start+1, end));
	76	break;
	77	case '{': //association
	78	// Association = { [name], [attributes], [weak], entities: ArrayOf entity indices }
	79	let relationship = { };
006d95a3	80	let nameRes = lines[start].match(/[^{}"\s]+/);
525c4d2a BA	81	if (nameRes !== null)
	82	relationship.name = nameRes[0];
	83	if (lines[start].charAt(1) == '{')
	84	relationship.weak = true;
	85	this.associations.push(Object.assign({}, relationship, this.parseAssociation(lines, start+1, end)));
	86	break;
	87	}
	88	}
	89
	90	// attributes: ArrayOf {name, [isKey], [type], [qualifiers]}
	91	parseAttributes(lines, start, end)
	92	{
5fe4fa10	93	let attributes = [ ];
525c4d2a BA	94	for (let i=start; i<end; i++)
525c4d2a BA	95	{
d6c9499e BA	96	let field = { };
d6c9499e BA	97	let line = lines[i];
6a430a22	98	if (line.charAt(0) == '+')
d6c9499e	99	{
525c4d2a	100	field.isKey = true;
d6c9499e BA	101	line = line.slice(1);
d6c9499e BA	102	}
8edb29ff BA	103	field.name = line.match(/[^"\s]+/)[0];
	104	let sqlClues = line.substring(field.name.length).trim();
	105	if (sqlClues.length > 0)
525c4d2a	106	{
19addd10	107	field.type = sqlClues.match(/[^\s]+/)[0]; //type is always the first indication (mandatory)
8edb29ff	108	field.qualifiers = sqlClues.substring(field.type.length);
525c4d2a BA	109	}
	110	attributes.push(field);
	111	}
	112	return attributes;
	113	}
	114
	115	// GroupOf Inheritance: { parent, children: ArrayOf entity indices }
	116	parseInheritance(lines, start, end)
	117	{
	118	let inheritance = [];
	119	for (let i=start; i<end; i++)
	120	{
	121	let lineParts = lines[i].split(" ");
	122	let children = [];
	123	for (let j=1; j<lineParts.length; j++)
	124	children.push(lineParts[j]);
	125	inheritance.push({ parent:lineParts[0], children: children });
	126	}
	127	return inheritance;
	128	}
	129
c728aeca BA	130	// Association (parsed here): {
	131	// entities: ArrayOf entity names + cardinality,
	132	// [attributes: ArrayOf {name, [isKey], [type], [qualifiers]}]
	133	// }
525c4d2a BA	134	parseAssociation(lines, start, end)
	135	{
	136	let assoce = { };
	137	let entities = [];
	138	let i = start;
	139	while (i < end)
	140	{
	141	if (lines[i].charAt(0) == '-')
	142	{
	143	assoce.attributes = this.parseAttributes(lines, i+1, end);
	144	break;
	145	}
	146	else
	147	{
	148	// Read entity name + cardinality
	149	let lineParts = lines[i].split(" ");
	150	entities.push({ name:lineParts[0], card:lineParts[1] });
	151	}
	152	i++;
	153	}
	154	assoce.entities = entities;
	155	return assoce;
	156	}
	157
19addd10 BA	158	//////////////////////////////
	159	// PARSING STAGE 2: MCD to MLD
	160	//////////////////////////////
	161
	162	// From entities + relationships to tables
	163	mldParsing()
	164	{
	165	// Pass 1: initialize tables
	166	Object.keys(this.entities).forEach( name => {
	167	let newTable = [ ]; //array of fields
	168	this.entities[name].attributes.forEach( attr => {
8edb29ff	169	let newField = {
19addd10 BA	170	name: attr.name,
	171	type: attr.type,
	172	isKey: attr.isKey,
	173	qualifiers: attr.qualifiers,
8edb29ff	174	};
3789126f BA	175	if (!!attr.qualifiers && !!attr.qualifiers.match(/references/i))
3789126f BA	176	{
8edb29ff	177	Object.assign(newField, {ref: attr.qualifiers.match(/references ([^\s]+)/i)[1]});
3789126f BA	178	attr.qualifiers = attr.qualifiers.replace(/references [^\s]+/, "");
3789126f BA	179	}
8edb29ff	180	newTable.push(newField);
19addd10 BA	181	});
	182	this.tables[name] = newTable;
	183	});
3ca1e50c BA	184	// Add foreign keys information for children (inheritance). TODO: allow several levels
	185	// NOTE: modelisation assume each child has its own table, refering parent (other options exist)
	186	this.inheritances.forEach( inh => {
	187	let idx = this.tables[inh.parent].findIndex( item => { return item.isKey; });
	188	inh.children.forEach( c => {
	189	this.tables[c].push({
	190	name: inh.parent + "_id",
	191	type: this.tables[inh.parent][idx].type,
	192	isKey: true,
3789126f BA	193	qualifiers: this.tables[inh.parent][idx].qualifiers \|\| "",
3789126f BA	194	ref: inh.parent + "(" + this.tables[inh.parent][idx].name + ")",
3ca1e50c BA	195	});
	196	});
	197	});
19addd10 BA	198	// Pass 2: parse associations, add foreign keys when cardinality is 0,1 or 1,1
	199	this.associations.forEach( a => {
	200	let newTableAttrs = [ ];
0133e929	201	let hasZeroOne = false;
19addd10 BA	202	a.entities.forEach( e => {
	203	if (['?','1'].includes(e.card[0]))
	204	{
0133e929	205	hasZeroOne = true;
19addd10 BA	206	// Foreign key apparition (for each entity in association minus current one, for each identifying attribute)
	207	a.entities.forEach( e2 => {
	208	if (e2.name == e.name)
	209	return;
5fe4fa10	210	this.entities[e2.name].attributes.forEach( attr => {
19addd10 BA	211	if (attr.isKey)
19addd10 BA	212	{
2a12fea9 BA	213	// For "weak tables", foreign keys become part of the key
2a12fea9 BA	214	const isKey = e.card.length >= 2 && e.card[1] == 'R';
19addd10	215	this.tables[e.name].push({
2a12fea9	216	isKey: isKey,
3ca1e50c	217	name: e2.name + "_" + attr.name,
19addd10	218	type: attr.type,
3789126f BA	219	qualifiers: !isKey && e.card[0]=='1' ? "not null" : "",
3789126f BA	220	ref: e2.name + "(" + attr.name + ")",
19addd10 BA	221	});
	222	}
	223	});
	224	});
	225	}
	226	else
	227	{
	228	// Add all keys in current entity
351d7a84	229	let fields = this.entities[e.name].attributes.filter( attr => { return attr.isKey; });
19addd10 BA	230	newTableAttrs.push({
	231	fields: fields,
	232	entity: e.name,
	233	});
	234	}
351d7a84	235	});
0133e929	236	if (!hasZeroOne && newTableAttrs.length > 1)
19addd10 BA	237	{
	238	// Ok, really create a new table
	239	let newTable = {
351d7a84	240	name: a.name \|\| newTableAttrs.map( item => { return item.entity; }).join("_"),
19addd10 BA	241	fields: [ ],
	242	};
	243	newTableAttrs.forEach( item => {
	244	item.fields.forEach( f => {
	245	newTable.fields.push({
	246	name: item.entity + "_" + f.name,
	247	isKey: true,
351d7a84	248	type: f.type,
3789126f BA	249	qualifiers: f.qualifiers \|\| "",
3789126f BA	250	ref: item.entity + "(" + f.name + ")",
19addd10 BA	251	});
	252	});
	253	});
7a80e6db BA	254	// Check for duplicates (in case of self-relationship), rename if needed
	255	newTable.fields.forEach( (f,i) => {
	256	const idx = newTable.fields.findIndex( item => { return item.name == f.name; });
	257	if (idx < i)
	258	{
	259	// Current field is a duplicate
	260	let suffix = 2;
	261	let newName = f.name + suffix;
	262	while (newTable.fields.findIndex( item => { return item.name == newName; }) >= 0)
	263	{
	264	suffix++;
	265	newName = f.name + suffix;
	266	}
	267	f.name = newName;
	268	}
	269	});
19addd10	270	// Add relationship potential own attributes
5fe4fa10	271	(a.attributes \|\| [ ]).forEach( attr => {
19addd10 BA	272	newTable.fields.push({
	273	name: attr.name,
	274	isKey: false,
	275	type: attr.type,
	276	qualifiers: attr.qualifiers,
	277	});
	278	});
	279	this.tables[newTable.name] = newTable.fields;
	280	}
	281	});
	282	}
	283
	284	/////////////////////////////////
	285	// DRAWING + GET SQL FROM PARSING
	286	/////////////////////////////////
525c4d2a BA	287
	288	static AjaxGet(dotInput, callback)
	289	{
	290	let xhr = new XMLHttpRequest();
	291	xhr.onreadystatechange = function() {
	292	if (this.readyState == 4 && this.status == 200)
	293	callback(this.responseText);
	294	};
	295	xhr.open("GET", "scripts/getGraphSvg.php?dot=" + encodeURIComponent(dotInput), true);
	296	xhr.send();
	297	}
	298
	299	// "Modèle conceptuel des données". TODO: option for graph size
48a55161	300	// NOTE: randomizing helps to obtain better graphs (sometimes)
525c4d2a BA	301	drawMcd(id, mcdStyle) //mcdStyle: bubble, or compact
	302	{
	303	let element = document.getElementById(id);
	304	mcdStyle = mcdStyle \|\| "compact";
	305	if (this.mcdGraph.length > 0)
	306	{
	307	element.innerHTML = this.mcdGraph;
	308	return;
	309	}
	310	// Build dot graph input
	311	let mcdDot = 'graph {\n';
48a55161	312	mcdDot += 'rankdir="LR";\n';
525c4d2a	313	// Nodes:
48a55161	314	if (mcdStyle == "compact")
c728aeca	315	mcdDot += 'node [shape=plaintext];\n';
48a55161	316	_.shuffle(Object.keys(this.entities)).forEach( name => {
525c4d2a BA	317	if (mcdStyle == "bubble")
525c4d2a BA	318	{
006d95a3	319	mcdDot += '"' + name + '" [shape=rectangle, label="' + name + '"';
525c4d2a BA	320	if (this.entities[name].weak)
	321	mcdDot += ', peripheries=2';
	322	mcdDot += '];\n';
	323	if (!!this.entities[name].attributes)
	324	{
b74cfe41	325	this.entities[name].attributes.forEach( a => {
525c4d2a	326	let label = (a.isKey ? '#' : '') + a.name;
48a55161	327	let attrName = name + '_' + a.name;
006d95a3	328	mcdDot += '"' + attrName + '" [shape=ellipse, label="' + label + '"];\n';
48a55161	329	if (Math.random() < 0.5)
006d95a3	330	mcdDot += '"' + attrName + '" -- "' + name + '";\n';
48a55161	331	else
006d95a3	332	mcdDot += '"' + name + '" -- "' + attrName + '";\n';
525c4d2a BA	333	});
	334	}
	335	}
	336	else
	337	{
006d95a3	338	mcdDot += '"' + name + '" [label=<';
525c4d2a BA	339	if (this.entities[name].weak)
	340	{
	341	mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="0" CELLSPACING="3" CELLBORDER="0">' +
	342	'<tr><td><table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
	343	}
	344	else
	345	mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
	346	mcdDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
	347	if (!!this.entities[name].attributes)
	348	{
b74cfe41	349	this.entities[name].attributes.forEach( a => {
525c4d2a BA	350	let label = (a.isKey ? '<u>' : '') + a.name + (a.isKey ? '</u>' : '');
	351	mcdDot += '<tr><td BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
	352	});
	353	}
	354	mcdDot += '</table>';
	355	if (this.entities[name].weak)
	356	mcdDot += '</td></tr></table>';
	357	mcdDot += '>];\n';
	358	}
	359	});
	360	// Inheritances:
006d95a3	361	_.shuffle(this.inheritances).forEach( i => {
a2d8ba72 BA	362	// TODO: node shape = triangle fill yellow. See
	363	// https://merise.developpez.com/faq/?page=MCD#CIF-ou-dependance-fonctionnelle-de-A-a-Z
	364	// https://merise.developpez.com/faq/?page=MLD#Comment-transformer-un-MCD-en-MLD
	365	// https://www.developpez.net/forums/d1088964/general-developpement/alm/modelisation/structure-agregation-l-association-d-association/
48a55161 BA	366	_.shuffle(i.children).forEach( c => {
48a55161 BA	367	if (Math.random() < 0.5)
3ca1e50c	368	mcdDot += '"' + c + '":name -- "' + i.parent + '":name [dir="forward",arrowhead="vee",';
48a55161	369	else
3ca1e50c BA	370	mcdDot += '"' + i.parent + '":name -- "' + c + '":name [dir="back",arrowtail="vee",';
3ca1e50c BA	371	mcdDot += 'style="dashed"];\n';
525c4d2a BA	372	});
	373	});
	374	// Relationships:
c728aeca BA	375	if (mcdStyle == "compact")
c728aeca BA	376	mcdDot += 'node [shape=rectangle, style=rounded];\n';
525c4d2a	377	let assoceCounter = 0;
48a55161	378	_.shuffle(this.associations).forEach( a => {
19addd10	379	let name = a.name \|\| "_assoce" + assoceCounter++;
c728aeca BA	380	if (mcdStyle == "bubble")
	381	{
	382	mcdDot += '"' + name + '" [shape="diamond", style="filled", color="lightgrey", label="' + name + '"';
	383	if (a.weak)
	384	mcdDot += ', peripheries=2';
	385	mcdDot += '];\n';
	386	if (!!a.attributes)
	387	{
	388	a.attributes.forEach( attr => {
	389	let label = (attr.isKey ? '#' : '') + attr.name;
	390	mcdDot += '"' + name + '_' + attr.name + '" [shape=ellipse, label="' + label + '"];\n';
	391	let attrName = name + '_' + attr.name;
	392	if (Math.random() < 0.5)
	393	mcdDot += '"' + attrName + '" -- "' + name + '";\n';
	394	else
	395	mcdDot += '"' + name + '" -- "' + attrName + '";\n';
	396	});
	397	}
	398	}
	399	else
	400	{
4ef6cded	401	let label = '<' + name + '>';
c728aeca BA	402	if (!!a.attributes)
	403	{
	404	a.attributes.forEach( attr => {
	405	let attrLabel = (attr.isKey ? '#' : '') + attr.name;
4ef6cded	406	label += '\\n' + attrLabel;
c728aeca BA	407	});
	408	}
	409	mcdDot += '"' + name + '" [color="lightgrey", label="' + label + '"';
	410	if (a.weak)
	411	mcdDot += ', peripheries=2';
	412	mcdDot += '];\n';
	413	}
48a55161 BA	414	_.shuffle(a.entities).forEach( e => {
48a55161 BA	415	if (Math.random() < 0.5)
006d95a3	416	mcdDot += '"' + e.name + '":name -- "' + name + '"';
48a55161	417	else
006d95a3	418	mcdDot += '"' + name + '" -- "' + e.name + '":name';
7a80e6db	419	mcdDot += '[label="' + ErDiags.CARDINAL(e.card) + '"];\n';
525c4d2a	420	});
525c4d2a BA	421	});
525c4d2a BA	422	mcdDot += '}';
3ca1e50c	423	//console.log(mcdDot);
525c4d2a BA	424	ErDiags.AjaxGet(mcdDot, graphSvg => {
	425	this.mcdGraph = graphSvg;
	426	element.innerHTML = graphSvg;
d6c9499e	427	});
525c4d2a BA	428	}
525c4d2a BA	429
19addd10	430	// "Modèle logique des données", from MCD without anomalies
48a55161	431	// TODO: this one should draw links from foreign keys to keys (port=... in <TD>)
525c4d2a BA	432	drawMld(id)
	433	{
	434	let element = document.getElementById(id);
	435	if (this.mldGraph.length > 0)
	436	{
	437	element.innerHTML = this.mcdGraph;
	438	return;
	439	}
4ef6cded	440	// Build dot graph input (assuming foreign keys not already present...)
e2610c05	441	let mldDot = 'graph {\n';
3ca1e50c	442	mldDot += 'rankdir="LR";\n';
19addd10 BA	443	mldDot += 'node [shape=plaintext];\n';
	444	let links = "";
	445	_.shuffle(Object.keys(this.tables)).forEach( name => {
	446	mldDot += '"' + name + '" [label=<<table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
	447	mldDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
351d7a84	448	this.tables[name].forEach( f => {
8edb29ff	449	let label = (f.isKey ? '<u>' : '') + (!!f.ref ? '#' : '') + f.name + (f.isKey ? '</u>' : '');
3ca1e50c	450	mldDot += '<tr><td port="' + f.name + '"' + ' BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
19addd10	451	if (!!f.ref)
4ef6cded	452	{
3789126f	453	const refPort = f.ref.slice(0,-1).replace('(',':');
19addd10	454	if (Math.random() < 0.5)
3789126f	455	links += refPort + ' -- "' + name+'":"'+f.name + '" [dir="forward",arrowhead="dot"';
19addd10	456	else
3789126f	457	links += '"'+name+'":"'+f.name+'" -- ' + refPort + ' [dir="back",arrowtail="dot"';
3ca1e50c	458	links += ']\n;';
19addd10	459	}
e2610c05	460	});
19addd10	461	mldDot += '</table>>];\n';
e2610c05	462	});
19addd10 BA	463	mldDot += links + '\n';
19addd10 BA	464	mldDot += '}\n';
3ca1e50c	465	//console.log(mldDot);
d6c9499e BA	466	ErDiags.AjaxGet(mldDot, graphSvg => {
	467	this.mldGraph = graphSvg;
	468	element.innerHTML = graphSvg;
	469	});
525c4d2a BA	470	}
	471
	472	fillSql(id)
	473	{
	474	let element = document.getElementById(id);
	475	if (this.sqlText.length > 0)
	476	{
	477	element.innerHTML = this.sqlText;
	478	return;
	479	}
19addd10 BA	480	let sqlText = "";
	481	Object.keys(this.tables).forEach( name => {
	482	sqlText += "CREATE TABLE " + name + " (\n";
	483	let key = "";
3789126f	484	let foreignKey = [ ];
19addd10	485	this.tables[name].forEach( f => {
8edb29ff	486	let type = f.type \|\| (f.isKey ? "INTEGER" : "TEXT");
3789126f BA	487	if (!!f.ref)
3789126f BA	488	foreignKey.push({name: f.name, ref: f.ref});
8edb29ff	489	sqlText += "\t" + f.name + " " + type + " " + (f.qualifiers \|\| "") + ",\n";
19addd10 BA	490	if (f.isKey)
	491	key += (key.length>0 ? "," : "") + f.name;
	492	});
3789126f BA	493	sqlText += "\tPRIMARY KEY (" + key + ")";
	494	foreignKey.forEach( f => {
	495	let refParts = f.ref.split("(");
	496	const table = refParts[0];
	497	const field = refParts[1].slice(0,-1); //remove last parenthesis
	498	sqlText += ",\n\tFOREIGN KEY (" + f.name + ") REFERENCES " + table + "(" + field + ")";
	499	});
	500	sqlText += "\n);\n";
19addd10 BA	501	});
	502	//console.log(sqlText);
	503	this.sqlText = sqlText;
	504	element.innerHTML = "<pre><code>" + sqlText + "</code></pre>";
525c4d2a BA	505	}
525c4d2a BA	506	}