diff --git a/relational-query.cabal b/relational-query.cabal
--- a/relational-query.cabal
+++ b/relational-query.cabal
@@ -1,5 +1,5 @@
 name:                relational-query
-version:             0.2.1.0
+version:             0.3.0.0
 synopsis:            Typeful, Modular, Relational, algebraic query engine
 description:         This package contiains typeful relation structure and
                      relational-algebraic query building DSL which can
diff --git a/src/Database/Relational/Query/Effect.hs b/src/Database/Relational/Query/Effect.hs
--- a/src/Database/Relational/Query/Effect.hs
+++ b/src/Database/Relational/Query/Effect.hs
@@ -32,11 +32,11 @@
 import Database.Relational.Query.Context (Flat)
 import Database.Relational.Query.Pi (id')
 import Database.Relational.Query.Table (Table, TableDerivable, derivedTable)
-import Database.Relational.Query.Component (composeWhere, composeSets)
+import Database.Relational.Query.Component (Config, defaultConfig, composeWhere, composeSets)
 import Database.Relational.Query.Projection (Projection)
 import qualified Database.Relational.Query.Projection as Projection
 import Database.Relational.Query.Projectable
-  (PlaceHolders, placeholder, addPlaceHolders, (><), rightId)
+  (PlaceHolders, placeholder, unsafeAddPlaceHolders, (><), rightId)
 
 import Database.Relational.Query.Monad.Trans.Assigning (assignings, (<-#))
 import Database.Relational.Query.Monad.Restrict (Restrict, RestrictedStatement)
@@ -62,16 +62,16 @@
 runRestriction :: Restriction p r
                -> RestrictedStatement r (PlaceHolders p)
 runRestriction (Restriction qf) =
-  fmap fst . addPlaceHolders . qf
+  fmap fst . unsafeAddPlaceHolders . qf
 
 -- | SQL WHERE clause 'StringSQL' string from 'Restriction'.
-sqlWhereFromRestriction :: Table r -> Restriction p r -> StringSQL
-sqlWhereFromRestriction tbl (Restriction q) = composeWhere rs
-  where (_ph, rs) = Restrict.extract (q $ Projection.unsafeFromTable tbl)
+sqlWhereFromRestriction :: Config -> Table r -> Restriction p r -> StringSQL
+sqlWhereFromRestriction config tbl (Restriction q) = composeWhere rs
+  where (_ph, rs) = Restrict.extract (q $ Projection.unsafeFromTable tbl) config
 
 -- | Show where clause.
 instance TableDerivable r => Show (Restriction p r) where
-  show = showStringSQL . sqlWhereFromRestriction derivedTable
+  show = showStringSQL . sqlWhereFromRestriction defaultConfig derivedTable
 
 -- | UpdateTarget type with place-holder parameter 'p' and projection record type 'r'.
 newtype UpdateTarget p r = UpdateTarget (AssignStatement r ())
@@ -92,7 +92,7 @@
 _runUpdateTarget :: UpdateTarget p r
                  -> AssignStatement r (PlaceHolders p)
 _runUpdateTarget (UpdateTarget qf) =
-  fmap fst . addPlaceHolders . qf
+  fmap fst . unsafeAddPlaceHolders . qf
 
 updateAllColumn :: PersistableWidth r
                 => Restriction p r
@@ -128,6 +128,9 @@
 
 
 -- | SQL SET clause and WHERE clause 'StringSQL' string from 'UpdateTarget'
-sqlFromUpdateTarget :: Table r -> UpdateTarget p r -> StringSQL
-sqlFromUpdateTarget tbl (UpdateTarget q) = composeSets (asR tbl) <> composeWhere rs
-  where ((_ph, asR), rs) = Assign.extract (q (Projection.unsafeFromTable tbl))
+sqlFromUpdateTarget :: Config -> Table r -> UpdateTarget p r -> StringSQL
+sqlFromUpdateTarget config tbl (UpdateTarget q) = composeSets (asR tbl) <> composeWhere rs
+  where ((_ph, asR), rs) = Assign.extract (q (Projection.unsafeFromTable tbl)) config
+
+instance TableDerivable r => Show (UpdateTarget p r) where
+  show = showStringSQL . sqlFromUpdateTarget defaultConfig derivedTable
diff --git a/src/Database/Relational/Query/Monad/Aggregate.hs b/src/Database/Relational/Query/Monad/Aggregate.hs
--- a/src/Database/Relational/Query/Monad/Aggregate.hs
+++ b/src/Database/Relational/Query/Monad/Aggregate.hs
@@ -65,7 +65,7 @@
 
 -- | Restricted 'MonadRestrict' instance.
 instance MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q) where
-  restrictContext = restrictings . restrictContext
+  restrict = restrictings . restrict
 
 -- | Instance to lift from qualified table forms into 'QueryAggregate'.
 instance MonadQualify ConfigureQuery QueryAggregate where
diff --git a/src/Database/Relational/Query/Monad/Assign.hs b/src/Database/Relational/Query/Monad/Assign.hs
--- a/src/Database/Relational/Query/Monad/Assign.hs
+++ b/src/Database/Relational/Query/Monad/Assign.hs
@@ -1,3 +1,7 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
 -- |
 -- Module      : Database.Relational.Query.Monad.Assign
 -- Copyright   : 2013 Kei Hibino
@@ -15,13 +19,17 @@
   extract,
   ) where
 
-import Database.Relational.Query.Component (QueryRestriction, Assignments)
+import Control.Monad.Trans.Class (lift)
+
+import Database.Relational.Query.Component (Config, QueryRestriction, Assignments)
 import Database.Relational.Query.Context (Flat)
 import Database.Relational.Query.Table (Table)
 import Database.Relational.Query.Projection (Projection)
+import Database.Relational.Query.Monad.Class (MonadQualify(..))
 import Database.Relational.Query.Monad.Restrict (Restrict)
 import qualified Database.Relational.Query.Monad.Restrict as Restrict
 import Database.Relational.Query.Monad.Trans.Assigning (Assignings, extractAssignments)
+import Database.Relational.Query.Monad.Type (ConfigureQuery)
 
 -- | Target update monad type used from update statement and merge statement.
 type Assign r = Assignings r Restrict
@@ -32,10 +40,14 @@
 --   the same as 'Target' type parameter 'r'.
 type AssignStatement r a = Projection Flat r -> Assign r a
 
+-- | Instance to lift from qualified table forms into 'Restrict'.
+instance MonadQualify ConfigureQuery (Assign r) where
+  liftQualify = lift . liftQualify
+
 -- -- | 'return' of 'Update'
 -- updateStatement :: a -> Assignings r (Restrictings Identity) a
 -- updateStatement =  assignings . restrictings . Identity
 
 -- | Run 'Assign'.
-extract :: Assign r a -> ((a, Table r -> Assignments), QueryRestriction Flat)
+extract :: Assign r a -> Config -> ((a, Table r -> Assignments), QueryRestriction Flat)
 extract =  Restrict.extract . extractAssignments
diff --git a/src/Database/Relational/Query/Monad/Class.hs b/src/Database/Relational/Query/Monad/Class.hs
--- a/src/Database/Relational/Query/Monad/Class.hs
+++ b/src/Database/Relational/Query/Monad/Class.hs
@@ -16,7 +16,7 @@
   MonadQualify (..), MonadQualifyUnique(..), MonadRestrict (..),
   MonadQuery (..), MonadAggregate (..), MonadPartition (..),
 
-  all', distinct, restrict,
+  all', distinct,
   onE, on, wheresE, wheres,
   groupBy,
   havingE, having
@@ -26,9 +26,8 @@
 import Database.Relational.Query.Expr (Expr)
 import Database.Relational.Query.Component
   (Duplication (..), AggregateElem, AggregateColumnRef, aggregateColumnRef)
-import Database.Relational.Query.Projection (Projection)
+import Database.Relational.Query.Projection (Projection, predicateProjectionFromExpr)
 import qualified Database.Relational.Query.Projection as Projection
-import Database.Relational.Query.Projectable (expr)
 import Database.Relational.Query.Sub (SubQuery, Qualified)
 
 import Database.Relational.Query.Internal.Product (NodeAttr)
@@ -36,27 +35,28 @@
 -- | Restrict context interface
 class (Functor m, Monad m) => MonadRestrict c m where
   -- | Add restriction to this context.
-  restrictContext :: Expr c (Maybe Bool) -- ^ 'Expr' 'Projection' which represent restriction
-                  -> m ()                         -- ^ Restricted query context
+  restrict :: Projection c (Maybe Bool) -- ^ 'Projection' which represent restriction
+           -> m ()                      -- ^ Restricted query context
 
 -- | Query building interface.
 class (Functor m, Monad m) => MonadQuery m where
   -- | Specify duplication.
   setDuplication :: Duplication -> m ()
   -- | Add restriction to last join.
-  restrictJoin :: Expr Flat (Maybe Bool) -- ^ 'Expr' 'Projection' which represent restriction
-               -> m ()                   -- ^ Restricted query context
+  restrictJoin :: Projection Flat (Maybe Bool) -- ^ 'Projection' which represent restriction
+               -> m ()                         -- ^ Restricted query context
   -- | Unsafely join subquery with this query.
   unsafeSubQuery :: NodeAttr              -- ^ Attribute maybe or just
                  -> Qualified SubQuery    -- ^ 'SubQuery' to join
                  -> m (Projection Flat r) -- ^ Result joined context and 'SubQuery' result projection.
 
 -- | Lift interface from base qualify monad.
-class (Functor q, Monad q, MonadQuery m) => MonadQualify q m where
+class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m where
   -- | Lift from qualify monad 'q' into 'MonadQuery' m.
   --   Qualify monad qualifies table form 'SubQuery'.
   liftQualify :: q a -> m a
 
+-- The only method to lift to QueryUnique.
 -- | Lift interface from base qualify monad. Another constraint to support unique query.
 class (Functor q, Monad q, MonadQuery m) => MonadQualifyUnique q m where
   -- | Lift from qualify monad 'q' into 'MonadQuery' m.
@@ -84,19 +84,15 @@
 
 -- | Add restriction to last join.
 onE :: MonadQuery m => Expr Flat (Maybe Bool) -> m ()
-onE =  restrictJoin
+onE =  restrictJoin . predicateProjectionFromExpr
 
 -- | Add restriction to last join. Projection type version.
 on :: MonadQuery m => Projection Flat (Maybe Bool) -> m ()
-on =  restrictJoin . expr
-
--- | Add restriction to this query.
-restrict :: MonadRestrict c m => Projection c (Maybe Bool) -> m ()
-restrict =  restrictContext . expr
+on =  restrictJoin
 
 -- | Add restriction to this query. Expr type version.
 wheresE :: MonadRestrict Flat m => Expr Flat (Maybe Bool) -> m ()
-wheresE =  restrictContext
+wheresE =  restrict . predicateProjectionFromExpr
 
 -- | Add restriction to this not aggregated query.
 wheres :: MonadRestrict Flat m => Projection Flat (Maybe Bool) -> m ()
@@ -112,7 +108,7 @@
 
 -- | Add restriction to this aggregated query. Expr type version.
 havingE :: MonadRestrict Aggregated m => Expr Aggregated (Maybe Bool) -> m ()
-havingE =  restrictContext
+havingE =  restrict . predicateProjectionFromExpr
 
 -- | Add restriction to this aggregated query. Aggregated Projection type version.
 having :: MonadRestrict Aggregated m => Projection Aggregated (Maybe Bool) -> m ()
diff --git a/src/Database/Relational/Query/Monad/Restrict.hs b/src/Database/Relational/Query/Monad/Restrict.hs
--- a/src/Database/Relational/Query/Monad/Restrict.hs
+++ b/src/Database/Relational/Query/Monad/Restrict.hs
@@ -1,3 +1,7 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
 -- |
 -- Module      : Database.Relational.Query.Monad.Restrict
 -- Copyright   : 2013 Kei Hibino
@@ -16,26 +20,31 @@
   extract
   ) where
 
