.gitignore

@@ -397,6 +397,3 @@ FodyWeavers.xsd
 # JetBrains Rider
 *.sln.iml
 **/.idea
-
-# Test run files
-src/*-tests.txt

src/Common/Library.fs

@@ -2,45 +2,39 @@
 
 open System.Security.Cryptography
 
-/// The types of comparisons available for JSON fields
+/// The types of logical operations available for JSON fields
-type Comparison =
+[<Struct>]
+type Op =
     /// Equals (=)
-    | Equal of Value: obj
+    | EQ
     /// Greater Than (>)
-    | Greater of Value: obj
+    | GT
     /// Greater Than or Equal To (>=)
-    | GreaterOrEqual of Value: obj
+    | GE
     /// Less Than (<)
-    | Less of Value: obj
+    | LT
     /// Less Than or Equal To (<=)
-    | LessOrEqual of Value: obj 
+    | LE
     /// Not Equal to (<>)
-    | NotEqual of Value: obj
+    | NE
     /// Between (BETWEEN)
-    | Between of Min: obj * Max: obj
+    | BT
-    /// In (IN)
-    | In of Values: obj seq
-    /// In Array (PostgreSQL: |?, SQLite: EXISTS / json_each / IN)
-    | InArray of Table: string * Values: obj seq
     /// Exists (IS NOT NULL)
-    | Exists
+    | EX
     /// Does Not Exist (IS NULL)
-    | NotExists
+    | NEX
     
-    /// Get the operator SQL for this comparison
+    override this.ToString() =
-    member this.OpSql =
         match this with
-        | Equal _ -> "="
+        | EQ -> "="
-        | Greater _ -> ">"
+        | GT -> ">"
-        | GreaterOrEqual _ -> ">="
+        | GE -> ">="
-        | Less _ -> "<"
+        | LT -> "<"
-        | LessOrEqual _ -> "<="
+        | LE -> "<="
-        | NotEqual _ -> "<>"
+        | NE -> "<>"
-        | Between _ -> "BETWEEN"
+        | BT -> "BETWEEN"
-        | In _ -> "IN"
+        | EX -> "IS NOT NULL"
-        | InArray _ -> "?|" // PostgreSQL only; SQL needs a subquery for this 
+        | NEX -> "IS NULL"
-        | Exists -> "IS NOT NULL"
-        | NotExists -> "IS NULL"
 
 
 /// The dialect in which a command should be rendered
@@ -49,129 +43,73 @@ type Dialect =
     | PostgreSQL
     | SQLite
 
-
-/// The format in which an element of a JSON field should be extracted 
-[<Struct>]
-type FieldFormat =
-    /// Use ->> or #>>; extracts a text (PostgreSQL) or SQL (SQLite) value
-    | AsSql
-    /// Use -> or #>; extracts a JSONB (PostgreSQL) or JSON (SQLite) value
-    | AsJson
-
-
 /// Criteria for a field WHERE clause
-type Field =
+type Field = {
-    { /// The name of the field
+    /// The name of the field
-      Name: string
+    Name: string
     
-      /// The comparison for the field
+    /// The operation by which the field will be compared
-      Comparison: Comparison
+    Op: Op
     
-      /// The name of the parameter for this field
+    /// The value of the field
-      ParameterName: string option
+    Value: obj
     
-      /// The table qualifier for this field
+    /// The name of the parameter for this field
-      Qualifier: string option }
+    ParameterName: string option
-with
     
-    /// Create a comparison against a field
+    /// The table qualifier for this field
-    static member Where name (comparison: Comparison) =
+    Qualifier: string option
-        { Name = name; Comparison = comparison; ParameterName = None; Qualifier = None }
+} with
     
     /// Create an equals (=) field criterion
-    static member Equal<'T> name (value: 'T) =
+    static member EQ name (value: obj) =
-        Field.Where name (Equal value)
+        { Name = name; Op = EQ; Value = value; ParameterName = None; Qualifier = None }
-    
-    /// Create an equals (=) field criterion (alias)
-    static member EQ<'T> name (value: 'T) = Field.Equal name value
     
     /// Create a greater than (>) field criterion
-    static member Greater<'T> name (value: 'T) =
+    static member GT name (value: obj) =
-        Field.Where name (Greater value)
+        { Name = name; Op = GT; Value = value; ParameterName = None; Qualifier = None }
-    
-    /// Create a greater than (>) field criterion (alias)
-    static member GT<'T> name (value: 'T) = Field.Greater name value
     
     /// Create a greater than or equal to (>=) field criterion
-    static member GreaterOrEqual<'T> name (value: 'T) =
+    static member GE name (value: obj) =
-        Field.Where name (GreaterOrEqual value)
+        { Name = name; Op = GE; Value = value; ParameterName = None; Qualifier = None }
-    
-    /// Create a greater than or equal to (>=) field criterion (alias)
-    static member GE<'T> name (value: 'T) = Field.GreaterOrEqual name value
     
     /// Create a less than (<) field criterion
-    static member Less<'T> name (value: 'T) =
+    static member LT name (value: obj) =
-        Field.Where name (Less value)
+        { Name = name; Op = LT; Value = value; ParameterName = None; Qualifier = None }
-    
-    /// Create a less than (<) field criterion (alias)
-    static member LT<'T> name (value: 'T) = Field.Less name value
     
     /// Create a less than or equal to (<=) field criterion
-    static member LessOrEqual<'T> name (value: 'T) =
+    static member LE name (value: obj) =
-        Field.Where name (LessOrEqual value)
+        { Name = name; Op = LE; Value = value; ParameterName = None; Qualifier = None }
-    
-    /// Create a less than or equal to (<=) field criterion (alias)
-    static member LE<'T> name (value: 'T) = Field.LessOrEqual name value
     
     /// Create a not equals (<>) field criterion
-    static member NotEqual<'T> name (value: 'T) =
+    static member NE name (value: obj) =
-        Field.Where name (NotEqual value)
+        { Name = name; Op = NE; Value = value; ParameterName = None; Qualifier = None }
     
-    /// Create a not equals (<>) field criterion (alias)
+    /// Create a BETWEEN field criterion
-    static member NE<'T> name (value: 'T) = Field.NotEqual name value
+    static member BT name (min: obj) (max: obj) =
-    
+        { Name = name; Op = BT; Value = [ min; max ]; ParameterName = None; Qualifier = None }
-    /// Create a Between field criterion
-    static member Between<'T> name (min: 'T) (max: 'T) =
-        Field.Where name (Between(min, max))
-    
-    /// Create a Between field criterion (alias)
-    static member BT<'T> name (min: 'T) (max: 'T) = Field.Between name min max
-    
-    /// Create an In field criterion
-    static member In<'T> name (values: 'T seq) =
-        Field.Where name (In (Seq.map box values))
-    
-    /// Create an In field criterion (alias)
-    static member IN<'T> name (values: 'T seq) = Field.In name values
-    
-    /// Create an InArray field criterion
-    static member InArray<'T> name tableName (values: 'T seq) =
-        Field.Where name (InArray(tableName, Seq.map box values))
     
     /// Create an exists (IS NOT NULL) field criterion
-    static member Exists name =
+    static member EX name =
-        Field.Where name Exists
+        { Name = name; Op = EX; Value = obj (); ParameterName = None; Qualifier = None }
-    
-    /// Create an exists (IS NOT NULL) field criterion (alias)
-    static member EX name = Field.Exists name
     
     /// Create a not exists (IS NULL) field criterion
-    static member NotExists name =
+    static member NEX name =
-        Field.Where name NotExists
+        { Name = name; Op = NEX; Value = obj (); ParameterName = None; Qualifier = None }
-    
-    /// Create a not exists (IS NULL) field criterion (alias)
-    static member NEX name = Field.NotExists name
     
     /// Transform a field name (a.b.c) to a path for the given SQL dialect
-    static member NameToPath (name: string) dialect format =
+    static member NameToPath (name: string) dialect =
         let path =
             if name.Contains '.' then
                 match dialect with
-                | PostgreSQL ->
+                | PostgreSQL -> "#>>'{" + String.concat "," (name.Split '.') + "}'"
-                    (match format with AsJson -> "#>" | AsSql -> "#>>")
+                | SQLite -> "->>'" + String.concat "'->>'" (name.Split '.') + "'"
-                        + "'{" + String.concat "," (name.Split '.') + "}'"
+            else $"->>'{name}'"
-                | SQLite ->
-                    let parts = name.Split '.'
-                    let last  = Array.last parts
-                    let final = (match format with AsJson -> "'->'" | AsSql -> "'->>'") + $"{last}'"
-                    "->'" + String.concat "'->'" (Array.truncate (Array.length parts - 1) parts) + final
-            else
-                match format with AsJson -> $"->'{name}'" | AsSql -> $"->>'{name}'"
         $"data{path}"
     
     /// Create a field with a given name, but no other properties filled (op will be EQ, value will be "")
     static member Named name =
-        Field.Where name (Equal "")
+        { Name = name; Op = EQ; Value = ""; ParameterName = None; Qualifier = None }
     
     /// Specify the name of the parameter for this field
     member this.WithParameterName name =
@@ -182,9 +120,8 @@ with
         { this with Qualifier = Some alias }
 
     /// Get the qualified path to the field
-    member this.Path dialect format =
+    member this.Path dialect =
-        (this.Qualifier |> Option.map (fun q -> $"{q}.") |> Option.defaultValue "")
+        (this.Qualifier |> Option.map (fun q -> $"{q}.") |> Option.defaultValue "") + Field.NameToPath this.Name dialect
-            + Field.NameToPath this.Name dialect format
 
 
 /// How fields should be matched
@@ -400,7 +337,7 @@ module Query =
                     let parts = it.Split ' '
                     let fieldName = if Array.length parts = 1 then it else parts[0]
                     let direction = if Array.length parts < 2 then "" else $" {parts[1]}"
-                    $"({Field.NameToPath fieldName dialect AsSql}){direction}")
+                    $"({Field.NameToPath fieldName dialect}){direction}")
                 |> String.concat ", "
             $"CREATE INDEX IF NOT EXISTS idx_{tbl}_%s{indexName} ON {tableName} ({jsonFields})"
 
@@ -461,18 +398,13 @@ module Query =
             |> Seq.map (fun it ->
                 if it.Name.Contains ' ' then
                     let parts = it.Name.Split ' '
-                    { it with Name = parts[0] }, Some $""" {parts |> Array.skip 1 |> String.concat " "}"""
+                    { it with Name = parts[0] }, Some $" {parts[1]}"
                 else it, None)
             |> Seq.map (fun (field, direction) ->
-                if field.Name.StartsWith "n:" then
+                match dialect, field.Name.StartsWith "n:" with
-                    let f = { field with Name = field.Name[2..] }
+                | PostgreSQL, true -> $"({ { field with Name = field.Name[2..] }.Path PostgreSQL})::numeric"
-                    match dialect with
+                | SQLite, true     -> { field with Name = field.Name[2..] }.Path SQLite
-                    | PostgreSQL -> $"({f.Path PostgreSQL AsSql})::numeric"
+                | _, _             -> field.Path dialect
-                    | SQLite -> f.Path SQLite AsSql
-                elif field.Name.StartsWith "i:" then
-                    let p = { field with Name = field.Name[2..] }.Path dialect AsSql
-                    match dialect with PostgreSQL ->  $"LOWER({p})" | SQLite -> $"{p} COLLATE NOCASE"
-                else field.Path dialect AsSql
                 |> function path -> path + defaultArg direction "")
             |> String.concat ", "
             |> function it -> $" ORDER BY {it}"

src/Directory.Build.props

@@ -6,17 +6,8 @@
     <AssemblyVersion>4.0.0.0</AssemblyVersion>
     <FileVersion>4.0.0.0</FileVersion>
     <VersionPrefix>4.0.0</VersionPrefix>
-    <VersionSuffix>rc5</VersionSuffix>
+    <VersionSuffix>rc1</VersionSuffix>
-    <PackageReleaseNotes>From v3.1: (see project site for breaking changes and compatibility)
+    <PackageReleaseNotes>Change ByField to ByFields; support dot-access to nested document fields; add Find*Ordered functions/methods; see project site for breaking changes and compatibility</PackageReleaseNotes>
-- Change ByField to ByFields
-- Support dot-access to nested document fields
-- Add Find*Ordered functions/methods
-
-Release Candidate Changes:
-- from v4-rc4: Field construction functions are now generic.
-- from v4-rc3: Add In/InArray field comparisons, revamp internal comparison handling.
-- from v4-rc2: preserve additional ORDER BY qualifiers.
-- from v4-rc1: add case-insensitive ordering.</PackageReleaseNotes>
     <Authors>danieljsummers</Authors>
     <Company>Bit Badger Solutions</Company>
     <PackageReadmeFile>README.md</PackageReadmeFile>

src/Postgres/Library.fs

@@ -87,25 +87,18 @@ module Parameters =
         fields
         |> Seq.map (fun it ->
             seq {
-                match it.Comparison with
+                match it.Op with
-                | Exists | NotExists -> ()
+                | EX | NEX -> ()
-                | Between (min, max) ->
+                | BT ->
+                    let p      = name.Derive it.ParameterName
+                    let values = it.Value :?> obj list
+                    yield ($"{p}min",
+                           parameterFor (List.head values) (fun v -> Sql.parameter (NpgsqlParameter($"{p}min", v))))
+                    yield ($"{p}max",
+                           parameterFor (List.last values) (fun v -> Sql.parameter (NpgsqlParameter($"{p}max", v))))
+                | _ ->
                     let p = name.Derive it.ParameterName
-                    yield ($"{p}min", parameterFor min (fun v -> Sql.parameter (NpgsqlParameter($"{p}min", v))))
+                    yield (p, parameterFor it.Value (fun v -> Sql.parameter (NpgsqlParameter(p, v)))) })
-                    yield ($"{p}max", parameterFor max (fun v -> Sql.parameter (NpgsqlParameter($"{p}max", v))))
-                | In values ->
-                    let p = name.Derive it.ParameterName
-                    yield!
-                        values
-                        |> Seq.mapi (fun idx v ->
-                            let paramName = $"{p}_{idx}" 
-                            paramName, Sql.parameter (NpgsqlParameter(paramName, v)))
-                | InArray (_, values) ->
-                    let p = name.Derive it.ParameterName
-                    yield (p, Sql.stringArray (values |> Seq.map string |> Array.ofSeq))
-                | Equal v | Greater v | GreaterOrEqual v | Less v | LessOrEqual v | NotEqual v ->
-                    let p = name.Derive it.ParameterName
-                    yield (p, parameterFor v (fun l -> Sql.parameter (NpgsqlParameter(p, l)))) })
         |> Seq.collect id
         |> Seq.append parameters
         |> Seq.toList
@@ -138,28 +131,23 @@ module Query =
             | _ -> false
         fields
         |> Seq.map (fun it ->
-            match it.Comparison with
+            match it.Op with
-            | Exists | NotExists -> $"{it.Path PostgreSQL AsSql} {it.Comparison.OpSql}"
+            | EX | NEX -> $"{it.Path PostgreSQL} {it.Op}"
-            | InArray _ -> $"{it.Path PostgreSQL AsJson} {it.Comparison.OpSql} {name.Derive it.ParameterName}"
             | _ ->
                 let p            = name.Derive it.ParameterName
                 let param, value =
-                    match it.Comparison with
+                    match it.Op with
-                    | Between (min, _) -> $"{p}min AND {p}max", min
+                    | BT -> $"{p}min AND {p}max", (it.Value :?> obj list)[0]
-                    | In values ->
+                    | _  -> p, it.Value
-                        let paramNames = values |> Seq.mapi (fun idx _ -> $"{p}_{idx}") |> String.concat ", "
-                        $"({paramNames})", defaultArg (Seq.tryHead values) (obj ())
-                    | Equal v | Greater v | GreaterOrEqual v | Less v | LessOrEqual v | NotEqual v  -> p, v
-                    | _ -> p, ""
                 if isNumeric value then
-                    $"({it.Path PostgreSQL AsSql})::numeric {it.Comparison.OpSql} {param}"
+                    $"({it.Path PostgreSQL})::numeric {it.Op} {param}"
-                else $"{it.Path PostgreSQL AsSql} {it.Comparison.OpSql} {param}")
+                else $"{it.Path PostgreSQL} {it.Op} {param}")
         |> String.concat $" {howMatched} "
 
     /// Create a WHERE clause fragment to implement an ID-based query
     [<CompiledName "WhereById">]
     let whereById<'TKey> (docId: 'TKey) =
-        whereByFields Any [ { Field.Equal (Configuration.idField ()) docId with ParameterName = Some "@id" } ]
+        whereByFields Any [ { Field.EQ (Configuration.idField ()) docId with ParameterName = Some "@id" } ]
     
     /// Table and index definition queries
     module Definition =

src/Postgres/README.md

@@ -66,7 +66,7 @@ var customer = await Find.ById<string, Customer>("customer", "123");
 // Find.byId type signature is string -> 'TKey -> Task<'TDoc option>
 let! customer = Find.byId<string, Customer> "customer" "123"
 ```
-_(keys are treated as strings or numbers depending on their defintion; however, they are indexed as strings)_
+_(keys are treated as strings in the database)_
 
 Count customers in Atlanta (using JSON containment):
 

src/Sqlite/Library.fs

@@ -37,26 +37,18 @@ module Query =
         let name = ParameterName()
         fields
         |> Seq.map (fun it ->
-            match it.Comparison with
+            match it.Op with
-            | Exists | NotExists -> $"{it.Path SQLite AsSql} {it.Comparison.OpSql}"
+            | EX | NEX -> $"{it.Path SQLite} {it.Op}"
-            | Between _ ->
+            | BT ->
                 let p = name.Derive it.ParameterName
-                $"{it.Path SQLite AsSql} {it.Comparison.OpSql} {p}min AND {p}max"
+                $"{it.Path SQLite} {it.Op} {p}min AND {p}max"
-            | In values ->
+            | _ -> $"{it.Path SQLite} {it.Op} {name.Derive it.ParameterName}")
-                let p          = name.Derive it.ParameterName
-                let paramNames = values |> Seq.mapi (fun idx _ -> $"{p}_{idx}") |> String.concat ", "
-                $"{it.Path SQLite AsSql} {it.Comparison.OpSql} ({paramNames})"
-            | InArray (table, values) ->
-                let p          = name.Derive it.ParameterName
-                let paramNames = values |> Seq.mapi (fun idx _ -> $"{p}_{idx}") |> String.concat ", "
-                $"EXISTS (SELECT 1 FROM json_each({table}.data, '$.{it.Name}') WHERE value IN ({paramNames}))"
-            | _ -> $"{it.Path SQLite AsSql} {it.Comparison.OpSql} {name.Derive it.ParameterName}")
         |> String.concat $" {howMatched} "
 
     /// Create a WHERE clause fragment to implement an ID-based query
     [<CompiledName "WhereById">]
     let whereById paramName =
-        whereByFields Any [ { Field.Equal (Configuration.idField ()) 0 with ParameterName = Some paramName } ]
+        whereByFields Any [ { Field.EQ (Configuration.idField ()) 0 with ParameterName = Some paramName } ]
     
     /// Create an UPDATE statement to patch documents
     [<CompiledName "Patch">]
@@ -74,7 +66,7 @@ module Query =
     let byId<'TKey> statement (docId: 'TKey) =
         Query.statementWhere
             statement
-            (whereByFields Any [ { Field.Equal (Configuration.idField ()) docId with ParameterName = Some "@id" } ])
+            (whereByFields Any [ { Field.EQ (Configuration.idField ()) docId with ParameterName = Some "@id" } ])
     
     /// Create a query on JSON fields
     [<CompiledName "ByFields">]
@@ -111,16 +103,14 @@ module Parameters =
         fields
         |> Seq.map (fun it ->
             seq {
-                match it.Comparison with
+                match it.Op with
-                | Exists | NotExists -> ()
+                | EX | NEX -> ()
-                | Between (min, max) ->
+                | BT ->
-                    let p = name.Derive it.ParameterName
+                    let p      = name.Derive it.ParameterName
-                    yield! [ SqliteParameter($"{p}min", min); SqliteParameter($"{p}max", max) ]
+                    let values = it.Value :?> obj list
-                | In values | InArray (_, values) ->
+                    yield SqliteParameter($"{p}min", List.head values)
-                    let p = name.Derive it.ParameterName
+                    yield SqliteParameter($"{p}max", List.last values)
-                    yield! values |> Seq.mapi (fun idx v -> SqliteParameter($"{p}_{idx}", v))
+                | _ -> yield SqliteParameter(name.Derive it.ParameterName, it.Value) })
-                | Equal v | Greater v | GreaterOrEqual v | Less v | LessOrEqual v | NotEqual v ->
-                    yield SqliteParameter(name.Derive it.ParameterName, v) })
         |> Seq.collect id
         |> Seq.append parameters
         |> Seq.toList

src/Sqlite/README.md

@@ -73,13 +73,13 @@ Count customers in Atlanta:
 ```csharp
 // C#; parameters are table name, field, operator, and value
 // Count.ByField type signature is Func<string, Field, Task<long>>
-var customerCount = await Count.ByField("customer", Field.Equal("City", "Atlanta"));
+var customerCount = await Count.ByField("customer", Field.EQ("City", "Atlanta"));
 ```
 
 ```fsharp
 // F#
 // Count.byField type signature is string -> Field -> Task<int64>
-let! customerCount = Count.byField "customer" (Field.Equal "City" "Atlanta")
+let! customerCount = Count.byField "customer" (Field.EQ "City" "Atlanta")
 ```
 
 Delete customers in Chicago: _(no offense, Second City; just an example...)_
@@ -87,13 +87,13 @@ Delete customers in Chicago: _(no offense, Second City; just an example...)_
 ```csharp
 // C#; parameters are same as above, except return is void
 // Delete.ByField type signature is Func<string, Field, Task>
-await Delete.ByField("customer", Field.Equal("City", "Chicago"));
+await Delete.ByField("customer", Field.EQ("City", "Chicago"));
 ```
 
 ```fsharp
 // F#
 // Delete.byField type signature is string -> string -> Op -> obj -> Task<unit>
-do! Delete.byField "customer" (Field.Equal "City" "Chicago")
+do! Delete.byField "customer" (Field.EQ "City" "Chicago")
 ```
 
 ## More Information

src/Tests.CSharp/CommonCSharpTests.cs

@@ -1,5 +1,6 @@
 using Expecto.CSharp;
 using Expecto;
+using Microsoft.FSharp.Collections;
 using Microsoft.FSharp.Core;
 
 namespace BitBadger.Documents.Tests.CSharp;
@@ -21,53 +22,45 @@ internal class TestSerializer : IDocumentSerializer
 public static class CommonCSharpTests
 {
     /// <summary>
-    /// Unit tests for the OpSql property of the Comparison discriminated union
+    /// Unit tests for the Op enum
     /// </summary>
-    private static readonly Test OpTests = TestList("Comparison.OpSql",
+    private static readonly Test OpTests = TestList("Op",
     [
-        TestCase("Equal succeeds", () =>
+        TestCase("EQ succeeds", () =>
         {
-            Expect.equal(Comparison.NewEqual("").OpSql, "=", "The Equals SQL was not correct");
+            Expect.equal(Op.EQ.ToString(), "=", "The equals operator was not correct");
         }),
-        TestCase("Greater succeeds", () =>
+        TestCase("GT succeeds", () =>
         {
-            Expect.equal(Comparison.NewGreater("").OpSql, ">", "The Greater SQL was not correct");
+            Expect.equal(Op.GT.ToString(), ">", "The greater than operator was not correct");
         }),
-        TestCase("GreaterOrEqual succeeds", () =>
+        TestCase("GE succeeds", () =>
         {
-            Expect.equal(Comparison.NewGreaterOrEqual("").OpSql, ">=", "The GreaterOrEqual SQL was not correct");
+            Expect.equal(Op.GE.ToString(), ">=", "The greater than or equal to operator was not correct");
         }),
-        TestCase("Less succeeds", () =>
+        TestCase("LT succeeds", () =>
         {
-            Expect.equal(Comparison.NewLess("").OpSql, "<", "The Less SQL was not correct");
+            Expect.equal(Op.LT.ToString(), "<", "The less than operator was not correct");
         }),
-        TestCase("LessOrEqual succeeds", () =>
+        TestCase("LE succeeds", () =>
         {
-            Expect.equal(Comparison.NewLessOrEqual("").OpSql, "<=", "The LessOrEqual SQL was not correct");
+            Expect.equal(Op.LE.ToString(), "<=", "The less than or equal to operator was not correct");
         }),
-        TestCase("NotEqual succeeds", () =>
+        TestCase("NE succeeds", () =>
         {
-            Expect.equal(Comparison.NewNotEqual("").OpSql, "<>", "The NotEqual SQL was not correct");
+            Expect.equal(Op.NE.ToString(), "<>", "The not equal to operator was not correct");
         }),
-        TestCase("Between succeeds", () =>
+        TestCase("BT succeeds", () =>
         {
-            Expect.equal(Comparison.NewBetween("", "").OpSql, "BETWEEN", "The Between SQL was not correct");
+            Expect.equal(Op.BT.ToString(), "BETWEEN", "The \"between\" operator was not correct");
         }),
-        TestCase("In succeeds", () =>
+        TestCase("EX succeeds", () =>
         {
-            Expect.equal(Comparison.NewIn([]).OpSql, "IN", "The In SQL was not correct");
+            Expect.equal(Op.EX.ToString(), "IS NOT NULL", "The \"exists\" operator was not correct");
         }),
-        TestCase("InArray succeeds", () =>
+        TestCase("NEX succeeds", () =>
         {
-            Expect.equal(Comparison.NewInArray("", []).OpSql, "?|", "The InArray SQL was not correct");
+            Expect.equal(Op.NEX.ToString(), "IS NULL", "The \"not exists\" operator was not correct");
-        }),
-        TestCase("Exists succeeds", () =>
-        {
-            Expect.equal(Comparison.Exists.OpSql, "IS NOT NULL", "The Exists SQL was not correct");
-        }),
-        TestCase("NotExists succeeds", () =>
-        {
-            Expect.equal(Comparison.NotExists.OpSql, "IS NULL", "The NotExists SQL was not correct");
         })
     ]);
 
@@ -76,110 +69,101 @@ public static class CommonCSharpTests
     /// </summary>
     private static readonly Test FieldTests = TestList("Field",
     [
-        TestCase("Equal succeeds", () =>
+        TestCase("EQ succeeds", () =>
         {
-            var field = Field.Equal("Test", 14);
+            var field = Field.EQ("Test", 14);
             Expect.equal(field.Name, "Test", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewEqual(14), "Comparison incorrect");
+            Expect.equal(field.Op, Op.EQ, "Operator incorrect");
+            Expect.equal(field.Value, 14, "Value incorrect");
         }),
-        TestCase("Greater succeeds", () =>
+        TestCase("GT succeeds", () =>
         {
-            var field = Field.Greater("Great", "night");
+            var field = Field.GT("Great", "night");
             Expect.equal(field.Name, "Great", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewGreater("night"), "Comparison incorrect");
+            Expect.equal(field.Op, Op.GT, "Operator incorrect");
+            Expect.equal(field.Value, "night", "Value incorrect");
         }),
-        TestCase("GreaterOrEqual succeeds", () =>
+        TestCase("GE succeeds", () =>
         {
-            var field = Field.GreaterOrEqual("Nice", 88L);
+            var field = Field.GE("Nice", 88L);
             Expect.equal(field.Name, "Nice", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewGreaterOrEqual(88L), "Comparison incorrect");
+            Expect.equal(field.Op, Op.GE, "Operator incorrect");
+            Expect.equal(field.Value, 88L, "Value incorrect");
         }),
-        TestCase("Less succeeds", () =>
+        TestCase("LT succeeds", () =>
         {
-            var field = Field.Less("Lesser", "seven");
+            var field = Field.LT("Lesser", "seven");
             Expect.equal(field.Name, "Lesser", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewLess("seven"), "Comparison incorrect");
+            Expect.equal(field.Op, Op.LT, "Operator incorrect");
+            Expect.equal(field.Value, "seven", "Value incorrect");
         }),
-        TestCase("LessOrEqual succeeds", () =>
+        TestCase("LE succeeds", () =>
         {
-            var field = Field.LessOrEqual("Nobody", "KNOWS");
+            var field = Field.LE("Nobody", "KNOWS");
             Expect.equal(field.Name, "Nobody", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewLessOrEqual("KNOWS"), "Comparison incorrect");
+            Expect.equal(field.Op, Op.LE, "Operator incorrect");
+            Expect.equal(field.Value, "KNOWS", "Value incorrect");
         }),
-        TestCase("NotEqual succeeds", () =>
+        TestCase("NE succeeds", () =>
         {
-            var field = Field.NotEqual("Park", "here");
+            var field = Field.NE("Park", "here");
             Expect.equal(field.Name, "Park", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewNotEqual("here"), "Comparison incorrect");
+            Expect.equal(field.Op, Op.NE, "Operator incorrect");
+            Expect.equal(field.Value, "here", "Value incorrect");
         }),
-        TestCase("Between succeeds", () =>
+        TestCase("BT succeeds", () =>
         {
-            var field = Field.Between("Age", 18, 49);
+            var field = Field.BT("Age", 18, 49);
             Expect.equal(field.Name, "Age", "Field name incorrect");
-            Expect.equal(field.Comparison, Comparison.NewBetween(18, 49), "Comparison incorrect");
+            Expect.equal(field.Op, Op.BT, "Operator incorrect");
+            Expect.equal(((FSharpList<object>)field.Value).ToArray(), [18, 49], "Value incorrect");
         }),
-        TestCase("In succeeds", () =>
+        TestCase("EX succeeds", () =>
         {
-            var field = Field.In("Here", [8, 16, 32]);
+            var field = Field.EX("Groovy");
-            Expect.equal(field.Name, "Here", "Field name incorrect");
-            Expect.isTrue(field.Comparison.IsIn, "Comparison incorrect");
-            Expect.sequenceEqual(((Comparison.In)field.Comparison).Values, [8, 16, 32], "Value incorrect");
-        }),
-        TestCase("InArray succeeds", () =>
-        {
-            var field = Field.InArray("ArrayField", "table", ["x", "y", "z"]);
-            Expect.equal(field.Name, "ArrayField", "Field name incorrect");
-            Expect.isTrue(field.Comparison.IsInArray, "Comparison incorrect");
-            var it = (Comparison.InArray)field.Comparison;
-            Expect.equal(it.Table, "table", "Table name incorrect");
-            Expect.sequenceEqual(it.Values, ["x", "y", "z"], "Value incorrect");
-        }),
-        TestCase("Exists succeeds", () =>
-        {
-            var field = Field.Exists("Groovy");
             Expect.equal(field.Name, "Groovy", "Field name incorrect");
-            Expect.isTrue(field.Comparison.IsExists, "Comparison incorrect");
+            Expect.equal(field.Op, Op.EX, "Operator incorrect");
         }),
-        TestCase("NotExists succeeds", () =>
+        TestCase("NEX succeeds", () =>
         {
-            var field = Field.NotExists("Rad");
+            var field = Field.NEX("Rad");
             Expect.equal(field.Name, "Rad", "Field name incorrect");
-            Expect.isTrue(field.Comparison.IsNotExists, "Comparison incorrect");
+            Expect.equal(field.Op, Op.NEX, "Operator incorrect");
         }),
         TestList("NameToPath",
         [
             TestCase("succeeds for PostgreSQL and a simple name", () =>
             {
-                Expect.equal("data->>'Simple'", Field.NameToPath("Simple", Dialect.PostgreSQL, FieldFormat.AsSql),
+                Expect.equal("data->>'Simple'", Field.NameToPath("Simple", Dialect.PostgreSQL),
                     "Path not constructed correctly");
             }),
             TestCase("succeeds for SQLite and a simple name", () =>
             {
-                Expect.equal("data->>'Simple'", Field.NameToPath("Simple", Dialect.SQLite, FieldFormat.AsSql),
+                Expect.equal("data->>'Simple'", Field.NameToPath("Simple", Dialect.SQLite),
                     "Path not constructed correctly");
             }),
             TestCase("succeeds for PostgreSQL and a nested name", () =>
             {
                 Expect.equal("data#>>'{A,Long,Path,to,the,Property}'",
-                    Field.NameToPath("A.Long.Path.to.the.Property", Dialect.PostgreSQL, FieldFormat.AsSql),
+                    Field.NameToPath("A.Long.Path.to.the.Property", Dialect.PostgreSQL),
                     "Path not constructed correctly");
             }),
             TestCase("succeeds for SQLite and a nested name", () =>
             {
-                Expect.equal("data->'A'->'Long'->'Path'->'to'->'the'->>'Property'",
+                Expect.equal("data->>'A'->>'Long'->>'Path'->>'to'->>'the'->>'Property'",
-                    Field.NameToPath("A.Long.Path.to.the.Property", Dialect.SQLite, FieldFormat.AsSql),
+                    Field.NameToPath("A.Long.Path.to.the.Property", Dialect.SQLite),
                     "Path not constructed correctly");
             })
         ]),
         TestCase("WithParameterName succeeds", () =>
         {
-            var field = Field.Equal("Bob", "Tom").WithParameterName("@name");
+            var field = Field.EQ("Bob", "Tom").WithParameterName("@name");
             Expect.isSome(field.ParameterName, "The parameter name should have been filled");
             Expect.equal("@name", field.ParameterName.Value, "The parameter name is incorrect");
         }),
         TestCase("WithQualifier succeeds", () =>
         {
-            var field = Field.Equal("Bill", "Matt").WithQualifier("joe");
+            var field = Field.EQ("Bill", "Matt").WithQualifier("joe");
             Expect.isSome(field.Qualifier, "The table qualifier should have been filled");
             Expect.equal("joe", field.Qualifier.Value, "The table qualifier is incorrect");
         }),
@@ -187,51 +171,48 @@ public static class CommonCSharpTests
         [
             TestCase("succeeds for a PostgreSQL single field with no qualifier", () =>
             {
-                var field = Field.GreaterOrEqual("SomethingCool", 18);
+                var field = Field.GE("SomethingCool", 18);
-                Expect.equal("data->>'SomethingCool'", field.Path(Dialect.PostgreSQL, FieldFormat.AsSql),
+                Expect.equal("data->>'SomethingCool'", field.Path(Dialect.PostgreSQL),
                     "The PostgreSQL path is incorrect");
             }),
             TestCase("succeeds for a PostgreSQL single field with a qualifier", () =>
             {
-                var field = Field.Less("SomethingElse", 9).WithQualifier("this");
+                var field = Field.LT("SomethingElse", 9).WithQualifier("this");
-                Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.PostgreSQL, FieldFormat.AsSql),
+                Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.PostgreSQL),
                     "The PostgreSQL path is incorrect");
             }),
             TestCase("succeeds for a PostgreSQL nested field with no qualifier", () =>
             {
-                var field = Field.Equal("My.Nested.Field", "howdy");
+                var field = Field.EQ("My.Nested.Field", "howdy");
-                Expect.equal("data#>>'{My,Nested,Field}'", field.Path(Dialect.PostgreSQL, FieldFormat.AsSql),
+                Expect.equal("data#>>'{My,Nested,Field}'", field.Path(Dialect.PostgreSQL),
                     "The PostgreSQL path is incorrect");
             }),
             TestCase("succeeds for a PostgreSQL nested field with a qualifier", () =>
             {
-                var field = Field.Equal("Nest.Away", "doc").WithQualifier("bird");
+                var field = Field.EQ("Nest.Away", "doc").WithQualifier("bird");
-                Expect.equal("bird.data#>>'{Nest,Away}'", field.Path(Dialect.PostgreSQL, FieldFormat.AsSql),
+                Expect.equal("bird.data#>>'{Nest,Away}'", field.Path(Dialect.PostgreSQL),
                     "The PostgreSQL path is incorrect");
             }),
             TestCase("succeeds for a SQLite single field with no qualifier", () =>
             {
-                var field = Field.GreaterOrEqual("SomethingCool", 18);
+                var field = Field.GE("SomethingCool", 18);
-                Expect.equal("data->>'SomethingCool'", field.Path(Dialect.SQLite, FieldFormat.AsSql),
+                Expect.equal("data->>'SomethingCool'", field.Path(Dialect.SQLite), "The SQLite path is incorrect");
-                    "The SQLite path is incorrect");
             }),
             TestCase("succeeds for a SQLite single field with a qualifier", () =>
             {
-                var field = Field.Less("SomethingElse", 9).WithQualifier("this");
+                var field = Field.LT("SomethingElse", 9).WithQualifier("this");
-                Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.SQLite, FieldFormat.AsSql),
+                Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.SQLite), "The SQLite path is incorrect");
-                    "The SQLite path is incorrect");
             }),
             TestCase("succeeds for a SQLite nested field with no qualifier", () =>
             {
-                var field = Field.Equal("My.Nested.Field", "howdy");
+                var field = Field.EQ("My.Nested.Field", "howdy");
-                Expect.equal("data->'My'->'Nested'->>'Field'", field.Path(Dialect.SQLite, FieldFormat.AsSql),
+                Expect.equal("data->>'My'->>'Nested'->>'Field'", field.Path(Dialect.SQLite),
                     "The SQLite path is incorrect");
             }),
             TestCase("succeeds for a SQLite nested field with a qualifier", () =>
             {
-                var field = Field.Equal("Nest.Away", "doc").WithQualifier("bird");
+                var field = Field.EQ("Nest.Away", "doc").WithQualifier("bird");
-                Expect.equal("bird.data->'Nest'->>'Away'", field.Path(Dialect.SQLite, FieldFormat.AsSql),
+                Expect.equal("bird.data->>'Nest'->>'Away'", field.Path(Dialect.SQLite), "The SQLite path is incorrect");
-                    "The SQLite path is incorrect");
             })
         ])
     ]);
@@ -548,7 +529,7 @@ public static class CommonCSharpTests
                 {
                     Expect.equal(
                         Query.Definition.EnsureIndexOn("tbl", "nest", ["a.b.c"], Dialect.SQLite),
-                        "CREATE INDEX IF NOT EXISTS idx_tbl_nest ON tbl ((data->'a'->'b'->>'c'))",
+                        "CREATE INDEX IF NOT EXISTS idx_tbl_nest ON tbl ((data->>'a'->>'b'->>'c'))",
                         "CREATE INDEX for nested SQLite field incorrect");
                 })
             ])
@@ -620,7 +601,7 @@ public static class CommonCSharpTests
                             Field.Named("Nested.Test.Field DESC"), Field.Named("AnotherField"),
                             Field.Named("It DESC")
                         ], Dialect.SQLite),
-                    " ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
+                    " ORDER BY data->>'Nested'->>'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
                     "Order By not constructed correctly");
             }),
             TestCase("succeeds for PostgreSQL numeric fields", () =>
@@ -632,18 +613,6 @@ public static class CommonCSharpTests
             {
                 Expect.equal(Query.OrderBy([Field.Named("n:Test")], Dialect.SQLite), " ORDER BY data->>'Test'",
                     "Order By not constructed correctly for numeric field");
-            }),
-            TestCase("succeeds for PostgreSQL case-insensitive ordering", () =>
-            {
-                Expect.equal(Query.OrderBy([Field.Named("i:Test.Field DESC NULLS FIRST")], Dialect.PostgreSQL),
-                    " ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST",
-                    "Order By not constructed correctly for case-insensitive field");
-            }),
-            TestCase("succeeds for SQLite case-insensitive ordering", () =>
-            {
-                Expect.equal(Query.OrderBy([Field.Named("i:Test.Field ASC NULLS LAST")], Dialect.SQLite),
-                    " ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST",
-                    "Order By not constructed correctly for case-insensitive field");
             })
         ])
     ]);

src/Tests.CSharp/PostgresCSharpExtensionTests.cs

@@ -205,7 +205,7 @@ public class PostgresCSharpExtensionTests
                 }
             })
         ]),
-        TestList("Save",
+        TestList("save",
         [
             TestCase("succeeds when a document is inserted", async () =>
             {
@@ -253,7 +253,7 @@ public class PostgresCSharpExtensionTests
             await LoadDocs();
 
             var theCount = await conn.CountByFields(PostgresDb.TableName, FieldMatch.Any,
-                [Field.Equal("Value", "purple")]);
+                [Field.EQ("Value", "purple")]);
             Expect.equal(theCount, 2, "There should have been 2 matching documents");
         }),
         TestCase("CountByContains succeeds", async () =>
@@ -303,7 +303,7 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                var exists = await conn.ExistsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Exists("Sub")]);
+                var exists = await conn.ExistsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EX("Sub")]);
                 Expect.isTrue(exists, "There should have been existing documents");
             }),
             TestCase("succeeds when documents do not exist", async () =>
@@ -313,7 +313,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var exists =
-                    await conn.ExistsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "six")]);
+                    await conn.ExistsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "six")]);
                 Expect.isFalse(exists, "There should not have been existing documents");
             })
         ]),
@@ -450,7 +450,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
                 Expect.equal(docs.Count, 1, "There should have been one document returned");
             }),
             TestCase("succeeds when documents are not found", async () =>
@@ -460,7 +460,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "mauve")]);
+                    [Field.EQ("Value", "mauve")]);
                 Expect.isEmpty(docs, "There should have been no documents returned");
             })
         ]),
@@ -473,7 +473,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id")]);
                 Expect.hasLength(docs, 2, "There should have been two document returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "five|four",
                     "The documents were not ordered correctly");
@@ -485,7 +485,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id DESC")]);
                 Expect.hasLength(docs, 2, "There should have been two document returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "four|five",
                     "The documents were not ordered correctly");
@@ -599,7 +599,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal(doc.Id, "two", "The incorrect document was returned");
             }),
@@ -610,7 +610,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")]);
+                    [Field.EQ("Value", "purple")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.contains(["five", "four"], doc.Id, "An incorrect document was returned");
             }),
@@ -621,7 +621,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "absent")]);
+                    [Field.EQ("Value", "absent")]);
                 Expect.isNull(doc, "There should not have been a document returned");
             })
         ]),
@@ -634,7 +634,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("five", doc.Id, "An incorrect document was returned");
             }),
@@ -645,7 +645,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id DESC")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("four", doc.Id, "An incorrect document was returned");
             })
@@ -859,10 +859,10 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                await conn.PatchByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "purple")],
+                await conn.PatchByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")],
                     new { NumValue = 77 });
                 var after = await conn.CountByFields(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("NumValue", 77)]);
+                    [Field.EQ("NumValue", "77")]);
                 Expect.equal(after, 2, "There should have been 2 documents returned");
             }),
             TestCase("succeeds when no document is updated", async () =>
@@ -873,7 +873,7 @@ public class PostgresCSharpExtensionTests
                 Expect.equal(before, 0, "There should have been no documents returned");
                 
                 // This not raising an exception is the test
-                await conn.PatchByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "burgundy")],
+                await conn.PatchByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "burgundy")],
                     new { Foo = "green" });
             })
         ]),
@@ -975,7 +975,7 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Sub", "Value"]);
                 var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
@@ -988,7 +988,7 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Sub"]);
                 var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
@@ -1002,7 +1002,7 @@ public class PostgresCSharpExtensionTests
                 await LoadDocs();
                     
                 // This not raising an exception is the test
-                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Nothing"]);
             }),
             TestCase("succeeds when no document is matched", async () =>
@@ -1012,7 +1012,7 @@ public class PostgresCSharpExtensionTests
                 
                 // This not raising an exception is the test
                 await conn.RemoveFieldsByFields(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.NotEqual("Abracadabra", "apple")], ["Value"]);
+                    [Field.NE("Abracadabra", "apple")], ["Value"]);
             })
         ]),
         TestList("RemoveFieldsByContains",
@@ -1134,7 +1134,7 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                await conn.DeleteByFields(PostgresDb.TableName, FieldMatch.Any, [Field.NotEqual("Value", "purple")]);
+                await conn.DeleteByFields(PostgresDb.TableName, FieldMatch.Any, [Field.NE("Value", "purple")]);
                 var remaining = await conn.CountAll(PostgresDb.TableName);
                 Expect.equal(remaining, 2, "There should have been 2 documents remaining");
             }),
@@ -1144,7 +1144,7 @@ public class PostgresCSharpExtensionTests
                 await using var conn = MkConn(db);
                 await LoadDocs();
 
-                await conn.DeleteByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "crimson")]);
+                await conn.DeleteByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "crimson")]);
                 var remaining = await conn.CountAll(PostgresDb.TableName);
                 Expect.equal(remaining, 5, "There should have been 5 documents remaining");
             })

src/Tests.CSharp/PostgresCSharpTests.cs

@@ -111,7 +111,7 @@ public static class PostgresCSharpTests
         [
             TestCase("succeeds when a parameter is added", () =>
             {
-                var paramList = Parameters.AddFields([Field.Equal("it", "242")], []).ToList();
+                var paramList = Parameters.AddFields([Field.EQ("it", "242")], []).ToList();
                 Expect.hasLength(paramList, 1, "There should have been a parameter added");
                 var (name, value) = paramList[0];
                 Expect.equal(name, "@field0", "Field parameter name not correct");
@@ -119,7 +119,7 @@ public static class PostgresCSharpTests
             }),
             TestCase("succeeds when multiple independent parameters are added", () =>
             {
-                var paramList = Parameters.AddFields([Field.Equal("me", "you"), Field.Greater("us", "them")],
+                var paramList = Parameters.AddFields([Field.EQ("me", "you"), Field.GT("us", "them")],
                     [Parameters.Id(14)]).ToList();
                 Expect.hasLength(paramList, 3, "There should have been 2 parameters added");
                 var (name, value) = paramList[0];
@@ -134,13 +134,13 @@ public static class PostgresCSharpTests
             }),
             TestCase("succeeds when a parameter is not added", () =>
             {
-                var paramList = Parameters.AddFields([Field.Exists("tacos")], []).ToList();
+                var paramList = Parameters.AddFields([Field.EX("tacos")], []).ToList();
                 Expect.isEmpty(paramList, "There should not have been any parameters added");
             }),
             TestCase("succeeds when two parameters are added for one field", () =>
             {
                 var paramList =
-                    Parameters.AddFields([Field.Between("that", "eh", "zed").WithParameterName("@test")], []).ToList();
+                    Parameters.AddFields([Field.BT("that", "eh", "zed").WithParameterName("@test")], []).ToList();
                 Expect.hasLength(paramList, 2, "There should have been 2 parameters added");
                 var (name, value) = paramList[0];
                 Expect.equal(name, "@testmin", "Minimum field name not correct");
@@ -184,60 +184,54 @@ public static class PostgresCSharpTests
     [
         TestList("WhereByFields",
         [
-            TestCase("succeeds for a single field when a logical comparison is passed", () =>
+            TestCase("succeeds for a single field when a logical operator is passed", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.Any,
-                        [Field.Greater("theField", "0").WithParameterName("@test")]),
+                        [Field.GT("theField", "0").WithParameterName("@test")]),
                     "data->>'theField' > @test", "WHERE clause not correct");
             }),
-            TestCase("succeeds for a single field when an existence comparison is passed", () =>
+            TestCase("succeeds for a single field when an existence operator is passed", () =>
             {
-                Expect.equal(Postgres.Query.WhereByFields(FieldMatch.Any, [Field.NotExists("thatField")]),
+                Expect.equal(Postgres.Query.WhereByFields(FieldMatch.Any, [Field.NEX("thatField")]),
                     "data->>'thatField' IS NULL", "WHERE clause not correct");
             }),
-            TestCase("succeeds for a single field when a between comparison is passed with numeric values", () =>
+            TestCase("succeeds for a single field when a between operator is passed with numeric values", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.All,
-                        [Field.Between("aField", 50, 99).WithParameterName("@range")]),
+                        [Field.BT("aField", 50, 99).WithParameterName("@range")]),
                     "(data->>'aField')::numeric BETWEEN @rangemin AND @rangemax", "WHERE clause not correct");
             }),
-            TestCase("succeeds for a single field when a between comparison is passed with non-numeric values", () =>
+            TestCase("succeeds for a single field when a between operator is passed with non-numeric values", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.Any,
-                        [Field.Between("field0", "a", "b").WithParameterName("@alpha")]),
+                        [Field.BT("field0", "a", "b").WithParameterName("@alpha")]),
                     "data->>'field0' BETWEEN @alphamin AND @alphamax", "WHERE clause not correct");
             }),
-            TestCase("succeeds for all multiple fields with logical comparisons", () =>
+            TestCase("succeeds for all multiple fields with logical operators", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.All,
-                        [Field.Equal("theFirst", "1"), Field.Equal("numberTwo", "2")]),
+                        [Field.EQ("theFirst", "1"), Field.EQ("numberTwo", "2")]),
                     "data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1", "WHERE clause not correct");
             }),
-            TestCase("succeeds for any multiple fields with an existence comparison", () =>
+            TestCase("succeeds for any multiple fields with an existence operator", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.Any,
-                        [Field.NotExists("thatField"), Field.GreaterOrEqual("thisField", 18)]),
+                        [Field.NEX("thatField"), Field.GE("thisField", 18)]),
                     "data->>'thatField' IS NULL OR (data->>'thisField')::numeric >= @field0",
                     "WHERE clause not correct");
             }),
-            TestCase("succeeds for all multiple fields with between comparisons", () =>
+            TestCase("succeeds for all multiple fields with between operators", () =>
             {
                 Expect.equal(
                     Postgres.Query.WhereByFields(FieldMatch.All,
-                        [Field.Between("aField", 50, 99), Field.Between("anotherField", "a", "b")]),
+                        [Field.BT("aField", 50, 99), Field.BT("anotherField", "a", "b")]),
                     "(data->>'aField')::numeric BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max",
                     "WHERE clause not correct");
-            }),
-            TestCase("succeeds for a field with an InArray comparison", () =>
-            {
-                Expect.equal(
-                    Postgres.Query.WhereByFields(FieldMatch.All, [Field.InArray("theField", "the_table", ["q", "r"])]),
-                        "data->'theField' ?| @field0", "WHERE clause not correct");
             })
         ]),
         TestList("WhereById",
@@ -305,7 +299,7 @@ public static class PostgresCSharpTests
         }),
         TestCase("ByFields succeeds", () =>
         {
-            Expect.equal(Postgres.Query.ByFields("unit", FieldMatch.Any, [Field.Greater("That", 14)]),
+            Expect.equal(Postgres.Query.ByFields("unit", FieldMatch.Any, [Field.GT("That", 14)]),
                 "unit WHERE (data->>'That')::numeric > @field0", "By-Field query not correct");
         }),
         TestCase("ByContains succeeds", () =>
@@ -320,12 +314,21 @@ public static class PostgresCSharpTests
         })
     ]);
     
+    private static readonly List<JsonDocument> TestDocuments =
+    [
+        new() { Id = "one", Value = "FIRST!", NumValue = 0 },
+        new() { Id = "two", Value = "another", NumValue = 10, Sub = new() { Foo = "green", Bar = "blue" } },
+        new() { Id = "three", Value = "", NumValue = 4 },
+        new() { Id = "four", Value = "purple", NumValue = 17, Sub = new() { Foo = "green", Bar = "red" } },
+        new() { Id = "five", Value = "purple", NumValue = 18 }
+    ];
+
     /// <summary>
     /// Add the test documents to the database
     /// </summary>
     internal static async Task LoadDocs()
     {
-        foreach (var doc in JsonDocument.TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
+        foreach (var doc in TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
     }
 
     /// <summary>
@@ -673,7 +676,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var theCount = await Count.ByFields(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Between("NumValue", 10, 20)]);
+                    [Field.BT("NumValue", 10, 20)]);
                 Expect.equal(theCount, 3, "There should have been 3 matching documents");
             }),
             TestCase("succeeds for non-numeric range", async () =>
@@ -682,7 +685,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var theCount = await Count.ByFields(PostgresDb.TableName, FieldMatch.All,
-                    [Field.Between("Value", "aardvark", "apple")]);
+                    [Field.BT("Value", "aardvark", "apple")]);
                 Expect.equal(theCount, 1, "There should have been 1 matching document");
             })
         ]),
@@ -735,7 +738,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                var exists = await Exists.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.NotExists("Sub")]);
+                var exists = await Exists.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.NEX("Sub")]);
                 Expect.isTrue(exists, "There should have been existing documents");
             }),
             TestCase("succeeds when documents do not exist", async () =>
@@ -743,8 +746,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                var exists = await Exists.ByFields(PostgresDb.TableName, FieldMatch.Any,
+                var exists = await Exists.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "six")]);
-                    [Field.Equal("NumValue", "six")]);
                 Expect.isFalse(exists, "There should not have been existing documents");
             })
         ]),
@@ -876,16 +878,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
-                Expect.hasLength(docs, 1, "There should have been one document returned");
-            }),
-            TestCase("succeeds when documents are found using IN with numeric field", async () =>
-            {
-                await using var db = PostgresDb.BuildDb();
-                await LoadDocs();
-
-                var docs = await Find.ByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.All,
-                    [Field.In("NumValue", [2, 4, 6, 8])]);
                 Expect.hasLength(docs, 1, "There should have been one document returned");
             }),
             TestCase("succeeds when documents are not found", async () =>
@@ -894,27 +887,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "mauve")]);
+                    [Field.EQ("Value", "mauve")]);
-                Expect.isEmpty(docs, "There should have been no documents returned");
-            }),
-            TestCase("succeeds for InArray when matching documents exist", async () =>
-            {
-                await using var db = PostgresDb.BuildDb();
-                await Definition.EnsureTable(PostgresDb.TableName);
-                foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(PostgresDb.TableName, doc);
-
-                var docs = await Find.ByFields<ArrayDocument>(PostgresDb.TableName, FieldMatch.All,
-                    [Field.InArray("Values", PostgresDb.TableName, ["c"])]);
-                Expect.hasLength(docs, 2, "There should have been two document returned");
-            }),
-            TestCase("succeeds for InArray when no matching documents exist", async () =>
-            {
-                await using var db = PostgresDb.BuildDb();
-                await Definition.EnsureTable(PostgresDb.TableName);
-                foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(PostgresDb.TableName, doc);
-
-                var docs = await Find.ByFields<ArrayDocument>(PostgresDb.TableName, FieldMatch.All,
-                    [Field.InArray("Values", PostgresDb.TableName, ["j"])]);
                 Expect.isEmpty(docs, "There should have been no documents returned");
             })
         ]),
@@ -926,7 +899,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id")]);
                 Expect.hasLength(docs, 2, "There should have been two document returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "five|four",
                     "The documents were not ordered correctly");
@@ -937,7 +910,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id DESC")]);
                 Expect.hasLength(docs, 2, "There should have been two document returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "four|five",
                     "The documents were not ordered correctly");
@@ -1042,7 +1015,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal(doc.Id, "two", "The incorrect document was returned");
             }),
@@ -1052,7 +1025,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")]);
+                    [Field.EQ("Value", "purple")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.contains(["five", "four"], doc.Id, "An incorrect document was returned");
             }),
@@ -1062,7 +1035,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "absent")]);
+                    [Field.EQ("Value", "absent")]);
                 Expect.isNull(doc, "There should not have been a document returned");
             })
         ]),
@@ -1074,7 +1047,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("five", doc.Id, "An incorrect document was returned");
             }),
@@ -1084,7 +1057,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFieldsOrdered<JsonDocument>(PostgresDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
+                    [Field.EQ("Value", "purple")], [Field.Named("Id DESC")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("four", doc.Id, "An incorrect document was returned");
             })
@@ -1298,9 +1271,9 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                await Patch.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "purple")],
+                await Patch.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")],
                     new { NumValue = 77 });
-                var after = await Count.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "77")]);
+                var after = await Count.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "77")]);
                 Expect.equal(after, 2, "There should have been 2 documents returned");
             }),
             TestCase("succeeds when no document is updated", async () =>
@@ -1311,7 +1284,7 @@ public static class PostgresCSharpTests
                 Expect.equal(before, 0, "There should have been no documents returned");
 
                 // This not raising an exception is the test
-                await Patch.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "burgundy")],
+                await Patch.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "burgundy")],
                     new { Foo = "green" });
             })
         ]),
@@ -1413,7 +1386,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Sub", "Value"]);
                 var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
@@ -1425,7 +1398,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Sub"]);
                 var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
@@ -1438,7 +1411,7 @@ public static class PostgresCSharpTests
                 await LoadDocs();
 
                 // This not raising an exception is the test
-                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", "17")],
+                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", "17")],
                     ["Nothing"]);
             }),
             TestCase("succeeds when no document is matched", async () =>
@@ -1446,8 +1419,8 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
 
                 // This not raising an exception is the test
-                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any,
+                await RemoveFields.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.NE("Abracadabra", "apple")],
-                    [Field.NotEqual("Abracadabra", "apple")], ["Value"]);
+                    ["Value"]);
             })
         ]),
         TestList("ByContains",
@@ -1565,7 +1538,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                await Delete.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "purple")]);
+                await Delete.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")]);
                 var remaining = await Count.All(PostgresDb.TableName);
                 Expect.equal(remaining, 3, "There should have been 3 documents remaining");
             }),
@@ -1574,7 +1547,7 @@ public static class PostgresCSharpTests
                 await using var db = PostgresDb.BuildDb();
                 await LoadDocs();
 
-                await Delete.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.Equal("Value", "crimson")]);
+                await Delete.ByFields(PostgresDb.TableName, FieldMatch.Any, [Field.EQ("Value", "crimson")]);
                 var remaining = await Count.All(PostgresDb.TableName);
                 Expect.equal(remaining, 5, "There should have been 5 documents remaining");
             })

src/Tests.CSharp/PostgresDb.cs

@@ -1,3 +1,4 @@
+using BitBadger.Documents.Postgres;
 using Npgsql;
 using Npgsql.FSharp;
 using ThrowawayDb.Postgres;

src/Tests.CSharp/SqliteCSharpExtensionTests.cs

@@ -221,8 +221,7 @@ public static class SqliteCSharpExtensionTests
             await using var conn = Sqlite.Configuration.DbConn();
             await LoadDocs();
 
-            var theCount = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any,
+            var theCount = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")]);
-                [Field.Equal("Value", "purple")]);
             Expect.equal(theCount, 2L, "There should have been 2 matching documents");
         }),
         TestList("ExistsById",
@@ -254,8 +253,7 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 await LoadDocs();
 
-                var exists = await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any,
+                var exists = await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.GE("NumValue", 10)]);
-                    [Field.GreaterOrEqual("NumValue", 10)]);
                 Expect.isTrue(exists, "There should have been existing documents");
             }),
             TestCase("succeeds when no matching documents exist", async () =>
@@ -265,7 +263,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var exists =
-                    await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Nothing", "none")]);
+                    await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Nothing", "none")]);
                 Expect.isFalse(exists, "There should not have been any existing documents");
             })
         ]),
@@ -359,7 +357,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)]);
+                    [Field.GT("NumValue", 15)]);
                 Expect.equal(docs.Count, 2, "There should have been two documents returned");
             }),
             TestCase("succeeds when documents are not found", async () =>
@@ -369,7 +367,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "mauve")]);
+                    [Field.EQ("Value", "mauve")]);
                 Expect.isEmpty(docs, "There should have been no documents returned");
             })
         ]),
@@ -382,7 +380,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)], [Field.Named("Id")]);
+                    [Field.GT("NumValue", 15)], [Field.Named("Id")]);
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "five|four",
                     "There should have been two documents returned");
             }),
@@ -393,7 +391,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var docs = await conn.FindByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)], [Field.Named("Id DESC")]);
+                    [Field.GT("NumValue", 15)], [Field.Named("Id DESC")]);
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "four|five",
                     "There should have been two documents returned");
             })
@@ -407,7 +405,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal(doc!.Id, "two", "The incorrect document was returned");
             }),
@@ -418,7 +416,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")]);
+                    [Field.EQ("Sub.Foo", "green")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.contains(["two", "four"], doc!.Id, "An incorrect document was returned");
             }),
@@ -429,7 +427,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "absent")]);
+                    [Field.EQ("Value", "absent")]);
                 Expect.isNull(doc, "There should not have been a document returned");
             })
         ]),
@@ -442,7 +440,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")], [Field.Named("Sub.Bar")]);
+                    [Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("two", doc!.Id, "An incorrect document was returned");
             }),
@@ -453,7 +451,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
 
                 var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")], [Field.Named("Sub.Bar DESC")]);
+                    [Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar DESC")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("four", doc!.Id, "An incorrect document was returned");
             })
@@ -549,9 +547,9 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 await LoadDocs();
 
-                await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Value", "purple")],
+                await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")],
                     new { NumValue = 77 });
-                var after = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 77)]);
+                var after = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 77)]);
                 Expect.equal(after, 2L, "There should have been 2 documents returned");
             }),
             TestCase("succeeds when no document is updated", async () =>
@@ -562,7 +560,7 @@ public static class SqliteCSharpExtensionTests
                 Expect.isEmpty(before, "There should have been no documents returned");
 
                 // This not raising an exception is the test
-                await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Value", "burgundy")],
+                await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "burgundy")],
                     new { Foo = "green" });
             })
         ]),
@@ -606,7 +604,7 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 await LoadDocs();
 
-                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 17)],
+                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)],
                     ["Sub"]);
                 var updated = await Find.ById<string, JsonDocument>(SqliteDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
@@ -619,7 +617,7 @@ public static class SqliteCSharpExtensionTests
                 await LoadDocs();
                     
                 // This not raising an exception is the test
-                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 17)],
+                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)],
                     ["Nothing"]);
             }),
             TestCase("succeeds when no document is matched", async () =>
@@ -628,8 +626,8 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 
                 // This not raising an exception is the test
-                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any,
+                await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Abracadabra", "apple")],
-                    [Field.NotEqual("Abracadabra", "apple")], ["Value"]);
+                    ["Value"]);
             })
         ]),
         TestList("DeleteById",
@@ -663,7 +661,7 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 await LoadDocs();
 
-                await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NotEqual("Value", "purple")]);
+                await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Value", "purple")]);
                 var remaining = await conn.CountAll(SqliteDb.TableName);
                 Expect.equal(remaining, 2L, "There should have been 2 documents remaining");
             }),
@@ -673,7 +671,7 @@ public static class SqliteCSharpExtensionTests
                 await using var conn = Sqlite.Configuration.DbConn();
                 await LoadDocs();
 
-                await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Value", "crimson")]);
+                await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "crimson")]);
                 var remaining = await conn.CountAll(SqliteDb.TableName);
                 Expect.equal(remaining, 5L, "There should have been 5 documents remaining");
             })

src/Tests.CSharp/SqliteCSharpTests.cs

@@ -22,55 +22,40 @@ public static class SqliteCSharpTests
             TestCase("succeeds for a single field when a logical operator is passed", () =>
             {
                 Expect.equal(
-                    Sqlite.Query.WhereByFields(FieldMatch.Any,
+                    Sqlite.Query.WhereByFields(FieldMatch.Any, [Field.GT("theField", 0).WithParameterName("@test")]),
-                        [Field.Greater("theField", 0).WithParameterName("@test")]),
                     "data->>'theField' > @test", "WHERE clause not correct");
             }),
             TestCase("succeeds for a single field when an existence operator is passed", () =>
             {
-                Expect.equal(Sqlite.Query.WhereByFields(FieldMatch.Any, [Field.NotExists("thatField")]),
+                Expect.equal(Sqlite.Query.WhereByFields(FieldMatch.Any, [Field.NEX("thatField")]),
                     "data->>'thatField' IS NULL", "WHERE clause not correct");
             }),
             TestCase("succeeds for a single field when a between operator is passed", () =>
             {
                 Expect.equal(
                     Sqlite.Query.WhereByFields(FieldMatch.All,
-                        [Field.Between("aField", 50, 99).WithParameterName("@range")]),
+                        [Field.BT("aField", 50, 99).WithParameterName("@range")]),
                     "data->>'aField' BETWEEN @rangemin AND @rangemax", "WHERE clause not correct");
             }),
             TestCase("succeeds for all multiple fields with logical operators", () =>
             {
                 Expect.equal(
-                    Sqlite.Query.WhereByFields(FieldMatch.All,
+                    Sqlite.Query.WhereByFields(FieldMatch.All, [Field.EQ("theFirst", "1"), Field.EQ("numberTwo", "2")]),
-                        [Field.Equal("theFirst", "1"), Field.Equal("numberTwo", "2")]),
                     "data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1", "WHERE clause not correct");
             }),
             TestCase("succeeds for any multiple fields with an existence operator", () =>
             {
                 Expect.equal(
-                    Sqlite.Query.WhereByFields(FieldMatch.Any,
+                    Sqlite.Query.WhereByFields(FieldMatch.Any, [Field.NEX("thatField"), Field.GE("thisField", 18)]),
-                        [Field.NotExists("thatField"), Field.GreaterOrEqual("thisField", 18)]),
                     "data->>'thatField' IS NULL OR data->>'thisField' >= @field0", "WHERE clause not correct");
             }),
             TestCase("succeeds for all multiple fields with between operators", () =>
             {
                 Expect.equal(
                     Sqlite.Query.WhereByFields(FieldMatch.All,
-                        [Field.Between("aField", 50, 99), Field.Between("anotherField", "a", "b")]),
+                        [Field.BT("aField", 50, 99), Field.BT("anotherField", "a", "b")]),
                     "data->>'aField' BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max",
                     "WHERE clause not correct");
-            }),
-            TestCase("succeeds for a field with an In comparison", () =>
-            {
-                Expect.equal(Sqlite.Query.WhereByFields(FieldMatch.All, [Field.In("this", ["a", "b", "c"])]),
-                    "data->>'this' IN (@field0_0, @field0_1, @field0_2)", "WHERE clause not correct");
-            }),
-            TestCase("succeeds for a field with an InArray comparison", () =>
-            {
-                Expect.equal(
-                    Sqlite.Query.WhereByFields(FieldMatch.All, [Field.InArray("this", "the_table", ["a", "b"])]),
-                    "EXISTS (SELECT 1 FROM json_each(the_table.data, '$.this') WHERE value IN (@field0_0, @field0_1))",
-                    "WHERE clause not correct");
             })
         ]),
         TestCase("WhereById succeeds", () =>
@@ -94,7 +79,7 @@ public static class SqliteCSharpTests
         }),
         TestCase("ByFields succeeds", () =>
         {
-            Expect.equal(Sqlite.Query.ByFields("unit", FieldMatch.Any, [Field.Greater("That", 14)]),
+            Expect.equal(Sqlite.Query.ByFields("unit", FieldMatch.Any, [Field.GT("That", 14)]),
                 "unit WHERE data->>'That' > @field0", "By-Field query not correct");
         }),
         TestCase("Definition.EnsureTable succeeds", () =>
@@ -124,7 +109,7 @@ public static class SqliteCSharpTests
 #pragma warning disable CS0618
         TestCase("AddField succeeds when adding a parameter", () =>
         {
-            var paramList = Parameters.AddField("@field", Field.Equal("it", 99), []).ToList();
+            var paramList = Parameters.AddField("@field", Field.EQ("it", 99), []).ToList();
             Expect.hasLength(paramList, 1, "There should have been a parameter added");
             var theParam = paramList[0];
             Expect.equal(theParam.ParameterName, "@field", "The parameter name is incorrect");
@@ -132,7 +117,7 @@ public static class SqliteCSharpTests
         }),
         TestCase("AddField succeeds when not adding a parameter", () =>
         {
-            var paramSeq = Parameters.AddField("@it", Field.Exists("Coffee"), []);
+            var paramSeq = Parameters.AddField("@it", Field.EX("Coffee"), []);
             Expect.isEmpty(paramSeq, "There should not have been any parameters added");
         }),
 #pragma warning restore CS0618
@@ -144,12 +129,24 @@ public static class SqliteCSharpTests
     
     // Results are exhaustively executed in the context of other tests
     
+    /// <summary>
+    /// Documents used for integration tests
+    /// </summary>
+    private static readonly List<JsonDocument> TestDocuments =
+    [
+        new() { Id = "one", Value = "FIRST!", NumValue = 0 },
+        new() { Id = "two", Value = "another", NumValue = 10, Sub = new() { Foo = "green", Bar = "blue" } },
+        new() { Id = "three", Value = "", NumValue = 4 },
+        new() { Id = "four", Value = "purple", NumValue = 17, Sub = new() { Foo = "green", Bar = "red" } },
+        new() { Id = "five", Value = "purple", NumValue = 18 }
+    ];
+
     /// <summary>
     /// Add the test documents to the database
     /// </summary>
     internal static async Task LoadDocs()
     {
-        foreach (var doc in JsonDocument.TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
+        foreach (var doc in TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
     }
 
     /// <summary>
@@ -462,8 +459,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                var theCount = await Count.ByFields(SqliteDb.TableName, FieldMatch.Any,
+                var theCount = await Count.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.BT("NumValue", 10, 20)]);
-                    [Field.Between("NumValue", 10, 20)]);
                 Expect.equal(theCount, 3L, "There should have been 3 matching documents");
             }),
             TestCase("succeeds for non-numeric range", async () =>
@@ -472,7 +468,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var theCount = await Count.ByFields(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Between("Value", "aardvark", "apple")]);
+                    [Field.BT("Value", "aardvark", "apple")]);
                 Expect.equal(theCount, 1L, "There should have been 1 matching document");
             })
         ])
@@ -509,8 +505,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                var exists = await Exists.ByFields(SqliteDb.TableName, FieldMatch.Any,
+                var exists = await Exists.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.GE("NumValue", 10)]);
-                    [Field.GreaterOrEqual("NumValue", 10)]);
                 Expect.isTrue(exists, "There should have been existing documents");
             }),
             TestCase("succeeds when no matching documents exist", async () =>
@@ -518,8 +513,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                var exists = await Exists.ByFields(SqliteDb.TableName, FieldMatch.Any,
+                var exists = await Exists.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Nothing", "none")]);
-                    [Field.Equal("Nothing", "none")]);
                 Expect.isFalse(exists, "There should not have been any existing documents");
             })
         ])
@@ -611,45 +605,16 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)]);
+                    [Field.GT("NumValue", 15)]);
                 Expect.equal(docs.Count, 2, "There should have been two documents returned");
             }),
-            TestCase("succeeds when documents are found using IN with numeric field", async () =>
-            {
-                await using var db = await SqliteDb.BuildDb();
-                await LoadDocs();
-
-                var docs = await Find.ByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.All,
-                    [Field.In("NumValue", [2, 4, 6, 8])]);
-                Expect.hasLength(docs, 1, "There should have been one document returned");
-            }),
             TestCase("succeeds when documents are not found", async () =>
             {
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
                 var docs = await Find.ByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "mauve")]);
+                    [Field.EQ("Value", "mauve")]);
-                Expect.isEmpty(docs, "There should have been no documents returned");
-            }),
-            TestCase("succeeds for InArray when matching documents exist", async () =>
-            {
-                await using var db = await SqliteDb.BuildDb();
-                await Definition.EnsureTable(SqliteDb.TableName);
-                foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
-
-                var docs = await Find.ByFields<ArrayDocument>(SqliteDb.TableName, FieldMatch.All,
-                    [Field.InArray("Values", SqliteDb.TableName, ["c"])]);
-                Expect.hasLength(docs, 2, "There should have been two document returned");
-            }),
-            TestCase("succeeds for InArray when no matching documents exist", async () =>
-            {
-                await using var db = await SqliteDb.BuildDb();
-                await Definition.EnsureTable(SqliteDb.TableName);
-                foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
-
-                var docs = await Find.ByFields<ArrayDocument>(SqliteDb.TableName, FieldMatch.All,
-                    [Field.InArray("Values", SqliteDb.TableName, ["j"])]);
                 Expect.isEmpty(docs, "There should have been no documents returned");
             })
         ]),
@@ -661,10 +626,9 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)], [Field.Named("Id")]);
+                    [Field.GT("NumValue", 15)], [Field.Named("Id")]);
-                Expect.hasLength(docs, 2, "There should have been two documents returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "five|four",
-                    "The documents were not sorted correctly");
+                    "There should have been two documents returned");
             }),
             TestCase("succeeds when documents are not found", async () =>
             {
@@ -672,32 +636,9 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var docs = await Find.ByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Greater("NumValue", 15)], [Field.Named("Id DESC")]);
+                    [Field.GT("NumValue", 15)], [Field.Named("Id DESC")]);
-                Expect.hasLength(docs, 2, "There should have been two documents returned");
                 Expect.equal(string.Join('|', docs.Select(x => x.Id)), "four|five",
-                    "The documents were not sorted correctly");
+                    "There should have been two documents returned");
-            }),
-            TestCase("succeeds when sorting case-sensitively", async () =>
-            {
-                await using var db = await SqliteDb.BuildDb();
-                await LoadDocs();
-
-                var docs = await Find.ByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.LessOrEqual("NumValue", 10)], [Field.Named("Value")]);
-                Expect.hasLength(docs, 3, "There should have been three documents returned");
-                Expect.equal(string.Join('|', docs.Select(x => x.Id)), "three|one|two",
-                    "The documents were not sorted correctly");
-            }),
-            TestCase("succeeds when sorting case-insensitively", async () =>
-            {
-                await using var db = await SqliteDb.BuildDb();
-                await LoadDocs();
-
-                var docs = await Find.ByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.LessOrEqual("NumValue", 10)], [Field.Named("i:Value")]);
-                Expect.hasLength(docs, 3, "There should have been three documents returned");
-                Expect.equal(string.Join('|', docs.Select(x => x.Id)), "three|two|one",
-                    "The documents were not sorted correctly");
             })
         ]),
         TestList("FirstByFields",
@@ -708,7 +649,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "another")]);
+                    [Field.EQ("Value", "another")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal(doc!.Id, "two", "The incorrect document was returned");
             }),
@@ -718,7 +659,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")]);
+                    [Field.EQ("Sub.Foo", "green")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.contains(["two", "four"], doc!.Id, "An incorrect document was returned");
             }),
@@ -728,7 +669,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Value", "absent")]);
+                    [Field.EQ("Value", "absent")]);
                 Expect.isNull(doc, "There should not have been a document returned");
             })
         ]),
@@ -740,7 +681,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")], [Field.Named("Sub.Bar")]);
+                    [Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("two", doc!.Id, "An incorrect document was returned");
             }),
@@ -750,7 +691,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 var doc = await Find.FirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
-                    [Field.Equal("Sub.Foo", "green")], [Field.Named("Sub.Bar DESC")]);
+                    [Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar DESC")]);
                 Expect.isNotNull(doc, "There should have been a document returned");
                 Expect.equal("four", doc!.Id, "An incorrect document was returned");
             })
@@ -856,9 +797,9 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                await Patch.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Value", "purple")],
+                await Patch.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")],
                     new { NumValue = 77 });
-                var after = await Count.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 77)]);
+                var after = await Count.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 77)]);
                 Expect.equal(after, 2L, "There should have been 2 documents returned");
             }),
             TestCase("succeeds when no document is updated", async () =>
@@ -869,7 +810,7 @@ public static class SqliteCSharpTests
                 Expect.isEmpty(before, "There should have been no documents returned");
 
                 // This not raising an exception is the test
-                await Patch.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("Value", "burgundy")],
+                await Patch.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "burgundy")],
                     new { Foo = "green" });
             })
         ])
@@ -916,7 +857,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 17)], ["Sub"]);
+                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)], ["Sub"]);
                 var updated = await Find.ById<string, JsonDocument>(SqliteDb.TableName, "four");
                 Expect.isNotNull(updated, "The updated document should have been retrieved");
                 Expect.isNull(updated.Sub, "The sub-document should have been removed");
@@ -927,7 +868,7 @@ public static class SqliteCSharpTests
                 await LoadDocs();
 
                 // This not raising an exception is the test
-                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.Equal("NumValue", 17)],
+                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)],
                     ["Nothing"]);
             }),
             TestCase("succeeds when no document is matched", async () =>
@@ -935,8 +876,8 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
 
                 // This not raising an exception is the test
-                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any,
+                await RemoveFields.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Abracadabra", "apple")],
-                    [Field.NotEqual("Abracadabra", "apple")], ["Value"]);
+                    ["Value"]);
             })
         ])
     ]);
@@ -974,7 +915,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                await Delete.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NotEqual("Value", "purple")]);
+                await Delete.ByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Value", "purple")]);
                 var remaining = await Count.All(SqliteDb.TableName);
                 Expect.equal(remaining, 2L, "There should have been 2 documents remaining");
             }),
@@ -983,7 +924,7 @@ public static class SqliteCSharpTests
                 await using var db = await SqliteDb.BuildDb();
                 await LoadDocs();
 
-                await Delete.ByFields(SqliteDb.TableName, FieldMatch.All, [Field.Equal("Value", "crimson")]);
+                await Delete.ByFields(SqliteDb.TableName, FieldMatch.All, [Field.EQ("Value", "crimson")]);
                 var remaining = await Count.All(SqliteDb.TableName);
                 Expect.equal(remaining, 5L, "There should have been 5 documents remaining");
             })

src/Tests.CSharp/Types.cs

@@ -18,32 +18,4 @@ public class JsonDocument
     public string Value { get; set; } = "";
     public int NumValue { get; set; } = 0;
     public SubDocument? Sub { get; set; } = null;
-    
-    /// <summary>
-    /// A set of documents used for integration tests
-    /// </summary>
-    public static readonly List<JsonDocument> TestDocuments =
-    [
-        new() { Id = "one", Value = "FIRST!", NumValue = 0 },
-        new() { Id = "two", Value = "another", NumValue = 10, Sub = new() { Foo = "green", Bar = "blue" } },
-        new() { Id = "three", Value = "", NumValue = 4 },
-        new() { Id = "four", Value = "purple", NumValue = 17, Sub = new() { Foo = "green", Bar = "red" } },
-        new() { Id = "five", Value = "purple", NumValue = 18 }
-    ];
-}
-
-public class ArrayDocument
-{
-    public string Id { get; set; } = "";
-    public string[] Values { get; set; } = [];
-
-    /// <summary>
-    /// A set of documents used for integration tests
-    /// </summary>
-    public static readonly List<ArrayDocument> TestDocuments =
-    [
-        new() { Id = "first", Values = ["a", "b", "c"] },
-        new() { Id = "second", Values = ["c", "d", "e"] },
-        new() { Id = "third", Values = ["x", "y", "z"] }
-    ];
 }

src/Tests/CommonTests.fs

@@ -7,189 +7,170 @@ open Expecto
 let tbl = "test_table"
 
 /// Unit tests for the Op DU
-let comparisonTests = testList "Comparison.OpSql" [
+let opTests = testList "Op" [
-    test "Equal succeeds" {
+    test "EQ succeeds" {
-        Expect.equal (Equal "").OpSql "=" "The Equals SQL was not correct"
+        Expect.equal (string EQ) "=" "The equals operator was not correct"
     }
-    test "Greater succeeds" {
+    test "GT succeeds" {
-        Expect.equal (Greater "").OpSql ">" "The Greater SQL was not correct"
+        Expect.equal (string GT) ">" "The greater than operator was not correct"
     }
-    test "GreaterOrEqual succeeds" {
+    test "GE succeeds" {
-        Expect.equal (GreaterOrEqual "").OpSql ">=" "The GreaterOrEqual SQL was not correct"
+        Expect.equal (string GE) ">=" "The greater than or equal to operator was not correct"
     }
-    test "Less succeeds" {
+    test "LT succeeds" {
-        Expect.equal (Less "").OpSql "<" "The Less SQL was not correct"
+        Expect.equal (string LT) "<" "The less than operator was not correct"
     }
-    test "LessOrEqual succeeds" {
+    test "LE succeeds" {
-        Expect.equal (LessOrEqual "").OpSql "<=" "The LessOrEqual SQL was not correct"
+        Expect.equal (string LE) "<=" "The less than or equal to operator was not correct"
     }
-    test "NotEqual succeeds" {
+    test "NE succeeds" {
-        Expect.equal (NotEqual "").OpSql "<>" "The NotEqual SQL was not correct"
+        Expect.equal (string NE) "<>" "The not equal to operator was not correct"
     }
-    test "Between succeeds" {
+    test "BT succeeds" {
-        Expect.equal (Between("", "")).OpSql "BETWEEN" "The Between SQL was not correct"
+        Expect.equal (string BT) "BETWEEN" """The "between" operator was not correct"""
     }
-    test "In succeeds" {
+    test "EX succeeds" {
-        Expect.equal (In []).OpSql "IN" "The In SQL was not correct"
+        Expect.equal (string EX) "IS NOT NULL" """The "exists" operator was not correct"""
     }
-    test "InArray succeeds" {
+    test "NEX succeeds" {
-        Expect.equal (InArray("", [])).OpSql "?|" "The InArray SQL was not correct"
+        Expect.equal (string NEX) "IS NULL" """The "not exists" operator was not correct"""
-    }
-    test "Exists succeeds" {
-        Expect.equal Exists.OpSql "IS NOT NULL" "The Exists SQL was not correct"
-    }
-    test "NotExists succeeds" {
-        Expect.equal NotExists.OpSql "IS NULL" "The NotExists SQL was not correct"
     }
 ]
 
 /// Unit tests for the Field class
 let fieldTests = testList "Field" [
-    test "Equal succeeds" {
+    test "EQ succeeds" {
-        let field = Field.Equal "Test" 14
+        let field = Field.EQ "Test" 14
         Expect.equal field.Name "Test" "Field name incorrect"
-        Expect.equal field.Comparison (Equal 14) "Comparison incorrect"
+        Expect.equal field.Op EQ "Operator incorrect"
+        Expect.equal field.Value 14 "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "Greater succeeds" {
+    test "GT succeeds" {
-        let field = Field.Greater "Great" "night"
+        let field = Field.GT "Great" "night"
         Expect.equal field.Name "Great" "Field name incorrect"
-        Expect.equal field.Comparison (Greater "night") "Comparison incorrect"
+        Expect.equal field.Op GT "Operator incorrect"
+        Expect.equal field.Value "night" "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "GreaterOrEqual succeeds" {
+    test "GE succeeds" {
-        let field = Field.GreaterOrEqual "Nice" 88L
+        let field = Field.GE "Nice" 88L
         Expect.equal field.Name "Nice" "Field name incorrect"
-        Expect.equal field.Comparison (GreaterOrEqual 88L) "Comparison incorrect"
+        Expect.equal field.Op GE "Operator incorrect"
+        Expect.equal field.Value 88L "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "Less succeeds" {
+    test "LT succeeds" {
-        let field = Field.Less "Lesser" "seven"
+        let field = Field.LT "Lesser" "seven"
         Expect.equal field.Name "Lesser" "Field name incorrect"
-        Expect.equal field.Comparison (Less "seven") "Comparison incorrect"
+        Expect.equal field.Op LT "Operator incorrect"
+        Expect.equal field.Value "seven" "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "LessOrEqual succeeds" {
+    test "LE succeeds" {
-        let field = Field.LessOrEqual "Nobody" "KNOWS";
+        let field = Field.LE "Nobody" "KNOWS";
         Expect.equal field.Name "Nobody" "Field name incorrect"
-        Expect.equal field.Comparison (LessOrEqual "KNOWS") "Comparison incorrect"
+        Expect.equal field.Op LE "Operator incorrect"
+        Expect.equal field.Value "KNOWS" "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "NotEqual succeeds" {
+    test "NE succeeds" {
-        let field = Field.NotEqual "Park" "here"
+        let field = Field.NE "Park" "here"
         Expect.equal field.Name "Park" "Field name incorrect"
-        Expect.equal field.Comparison (NotEqual "here") "Comparison incorrect"
+        Expect.equal field.Op NE "Operator incorrect"
+        Expect.equal field.Value "here" "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "Between succeeds" {
+    test "BT succeeds" {
-        let field = Field.Between "Age" 18 49
+        let field = Field.BT "Age" 18 49
         Expect.equal field.Name "Age" "Field name incorrect"
-        Expect.equal field.Comparison (Between(18, 49)) "Comparison incorrect"
+        Expect.equal field.Op BT "Operator incorrect"
+        Expect.sequenceEqual (field.Value :?> obj list) [ 18; 49 ] "Value incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "In succeeds" {
+    test "EX succeeds" {
-        let field = Field.In "Here" [| 8; 16; 32 |]
+        let field = Field.EX "Groovy"
-        Expect.equal field.Name "Here" "Field name incorrect"
-        match field.Comparison with
-        | In values -> Expect.equal (List.ofSeq values) [ box 8; box 16; box 32 ] "Comparison incorrect"
-        | it -> Expect.isTrue false $"Expected In, received %A{it}"
-        Expect.isNone field.ParameterName "The default parameter name should be None"
-        Expect.isNone field.Qualifier "The default table qualifier should be None"
-    }
-    test "InArray succeeds" {
-        let field = Field.InArray "ArrayField" "table" [| "z" |]
-        Expect.equal field.Name "ArrayField" "Field name incorrect"
-        match field.Comparison with
-        | InArray (table, values) ->
-            Expect.equal table "table" "Comparison table incorrect"
-            Expect.equal (List.ofSeq values) [ box "z" ] "Comparison values incorrect"
-        | it -> Expect.isTrue false $"Expected InArray, received %A{it}"
-        Expect.isNone field.ParameterName "The default parameter name should be None"
-        Expect.isNone field.Qualifier "The default table qualifier should be None"
-    }
-    test "Exists succeeds" {
-        let field = Field.Exists "Groovy"
         Expect.equal field.Name "Groovy" "Field name incorrect"
-        Expect.equal field.Comparison Exists "Comparison incorrect"
+        Expect.equal field.Op EX "Operator incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
-    test "NotExists succeeds" {
+    test "NEX succeeds" {
-        let field = Field.NotExists "Rad"
+        let field = Field.NEX "Rad"
         Expect.equal field.Name "Rad" "Field name incorrect"
-        Expect.equal field.Comparison NotExists "Comparison incorrect"
+        Expect.equal field.Op NEX "Operator incorrect"
         Expect.isNone field.ParameterName "The default parameter name should be None"
         Expect.isNone field.Qualifier "The default table qualifier should be None"
     }
     testList "NameToPath" [
         test "succeeds for PostgreSQL and a simple name" {
-            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" PostgreSQL AsSql) "Path not constructed correctly"
+            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" PostgreSQL) "Path not constructed correctly"
         }
         test "succeeds for SQLite and a simple name" {
-            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" SQLite AsSql) "Path not constructed correctly"
+            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" SQLite) "Path not constructed correctly"
         }
         test "succeeds for PostgreSQL and a nested name" {
             Expect.equal
                 "data#>>'{A,Long,Path,to,the,Property}'"
-                (Field.NameToPath "A.Long.Path.to.the.Property" PostgreSQL AsSql)
+                (Field.NameToPath "A.Long.Path.to.the.Property" PostgreSQL)
                 "Path not constructed correctly"
         }
         test "succeeds for SQLite and a nested name" {
             Expect.equal
-                "data->'A'->'Long'->'Path'->'to'->'the'->>'Property'"
+                "data->>'A'->>'Long'->>'Path'->>'to'->>'the'->>'Property'"
-                (Field.NameToPath "A.Long.Path.to.the.Property" SQLite AsSql)
+                (Field.NameToPath "A.Long.Path.to.the.Property" SQLite)
                 "Path not constructed correctly"
         }
     ]
     test "WithParameterName succeeds" {
-        let field = (Field.Equal "Bob" "Tom").WithParameterName "@name"
+        let field = (Field.EQ "Bob" "Tom").WithParameterName "@name"
         Expect.isSome field.ParameterName "The parameter name should have been filled"
         Expect.equal "@name" field.ParameterName.Value "The parameter name is incorrect"
     }
     test "WithQualifier succeeds" {
-        let field = (Field.Equal "Bill" "Matt").WithQualifier "joe"
+        let field = (Field.EQ "Bill" "Matt").WithQualifier "joe"
         Expect.isSome field.Qualifier "The table qualifier should have been filled"
         Expect.equal "joe" field.Qualifier.Value "The table qualifier is incorrect"
     }
     testList "Path" [
         test "succeeds for a PostgreSQL single field with no qualifier" {
-            let field = Field.GreaterOrEqual "SomethingCool" 18
+            let field = Field.GE "SomethingCool" 18
-            Expect.equal "data->>'SomethingCool'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
+            Expect.equal "data->>'SomethingCool'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
         }
         test "succeeds for a PostgreSQL single field with a qualifier" {
-            let field = { Field.Less "SomethingElse" 9 with Qualifier = Some "this" }
+            let field = { Field.LT "SomethingElse" 9 with Qualifier = Some "this" }
-            Expect.equal "this.data->>'SomethingElse'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
+            Expect.equal "this.data->>'SomethingElse'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
         }
         test "succeeds for a PostgreSQL nested field with no qualifier" {
-            let field = Field.Equal "My.Nested.Field" "howdy"
+            let field = Field.EQ "My.Nested.Field" "howdy"
-            Expect.equal "data#>>'{My,Nested,Field}'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
+            Expect.equal "data#>>'{My,Nested,Field}'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
         }
         test "succeeds for a PostgreSQL nested field with a qualifier" {
-            let field = { Field.Equal "Nest.Away" "doc" with Qualifier = Some "bird" } 
+            let field = { Field.EQ "Nest.Away" "doc" with Qualifier = Some "bird" } 
-            Expect.equal "bird.data#>>'{Nest,Away}'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
+            Expect.equal "bird.data#>>'{Nest,Away}'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
         }
         test "succeeds for a SQLite single field with no qualifier" {
-            let field = Field.GreaterOrEqual "SomethingCool" 18
+            let field = Field.GE "SomethingCool" 18
-            Expect.equal "data->>'SomethingCool'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
+            Expect.equal "data->>'SomethingCool'" (field.Path SQLite) "The SQLite path is incorrect"
         }
         test "succeeds for a SQLite single field with a qualifier" {
-            let field = { Field.Less "SomethingElse" 9 with Qualifier = Some "this" }
+            let field = { Field.LT "SomethingElse" 9 with Qualifier = Some "this" }
-            Expect.equal "this.data->>'SomethingElse'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
+            Expect.equal "this.data->>'SomethingElse'" (field.Path SQLite) "The SQLite path is incorrect"
         }
         test "succeeds for a SQLite nested field with no qualifier" {
-            let field = Field.Equal "My.Nested.Field" "howdy"
+            let field = Field.EQ "My.Nested.Field" "howdy"
-            Expect.equal "data->'My'->'Nested'->>'Field'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
+            Expect.equal "data->>'My'->>'Nested'->>'Field'" (field.Path SQLite) "The SQLite path is incorrect"
         }
         test "succeeds for a SQLite nested field with a qualifier" {
-            let field = { Field.Equal "Nest.Away" "doc" with Qualifier = Some "bird" } 
+            let field = { Field.EQ "Nest.Away" "doc" with Qualifier = Some "bird" } 
-            Expect.equal "bird.data->'Nest'->>'Away'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
+            Expect.equal "bird.data->>'Nest'->>'Away'" (field.Path SQLite) "The SQLite path is incorrect"
         }
     ]
 ]
@@ -392,7 +373,7 @@ let queryTests = testList "Query" [
             test "succeeds for nested SQLite field" {
                 Expect.equal
                     (Query.Definition.ensureIndexOn tbl "nest" [ "a.b.c" ] SQLite)
-                    $"CREATE INDEX IF NOT EXISTS idx_{tbl}_nest ON {tbl} ((data->'a'->'b'->>'c'))"
+                    $"CREATE INDEX IF NOT EXISTS idx_{tbl}_nest ON {tbl} ((data->>'a'->>'b'->>'c'))"
                     "CREATE INDEX for nested SQLite field incorrect"
             }
         ]
@@ -454,7 +435,7 @@ let queryTests = testList "Query" [
                 (Query.orderBy
                      [ Field.Named "Nested.Test.Field DESC"; Field.Named "AnotherField"; Field.Named "It DESC" ]
                      SQLite)
-                " ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC"
+                " ORDER BY data->>'Nested'->>'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC"
                 "Order By not constructed correctly"
         }
         test "succeeds for PostgreSQL numeric fields" {
@@ -469,24 +450,12 @@ let queryTests = testList "Query" [
                 " ORDER BY data->>'Test'"
                 "Order By not constructed correctly for numeric field"
         }
-        test "succeeds for PostgreSQL case-insensitive ordering" {
-            Expect.equal
-                (Query.orderBy [ Field.Named "i:Test.Field DESC NULLS FIRST" ] PostgreSQL)
-                " ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST"
-                "Order By not constructed correctly for case-insensitive field"
-        }
-        test "succeeds for SQLite case-insensitive ordering" {
-            Expect.equal
-                (Query.orderBy [ Field.Named "i:Test.Field ASC NULLS LAST" ] SQLite)
-                " ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST"
-                "Order By not constructed correctly for case-insensitive field"
-        }
     ]
 ]
 
 /// Tests which do not hit the database
 let all = testList "Common" [
-    comparisonTests
+    opTests
     fieldTests
     fieldMatchTests
     parameterNameTests

src/Tests/PostgresExtensionTests.fs

@@ -214,7 +214,7 @@ let integrationTests =
             use conn = mkConn db
             do! loadDocs conn
             
-            let! theCount = conn.countByFields PostgresDb.TableName Any [ Field.Equal "Value" "purple" ]
+            let! theCount = conn.countByFields PostgresDb.TableName Any [ Field.EQ "Value" "purple" ]
             Expect.equal theCount 2 "There should have been 2 matching documents"
         }
         testTask "countByContains succeeds" {
@@ -257,7 +257,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! exists = conn.existsByFields PostgresDb.TableName Any [ Field.Exists "Sub" ]
+                let! exists = conn.existsByFields PostgresDb.TableName Any [ Field.EX "Sub" ]
                 Expect.isTrue exists "There should have been existing documents"
             }
             testTask "succeeds when documents do not exist" {
@@ -265,7 +265,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! exists = conn.existsByFields PostgresDb.TableName Any [ Field.Equal "NumValue" "six" ]
+                let! exists = conn.existsByFields PostgresDb.TableName Any [ Field.EQ "NumValue" "six" ]
                 Expect.isFalse exists "There should not have been existing documents"
             }
         ]
@@ -390,7 +390,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! docs = conn.findByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "another" ]
+                let! docs = conn.findByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "another" ]
                 Expect.equal (List.length docs) 1 "There should have been one document returned"
             }
             testTask "succeeds when documents are not found" {
@@ -398,7 +398,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! docs = conn.findByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "mauve" ]
+                let! docs = conn.findByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "mauve" ]
                 Expect.isEmpty docs "There should have been no documents returned"
             }
         ]
@@ -410,7 +410,7 @@ let integrationTests =
 
                 let! docs =
                     conn.findByFieldsOrdered<JsonDocument>
-                        PostgresDb.TableName All [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
+                        PostgresDb.TableName All [ Field.EQ "Value" "purple" ] [ Field.Named "Id" ]
                 Expect.hasLength docs 2 "There should have been two documents returned"
                 Expect.equal
                     (docs |> List.map _.Id |> String.concat "|") "five|four" "Documents not ordered correctly"
@@ -422,7 +422,7 @@ let integrationTests =
 
                 let! docs =
                     conn.findByFieldsOrdered<JsonDocument>
-                        PostgresDb.TableName All [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
+                        PostgresDb.TableName All [ Field.EQ "Value" "purple" ] [ Field.Named "Id DESC" ]
                 Expect.hasLength docs 2 "There should have been two documents returned"
                 Expect.equal
                     (docs |> List.map _.Id |> String.concat "|") "four|five" "Documents not ordered correctly"
@@ -524,8 +524,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! doc =
+                let! doc = conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "another" ]
-                    conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "another" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal doc.Value.Id "two" "The incorrect document was returned"
             }
@@ -534,8 +533,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! doc =
+                let! doc = conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "purple" ]
-                    conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "purple" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.contains [ "five"; "four" ] doc.Value.Id "An incorrect document was returned"
             }
@@ -544,8 +542,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                let! doc =
+                let! doc = conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "absent" ]
-                    conn.findFirstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "absent" ]
                 Expect.isNone doc "There should not have been a document returned"
             }
         ]
@@ -557,7 +554,7 @@ let integrationTests =
 
                 let! doc =
                     conn.findFirstByFieldsOrdered<JsonDocument>
-                        PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
+                        PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] [ Field.Named "Id" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal "five" doc.Value.Id "An incorrect document was returned"
             }
@@ -568,7 +565,7 @@ let integrationTests =
 
                 let! doc =
                     conn.findFirstByFieldsOrdered<JsonDocument>
-                        PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
+                        PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] [ Field.Named "Id DESC" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal "four" doc.Value.Id "An incorrect document was returned"
             }
@@ -753,8 +750,8 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
                 
-                do! conn.patchByFields PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] {| NumValue = 77 |}
+                do! conn.patchByFields PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] {| NumValue = 77 |}
-                let! after = conn.countByFields PostgresDb.TableName Any [ Field.Equal "NumValue" "77" ]
+                let! after = conn.countByFields PostgresDb.TableName Any [ Field.EQ "NumValue" "77" ]
                 Expect.equal after 2 "There should have been 2 documents returned"
             }
             testTask "succeeds when no document is updated" {
@@ -764,7 +761,7 @@ let integrationTests =
                 Expect.equal before 0 "There should have been no documents returned"
                 
                 // This not raising an exception is the test
-                do! conn.patchByFields PostgresDb.TableName Any [ Field.Equal "Value" "burgundy" ] {| Foo = "green" |}
+                do! conn.patchByFields PostgresDb.TableName Any [ Field.EQ "Value" "burgundy" ] {| Foo = "green" |}
             }
         ]
         testList "patchByContains" [
@@ -814,9 +811,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsById PostgresDb.TableName "two" [ "Sub"; "Value" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 1 "There should be 1 document without Value fields"
             }
             testTask "succeeds when a single field is removed" {
@@ -825,9 +822,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsById PostgresDb.TableName "two" [ "Sub" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 0 "There should be no documents without Value fields"
             }
             testTask "succeeds when a field is not removed" {
@@ -852,11 +849,10 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                do! conn.removeFieldsByFields
+                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Sub"; "Value" ]
-                        PostgresDb.TableName Any [ Field.Equal "NumValue" "17" ] [ "Sub"; "Value" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 1 "There should be 1 document without Value fields"
             }
             testTask "succeeds when a single field is removed" {
@@ -864,10 +860,10 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.Equal "NumValue" "17" ] [ "Sub" ]
+                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Sub" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 0 "There should be no documents without Value fields"
             }
             testTask "succeeds when a field is not removed" {
@@ -876,15 +872,14 @@ let integrationTests =
                 do! loadDocs conn
                     
                 // This not raising an exception is the test
-                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.Equal "NumValue" "17" ] [ "Nothing" ]
+                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Nothing" ]
             }
             testTask "succeeds when no document is matched" {
                 use db   = PostgresDb.BuildDb()
                 use conn = mkConn db
                 
                 // This not raising an exception is the test
-                do! conn.removeFieldsByFields
+                do! conn.removeFieldsByFields PostgresDb.TableName Any [ Field.NE "Abracadabra" "apple" ] [ "Value" ]
-                        PostgresDb.TableName Any [ Field.NotEqual "Abracadabra" "apple" ] [ "Value" ]
             }
         ]
         testList "removeFieldsByContains" [
@@ -894,9 +889,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsByContains PostgresDb.TableName {| NumValue = 17 |} [ "Sub"; "Value" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 1 "There should be 1 document without Value fields"
             }
             testTask "succeeds when a single field is removed" {
@@ -905,9 +900,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsByContains PostgresDb.TableName {| NumValue = 17 |} [ "Sub" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 0 "There should be no documents without Value fields"
             }
             testTask "succeeds when a field is not removed" {
@@ -933,9 +928,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsByJsonPath PostgresDb.TableName "$.NumValue ? (@ == 17)" [ "Sub"; "Value" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 1 "There should be 1 document without Value fields"
             }
             testTask "succeeds when a single field is removed" {
@@ -944,9 +939,9 @@ let integrationTests =
                 do! loadDocs conn
 
                 do! conn.removeFieldsByJsonPath PostgresDb.TableName "$.NumValue ? (@ == 17)" [ "Sub" ]
-                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+                let! noSubs = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
                 Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+                let! noValue = conn.countByFields PostgresDb.TableName Any [ Field.NEX "Value" ]
                 Expect.equal noValue 0 "There should be no documents without Value fields"
             }
             testTask "succeeds when a field is not removed" {
@@ -991,7 +986,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                do! conn.deleteByFields PostgresDb.TableName Any [ Field.Equal "Value" "purple" ]
+                do! conn.deleteByFields PostgresDb.TableName Any [ Field.EQ "Value" "purple" ]
                 let! remaining = conn.countAll PostgresDb.TableName
                 Expect.equal remaining 3 "There should have been 3 documents remaining"
             }
@@ -1000,7 +995,7 @@ let integrationTests =
                 use conn = mkConn db
                 do! loadDocs conn
 
-                do! conn.deleteByFields PostgresDb.TableName Any [ Field.Equal "Value" "crimson" ]
+                do! conn.deleteByFields PostgresDb.TableName Any [ Field.EQ "Value" "crimson" ]
                 let! remaining = conn.countAll PostgresDb.TableName
                 Expect.equal remaining 5 "There should have been 5 documents remaining"
             }

src/Tests/PostgresTests.fs

@@ -83,14 +83,14 @@ let parametersTests = testList "Parameters" [
     }
     testList "addFieldParams" [
         test "succeeds when a parameter is added" {
-            let paramList = addFieldParams [ Field.Where "it" (Equal "242") ] []
+            let paramList = addFieldParams [ Field.EQ "it" "242" ] []
             Expect.hasLength paramList 1 "There should have been a parameter added"
             let name, value = Seq.head paramList
             Expect.equal name "@field0" "Field parameter name not correct"
             Expect.equal value (Sql.string "242") "Parameter value not correct"
         }
         test "succeeds when multiple independent parameters are added" {
-            let paramList = addFieldParams [ Field.Equal "me" "you"; Field.Greater "us" "them" ] [ idParam 14 ]
+            let paramList = addFieldParams [ Field.EQ "me" "you"; Field.GT "us" "them" ] [ idParam 14 ]
             Expect.hasLength paramList 3 "There should have been 2 parameters added"
             let p = Array.ofSeq paramList
             Expect.equal (fst p[0]) "@id" "First field parameter name not correct"
@@ -101,11 +101,11 @@ let parametersTests = testList "Parameters" [
             Expect.equal (snd p[2]) (Sql.string "them") "Third parameter value not correct"
         }
         test "succeeds when a parameter is not added" {
-            let paramList = addFieldParams [ Field.Exists "tacos" ] []
+            let paramList = addFieldParams [ Field.EX "tacos" ] []
             Expect.isEmpty paramList "There should not have been any parameters added"
         }
         test "succeeds when two parameters are added for one field" {
-            let paramList = addFieldParams [ { Field.Between "that" "eh" "zed" with ParameterName = Some "@test" } ] []
+            let paramList = addFieldParams [ { Field.BT "that" "eh" "zed" with ParameterName = Some "@test" } ] []
             Expect.hasLength paramList 2 "There should have been 2 parameters added"
             let name, value = Seq.head paramList
             Expect.equal name "@testmin" "Minimum field name not correct"
@@ -135,66 +135,48 @@ let parametersTests = testList "Parameters" [
 /// Unit tests for the Query module of the PostgreSQL library
 let queryTests = testList "Query" [
     testList "whereByFields" [
-        test "succeeds for a single field when a logical comparison is passed" {
+        test "succeeds for a single field when a logical operator is passed" {
             Expect.equal
-                (Query.whereByFields Any [ { Field.Greater "theField" "0" with ParameterName = Some "@test" } ])
+                (Query.whereByFields Any [ { Field.GT "theField" "0" with ParameterName = Some "@test" } ])
                 "data->>'theField' > @test"
                 "WHERE clause not correct"
         }
-        test "succeeds for a single field when an existence comparison is passed" {
+        test "succeeds for a single field when an existence operator is passed" {
             Expect.equal
-                (Query.whereByFields Any [ Field.NotExists "thatField" ])
+                (Query.whereByFields Any [ Field.NEX "thatField" ])
                 "data->>'thatField' IS NULL"
                 "WHERE clause not correct"
         }
-        test "succeeds for a single field when a between comparison is passed with numeric values" {
+        test "succeeds for a single field when a between operator is passed with numeric values" {
             Expect.equal
-                (Query.whereByFields All [ { Field.Between "aField" 50 99 with ParameterName = Some "@range" } ])
+                (Query.whereByFields All [ { Field.BT "aField" 50 99 with ParameterName = Some "@range" } ])
                 "(data->>'aField')::numeric BETWEEN @rangemin AND @rangemax"
                 "WHERE clause not correct"
         }
-        test "succeeds for a single field when a between comparison is passed with non-numeric values" {
+        test "succeeds for a single field when a between operator is passed with non-numeric values" {
             Expect.equal
-                (Query.whereByFields Any [ { Field.Between "field0" "a" "b" with ParameterName = Some "@alpha" } ])
+                (Query.whereByFields Any [ { Field.BT "field0" "a" "b" with ParameterName = Some "@alpha" } ])
                 "data->>'field0' BETWEEN @alphamin AND @alphamax"
                 "WHERE clause not correct"
         }
-        test "succeeds for all multiple fields with logical comparisons" {
+        test "succeeds for all multiple fields with logical operators" {
             Expect.equal
-                (Query.whereByFields All [ Field.Equal "theFirst" "1"; Field.Equal "numberTwo" "2" ])
+                (Query.whereByFields All [ Field.EQ "theFirst" "1"; Field.EQ "numberTwo" "2" ])
                 "data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1"
                 "WHERE clause not correct"
         }
-        test "succeeds for any multiple fields with an existence comparisons" {
+        test "succeeds for any multiple fields with an existence operator" {
             Expect.equal
-                (Query.whereByFields Any [ Field.NotExists "thatField"; Field.GreaterOrEqual "thisField" 18 ])
+                (Query.whereByFields Any [ Field.NEX "thatField"; Field.GE "thisField" 18 ])
                 "data->>'thatField' IS NULL OR (data->>'thisField')::numeric >= @field0"
                 "WHERE clause not correct"
         }
-        test "succeeds for all multiple fields with between comparisons" {
+        test "succeeds for all multiple fields with between operators" {
             Expect.equal
-                (Query.whereByFields All [ Field.Between "aField" 50 99; Field.Between "anotherField" "a" "b" ])
+                (Query.whereByFields All [ Field.BT "aField" 50 99; Field.BT "anotherField" "a" "b" ])
                 "(data->>'aField')::numeric BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max"
                 "WHERE clause not correct"
         }
-        test "succeeds for a field with an In comparison with alphanumeric values" {
-            Expect.equal
-                (Query.whereByFields All [ Field.In "this" [ "a"; "b"; "c" ] ])
-                "data->>'this' IN (@field0_0, @field0_1, @field0_2)"
-                "WHERE clause not correct"
-        }
-        test "succeeds for a field with an In comparison with numeric values" {
-            Expect.equal
-                (Query.whereByFields All [ Field.In "this" [ 7; 14; 21 ] ])
-                "(data->>'this')::numeric IN (@field0_0, @field0_1, @field0_2)"
-                "WHERE clause not correct"
-        }
-        test "succeeds for a field with an InArray comparison" {
-            Expect.equal
-                (Query.whereByFields All [ Field.InArray "theField" "the_table" [ "q", "r" ] ])
-                "data->'theField' ?| @field0"
-                "WHERE clause not correct"
-        }
     ]
     testList "whereById" [
         test "succeeds for numeric ID" {
@@ -252,7 +234,7 @@ let queryTests = testList "Query" [
     }
     test "byFields succeeds" {
         Expect.equal
-            (Query.byFields "unit" Any [ Field.Greater "That" 14 ])
+            (Query.byFields "unit" Any [ Field.GT "That" 14 ])
             "unit WHERE (data->>'That')::numeric > @field0"
             "By-Field query not correct"
     }
@@ -550,15 +532,14 @@ let countTests = testList "Count" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
             
-            let! theCount =
+            let! theCount = Count.byFields PostgresDb.TableName Any [ Field.BT "NumValue" 15 20; Field.EQ "NumValue" 0 ]
-                Count.byFields PostgresDb.TableName Any [ Field.Between "NumValue" 15 20; Field.Equal "NumValue" 0 ]
             Expect.equal theCount 3 "There should have been 3 matching documents"
         }
         testTask "succeeds when items are not found" {
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
             
-            let! theCount = Count.byFields PostgresDb.TableName All [ Field.Exists "Sub"; Field.Greater "NumValue" 100 ]
+            let! theCount = Count.byFields PostgresDb.TableName All [ Field.EX "Sub"; Field.GT "NumValue" 100 ]
             Expect.equal theCount 0 "There should have been no matching documents"
         }
     ]
@@ -601,14 +582,14 @@ let existsTests = testList "Exists" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            let! exists = Exists.byFields PostgresDb.TableName Any [ Field.Exists "Sub"; Field.Exists "Boo" ]
+            let! exists = Exists.byFields PostgresDb.TableName Any [ Field.EX "Sub"; Field.EX "Boo" ]
             Expect.isTrue exists "There should have been existing documents"
         }
         testTask "succeeds when documents do not exist" {
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            let! exists = Exists.byFields PostgresDb.TableName All [ Field.Equal "NumValue" "six"; Field.Exists "Nope" ]
+            let! exists = Exists.byFields PostgresDb.TableName All [ Field.EQ "NumValue" "six"; Field.EX "Nope" ]
             Expect.isFalse exists "There should not have been existing documents"
         }
     ]
@@ -726,16 +707,8 @@ let findTests = testList "Find" [
             do! loadDocs ()
 
             let! docs =
-                Find.byFields<JsonDocument>
+                Find.byFields<JsonDocument> PostgresDb.TableName All [ Field.EQ "Value" "purple"; Field.EX "Sub" ]
-                    PostgresDb.TableName All [ Field.In "Value" [ "purple"; "blue" ]; Field.Exists "Sub" ]
+            Expect.equal (List.length docs) 1 "There should have been one document returned"
-            Expect.hasLength docs 1 "There should have been one document returned"
-        }
-        testTask "succeeds when documents are found using IN with numeric field" {
-            use db = PostgresDb.BuildDb()
-            do! loadDocs ()
-
-            let! docs = Find.byFields<JsonDocument> PostgresDb.TableName All [ Field.In "NumValue" [ 2; 4; 6; 8 ] ]
-            Expect.hasLength docs 1 "There should have been one document returned"
         }
         testTask "succeeds when documents are not found" {
             use db = PostgresDb.BuildDb()
@@ -743,27 +716,7 @@ let findTests = testList "Find" [
 
             let! docs =
                 Find.byFields<JsonDocument>
-                    PostgresDb.TableName All [ Field.Equal "Value" "mauve"; Field.NotEqual "NumValue" 40 ]
+                    PostgresDb.TableName All [ Field.EQ "Value" "mauve"; Field.NE "NumValue" 40 ]
-            Expect.isEmpty docs "There should have been no documents returned"
-        }
-        testTask "succeeds for InArray when matching documents exist" {
-            use db = PostgresDb.BuildDb()
-            do! Definition.ensureTable PostgresDb.TableName
-            for doc in ArrayDocument.TestDocuments do do! insert PostgresDb.TableName doc
-            
-            let! docs =
-                Find.byFields<ArrayDocument>
-                    PostgresDb.TableName All [ Field.InArray "Values" PostgresDb.TableName [ "c" ] ]
-            Expect.hasLength docs 2 "There should have been two documents returned"
-        }
-        testTask "succeeds for InArray when no matching documents exist" {
-            use db = PostgresDb.BuildDb()
-            do! Definition.ensureTable PostgresDb.TableName
-            for doc in ArrayDocument.TestDocuments do do! insert PostgresDb.TableName doc
-            
-            let! docs =
-                Find.byFields<ArrayDocument>
-                    PostgresDb.TableName All [ Field.InArray "Values" PostgresDb.TableName [ "j" ] ]
             Expect.isEmpty docs "There should have been no documents returned"
         }
     ]
@@ -774,7 +727,7 @@ let findTests = testList "Find" [
 
             let! docs =
                 Find.byFieldsOrdered<JsonDocument>
-                    PostgresDb.TableName All [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
+                    PostgresDb.TableName All [ Field.EQ "Value" "purple" ] [ Field.Named "Id" ]
             Expect.hasLength docs 2 "There should have been two documents returned"
             Expect.equal
                 (docs |> List.map _.Id |> String.concat "|") "five|four" "Documents not ordered correctly"
@@ -785,7 +738,7 @@ let findTests = testList "Find" [
 
             let! docs =
                 Find.byFieldsOrdered<JsonDocument>
-                    PostgresDb.TableName All [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
+                    PostgresDb.TableName All [ Field.EQ "Value" "purple" ] [ Field.Named "Id DESC" ]
             Expect.hasLength docs 2 "There should have been two documents returned"
             Expect.equal
                 (docs |> List.map _.Id |> String.concat "|") "four|five" "Documents not ordered correctly"
@@ -878,7 +831,7 @@ let findTests = testList "Find" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "another" ]
+            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "another" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal doc.Value.Id "two" "The incorrect document was returned"
         }
@@ -886,7 +839,7 @@ let findTests = testList "Find" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "purple" ]
+            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "purple" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.contains [ "five"; "four" ] doc.Value.Id "An incorrect document was returned"
         }
@@ -894,7 +847,7 @@ let findTests = testList "Find" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.Equal "Value" "absent" ]
+            let! doc = Find.firstByFields<JsonDocument> PostgresDb.TableName Any [ Field.EQ "Value" "absent" ]
             Expect.isNone doc "There should not have been a document returned"
         }
     ]
@@ -905,7 +858,7 @@ let findTests = testList "Find" [
 
             let! doc =
                 Find.firstByFieldsOrdered<JsonDocument>
-                    PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
+                    PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] [ Field.Named "Id" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal "five" doc.Value.Id "An incorrect document was returned"
         }
@@ -915,7 +868,7 @@ let findTests = testList "Find" [
 
             let! doc =
                 Find.firstByFieldsOrdered<JsonDocument>
-                    PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
+                    PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] [ Field.Named "Id DESC" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal "four" doc.Value.Id "An incorrect document was returned"
         }
@@ -1092,8 +1045,8 @@ let patchTests = testList "Patch" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
             
-            do! Patch.byFields PostgresDb.TableName Any [ Field.Equal "Value" "purple" ] {| NumValue = 77 |}
+            do! Patch.byFields PostgresDb.TableName Any [ Field.EQ "Value" "purple" ] {| NumValue = 77 |}
-            let! after = Count.byFields PostgresDb.TableName Any [ Field.Equal "NumValue" 77 ]
+            let! after = Count.byFields PostgresDb.TableName Any [ Field.EQ "NumValue" 77 ]
             Expect.equal after 2 "There should have been 2 documents returned"
         }
         testTask "succeeds when no document is updated" {
@@ -1103,7 +1056,7 @@ let patchTests = testList "Patch" [
             Expect.equal before 0 "There should have been no documents returned"
             
             // This not raising an exception is the test
-            do! Patch.byFields PostgresDb.TableName Any [ Field.Equal "Value" "burgundy" ] {| Foo = "green" |}
+            do! Patch.byFields PostgresDb.TableName Any [ Field.EQ "Value" "burgundy" ] {| Foo = "green" |}
         }
     ]
     testList "byContains" [
@@ -1154,9 +1107,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byId PostgresDb.TableName "two" [ "Sub"; "Value" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 1 "There should be 1 document without Value fields"
         }
         testTask "succeeds when a single field is removed" {
@@ -1164,9 +1117,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byId PostgresDb.TableName "two" [ "Sub" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 0 "There should be no documents without Value fields"
         }
         testTask "succeeds when a field is not removed" {
@@ -1188,20 +1141,20 @@ let removeFieldsTests = testList "RemoveFields" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Sub"; "Value" ]
+            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Sub"; "Value" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 1 "There should be 1 document without Value fields"
         }
         testTask "succeeds when a single field is removed" {
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Sub" ]
+            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Sub" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 0 "There should be no documents without Value fields"
         }
         testTask "succeeds when a field is not removed" {
@@ -1209,13 +1162,13 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
                 
             // This not raising an exception is the test
-            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Nothing" ]
+            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.EQ "NumValue" "17" ] [ "Nothing" ]
         }
         testTask "succeeds when no document is matched" {
             use db = PostgresDb.BuildDb()
             
             // This not raising an exception is the test
-            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.NotEqual "Abracadabra" "apple" ] [ "Value" ]
+            do! RemoveFields.byFields PostgresDb.TableName Any [ Field.NE "Abracadabra" "apple" ] [ "Value" ]
         }
     ]
     testList "byContains" [
@@ -1224,9 +1177,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byContains PostgresDb.TableName {| NumValue = 17 |} [ "Sub"; "Value" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 1 "There should be 1 document without Value fields"
         }
         testTask "succeeds when a single field is removed" {
@@ -1234,9 +1187,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byContains PostgresDb.TableName {| NumValue = 17 |} [ "Sub" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 0 "There should be no documents without Value fields"
         }
         testTask "succeeds when a field is not removed" {
@@ -1259,9 +1212,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byJsonPath PostgresDb.TableName "$.NumValue ? (@ == 17)" [ "Sub"; "Value" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 1 "There should be 1 document without Value fields"
         }
         testTask "succeeds when a single field is removed" {
@@ -1269,9 +1222,9 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
 
             do! RemoveFields.byJsonPath PostgresDb.TableName "$.NumValue ? (@ == 17)" [ "Sub" ]
-            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Sub" ]
+            let! noSubs = Count.byFields PostgresDb.TableName Any [ Field.NEX "Sub" ]
             Expect.equal noSubs 4 "There should now be 4 documents without Sub fields"
-            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NotExists "Value" ]
+            let! noValue = Count.byFields PostgresDb.TableName Any [ Field.NEX "Value" ]
             Expect.equal noValue 0 "There should be no documents without Value fields"
         }
         testTask "succeeds when a field is not removed" {
@@ -1315,7 +1268,7 @@ let deleteTests = testList "Delete" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            do! Delete.byFields PostgresDb.TableName Any [ Field.Equal "Value" "purple" ]
+            do! Delete.byFields PostgresDb.TableName Any [ Field.EQ "Value" "purple" ]
             let! remaining = Count.all PostgresDb.TableName
             Expect.equal remaining 3 "There should have been 3 documents remaining"
         }
@@ -1323,7 +1276,7 @@ let deleteTests = testList "Delete" [
             use db = PostgresDb.BuildDb()
             do! loadDocs ()
 
-            do! Delete.byFields PostgresDb.TableName Any [ Field.Equal "Value" "crimson" ]
+            do! Delete.byFields PostgresDb.TableName Any [ Field.EQ "Value" "crimson" ]
             let! remaining = Count.all PostgresDb.TableName
             Expect.equal remaining 5 "There should have been 5 documents remaining"
         }

src/Tests/SqliteExtensionTests.fs

@@ -118,7 +118,7 @@ let integrationTests =
             use  conn = Configuration.dbConn ()
             do! loadDocs ()
     
-            let! theCount = conn.countByFields SqliteDb.TableName Any [ Field.Equal "Value" "purple" ]
+            let! theCount = conn.countByFields SqliteDb.TableName Any [ Field.EQ "Value" "purple" ]
             Expect.equal theCount 2L "There should have been 2 matching documents"
         }
         testList "existsById" [
@@ -145,7 +145,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! exists = conn.existsByFields SqliteDb.TableName Any [ Field.Equal "NumValue" 10 ]
+                let! exists = conn.existsByFields SqliteDb.TableName Any [ Field.EQ "NumValue" 10 ]
                 Expect.isTrue exists "There should have been existing documents"
             }
             testTask "succeeds when no matching documents exist" {
@@ -153,7 +153,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! exists = conn.existsByFields SqliteDb.TableName Any [ Field.Equal "Nothing" "none" ]
+                let! exists = conn.existsByFields SqliteDb.TableName Any [ Field.EQ "Nothing" "none" ]
                 Expect.isFalse exists "There should not have been any existing documents"
             }
         ]
@@ -244,7 +244,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! docs = conn.findByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ]
+                let! docs = conn.findByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ]
                 Expect.hasLength docs 2 "There should have been two documents returned"
             }
             testTask "succeeds when documents are not found" {
@@ -252,7 +252,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! docs = conn.findByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Value" "mauve" ]
+                let! docs = conn.findByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "mauve" ]
                 Expect.isEmpty docs "There should have been no documents returned"
             }
         ]
@@ -264,7 +264,7 @@ let integrationTests =
 
                 let! docs =
                     conn.findByFieldsOrdered<JsonDocument>
-                        SqliteDb.TableName Any [ Field.Greater "NumValue" 15 ] [ Field.Named "Id" ]
+                        SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id" ]
                 Expect.equal
                     (docs |> List.map _.Id |> String.concat "|") "five|four" "The documents were not ordered correctly"
             }
@@ -275,7 +275,7 @@ let integrationTests =
 
                 let! docs =
                     conn.findByFieldsOrdered<JsonDocument>
-                        SqliteDb.TableName Any [ Field.Greater "NumValue" 15 ] [ Field.Named "Id DESC" ]
+                        SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id DESC" ]
                 Expect.equal
                     (docs |> List.map _.Id |> String.concat "|") "four|five" "The documents were not ordered correctly"
             }
@@ -286,7 +286,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Value" "another" ]
+                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "another" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal doc.Value.Id "two" "The incorrect document was returned"
             }
@@ -295,7 +295,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ]
+                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.contains [ "two"; "four" ] doc.Value.Id "An incorrect document was returned"
             }
@@ -304,7 +304,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Value" "absent" ]
+                let! doc = conn.findFirstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "absent" ]
                 Expect.isNone doc "There should not have been a document returned"
             }
         ]
@@ -316,7 +316,7 @@ let integrationTests =
 
                 let! doc =
                     conn.findFirstByFieldsOrdered<JsonDocument>
-                        SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ] [ Field.Named "Sub.Bar" ]
+                        SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal "two" doc.Value.Id "An incorrect document was returned"
             }
@@ -327,7 +327,7 @@ let integrationTests =
 
                 let! doc =
                     conn.findFirstByFieldsOrdered<JsonDocument>
-                        SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ] [ Field.Named "Sub.Bar DESC" ]
+                        SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar DESC" ]
                 Expect.isSome doc "There should have been a document returned"
                 Expect.equal "four" doc.Value.Id "An incorrect document was returned"
             }
@@ -416,8 +416,8 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
                 
-                do! conn.patchByFields SqliteDb.TableName Any [ Field.Equal "Value" "purple" ] {| NumValue = 77 |}
+                do! conn.patchByFields SqliteDb.TableName Any [ Field.EQ "Value" "purple" ] {| NumValue = 77 |}
-                let! after = conn.countByFields SqliteDb.TableName Any [ Field.Equal "NumValue" 77 ]
+                let! after = conn.countByFields SqliteDb.TableName Any [ Field.EQ "NumValue" 77 ]
                 Expect.equal after 2L "There should have been 2 documents returned"
             }
             testTask "succeeds when no document is updated" {
@@ -428,7 +428,7 @@ let integrationTests =
                 Expect.isEmpty before "There should have been no documents returned"
                 
                 // This not raising an exception is the test
-                do! conn.patchByFields SqliteDb.TableName Any [ Field.Equal "Value" "burgundy" ] {| Foo = "green" |}
+                do! conn.patchByFields SqliteDb.TableName Any [ Field.EQ "Value" "burgundy" ] {| Foo = "green" |}
             }
         ]
         testList "removeFieldsById" [
@@ -467,7 +467,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
                 
-                do! conn.removeFieldsByFields SqliteDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Sub" ]
+                do! conn.removeFieldsByFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Sub" ]
                 try
                     let! _ = conn.findById<string, JsonDocument> SqliteDb.TableName "four"
                     Expect.isTrue false "The updated document should have failed to parse"
@@ -481,15 +481,14 @@ let integrationTests =
                 do! loadDocs ()
                 
                 // This not raising an exception is the test
-                do! conn.removeFieldsByFields SqliteDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Nothing" ]
+                do! conn.removeFieldsByFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Nothing" ]
             }
             testTask "succeeds when no document is matched" {
                 use! db   = SqliteDb.BuildDb()
                 use  conn = Configuration.dbConn ()
                 
                 // This not raising an exception is the test
-                do! conn.removeFieldsByFields
+                do! conn.removeFieldsByFields SqliteDb.TableName Any [ Field.NE "Abracadabra" "apple" ] [ "Value" ]
-                        SqliteDb.TableName Any [ Field.NotEqual "Abracadabra" "apple" ] [ "Value" ]
             }
         ]
         testList "deleteById" [
@@ -518,7 +517,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                do! conn.deleteByFields SqliteDb.TableName Any [ Field.NotEqual "Value" "purple" ]
+                do! conn.deleteByFields SqliteDb.TableName Any [ Field.NE "Value" "purple" ]
                 let! remaining = conn.countAll SqliteDb.TableName
                 Expect.equal remaining 2L "There should have been 2 documents remaining"
             }
@@ -527,7 +526,7 @@ let integrationTests =
                 use  conn = Configuration.dbConn ()
                 do! loadDocs ()
     
-                do! conn.deleteByFields SqliteDb.TableName Any [ Field.Equal "Value" "crimson" ]
+                do! conn.deleteByFields SqliteDb.TableName Any [ Field.EQ "Value" "crimson" ]
                 let! remaining = conn.countAll SqliteDb.TableName
                 Expect.equal remaining 5L "There should have been 5 documents remaining"
             }

src/Tests/SqliteTests.fs

@@ -15,54 +15,42 @@ open Types
 /// Unit tests for the Query module of the SQLite library
 let queryTests = testList "Query" [
     testList "whereByFields" [
-        test "succeeds for a single field when a logical comparison is passed" {
+        test "succeeds for a single field when a logical operator is passed" {
             Expect.equal
-                (Query.whereByFields Any [ { Field.Greater "theField" 0 with ParameterName = Some "@test" } ])
+                (Query.whereByFields Any [ { Field.GT "theField" 0 with ParameterName = Some "@test" } ])
                 "data->>'theField' > @test"
                 "WHERE clause not correct"
         }
-        test "succeeds for a single field when an existence comparison is passed" {
+        test "succeeds for a single field when an existence operator is passed" {
             Expect.equal
-                (Query.whereByFields Any [ Field.NotExists "thatField" ])
+                (Query.whereByFields Any [ Field.NEX "thatField" ])
                 "data->>'thatField' IS NULL"
                 "WHERE clause not correct"
         }
-        test "succeeds for a single field when a between comparison is passed" {
+        test "succeeds for a single field when a between operator is passed" {
             Expect.equal
-                (Query.whereByFields All [ { Field.Between "aField" 50 99 with ParameterName = Some "@range" } ])
+                (Query.whereByFields All [ { Field.BT "aField" 50 99 with ParameterName = Some "@range" } ])
                 "data->>'aField' BETWEEN @rangemin AND @rangemax"
                 "WHERE clause not correct"
         }
-        test "succeeds for all multiple fields with logical comparisons" {
+        test "succeeds for all multiple fields with logical operators" {
             Expect.equal
-                (Query.whereByFields All [ Field.Equal "theFirst" "1"; Field.Equal "numberTwo" "2" ])
+                (Query.whereByFields All [ Field.EQ "theFirst" "1"; Field.EQ "numberTwo" "2" ])
                 "data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1"
                 "WHERE clause not correct"
         }
-        test "succeeds for any multiple fields with an existence comparison" {
+        test "succeeds for any multiple fields with an existence operator" {
             Expect.equal
-                (Query.whereByFields Any [ Field.NotExists "thatField"; Field.GreaterOrEqual "thisField" 18 ])
+                (Query.whereByFields Any [ Field.NEX "thatField"; Field.GE "thisField" 18 ])
                 "data->>'thatField' IS NULL OR data->>'thisField' >= @field0"
                 "WHERE clause not correct"
         }
-        test "succeeds for all multiple fields with between comparisons" {
+        test "succeeds for all multiple fields with between operators" {
             Expect.equal
-                (Query.whereByFields All [ Field.Between "aField" 50 99; Field.Between "anotherField" "a" "b" ])
+                (Query.whereByFields All [ Field.BT "aField" 50 99; Field.BT "anotherField" "a" "b" ])
                 "data->>'aField' BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max"
                 "WHERE clause not correct"
         }
-        test "succeeds for a field with an In comparison" {
-            Expect.equal
-                (Query.whereByFields All [ Field.In "this" [ "a"; "b"; "c" ] ])
-                "data->>'this' IN (@field0_0, @field0_1, @field0_2)"
-                "WHERE clause not correct"
-        }
-        test "succeeds for a field with an InArray comparison" {
-            Expect.equal
-                (Query.whereByFields All [ Field.InArray "this" "the_table" [ "a"; "b" ] ])
-                "EXISTS (SELECT 1 FROM json_each(the_table.data, '$.this') WHERE value IN (@field0_0, @field0_1))"
-                "WHERE clause not correct"
-        }
     ]
     test "whereById succeeds" {
         Expect.equal (Query.whereById "@id") "data->>'Id' = @id" "WHERE clause not correct"
@@ -84,7 +72,7 @@ let queryTests = testList "Query" [
     }
     test "byFields succeeds" {
         Expect.equal
-            (Query.byFields "unit" Any [ Field.Greater "That" 14 ])
+            (Query.byFields "unit" Any [ Field.GT "That" 14 ])
             "unit WHERE data->>'That' > @field0"
             "By-Field query not correct"
     }
@@ -110,14 +98,14 @@ let parametersTests = testList "Parameters" [
     }
     testList "addFieldParam" [
         test "succeeds when adding a parameter" {
-            let paramList = addFieldParam "@field" (Field.Equal "it" 99) []
+            let paramList = addFieldParam "@field" (Field.EQ "it" 99) []
             Expect.hasLength paramList 1 "There should have been a parameter added"
             let theParam = Seq.head paramList
             Expect.equal theParam.ParameterName "@field" "The parameter name is incorrect"
             Expect.equal theParam.Value 99 "The parameter value is incorrect"
         }
         test "succeeds when not adding a parameter" {
-            let paramList = addFieldParam "@it" (Field.NotExists "Coffee") []
+            let paramList = addFieldParam "@it" (Field.NEX "Coffee") []
             Expect.isEmpty paramList "There should not have been any parameters added"
         }
     ]
@@ -392,14 +380,14 @@ let countTests = testList "Count" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
     
-            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.Between "NumValue" 10 20 ]
+            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.BT "NumValue" 10 20 ]
             Expect.equal theCount 3L "There should have been 3 matching documents"
         }
         testTask "succeeds for a non-numeric range" {
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
     
-            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.Between "Value" "aardvark" "apple" ]
+            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.BT "Value" "aardvark" "apple" ]
             Expect.equal theCount 1L "There should have been 1 matching document"
         }
     ]
@@ -428,14 +416,14 @@ let existsTests = testList "Exists" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.Equal "NumValue" 10 ]
+            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 10 ]
             Expect.isTrue exists "There should have been existing documents"
         }
         testTask "succeeds when no matching documents exist" {
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.Less "Nothing" "none" ]
+            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.LT "Nothing" "none" ]
             Expect.isFalse exists "There should not have been any existing documents"
         }
     ]
@@ -520,43 +508,16 @@ let findTests = testList "Find" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.Greater "NumValue" 15 ]
+            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.GT "NumValue" 15 ]
-            Expect.hasLength docs 2 "There should have been two documents returned"
+            Expect.equal (List.length docs) 2 "There should have been two documents returned"
-        }
-        testTask "succeeds when documents are found using IN with numeric field" {
-            use! db = SqliteDb.BuildDb()
-            do! loadDocs ()
-
-            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName All [ Field.In "NumValue" [ 2; 4; 6; 8 ] ]
-            Expect.hasLength docs 1 "There should have been one document returned"
         }
         testTask "succeeds when documents are not found" {
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.Greater "NumValue" 100 ]
+            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.GT "NumValue" 100 ]
             Expect.isTrue (List.isEmpty docs) "There should have been no documents returned"
         }
-        testTask "succeeds for InArray when matching documents exist" {
-            use! db = SqliteDb.BuildDb()
-            do! Definition.ensureTable SqliteDb.TableName
-            for doc in ArrayDocument.TestDocuments do do! insert SqliteDb.TableName doc
-            
-            let! docs =
-                Find.byFields<ArrayDocument>
-                    SqliteDb.TableName All [ Field.InArray "Values" SqliteDb.TableName [ "c" ] ]
-            Expect.hasLength docs 2 "There should have been two documents returned"
-        }
-        testTask "succeeds for InArray when no matching documents exist" {
-            use! db = SqliteDb.BuildDb()
-            do! Definition.ensureTable SqliteDb.TableName
-            for doc in ArrayDocument.TestDocuments do do! insert SqliteDb.TableName doc
-            
-            let! docs =
-                Find.byFields<ArrayDocument>
-                    SqliteDb.TableName All [ Field.InArray "Values" SqliteDb.TableName [ "j" ] ]
-            Expect.isEmpty docs "There should have been no documents returned"
-        }
     ]
     testList "byFieldsOrdered" [
         testTask "succeeds when sorting ascending" {
@@ -565,8 +526,7 @@ let findTests = testList "Find" [
 
             let! docs =
                 Find.byFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName Any [ Field.Greater "NumValue" 15 ] [ Field.Named "Id" ]
+                    SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id" ]
-            Expect.hasLength docs 2 "There should have been two documents returned"
             Expect.equal
                 (docs |> List.map _.Id |> String.concat "|") "five|four" "The documents were not ordered correctly"
         }
@@ -576,40 +536,17 @@ let findTests = testList "Find" [
 
             let! docs =
                 Find.byFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName Any [ Field.Greater "NumValue" 15 ] [ Field.Named "Id DESC" ]
+                    SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id DESC" ]
-            Expect.hasLength docs 2 "There should have been two documents returned"
             Expect.equal
                 (docs |> List.map _.Id |> String.concat "|") "four|five" "The documents were not ordered correctly"
         }
-        testTask "succeeds when sorting case-sensitively" {
-            use! db = SqliteDb.BuildDb()
-            do! loadDocs ()
-
-            let! docs =
-                Find.byFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName All [ Field.LessOrEqual "NumValue" 10 ] [ Field.Named "Value" ]
-            Expect.hasLength docs 3 "There should have been three documents returned"
-            Expect.equal
-                (docs |> List.map _.Id |> String.concat "|") "three|one|two" "Documents not ordered correctly"
-        }
-        testTask "succeeds when sorting case-insensitively" {
-            use! db = SqliteDb.BuildDb()
-            do! loadDocs ()
-
-            let! docs =
-                Find.byFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName All [ Field.LessOrEqual "NumValue" 10 ] [ Field.Named "i:Value" ]
-            Expect.hasLength docs 3 "There should have been three documents returned"
-            Expect.equal
-                (docs |> List.map _.Id |> String.concat "|") "three|two|one" "Documents not ordered correctly"
-        }
     ]
     testList "firstByFields" [
         testTask "succeeds when a document is found" {
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Value" "another" ]
+            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "another" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal doc.Value.Id "two" "The incorrect document was returned"
         }
@@ -617,7 +554,7 @@ let findTests = testList "Find" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ]
+            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.contains [ "two"; "four" ] doc.Value.Id "An incorrect document was returned"
         }
@@ -625,7 +562,7 @@ let findTests = testList "Find" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.Equal "Value" "absent" ]
+            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "absent" ]
             Expect.isNone doc "There should not have been a document returned"
         }
     ]
@@ -636,7 +573,7 @@ let findTests = testList "Find" [
 
             let! doc =
                 Find.firstByFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ] [ Field.Named "Sub.Bar" ]
+                    SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal "two" doc.Value.Id "An incorrect document was returned"
         }
@@ -646,7 +583,7 @@ let findTests = testList "Find" [
 
             let! doc =
                 Find.firstByFieldsOrdered<JsonDocument>
-                    SqliteDb.TableName Any [ Field.Equal "Sub.Foo" "green" ] [ Field.Named "Sub.Bar DESC" ]
+                    SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar DESC" ]
             Expect.isSome doc "There should have been a document returned"
             Expect.equal "four" doc.Value.Id "An incorrect document was returned"
         }
@@ -729,8 +666,8 @@ let patchTests = testList "Patch" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
             
-            do! Patch.byFields SqliteDb.TableName Any [ Field.Equal "Value" "purple" ] {| NumValue = 77 |}
+            do! Patch.byFields SqliteDb.TableName Any [ Field.EQ "Value" "purple" ] {| NumValue = 77 |}
-            let! after = Count.byFields SqliteDb.TableName Any [ Field.Equal "NumValue" 77 ]
+            let! after = Count.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 77 ]
             Expect.equal after 2L "There should have been 2 documents returned"
         }
         testTask "succeeds when no document is updated" {
@@ -740,7 +677,7 @@ let patchTests = testList "Patch" [
             Expect.isEmpty before "There should have been no documents returned"
             
             // This not raising an exception is the test
-            do! Patch.byFields SqliteDb.TableName Any [ Field.Equal "Value" "burgundy" ] {| Foo = "green" |}
+            do! Patch.byFields SqliteDb.TableName Any [ Field.EQ "Value" "burgundy" ] {| Foo = "green" |}
         }
     ]
 ]
@@ -779,7 +716,7 @@ let removeFieldsTests = testList "RemoveFields" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
             
-            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Sub" ]
+            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Sub" ]
             try
                 let! _ = Find.byId<string, JsonDocument> SqliteDb.TableName "four"
                 Expect.isTrue false "The updated document should have failed to parse"
@@ -792,13 +729,13 @@ let removeFieldsTests = testList "RemoveFields" [
             do! loadDocs ()
             
             // This not raising an exception is the test
-            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.Equal "NumValue" 17 ] [ "Nothing" ]
+            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Nothing" ]
         }
         testTask "succeeds when no document is matched" {
             use! db = SqliteDb.BuildDb()
             
             // This not raising an exception is the test
-            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.NotEqual "Abracadabra" "apple" ] [ "Value" ]
+            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.NE "Abracadabra" "apple" ] [ "Value" ]
         }
     ]
 ]
@@ -828,7 +765,7 @@ let deleteTests = testList "Delete" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            do! Delete.byFields SqliteDb.TableName Any [ Field.NotEqual "Value" "purple" ]
+            do! Delete.byFields SqliteDb.TableName Any [ Field.NE "Value" "purple" ]
             let! remaining = Count.all SqliteDb.TableName
             Expect.equal remaining 2L "There should have been 2 documents remaining"
         }
@@ -836,7 +773,7 @@ let deleteTests = testList "Delete" [
             use! db = SqliteDb.BuildDb()
             do! loadDocs ()
 
-            do! Delete.byFields SqliteDb.TableName Any [ Field.Equal "Value" "crimson" ]
+            do! Delete.byFields SqliteDb.TableName Any [ Field.EQ "Value" "crimson" ]
             let! remaining = Count.all SqliteDb.TableName
             Expect.equal remaining 5L "There should have been 5 documents remaining"
         }

src/Tests/Types.fs

@@ -8,32 +8,20 @@ type SubDocument =
     { Foo: string
       Bar: string }
 
-type ArrayDocument =
-    { Id: string
-      Values: string list }
-with
-    /// <summary>
-    /// A set of documents used for integration tests
-    /// </summary>
-    static member TestDocuments =
-        [ { Id = "first";  Values = [ "a"; "b"; "c" ] }
-          { Id = "second"; Values = [ "c"; "d"; "e" ] }
-          { Id = "third";  Values = [ "x"; "y"; "z" ] } ]
-
 type JsonDocument =
     { Id: string
       Value: string
       NumValue: int
       Sub: SubDocument option }
 
-
 /// An empty JsonDocument
 let emptyDoc = { Id = ""; Value = ""; NumValue = 0; Sub = None }
 
 /// Documents to use for testing
-let testDocuments =
+let testDocuments = [
-    [ { Id = "one";   Value = "FIRST!";  NumValue = 0;  Sub = None }
+    { Id = "one"; Value = "FIRST!"; NumValue = 0; Sub = None }
-      { Id = "two";   Value = "another"; NumValue = 10; Sub = Some { Foo = "green"; Bar = "blue" } }
+    { Id = "two"; Value = "another"; NumValue = 10; Sub = Some { Foo = "green"; Bar = "blue" } }
-      { Id = "three"; Value = "";        NumValue = 4;  Sub = None }
+    { Id = "three"; Value = ""; NumValue = 4; Sub = None }
-      { Id = "four";  Value = "purple";  NumValue = 17; Sub = Some { Foo = "green"; Bar = "red" } }
+    { Id = "four"; Value = "purple"; NumValue = 17; Sub = Some { Foo = "green"; Bar = "red" } }
-      { Id = "five";  Value = "purple";  NumValue = 18; Sub = None } ]
+    { Id = "five"; Value = "purple"; NumValue = 18; Sub = None }
+]