0eafb7b · squeal · git.iko.soy

git.iko.soy/squeal

style

* renderAlias * UpdateExpression

commit0eafb7bc2af4bd586ec56223e2197d19e1a7ecf0 authorEitan Chatav <eitan.chatav@gmail.com> dateWed 26 Jul 2017, 14:48 (9 years ago) parent6523018

3 files changed+92−91

compare with dev

unifiedsplit

squeel-postgresql/src/Squeel/PostgreSQL/Schema.hs+4 squeel-postgresql/src/Squeel/PostgreSQL/Statement.hs+84−87 squeel-postgresql/test/Squeel/PostgreSQL/StatementSpec.hs+4−4

squeel-postgresql/src/Squeel/PostgreSQL/Schema.hs+4

@@ -22,6 +22,7 @@ module Squeel.PostgreSQL.Schema

2222 , PGFloating

2323 , (:::)

2424 , Alias (Alias)

25+ , renderAlias

2526 , Aliased (As)

2627 , renderAliased

2728 , NullityType (..)

@@ -108,6 +109,9 @@ type (:::) (alias :: Symbol) (ty :: polykind) = '(alias,ty)

108109

109110data Alias (alias :: Symbol) = Alias (Proxy# alias)

110111

112+renderAlias :: KnownSymbol alias => Alias alias -> ByteString

113+renderAlias (Alias alias) = fromString (symbolVal' alias)

114+

111115instance alias1 ~ alias2 => IsLabel alias1 (Alias alias2) where

112116 fromLabel = Alias

113117

squeel-postgresql/src/Squeel/PostgreSQL/Statement.hs+84−87

@@ -78,10 +78,8 @@ instance (HasColumn column columns ty, tables ~ '[table ::: columns])

7878(&.)

7979 :: (HasTable table tables columns, HasColumn column columns ty)

8080 => Alias table -> Alias column -> Expression params tables ty

81−Alias table &. Alias column = UnsafeExpression $

82− fromString (symbolVal' table)

83− <> "." <>

84− fromString (symbolVal' column)

81+table &. column = UnsafeExpression $

82+ renderAlias table <> "." <> renderAlias column

8583

8684def :: Expression params '[] ('Optional (nullity ty))

8785def = UnsafeExpression "DEFAULT"

@@ -691,8 +689,8 @@ dotStarFrom

691689 => Alias table

692690 -> TableExpression params schema tables

693691 -> Selection params schema columns

694−Alias tab `dotStarFrom` tabs = UnsafeSelection $

695− fromString (symbolVal' tab) <> ".* FROM " <> renderTableExpression tabs

692+table `dotStarFrom` tables = UnsafeSelection $

693+ renderAlias table <> ".* FROM " <> renderTableExpression tables

696694

697695from

698696 :: SListI columns

@@ -726,9 +724,9 @@ createTable

726724 => Alias table

727725 -> NP (Aliased TypeExpression) columns

728726 -> Statement '[] '[] schema (Create table columns schema)

729−createTable (Alias table) columns = UnsafeStatement $ mconcat

727+createTable table columns = UnsafeStatement $ mconcat

730728 [ "CREATE TABLE "

731− , fromString $ symbolVal' table

729+ , renderAlias table

732730 , " ("

733731 , ByteString.intercalate ", " . hcollapse $

734732 hmap (K . renderColumn) columns

@@ -736,8 +734,8 @@ createTable (Alias table) columns = UnsafeStatement $ mconcat

736734 ]

737735 where

738736 renderColumn :: Aliased TypeExpression x -> ByteString

739− renderColumn (ty `As` Alias column) =

740− fromString (symbolVal' column) <> " " <> renderTypeExpression ty

737+ renderColumn (ty `As` column) =

738+ renderAlias column <> " " <> renderTypeExpression ty

741739

742740{-----------------------------------------

743741DROP statements

@@ -747,8 +745,8 @@ dropTable

747745 :: KnownSymbol table

748746 => Alias table

749747 -> Statement '[] '[] schema (Drop table schema)

750−dropTable (Alias table) = UnsafeStatement $

751− "DROP TABLE " <> fromString (symbolVal' table) <> ";"

748+dropTable table = UnsafeStatement $

749+ "DROP TABLE " <> renderAlias table <> ";"

752750

753751{-----------------------------------------

754752ALTER statements

@@ -759,9 +757,9 @@ alterTable

759757 => Alias table

760758 -> AlterTable columns0 columns1

761759 -> Statement '[] '[] schema (Alter table schema columns1)

762−alterTable (Alias table) alteration = UnsafeStatement $

760+alterTable table alteration = UnsafeStatement $

763761 "ALTER TABLE "

764− <> fromString (symbolVal' table)

762+ <> renderAlias table

765763 <> " "

766764 <> renderAlterTable alteration

767765 <> ";"

@@ -771,11 +769,11 @@ alterTableRename

771769 => Alias table0

772770 -> Alias table1

773771 -> Statement '[] '[] schema (Rename table0 table1 schema)

774−alterTableRename (Alias table0) (Alias table1) = UnsafeStatement $

772+alterTableRename table0 table1 = UnsafeStatement $

775773 "ALTER TABLE "

776− <> fromString (symbolVal' table0)

774+ <> renderAlias table0

777775 <> " RENAME TO "

778− <> fromString (symbolVal' table1)

776+ <> renderAlias table1

779777 <> ";"

780778

781779data AlterTable

@@ -788,9 +786,9 @@ addColumnDefault

788786 => Alias column

789787 -> TypeExpression ('Optional ty)

790788 -> AlterTable columns (Create column ('Optional ty) columns)

791−addColumnDefault (Alias column) ty = UnsafeAlterTable $

789+addColumnDefault column ty = UnsafeAlterTable $

792790 "ADD COLUMN "

793− <> fromString (symbolVal' column)

791+ <> renderAlias column

794792 <> " "

795793 <> renderTypeExpression ty

796794

@@ -799,9 +797,9 @@ addColumnNull

799797 => Alias column

800798 -> TypeExpression ('Required ('Null ty))

801799 -> AlterTable columns ((column ::: 'Required ('Null ty)) ': columns)

802−addColumnNull (Alias column) ty = UnsafeAlterTable $

800+addColumnNull column ty = UnsafeAlterTable $

803801 "ADD COLUMN "

804− <> fromString (symbolVal' column)

802+ <> renderAlias column

805803 <> " "

806804 <> renderTypeExpression ty

807805

@@ -809,25 +807,25 @@ dropColumn

809807 :: KnownSymbol column

810808 => Alias column

811809 -> AlterTable columns (Drop column columns)

812−dropColumn (Alias column) = UnsafeAlterTable $

813− "DROP COLUMN " <> fromString (symbolVal' column)

810+dropColumn column = UnsafeAlterTable $

811+ "DROP COLUMN " <> renderAlias column

814812

815813renameColumn

816814 :: (KnownSymbol column0, KnownSymbol column1)

817815 => Alias column0

818816 -> Alias column1

819817 -> AlterTable columns (Rename column0 column1 columns)

820−renameColumn (Alias column0) (Alias column1) = UnsafeAlterTable $

821− "RENAME COLUMN " <> fromString (symbolVal' column0)

822− <> " TO " <> fromString (symbolVal' column1)

818+renameColumn column0 column1 = UnsafeAlterTable $

819+ "RENAME COLUMN " <> renderAlias column0

820+ <> " TO " <> renderAlias column1

823821

824822alterColumn

825823 :: (KnownSymbol column, HasColumn column columns ty0)

826824 => Alias column

827825 -> AlterColumn ty0 ty1

828826 -> AlterTable columns (Alter column columns ty1)

829−alterColumn (Alias column) alteration = UnsafeAlterTable $

830− "ALTER COLUMN " <> fromString (symbolVal' column)

827+alterColumn column alteration = UnsafeAlterTable $

828+ "ALTER COLUMN " <> renderAlias column

831829 <> " " <> renderAlterColumn alteration

832830

833831data AlterColumn (ty0 :: ColumnType) (ty1 :: ColumnType) =

@@ -865,15 +863,15 @@ insertInto

865863 => Alias table

866864 -> NP (Aliased (Expression params '[])) columns

867865 -> Statement params '[] schema schema

868−insertInto (Alias table) expressions = UnsafeStatement $ "INSERT INTO "

869− <> fromString (symbolVal' table)

866+insertInto table expressions = UnsafeStatement $ "INSERT INTO "

867+ <> renderAlias table

870868 <> " (" <> ByteString.intercalate ", " aliases

871869 <> ") VALUES ("

872870 <> ByteString.intercalate ", " values

873871 <> ");"

874872 where

875873 aliases = hcollapse $ hmap

876− (\ (_ `As` Alias name) -> K (fromString (symbolVal' name)))

874+ (\ (_ `As` name) -> K (renderAlias name))

877875 expressions

878876 values = hcollapse $ hmap

879877 (\ (expression `As` _) -> K (renderExpression expression))

@@ -885,10 +883,10 @@ insertIntoReturning

885883 -> NP (Aliased (Expression params '[])) columns

886884 -> NP (Aliased (Expression params '[table ::: columns])) results

887885 -> Statement params results schema schema

888−insertIntoReturning (Alias table) inserts results

886+insertIntoReturning table inserts results

889887 = UnsafeStatement . mconcat $

890888 [ "INSERT INTO "

891− , fromString (symbolVal' table)

889+ , renderAlias table

892890 , " (" <> ByteString.intercalate ", " aliases

893891 , ") VALUES ("

894892 , ByteString.intercalate ", " values

@@ -898,7 +896,7 @@ insertIntoReturning (Alias table) inserts results

898896 ]

899897 where

900898 aliases = hcollapse $ hmap

901− (\ (_ `As` Alias name) -> K (fromString (symbolVal' name)))

899+ (\ (_ `As` name) -> K (renderAlias name))

902900 inserts

903901 values = hcollapse $ hmap

904902 (\ (expression `As` _) -> K (renderExpression expression))

@@ -912,51 +910,49 @@ insertIntoReturning (Alias table) inserts results

912910UPDATE statements

913911-----------------------------------------}

914912

915−set :: Expression params tables x -> (Maybe :.: Expression params tables) x

916−set = Comp . Just

913+data UpdateExpression params table ty

914+ = Same

915+ | Set (Expression params table ty)

917916

918−same :: (Maybe :.: Expression params tables) x

919−same = Comp Nothing

920−

921−renderSet

922− :: Aliased (Maybe :.: Expression params '[table ::: columns]) column

917+renderUpdateExpression

918+ :: Aliased (UpdateExpression params '[table ::: columns]) column

923919 -> Maybe ByteString

924−renderSet = \case

925− Comp (Just expression) `As` Alias column -> Just $ mconcat

926− [ fromString $ symbolVal' column

920+renderUpdateExpression = \case

921+ Same `As` _ -> Nothing

922+ Set expression `As` column -> Just $ mconcat

923+ [ renderAlias column

927924 , " = "

928925 , renderExpression expression

929926 ]

930− Comp Nothing `As` _ -> Nothing

931927

932928update

933929 :: (HasTable table schema columns, SListI columns)

934930 => Alias table

935− -> NP (Aliased (Maybe :.: Expression params '[table ::: columns])) columns

931+ -> NP (Aliased (UpdateExpression params '[table ::: columns])) columns

936932 -> Predicate params '[table ::: columns]

937933 -> Statement params '[] schema schema

938−update (Alias table) columns wh = UnsafeStatement $ mconcat

934+update table columns wh = UnsafeStatement $ mconcat

939935 [ "UPDATE "

940− , fromString $ symbolVal' table

936+ , renderAlias table

941937 , " SET "

942938 , ByteString.intercalate ", " . catMaybes . hcollapse $

943− hmap (K . renderSet) columns

939+ hmap (K . renderUpdateExpression) columns

944940 , " WHERE ", renderExpression wh, ";"

945941 ]

946942

947943updateReturning

948944 :: (SListI columns, SListI results, HasTable table schema columns)

949945 => Alias table

950− -> NP (Aliased (Maybe :.: Expression params '[table ::: columns])) columns

946+ -> NP (Aliased (UpdateExpression params '[table ::: columns])) columns

951947 -> Predicate params '[table ::: columns]

952948 -> NP (Aliased (Expression params '[table ::: columns])) results

953949 -> Statement params results schema schema

954−updateReturning (Alias table) updates wh results = UnsafeStatement $ mconcat

950+updateReturning table updates wh results = UnsafeStatement $ mconcat

955951 [ "UPDATE "

956− , fromString $ symbolVal' table

952+ , renderAlias table

957953 , " SET "

958954 , ByteString.intercalate ", " . catMaybes . hcollapse $

959− hmap (K . renderSet) updates

955+ hmap (K . renderUpdateExpression) updates

960956 , " WHERE ", renderExpression wh

961957 , " RETURNING ", renderList results

962958 , ";"

@@ -971,24 +967,24 @@ upsertInto

971967 :: (SListI columns, HasTable table schema columns)

972968 => Alias table

973969 -> NP (Aliased (Expression params '[])) columns

974− -> NP (Aliased (Maybe :.: Expression params '[table ::: columns])) columns

970+ -> NP (Aliased (UpdateExpression params '[table ::: columns])) columns

975971 -> Predicate params '[table ::: columns]

976972 -> Statement params '[] schema schema

977−upsertInto (Alias table) inserts updates wh = UnsafeStatement . mconcat $

973+upsertInto table inserts updates wh = UnsafeStatement . mconcat $

978974 [ "INSERT INTO "

979− , fromString (symbolVal' table)

975+ , renderAlias table

980976 , " (" <> ByteString.intercalate ", " aliases

981977 , ") VALUES ("

982978 , ByteString.intercalate ", " values

983979 , ") ON CONFLICT UPDATE "

984− , fromString $ symbolVal' table

980+ , renderAlias table

985981 , " SET "

986982 , ByteString.intercalate ", " . catMaybes . hcollapse $

987− hmap (K . renderSet) updates

983+ hmap (K . renderUpdateExpression) updates

988984 , " WHERE ", renderExpression wh, ";"

989985 ] where

990986 aliases = hcollapse $ hmap

991− (\ (_ `As` Alias name) -> K (fromString (symbolVal' name)))

987+ (\ (_ `As` name) -> K (renderAlias name))

992988 inserts

993989 values = hcollapse $ hmap

994990 (\ (expression `As` _) -> K (renderExpression expression))

@@ -998,35 +994,36 @@ upsertIntoReturning

998994 :: (SListI columns, SListI results, HasTable table schema columns)

999995 => Alias table

1000996 -> NP (Aliased (Expression params '[])) columns

1001− -> NP (Aliased (Maybe :.: Expression params '[table ::: columns])) columns

997+ -> NP (Aliased (UpdateExpression params '[table ::: columns])) columns

1002998 -> Predicate params '[table ::: columns]

1003999 -> NP (Aliased (Expression params '[table ::: columns])) results

10041000 -> Statement params results schema schema

1005−upsertIntoReturning (Alias table) inserts updates wh results = UnsafeStatement . mconcat $

1006− [ "INSERT INTO "

1007− , fromString (symbolVal' table)

1008− , " (" <> ByteString.intercalate ", " aliases

1009− , ") VALUES ("

1010− , ByteString.intercalate ", " values

1011− , ") ON CONFLICT UPDATE "

1012− , fromString $ symbolVal' table

1013− , " SET "

1014− , ByteString.intercalate ", " . catMaybes . hcollapse $

1015− hmap (K . renderSet) updates

1016− , " WHERE ", renderExpression wh

1017− , " RETURNING ", renderList results

1018− , ";"

1019− ] where

1020− aliases = hcollapse $ hmap

1021− (\ (_ `As` Alias name) -> K (fromString (symbolVal' name)))

1022− inserts

1023− values = hcollapse $ hmap

1024− (\ (expression `As` _) -> K (renderExpression expression))

1025− inserts

1026− renderList

1027− = ByteString.intercalate ", "

1028− . hcollapse

1029− . hmap (K . renderAliased renderExpression)

1001+upsertIntoReturning table inserts updates wh results =

1002+ UnsafeStatement . mconcat $

1003+ [ "INSERT INTO "

1004+ , renderAlias table

1005+ , " (" <> ByteString.intercalate ", " aliases

1006+ , ") VALUES ("

1007+ , ByteString.intercalate ", " values

1008+ , ") ON CONFLICT UPDATE "

1009+ , renderAlias table

1010+ , " SET "

1011+ , ByteString.intercalate ", " . catMaybes . hcollapse $

1012+ hmap (K . renderUpdateExpression) updates

1013+ , " WHERE ", renderExpression wh

1014+ , " RETURNING ", renderList results

1015+ , ";"

1016+ ] where

1017+ aliases = hcollapse $ hmap

1018+ (\ (_ `As` name) -> K (renderAlias name))

1019+ inserts

1020+ values = hcollapse $ hmap

1021+ (\ (expression `As` _) -> K (renderExpression expression))

1022+ inserts

1023+ renderList

1024+ = ByteString.intercalate ", "

1025+ . hcollapse

1026+ . hmap (K . renderAliased renderExpression)

10301027

10311028{-----------------------------------------

10321029DELETE statements

@@ -1037,8 +1034,8 @@ deleteFrom

10371034 => Alias table

10381035 -> Predicate params '[table ::: columns]

10391036 -> Statement params '[] schema schema

1040−deleteFrom (Alias table) wh = UnsafeStatement $ mconcat

1037+deleteFrom table wh = UnsafeStatement $ mconcat

10411038 [ "DELETE FROM "

1042− , fromString $ symbolVal' table

1039+ , renderAlias table

10431040 , " WHERE ", renderExpression wh, ";"

10441041 ]

squeel-postgresql/test/Squeel/PostgreSQL/StatementSpec.hs+4−4

@@ -85,14 +85,14 @@ spec = do

8585 it "correctly renders simple UPDATEs" $ do

8686 let

8787 statement :: Statement '[] '[] Tables Tables

88− statement = update #table1 (set 2 `As` #col1 :* same `As` #col2 :* Nil) (#col1 /=* #col2)

88+ statement = update #table1 (Set 2 `As` #col1 :* Same `As` #col2 :* Nil) (#col1 /=* #col2)

8989 statement `shouldRenderAs`

9090 "UPDATE table1 SET col1 = 2 WHERE (col1 <> col2);"

9191 it "correctly renders returning UPDATEs" $ do

9292 let

9393 statement :: Statement '[] SumAndCol1 Tables Tables

9494 statement = updateReturning #table1

95− (set 2 `As` #col1 :* same `As` #col2 :* Nil)

95+ (Set 2 `As` #col1 :* Same `As` #col2 :* Nil)

9696 (#col1 /=* #col2)

9797 ((#col1 + #col2) `As` #sum :* #col1 :* Nil)

9898 statement `shouldRenderAs`

@@ -102,7 +102,7 @@ spec = do

102102 statement :: Statement '[] '[] Tables Tables

103103 statement = upsertInto #table1

104104 (2 `As` #col1 :* 4 `As` #col2 :* Nil)

105− (set 2 `As` #col1 :* same `As` #col2 :* Nil)

105+ (Set 2 `As` #col1 :* Same `As` #col2 :* Nil)

106106 (#col1 /=* #col2)

107107 statement `shouldRenderAs`

108108 "INSERT INTO table1 (col1, col2) VALUES (2, 4) ON CONFLICT UPDATE table1 SET col1 = 2 WHERE (col1 <> col2);"

@@ -111,7 +111,7 @@ spec = do

111111 statement :: Statement '[] SumAndCol1 Tables Tables

112112 statement = upsertIntoReturning #table1

113113 (2 `As` #col1 :* 4 `As` #col2 :* Nil)

114− (set 2 `As` #col1 :* same `As` #col2 :* Nil)

114+ (Set 2 `As` #col1 :* Same `As` #col2 :* Nil)

115115 (#col1 /=* #col2)

116116 ((#col1 + #col2) `As` #sum :* #col1 :* Nil)

117117 statement `shouldRenderAs`