-import Data.Functor.Identity (Identity (..), runIdentity)
-
-import Database.Relational.Query.Component (QueryRestriction)
+import Database.Relational.Query.Component (Config, QueryRestriction)
 import Database.Relational.Query.Context (Flat)
 import Database.Relational.Query.Projection (Projection)
-import Database.Relational.Query.Monad.Trans.Restricting (Restrictings, extractRestrict)
+import Database.Relational.Query.Monad.Class (MonadQualify(..))
+import Database.Relational.Query.Monad.Trans.Restricting
+  (Restrictings, restrictings, extractRestrict)
+import Database.Relational.Query.Monad.Type (ConfigureQuery, configureQuery)
 
 
 -- | Restrict only monad type used from update statement and delete statement.
-type Restrict = Restrictings Flat Identity
+type Restrict = Restrictings Flat ConfigureQuery
 
 -- | RestrictedStatement type synonym.
 --   Projection record type 'r' must be
 --   the same as 'Restrictings' type parameter 'r'.
 type RestrictedStatement r a = Projection Flat r -> Restrict a
 
+-- | Instance to lift from qualified table forms into 'Restrict'.
+instance MonadQualify ConfigureQuery Restrict where
+  liftQualify = restrictings
+
 -- -- | 'return' of 'Restrict'
 -- restricted :: a -> Restrict a
 -- restricted =  restrict . Identity
 
 -- | Run 'Restrict' to get 'QueryRestriction'.
