Fixed the broken order Method

Author: JanHolger

src/main/java/org/javawebstack/orm/query/Query.java

@@ -20,10 +20,10 @@ public class Query<T extends Model> {
     private final Repo<T> repo;
     private final Class<T> model;
     private List<String> select = new ArrayList<>();
-    private final QueryGroup<T> where;
+    private final QueryGroup<T> where = new QueryGroup<>();
     private Integer offset;
     private Integer limit;
-    private QueryOrderBy order;
+    private List<QueryOrderBy> order = new ArrayList<>();
     private boolean withDeleted = false;
     private final List<QueryColumn> groupBy = new ArrayList<>();
     private QueryGroup<T> having;
@@ -35,8 +35,6 @@ public Query(Class<T> model) {
     public Query(Repo<T> repo, Class<T> model) {
         this.repo = repo;
         this.model = model;
-        this.where = new QueryGroup<>();
-        this.order = new QueryOrderBy();
     }
 
     public boolean isWithDeleted() {
@@ -67,7 +65,7 @@ public Integer getOffset() {
         return offset;
     }
 
-    public QueryOrderBy getOrder() {
+    public List<QueryOrderBy> getOrder() {
         return order;
     }
 
@@ -325,47 +323,16 @@ public Query<T> search(String search) {
         return this;
     }
 
-    /**
-     * Sorts the results by the given column name ascendingly.
-     *
-     * @param columnName The name of the column to sort ascendingly by.
-     * @return The Query object with the given order by information added.
-     * @throws ORMQueryException if the order operation is called twice on a column specification with the same name.
-     */
     public Query<T> order(String columnName) throws ORMQueryException {
         return order(columnName, false);
     }
 
-    /**
-     * Sorts the results by the given column name with the given order direction.
-     *
-     * @param columnName The name of the column to sort ascendingly by.
-     * @param desc If true it will order descendingly, if false it will order ascendingly.
-     * @return The Query object with the given order by information added.
-     * @throws ORMQueryException if the order operation is called twice on a column specification with the same name.
-     */
     public Query<T> order(String columnName, boolean desc) throws ORMQueryException {
         return order(new QueryColumn(columnName), desc);
     }
 
-    /**
-     * Sorts the results by the given column  with the given order direction.
-     *
-     * @param column The column encoded as QueryColumn object.
-     * @param desc If true it will order descendingly, if false it will order ascendingly.
-     * @return The Query object with the given order by information added.
-     * @throws ORMQueryException if the order operation is called twice on a column specification with the same name.
-     */
     public Query<T> order(QueryColumn column, boolean desc) throws ORMQueryException{
-        boolean success = this.order.add(column, desc);
-        if(!success) {
-            throw new ORMQueryException(String.format(
-                "The column %s could not be ordered %s. This is probably caused by calling .order() on this column twice.",
-                column.toString(),
-                desc ? "descendingly" : "ascendingly"
-            ));
-        }
-
+        this.order.add(new QueryOrderBy(column, desc));
         return this;
     }
 

src/main/java/org/javawebstack/orm/query/QueryOrderBy.java

@@ -2,69 +2,77 @@
 
 import org.javawebstack.orm.TableInfo;
 
-import java.util.LinkedList;
-import java.util.stream.Collectors;
+import java.util.Objects;
 
 /**
- * The QueryOrderBy class serves as an aggregation of order by elements. It extends a list, because the order of the
- * order by statements is of relevance.
+ * The QueryOrderBy class encodes an Order By Statement.
  */
-public class QueryOrderBy extends LinkedList<QueryOrderByElement>{
+public class QueryOrderBy {
+
+    private final QueryColumn queryColumn;
+    private final boolean desc;
+
+    QueryOrderBy(String columnName, boolean desc) {
+        queryColumn = new QueryColumn(columnName);
+        this.desc = desc;
+    }
+
+    QueryOrderBy(QueryColumn column, boolean desc) {
+        this.queryColumn = column;
+        this.desc = desc;
+    }
 
     /**
-     * Add a new order by statement. If a statement with the same column name already exists it will not add the
-     * statement.
+     * Retrieves the QueryColumn of the statement which encodes the column name.
      *
-     * @param columnName The column name to order by.
-     * @param desc If the column should be order descendingly.
-     * @return True if adding the statement was successful. False otherwise.
+     * @return The encoding QueryColumn object.
      */
-    public boolean add(String columnName, boolean desc) {
-        return this.add(new QueryColumn(columnName), desc);
+    public QueryColumn getQueryColumn() {
+        return queryColumn;
     }
 
     /**
-     * Add a new order by statement. If a statement with the same column name already exists it will not add the
-     * statement.
+     * Retrieves the information if this column is ordered ascendingly or descendingly.
      *
-     * @param column The column to be ordered by. It will retrieve the name from the QueryColumn.
-     * @param desc If the column should be order descendingly.
-     * @return True if adding the statement was successful. False otherwise.
+     * @return false if ascending, true if descending.
      */
-    public boolean add(QueryColumn column, boolean desc) {
-        return this.add(new QueryOrderByElement(column, desc));
+    public boolean isDesc() {
+        return desc;
     }
 
-    @Override
     /**
-     * Add a new order by statement. If a statement with the same column name already exists it will not add the
-     * statement.
+     * Compares the encoded column name.
      *
-     * @param element The direct QueryOrderByElement which encodes the order by statement.
-     * @return True if adding the statement was successful. False otherwise.
+     * @param o An object to compare to.
+     * @return True if the object is a QueryOrderBy with a QueryColumn with generates the same identifier.
      */
-    public boolean add(QueryOrderByElement element) {
-        boolean hasBeenAdded = false;
-        if(!willOverwrite(element))
-            hasBeenAdded = super.add(element);
-
-        return hasBeenAdded;
+    public boolean hasEqualColumn(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        QueryOrderBy that = (QueryOrderBy) o;
+        return getQueryColumn().equals(that.getQueryColumn());
     }
 
-    private boolean willOverwrite(QueryOrderByElement element) {
-        return this.stream().anyMatch(element::hasEqualColumn);
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        QueryOrderBy that = (QueryOrderBy) o;
+        return isDesc() == that.isDesc() && getQueryColumn().equals(that.getQueryColumn());
     }
 
+    public int hashCode() {
+        return Objects.hash(getQueryColumn(), isDesc());
+    }
 
-    // The toString methods are specific to MySQL so they might have to be replaced later on.
-    @Override
     public String toString() {
-        return toString(null);
+        return this.toString(null);
     }
 
     public String toString(TableInfo info) {
-        return this.stream()
-                .map(singleOrderByElement -> singleOrderByElement.toString(info))
-                .collect(Collectors.joining(","));
+        String stringifiedOrderBy = getQueryColumn().toString(info);
+        if (isDesc())
+            stringifiedOrderBy += " DESC";
+        return stringifiedOrderBy;
     }
+
 }

src/main/java/org/javawebstack/orm/query/QueryOrderByElement.java

@@ -66,10 +66,10 @@ public SQLQueryString buildQuery(Query<?> query) {
             parameters.addAll(group.getParameters());
         }
 
-        QueryOrderBy orderBy = query.getOrder();
+        List<QueryOrderBy> orderBy = query.getOrder();
         if (!orderBy.isEmpty()) {
             sb.append(" ORDER BY ")
-                .append(orderBy.toString(repo.getInfo()));
+                .append(orderBy.stream().map(ob -> ob.toString(repo.getInfo())).collect(Collectors.joining(",")));
         }
 
         Integer offset = query.getOffset();