From 71f4a23cde80a8e68b25fb9944e951310f2d4aac Mon Sep 17 00:00:00 2001
From: Matt Freels <matt@freels.name>
Date: Tue, 20 Feb 2024 14:50:16 -0700
Subject: [PATCH 1/2] consolidate Execute impl

---
 Fauna/Linq/QuerySource.cs    | 23 -----------
 Fauna/Linq/QuerySourceDsl.cs | 79 +++++++++++++++++++-----------------
 2 files changed, 42 insertions(+), 60 deletions(-)

diff --git a/Fauna/Linq/QuerySource.cs b/Fauna/Linq/QuerySource.cs
index c77d0b16..5e1c9761 100644
--- a/Fauna/Linq/QuerySource.cs
+++ b/Fauna/Linq/QuerySource.cs
@@ -19,12 +19,6 @@ internal void SetQuery<TElem>(Query query)
     {
         Pipeline = new Pipeline(PipelineMode.Query, query, typeof(TElem), false, null, null);
     }
-
-    // DSL Helpers
-
-    internal abstract TResult Execute<TResult>(Pipeline pl);
-
-    internal abstract Task<TResult> ExecuteAsync<TResult>(Pipeline pl, CancellationToken cancel = default);
 }
 
 public partial class QuerySource<T> : QuerySource, IQuerySource<T>
@@ -39,23 +33,6 @@ internal QuerySource(DataContext ctx, Pipeline pl)
     // constructors, so they use this base one.
     internal QuerySource() { }
 
-    internal override TResult Execute<TResult>(Pipeline pl)
-    {
-        try
-        {
-            var res = ExecuteAsync<TResult>(pl);
-            res.Wait();
-            return res.Result;
-        }
-        catch (AggregateException ex)
-        {
-            throw ex.InnerExceptions.First();
-        }
-    }
-
-    internal override Task<TResult> ExecuteAsync<TResult>(Pipeline pl, CancellationToken cancel = default) =>
-        pl.GetExec(Ctx).Result<TResult>(queryOptions: null, cancel: cancel);
-
     public IAsyncEnumerable<Page<T>> PaginateAsync(QueryOptions? queryOptions = null, CancellationToken cancel = default)
     {
         var pe = Pipeline.GetExec(Ctx);
diff --git a/Fauna/Linq/QuerySourceDsl.cs b/Fauna/Linq/QuerySourceDsl.cs
index df5fa678..1889f7b5 100644
--- a/Fauna/Linq/QuerySourceDsl.cs
+++ b/Fauna/Linq/QuerySourceDsl.cs
@@ -103,12 +103,12 @@ private Pipeline CountImpl(Expression<Func<T, bool>>? predicate) =>
             q: QH.MethodCall(MaybeWhereCall(Query, predicate), "count"),
             ety: typeof(int));
 