-extract :: Restrict a -> (a, QueryRestriction Flat)
-extract =  runIdentity . extractRestrict
+extract :: Restrict a -> Config -> (a, QueryRestriction Flat)
+extract =  configureQuery . extractRestrict
diff --git a/src/Database/Relational/Query/Monad/Trans/Aggregating.hs b/src/Database/Relational/Query/Monad/Trans/Aggregating.hs
--- a/src/Database/Relational/Query/Monad/Trans/Aggregating.hs
+++ b/src/Database/Relational/Query/Monad/Trans/Aggregating.hs
@@ -77,7 +77,7 @@
 
 -- | Aggregated 'MonadRestrict'.
 instance MonadRestrict c m => MonadRestrict c (AggregatingSetT m) where
-  restrictContext =  aggregatings . restrictContext
+  restrict =  aggregatings . restrict
 
 -- | Aggregated 'MonadQuery'.
 instance MonadQuery m => MonadQuery (AggregatingSetT m) where
diff --git a/src/Database/Relational/Query/Monad/Trans/Assigning.hs b/src/Database/Relational/Query/Monad/Trans/Assigning.hs
--- a/src/Database/Relational/Query/Monad/Trans/Assigning.hs
+++ b/src/Database/Relational/Query/Monad/Trans/Assigning.hs
@@ -53,7 +53,7 @@
 
 -- | 'MonadRestrict' with ordering.
 instance MonadRestrict c m => MonadRestrict c (Assignings r m) where
