6be23e2 · squeal · git.iko.soy

git.iko.soy/squeal

on dev help sign in

setof and more

6be23e2Eitan Chatav7 years ago

squeal-postgresql/src/Squeal/PostgreSQL/Definition.hs+59−9

compare with dev

unifiedsplit

@@ -50,6 +50,8 @@ module Squeal.PostgreSQL.Definition

50 , createIndex

51 , createFunction

52 , createOrReplaceFunction

53+ , createSetFunction

54+ , createOrReplaceSetFunction

53 , TableConstraintExpression (..)

55 , TableConstraintExpression (..)

54 , check

56 , check

55 , unique

57 , unique

@@ -60,6 +62,7 @@ module Squeal.PostgreSQL.Definition

60 , OnUpdateClause (..)

62 , OnUpdateClause (..)

61 , FunctionDefinition(..)

63 , FunctionDefinition(..)

62 , languageSql

64 , languageSql

65+ , languageSqlSet

63 -- ** Drop

66 -- ** Drop

64 , dropSchema

67 , dropSchema

65 , dropTable

68 , dropTable

@@ -1136,8 +1139,8 @@ createFunction

1136 => QualifiedAlias sch fun

1139 => QualifiedAlias sch fun

1137 -> NP (TypeExpression schemas) args

1140 -> NP (TypeExpression schemas) args

1138 -> TypeExpression schemas ret

1141 -> TypeExpression schemas ret

1139− -> FunctionDefinition schemas ('Fun args ret)

1142+ -> FunctionDefinition schemas args ('Returns ret)

1140− -> Definition schemas (Alter sch (Create fun ('Function ('Fun args ret)) schema) schemas)

1143+ -> Definition schemas (Alter sch (Create fun ('Function args ('Returns ret)) schema) schemas)

1141createFunction fun args ret fundef = UnsafeDefinition $

1144createFunction fun args ret fundef = UnsafeDefinition $

1142 "CREATE" <+> "FUNCTION" <+> renderSQL fun

1145 "CREATE" <+> "FUNCTION" <+> renderSQL fun

1143 <+> parenthesized (renderCommaSeparated renderSQL args)

1146 <+> parenthesized (renderCommaSeparated renderSQL args)

@@ -1145,13 +1148,13 @@ createFunction fun args ret fundef = UnsafeDefinition $

1145

1148

1146createOrReplaceFunction

1149createOrReplaceFunction

1147 :: ( Has sch schemas schema

1150 :: ( Has sch schemas schema

1148− , Has fun schema ('Function ('Fun args0 ret0))

1151+ , Has fun schema ('Function args0 ret0)

1149 , SOP.SListI args )

1152 , SOP.SListI args )

1150 => QualifiedAlias sch fun

1153 => QualifiedAlias sch fun

1151 -> NP (TypeExpression schemas) args

1154 -> NP (TypeExpression schemas) args

1152 -> TypeExpression schemas ret

1155 -> TypeExpression schemas ret

1153− -> FunctionDefinition schemas ('Fun args ret)

1156+ -> FunctionDefinition schemas args ('Returns ret)

1154− -> Definition schemas (Alter sch (Alter fun ('Function ('Fun args ret)) schema) schemas)

1157+ -> Definition schemas (Alter sch (Alter fun ('Function args ('Returns ret)) schema) schemas)

1155createOrReplaceFunction fun args ret fundef = UnsafeDefinition $

1158createOrReplaceFunction fun args ret fundef = UnsafeDefinition $

1156 "CREATE" <+> "OR" <+> "REPLACE" <+> "FUNCTION" <+> renderSQL fun

1159 "CREATE" <+> "OR" <+> "REPLACE" <+> "FUNCTION" <+> renderSQL fun

1157 <+> parenthesized (renderCommaSeparated renderSQL args)

1160 <+> parenthesized (renderCommaSeparated renderSQL args)

@@ -1159,22 +1162,69 @@ createOrReplaceFunction fun args ret fundef = UnsafeDefinition $

1159

1162

1160languageSql

1163languageSql

1161 :: Query '[] '[] schemas args '[col ::: ret]

1164 :: Query '[] '[] schemas args '[col ::: ret]