-    public T First() => ExecuteMaybeEmpty<T>(FirstImpl(null));
+    public T First() => Execute<T>(FirstImpl(null));
     public Task<T> FirstAsync(CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<T>(FirstImpl(null), cancel);
-    public T First(Expression<Func<T, bool>> predicate) => ExecuteMaybeEmpty<T>(FirstImpl(predicate));
+        ExecuteAsync<T>(FirstImpl(null), cancel);
+    public T First(Expression<Func<T, bool>> predicate) => Execute<T>(FirstImpl(predicate));
     public Task<T> FirstAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<T>(FirstImpl(predicate), cancel);
+        ExecuteAsync<T>(FirstImpl(predicate), cancel);
     private Pipeline FirstImpl(Expression<Func<T, bool>>? predicate) =>
         CopyPipeline(
             mode: PipelineMode.Scalar,
@@ -127,12 +127,12 @@ private Pipeline FirstOrDefaultImpl(Expression<Func<T, bool>>? predicate) =>
             ety: typeof(T),
             enull: true);
 
-    public T Last() => ExecuteMaybeEmpty<T>(LastImpl(null));
+    public T Last() => Execute<T>(LastImpl(null));
     public Task<T> LastAsync(CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<T>(LastImpl(null), cancel);
-    public T Last(Expression<Func<T, bool>> predicate) => ExecuteMaybeEmpty<T>(LastImpl(predicate));
+        ExecuteAsync<T>(LastImpl(null), cancel);
+    public T Last(Expression<Func<T, bool>> predicate) => Execute<T>(LastImpl(predicate));
     public Task<T> LastAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<T>(LastImpl(predicate), cancel);
+        ExecuteAsync<T>(LastImpl(predicate), cancel);
     private Pipeline LastImpl(Expression<Func<T, bool>>? predicate) =>
         CopyPipeline(
             mode: PipelineMode.Scalar,
@@ -165,15 +165,15 @@ private Pipeline LongCountImpl(Expression<Func<T, bool>>? predicate) =>
 
     private static readonly Query _maxReducer = QH.Expr("(a, b) => if (a >= b) a else b");
 
-    public T Max() => ExecuteMaybeEmpty<T>(MaxImpl<T>(null));
+    public T Max() => Execute<T>(MaxImpl<T>(null));
     public Task<T> MaxAsync(CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<T>(MaxImpl<T>(null), cancel);
-    public R Max<R>(Expression<Func<T, R>> selector) => ExecuteMaybeEmpty<R>(MaxImpl(selector));
+        ExecuteAsync<T>(MaxImpl<T>(null), cancel);
+    public R Max<R>(Expression<Func<T, R>> selector) => Execute<R>(MaxImpl(selector));
     public Task<R> MaxAsync<R>(Expression<Func<T, R>> selector, CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<R>(MaxImpl(selector), cancel);
-    private Pipeline MaxImpl<R>(Expression<Func<T, R>>? selector)
+        ExecuteAsync<R>(MaxImpl(selector), cancel);
+    private Pipeline MaxImpl<R>(Expression<Func<T, R>>? selector, [CallerMemberName] string callerName = "")
     {
-        RequireQueryMode("Max");
+        RequireQueryMode(callerName);
         return CopyPipeline(
             mode: PipelineMode.Scalar,
             q: QH.MethodCall(MaybeMap(AbortIfEmpty(Query), selector), "reduce", _maxReducer),
@@ -182,14 +182,14 @@ private Pipeline MaxImpl<R>(Expression<Func<T, R>>? selector)
 
     private static readonly Query _minReducer = QH.Expr("(a, b) => if (a <= b) a else b");
 
-    public T Min() => ExecuteMaybeEmpty<T>(MinImpl<T>(null));
-    public Task<T> MinAsync(CancellationToken cancel = default) => ExecuteMaybeEmptyAsync<T>(MinImpl<T>(null), cancel);
-    public R Min<R>(Expression<Func<T, R>> selector) => ExecuteMaybeEmpty<R>(MinImpl(selector));
+    public T Min() => Execute<T>(MinImpl<T>(null));
+    public Task<T> MinAsync(CancellationToken cancel = default) => ExecuteAsync<T>(MinImpl<T>(null), cancel);
+    public R Min<R>(Expression<Func<T, R>> selector) => Execute<R>(MinImpl(selector));
     public Task<R> MinAsync<R>(Expression<Func<T, R>> selector, CancellationToken cancel = default) =>
-        ExecuteMaybeEmptyAsync<R>(MinImpl(selector), cancel);
-    private Pipeline MinImpl<R>(Expression<Func<T, R>>? selector)
+        ExecuteAsync<R>(MinImpl(selector), cancel);
+    private Pipeline MinImpl<R>(Expression<Func<T, R>>? selector, [CallerMemberName] string callerName = "")
     {
-        RequireQueryMode("Min");
+        RequireQueryMode(callerName);
         return CopyPipeline(
             mode: PipelineMode.Scalar,
             q: QH.MethodCall(MaybeMap(AbortIfEmpty(Query), selector), "reduce", _minReducer),
@@ -232,34 +232,29 @@ private void RequireQueryMode([CallerMemberName] string callerName = "")
         }
     }
 
-    private R ExecuteMaybeEmpty<R>(Pipeline pl)
+    private R Execute<R>(Pipeline pl)
     {
         try
         {
-            return Execute<R>(pl);
+            var res = ExecuteAsync<R>(pl);
+            res.Wait();
+            return res.Result;
         }
-        catch (AbortException ex)
+        catch (AggregateException ex)
         {
-            throw TranslateEmptySetAbort(ex);
+            throw TranslateException(ex.InnerExceptions.First());
         }
     }
 
-    private async Task<R> ExecuteMaybeEmptyAsync<R>(Pipeline pl, CancellationToken cancel)
+    private async Task<R> ExecuteAsync<R>(Pipeline pl, CancellationToken cancel = default)
     {
         try
         {
-            return await ExecuteAsync<R>(pl, cancel);
+            return await pl.GetExec(Ctx).Result<R>(queryOptions: null, cancel: cancel);
         }
         catch (AggregateException ex)
         {
-            if (ex.InnerExceptions.First() is AbortException aex)
-            {
-                throw TranslateEmptySetAbort(aex);
-            }
-            else
-            {
-                throw;
-            }
+            throw TranslateException(ex.InnerExceptions.First());
         }
     }
 
@@ -300,10 +295,20 @@ private Pipeline CopyPipeline(
     // value is a string. Work around it by using an array.
     // FIXME(matt) remove workaround and use a string
     private Query AbortIfEmpty(Query setq) =>
-        QH.Expr("({ let s = (").Concat(setq).Concat("); if (s.isEmpty()) abort(['empty set']); s })");
+        QH.Expr("({ let s = (").Concat(setq).Concat("); if (s.isEmpty()) abort(['empty']); s })");
 
-    private Exception TranslateEmptySetAbort(AbortException ex) =>
-        ex.GetData<List<string>>()?.First() == "empty set" ? new InvalidOperationException("Empty set") : ex;
+    private Exception TranslateException(Exception ex) =>
+        ex switch
+        {
+            AbortException aex =>
+                aex.GetData<List<string>>()?.First() switch
+                {
+                    "empty" => new InvalidOperationException("Empty set"),
+                    "not single" => new InvalidOperationException("Set contains more than one element"),
+                    _ => aex,
+                },
+            _ => ex
+        };
 
     private Query MaybeWhereCall(Query callee, Expression? predicate, [CallerMemberName] string callerName = "") =>
         predicate is null ? callee : WhereCall(callee, predicate, callerName);

From 8d082ab8834d03658cde558eb957089c0c8abfc4 Mon Sep 17 00:00:00 2001
From: Matt Freels <matt@freels.name>
Date: Tue, 20 Feb 2024 15:15:49 -0700
Subject: [PATCH 2/2] Single family of methods

---
 Fauna.Test/Linq/Query.Tests.cs | 47 ++++++++++++++++++++++++++++++++++
 Fauna/Linq/IQuerySource.cs     | 16 ++++++------
 Fauna/Linq/QuerySourceDsl.cs   | 34 +++++++++++++++++++++++-
 3 files changed, 88 insertions(+), 9 deletions(-)

diff --git a/Fauna.Test/Linq/Query.Tests.cs b/Fauna.Test/Linq/Query.Tests.cs
index 5b37b9d2..a2bfc005 100644
--- a/Fauna.Test/Linq/Query.Tests.cs
+++ b/Fauna.Test/Linq/Query.Tests.cs
@@ -475,6 +475,53 @@ public async Task Query_Reverse()
         Assert.AreEqual(new List<string> { "Bob", "Alice" }, names);
     }
 
+    [Test]
+    public void Query_Single()
+    {
+        try
+        {
+            db.Author.Single();
+            Assert.Fail();
+        }
+        catch (InvalidOperationException ex)
+        {
+            Assert.AreEqual("Set contains more than one element", ex.Message);
+        }
+
+        var sngPred = db.Author.Single(a => a.Name == "Alice");
+        Assert.AreEqual("Alice", sngPred.Name);
+
+        try
+        {
+            db.Author.Single(a => a.Name == "No name");
+            Assert.Fail();
+        }
+        catch (InvalidOperationException ex)
+        {
+            Assert.AreEqual("Empty set", ex.Message);
+        }
+    }
+
+    [Test]
+    public void Query_SingleOrDefault()
+    {
+        try
+        {
+            db.Author.SingleOrDefault();
+            Assert.Fail();
+        }
+        catch (InvalidOperationException ex)
+        {
+            Assert.AreEqual("Set contains more than one element", ex.Message);
+        }
+
+        var sngPred = db.Author.SingleOrDefault(a => a.Name == "Alice");
+        Assert.AreEqual("Alice", sngPred?.Name);
+
+        var sngNull = db.Author.SingleOrDefault(a => a.Name == "No name");
+        Assert.AreEqual(null, sngNull);
+    }
+
     [Test]
     public async Task Query_Skip()
     {
diff --git a/Fauna/Linq/IQuerySource.cs b/Fauna/Linq/IQuerySource.cs
index b46ec7e1..7136be84 100644
--- a/Fauna/Linq/IQuerySource.cs
+++ b/Fauna/Linq/IQuerySource.cs
@@ -110,17 +110,17 @@ public interface IQuerySource<T> : IQuerySource
     public R Min<R>(Expression<Func<T, R>> selector);
     public Task<R> MinAsync<R>(Expression<Func<T, R>> selector, CancellationToken cancel = default);
 
-    // public T Single();
-    // public Task<T> SingleAsync(CancellationToken cancel = default);
+    public T Single();
+    public Task<T> SingleAsync(CancellationToken cancel = default);
 
-    // public T Single(Expression<Func<T, bool>> predicate);
-    // public Task<T> SingleAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default);
+    public T Single(Expression<Func<T, bool>> predicate);
+    public Task<T> SingleAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default);
 
-    // public T SingleOrDefault();
-    // public Task<T> SingleOrDefaultAsync(CancellationToken cancel = default);
+    public T SingleOrDefault();
+    public Task<T> SingleOrDefaultAsync(CancellationToken cancel = default);
 
-    // public T SingleOrDefault(Expression<Func<T, bool>> predicate);
-    // public Task<T> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default);
+    public T SingleOrDefault(Expression<Func<T, bool>> predicate);
+    public Task<T> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default);
 
     public int Sum(Expression<Func<T, int>> selector);
     public Task<int> SumAsync(Expression<Func<T, int>> selector, CancellationToken cancel = default);
diff --git a/Fauna/Linq/QuerySourceDsl.cs b/Fauna/Linq/QuerySourceDsl.cs
index 1889f7b5..e2e66b0a 100644
--- a/Fauna/Linq/QuerySourceDsl.cs
+++ b/Fauna/Linq/QuerySourceDsl.cs
@@ -196,6 +196,28 @@ private Pipeline MinImpl<R>(Expression<Func<T, R>>? selector, [CallerMemberName]
             ety: typeof(R));
     }
 
+    public T Single() => Execute<T>(SingleImpl(null));
+    public Task<T> SingleAsync(CancellationToken cancel = default) => ExecuteAsync<T>(SingleImpl(null), cancel);
+    public T Single(Expression<Func<T, bool>> predicate) => Execute<T>(SingleImpl(predicate));
+    public Task<T> SingleAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default) =>
+        ExecuteAsync<T>(SingleImpl(predicate), cancel);
+    private Pipeline SingleImpl(Expression<Func<T, bool>>? predicate) =>
+        CopyPipeline(
+            mode: PipelineMode.Scalar,
+            q: QH.MethodCall(AbortIfEmpty(Singularize(MaybeWhereCall(Query, predicate))), "first"));
+
+    public T SingleOrDefault() => Execute<T>(SingleOrDefaultImpl(null));
+    public Task<T> SingleOrDefaultAsync(CancellationToken cancel = default) => ExecuteAsync<T>(SingleOrDefaultImpl(null), cancel);
+    public T SingleOrDefault(Expression<Func<T, bool>> predicate) => Execute<T>(SingleOrDefaultImpl(predicate));
+    public Task<T> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancel = default) =>
+        ExecuteAsync<T>(SingleOrDefaultImpl(predicate), cancel);
+    private Pipeline SingleOrDefaultImpl(Expression<Func<T, bool>>? predicate) =>
+        CopyPipeline(
+            mode: PipelineMode.Scalar,
+            q: QH.MethodCall(Singularize(MaybeWhereCall(Query, predicate)), "first"),
+            ety: typeof(T),
+            enull: true);
+
     private static readonly Query _sumReducer = QH.Expr("(a, b) => a + b");
 
     public int Sum(Expression<Func<T, int>> selector) => Execute<int>(SumImpl<int>(selector));
@@ -295,7 +317,17 @@ private Pipeline CopyPipeline(
     // value is a string. Work around it by using an array.
     // FIXME(matt) remove workaround and use a string
     private Query AbortIfEmpty(Query setq) =>
-        QH.Expr("({ let s = (").Concat(setq).Concat("); if (s.isEmpty()) abort(['empty']); s })");
+        QH.Expr(@"({ let s = (").Concat(setq).Concat(@")
+            if (s.isEmpty()) abort(['empty'])
+            s
+        })");
+
+    private Query Singularize(Query setq) =>
+        QH.Expr(@"({
+          let s = (").Concat(setq).Concat(@").take(2).toArray()
+          if (s.length > 1) abort(['not single'])
+          s.take(1)
+        })");
 
     private Exception TranslateException(Exception ex) =>
         ex switch