-  restrictContext = assignings . restrictContext
+  restrict = assignings . restrict
 
 -- | Target of assignment.
 type AssignTarget r v = Pi r v
diff --git a/src/Database/Relational/Query/Monad/Trans/Join.hs b/src/Database/Relational/Query/Monad/Trans/Join.hs
--- a/src/Database/Relational/Query/Monad/Trans/Join.hs
+++ b/src/Database/Relational/Query/Monad/Trans/Join.hs
@@ -36,6 +36,7 @@
 import Database.Relational.Query.Expr (Expr, fromJust)
 import Database.Relational.Query.Component (Duplication (All))
 import Database.Relational.Query.Sub (SubQuery, Qualified, JoinProduct)
+import Database.Relational.Query.Projectable (expr)
 
 import Database.Relational.Query.Monad.Class (MonadQuery (..))
 
@@ -62,7 +63,7 @@
 -- | Joinable query instance.
 instance (Monad q, Functor q) => MonadQuery (QueryJoin q) where
   setDuplication     = QueryJoin . lift . tell . Last . Just
-  restrictJoin       = updateJoinRestriction
+  restrictJoin       = updateJoinRestriction . expr
   unsafeSubQuery     = unsafeSubQueryWithAttr
 
 -- | Unsafely join subquery with this query.
