Bug correction

README.md

@@ -4,7 +4,7 @@ Hedsql
 Hedsql is a EDSL (Embedded Domain-Specific Language) written in Haskell for SQL.
 
 It allows to create SQL statements in a compact, modular and flexible way.
-The output are strings, meaning that it can be used with in any database
-access library such as HDBC or [x]-simple, etc.
+Outputs are strings. It means that Hedsql can be used with in any database
+access library such as HDBC, [x]-simple, etc.
 
-Please see the GitHub Wiki for a quick start and examples.
+Take a look at the GitHub Wiki for a quick start and examples.

src/Database/Hedsql/Common/Constructor/DataManipulation.hs

@@ -37,13 +37,13 @@ import Database.Hedsql.Common.DataStructure
 -- | Create a column/value pair to be used in an UPDATE statement.
 assign ::
     (
-       ToCols      a [Column   c]
-    ,  ToSqlValues b [SqlValue c]
+       ToCols    a [Column c]
+    ,  ToColRefs b [ColRef c]
     )
     => a -- ^ Column or name of the column.
-    -> b -- ^ Value for this column.
+    -> b -- ^ Value for this column. It can also be an expression.
     -> Assignment c
-assign a val = Assignment (toCol a) (ValueExpr $ value val)
+assign a val = Assignment (toCol a) (expr val)
 
 -- | Create a DELETE FROM statement.
 deleteFrom ::

src/Database/Hedsql/Common/DataStructure/Select.hs

@@ -296,9 +296,9 @@ data Where a =
 
 -- | SQL Condition.
 data Condition a =
-      FuncCond (FuncBool a)
-    | And [Condition a]
-    | Or [Condition a]
+      FuncCond (FuncBool  a)
+    | And      [Condition a]
+    | Or       [Condition a]
       deriving (Show)
 
 -- | GROUP BY clause.

src/Database/Hedsql/Common/DataStructure/Update.hs

@@ -13,16 +13,17 @@ Data structure of the UPDATE statement.
 -}
 module Database.Hedsql.Common.DataStructure.Update where 
 
+--------------------------------------------------------------------------------
+-- IMPORTS
+--------------------------------------------------------------------------------
+
 import Database.Hedsql.Common.DataStructure.Select
 
 import Control.Lens
 
--- | UPDATE query.
-data Update a = Update
-    { _updateTable :: Table a
-    , _updateAssignments :: [Assignment a]
-    , _updateWherePart :: Maybe (Where a)
-    } deriving (Show)
+--------------------------------------------------------------------------------
+-- PUBLIC
+--------------------------------------------------------------------------------
 
 {-|
 A value assigned to a column (used in the SET clause of an UPDATE statement).
@@ -32,6 +33,13 @@ data Assignment a = Assignment
     , _assignmentVal :: Expression a
     } deriving (Show)
 
+-- | UPDATE query.
+data Update a = Update
+    { _updateTable :: Table a
+    , _updateAssignments :: [Assignment a]
+    , _updateWherePart :: Maybe (Where a)
+    } deriving (Show)
+
 -- Make the lenses.
 makeLenses ''Assignment
 makeLenses ''Update

src/Database/Hedsql/Common/Parser/Queries.hs

@@ -311,7 +311,7 @@ parseUpdateFunc parser update =
         , Just $ parser^.quoteElem $ update^.updateTable.tableName
         , Just   " SET "
         , Just $ intercalate ", " $ map (parser^.parseAssgnmt) assignments
-        , fmap (parser^.parseWhere) (update^.updateWherePart)
+        , fmap (\x -> " " ++ (parser^.parseWhere) x) (update^.updateWherePart)
         ]
     where
         assignments = update^.updateAssignments
@@ -634,12 +634,18 @@ parseWhereFunc parser (Where condition) =
 parseJoinClauseFunc :: QueryParser a -> JoinClause a -> String
 parseJoinClauseFunc parser jClause =
     case jClause of
-        JoinClauseOn predicate -> "ON " ++ (parser^.parseCondition) predicate
-        JoinClauseUsing cols -> concat
-                                [ "USING ("
-                                , intercalate ", " $ map (parser^.parseCol) cols
-                                , ")"
-                                ]
+        JoinClauseOn predicate ->
+            let cond = (parser^.parseCondition) predicate
+            in "ON " ++
+            case predicate of
+                FuncCond _ ->  cond
+                _          ->  "(" ++ cond ++ ")"
+        JoinClauseUsing cols ->
+            concat
+                [ "USING ("
+                , intercalate ", " $ map (parser^.parseCol) cols
+                , ")"
+                ]
 
 -- | Parser a join on a column.
 parseJoinTColFunc :: JoinTypeCol a -> String