array_agg

Author: easafe

docs/edsl.md

@@ -165,6 +165,8 @@ Droplet offers a few functions built-in:
 
 * `string_agg`
 
+* `array_agg`
+
 * `coalesce`
 
 * `random`
@@ -178,9 +180,9 @@ function :: forall input output. String -> FunctionSignature input output
 -- represents a function that takes no arguments
 function' :: forall output. String -> FunctionSignature' output
 
--- example of defining array_agg for integer inputs
-int_array_agg :: FunctionSignature Int (Maybe (Array Int))
-int_array_agg = function "array_agg"
+-- example of defining func from integer to nullable integer
+func :: FunctionSignature Int (Maybe Int)
+func = function "func"
 ```
 
 Be aware that functions must be aliased

src/Droplet/Language.purs

@@ -55,6 +55,7 @@ import Droplet.Language.Internal.Function
       ( count
       , coalesce
       , string_agg
+      , array_agg
       , function
       , function'
       , Aggregate

src/Droplet/Language/Internal/Function.purs

@@ -7,8 +7,10 @@ module Droplet.Language.Internal.Function
       , function'
       , string_agg
       , class ToStringAgg
+      , class ToArrayAgg
       , class ToCoalesce
       , PgFunction(..)
+      , array_agg
       , class MatchArgument
       , function
       , class MatchArgumentList
@@ -22,7 +24,7 @@ import Prelude
 import Data.BigInt (BigInt)
 import Data.Maybe (Maybe)
 import Data.Tuple.Nested (type (/\))
-import Droplet.Language.Internal.Definition (class AppendPath, class ToValue, class UnwrapDefinition, class UnwrapNullable, Default, E, Path, Star)
+import Droplet.Language.Internal.Definition (class AppendPath, class ToValue, class UnwrapDefinition, class UnwrapNullable, E, Path, Star)
 import Prim.Row (class Cons)
 import Type.Equality (class TypeEquals)
 import Type.Proxy (Proxy)
@@ -32,6 +34,7 @@ import Type.Proxy (Proxy)
 data Aggregate input rest (fields ∷ Row Type) (output ∷ Type)
       = Count input
       | StringAgg input rest
+      | ArrayAgg input
 
 -- | Declares a functions
 data PgFunction (input ∷ Type) args (fields ∷ Row Type) (output ∷ Type) = PgFunction String args
@@ -61,6 +64,12 @@ instance TextColumn String
 
 instance TextColumn (Maybe String)
 
+class ToArrayAgg (f ∷ Type) (fields ∷ Row Type) (t ∷ Type) | f → fields t
+
+instance (Cons name t e fields, UnwrapDefinition t u) ⇒ ToArrayAgg (Proxy name) fields u
+
+instance (Cons name t e fields, UnwrapDefinition t u) ⇒ ToArrayAgg (Path alias name) fields u
+
 -- | Function arguments must match input type
 class MatchArgumentList (input ∷ Type) (args ∷ Type) (fields ∷ Row Type)
 
@@ -103,6 +112,10 @@ count = Count
 string_agg ∷ ∀ f rest fields. ToStringAgg f rest fields ⇒ f → rest → Aggregate f rest fields (Maybe String)
 string_agg f rest = StringAgg f rest
 
+--Maybe t because null
+array_agg ∷ ∀ f t fields. ToArrayAgg f fields t ⇒ f → Aggregate f E fields (Maybe (Array t))
+array_agg f = ArrayAgg f
+
 random ∷ FunctionSignature' Number
 random = function' "random"
 

src/Droplet/Language/Internal/Syntax.purs

@@ -152,7 +152,7 @@ import Data.Reflectable as DR
 import Data.Tuple.Nested (type (/\))
 import Droplet.Language.Internal.Condition (class ToCondition, class ValidComparision, Exists(..), Op(..), OuterScope)
 import Droplet.Language.Internal.Definition (class AppendPath, class ToType, class ToValue, class UnwrapDefinition, class UnwrapNullable, C, Column, Composite, Constraint, Default, Dot, E(..), Empty, ForeignKey, Identity, Joined, Path, PrimaryKey, Star, Table(..), Unique)
-import Droplet.Language.Internal.Function (class ToStringAgg, Aggregate, PgFunction)
+import Droplet.Language.Internal.Function (class ToArrayAgg, class ToStringAgg, Aggregate, PgFunction)
 import Prim.Boolean (False, True)
 import Prim.Row (class Cons, class Nub, class Union)
 import Prim.RowList (class RowToList, Cons, Nil, RowList)
@@ -695,7 +695,7 @@ data OrderBy f rest = OrderBy f rest
 
 data Sort (f ∷ Type) = Asc | Desc
 
--- | ORDER BY must be last statement
+-- | ORDER BY
 class ToOrderBy (f ∷ Type) (q ∷ Type)
 
 instance (SortColumnsSource s projection f columns available, SortColumns st available) ⇒ ToOrderBy st (Select s projection (From f columns E))
@@ -724,6 +724,25 @@ instance ToOrderBy (Proxy name) String
 
 instance ToOrderBy (Path alias name) String
 
+instance ToOrderBy (Proxy name) (Proxy otherName)
+
+instance ToOrderBy (Path alias name) (Path otherAlias otherName)
+
+--must be typed here
+instance
+      ( Cons name t e fields
+      , Cons otherName v r fields
+      , UnwrapDefinition v w
+      ) ⇒
+      ToArrayAgg (OrderBy (Proxy name) (Proxy otherName)) fields w
+
+instance
+      ( Cons name t e fields
+      , Cons otherName v r fields
+      , UnwrapDefinition v w
+      ) ⇒
+      ToArrayAgg (OrderBy (Path alias name) (Path otherAlias otherName)) fields w
+
 --this error might not be clear for the user
 -- | Columns available for sorting this query
 -- |

src/Droplet/Language/Internal/Token.purs

@@ -164,6 +164,9 @@ dotSymbol = "."
 string_aggFunctionName ∷ String
 string_aggFunctionName = "string_agg"
 
+array_aggFunctionName ∷ String
+array_aggFunctionName = "array_agg"
+
 simpleQuoteSymbol ∷ String
 simpleQuoteSymbol = "'"
 

src/Droplet/Language/Internal/Translate.purs

@@ -81,8 +81,8 @@ import Droplet.Language.Internal.Condition (BinaryOperator(..), Exists, In, IsNu
 import Droplet.Language.Internal.Definition (class AppendPath, class IsNullable, class ToParameters, class ToType, class ToValue, class UnwrapDefinition, class UnwrapNullable, C, Column, Composite, Constraint, Default, E(..), ForeignKey, Identity, Path, PrimaryKey, Star, Table, Unique)
 import Droplet.Language.Internal.Definition as DLID
 import Droplet.Language.Internal.Function (Aggregate(..), PgFunction(..))
-import Droplet.Language.Internal.Syntax (class ConstraintsToRowList, class OnlyAggregations, class JoinedToMaybe, class QueryOptionallyAliased, class ToProjection, class ToSingleColumn, class UniqueColumnNames, Add, Alter(..), As(..), Create, DefaultValues(..), Delete(..), Distinct(..), Drop, From(..), GroupBy(..), Inclusion(..), Inner, Insert(..), Into(..), Join(..), Limit(..), Offset(..), On(..), OrderBy(..), Outer, Plan, Prepare(..), Returning(..), Select(..), Set(..), Side, Sort(..), T(..), Union(..), Update(..), Values(..), Where(..))
-import Droplet.Language.Internal.Token (addKeyword, allKeyword, alterKeyword, andKeyword, asKeyword, ascKeyword, atSymbol, byKeyword, closeBracket, comma, constraintKeyword, countFunctionName, createKeyword, lesserEqualsThanSymbol, greaterEqualsThanSymbol, defaultKeyword, deleteKeyword, descKeyword, distinctKeyword, dotSymbol, dropKeyword, equalsSymbol, existsKeyword, foreignKeyKeyword, fromKeyword, greaterThanSymbol, groupByKeyword, identityKeyword, inKeyword, innerKeyword, insertKeyword, isNullKeyword, isNotNullKeyword, joinKeyword, leftKeyword, lesserThanSymbol, limitKeyword, notEqualsSymbol, notKeyword, notNullKeyword, offsetKeyword, onKeyword, openBracket, orKeyword, orderKeyword, parameterSymbol, primaryKeyKeyword, quoteSymbol, referencesKeyword, returningKeyword, selectKeyword, setKeyword, space, starSymbol, string_aggFunctionName, tableKeyword, unionKeyword, uniqueKeyword, updateKeyword, valuesKeyword, whereKeyword)
+import Droplet.Language.Internal.Syntax (class ConstraintsToRowList, class JoinedToMaybe, class OnlyAggregations, class QueryOptionallyAliased, class ToProjection, class ToSingleColumn, class UniqueColumnNames, Add, Alter(..), As(..), Create, DefaultValues(..), Delete(..), Distinct(..), Drop, From(..), GroupBy(..), Inclusion(..), Inner, Insert(..), Into(..), Join(..), Limit(..), Offset(..), On(..), OrderBy(..), Outer, Plan, Prepare(..), Returning(..), Select(..), Set(..), Side, Sort(..), T(..), Union(..), Update(..), Values(..), Where(..))
+import Droplet.Language.Internal.Token (addKeyword, allKeyword, alterKeyword, andKeyword, array_aggFunctionName, asKeyword, ascKeyword, atSymbol, byKeyword, closeBracket, comma, constraintKeyword, countFunctionName, createKeyword, defaultKeyword, deleteKeyword, descKeyword, distinctKeyword, dotSymbol, dropKeyword, equalsSymbol, existsKeyword, foreignKeyKeyword, fromKeyword, greaterEqualsThanSymbol, greaterThanSymbol, groupByKeyword, identityKeyword, inKeyword, innerKeyword, insertKeyword, isNotNullKeyword, isNullKeyword, joinKeyword, leftKeyword, lesserEqualsThanSymbol, lesserThanSymbol, limitKeyword, notEqualsSymbol, notKeyword, notNullKeyword, offsetKeyword, onKeyword, openBracket, orKeyword, orderKeyword, parameterSymbol, primaryKeyKeyword, quoteSymbol, referencesKeyword, returningKeyword, selectKeyword, setKeyword, space, starSymbol, string_aggFunctionName, tableKeyword, unionKeyword, uniqueKeyword, updateKeyword, valuesKeyword, whereKeyword)
 import Foreign (Foreign)
 import Prelude (class Show, Unit, bind, discard, map, otherwise, pure, show, ($), (<$>), (<<<), (<>), (==), (||))
 import Prim.Boolean (False, True)
@@ -779,6 +779,10 @@ instance (Reflectable alias String, Reflectable name String) ⇒ NameList (Path
 instance NameList Star where
       nameList _ = starSymbol
 
+--e.g. array_agg (field order by field)
+instance (NameList f, NameList g) ⇒ NameList (OrderBy f g) where
+      nameList (OrderBy f g) = nameList g <> orderKeyword <> byKeyword <> nameList f
+
 instance (NameList f, NameList rest) ⇒ NameList (Tuple f rest) where
       nameList (Tuple f rest) = nameList f <> comma <> nameList rest
 
@@ -1132,6 +1136,7 @@ printAggregation = case _ of
       StringAgg f rest → do
             nrest ← argumentList rest
             pure $ string_aggFunctionName <> openBracket <> nameList f <> comma <> nrest <> closeBracket
+      ArrayAgg f → pure $ array_aggFunctionName <> openBracket <> nameList f <> closeBracket
 
 printFunction ∷ ∀ inp fields args out. ArgumentList args ⇒ PgFunction inp args fields out → State QueryState String
 printFunction (PgFunction name args) = do

test/Function.purs

@@ -5,15 +5,14 @@ import Prelude
 import Data.BigInt as DB
 import Data.Maybe (Maybe(..))
 import Data.Tuple.Nested ((/\))
-import Droplet.Language (as, coalesce, count, from, orderBy, random, select, star, string_agg, (...))
+import Droplet.Language
 import Droplet.Language.Internal.Translate as DLIQ
 import Test.Model as TM
 import Test.Types
 
 import Test.Spec (Spec)
 import Test.Spec as TS
 
-
 tests ∷ Spec Unit
 tests = TS.describe "functions" do
       TS.describe "user defined functions" do
@@ -81,3 +80,21 @@ tests = TS.describe "functions" do
                         let q = select (string_agg (u ... name) (", " # orderBy (u ... id)) # as u) # from (users # as u)
                         TM.parameterized """SELECT string_agg("u"."name", $1 ORDER BY "u"."id") AS "u" FROM "users" AS "u"""" $ DLIQ.buildQuery q
                         TM.result q [ { u: Just "josh, mary" } ]
+      TS.describe "int_agg" do
+            TS.it "field" do
+                  let q = select (array_agg name # as u) # from users
+                  TM.notParameterized """SELECT array_agg("name") AS "u" FROM "users"""" $ DLIQ.buildQuery q
+                  TM.result q [ { u: Just [ "josh", "mary" ] } ]
+            TS.it "path" do
+                  let q = select (array_agg (u ... id) # as u) # from (users # as u)
+                  TM.notParameterized """SELECT array_agg("u"."id") AS "u" FROM "users" AS "u"""" $ DLIQ.buildQuery q
+                  TM.result q [ { u: Just [1, 2] } ]
+            TS.describe "order by" do
+                  TS.it "field" do
+                        let q = select (array_agg (id # orderBy id) # as u) # from users
+                        TM.notParameterized """SELECT array_agg("id" ORDER BY "id") AS "u" FROM "users"""" $ DLIQ.buildQuery q
+                        TM.result q [ { u: Just [1, 2]} ]
+                  TS.it "path" do
+                        let q = select (array_agg (u ... name # orderBy (u ... id)) # as u) # from (users # as u)
+                        TM.notParameterized """SELECT array_agg("u"."name" ORDER BY "u"."id") AS "u" FROM "users" AS "u"""" $ DLIQ.buildQuery q
+                        TM.result q [ { u: Just ["josh", "mary"] } ]