Add support for inverting sort direction of orderBy with '=' prefix e.g. orderBy=Id,-Name

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -305,14 +305,20 @@ private SqlExpression<T> OrderByFields(string orderBySuffix, FieldDefinition[] f
             return this;
         }
 
+        static class OrderBySuffix
+        {
+            public const string Asc = "";
+            public const string Desc = " DESC";
+        }
+
         public virtual SqlExpression<T> OrderByFields(params FieldDefinition[] fields)
         {
-            return OrderByFields("", fields);
+            return OrderByFields(OrderBySuffix.Asc, fields);
         }
 
         public virtual SqlExpression<T> OrderByFieldsDescending(params FieldDefinition[] fields)
         {
-            return OrderByFields(" DESC", fields);
+            return OrderByFields(OrderBySuffix.Desc, fields);
         }
 
         private SqlExpression<T> OrderByFields(string orderBySuffix, string[] fieldNames)
@@ -322,15 +328,21 @@ private SqlExpression<T> OrderByFields(string orderBySuffix, string[] fieldNames
             var sbOrderBy = new StringBuilder();
             foreach (var fieldName in fieldNames)
             {
-                var field = FirstMatchingField(fieldName);
+                var reverse = fieldName.StartsWith("-");
+                var useSuffix = reverse 
+                    ? (orderBySuffix == OrderBySuffix.Asc ? OrderBySuffix.Desc : OrderBySuffix.Asc)
+                    : orderBySuffix;
+                var useName = reverse ? fieldName.Substring(1) : fieldName;
+
+                var field = FirstMatchingField(useName);
                 if (field == null)
-                    throw new ArgumentException("Could not find field " + fieldName);
+                    throw new ArgumentException("Could not find field " + useName);
                 var qualifiedName = DialectProvider.GetQuotedColumnName(field.Item1, field.Item2);
 
                 if (sbOrderBy.Length > 0)
                     sbOrderBy.Append(", ");
 
-                sbOrderBy.Append(qualifiedName + orderBySuffix);
+                sbOrderBy.Append(qualifiedName + useSuffix);
             }
 
             this.orderBy = sbOrderBy.Length == 0

tests/ServiceStack.OrmLite.Tests/Expression/SqlExpressionTests.cs

@@ -241,5 +241,33 @@ public void Can_do_ToCountStatement_with_SqlExpression_if_where_expression_refer
                     db.Exists<LetterFrequency>(q => q.Join<LetterStat>().Where<LetterStat>(x => x.Id > 0)));
             }
         }
+
+        [Test]
+        public void Can_OrderBy_Fields_with_different_sort_directions()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<LetterFrequency>();
+                db.DropAndCreateTable<LetterStat>();
+
+                var i = 0;
+                "A,B,B,C,C,C,D,D,E".Split(',').Each(letter => {
+                    db.Insert(new LetterFrequency { Letter = letter }, selectIdentity: true);
+                });
+
+                var rows = db.Select<LetterFrequency>(q => q.OrderByFields("Letter", "Id"));
+                Assert.That(rows.Map(x => x.Letter), Is.EquivalentTo("A,B,B,C,C,C,D,D,E".Split(',')));
+                Assert.That(rows.Map(x => x.Id), Is.EquivalentTo("1,2,3,4,5,6,7,8,9".Split(',').Map(int.Parse)));
+
+                rows = db.Select<LetterFrequency>(q => q.OrderByFields("Letter", "-Id"));
+                Assert.That(rows.Map(x => x.Letter), Is.EquivalentTo("A,B,B,C,C,C,D,D,E".Split(',')));
+                Assert.That(rows.Map(x => x.Id), Is.EquivalentTo("1,3,2,6,5,4,8,7,9".Split(',').Map(int.Parse)));
+
+                rows = db.Select<LetterFrequency>(q => q.OrderByFieldsDescending("Letter", "-Id"));
+                Assert.That(rows.Map(x => x.Letter), Is.EquivalentTo("E,D,D,C,C,C,B,B,A".Split(',')));
+                Assert.That(rows.Map(x => x.Id), Is.EquivalentTo("9,7,8,4,5,6,2,3,1".Split(',').Map(int.Parse)));
+            }
+
+        }
     }
 }