Support specifying input expression when manually calling diffix_count.

Author: cristianberneanu

src/OpenDiffix.Core.Tests/QueryEngine.Tests.fs

@@ -200,7 +200,7 @@ type Tests(db: DBFixture) =
         Rows = [ [| Integer 11L; Boolean false |] ]
       }
 
-    let queryResult = runQuery "SELECT diffix_count(id) AS dc, diffix_low_count(id) AS lc FROM products"
+    let queryResult = runQuery "SELECT diffix_count(*, id) AS dc, diffix_low_count(id) AS lc FROM products"
     queryResult |> should equal expected
 
   interface IClassFixture<DBFixture>

src/OpenDiffix.Core/Aggregator.fs

@@ -118,6 +118,7 @@ type private DiffixCount(minCount) =
   interface IAggregator with
     member this.Transition args =
       match args with
+      | Value.List [] :: _ -> invalidArgs args
       | [ aidInstances; Null ] -> updateAidMaps aidInstances 0L
       | [ aidInstances ]
       | [ aidInstances; _ ] -> updateAidMaps aidInstances 1L
@@ -140,7 +141,7 @@ type private DiffixCountDistinct(minCount) =
     member this.Transition args =
       match args with
       | [ _aidInstances; Null ] -> ()
-      | [ Value.List aidInstances; value ] ->
+      | [ Value.List aidInstances; value ] when not aidInstances.IsEmpty ->
         let aidSets =
           match aidsPerValue.TryGetValue(value) with
           | true, aidSets -> aidSets
@@ -173,7 +174,7 @@ type private DiffixLowCount() =
     member this.Transition args =
       match args with
       | [ Null ] -> ()
-      | [ Value.List aidInstances ] ->
+      | [ Value.List aidInstances ] when not aidInstances.IsEmpty ->
         if isNull state then state <- emptySets aidInstances.Length
 
         aidInstances

src/OpenDiffix.Core/Analyzer.fs

@@ -44,12 +44,22 @@ let private mapFunctionExpression rangeColumns fn parsedArgs =
   (match fn, parsedArgs with
    | AggregateFunction (Count, aggregateArgs), [ ParserTypes.Star ] -> //
      AggregateFunction(Count, aggregateArgs), []
+   | AggregateFunction (DiffixLowCount, aggregateArgs), parsedAids ->
+     let aids = parsedAids |> List.map (mapExpression rangeColumns)
+     AggregateFunction(DiffixLowCount, aggregateArgs), [ ListExpr aids ]
+   | AggregateFunction (DiffixCount, aggregateArgs), parsedArg :: parsedAids ->
+     let aggregateArgs, args =
+       match parsedArg with
+       | ParserTypes.Star -> aggregateArgs, []
+       | ParserTypes.Distinct parsedExpr ->
+         { aggregateArgs with Distinct = true }, [ mapExpression rangeColumns parsedExpr ]
+       | parsedExpr -> aggregateArgs, [ mapExpression rangeColumns parsedExpr ]
+
+     let aids = parsedAids |> List.map (mapExpression rangeColumns) |> ListExpr
+     AggregateFunction(DiffixCount, aggregateArgs), aids :: args
    | AggregateFunction (aggregate, aggregateArgs), [ ParserTypes.Distinct expr ] ->
      let arg = mapExpression rangeColumns expr
      AggregateFunction(aggregate, { aggregateArgs with Distinct = true }), [ arg ]
-   | AggregateFunction (fn, aggregateArgs), parsedArgs when List.contains fn [ DiffixCount; DiffixLowCount ] -> //
-     let args = parsedArgs |> List.map (mapExpression rangeColumns)
-     AggregateFunction(fn, aggregateArgs), [ ListExpr args ]
    | _ ->
      let args = parsedArgs |> List.map (mapExpression rangeColumns)
      fn, args)