diff --git a/src/Database/Relational/Query/Monad/Trans/Ordering.hs b/src/Database/Relational/Query/Monad/Trans/Ordering.hs
--- a/src/Database/Relational/Query/Monad/Trans/Ordering.hs
+++ b/src/Database/Relational/Query/Monad/Trans/Ordering.hs
@@ -52,7 +52,7 @@
 
 -- | 'MonadRestrict' with ordering.
 instance MonadRestrict rc m => MonadRestrict rc (Orderings c m) where
-  restrictContext = orderings . restrictContext
+  restrict = orderings . restrict
 
 -- | 'MonadQuery' with ordering.
 instance MonadQuery m => MonadQuery (Orderings c m) where
diff --git a/src/Database/Relational/Query/Monad/Trans/Restricting.hs b/src/Database/Relational/Query/Monad/Trans/Restricting.hs
--- a/src/Database/Relational/Query/Monad/Trans/Restricting.hs
+++ b/src/Database/Relational/Query/Monad/Trans/Restricting.hs
@@ -28,6 +28,7 @@
 
 import Database.Relational.Query.Expr (Expr, fromJust)
 import Database.Relational.Query.Component (QueryRestriction)
+import Database.Relational.Query.Projectable (expr)
 
 import Database.Relational.Query.Monad.Class (MonadRestrict(..), MonadQuery (..), MonadAggregate(..))
 
@@ -49,7 +50,7 @@
 
 -- | 'MonadRestrict' instance.
 instance (Monad q, Functor q) => MonadRestrict c (Restrictings c q) where
-  restrictContext = updateRestriction
+  restrict = updateRestriction . expr
 
 -- | Restricted 'MonadQuery' instance.
 instance MonadQuery q => MonadQuery (Restrictings c q) where
diff --git a/src/Database/Relational/Query/Monad/Unique.hs b/src/Database/Relational/Query/Monad/Unique.hs
--- a/src/Database/Relational/Query/Monad/Unique.hs
+++ b/src/Database/Relational/Query/Monad/Unique.hs
@@ -41,7 +41,7 @@
 queryUnique :: ConfigureQuery a -> QueryUnique a
 queryUnique =  QueryUnique . restrictings . join'
 
--- | Instance to lift from qualified table forms into 'QuerySimple'.
+-- | Instance to lift from qualified table forms into 'QueryUnique'.
 instance MonadQualifyUnique ConfigureQuery QueryUnique where
   liftQualifyUnique = queryUnique
 
diff --git a/src/Database/Relational/Query/Projectable.hs b/src/Database/Relational/Query/Projectable.hs
--- a/src/Database/Relational/Query/Projectable.hs
+++ b/src/Database/Relational/Query/Projectable.hs
@@ -26,7 +26,7 @@
   unsafeValueNull,
 
   -- * Placeholders
-  PlaceHolders, addPlaceHolders, unsafePlaceHolders,
+  PlaceHolders, unsafeAddPlaceHolders, unsafePlaceHolders,
   placeholder', placeholder, unitPlaceHolder,
 
   -- * Projectable into SQL strings
@@ -493,8 +493,8 @@
 data PlaceHolders p = PlaceHolders
 
 -- | Unsafely add placeholder parameter to queries.
-addPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)
-addPlaceHolders =  fmap ((,) PlaceHolders)
+unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)
+unsafeAddPlaceHolders =  fmap ((,) PlaceHolders)
 
 -- | Unsafely get placeholder parameter
 unsafePlaceHolders :: PlaceHolders p
diff --git a/src/Database/Relational/Query/Projection.hs b/src/Database/Relational/Query/Projection.hs
--- a/src/Database/Relational/Query/Projection.hs
+++ b/src/Database/Relational/Query/Projection.hs
@@ -22,6 +22,7 @@
   unsafeFromQualifiedSubQuery,
   unsafeFromScalarSubQuery,
   unsafeFromTable,
+  predicateProjectionFromExpr,
 
   -- * Projections
   pi, piMaybe, piMaybe',
