Add proper support for parsing Order By expr into token list

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -518,11 +518,9 @@ private SqlExpression<T> OrderByDescendingInternal(Expression keySelector)
             sep = string.Empty;
             useFieldName = true;
             orderByProperties.Clear();
-            var fields = Visit(keySelector).ToString().Split(',');
-            foreach (var field in fields)
-            {
-                orderByProperties.Add(field.Trim() + " DESC");
-            }
+            var orderBySql = Visit(keySelector).ToString();
+            orderBySql.ParseTokens()
+                .Each(x => orderByProperties.Add(x + " DESC"));
             BuildOrderByClauseInternal();
             return this;
         }
@@ -549,11 +547,9 @@ private SqlExpression<T> ThenByDescendingInternal(Expression keySelector)
         {
             sep = string.Empty;
             useFieldName = true;
-            var fields = Visit(keySelector).ToString().Split(',');
-            foreach (var field in fields)
-            {
-                orderByProperties.Add(field.Trim() + " DESC");
-            }
+            var orderBySql = Visit(keySelector).ToString();
+            orderBySql.ParseTokens()
+                .Each(x => orderByProperties.Add(x + " DESC"));
             BuildOrderByClauseInternal();
             return this;
         }

src/ServiceStack.OrmLite/OrmLiteUtils.cs

@@ -580,5 +580,84 @@ public static List<string> GetNonDefaultValueInsertFields<T>(T obj)
                 ? null 
                 : insertFields;
         }
+
+        public static List<string> ParseTokens(this string expr)
+        {
+            var to = new List<string>();
+
+            if (string.IsNullOrEmpty(expr))
+                return to;
+
+            var inDoubleQuotes = false;
+            var inSingleQuotes = false;
+            var inBraces = false;
+
+            var pos = 0;
+
+            for (var i = 0; i < expr.Length; i++)
+            {
+                var c = expr[i];
+                if (inDoubleQuotes)
+                {
+                    if (c == '"')
+                        inDoubleQuotes = false;
+                    continue;
+                }
+                if (inSingleQuotes)
+                {
+                    if (c == '\'')
+                        inSingleQuotes = false;
+                    continue;
+                }
+                if (c == '"')
+                {
+                    inDoubleQuotes = true;
+                    continue;
+                }
+                if (c == '\'')
+                {
+                    inSingleQuotes = true;
+                    continue;
+                }
+                if (c == '(')
+                {
+                    inBraces = true;
+                    continue;
+                }
+                if (c == ')')
+                {
+                    inBraces = false;
+
+                    var endPos = expr.IndexOf(',', i);
+                    if (endPos == -1)
+                        endPos = expr.Length;
+
+                    to.Add(expr.Substring(pos, endPos - pos).Trim());
+
+                    pos = endPos;
+                    continue;
+                }
+
+                if (c == ',')
+                {
+                    if (!inBraces)
+                    {
+                        var arg = expr.Substring(pos, i - pos).Trim();
+                        if (!string.IsNullOrEmpty(arg))
+                            to.Add(arg);
+                        pos = i + 1;
+                    }
+                }
+            }
+
+            var remaining = expr.Substring(pos, expr.Length - pos);
+            if (!string.IsNullOrEmpty(remaining))
+                remaining = remaining.Trim();
+
+            if (!string.IsNullOrEmpty(remaining))
+                to.Add(remaining);
+
+            return to;
+        }
     }
 }

tests/ServiceStack.OrmLite.Tests/Issues/MultiColumnOrderByDescending.cs

@@ -1,6 +1,9 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using NUnit.Framework;
+using ServiceStack.Logging;
 using ServiceStack.OrmLite.Tests.Shared;
+using ServiceStack.Text;
 
 namespace ServiceStack.OrmLite.Tests.Issues
 {
@@ -83,5 +86,37 @@ public void Does_orderbydescending_multiple_columns_using_orderbydescending()
                 Assert.That(result[0].Id, Is.EqualTo(2));
             }
         }
+
+        public class Record
+        {
+            public int Id { get; set; }
+            public double Value { get; set; }
+            public DateTime? Time { get; set; }
+        }
+
+        [Test]
+        public void Can_OrderBy_DateTime()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<Record>();
+
+                db.InsertAll(new[] {
+                    new Record
+                    {
+                        Id = 1,
+                        Value = 50,
+                        Time = DateTime.Now,
+                    },
+                });
+
+                var q = db.From<Record>();
+                q.OrderByDescending(x => x.Time ?? DateTime.UtcNow);
+
+                var results = db.Select(q);
+
+                results.PrintDump();
+            }
+        }
     }
 }

tests/ServiceStack.OrmLite.Tests/OrderByTests.cs

@@ -1,6 +1,7 @@
-using System.Linq;
+using System;
+using System.Linq;
 using NUnit.Framework;
-using ServiceStack.Common.Tests.Models;
+using ServiceStack.Logging;
 using ServiceStack.OrmLite.Tests.Expression;
 using ServiceStack.Text;
 

tests/ServiceStack.OrmLite.Tests/OrmLiteUtilExtensionsTests.cs

@@ -1,7 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using ServiceStack.OrmLite;
+using NUnit.Framework;
 
 namespace ServiceStack.OrmLite.Tests
 {
@@ -36,5 +33,19 @@ public void CanCreateNullInStatementFromEmptyList()
 
             Assert.AreEqual("IN (NULL)", sql);
         }
+
+        [Test]
+        public void Can_parse_field_Tokens()
+        {
+            Assert.That("FirstName".ParseTokens(), Is.EquivalentTo(new[] { "FirstName" }));
+            Assert.That("FirstName, LastName".ParseTokens(), Is.EquivalentTo(new[] { "FirstName", "LastName" }));
+            Assert.That("\"FirstName\"".ParseTokens(), Is.EquivalentTo(new[] { "\"FirstName\"" }));
+            Assert.That("\"FirstName\",\"LastName\"".ParseTokens(), Is.EquivalentTo(new[] { "\"FirstName\"", "\"LastName\"" }));
+            Assert.That("COALESCE(\"Time\", '2015-10-05')".ParseTokens(), Is.EquivalentTo(new[] { "COALESCE(\"Time\", '2015-10-05')" }));
+            Assert.That("\"FirstName\",COALESCE(\"Time\", '2015-10-05'),\"LastName\"".ParseTokens(), Is.EquivalentTo(
+                new[] { "\"FirstName\"", "COALESCE(\"Time\", '2015-10-05')", "\"LastName\"" }));
+            Assert.That(" \"FirstName\" , COALESCE(\"Time\", '2015-10-05') , \"LastName\" ".ParseTokens(), Is.EquivalentTo(
+                new[] { "\"FirstName\"", "COALESCE(\"Time\", '2015-10-05')", "\"LastName\"" }));
+        }
     }
 }