Blueprint, Schema, ColumnBuilder added

src/main/java/com/opentek/catapult/core/exceptions/InvalidSchemaException.java

@@ -0,0 +1,7 @@
+package com.opentek.catapult.core.exceptions;
+
+public class InvalidSchemaException extends Exception {
+    public InvalidSchemaException(String message) {
+        super(message);
+    }
+}

src/main/java/com/opentek/catapult/core/models/migrations/BluePrint.java

@@ -1,5 +1,221 @@
 package com.opentek.catapult.core.models.migrations;
 
+import com.opentek.catapult.core.exceptions.InvalidSchemaException;
+
+import java.util.ArrayList;
+
 public class BluePrint {
+    private final static String TINYINT = "TINYINT";
+    private final static String SMALLINT = "SMALLINT";
+    private final static String MEDIUMINT = "MEDIUMINT";
+    private final static String INTEGER = "INT";
+    private final static String BIGINT = "BIGINT";
+    private final static String DECIMAL = "DECIMAL";
+    private final static String FLOAT = "FLOAT";
+    private final static String DOUBLE = "DOUBLE";
+    private final static String REAL = "REAL";
+    private static final String BIT = "BIT";
+    private static final String SERIAL = "SERIAL";
+    private static final String DATE = "DATE";
+    private static final String DATETIME = "DATETIME";
+    private static final String TIMESTAMP = "TIMESTAMP";
+    private static final String TIME = "TIME";
+    private static final String YEAR = "YEAR";
+    private static final String CHAR = "CHAR";
+    private static final String VARCHAR = "VARCHAR";
+    private static final String TINYTEXT = "TINYTEXT";
+    private static final String TEXT = "TEXT";
+    private static final String MEDIUMTEXT = "MEDIUMTEXT";
+    private static final String LONGTEXT = "LONGTEXT";
+    private static final String BINARY = "BINARY";
+    private static final String VARBINARY = "VARBINARY";
+    private static final String TINYBLOB = "TINYBLOB";
+    private static final String BLOB = "BLOB";
+    private static final String MEDIUMBLOB = "MEDIUMBLOB";
+    private static final String LONGBLOB = "LONGBLOB";
+    private static final String ENUM = "ENUM";
+    private static final String SET = "SET";
+
+
+    private String tableName;
+    private ArrayList<Column> columns;
+//    protected ColumnBuilder
+    protected BluePrint(String tableName){
+        this.tableName = tableName;
+        this.columns = new ArrayList<>();
+    }
+    public ColumnBuilder tinyint(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TINYINT, columns);
+    }
+    public ColumnBuilder smallint(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,SMALLINT, columns);
+    }
+    public ColumnBuilder mediumint(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,MEDIUMINT, columns);
+    }
+    public ColumnBuilder integer(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,INTEGER, columns);
+    }
+    public ColumnBuilder bigint(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,BIGINT, columns);
+    }
+    public ColumnBuilder decimal(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,DECIMAL, columns);
+    }
+    public ColumnBuilder floatType(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,FLOAT, columns);
+    }
+    public ColumnBuilder doubleType(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,DOUBLE, columns);
+    }
+    public ColumnBuilder real(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,REAL, columns);
+    }
+    public ColumnBuilder bit(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,BIT, columns);
+    }
+    public ColumnBuilder serial(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,SERIAL, columns);
+    }
+    public ColumnBuilder date(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,DATE, columns);
+    }
+    public ColumnBuilder datetime(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,DATETIME, columns);
+    }
+    public ColumnBuilder timestamp(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TIMESTAMP, columns);
+    }
+    public ColumnBuilder time(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TIME, columns);
+    }
+    public ColumnBuilder year(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,YEAR, columns);
+    }
+    public ColumnBuilder varchar(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,VARCHAR, columns);
+    }
+    public ColumnBuilder character(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,CHAR, columns);
+    }
+    public ColumnBuilder tinytext(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TINYTEXT, columns);
+    }
+    public ColumnBuilder text(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TEXT, columns);
+    }
+    public ColumnBuilder mediumtext(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,MEDIUMTEXT, columns);
+    }
+    public ColumnBuilder longtext(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,LONGTEXT, columns);
+    }
+    public ColumnBuilder binary(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,BINARY, columns);
+    }
+    public ColumnBuilder varbinary(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,VARBINARY, columns);
+    }
+    public ColumnBuilder tinyblob(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,TINYBLOB, columns);
+    }
+    public ColumnBuilder blob(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,BLOB, columns);
+    }
+    public ColumnBuilder mediumblob(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,MEDIUMBLOB, columns);
+    }
+    public ColumnBuilder longblob(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,LONGBLOB, columns);
+    }
+    public ColumnBuilder enumuration(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,ENUM, columns);
+    }
+    public ColumnBuilder set(String columnName) throws InvalidSchemaException {
+        if(columnName == null || columnName.equals(""))
+            throw new InvalidSchemaException("Column Name is invalid");
+        return new ColumnBuilder(columnName,SET, columns);
+    }
+
+    public String buildQuery(){
+        StringBuilder query = new StringBuilder("(");
+        for (int i = 0; i<columns.size(); i++) {
+            Column col = columns.get(i);
+            query.append(" ").append(col.getName()).append(" ").append(col.getType()).append(" ");
+            if(col.getLength() > 0){
+                query.append("(").append(col.getLength()).append(") ");
+            }
+            if(col.isNotnull())
+                query.append("NOT NULL ");
+            if(col.isPrimary())
+                query.append("PRIMARY KEY ");
+            if(col.isUnique())
+                query.append("UNIQUE ");
+            if(col.getDefaultValue() != null)
+                query.append("DEFAULT '").append(col.getDefaultValue()).append("'");
+//            if(col.getReference())
+            query.append(i == columns.size() - 1 ? "" : ",");
 
+        }
+        query.append(")");
+        return query.toString();
+    }
 }

