1 files changed, 118 insertions, 13 deletions
diff --git a/container-compiler-plugin/src/main/java/io/trygvis/persistence/EntityMirror.java b/container-compiler-plugin/src/main/java/io/trygvis/persistence/EntityMirror.java
index 2a4952f..8e1602c 100644
--- a/container-compiler-plugin/src/main/java/io/trygvis/persistence/EntityMirror.java
+++ b/container-compiler-plugin/src/main/java/io/trygvis/persistence/EntityMirror.java
@@ -1,5 +1,7 @@
 package io.trygvis.persistence;
 
+import io.trygvis.container.compiler.NotImplementedException;
+import io.trygvis.container.compiler.SqlUnitModel;
 import io.trygvis.container.compiler.model.ClassG;
 import io.trygvis.container.compiler.model.ParameterRef;
 import io.trygvis.container.compiler.model.TypeRef;
@@ -10,19 +12,21 @@ import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
 
+import static io.trygvis.persistence.FieldMirror.PrimitiveFieldMirror;
+import static io.trygvis.persistence.FieldMirror.ReferenceFieldMirror;
 import static java.lang.String.format;
 import static org.apache.commons.lang.StringUtils.join;
 
-public class EntityMirror {
-    public final GeneratorSupport generatorSupport;
+public class EntityMirror implements Comparable<EntityMirror> {
+    public final GeneratorConfiguration generatorConfiguration;
     public final List<FieldMirror> fields = new ArrayList<>();
     public final List<FieldMirror> idFields = new ArrayList<>();
     public final TypeRef type;
     public final String tableName;
     public final TypeRef daoType;
 
-    public EntityMirror(GeneratorSupport generatorSupport, TypeRef type, String tableName) {
-        this.generatorSupport = generatorSupport;
+    public EntityMirror(GeneratorConfiguration generatorConfiguration, TypeRef type, String tableName) {
+        this.generatorConfiguration = generatorConfiguration;
         this.type = type;
         this.tableName = tableName;
 
@@ -31,18 +35,48 @@ public class EntityMirror {
 
     public void add(FieldMirror field) {
         fields.add(field);
-        if(field.id) {
+        if (field.id) {
             idFields.add(field);
         }
     }
 
-    public String createTableSql() {
+    public FieldMirror getIdField() {
+        return idFields.get(0);
+    }
+
+    public String createTableSql(SqlUnitModel unit) {
         List<String> columns = new ArrayList<>();
         for (FieldMirror field : fields) {
-            TypeHandler typeHandler = generatorSupport.typeHandler(field.type);
-            String s = "  " + field.sqlName + " " + typeHandler.sqlType(field);
-            if(field.id) {
-                s += " PRIMARY KEY";
+            String s;
+            if (field instanceof PrimitiveFieldMirror) {
+                TypeHandler typeHandler = generatorConfiguration.typeHandler(field.type);
+                s = "  " + field.sqlName + " " + typeHandler.sqlType(field);
+                if (field.id) {
+                    s += " PRIMARY KEY";
+                } else if (field.notNull) {
+                    s += " NOT NULL";
+                } else if (field.unique) {
+                    s += " UNIQUE";
+                }
+            } else if (field instanceof ReferenceFieldMirror) {
+                ReferenceFieldMirror ref = (ReferenceFieldMirror) field;
+                EntityMirror referenced = unit.get(ref.type);
+                if(referenced.idFields.size() == 1) {
+                    FieldMirror idField = referenced.idFields.get(0);
+                    TypeHandler typeHandler = generatorConfiguration.typeHandler(idField.type);
+                    s = "  " + field.sqlName + " " + typeHandler.sqlType(field);
+                    s += " REFERENCES " + referenced.tableName + "(" + idField.sqlName + ")";
+                    if (field.notNull) {
+                        s += " NOT NULL";
+                    } else if (field.unique) {
+                        s += " UNIQUE";
+                    }
+                }
+                else {
+                    throw new NotImplementedException();
+                }
+            } else {
+                throw new RuntimeException("Unknown field type: " + field.getClass());
             }
             columns.add(s);
         }
@@ -77,7 +111,7 @@ public class EntityMirror {
         return "DELETE FROM " + tableName + " WHERE " + join(ss, " AND ") + ";";
     }
 
-    public void insertInto(ClassG g) {
+    public void insertInto(SqlUnitModel unit, ClassG g) {
         TypeRef conType = g.addImport(Connection.class);
         TypeRef psType = g.addImport(PreparedStatement.class);
         TypeRef objectType = g.addImport(type);
@@ -89,8 +123,16 @@ public class EntityMirror {
         body.add("try(" + psType.name + " stmt = " + con.name + ".prepareStatement(insertIntoSql)) {");
         for (int i = 0; i < fields.size(); i++) {
             FieldMirror field = fields.get(i);
-            TypeHandler typeHandler = generatorSupport.typeHandler(field.type);
-            body.add("    stmt." + typeHandler.resultSetSetter(i + 1, "o", field) + ";");
+            if(field instanceof PrimitiveFieldMirror) {
+                TypeHandler typeHandler = generatorConfiguration.typeHandler(field.type);
+                body.add("    stmt." + typeHandler.setter(i + 1, "o." + field.javaName) + ";");
+            } else if (field instanceof ReferenceFieldMirror) {
+                ReferenceFieldMirror ref = (ReferenceFieldMirror) field;
+                EntityMirror referenced = unit.get(ref.type);
+                FieldMirror idField = referenced.getIdField();
+                TypeHandler typeHandler = generatorConfiguration.typeHandler(idField.type);
+                body.add("    stmt." + typeHandler.setter(i + 1, "o." + field.javaName + "." + idField.javaName) + ";");
+            }
         }
         body.add("    stmt.executeUpdate();");
         body.add("}");
@@ -98,4 +140,67 @@ public class EntityMirror {
         g.addStaticMethod(body, TypeRef.VOID, "insertInto", con, object).
                 exception(g.addImport(SQLException.class));
     }
+
+    public void delete(ClassG g) {
+        TypeRef conType = g.addImport(Connection.class);
+        TypeRef objectType = g.addImport(type);
+        ParameterRef con = new ParameterRef(conType, "con");
+        ParameterRef o = new ParameterRef(objectType, "o");
+
+        List<String> arguments = new ArrayList<>();
+        arguments.add(con.name);
+        for (FieldMirror field : idFields) {
+            arguments.add(o.name + "." + field.javaName);
+        }
+        List<String> body = new ArrayList<>();
+        body.add("deleteById(" + join(arguments, ", ") + ");");
+
+        g.addStaticMethod(body, TypeRef.VOID, "delete", con, o).
+                exception(g.addImport(SQLException.class));
+    }
+
+    public void deleteById(ClassG g) {
+        TypeRef conType = g.addImport(Connection.class);
+        TypeRef psType = g.addImport(PreparedStatement.class);
+        ParameterRef con = new ParameterRef(conType, "con");
+
+        ParameterRef[] parameters = new ParameterRef[idFields.size() + 1];
+        parameters[0] = con;
+
+        List<String> body = new ArrayList<>();
+
+        body.add("try(" + psType.name + " stmt = " + con.name + ".prepareStatement(deleteFromSql)) {");
+        for (int i = 0; i < idFields.size(); i++) {
+            FieldMirror field = idFields.get(i);
+            TypeHandler typeHandler = generatorConfiguration.typeHandler(field.type);
+            ParameterRef p = new ParameterRef(field.type, field.javaName);
+            parameters[i + 1] = p;
+            body.add("    stmt." + typeHandler.setter(i + 1, field.javaName) + ";");
+        }
+        body.add("    stmt.executeUpdate();");
+        body.add("}");
+
+        g.addStaticMethod(body, TypeRef.VOID, "deleteById", parameters).
+                exception(g.addImport(SQLException.class));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof EntityMirror)) return false;
+
+        EntityMirror that = (EntityMirror) o;
+
+        return type.equals(that.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return type.hashCode();
+    }
+
+    @Override
+    public int compareTo(EntityMirror o) {
+        return type.compareTo(o.type);
+    }
 }