Add postgresql format

src/commonMain/kotlin/com/republicate/kddl/KDDLProcessor.kt

@@ -8,7 +8,7 @@ import net.akehurst.language.api.analyser.SyntaxAnalyser
 
 enum class Format {
     PLANTUML,
-    PSQL
+    POSTGRESQL
 }
 
 abstract class KDDLProcessor(val format: Format) {

src/commonMain/kotlin/com/republicate/kddl/Main.kt

@@ -14,7 +14,7 @@ fun main(args: Array<String>) {
 
     val processor : KDDLProcessor = when(format) {
         Format.PLANTUML -> PlantUMLProcessor()
-        Format.PSQL -> TODO("wip PSQLProcessor")
+        Format.POSTGRESQL -> PostgreSQLProcessor()
         else -> throw IllegalArgumentException("invalid format")
     }
     println(processor.processor.formatTextForGoal<Database>("database", model))

src/commonMain/kotlin/com/republicate/kddl/postrgesql.kt

+package com.republicate.kddl
+
+import net.akehurst.language.agl.processor.Agl
+import net.akehurst.language.api.processor.LanguageProcessor
+
+class PostgreSQLProcessor : KDDLProcessor(Format.POSTGRESQL) {
+    override val formatter = PostgreSQLFormatter()
+}
+
+class PostgreSQLFormatter : KDDLFormatter() {
+
+    override fun format(indent: String, asm: Database): String {
+        val ret = StringBuilder("-- database $asm.name")
+        // TODO postgresql options
+        ret.append(
+                asm.schemas.map {
+                    format(indent, it.value)
+                }.joinToString(separator = EOL)
+        )
+        return ret.toString()
+    }
+
+    val END = ";EOL"
+
+    override fun format(indent: String, asm: Schema): String {
+        val ret = StringBuilder()
+        ret.append("-- schema ${asm.name}")
+        ret.append("DROP SCHEMA IF EXISTS ${asm.name}$END")
+        ret.append("CREATE SCHEMA ${asm.name}")
+        val owner = asm.db.options["owner"]?.value ?: ""
+        if (owner.isNotEmpty()) ret.append(" WITH OWNER $owner")
+        ret.append(END)
+        ret.append("SET search_path TO ${asm.name}$END")
+        ret.append(
+                asm.tables.map {
+                    format(indent, it.value)
+                }.joinToString(separator = EOL)
+        )
+        asm.tables.values.flatMap{ it.foreignKeys }/*.filter {
+            !it.isFieldLink()
+        }*/.forEach {
+            ret.append(format(indent, it))
+        }
+        return ret.toString()
+    }
+
+    override fun format(indent: String, asm: Table): String {
+        val ret = StringBuilder()
+        if (asm !is JoinTable) {
+            ret.append("CREATE TABLE ${asm.name} (")
+            var firstField = true
+            for (field in asm.fields.values) {
+                if (firstField) firstField = false else ret.append(",")
+                ret.append(EOL)
+                ret.append(format("  ", field))
+            }
+            ret.append("$EOL)")
+            if (asm.parent != null) ret.append(" INERITS (${asm.parent.name})")
+            ret.append("$END)")
+        }
+        return ret.toString()
+    }
+
+    override fun format(indent: String, asm: Field): String {
+        val ret = StringBuilder(indent)
+        asm.apply {
+            ret.append(name)
+            if (type.isEmpty()) throw RuntimeException("Missing type for ${asm.table.schema.name}.${asm.table.name}.${asm.name}")
+            ret.append(" $type")
+            if (nonNull) ret.append(" NOT NULL")
+            if (primaryKey) ret.append(" PRIMARY KEY")
+        }
+        return ret.toString()
+    }
+
+    override fun format(indent: String, asm: ForeignKey): String {
+        val ret = StringBuilder()
+        ret.append("ALTER TABLE ${asm.from.name}")
+        ret.append(" ADD CONSTRAINT ${asm.fields.first().name.removeSuffix(suffix)}")
+        ret.append(" FOREIGN KEY (${asm.fields.first().name})")
+        ret.append(" REFRENCES  ")
+        if (asm.towards.schema.name != asm.from.schema.name) {
+            ret.append("${asm.towards.schema.name}.")
+        }
+        ret.append("${asm.towards.name} (${asm.towards.getPrimaryKey().first().name})$END")
+        return ret.toString()
+    }
+
+}