function database_mysql_value_encode(
	value : any
) : string
{
	if (value === null) {
		return "NULL";
	}
	else {
		switch (typeof(value)) {
			case "boolean": {
				return (value ? "TRUE" : "FALSE");
				break;
			}
			case "number": {
				return value.toString();
				break;
			}
			case "string": {
				return ("'" + value + "'");
				break;
			}
			default: {
				throw (new Error("unhandled"));
				break;
			}
		}
	}
}

const output_database_mysql : type_output = {
	"render": function (input_data) {
		return (
			input_data.domains
			.map(
				(domain) => lib_plankton.string.coin(
					"CREATE TABLE\n\t`{{name}}`(\n{{entries}}\n\t){{comment}}\n;",
					{
						"name": domain.name,
						"comment": (
							(domain.description === null)
							? ""
							: lib_plankton.string.coin(
								" COMMENT '{{comment}}'",
								{
									"comment": domain.description,
								}
							)
						),
						"entries": (
							(
								[]
								// key field
								.concat(
									(domain.key_field === null)
									? []
									: lib_plankton.string.coin(
										"`{{name}}` {{parameters}}",
										{
											"name": domain.key_field.name,
											"parameters": (
												[
													"INTEGER",
													"PRIMARY KEY",
													"AUTO INCREMENT",
												]
												.concat(
													(domain.key_field.description === null)
													? []
													: [
														lib_plankton.string.coin(
															"COMMENT '{{comment}}'",
															{
																"comment": domain.key_field.description,
															}
														),
													]
												)
												.join(" ")
											),
										}
									)
								)
								// data fields
								.concat(
									domain.data_fields
									.map(
										(data_field) => lib_plankton.string.coin(
											"`{{name}}` {{parameters}}",
											{
												"name": data_field.name,
												"parameters": (
													(
														// type
														[
															{
																"boolean": "BOOLEAN",
																"integer": "INTEGER",
																"string_short": "VARCHAR(63)",
																"string_medium": "VARCHAR(255)",
																"string_long": "TEXT",
															}[data_field.type],
														]
														// nullability
														.concat(
															data_field.nullable
															? ["NULL"]
															: []
														)
														// default
														.concat(
															(data_field.default === undefined)
															? []
															: [
																lib_plankton.string.coin(
																	"DEFAULT {{value}}",
																	{
																		"value": database_mysql_value_encode(data_field.default),
																	}
																),
															]
														)
														// comment
														.concat(
															(data_field.description === null)
															? []
															: [
																lib_plankton.string.coin(
																	"COMMENT '{{comment}}'",
																	{
																		"comment": data_field.description,
																	}
																),
															]
														)
													)
													.join(" ")
												)
											}
										)
									)
								)
								// constraints
								.concat(
									domain["constraints"]
									.map(
										(constraint) => {
											switch (constraint.kind) {
												default: {
													throw (new Error("unhandled constraint kind: " + constraint.kind));
													break;
												}
												case "foreign_key": {
													return lib_plankton.string.coin(
														"FOREIGN KEY ({{fields}}) REFERENCES `{{reference_name}}`({{reference_fields}})",
														{
															"fields": (
																constraint.parameters["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
															"reference_name": constraint.parameters["reference"]["name"],
															"reference_fields": (
																constraint.parameters["reference"]["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
														}
													);
													break;
												}
												case "unique": {
													return lib_plankton.string.coin(
														"UNIQUE ({{fields}})",
														{
															"fields": (
																constraint.parameters["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
														}
													);
													break;
												}
											}
										}
									)
								)
							)
							.map(x => ("\t\t" + x))
							.join(",\n")
						),
					}
				)
			)
			.map(x => (x + "\n"))
			.join("\n")
		);
	},
};