1162− -> FunctionDefinition schemas ('Fun args ret)

1165+ -> FunctionDefinition schemas args ('Returns ret)

1163languageSql qry = UnsafeFunctionDefinition $

1166languageSql qry = UnsafeFunctionDefinition $

1164 "language sql as" <+> "$$" <+> renderSQL qry <+> "$$"

1167 "language sql as" <+> "$$" <+> renderSQL qry <+> "$$"

1165

1168

1169+languageSqlSet

1170+ :: Query '[] '[] schemas args rets

1171+ -> FunctionDefinition schemas args ('ReturnsTable rets)

1172+languageSqlSet qry = UnsafeFunctionDefinition $

1173+ "language sql as" <+> "$$" <+> renderSQL qry <+> "$$"

1174+

1175+

1176+createSetFunction

1177+ :: ( Has sch schemas schema

1178+ , KnownSymbol fun

1179+ , SOP.SListI args

1180+ , SOP.SListI rets )

1181+ => QualifiedAlias sch fun

1182+ -> NP (TypeExpression schemas) args

1183+ -> NP (Aliased (TypeExpression schemas)) rets

1184+ -> FunctionDefinition schemas args ('ReturnsTable rets)

1185+ -> Definition schemas (Alter sch (Create fun ('Function args ('ReturnsTable rets)) schema) schemas)

1186+createSetFunction fun args rets fundef = UnsafeDefinition $

1187+ "CREATE" <+> "FUNCTION" <+> renderSQL fun

1188+ <+> parenthesized (renderCommaSeparated renderSQL args)

1189+ <+> "RETURNS" <+> "TABLE"

1190+ <+> parenthesized (renderCommaSeparated renderRet rets)

1191+ <+> renderSQL fundef <> ";"

1192+ where

1193+ renderRet :: Aliased (TypeExpression s) r -> ByteString

1194+ renderRet (ty `As` col) = renderSQL col <+> renderSQL ty

1195+

1196+createOrReplaceSetFunction

1197+ :: ( Has sch schemas schema

1198+ , Has fun schema ('Function args0 ret0)

1199+ , SOP.SListI args

1200+ , SOP.SListI rets )

1201+ => QualifiedAlias sch fun

1202+ -> NP (TypeExpression schemas) args

1203+ -> NP (Aliased (TypeExpression schemas)) rets

1204+ -> FunctionDefinition schemas args ('ReturnsTable rets)

1205+ -> Definition schemas (Alter sch (Alter fun ('Function args ('ReturnsTable rets)) schema) schemas)

1206+createOrReplaceSetFunction fun args rets fundef = UnsafeDefinition $

1207+ "CREATE" <+> "OR" <+> "REPLACE" <+> "FUNCTION" <+> renderSQL fun

1208+ <+> parenthesized (renderCommaSeparated renderSQL args)

1209+ <+> "RETURNS" <+> "TABLE"

1210+ <+> parenthesized (renderCommaSeparated renderRet rets)

1211+ <+> renderSQL fundef <> ";"

1212+ where

1213+ renderRet :: Aliased (TypeExpression s) r -> ByteString

1214+ renderRet (ty `As` col) = renderSQL col <+> renderSQL ty

1215+

1166dropFunction

1216dropFunction

1167− :: (Has sch schemas schema, Has fun schema ('Function funty))

1217+ :: (Has sch schemas schema, Has fun schema ('Function args ret))

1168 => QualifiedAlias sch fun

1218 => QualifiedAlias sch fun

1169 -- ^ name of the user defined function

1219 -- ^ name of the user defined function

1170 -> Definition schemas (Alter sch (Drop ix schema) schemas)

1220 -> Definition schemas (Alter sch (Drop ix schema) schemas)

1171dropFunction fun = UnsafeDefinition $

1221dropFunction fun = UnsafeDefinition $

1172 "DROP" <+> "Function" <+> renderSQL fun <> ";"

1222 "DROP" <+> "Function" <+> renderSQL fun <> ";"

1173

1223

1174−newtype FunctionDefinition schemas funty = UnsafeFunctionDefinition

1224+newtype FunctionDefinition schemas args ret = UnsafeFunctionDefinition

1175 { renderFunctionDefinition :: ByteString }

1225 { renderFunctionDefinition :: ByteString }

1176 deriving (Eq,Show,GHC.Generic,NFData)

1226 deriving (Eq,Show,GHC.Generic,NFData)

1177−instance RenderSQL (FunctionDefinition schemas funty) where

1227+instance RenderSQL (FunctionDefinition schemas args ret) where

1178 renderSQL = renderFunctionDefinition

1228 renderSQL = renderFunctionDefinition

1179

1229

1180-- |

1230-- |

squeal-postgresql/src/Squeal/PostgreSQL/Expression.hs+10−4

@@ -324,9 +324,11 @@ unsafeFunction fun x = UnsafeExpression $

324 fun <> parenthesized (renderSQL x)

325

326function

327− :: (Has sch schemas schema, Has fun schema ('Function ('Fun '[x] y)))

327+ :: (Has sch schemas schema, Has fun schema ('Function '[x] ('Returns y)))

328 => QualifiedAlias sch fun

329− -> x :--> y

329+ -> ( forall outer commons grp params from

330+ . Expression outer commons grp schemas params from x

331+ -> Expression outer commons grp schemas params from y )

330function = unsafeFunction . renderSQL

332function = unsafeFunction . renderSQL

331

333

332-- | >>> printSQL $ unsafeFunctionN "f" (currentTime :* localTimestamp :* false *: literal 'a')

334-- | >>> printSQL $ unsafeFunctionN "f" (currentTime :* localTimestamp :* false *: literal 'a')

@@ -336,9 +338,13 @@ unsafeFunctionN fun xs = UnsafeExpression $

336 fun <> parenthesized (renderCommaSeparated renderSQL xs)

338 fun <> parenthesized (renderCommaSeparated renderSQL xs)

337

339

338functionN

340functionN

339− :: (Has sch schemas schema, Has fun schema ('Function ('Fun xs y)), SListI xs)

341+ :: ( Has sch schemas schema

342+ , Has fun schema ('Function xs ('Returns y))

343+ , SListI xs )

340 => QualifiedAlias sch fun

344 => QualifiedAlias sch fun

341− -> FunctionN xs y

345+ -> ( forall outer commons grp params from

346+ . NP (Expression outer commons grp schemas params from) xs

347+ -> Expression outer commons grp schemas params from y )

342functionN = unsafeFunctionN . renderSQL

348functionN = unsafeFunctionN . renderSQL

343

349

344instance ty `In` PGNum

350instance ty `In` PGNum

squeal-postgresql/src/Squeal/PostgreSQL/Expression/SetOf.hs+21

@@ -26,8 +26,10 @@ module Squeal.PostgreSQL.Expression.SetOf

26 , generateSeriesTimestamp

27 , SetOfFunction

28 , unsafeSetOfFunction

29+ , setOfFunction

29 , SetOfFunctionN

30 , SetOfFunctionN

30 , unsafeSetOfFunctionN

31 , unsafeSetOfFunctionN

32+ , setOfFunctionN

31 ) where

33 ) where

33import GHC.TypeLits

35import GHC.TypeLits

@@ -58,6 +60,15 @@ unsafeSetOfFunction

58unsafeSetOfFunction x = UnsafeFromClause $

60unsafeSetOfFunction x = UnsafeFromClause $

59 renderSymbol @fun <> parenthesized (renderSQL x)

61 renderSymbol @fun <> parenthesized (renderSQL x)

63+setOfFunction

64+ :: ( Has sch schemas schema

65+ , Has fun schema ('Function '[ty] ('ReturnsTable setof)) )

66+ => Alias fun

67+ -> ( forall outer commons params

68+ . Expression outer commons 'Ungrouped schemas params '[] ty

69+ -> FromClause outer commons schemas params '[fun ::: setof] )

70+setOfFunction _ = unsafeSetOfFunction

71+

61{- |

72{- |

62A @RankNType@ for set returning functions with multiple argument.

73A @RankNType@ for set returning functions with multiple argument.

63-}

74-}

@@ -75,6 +86,16 @@ unsafeSetOfFunctionN

75unsafeSetOfFunctionN xs = UnsafeFromClause $

86unsafeSetOfFunctionN xs = UnsafeFromClause $

76 renderSymbol @fun <> parenthesized (renderCommaSeparated renderSQL xs)

87 renderSymbol @fun <> parenthesized (renderCommaSeparated renderSQL xs)

89+setOfFunctionN

90+ :: ( Has sch schemas schema

91+ , Has fun schema ('Function tys ('ReturnsTable setof))

92+ , SOP.SListI tys )

93+ => Alias fun

94+ -> ( forall outer commons params

95+ . NP (Expression outer commons 'Ungrouped schemas params '[]) tys

96+ -> FromClause outer commons schemas params '[fun ::: setof] )

97+setOfFunctionN _ = unsafeSetOfFunctionN

98+

78{- | @generateSeries (start *: stop)@

99{- | @generateSeries (start *: stop)@

100

80Generate a series of values, from @start@ to @stop@ with a step size of one

101Generate a series of values, from @start@ to @stop@ with a step size of one

squeal-postgresql/src/Squeal/PostgreSQL/Schema.hs+5−5

@@ -45,7 +45,7 @@ module Squeal.PostgreSQL.Schema

45 , TableType

46 , SchemumType (..)

47 , OperatorType (..)

48− , FunctionType (..)

48+ , ReturnsType (..)

49 , SchemaType

50 , SchemasType

51 , Public

@@ -369,13 +369,13 @@ data SchemumType

369 | View RowType

370 | Typedef PGType

371 | Index

372− | Function FunctionType

372+ | Function [NullityType] ReturnsType

373 | Operator OperatorType

374 | UnsafeSchemum Symbol

375

376−data FunctionType

376+data ReturnsType

377− = Fun [NullityType] NullityType

377+ = Returns NullityType

378− | SetFun [NullityType] [NullityType]

378+ | ReturnsTable RowType

379

380data OperatorType

381 = BinaryOp NullityType NullityType NullityType