src/main/java/com/opentek/catapult/core/models/migrations/Column.java

@@ -4,15 +4,36 @@
 
 public class Column {
       private String type, name, defaultValue, reference;
-      private boolean unique, primary;
+      private int length;
+      private boolean unique, primary, notnull;
 
-      public Column(String type, String name, String defaultValue, String reference, boolean unique, boolean primary) {
+      public boolean isNotnull() {
+            return notnull;
+      }
+
+      public void setNotnull(boolean notnull) {
+            this.notnull = notnull;
+      }
+
+      public Column(String type, String name, String defaultValue, String reference, boolean unique, boolean primary, boolean notnull) {
             this.type = type;
             this.name = name;
             this.defaultValue = defaultValue;
             this.reference = reference;
             this.unique = unique;
             this.primary = primary;
+            this.notnull = notnull;
+      }
+
+      public Column() {
+      }
+
+      public int getLength() {
+            return length;
+      }
+
+      public void setLength(int length) {
+            this.length = length;
       }
 
       public String getType() {

src/main/java/com/opentek/catapult/core/models/migrations/ColumnBuilder.java

@@ -0,0 +1,49 @@
+package com.opentek.catapult.core.models.migrations;
+
+
+import java.util.ArrayList;
+
+public class ColumnBuilder {
+    private String columnName;
+    private Column column;
+    private ArrayList<Column> columns;
+    public ColumnBuilder(String columnName, String datatype, ArrayList<Column> columns) {
+        this.columns = columns;
+        this.columnName = columnName;
+        this.column = new Column();
+        this.column.setName(columnName);
+        this.column.setType(datatype);
+    }
+    public ColumnBuilder unique(){
+        this.column.setUnique(true);
+        return this;
+    }
+    public ColumnBuilder defaultValue(String value){
+        this.column.setDefaultValue(value);
+        return this;
+    }
+
+    public ColumnBuilder primaryKey(){
+        this.column.setPrimary(true);
+        return this;
+    }
+    public ColumnBuilder reference(String ref){
+        if(ref == null || ref.equals(""))
+            throw new IllegalArgumentException("invalid reference");
+        this.column.setReference(ref);
+        return this;
+    }
+    public ColumnBuilder notnull(){
+        this.column.setNotnull(true);
+        return this;
+    }
+    public void build(){
+        this.columns.add(this.column);
+    }
+    public ColumnBuilder length(int length){
+        if(length < 0)
+            throw new IllegalArgumentException("length cannot be negative");
+        this.column.setLength(length);
+        return this;
+    }
+}

src/main/java/com/opentek/catapult/core/models/migrations/Schema.java

@@ -0,0 +1,37 @@
+package com.opentek.catapult.core.models.migrations;
+
+import com.opentek.catapult.core.exceptions.InvalidSchemaException;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ *
+ * Schema methods For DDL
+ *  create
+ *  rename
+ *  drop
+ *  dropIfExists
+ *  alter
+ *  hasTable
+ *  table - to modify the table schema
+ */
+public class Schema {
+    /**
+     * Creates a table if is not exists in the database.
+     * @param tableName - name of the table to be created
+     * @param consumer - a callback which will give the call to the get method.
+     */
+    public static void create(String tableName, Consumer<BluePrint> consumer) throws InvalidSchemaException{
+        if(tableName == null || tableName.equals("")){
+            throw new InvalidSchemaException("Table name not valid");
+        }
+        BluePrint bluePrint = new BluePrint(tableName);
+        consumer.accept(bluePrint);
+        String query = "CREATE TABLE IF NOT EXISTS " + tableName;
+        query += bluePrint.buildQuery();
+        System.out.println(query);
+    }
+}

src/main/java/com/opentek/catapult/core/services/ModelService.java

@@ -66,7 +66,7 @@ public static List<Column> extractColumns(String[] args) throws InvalidModelExce
                                     throw new InvalidModelException("Invalid model given");
                         }
                   }
-                  Column column = new Column(type, columnName, defaultValue, ref, unique, primary);
+                  Column column = new Column(type, columnName, defaultValue, ref, unique, primary, false);
                   columns.add(column);
             }
             return columns;

src/main/java/com/opentek/catapult/sample/SchemaTest.java

@@ -0,0 +1,17 @@
+package com.opentek.catapult.sample;
+
+import com.opentek.catapult.core.exceptions.InvalidSchemaException;
+import com.opentek.catapult.core.models.migrations.Schema;
+
+public class SchemaTest {
+    public static void main(String[] args) throws InvalidSchemaException {
+        Schema.create("Student",(bluePrint)->{
+            try {
+                bluePrint.integer("id").primaryKey().unique().length(11).notnull().build();
+                bluePrint.varchar("student_name").length(255).notnull().build();
+            } catch (InvalidSchemaException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+}