OrderByKey and OrderByKeyDescending TableQuery APIs (#17)

Author: johnfoconnor

SQLite.Net.Tests/LinqTest.cs

@@ -13,6 +13,7 @@ private TestDb CreateDb()
         {
             var db = new TestDb();
             db.CreateTable<Product>();
+            db.CreateTable<KeyedProduct>(); 
             db.CreateTable<Order>();
             db.CreateTable<OrderLine>();
             db.CreateTable<OrderHistory>();
@@ -143,6 +144,52 @@ public void Issue96_NullabelIntsInQueries()
             Assert.AreEqual(3, db.Table<Issue96_A>().Where(p => p.ClassB == null).Count());
         }
 
+        [Test]
+        public void OrderByKey()
+        {
+            TestDb db = CreateDb();
+
+            var products = new List<KeyedProduct>()
+            {
+                new ()
+                {
+                    Id = ("FOO", 1),
+                    Name = "A",
+                    TotalSales = 1,
+                },
+                new()
+                {
+                    Id = ("FOO", 2),
+                    Name = "C",
+                    TotalSales = 5,
+                },
+                new()
+                {
+                    Id = ("FOO",3),
+                    Name = "D",
+                    TotalSales = 400,
+                },
+                new()
+                {
+                    Id = ("FOO", 10),
+                    Name = "B",
+                    TotalSales = 100,
+                },
+            
+            };
+            foreach (var product in products)
+            {
+                db.Insert(product);
+            }
+
+            List<KeyedProduct> asc = (from p in db.Table<KeyedProduct>().OrderByKey() select p).ToList();
+            Assert.That(products, Is.EquivalentTo(asc));
+
+            List<KeyedProduct> desc = (from p in db.Table<KeyedProduct>().OrderByKeyDescending() select p).ToList();
+            products.Reverse();
+            Assert.That(products, Is.EquivalentTo(desc));
+        }
+        
         [Test]
         public void OrderByCast()
         {

SQLite.Net.Tests/TestDb.cs

@@ -16,14 +16,47 @@ public interface IProduct
         uint TotalSales { get; set; }
     }
 
-    public class Product : IProduct
+    public class Product : BaseProduct, IProduct
     {
         [AutoIncrement, PrimaryKey]
         public int Id { get; set; }
 
+    }
+
+    public class KeyedProduct : BaseProduct
+    {
+        [PrimaryKey] 
+        public (string, int) Id { get; set; }
+
+        public override bool Equals(object? obj)
+        {
+            var o = obj as KeyedProduct;
+            if (o == null)
+            {
+                return false;
+            }
+            return base.Equals(obj) && Id == o.Id;
+        }
+
+    }
+
+    
+    public class BaseProduct
+    {
         public string Name { get; set; }
         public decimal Price { get; set; }
         public uint TotalSales { get; set; }
+       
+        public override bool Equals(object? obj)
+        {
+            var o = obj as BaseProduct;
+            if (o == null)
+            {
+                return false;
+            }
+        
+            return o.Name == Name && o.Price == Price && o.TotalSales == TotalSales;
+        }
     }
 
     [Table("Order")]

src/SQLite.Net/TableQuery.cs

@@ -200,6 +200,31 @@ public TableQuery<T> OrderByDescending<TValue>(Expression<Func<T, TValue>> order
             return AddOrderBy(orderExpr, false);
         }
 
+        /// <summary>
+        /// Order the Query based on the Primary Key Column(s)
+        /// </summary>
+        public TableQuery<T> OrderByKey()
+        {
+            var pks = Table.PKs;
+            return AddOrdering(pks.Select(pk => new Ordering()
+            {
+                ColumnName = pk.Name,
+                Ascending = true,
+            }).ToArray());
+        }
+
+        /// <summary>
+        /// Order the Query based on the Primary Key Column(s)
+        /// </summary>
+        public TableQuery<T> OrderByKeyDescending()
+        {
+            var pks = Table.PKs;
+            return AddOrdering(pks.Select(pk => new Ordering()
+            {
+                ColumnName = pk.Name,
+                Ascending = false,
+            }).ToArray());
+        }
 
         public TableQuery<T> ThenBy<TValue>(Expression<Func<T, TValue>> orderExpr)
         {
@@ -212,6 +237,21 @@ public TableQuery<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orderE
             return AddOrderBy(orderExpr, false);
         }
 
+        private TableQuery<T> AddOrdering(params Ordering[] orderings)
+        {
+            var q = Clone<T>();
+            if (q._orderBys == null)
+            {
+                q._orderBys = new List<Ordering>();
+            }
+            foreach (var ordering in orderings)
+            {
+                q._orderBys.Add(ordering);   
+            }
+            return q;
+        }
+
+        
         private TableQuery<T> AddOrderBy<TValue>( Expression<Func<T, TValue>> orderExpr, bool asc)
         {
             if (orderExpr == null)
@@ -241,17 +281,11 @@ private TableQuery<T> AddOrderBy<TValue>( Expression<Func<T, TValue>> orderExpr,
                 throw new NotSupportedException("Order By does not support: " + orderExpr);
             }
 
-            var q = Clone<T>();
-            if (q._orderBys == null)
-            {
-                q._orderBys = new List<Ordering>();
-            }
-            q._orderBys.Add(new Ordering
+            return AddOrdering(new Ordering
             {
                 ColumnName = GetColumnName(mem),
                 Ascending = asc
             });
-            return q;
         }
 
         private void AddWhere( Expression pred)