@@ -47,15 +48,16 @@
 
 import Database.Relational.Query.Internal.SQL (rowListStringString)
 import Database.Relational.Query.Context (Aggregated, Flat)
-import Database.Relational.Query.Component (ColumnSQL)
+import Database.Relational.Query.Component (ColumnSQL, columnSQL')
 import Database.Relational.Query.Table (Table)
 import qualified Database.Relational.Query.Table as Table
 import Database.Relational.Query.Pure (ProductConstructor (..))
+import Database.Relational.Query.Expr.Unsafe (Expr, sqlExpr)
 import Database.Relational.Query.Pi (Pi)
 import qualified Database.Relational.Query.Pi.Unsafe as UnsafePi
 import Database.Relational.Query.Sub
   (SubQuery, Qualified,
-   UntypedProjection, widthOfUntypedProjection, columnsOfUntypedProjection,
+   UntypedProjection, widthOfUntypedProjection, columnsOfUntypedProjection, untypedProjectionFromColumns,
    untypedProjectionFromColumns, untypedProjectionFromJoinedSubQuery, untypedProjectionFromScalarSubQuery)
 import qualified Database.Relational.Query.Sub as SubQuery
 
@@ -97,6 +99,11 @@
 unsafeFromTable :: Table r
                 -> Projection c r
 unsafeFromTable =  unsafeFromColumns . Table.columns
+
+-- | Lift 'Expr' to 'Projection' to use as restrict predicate.
+predicateProjectionFromExpr :: Expr c (Maybe Bool) -> Projection c (Maybe Bool)
+predicateProjectionFromExpr =
+  typedProjection . untypedProjectionFromColumns . (:[]) .  columnSQL' . sqlExpr
 
 
 -- | Unsafely trace projection path.
diff --git a/src/Database/Relational/Query/Relation.hs b/src/Database/Relational/Query/Relation.hs
--- a/src/Database/Relational/Query/Relation.hs
+++ b/src/Database/Relational/Query/Relation.hs
@@ -73,7 +73,7 @@
   (Projection, ListProjection, unsafeListProjectionFromSubQuery)
 import qualified Database.Relational.Query.Projection as Projection
 import Database.Relational.Query.Projectable
-  (PlaceHolders, unitPlaceHolder, addPlaceHolders, unsafePlaceHolders, projectZip)
+  (PlaceHolders, unitPlaceHolder, unsafeAddPlaceHolders, unsafePlaceHolders, projectZip)
 import Database.Relational.Query.ProjectableExtended ((!))
 
 
@@ -106,9 +106,11 @@
 -- subQueryFromRelation =  configureQuery . subQueryQualifyFromRelation
 
 -- | Basic monadic join operation using 'MonadQuery'.
-queryWithAttr :: MonadQualify ConfigureQuery m
-              => NodeAttr -> Relation p r -> m (PlaceHolders p, Projection Flat r)
-queryWithAttr attr = addPlaceHolders . run where
+queryWithAttr :: (MonadQualify ConfigureQuery m, MonadQuery m)
+              => NodeAttr
+              -> Relation p r
+              -> m (PlaceHolders p, Projection Flat r)
+queryWithAttr attr = unsafeAddPlaceHolders . run where
   run rel = do
     q <- liftQualify $ do
       sq <- subQueryQualifyFromRelation rel
@@ -117,21 +119,29 @@
   -- d (Relation q) = unsafeMergeAnotherQuery attr q
 
 -- | Join subquery with place-holder parameter 'p'. query result is not 'Maybe'.
-query' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, Projection Flat r)
+query' :: (MonadQualify ConfigureQuery m, MonadQuery m)
+       => Relation p r
+       -> m (PlaceHolders p, Projection Flat r)
 query' =  queryWithAttr Just'
 
 -- | Join subquery. Query result is not 'Maybe'.
-query :: MonadQualify ConfigureQuery m => Relation () r -> m (Projection Flat r)
+query :: (MonadQualify ConfigureQuery m, MonadQuery m)
+      => Relation () r
+      -> m (Projection Flat r)
 query =  fmap snd . query'
 
 -- | Join subquery with place-holder parameter 'p'. Query result is 'Maybe'.
-queryMaybe' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, Projection Flat (Maybe r))
+queryMaybe' :: (MonadQualify ConfigureQuery m, MonadQuery m)
+            => Relation p r
+            -> m (PlaceHolders p, Projection Flat (Maybe r))
 queryMaybe' pr =  do
   (ph, pj) <- queryWithAttr Maybe pr
   return (ph, Projection.just pj)
 
 -- | Join subquery. Query result is 'Maybe'.
-queryMaybe :: MonadQualify ConfigureQuery m => Relation () r -> m (Projection Flat (Maybe r))
+queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m)
+           => Relation () r
+           -> m (Projection Flat (Maybe r))
 queryMaybe =  fmap snd . queryMaybe'
 
 queryList0 :: MonadQualify ConfigureQuery m => Relation p r -> m (ListProjection (Projection c) r)
