b983def · rel8 · git.iko.soy

git.iko.soy/rel8

Magic Sql constraint synonym

commitb983def6a9a9ff46cf467a914f912c99b62b2b02 authorShane O'Brien <shane.obrien@circuithub.com> dateTue 23 Mar 2021, 17:12 (6 years ago) parentb5fc074

24 files changed+136−162

compare with master

unifiedsplit

src/Rel8/Expr.hs+6−6

@@ -32,7 +32,7 @@ import Rel8.Expr.Opaleye

3232import Rel8.Expr.Serialize ( litExpr )

3333import Rel8.Schema.Nullability

3434 ( Nullability( Nullable, NonNullable )

35− , Nullabilizes, nullabilization

35+ , Sql, nullabilization

3636 )

3737import Rel8.Type ( DBType )

3838import Rel8.Type.Monoid ( DBMonoid, memptyExpr )

@@ -46,25 +46,25 @@ newtype Expr a = Expr Opaleye.PrimExpr

4646 deriving stock Show

4747

4848

49−instance (DBSemigroup db, Nullabilizes db a) => Semigroup (Expr a) where

49+instance Sql DBSemigroup a => Semigroup (Expr a) where

5050 (<>) = case nullabilization @a of

5151 Nullable -> liftOpNullable (<>.)

5252 NonNullable -> (<>.)

5353

5454

55−instance (DBMonoid db, Nullabilizes db a) => Monoid (Expr a) where

55+instance Sql DBMonoid a => Monoid (Expr a) where

5656 mempty = case nullabilization @a of

5757 Nullable -> nullify memptyExpr

5858 NonNullable -> memptyExpr

5959

6060

61−instance (IsString db, DBType db, Nullabilizes db a) => IsString (Expr a) where

61+instance (Sql IsString a, Sql DBType a) => IsString (Expr a) where

6262 fromString = litExpr . case nullabilization @a of

6363 Nullable -> Just . fromString

6464 NonNullable -> fromString

6565

6666

67−instance (DBNum db, Nullabilizes db a) => Num (Expr a) where

67+instance Sql DBNum a => Num (Expr a) where

6868 (+) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:+))

6969 (*) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:*))

7070 (-) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:-))

@@ -77,7 +77,7 @@ instance (DBNum db, Nullabilizes db a) => Num (Expr a) where

7777 fromInteger = castExpr . fromPrimExpr . Opaleye.ConstExpr . Opaleye.IntegerLit

7878

7979

80−instance (DBFractional db, Nullabilizes db a) => Fractional (Expr a) where

80+instance Sql DBFractional a => Fractional (Expr a) where

8181 (/) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:/))

8282

8383 fromRational =

src/Rel8/Expr/Aggregate.hs+9−8

@@ -1,4 +1,5 @@

