Rework the SortSpecification to avoid some weirdness in the DSL

When a column is renamed, or when using a calculated column or an
aggregate, it makes much more syntactic sense to just reuse the name
rather that using a fake column with an alias.

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/SortSpecification.java

@@ -22,7 +22,7 @@
  *
  */
 public interface SortSpecification {
-    SortSpecification as(String alias);
+    SortSpecification descending();
     String aliasOrName();
     boolean isDescending();
 }

src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java

@@ -25,6 +25,7 @@
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
 import org.mybatis.dynamic.sql.select.SelectDSL;
 import org.mybatis.dynamic.sql.select.SelectModel;
+import org.mybatis.dynamic.sql.select.SimpleSortSpecification;
 import org.mybatis.dynamic.sql.select.aggregate.Avg;
 import org.mybatis.dynamic.sql.select.aggregate.Count;
 import org.mybatis.dynamic.sql.select.aggregate.CountAll;
@@ -310,4 +311,9 @@ static IsInCaseInsensitive isInCaseInsensitive(String...values) {
     static IsNotInCaseInsensitive isNotInCaseInsensitive(String...values) {
         return IsNotInCaseInsensitive.of(Arrays.asList(values));
     }
+    
+    // order by support
+    static SortSpecification sortColumn(String name) {
+        return SimpleSortSpecification.of(name);
+    }
 }

src/main/java/org/mybatis/dynamic/sql/SqlColumn.java

@@ -65,23 +65,11 @@ public Optional<String> typeHandler() {
         return typeHandler;
     }
 
+    @Override
     public SortSpecification descending() {
-        return new SortSpecification() {
-            @Override
-            public SortSpecification as(String alias) {
-                return SqlColumn.this.as(alias);
-            }
-            
-            @Override
-            public boolean isDescending() {
-                return true;
-            }
-            
-            @Override
-            public String aliasOrName() {
-                return SqlColumn.this.aliasOrName();
-            }
-        };
+        SqlColumn<T> column = new SqlColumn<>(this);
+        column.isDescending = true;
+        return column;
     }
 
     @Override

src/main/java/org/mybatis/dynamic/sql/select/SimpleSortSpecification.java

@@ -0,0 +1,57 @@
+/**
+ *    Copyright 2016-2017 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select;
+
+import java.util.Objects;
+
+import org.mybatis.dynamic.sql.SortSpecification;
+
+/**
+ * This class is used for an order by phrase where there is no suitable column name
+ * to use (for example a calculated column or an aggregate column). 
+ * 
+ * @author Jeff Butler
+ */
+public class SimpleSortSpecification implements SortSpecification {
+    
+    private String name;
+    private boolean isDescending;
+
+    private SimpleSortSpecification(String name) {
+        this.name = Objects.requireNonNull(name);
+    }
+    
+    @Override
+    public SortSpecification descending() {
+        SimpleSortSpecification answer = new SimpleSortSpecification(name);
+        answer.isDescending = true;
+        return answer;
+    }
+
+    @Override
+    public String aliasOrName() {
+        return name;
+    }
+
+    @Override
+    public boolean isDescending() {
+        return isDescending;
+    }
+    
+    public static SimpleSortSpecification of(String name) {
+        return new SimpleSortSpecification(name);
+    }
+}

src/test/java/examples/animal/data/AnimalDataTest.java

@@ -291,7 +291,7 @@ public void testUnionSelectWithTableAndColumnAliases() {
                     .select(id.as("animalId"), animalName, bodyWeight, brainWeight)
                     .from(animalData, "b")
                     .where(id, isGreaterThan(40))
-                    .orderBy(id.as("animalId"))
+                    .orderBy(sortColumn("animalId"))
                     .build()
                     .render(RenderingStrategy.MYBATIS3);
 

src/test/java/examples/groupby/GroupByTest.java

@@ -163,22 +163,22 @@ public void testBasicGroupByOrderByWithCalculatedColumnAndTableAlias() {
             SelectStatement selectStatement = select(substring(gender, 1, 1).as("ShortGender"), avg(age).as("AverageAge"))
                     .from(person, "a")
                     .groupBy(substring(gender, 1, 1))
-                    .orderBy(gender.as("ShortGender"))
+                    .orderBy(sortColumn("ShortGender").descending())
                     .build()
                     .render(RenderingStrategy.MYBATIS3);
 
-            String expected = "select substring(a.gender, 1, 1) as ShortGender, avg(a.age) as AverageAge from Person a group by substring(a.gender, 1, 1) order by ShortGender";
+            String expected = "select substring(a.gender, 1, 1) as ShortGender, avg(a.age) as AverageAge from Person a group by substring(a.gender, 1, 1) order by ShortGender DESC";
             assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
 
             List<Map<String, Object>> rows = mapper.generalSelect(selectStatement);
             assertThat(rows.size()).isEqualTo(2);
             Map<String, Object> row = rows.get(0);
-            assertThat(row.get("SHORTGENDER")).isEqualTo("F");
-            assertThat(row.get("AVERAGEAGE")).isEqualTo(27);
-
-            row = rows.get(1);
             assertThat(row.get("SHORTGENDER")).isEqualTo("M");
             assertThat(row.get("AVERAGEAGE")).isEqualTo(25);
+
+            row = rows.get(1);
+            assertThat(row.get("SHORTGENDER")).isEqualTo("F");
+            assertThat(row.get("AVERAGEAGE")).isEqualTo(27);
         } finally {
             session.close();
         }

src/test/java/examples/joins/JoinMapperTest.java

@@ -439,7 +439,7 @@ public void testFullJoin() {
             SelectStatement selectStatement = select(orderLine.orderId, orderLine.quantity, orderLine.itemId.as("ol_itemid"), itemMaster.itemId.as("im_itemid"), itemMaster.description)
                     .from(itemMaster, "im")
                     .fullJoin(orderLine, "ol").on(itemMaster.itemId, equalTo(orderLine.itemId))
-                    .orderBy(itemMaster.itemId.as("im_itemid"))
+                    .orderBy(sortColumn("im_itemid"))
                     .build()
                     .render(RenderingStrategy.MYBATIS3);