@@ -393,7 +403,7 @@
                     => NodeAttr
                     -> UniqueRelation p c r
                     -> m (PlaceHolders p, Projection c r)
-uniqueQueryWithAttr attr = addPlaceHolders . run where
+uniqueQueryWithAttr attr = unsafeAddPlaceHolders . run where
   run rel = do
     q <- liftQualifyUnique $ do
       sq <- subQueryQualifyFromRelation (unUnique rel)
@@ -432,7 +442,7 @@
              => UniqueRelation p c r
              -> m (PlaceHolders p, Projection c (Maybe r))
 queryScalar' ur =
-  addPlaceHolders . liftQualify $
+  unsafeAddPlaceHolders . liftQualify $
   Projection.unsafeFromScalarSubQuery <$> subQueryQualifyFromRelation (unUnique ur)
 
 -- | Scalar subQuery.
diff --git a/src/Database/Relational/Query/Type.hs b/src/Database/Relational/Query/Type.hs
--- a/src/Database/Relational/Query/Type.hs
+++ b/src/Database/Relational/Query/Type.hs
@@ -18,7 +18,7 @@
 
   -- * Typed update statement
   KeyUpdate (..), unsafeTypedKeyUpdate, typedKeyUpdate, typedKeyUpdateTable,
-  Update (..), unsafeTypedUpdate, typedUpdate, typedUpdateTable, targetUpdate, targetUpdateTable,
+  Update (..), unsafeTypedUpdate, typedUpdate', typedUpdate, derivedUpdate', derivedUpdate,
   typedUpdateAllColumn, restrictedUpdateAllColumn, restrictedUpdateTableAllColumn,
 
   updateSQL,
@@ -30,7 +30,7 @@
   insertQuerySQL,
 
   -- * Typed delete statement
-  Delete (..), unsafeTypedDelete, typedDelete, restrictedDelete,
+  Delete (..), unsafeTypedDelete, typedDelete', typedDelete, derivedDelete', derivedDelete,
 
   deleteSQL,
 
@@ -113,31 +113,31 @@
 unsafeTypedUpdate :: String -> Update p
 unsafeTypedUpdate =  Update
 
--- | Make untyped update SQL string from 'Table' and 'Restriction'.
-updateSQL :: Table r -> UpdateTarget p r -> String
-updateSQL tbl ut = showStringSQL $ updatePrefixSQL tbl <> sqlFromUpdateTarget tbl ut
+-- | Make untyped update SQL string from 'Table' and 'UpdateTarget'.
+updateSQL :: Config -> Table r -> UpdateTarget p r -> String
+updateSQL config tbl ut = showStringSQL $ updatePrefixSQL tbl <> sqlFromUpdateTarget config tbl ut
 
--- | Make typed 'Update' from 'Table' and 'Restriction'.
+-- | Make typed 'Update' from 'Config', 'Table' and 'UpdateTarget'.
+typedUpdate' :: Config -> Table r -> UpdateTarget p r -> Update p
+typedUpdate' config tbl ut = unsafeTypedUpdate $ updateSQL config tbl ut
+
+-- | Make typed 'Update' using 'defaultConfig', 'Table' and 'UpdateTarget'.
 typedUpdate :: Table r -> UpdateTarget p r -> Update p