11{-# language DataKinds #-}

2+{-# language FlexibleContexts #-}

23{-# language ScopedTypeVariables #-}

34{-# language TypeApplications #-}

45{-# language TypeFamilies #-}

@@ -37,7 +38,7 @@ import Rel8.Expr.Opaleye

3738 )

3839import Rel8.Expr.Null ( null )

3940import Rel8.Expr.Serialize ( litExpr )

40−import Rel8.Schema.Nullability ( Nullability, Nullabilizes, nullabilization )

41+import Rel8.Schema.Nullability ( Nullability, Sql, nullabilization )

4142import Rel8.Type.Array ( fromPrimArray )

4243import Rel8.Type.Eq ( DBEq )

4344import Rel8.Type.Num ( DBNum )

@@ -97,7 +98,7 @@ or = unsafeMakeAggregate toPrimExpr fromPrimExpr $

9798

9899

99100-- | Produce an aggregation for @Expr a@ using the @max@ function.

100−max :: (DBMax db, Nullabilizes db a) => Expr a -> Aggregate (Expr a)

101+max :: Sql DBMax a => Expr a -> Aggregate (Expr a)

101102max = unsafeMakeAggregate toPrimExpr fromPrimExpr $

102103 Just Aggregator

103104 { operation = Opaleye.AggrSum

@@ -107,7 +108,7 @@ max = unsafeMakeAggregate toPrimExpr fromPrimExpr $

107108

108109

109110-- | Produce an aggregation for @Expr a@ using the @max@ function.

110−min :: (DBMin db, Nullabilizes db a) => Expr a -> Aggregate (Expr a)

111+min :: Sql DBMin a => Expr a -> Aggregate (Expr a)

111112min = unsafeMakeAggregate toPrimExpr fromPrimExpr $

112113 Just Aggregator

113114 { operation = Opaleye.AggrSum

@@ -116,7 +117,7 @@ min = unsafeMakeAggregate toPrimExpr fromPrimExpr $

116117 }

117118

118119-- | Corresponds to @sum@.

119−sum :: (DBSum db, Nullabilizes db a) => Expr a -> Aggregate (Expr a)

120+sum :: Sql DBSum a => Expr a -> Aggregate (Expr a)

120121sum = unsafeMakeAggregate toPrimExpr (castExpr . fromPrimExpr) $

121122 Just Aggregator

122123 { operation = Opaleye.AggrSum

@@ -125,12 +126,12 @@ sum = unsafeMakeAggregate toPrimExpr (castExpr . fromPrimExpr) $

125126 }

126127

127128

128−sumWhere :: (DBNum db, DBSum db, Nullabilizes db a)

129+sumWhere :: (Sql DBNum a, Sql DBSum a)

129130 => Expr Bool -> Expr a -> Aggregate (Expr a)

130131sumWhere condition a = sum (caseExpr [(condition, a)] 0)

131132

132133

133−stringAgg :: (DBString db, Nullabilizes db a)

134+stringAgg :: Sql DBString a

134135 => Expr db -> Expr a -> Aggregate (Expr a)

135136stringAgg delimiter =

136137 unsafeMakeAggregate toPrimExpr (castExpr . fromPrimExpr) $

@@ -141,8 +142,8 @@ stringAgg delimiter =

141142 }

142143

143144

144−-- | Aggregate a value by grouping by it.

145−groupByExpr :: (DBEq db, Nullabilizes db a) => Expr a -> Aggregate (Expr a)

145+-- | Aggregate a value by grouping by it.

146+groupByExpr :: Sql DBEq a => Expr a -> Aggregate (Expr a)

146147groupByExpr = sgroupByExpr nullabilization

147148

148149

src/Rel8/Expr/Array.hs+7−7

@@ -28,7 +28,7 @@ import Rel8.Expr.Opaleye

2828import Rel8.Type ( DBType, typeInformation )

2929import Rel8.Type.Array ( array, zipPrimArraysWith )

3030import Rel8.Type.Information ( TypeInformation(..) )

31−import Rel8.Schema.Nullability ( Nullability, Nullabilizes )

31+import Rel8.Schema.Nullability ( Unnullify, Nullability, Sql )

3232

3333

3434sappend :: Expr [a] -> Expr [a] -> Expr [a]

@@ -43,11 +43,11 @@ sempty :: Nullability t a -> TypeInformation t -> Expr [a]

4343sempty _ info = fromPrimExpr $ array info []

4444

4545

46−listOf :: forall a t. (Nullabilizes t a, DBType t)

47− => [Expr a] -> Expr [a]

48−listOf = fromPrimExpr . array (typeInformation @t) . fmap toPrimExpr

46+listOf :: forall a. Sql DBType a => [Expr a] -> Expr [a]

47+listOf =

48+ fromPrimExpr . array (typeInformation @(Unnullify a)) . fmap toPrimExpr

4949

5050

51−nonEmptyOf :: forall a t. (Nullabilizes t a, DBType t)

52− => NonEmpty (Expr a) -> Expr (NonEmpty a)

53−nonEmptyOf = fromPrimExpr . array (typeInformation @t) . fmap toPrimExpr

51+nonEmptyOf :: forall a. Sql DBType a => NonEmpty (Expr a) -> Expr (NonEmpty a)

52+nonEmptyOf =

53+ fromPrimExpr . array (typeInformation @(Unnullify a)) . fmap toPrimExpr

src/Rel8/Expr/Eq.hs+5−5

@@ -1,3 +1,4 @@

1+{-# language FlexibleContexts #-}

12{-# language GADTs #-}

23{-# language LambdaCase #-}

34{-# language ViewPatterns #-}

@@ -27,7 +28,7 @@ import Rel8.Expr.Null ( isNull, unsafeLiftOpNullable )

2728import Rel8.Expr.Opaleye ( fromPrimExpr, toPrimExpr, zipPrimExprsWith )

2829import Rel8.Schema.Nullability

2930 ( Nullability( NonNullable, Nullable )

30− , Nullabilizes, nullabilization

31+ , Sql, nullabilization

3132 )

3233import Rel8.Type.Eq ( DBEq )

3334

@@ -65,12 +66,12 @@ sin nullability (toList -> as) a = case nullability of

6566 (Opaleye.ListExpr (toPrimExpr <$> xs))

6667

6768

68−(==.) :: (DBEq db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

69+(==.) :: Sql DBEq a => Expr a -> Expr a -> Expr Bool

6970(==.) = seq nullabilization

7071infix 4 ==.

7172

7273

73−(/=.) :: (DBEq db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

74+(/=.) :: Sql DBEq a => Expr a -> Expr a -> Expr Bool

7475(/=.) = sne nullabilization

7576infix 4 /=.

7677

@@ -93,6 +94,5 @@ infix 4 /=?

9394--

9495-- >>> select c $ return $ lit (42 :: Int32) `in_` [ lit x | x <- [1..5] ]

9596-- [False]

96−in_ :: (DBEq db, Nullabilizes db a, Foldable f)

97− => f (Expr a) -> Expr a -> Expr Bool

97+in_ :: (Sql DBEq a, Foldable f) => f (Expr a) -> Expr a -> Expr Bool

9898in_ = sin nullabilization

src/Rel8/Expr/Function.hs+4−6

@@ -25,7 +25,7 @@ import Rel8.Expr.Opaleye

2525 ( castExpr

2626 , fromPrimExpr, toPrimExpr, zipPrimExprsWith

2727 )

28−import Rel8.Schema.Nullability ( Nullabilizes )

28+import Rel8.Schema.Nullability ( Sql )

2929import Rel8.Type ( DBType )

3030

3131

@@ -34,8 +34,7 @@ class Function arg res where

3434 applyArgument :: ([Opaleye.PrimExpr] -> Opaleye.PrimExpr) -> arg -> res

3535

3636

37−instance (arg ~ Expr a, DBType db, Nullabilizes db b) => Function arg (Expr b)

38− where

37+instance (arg ~ Expr a, Sql DBType b) => Function arg (Expr b) where

3938 applyArgument f a = castExpr $ fromPrimExpr $ f [toPrimExpr a]

4039

4140

@@ -81,13 +80,12 @@ function = applyArgument . Opaleye.FunExpr

8180--

8281-- >>> select c $ pure $ sqlPi

8382-- [3.141592653589793]

84−nullaryFunction :: (DBType db, Nullabilizes db a) => String -> Expr a

83+nullaryFunction :: Sql DBType a => String -> Expr a

8584nullaryFunction name = castExpr $ Expr (Opaleye.FunExpr name [])

8685

8786

8887-- | Construct an expression by applying an infix binary operator to two

8988-- operands.

90−binaryOperator :: (DBType db, Nullabilizes db c)

91− => String -> Expr a -> Expr b -> Expr c

89+binaryOperator :: Sql DBType c => String -> Expr a -> Expr b -> Expr c

9290binaryOperator operator a b =

9391 castExpr $ zipPrimExprsWith (Opaleye.BinExpr (Opaleye.OpOther operator)) a b

src/Rel8/Expr/Num.hs+10−33

@@ -1,3 +1,4 @@

1+{-# language FlexibleContexts #-}

12{-# language TypeFamilies #-}

34{-# options_ghc -fno-warn-redundant-constraints #-}

@@ -14,67 +15,43 @@ import Prelude ()

1415import Rel8.Expr ( Expr( Expr ) )

1516import Rel8.Expr.Function ( function )

1617import Rel8.Expr.Opaleye ( castExpr )

17−import Rel8.Schema.Nullability ( IsMaybe, Nullabilizes )

18+import Rel8.Schema.Nullability ( IsMaybe, Sql )

1819import Rel8.Type.Num ( DBFractional, DBIntegral, DBNum )

1920

2021

21−fromIntegral ::

22− ( DBIntegral _a, Nullabilizes _a a

23− , DBNum _b, Nullabilizes _b b

24− , IsMaybe a ~ IsMaybe b

25− )

22+fromIntegral :: (Sql DBIntegral a, Sql DBNum b, IsMaybe a ~ IsMaybe b)

2623 => Expr a -> Expr b

2724fromIntegral (Expr a) = castExpr (Expr a)

2825

2926

30−realToFrac ::

31− ( DBNum _a, Nullabilizes _a a

32− , DBFractional _b, Nullabilizes _b b

33− , IsMaybe a ~ IsMaybe b

34− )

27+realToFrac :: (Sql DBNum a, Sql DBFractional b, IsMaybe a ~ IsMaybe b)

3528 => Expr a -> Expr b

3629realToFrac (Expr a) = castExpr (Expr a)

3730

3831

39−ceiling ::

40− ( DBFractional _a, Nullabilizes _a a

41− , DBIntegral _b, Nullabilizes _b b

42− , IsMaybe a ~ IsMaybe b

43− )

32+ceiling :: (Sql DBFractional a, Sql DBIntegral b, IsMaybe a ~ IsMaybe b)

4433 => Expr a -> Expr b

4534ceiling = function "CEILING"

4635

4736

48−div :: (DBIntegral _a, Nullabilizes _a a) => Expr a -> Expr a -> Expr a

37+div :: Sql DBIntegral a => Expr a -> Expr a -> Expr a

4938div = function "DIV"

5039

5140

52−mod :: (DBIntegral _a, Nullabilizes _a a) => Expr a -> Expr a -> Expr a

41+mod :: Sql DBIntegral a => Expr a -> Expr a -> Expr a

5342mod = function "MOD"

5443

5544

56−floor ::

57− ( DBFractional _a, Nullabilizes _a a

58− , DBIntegral _b, Nullabilizes _b b

59− , IsMaybe a ~ IsMaybe b

60− )

45+floor :: (Sql DBFractional a, Sql DBIntegral b, IsMaybe a ~ IsMaybe b)

6146 => Expr a -> Expr b

6247floor = function "FLOOR"

6348

6449

65−round ::

66− ( DBFractional _a, Nullabilizes _a a

67− , DBIntegral _b, Nullabilizes _b b

68− , IsMaybe a ~ IsMaybe b

69− )

50+round :: (Sql DBFractional a, Sql DBIntegral b, IsMaybe a ~ IsMaybe b)

7051 => Expr a -> Expr b

7152round = function "ROUND"

7253

7354

74−truncate ::

75− ( DBFractional _a, Nullabilizes _a a

76− , DBIntegral _b, Nullabilizes _b b

77− , IsMaybe a ~ IsMaybe b

78− )

55+truncate :: (Sql DBFractional a, Sql DBIntegral b, IsMaybe a ~ IsMaybe b)

7956 => Expr a -> Expr b

8057truncate = function "TRUNC"

src/Rel8/Expr/Opaleye.hs+4−4

@@ -25,16 +25,16 @@ import qualified Opaleye.Internal.HaskellDB.PrimQuery as Opaleye

2525

2626-- rel8

2727import {-# SOURCE #-} Rel8.Expr ( Expr( Expr ) )

28−import Rel8.Schema.Nullability ( Nullability, Nullabilizes, nullabilization )

28+import Rel8.Schema.Nullability ( Nullability, Sql, nullabilization )

2929import Rel8.Type ( DBType, typeInformation )

3030import Rel8.Type.Information ( TypeInformation(..) )

3131

3232

33−castExpr :: (DBType db, Nullabilizes db a) => Expr a -> Expr a

33+castExpr :: Sql DBType a => Expr a -> Expr a

3434castExpr = scastExpr nullabilization typeInformation

3535

3636

37−unsafeCastExpr :: (DBType db, Nullabilizes db b) => Expr a -> Expr b

37+unsafeCastExpr :: Sql DBType b => Expr a -> Expr b

3838unsafeCastExpr = sunsafeCastExpr nullabilization typeInformation

3939

4040

@@ -48,7 +48,7 @@ sunsafeCastExpr _ TypeInformation {typeName} =

4848 fromPrimExpr . Opaleye.CastExpr typeName . toPrimExpr

4949

5050

51−unsafeLiteral :: (DBType db, Nullabilizes db a) => String -> Expr a

51+unsafeLiteral :: Sql DBType a => String -> Expr a

5252unsafeLiteral = castExpr . Expr . Opaleye.ConstExpr . Opaleye.OtherLit

5353

5454

src/Rel8/Expr/Ord.hs+8−10

@@ -1,4 +1,5 @@

11{-# language DataKinds #-}

2+{-# language FlexibleContexts #-}

23{-# language LambdaCase #-}

34{-# language GADTs #-}

45{-# language ScopedTypeVariables #-}

@@ -27,7 +28,7 @@ import Rel8.Expr.Null ( isNull, isNonNull, nullable, unsafeLiftOpNullable )

2728import Rel8.Expr.Opaleye ( zipPrimExprsWith )

2829import Rel8.Schema.Nullability

2930 ( Nullability( NonNullable, Nullable )

30− , Nullabilizes, nullabilization

31+ , Sql, nullabilization

3132 )

3233import Rel8.Type.Ord ( DBOrd )

3334

@@ -72,26 +73,25 @@ sge = \case

7273 NonNullable -> ge

7374

7475

75−-- | The PostgreSQL @<@ operator.

76−(<.) :: (DBOrd db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

76+(<.) :: Sql DBOrd a => Expr a -> Expr a -> Expr Bool

7777(<.) = slt nullabilization

7878infix 4 <.

7979

8080

8181-- | The PostgreSQL @<=@ operator.

82−(<=.) :: (DBOrd db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

82+(<=.) :: Sql DBOrd a => Expr a -> Expr a -> Expr Bool

8383(<=.) = sle nullabilization

8484infix 4 <=.

8585

8686

8787-- | The PostgreSQL @>@ operator.

88−(>.) :: (DBOrd db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

88+(>.) :: Sql DBOrd a => Expr a -> Expr a -> Expr Bool

8989(>.) = sgt nullabilization

9090infix 4 >.

9191

9292

9393-- | The PostgreSQL @>=@ operator.

94−(>=.) :: (DBOrd db, Nullabilizes db a) => Expr a -> Expr a -> Expr Bool

94+(>=.) :: Sql DBOrd a => Expr a -> Expr a -> Expr Bool

9595(>=.) = sge nullabilization

9696infix 4 >=.

9797

@@ -116,8 +116,7 @@ a >=? b = coalesce $ unsafeLiftOpNullable ge a b

116116infix 4 >=?

117117

118118

119−leastExpr :: forall a db. (DBOrd db, Nullabilizes db a)

120− => Expr a -> Expr a -> Expr a

119+leastExpr :: forall a. Sql DBOrd a => Expr a -> Expr a -> Expr a

121120leastExpr ma mb = case nullabilization @a of

122121 Nullable -> nullable ma (\a -> nullable mb (least_ a) mb) ma

123122 NonNullable -> least_ ma mb

@@ -125,8 +124,7 @@ leastExpr ma mb = case nullabilization @a of

125124 least_ (Expr a) (Expr b) = Expr (Opaleye.FunExpr "LEAST" [a, b])

126125

127126

128−greatestExpr :: forall a db. (DBOrd db, Nullabilizes db a)

129− => Expr a -> Expr a -> Expr a

127+greatestExpr :: forall a. Sql DBOrd a => Expr a -> Expr a -> Expr a

130128greatestExpr ma mb = case nullabilization @a of

131129 Nullable -> nullable mb (\a -> nullable ma (greatest_ a) mb) ma

132130 NonNullable -> greatest_ ma mb

src/Rel8/Expr/Serialize.hs+3−2

@@ -1,3 +1,4 @@

1+{-# language FlexibleContexts #-}

12{-# language NamedFieldPuns #-}

23{-# language TypeFamilies #-}

@@ -22,13 +23,13 @@ import {-# SOURCE #-} Rel8.Expr ( Expr( Expr ) )

2223import Rel8.Expr.Opaleye ( scastExpr )

2324import Rel8.Schema.Nullability

2425 ( Nullability( Nullable, NonNullable )

25− , Nullabilizes, nullabilization

26+ , Sql, nullabilization

2627 )

2728import Rel8.Type ( DBType, typeInformation )

2829import Rel8.Type.Information ( TypeInformation(..) )

2930

3031

31−litExpr :: (DBType db, Nullabilizes db a) => a -> Expr a

32+litExpr :: Sql DBType a => a -> Expr a

3233litExpr = slitExpr nullabilization typeInformation

3334

3435

src/Rel8/Schema/Context.hs+5−18

@@ -33,7 +33,7 @@ import Rel8.Kind.Necessity

3333 , SNecessity( SOptional, SRequired )

3434 , KnownNecessity, necessitySing

3535 )

36−import Rel8.Schema.Nullability ( Nullabilizes )

36+import Rel8.Schema.Nullability ( Sql )

3737import Rel8.Schema.Spec ( Context, Spec( Spec ) )

3838import Rel8.Schema.Structure ( Structure )

3939import Rel8.Type.Monoid ( DBMonoid )

@@ -55,21 +55,13 @@ data DB spec where

5555deriving stock instance Show (DB spec)

5656

5757

58−instance

59− ( spec ~ 'Spec labels necessity dbType a

60− , DBSemigroup dbType

61− , Nullabilizes dbType a

62− ) =>

58+instance (spec ~ 'Spec labels necessity dbType a, Sql DBSemigroup a) =>

6359 Semigroup (DB spec)

6460 where

6561 DB a <> DB b = DB (a <> b)

6662

6763

68−instance

69− ( spec ~ 'Spec labels necessity dbType a

70− , DBMonoid dbType

71− , Nullabilizes dbType a

72− ) =>

64+instance (spec ~ 'Spec labels necessity dbType a, Sql DBMonoid a) =>

7365 Monoid (DB spec)

7466 where

7567 mempty = DB mempty

@@ -86,11 +78,7 @@ data Insertion spec where

8678deriving stock instance Show (Insertion spec)

8779

8880

89−instance

90− ( spec ~ 'Spec labels necessity dbType a

91− , DBSemigroup dbType

92− , Nullabilizes dbType a

93− ) =>

81+instance (spec ~ 'Spec labels necessity dbType a, Sql DBSemigroup a) =>

9482 Semigroup (Insertion spec)

9583 where

9684 RequiredInsert a <> RequiredInsert b = RequiredInsert (a <> b)

@@ -100,8 +88,7 @@ instance

10088instance

10189 ( spec ~ 'Spec labels necessity dbType a

10290 , KnownNecessity necessity

103− , DBMonoid dbType

104− , Nullabilizes dbType a

91+ , Sql DBMonoid a

10592 ) => Monoid (Insertion spec)

10693 where

10794 mempty = case necessitySing @necessity of

src/Rel8/Schema/Context/Nullify.hs+3−6

@@ -41,10 +41,7 @@ import Rel8.Schema.Context

4141 , Insertion( RequiredInsert, OptionalInsert )

4242 , Name( Name )

4343 )

44−import Rel8.Schema.Nullability

45− ( Nullability( Nullable, NonNullable )

46− , Nullabilizes

47− )

44+import Rel8.Schema.Nullability ( Nullability( Nullable, NonNullable ), Sql )

4845import Rel8.Schema.Spec ( Context, Spec( Spec ), SSpec(..) )

4946import Rel8.Type.Eq ( DBEq )

5047import Rel8.Type.Monoid ( DBMonoid )

@@ -52,11 +49,11 @@ import Rel8.Type.Monoid ( DBMonoid )

5249

5350type Nullifiable :: Context -> Constraint

5451class Nullifiable context where

55− encodeTag :: (DBEq db, Nullabilizes db a, KnownLabels labels)

52+ encodeTag :: (Sql DBEq a, KnownLabels labels)

5653 => Expr a

5754 -> context ('Spec labels 'Required db a)

5855

59− decodeTag :: (DBMonoid db, Nullabilizes db a)

56+ decodeTag :: Sql DBMonoid a

6057 => context ('Spec labels 'Required db a)

6158 -> Expr a

6259

src/Rel8/Schema/HTable/Type.hs+2−2

@@ -23,7 +23,7 @@ import Rel8.Schema.HTable

2323 , hfield, htabulate, htraverse, hdicts, hspecs

2424 )

2525import Rel8.Schema.HTable.Context ( H, HKTable )

26−import Rel8.Schema.Nullability ( Unnullify, Nullabilizes, nullabilization )

26+import Rel8.Schema.Nullability ( Unnullify, Sql, nullabilization )

2727import Rel8.Schema.Spec ( Context, Spec( Spec ), SSpec(..) )

2828import Rel8.Type ( DBType, typeInformation )

2929

@@ -40,7 +40,7 @@ data HTypeField a spec where

4040 HTypeField :: HTypeField a ('Spec '[""] 'Required (Unnullify a) a)

4141

4242

43−instance (DBType db, Nullabilizes db a) => HTable (HType a) where

43+instance Sql DBType a => HTable (HType a) where

4444 type HConstrainTable (HType a) c = c ('Spec '[""] 'Required (Unnullify a) a)

4545 type HField (HType a) = HTypeField a

4646

src/Rel8/Schema/Nullability.hs+14

@@ -9,10 +9,12 @@

99{-# language StandaloneKindSignatures #-}

1010{-# language TypeFamilies #-}

1111{-# language UndecidableInstances #-}

12+{-# language UndecidableSuperClasses #-}

1213

1314module Rel8.Schema.Nullability

1415 ( IsMaybe, Nullify, Unnullify

1516 , Nullability( Nullable, NonNullable )

17+ , Sql

1618 , Nullabilizes, nullabilization

1719 )

1820where

@@ -82,5 +84,17 @@ instance Nullabilizes' (IsMaybe ma) a ma => Nullabilizes a ma

8284instance {-# OVERLAPPING #-} Nullabilizes Opaque Opaque

8385

8486

87+type Sql :: (Type -> Constraint) -> Type -> Constraint

88+class

89+ ( (forall c. (forall x. (constraint x => c x)) => Sql c a)

90+ , Nullabilizes (Unnullify a) a

91+ , constraint (Unnullify a)

92+ )

93+ => Sql constraint a

94+instance (constraint db, Nullabilizes db a) => Sql constraint a

95+instance {-# OVERLAPPING #-} (constraint Opaque, Sql constraint Opaque) => Sql constraint Opaque

96+-- instance {-# OVERLAPPING #-} Sql OpaqueC Opaque => Sql OpaqueC Opaque

97+

98+

8599nullabilization :: forall a db. Nullabilizes db a => Nullability db a

86100nullabilization = nullabilization'

src/Rel8/Schema/Spec.hs+5−4

@@ -23,7 +23,7 @@ import Rel8.Kind.Necessity

2323 , SNecessity

2424 , KnownNecessity, necessitySing

2525 )

26−import Rel8.Schema.Nullability ( Nullability, Nullabilizes, nullabilization )

26+import Rel8.Schema.Nullability ( Unnullify, Nullability, Sql, nullabilization )

2727import Rel8.Type ( DBType, typeInformation )

2828import Rel8.Type.Information ( TypeInformation )

2929

@@ -51,9 +51,10 @@ class KnownSpec spec where

5151instance

5252 ( KnownLabels labels

5353 , KnownNecessity necessity

54− , DBType db

55− , Nullabilizes db a

56− ) => KnownSpec ('Spec labels necessity db a)

54+ , Sql DBType a

55+ , db ~ Unnullify a

56+ )

57+ => KnownSpec ('Spec labels necessity db a)

5758 where

5859 specSing = SSpec

5960 { labels = labelsSing

src/Rel8/Table.hs+3−3

@@ -38,7 +38,7 @@ import Rel8.Schema.HTable.Quartet ( HQuartet(..) )

3838import Rel8.Schema.HTable.Quintet ( HQuintet(..) )

3939import Rel8.Schema.HTable.Trio ( HTrio(..) )

4040import Rel8.Schema.HTable.Type ( HType( HType ) )

41−import Rel8.Schema.Nullability ( Nullabilizes )

41+import Rel8.Schema.Nullability ( Sql )

4242import Rel8.Schema.Spec ( SSpec( SSpec ), KnownSpec )

4343import qualified Rel8.Schema.Spec as Kind ( Context )

4444import Rel8.Type ( DBType )

@@ -82,7 +82,7 @@ instance Table DB a => Table Aggregation (Aggregate a) where

8282 Aggregation a -> DB <$> a

8383

8484

85−instance (DBType db, Nullabilizes db a) => Table DB (Expr a) where

85+instance Sql DBType a => Table DB (Expr a) where

8686 type Columns (Expr a) = HType a

8787 type Context (Expr a) = DB

8888

@@ -90,7 +90,7 @@ instance (DBType db, Nullabilizes db a) => Table DB (Expr a) where

9090 fromColumns (HType (DB a)) = a

9191

9292

93−instance (DBType db, Nullabilizes db a) => Table Result (Identity a) where

93+instance Sql DBType a => Table Result (Identity a) where

9494 type Columns (Identity a) = HType a

9595 type Context (Identity a) = Result

9696

src/Rel8/Table/Maybe.hs+5−4

@@ -41,8 +41,9 @@ import Rel8.Schema.HTable.Label ( HLabel, hlabel, hunlabel )

4141import Rel8.Schema.HTable.Maybe ( HMaybeTable(..) )

4242import Rel8.Schema.HTable.Nullify ( hnullify, hunnullify )

4343import Rel8.Schema.Nullability

44− ( Nullability( Nullable, NonNullable )

45− , Nullabilizes, nullabilization

44+ ( Nullify

45+ , Nullability( Nullable, NonNullable )

46+ , Sql, nullabilization

4647 )

4748import Rel8.Table ( Table, Columns, Context, fromColumns, toColumns )

4849import Rel8.Table.Alternative

@@ -196,8 +197,8 @@ justTable = MaybeTable (nullify (litExpr IsJust))

196197--

197198-- >>> select c $ fmap (fst $?) (optional (values [lit (True, False)]))

198199-- [Just True]

199−($?) :: forall a b db. (DBType db, Nullabilizes db b)

200− => (a -> Expr b) -> MaybeTable a -> Expr (Maybe db)

200+($?) :: forall a b. Sql DBType b

201+ => (a -> Expr b) -> MaybeTable a -> Expr (Nullify b)

201202f $? ma@(MaybeTable _ a) = case nullabilization @b of

202203 Nullable -> boolExpr (f a) null (isNothingTable ma)

203204 NonNullable -> boolExpr (nullify (f a)) null (isNothingTable ma)

src/Rel8/Table/Recontextualize.hs+10−10

@@ -29,7 +29,7 @@ import Rel8.Schema.Context ( Aggregation, DB, Insertion, Name, Result )

2929import Rel8.Schema.Context.Label ( Labelable )

3030import Rel8.Schema.HTable ( HTable )

3131import Rel8.Schema.HTable.Context ( H )

32−import Rel8.Schema.Nullability ( Nullabilizes )

32+import Rel8.Schema.Nullability ( Sql )

3333import Rel8.Schema.Spec ( KnownSpec )

3434import qualified Rel8.Schema.Spec as Kind ( Context )

3535import Rel8.Table ( Table, Congruent )

@@ -51,39 +51,39 @@ class

5151 , b from -> a

5252

5353

54−instance (DBType db, Nullabilizes db a) =>

54+instance Sql DBType a =>

5555 Recontextualize Aggregation Aggregation (Aggregate (Expr a)) (Aggregate (Expr a))

5656

5757

58−instance (DBType db, Nullabilizes db a) =>

58+instance Sql DBType a =>

5959 Recontextualize Aggregation DB (Aggregate (Expr a)) (Expr a)

6060

6161

62−instance (DBType db, Nullabilizes db a) =>

62+instance Sql DBType a =>

6363 Recontextualize Aggregation Result (Aggregate (Expr a)) (Identity a)

6464

6565

66−instance (DBType db, Nullabilizes db a) =>

66+instance Sql DBType a =>

6767 Recontextualize DB Aggregation (Expr a) (Aggregate (Expr a))

6868

6969

70−instance (DBType db, Nullabilizes db a) =>

70+instance Sql DBType a =>

7171 Recontextualize DB DB (Expr a) (Expr a)

7272

7373

74−instance (DBType db, Nullabilizes db a) =>

74+instance Sql DBType a =>

7575 Recontextualize DB Result (Expr a) (Identity a)

7676

7777

78−instance (DBType db, Nullabilizes db a) =>

78+instance Sql DBType a =>

7979 Recontextualize Result Aggregation (Identity a) (Aggregate (Expr a))

8080

8181

82−instance (DBType db, Nullabilizes db a) =>

82+instance Sql DBType a =>

8383 Recontextualize Result DB (Identity a) (Expr a)

8484

8585

86−instance (DBType db, Nullabilizes db a) =>

86+instance Sql DBType a =>

8787 Recontextualize Result Result (Identity a) (Identity a)

8888

8989

src/Rel8/Table/Serialize.hs+5−7

@@ -47,7 +47,7 @@ import Rel8.Schema.HTable.Pair ( HPair(..) )

4747import Rel8.Schema.HTable.Trio ( HTrio(..) )

4848import Rel8.Schema.HTable.Type ( HType(..) )

4949import Rel8.Schema.HTable.Context ( H )

50−import Rel8.Schema.Nullability ( IsMaybe, Nullabilizes )

50+import Rel8.Schema.Nullability ( IsMaybe, Sql )

5151import Rel8.Schema.Spec ( SSpec(..), KnownSpec )

5252import Rel8.Table ( Table, Columns, fromColumns, toColumns )

5353import Rel8.Table.Either ( EitherTable )

@@ -151,8 +151,7 @@ instance

151151

152152

153153instance

154− ( DBType db

155− , Nullabilizes db a

154+ ( Sql DBType a

156155 , IsListTabular a ~ 'False

157156 , x ~ [a]

158157 ) => ExprsFor 'False 'False [a] (Expr x)

@@ -162,9 +161,9 @@ instance

162161

163162

164163instance

165− ( DBType a

166− , Nullabilizes a (Maybe a)

164+ ( Sql DBType a

167165 , isTabular ~ 'False

166+ , IsMaybe a ~ 'False

168167 , IsMaybeTabular a ~ 'False

169168 , x ~ Maybe a

170169 ) => ExprsFor 'False 'False (Maybe a) (Expr x)

@@ -174,8 +173,7 @@ instance

174173

175174

176175instance

177− ( DBType db

178− , Nullabilizes db a

176+ ( Sql DBType a

179177 , IsListTabular a ~ 'False

180178 , x ~ NonEmpty a

181179 ) => ExprsFor 'False 'False (NonEmpty a) (Expr x)

src/Rel8/Type.hs+3−3

@@ -36,7 +36,7 @@ import qualified Opaleye.Internal.HaskellDB.Sql.Default as Opaleye ( quote )

3636

3737-- rel8

3838import Rel8.Opaque ( Opaque )

39−import Rel8.Schema.Nullability ( Nullabilizes, nullabilization )

39+import Rel8.Schema.Nullability ( Sql, nullabilization )

4040import Rel8.Type.Array ( listTypeInformation, nonEmptyTypeInformation )

4141import Rel8.Type.Information ( TypeInformation(..), mapTypeInformation )

4242

@@ -301,11 +301,11 @@ instance DBType Value where

301301 }

302302

303303

304−instance (DBType db, Nullabilizes db a) => DBType [a] where

304+instance Sql DBType a => DBType [a] where

305305 typeInformation = listTypeInformation nullabilization typeInformation

306306

307307

308−instance (DBType db, Nullabilizes db a) => DBType (NonEmpty a) where

308+instance Sql DBType a => DBType (NonEmpty a) where

309309 typeInformation = nonEmptyTypeInformation nullabilization typeInformation

310310

311311

src/Rel8/Type/Array1D.hs+10−9

@@ -43,8 +43,9 @@ import qualified Opaleye.Internal.HaskellDB.PrimQuery as Opaleye

4343import Rel8.Expr.Opaleye ( zipPrimExprsWith )

4444import Rel8.Expr.Serialize ( litExpr )

4545import Rel8.Schema.Nullability

46− ( Nullability( Nullable, NonNullable )

47− , Nullabilizes, nullabilization

46+ ( Unnullify

47+ , Nullability( Nullable, NonNullable )

48+ , Sql, nullabilization

4849 )

4950import Rel8.Type ( DBType, typeInformation )

5051import Rel8.Type.Eq ( DBEq )

@@ -111,25 +112,25 @@ array1DTypeInformation nullability info =

111112 null = Opaleye.ConstExpr Opaleye.NullLit

112113

113114

114−instance (DBType db, Nullabilizes db a, IsArray1D db ~ 'False) => DBType (Array1D a) where

115+instance (Sql DBType a, IsArray1D (Unnullify a) ~ 'False) => DBType (Array1D a) where

115116 typeInformation = array1DTypeInformation nullabilization typeInformation

116117

117118

118−instance (DBEq db, Nullabilizes db a, IsArray1D db ~ 'False) => DBEq (Array1D a)

119+instance (Sql DBEq a, IsArray1D (Unnullify a) ~ 'False) => DBEq (Array1D a)

119120

120121

121−instance (DBOrd db, Nullabilizes db a, IsArray1D db ~ 'False) => DBOrd (Array1D a)

122+instance (Sql DBOrd a, IsArray1D (Unnullify a) ~ 'False) => DBOrd (Array1D a)

122123

123124

124−instance (DBMax db, Nullabilizes db a, IsArray1D db ~ 'False) => DBMax (Array1D a)

125+instance (Sql DBMax a, IsArray1D (Unnullify a) ~ 'False) => DBMax (Array1D a)

125126

126127

127−instance (DBMin db, Nullabilizes db a, IsArray1D db ~ 'False) => DBMin (Array1D a)

128+instance (Sql DBMin a, IsArray1D (Unnullify a) ~ 'False) => DBMin (Array1D a)

128129

129130

130−instance (DBType db, Nullabilizes db a, IsArray1D db ~ 'False) => DBSemigroup (Array1D a) where

131+instance (Sql DBType a, IsArray1D (Unnullify a) ~ 'False) => DBSemigroup (Array1D a) where

131132 (<>.) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:||))

132133

133134

134−instance (DBType db, Nullabilizes db a, IsArray1D db ~ 'False) => DBMonoid (Array1D a) where

135+instance (Sql DBType a, IsArray1D (Unnullify a) ~ 'False) => DBMonoid (Array1D a) where

135136 memptyExpr = litExpr mempty

src/Rel8/Type/Eq.hs+3−3

@@ -26,7 +26,7 @@ import Data.CaseInsensitive ( CI )

2626

2727-- rel8

2828import Rel8.Opaque ( Opaque )

29−import Rel8.Schema.Nullability ( Nullabilizes )

29+import Rel8.Schema.Nullability ( Sql )

3030import Rel8.Type ( DBType )

3131

3232-- scientific

@@ -104,6 +104,6 @@ instance DBEq ByteString

104104instance DBEq Lazy.ByteString

105105instance DBEq UUID

106106instance DBEq Value

107−instance (DBEq db, Nullabilizes db a) => DBEq [a]

108−instance (DBEq db, Nullabilizes db a) => DBEq (NonEmpty a)

107+instance Sql DBEq a => DBEq [a]

108+instance Sql DBEq a => DBEq (NonEmpty a)

109109instance DBEq Opaque

src/Rel8/Type/Monoid.hs+2−2

@@ -26,7 +26,7 @@ import Data.CaseInsensitive ( CI )

2626import {-# SOURCE #-} Rel8.Expr ( Expr )

2727import Rel8.Expr.Array ( sempty )

2828import Rel8.Expr.Serialize ( litExpr )

29−import Rel8.Schema.Nullability ( Nullabilizes, nullabilization )

29+import Rel8.Schema.Nullability ( Sql, nullabilization )

3030import Rel8.Type ( DBType, typeInformation )

3131import Rel8.Type.Semigroup ( DBSemigroup )

3232

@@ -43,7 +43,7 @@ class DBSemigroup a => DBMonoid a where

4343 memptyExpr :: Expr a

4444

4545

46−instance (DBType db, Nullabilizes db a) => DBMonoid [a] where

46+instance Sql DBType a => DBMonoid [a] where

4747 memptyExpr = sempty nullabilization typeInformation

4848

4949

src/Rel8/Type/Ord.hs+7−7

@@ -24,7 +24,7 @@ import Data.CaseInsensitive ( CI )

2424

2525-- rel8

2626import Rel8.Opaque ( Opaque )

27−import Rel8.Schema.Nullability ( Nullabilizes )

27+import Rel8.Schema.Nullability ( Sql )

2828import Rel8.Type.Eq ( DBEq )

2929

3030-- scientific

@@ -66,8 +66,8 @@ instance DBOrd (CI Lazy.Text)

6666instance DBOrd ByteString

6767instance DBOrd Lazy.ByteString

6868instance DBOrd UUID

69−instance (DBOrd db, Nullabilizes db a) => DBOrd [a]

70−instance (DBOrd db, Nullabilizes db a) => DBOrd (NonEmpty a)

69+instance Sql DBOrd a => DBOrd [a]

70+instance Sql DBOrd a => DBOrd (NonEmpty a)

7171instance {-# OVERLAPPING #-} DBOrd Opaque

7272

7373

@@ -93,8 +93,8 @@ instance DBMax (CI Text)

9393instance DBMax (CI Lazy.Text)

9494instance DBMax ByteString

9595instance DBMax Lazy.ByteString

96−instance (DBMax db, Nullabilizes db a) => DBMax [a]

97−instance (DBMax db, Nullabilizes db a) => DBMax (NonEmpty a)

96+instance Sql DBMax a => DBMax [a]

97+instance Sql DBMax a => DBMax (NonEmpty a)

9898

9999

100100type DBMin :: Type -> Constraint

@@ -119,5 +119,5 @@ instance DBMin (CI Text)

119119instance DBMin (CI Lazy.Text)

120120instance DBMin ByteString

121121instance DBMin Lazy.ByteString

122−instance (DBMin db, Nullabilizes db a) => DBMin [a]

123−instance (DBMin db, Nullabilizes db a) => DBMin (NonEmpty a)

122+instance Sql DBMin a => DBMin [a]

123+instance Sql DBMin a => DBMin (NonEmpty a)

src/Rel8/Type/Semigroup.hs+3−3

@@ -30,7 +30,7 @@ import qualified Opaleye.Internal.HaskellDB.PrimQuery as Opaleye

3030-- rel8

3131import {-# SOURCE #-} Rel8.Expr ( Expr )

3232import Rel8.Expr.Opaleye ( zipPrimExprsWith )

33−import Rel8.Schema.Nullability ( Nullabilizes )

33+import Rel8.Schema.Nullability ( Sql )

3434import Rel8.Type ( DBType )

3535

3636-- text

@@ -47,11 +47,11 @@ class DBType a => DBSemigroup a where

4747 infixr 6 <>.

4848

4949

50−instance (DBType db, Nullabilizes db a) => DBSemigroup [a] where

50+instance Sql DBType a => DBSemigroup [a] where

5151 (<>.) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:||))

5252

5353

54−instance (DBType db, Nullabilizes db a) => DBSemigroup (NonEmpty a) where

54+instance Sql DBType a => DBSemigroup (NonEmpty a) where

5555 (<>.) = zipPrimExprsWith (Opaleye.BinExpr (Opaleye.:||))

5656

5757