8301eb7 · rel8 · git.iko.soy

git.iko.soy/rel8

on master help sign in

A ListTable can't really have default values and HVectorize oughtn't preserve Necessity

8301eb7Shane O'Brien5 years ago

src/Rel8/Schema/HTable/Vectorize.hs+6−4

compare with master

unifiedsplit

@@ -32,6 +32,7 @@ import Data.List.NonEmpty ( NonEmpty )

32import Prelude

34-- rel8

35+import Rel8.Kind.Necessity ( Necessity( Required ), SNecessity( SRequired ) )

35import Rel8.Schema.Context.Label ( HLabelable, hlabeler, hunlabeler )

36import Rel8.Schema.Context.Label ( HLabelable, hlabeler, hunlabeler )

36import Rel8.Schema.Dict ( Dict( Dict ) )

37import Rel8.Schema.Dict ( Dict( Dict ) )

37import qualified Rel8.Schema.Kind as K

38import qualified Rel8.Schema.Kind as K

@@ -78,14 +79,15 @@ newtype HVectorize list table context = HVectorize (HMapTable (Vectorize list) t

78data Vectorize :: (Type -> Type) -> Spec -> Exp Spec

79data Vectorize :: (Type -> Type) -> Spec -> Exp Spec

81−type instance Eval (Vectorize list ('Spec labels necessity a)) = 'Spec labels necessity (list a)

82+type instance Eval (Vectorize list ('Spec labels _necessity a)) = 'Spec labels 'Required (list a)

84instance Vector list => MapSpec (Vectorize list) where

85instance Vector list => MapSpec (Vectorize list) where

85 mapInfo = \case

86 mapInfo = \case

86 SSpec {..} -> case listNotNull @list nullity of

87 SSpec {..} -> case listNotNull @list nullity of

87 Dict -> SSpec

88 Dict -> SSpec

89+ { necessity = SRequired

88− { nullity = NotNull

90+ , nullity = NotNull

89 , info = vectorTypeInformation nullity info

91 , info = vectorTypeInformation nullity info

90 , ..

92 , ..

91 }

93 }

@@ -95,7 +97,7 @@ hvectorize :: (HTable t, Unzip f, Vector list)

95 => (forall labels necessity a. ()

97 => (forall labels necessity a. ()

96 => SSpec ('Spec labels necessity a)

98 => SSpec ('Spec labels necessity a)

97 -> f (context ('Spec labels necessity a))

99 -> f (context ('Spec labels necessity a))

98− -> context' ('Spec labels necessity (list a)))

100+ -> context' ('Spec labels 'Required (list a)))

99 -> f (t context)

101 -> f (t context)

100 -> HVectorize list t context'

102 -> HVectorize list t context'

101hvectorize vectorizer as = HVectorize $ htabulate $ \(HMapTableField field) ->

103hvectorize vectorizer as = HVectorize $ htabulate $ \(HMapTableField field) ->

@@ -107,7 +109,7 @@ hvectorize vectorizer as = HVectorize $ htabulate $ \(HMapTableField field) ->

107hunvectorize :: (HTable t, Repeat f, Vector list)

109hunvectorize :: (HTable t, Repeat f, Vector list)

108 => (forall labels necessity a. ()

110 => (forall labels necessity a. ()

109 => SSpec ('Spec labels necessity a)

111 => SSpec ('Spec labels necessity a)

110− -> context ('Spec labels necessity (list a))

112+ -> context ('Spec labels 'Required (list a))

111 -> f (context' ('Spec labels necessity a)))

113 -> f (context' ('Spec labels necessity a)))

112 -> HVectorize list t context

114 -> HVectorize list t context

113 -> f (t context')

115 -> f (t context')

src/Rel8/Schema/Result.hs+3−2

@@ -16,6 +16,7 @@ where

16import Prelude hiding ( null )

18-- rel8

19+import Rel8.Kind.Necessity ( Necessity( Required ) )

19import Rel8.Schema.Context ( Interpretation( Col ) )

20import Rel8.Schema.Context ( Interpretation( Col ) )

20import Rel8.Schema.HTable.Identity ( HIdentity(..) )

21import Rel8.Schema.HTable.Identity ( HIdentity(..) )

21import Rel8.Schema.Kind ( Context )

22import Rel8.Schema.Kind ( Context )

@@ -64,12 +65,12 @@ unnullifier SSpec {nullity} (Result a) =

64vectorizer :: Functor f

65vectorizer :: Functor f

65 => SSpec ('Spec labels necessity a)

66 => SSpec ('Spec labels necessity a)

66 -> f (Col Result ('Spec labels necessity a))

67 -> f (Col Result ('Spec labels necessity a))

67− -> Col Result ('Spec labels necessity (f a))

68+ -> Col Result ('Spec labels 'Required (f a))

68vectorizer _ = Result . fmap (\(Result a) -> a)

69vectorizer _ = Result . fmap (\(Result a) -> a)

71unvectorizer :: Functor f

72unvectorizer :: Functor f

72 => SSpec ('Spec labels necessity a)

73 => SSpec ('Spec labels necessity a)

73− -> Col Result ('Spec labels necessity (f a))

74+ -> Col Result ('Spec labels 'Required (f a))

74 -> f (Col Result ('Spec labels necessity a))

75 -> f (Col Result ('Spec labels necessity a))

75unvectorizer _ (Result results) = Result <$> results

76unvectorizer _ (Result results) = Result <$> results

src/Rel8/Table/List.hs+4−9

@@ -23,11 +23,10 @@ import Prelude

23-- rel8

24import Rel8.Expr ( Expr, Col(..) )

25import Rel8.Expr.Array ( sappend, sempty, slistOf )

26−import Rel8.Kind.Necessity ( SNecessity( SOptional, SRequired ) )

27import Rel8.Schema.Dict ( Dict( Dict ) )

26import Rel8.Schema.Dict ( Dict( Dict ) )

28import Rel8.Schema.HTable.List ( HListTable )

27import Rel8.Schema.HTable.List ( HListTable )

29import Rel8.Schema.HTable.Vectorize ( happend, hempty, hvectorize )

28import Rel8.Schema.HTable.Vectorize ( happend, hempty, hvectorize )

30−import Rel8.Schema.Insert ( Col( OptionalInsert, RequiredInsert ), Insert )

29+import Rel8.Schema.Insert ( Inserts )

31import Rel8.Schema.Name ( Col( NameCol ), Name )

30import Rel8.Schema.Name ( Col( NameCol ), Name )

32import Rel8.Schema.Null ( Nullity( Null, NotNull ) )

31import Rel8.Schema.Null ( Nullity( Null, NotNull ) )

33import Rel8.Schema.Spec ( SSpec(..) )

32import Rel8.Schema.Spec ( SSpec(..) )

@@ -42,6 +41,7 @@ import Rel8.Table.Alternative

42 , AlternativeTable, emptyTable

41 , AlternativeTable, emptyTable

43 )

42 )

44import Rel8.Table.Eq ( EqTable, eqTable )

43import Rel8.Table.Eq ( EqTable, eqTable )

44+import Rel8.Table.Insert ( toInsert )

45import Rel8.Table.Ord ( OrdTable, ordTable )

46import Rel8.Table.Recontextualize ( Recontextualize )

47import Rel8.Table.Serialize ( FromExprs, ToExprs, fromResult, toResult )

@@ -127,13 +127,8 @@ listTable =

127 fmap toColumns

128

129

130−insertListTable :: Table Insert a => [a] -> ListTable a

130+insertListTable :: Inserts exprs inserts => [exprs] -> ListTable inserts

131−insertListTable =

131+insertListTable = toInsert . listTable

132− ListTable .

133− hvectorize (\SSpec {necessity, info} -> case necessity of

134− SRequired -> RequiredInsert . slistOf info . fmap (\(RequiredInsert a) -> a)

135− SOptional -> OptionalInsert . fmap (slistOf info) . traverse (\(OptionalInsert a) -> a)) .

136− fmap toColumns

137

132

138

133

139nameListTable :: Table Name a => a -> ListTable a

134nameListTable :: Table Name a => a -> ListTable a

src/Rel8/Table/NonEmpty.hs+5−9

@@ -24,11 +24,10 @@ import Prelude

24-- rel8

25import Rel8.Expr ( Expr, Col(..) )

26import Rel8.Expr.Array ( sappend1, snonEmptyOf )

27−import Rel8.Kind.Necessity ( SNecessity( SOptional, SRequired ) )

28import Rel8.Schema.Dict ( Dict( Dict ) )

27import Rel8.Schema.Dict ( Dict( Dict ) )

29import Rel8.Schema.HTable.NonEmpty ( HNonEmptyTable )

28import Rel8.Schema.HTable.NonEmpty ( HNonEmptyTable )

30import Rel8.Schema.HTable.Vectorize ( happend, hvectorize )

29import Rel8.Schema.HTable.Vectorize ( happend, hvectorize )

31−import Rel8.Schema.Insert ( Col( OptionalInsert, RequiredInsert ), Insert )

30+import Rel8.Schema.Insert ( Inserts )

32import Rel8.Schema.Name ( Col( NameCol ), Name )

31import Rel8.Schema.Name ( Col( NameCol ), Name )

33import Rel8.Schema.Null ( Nullity( Null, NotNull ) )

32import Rel8.Schema.Null ( Nullity( Null, NotNull ) )

34import Rel8.Schema.Reify ( hreify, hunreify )

33import Rel8.Schema.Reify ( hreify, hunreify )

@@ -40,6 +39,7 @@ import Rel8.Table

40 )

39 )

41import Rel8.Table.Alternative ( AltTable, (<|>:) )

40import Rel8.Table.Alternative ( AltTable, (<|>:) )

42import Rel8.Table.Eq ( EqTable, eqTable )

41import Rel8.Table.Eq ( EqTable, eqTable )

42+import Rel8.Table.Insert ( toInsert )

43import Rel8.Table.Ord ( OrdTable, ordTable )

44import Rel8.Table.Recontextualize ( Recontextualize )

45import Rel8.Table.Serialize ( FromExprs, ToExprs, fromResult, toResult )

@@ -118,13 +118,9 @@ nonEmptyTable =

118 fmap toColumns

119

120

121+insertNonEmptyTable :: Inserts exprs inserts

121−insertNonEmptyTable :: Table Insert a => NonEmpty a -> NonEmptyTable a

122+ => NonEmpty exprs -> NonEmptyTable inserts

122−insertNonEmptyTable =

123+insertNonEmptyTable = toInsert . nonEmptyTable

123− NonEmptyTable .

124− hvectorize (\SSpec {necessity, info} -> case necessity of

125− SRequired -> RequiredInsert . snonEmptyOf info . fmap (\(RequiredInsert a) -> a)

126− SOptional -> OptionalInsert . fmap (snonEmptyOf info) . traverse (\(OptionalInsert a) -> a)) .

127− fmap toColumns

128

124

129

125

130nameNonEmptyTable :: Table Name a => a -> NonEmptyTable a

126nameNonEmptyTable :: Table Name a => a -> NonEmptyTable a