-typedUpdate tbl ut = unsafeTypedUpdate $ updateSQL tbl ut
+typedUpdate =  typedUpdate' defaultConfig
 
--- | Make typed 'Update' object using derived info specified by 'Relation' type.
-typedUpdateTable :: TableDerivable r => Relation () r -> UpdateTarget p r -> Update p
-typedUpdateTable =  typedUpdate . tableOf
+targetTable :: TableDerivable r => UpdateTarget p r -> Table r
+targetTable =  const derivedTable
 
--- | Directly make typed 'Update' from 'Table' and 'Target' monad context.
-targetUpdate :: Table r
-             -> UpdateTargetContext p r -- ^ 'Target' monad context
-             -> Update p
-targetUpdate tbl = typedUpdate tbl . updateTarget'
+-- | Make typed 'Update' from 'Config', derived table and 'UpdateTargetContext'
+derivedUpdate' :: TableDerivable r => Config -> UpdateTargetContext p r -> Update p
+derivedUpdate' config utc =  typedUpdate' config (targetTable ut) ut  where
+  ut = updateTarget' utc
 
--- | Directly make typed 'Update' from 'Relation' and 'Target' monad context.
-targetUpdateTable :: TableDerivable r
-                  => Relation () r
-                  -> UpdateTargetContext p r -- ^ 'Target' monad context
-                  -> Update p
-targetUpdateTable =  targetUpdate . tableOf
+-- | Make typed 'Update' from 'defaultConfig', derived table and 'UpdateTargetContext'
+derivedUpdate :: TableDerivable r => UpdateTargetContext p r -> Update p
+derivedUpdate = derivedUpdate' defaultConfig
 
+
 -- | Make typed 'Update' from 'Table' and 'Restriction'.
 --   Update target is all column.
 typedUpdateAllColumn :: PersistableWidth r
@@ -232,18 +232,28 @@
 unsafeTypedDelete =  Delete
 
 -- | Make untyped delete SQL string from 'Table' and 'Restriction'.
-deleteSQL :: Table r -> Restriction p r -> String
-deleteSQL tbl r = showStringSQL $ deletePrefixSQL tbl <> sqlWhereFromRestriction tbl r
+deleteSQL :: Config -> Table r -> Restriction p r -> String
+deleteSQL config tbl r = showStringSQL $ deletePrefixSQL tbl <> sqlWhereFromRestriction config tbl r
 
+-- | Make typed 'Delete' from 'Config', 'Table' and 'Restriction'.
+typedDelete' :: Config -> Table r -> Restriction p r -> Delete p
+typedDelete' config tbl r = unsafeTypedDelete $ deleteSQL config tbl r
+
 -- | Make typed 'Delete' from 'Table' and 'Restriction'.
 typedDelete :: Table r -> Restriction p r -> Delete p
-typedDelete tbl r = unsafeTypedDelete $ deleteSQL tbl r
+typedDelete =  typedDelete' defaultConfig
 
--- | Directly make typed 'Delete' from 'Table' and 'Restrict' monad context.
-restrictedDelete :: Table r
-                 -> RestrictionContext p r -- ^ 'Restrict' monad context.
-                 -> Delete p
-restrictedDelete tbl = typedDelete tbl . restriction'
+restrictedTable :: TableDerivable r => Restriction p r -> Table r
+restrictedTable =  const derivedTable
+
+-- | Make typed 'Delete' from 'Config', derived table and 'RestrictContext'
+derivedDelete' :: TableDerivable r => Config -> RestrictionContext p r -> Delete p
+derivedDelete' config rc = typedDelete' config (restrictedTable rs) rs  where
+  rs = restriction' rc
+
+-- | Make typed 'Delete' from 'defaultConfig', derived table and 'RestrictContext'
+derivedDelete :: TableDerivable r => RestrictionContext p r -> Delete p
+derivedDelete = derivedDelete' defaultConfig
 
 -- | Show delete SQL string
 instance Show (Delete p) where