Merge branch 'master' into TimothyGillespie/addOrderByTests

TimothyGillespie · TimothyGillespie · commit 480b883fe1dd · 2021-03-31T04:41:59.000+02:00
diff --git a/pom.xml b/pom.xml
@@ -79,6 +79,18 @@
             <version>5.4.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.5</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.16</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <distributionManagement>
diff --git a/src/main/java/org/javawebstack/orm/Model.java b/src/main/java/org/javawebstack/orm/Model.java
@@ -6,6 +6,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -165,26 +166,40 @@ public <T extends Model> Query<T> belongsTo(Class<T> parent) {
     }
 
     public <T extends Model> Query<T> belongsTo(Class<T> parent, String fieldName) {
+        return belongsTo(parent, fieldName, Repo.get(parent).getInfo().getIdField());
+    }
+
+    public <T extends Model> Query<T> belongsTo(Class<T> parent, String fieldName, String otherFieldName) {
         try {
             Object id = Repo.get(getClass()).getInfo().getField(fieldName).get(this);
-            return Repo.get(parent).whereId(id);
+            return Repo.get(parent).where(otherFieldName, id);
         } catch (IllegalAccessException e) {
             throw new RuntimeException(e);
         }
     }
 
+    public <T extends Model> void assignTo(T value) {
+        if(value == null)
+            throw new InvalidParameterException("You need to specify a parent type if the value is null");
+        assignTo((Class<T>) value.getClass(), value);
+    }
+
     public <T extends Model> void assignTo(Class<T> parent, T value) {
         assignTo(parent, value, Repo.get(parent).getInfo().getRelationField());
     }
 
     public <T extends Model> void assignTo(Class<T> parent, T value, String fieldName) {
+        assignTo(parent, value, fieldName, Repo.get(parent).getInfo().getIdField());
+    }
+
+    public <T extends Model> void assignTo(Class<T> parent, T value, String fieldName, String otherFieldName) {
         try {
             Field f = Repo.get(getClass()).getInfo().getField(fieldName);
             if (value == null) {
                 f.set(this, null);
             } else {
                 Repo<T> repo = Repo.get(parent);
-                Object id = repo.getInfo().getField(repo.getInfo().getIdField()).get(value);
+                Object id = repo.getInfo().getField(otherFieldName).get(value);
                 f.set(this, id);
             }
         } catch (IllegalAccessException e) {
@@ -197,9 +212,13 @@ public <T extends Model> Query<T> hasMany(Class<T> child) {
     }
 
     public <T extends Model> Query<T> hasMany(Class<T> child, String fieldName) {
+        return hasMany(child, fieldName, Repo.get(getClass()).getInfo().getIdField());
+    }
+
+    public <T extends Model> Query<T> hasMany(Class<T> child, String fieldName, String ownFieldName) {
         try {
             Repo<?> ownRepo = Repo.get(getClass());
-            Object id = ownRepo.getInfo().getField(ownRepo.getInfo().getIdField()).get(this);
+            Object id = ownRepo.getInfo().getField(ownFieldName).get(this);
             return Repo.get(child).where(fieldName, id);
         } catch (IllegalAccessException e) {
             throw new RuntimeException(e);
@@ -214,17 +233,25 @@ public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other,
         return belongsToMany(other, pivot, Repo.get(getClass()).getInfo().getRelationField(), Repo.get(other).getInfo().getRelationField(), pivotFilter);
     }
 
-    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfFieldName, String otherFieldName) {
-        return belongsToMany(other, pivot, selfFieldName, otherFieldName, null);
+    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfPivotFieldName, String otherPivotFieldName) {
+        return belongsToMany(other, pivot, selfPivotFieldName, otherPivotFieldName, null);
+    }
+
+    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfPivotFieldName, String otherPivotFieldName, Function<Query<P>, Query<P>> pivotFilter) {
+        return belongsToMany(other, pivot, selfPivotFieldName, otherPivotFieldName, Repo.get(getClass()).getInfo().getIdField(), Repo.get(other).getInfo().getIdField(), pivotFilter);
     }
 
-    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfFieldName, String otherFieldName, Function<Query<P>, Query<P>> pivotFilter) {
+    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfPivotFieldName, String otherPivotFieldName, String selfFieldName, String otherFieldName) {
+        return belongsToMany(other, pivot, selfPivotFieldName, otherPivotFieldName, selfFieldName, otherFieldName, null);
+    }
+
+    public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other, Class<P> pivot, String selfPivotFieldName, String otherPivotFieldName, String selfFieldName, String otherFieldName, Function<Query<P>, Query<P>> pivotFilter) {
         try {
             Repo<?> selfRepo = Repo.get(getClass());
             Repo<T> otherRepo = Repo.get(other);
-            Object id = selfRepo.getInfo().getField(selfRepo.getInfo().getIdField()).get(this);
+            Object id = selfRepo.getInfo().getField(selfFieldName).get(this);
             return otherRepo.whereExists(pivot, q -> {
-                q.where(pivot, selfFieldName, "=", id).where(pivot, otherFieldName, "=", other, otherRepo.getInfo().getIdColumn());
+                q.where(pivot, selfPivotFieldName, "=", id).where(pivot, otherPivotFieldName, "=", other, otherFieldName);
                 if (pivotFilter != null)
                     q = pivotFilter.apply(q);
                 return q;
@@ -234,17 +261,4 @@ public <T extends Model, P extends Model> Query<T> belongsToMany(Class<T> other,
         }
     }
 
-    public void setMorph(String name, Class<? extends Model> type, Object id) {
-        TableInfo info = Repo.get(getClass()).getInfo();
-        try {
-            info.getField(name + "Id").set(this, id);
-            info.getField(name + "Type").set(this, Repo.get(type).getInfo().getMorphType());
-        } catch (IllegalAccessException ignored) {
-        }
-    }
-
-    public void setMorph(String name, Model model) {
-        setMorph(name, model.getClass(), Repo.get(model.getClass()).getId(model));
-    }
-
 }
diff --git a/src/main/java/org/javawebstack/orm/query/Query.java b/src/main/java/org/javawebstack/orm/query/Query.java
@@ -164,6 +164,16 @@ public Query<T> notNull(Object left) {
         where.notNull(left);
         return this;
     }
+    
+    public Query<T> whereNull(Object left) {
+        where.isNull(left);
+        return this;
+    }
+    
+    public Query<T> whereNotNull(Object left) {
+        where.notNull(left);
+        return this;
+    }
 
     public Query<T> lessThan(Object left, Object right) {
         where.lessThan(left, right);
diff --git a/src/main/java/org/javawebstack/orm/query/QueryGroup.java b/src/main/java/org/javawebstack/orm/query/QueryGroup.java
@@ -79,6 +79,14 @@ public QueryGroup<T> isNull(Object left) {
     public QueryGroup<T> notNull(Object left) {
         return where(left, "IS NOT NULL", null);
     }
+    
+    public QueryGroup<T> whereNull(Object left) {
+        return where(left, "IS NULL", null);
+    }
+    
+    public QueryGroup<T> whereNotNull(Object left) {
+        return where(left, "IS NOT NULL", null);
+    }
 
     public QueryGroup<T> lessThan(Object left, Object right) {
         return where(left, "<", right);
diff --git a/src/test/java/org/javawebstack/orm/test/other/QueryUtilTest.java b/src/test/java/org/javawebstack/orm/test/other/QueryUtilTest.java
@@ -0,0 +1,155 @@
+package org.javawebstack.orm.test.other;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.javawebstack.orm.test.shared.util.QueryStringUtil;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+/*
+ * The scope of this class is to test the QueryUtility as it will be used to write other tests.
+ */
+class QueryUtilTest {
+
+    @Test
+    void testGetSectionSimple() {
+        List<SectionRecord> list = new LinkedList<>(Arrays.asList(
+            new SectionRecord("SELECT", RandomStringUtils.randomAlphanumeric(3, 12)),
+            new SectionRecord("FROM", RandomStringUtils.randomAlphanumeric(3, 10)),
+            new SectionRecord("WHERE", RandomStringUtils.randomAlphanumeric(3, 10)),
+            new SectionRecord("ORDER BY", RandomStringUtils.randomAlphanumeric(3, 10)),
+            new SectionRecord("GROUP BY", RandomStringUtils.randomAlphanumeric(3, 10)),
+            new SectionRecord("HAVING", RandomStringUtils.randomAlphanumeric(3, 10)),
+            new SectionRecord("LIMIT", RandomStringUtils.randomNumeric(1, 100)),
+            new SectionRecord("OFFSET", RandomStringUtils.randomNumeric(1, 100))
+        ));
+
+        this.performStandardTestOnList(list);
+
+    }
+
+    @Test
+    void testCasingDoesNotMatter() {
+        List<SectionRecord> list = new LinkedList<>(Arrays.asList(
+                new SectionRecord("select", RandomStringUtils.randomAlphanumeric(3, 12)),
+                new SectionRecord("fRom", RandomStringUtils.randomAlphanumeric(3, 10)),
+                new SectionRecord("where", RandomStringUtils.randomAlphanumeric(3, 10)),
+                new SectionRecord("ordEr by", RandomStringUtils.randomAlphanumeric(3, 10)),
+                new SectionRecord("Group By", RandomStringUtils.randomAlphanumeric(3, 10)),
+                new SectionRecord("hAvIng", RandomStringUtils.randomAlphanumeric(3, 10)),
+                new SectionRecord("limit", RandomStringUtils.randomNumeric(1, 100)),
+                new SectionRecord("offset", RandomStringUtils.randomNumeric(1, 100))
+        ));
+
+        this.performStandardTestOnList(list);
+    }
+
+    // Example from here: https://www.freecodecamp.org/news/sql-example/
+    @Test
+    void testGetUsualCase() {
+        List<SectionRecord> list = new LinkedList<>(Arrays.asList(
+                new SectionRecord("SELECT", "`Customers`.`CustomerName`, `Orders`.`OrderID`"),
+                new SectionRecord("FROM", "`Customers`"),
+                new SectionRecord("FULL OUTER JOIN", "`Orders` ON `Customers`.`CustomerID`=`Orders`.`CustomerID`"),
+                new SectionRecord("ORDER BY", "`Customers`.`CustomerName`")
+        ));
+
+        this.performStandardTestOnList(list);
+    }
+
+    @Test
+    void testTrapExpressionsWhichAreEscaped() {
+        List<SectionRecord> list = new LinkedList<>(Arrays.asList(
+                new SectionRecord("SELECT", "`FROM`.`SELECT`, `GROUP BY`.`having`"),
+                new SectionRecord("FROM", "`order by`"),
+                new SectionRecord("WHERE", "`from` LIKE `where` AND 'from' = 'where'"),
+                new SectionRecord("FULL OUTER JOIN", "`from` ON `FROM`.`SELECT`=`select`.`from`"),
+                new SectionRecord("ORDER BY", "`limit`.`where`")
+        ));
+
+        this.performStandardTestOnList(list);
+    }
+
+    @Test
+    void testMultipleOccurrences() {
+        List<SectionRecord> list = new LinkedList<>(Arrays.asList(
+                new SectionRecord("SELECT", RandomStringUtils.randomAlphanumeric(3, 12)),
+                new SectionRecord("FROM", RandomStringUtils.randomAlphanumeric(3, 12)),
+                new SectionRecord("JOIN", RandomStringUtils.randomAlphanumeric(3, 12)),
+                new SectionRecord("JOIN", RandomStringUtils.randomAlphanumeric(3, 12)),
+                new SectionRecord("JOIN", RandomStringUtils.randomAlphanumeric(3, 12))
+        ));
+
+        String queryString = this.getQueryStringFromList(list);
+        QueryStringUtil util = new QueryStringUtil(queryString);
+
+        SectionRecord currentRecord = list.get(0);
+        assertEquals(currentRecord.getValue(), util.getTopLevelSectionsByKeyword(currentRecord.getKey()).get(0));
+
+        currentRecord = list.get(1);
+        assertEquals(currentRecord.getValue(), util.getTopLevelSectionsByKeyword(currentRecord.getKey()).get(0));
+
+        currentRecord = list.get(2);
+        assertEquals(currentRecord.getValue(), util.getTopLevelSectionsByKeyword(currentRecord.getKey()).get(0));
+
+        currentRecord = list.get(3);
+        assertEquals(currentRecord.getValue(), util.getTopLevelSectionsByKeyword(currentRecord.getKey()).get(1));
+
+        currentRecord = list.get(4);
+        assertEquals(currentRecord.getValue(), util.getTopLevelSectionsByKeyword(currentRecord.getKey()).get(2));
+
+    }
+    /*
+     * Boilerplate Code Reduction Methods
+     */
+
+    private String getQueryStringFromList(List<SectionRecord> list) {
+        StringBuilder builder = new StringBuilder();
+
+        for(SectionRecord entry : list)
+            builder
+                .append(entry.getKey())
+                .append(" ")
+                .append(entry.getValue())
+                .append(" ");
+
+        return builder.toString().trim();
+    }
+
+    /*
+     * The standard test in this case will be that each section cnly exists once and as defined per list.
+     */
+    private void performStandardTestOnList(List<SectionRecord> list) {
+        String query = this.getQueryStringFromList(list);
+        QueryStringUtil verification = new QueryStringUtil(query);
+
+        for (SectionRecord entry : list) {
+            List<String> foundSections = verification.getTopLevelSectionsByKeyword(entry.getKey());
+            String firstSection = foundSections.get(0);
+            assertEquals(1, foundSections.size(), "More than one section or no section was found, but only one unique section was expected.");
+            assertEquals(
+                    entry.getValue(),
+                    firstSection,
+                    String.format(
+                        "The section name %s has been %s instead of %s.",
+                        entry.getKey(),
+                        firstSection,
+                        entry.getValue()
+                    )
+            );
+        }
+    }
+
+    @Getter
+    @AllArgsConstructor
+    static class SectionRecord {
+        String key;
+        String value;
+    }
+
+}
diff --git a/src/test/java/org/javawebstack/orm/test/shared/knowledge/QueryKnowledgeBase.java b/src/test/java/org/javawebstack/orm/test/shared/knowledge/QueryKnowledgeBase.java
@@ -0,0 +1,50 @@
+package org.javawebstack.orm.test.shared.knowledge;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+/**
+ * The QueryKnowledgeBase serves as a decentralized information container around raw query terms.
+ */
+public class QueryKnowledgeBase {
+
+    /**
+     * Top level select keyword are SQL keywords which occur in SELECT statements and do not depend on another keyword
+     * except for SELECT and FROM (which are both included in this set as well).
+     * For example JOIN can appear after FROM statement so it is included. The ON keyword depends on a JOIN keyword though
+     * which we view as a sub keyword of JOIN and therefore not as a top level keyword.
+     */
+    public static final HashSet<String> TOP_LEVEL_SELECT_KEYWORDS;
+
+    /**
+     * Quote characters are characters which prevents an SQL parser from picking up on a keyword, if the
+     * wrap the keyword.
+     */
+    public static final HashSet<Character> QUOTE_CHARACTERS;
+
+
+    static {
+        TOP_LEVEL_SELECT_KEYWORDS = new HashSet<>(Arrays.asList(
+                "SELECT",
+                "FROM",
+                "WHERE",
+                "ORDER BY",
+                "JOIN",
+                "JOIN LEFT",
+                "JOIN RIGHT",
+                "INNER JOIN",
+                "FULL JOIN",
+                "FULL OUTER JOIN",
+                "OUTER JOIN",
+                "GROUP BY",
+                "HAVING",
+                "LIMIT",
+                "OFFSET"
+        ));
+
+        QUOTE_CHARACTERS = new HashSet<>(Arrays.asList(
+                '`',
+                '\''
+        ));
+    }
+}
diff --git a/src/test/java/org/javawebstack/orm/test/shared/util/QueryStringUtil.java b/src/test/java/org/javawebstack/orm/test/shared/util/QueryStringUtil.java
diff --git a/src/test/java/org/javawebstack/orm/test/shared/verification/QueryVerification.java b/src/test/java/org/javawebstack/orm/test/shared/verification/QueryVerification.java
