Merge pull request #5 from ZorTik/development

ZorTik · web-flow · commit 134330d48c5c · 2023-01-19T20:37:35.000+01:00
Development
diff --git a/api/src/main/java/me/zort/sqllib/internal/annotation/NullableField.java b/api/src/main/java/me/zort/sqllib/internal/annotation/NullableField.java
@@ -0,0 +1,34 @@
+package me.zort.sqllib.internal.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to mark whether a field in table mapping
+ * entity represents nullable column.
+ *
+ * <pre>
+ *     public class TableEntity {
+ *          &#064;PrimaryKey(autoIncrement = true)
+ *          private Integer id;
+ *          &#064;NullableField(nullable = false)
+ *          &#064;Id
+ *          private String name;
+ *     }
+ *
+ *     new SQLTableRepositoryBuilder<TableEntity, String>()
+ *                 .withConnection(connection)
+ *                 .withTableName(tableName)
+ *                 .withTypeClass(TableEntity.class)
+ *                 .build()
+ * </pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface NullableField {
+
+    boolean nullable() default true;
+
+}
diff --git a/api/src/main/java/me/zort/sqllib/internal/query/part/LimitStatement.java b/api/src/main/java/me/zort/sqllib/internal/query/part/LimitStatement.java
@@ -12,7 +12,7 @@ public class LimitStatement<P extends QueryPart<?>> extends QueryPartQuery<P> {
     private final int limit;
 
     public LimitStatement(@Nullable P parent, List<QueryPart<?>> initial, int limit) {
-        super(parent, initial, QueryPriority.LAST);
+        super(parent, initial, Integer.MAX_VALUE);
         this.limit = limit;
     }
 
diff --git a/core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java b/core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java
@@ -224,6 +224,11 @@ private <T> T assignValues(Row row, Class<T> typeClass) {
                 }
             }
             for(Field field : typeClass.getDeclaredFields()) {
+
+                if(Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) {
+                    continue;
+                }
+
                 try {
                     field.setAccessible(true);
                     field.set(instance, buildElementValue(field, row));
diff --git a/core/src/main/java/me/zort/sqllib/SQLTableRepositoryBuilder.java b/core/src/main/java/me/zort/sqllib/SQLTableRepositoryBuilder.java
@@ -4,6 +4,9 @@
 import me.zort.sqllib.api.SQLDatabaseConnection;
 import me.zort.sqllib.api.repository.CachingSQLTableRepository;
 import me.zort.sqllib.api.repository.SQLTableRepository;
+import me.zort.sqllib.internal.annotation.JsonField;
+import me.zort.sqllib.internal.annotation.NullableField;
+import me.zort.sqllib.internal.annotation.PrimaryKey;
 import me.zort.sqllib.util.Arrays;
 import me.zort.sqllib.util.Validator;
 import org.jetbrains.annotations.ApiStatus;
@@ -69,31 +72,50 @@ private void buildDefsFromType() {
         if(!(connection instanceof SQLDatabaseConnectionImpl)) {
             throw new IllegalStateException("We can build defs only from SQLDatabaseConnectionImpl child-classes.");
         }
+        debug("Building defs from type class: " + info.getTypeClass().getName());
 
         SQLDatabaseOptions options = ((SQLDatabaseConnectionImpl) connection).getOptions();
         String[] defs = new String[0];
 
-        for (Field field : info.getTypeClass().getFields()) {
-            if(Modifier.isTransient(field.getModifiers()))
+        for (Field field : info.getTypeClass().getDeclaredFields()) {
+            debug("Building def for field: " + field.getName() + " (" + field.getType().getName() + ")");
+            if(Modifier.isTransient(field.getModifiers())) {
+                debug(String.format("Field %s is transient, skipping.", field.getName()));
                 continue;
+            }
 
             String colName = options.getNamingStrategy().fieldNameToColumn(field.getName());
             String colType = recognizeFieldTypeToDbType(field);
+
+            if(colType != null && !colType.contains("NOT NULL") && field.isAnnotationPresent(NullableField.class)) {
+                if(!field.getAnnotation(NullableField.class).nullable()) {
+                    colType += " NOT NULL";
+                }
+            }
+
             defs = Arrays.add(defs, colName + " " + colType);
+
+            debug("Added def: " + colName + " " + colType);
         }
 
         info.setDefs(defs);
+        debug("Built defs: " + java.util.Arrays.toString(defs));
     }
 
-    private static String recognizeFieldTypeToDbType(Field field) {
+    private void debug(String message) {
+        if(connection instanceof SQLDatabaseConnectionImpl && ((SQLDatabaseConnectionImpl) connection).getOptions().isDebug())
+            ((SQLDatabaseConnectionImpl) connection).debug(message);
+    }
+
+    private String recognizeFieldTypeToDbType(Field field) {
         Class<?>[] supportedTypes = new Class<?>[] {
                 Integer.class,
                 Long.class,
                 Float.class,
                 Double.class,
                 String.class
         };
-        Class<?> fieldType = field.getType();
+        Class<?> fieldType = Primitives.wrap(field.getType());
 
         boolean isSupported = false;
         for (Class<?> aClass : supportedTypes) {
@@ -103,14 +125,18 @@ private static String recognizeFieldTypeToDbType(Field field) {
             }
         }
 
+        if(field.isAnnotationPresent(JsonField.class) && !isSupported) {
+            return "TEXT";
+        }
+
         if(!isSupported)
             throw new RuntimeException(String.format("We don't support %s types in SQLTableRepositoryBuilder yet.", fieldType.getSimpleName()));
 
         String dbType = null;
         if(fieldType.equals(String.class)) {
             dbType = "VARCHAR(255)";
         } else if(Primitives.wrap(fieldType).equals(Integer.class)) {
-            dbType = "INT";
+            dbType = "INTEGER";
         } else if(Primitives.wrap(fieldType).equals(Long.class)) {
             dbType = "BIGINT";
         } else if(Primitives.wrap(fieldType).equals(Double.class)) {
@@ -120,10 +146,13 @@ private static String recognizeFieldTypeToDbType(Field field) {
         }
 
         if(Validator.validateAutoIncrement(field))
-            dbType += " PRIMARY KEY AUTO_INCREMENT";
+            dbType += " PRIMARY KEY " + (isSQLite() ? "AUTOINCREMENT" : "AUTO_INCREMENT");
+
+        return dbType;
+    }
 
-        // Practically, it should not come here.
-        return null;
+    private boolean isSQLite() {
+        return connection instanceof SQLiteDatabaseConnectionImpl;
     }
 
     public interface RepoFactory<T, ID, R extends SQLTableRepository<T, ID>> {
diff --git a/core/src/main/java/me/zort/sqllib/SQLiteDatabaseConnectionImpl.java b/core/src/main/java/me/zort/sqllib/SQLiteDatabaseConnectionImpl.java
@@ -48,29 +48,43 @@ public QueryResult save(String table, Object obj) {
         String[] defs = defsValsPair.getFirst();
         UnknownValueWrapper[] vals = defsValsPair.getSecond();
 
+        debug("Saving object into table " + table + " with definitions " + Arrays.toString(defs) + " and values " + Arrays.toString(vals));
+
         PrimaryKey primaryKey = null;
         for(Field field : obj.getClass().getDeclaredFields()) {
             if(Modifier.isTransient(field.getModifiers())) {
                 continue;
             }
             if(field.isAnnotationPresent(me.zort.sqllib.internal.annotation.PrimaryKey.class)) {
                 String colName = getOptions().getNamingStrategy().fieldNameToColumn(field.getName());
-                int index = Arrays.binarySearch(defs, colName);
+                //int index = Arrays.binarySearch(defs, colName);
+                int index = -1;
+                int i = 0;
+                for (String def : defs) {
+                    if(def.equals(colName)) {
+                        index = i;
+                        break;
+                    }
+                    i++;
+                }
                 if(index >= 0) {
                     primaryKey = new PrimaryKey(colName, vals[index].getObject() instanceof String
                             ? (String)vals[index].getObject() : String.valueOf(vals[index].getObject()));
                     break;
                 }
             }
         }
-        if(primaryKey == null) {
-            debug("No primary key found for object: " + obj.getClass().getName());
-            return new QueryResultImpl(false);
-        }
         InsertQuery insert = insert().into(table, defs);
         for(UnknownValueWrapper val : vals) {
-            insert.appendVal(val);
+            insert.appendVal(val.getObject());
         }
+
+        if(primaryKey == null) {
+            debug("No primary key found for object " + obj.getClass().getName() + ", so we can't build update condition.");
+            debug("Performing insert query instead: " + insert.buildQuery());
+            return insert.execute();
+        }
+
         SetStatement<UpdateQuery> setStmt = update().table(table).set();
         for(int i = 0; i < defs.length; i++) {
             setStmt.and(defs[i], vals[i].getObject());

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public class LimitStatement<P extends QueryPart<?>> extends QueryPartQuery<P> {`
`12`	`12`	`private final int limit;`
`13`	`13`
`14`	`14`	`public LimitStatement(@Nullable P parent, List<QueryPart<?>> initial, int limit) {`
`15`		`- super(parent, initial, QueryPriority.LAST);`
	`15`	`+ super(parent, initial, Integer.MAX_VALUE);`
`16`	`16`	`this.limit = limit;`
`17`	`17`	`}`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -224,6 +224,11 @@ private <T> T assignValues(Row row, Class<T> typeClass) {`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`	`for(Field field : typeClass.getDeclaredFields()) {`
	`227`	`+`
	`228`	`+ if(Modifier.isTransient(field.getModifiers()) \|\| Modifier.isStatic(field.getModifiers())) {`
	`229`	`+ continue;`
	`230`	`+ }`
	`231`	`+`
`227`	`232`	`try {`
`228`	`233`	`field.setAccessible(true);`
`229`	`234`	`field.set(instance, buildElementValue(field, row));`