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.1.0.1
+version:             0.2.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/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
@@ -36,7 +36,7 @@
   (AggregateColumnRef, Duplication, QueryRestriction, OrderingTerms, AggregateElem, composeOver)
 import Database.Relational.Query.Sub (SubQuery, aggregatedSubQuery, JoinProduct)
 import qualified Database.Relational.Query.Sub as SubQuery
-import Database.Relational.Query.Projectable (SqlProjectable, unsafeProjectSql, unsafeShowSql)
+import Database.Relational.Query.Projectable (PlaceHolders, SqlProjectable, unsafeProjectSql, unsafeShowSql)
 
 import Database.Relational.Query.Monad.Class (MonadRestrict(..), MonadQualify(..), MonadPartition (..))
 import Database.Relational.Query.Monad.Trans.Join (join')
@@ -45,15 +45,16 @@
 import Database.Relational.Query.Monad.Trans.Aggregating
   (aggregatings, extractAggregateTerms, AggregatingSetT, PartitioningSet)
 import Database.Relational.Query.Monad.Trans.Ordering
-  (Orderings, orderings, OrderedQuery, extractOrderingTerms)
-import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)
+  (Orderings, orderings, extractOrderingTerms)
+import Database.Relational.Query.Monad.Type
+  (ConfigureQuery, askConfig, QueryCore, extractCore, OrderedQuery)
 
 
 -- | Aggregated query monad type.
 type QueryAggregate     = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore))
 
--- | Aggregated query type. AggregatedQuery r == QueryAggregate (Projection Aggregated r).
-type AggregatedQuery  r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) r
+-- | Aggregated query type. 'AggregatedQuery' p r == 'QueryAggregate' ('PlaceHolders' p, 'Projection' 'Aggregated' r).
+type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r
 
 -- | Partition monad type for partition-by clause.
 type Window           c = Orderings c (PartitioningSet c)
@@ -70,8 +71,8 @@
 instance MonadQualify ConfigureQuery QueryAggregate where
   liftQualify = aggregatedQuery
 
-extract :: AggregatedQuery r
-        -> ConfigureQuery ((((((Projection Aggregated r, OrderingTerms),
+extract :: AggregatedQuery p r
+        -> ConfigureQuery (((((((PlaceHolders p, Projection Aggregated r), OrderingTerms),
                                QueryRestriction Aggregated),
                               [AggregateElem]),
                              QueryRestriction Flat),
@@ -79,15 +80,15 @@
 extract =  extractCore . extractAggregateTerms . extractRestrict . extractOrderingTerms
 
 -- | Run 'AggregatedQuery' to get SQL with 'ConfigureQuery' computation.
-toSQL :: AggregatedQuery r     -- ^ 'AggregatedQuery' to run
+toSQL :: AggregatedQuery p r     -- ^ 'AggregatedQuery' to run
       -> ConfigureQuery String -- ^ Result SQL string with 'ConfigureQuery' computation
 toSQL =  fmap SubQuery.toSQL . toSubQuery
 
 -- | Run 'AggregatedQuery' to get 'SubQuery' with 'ConfigureQuery' computation.
-toSubQuery :: AggregatedQuery r       -- ^ 'AggregatedQuery' to run
+toSubQuery :: AggregatedQuery p r       -- ^ 'AggregatedQuery' to run
            -> ConfigureQuery SubQuery -- ^ Result 'SubQuery' with 'ConfigureQuery' computation
 toSubQuery q = do
-  ((((((pj, ot), grs), ag), rs), pd), da) <- extract q
+  (((((((_ph, pj), ot), grs), ag), rs), pd), da) <- extract q
   c <- askConfig
   return $ aggregatedSubQuery c (Projection.untype pj) da pd rs ag grs ot
 
diff --git a/src/Database/Relational/Query/Monad/Simple.hs b/src/Database/Relational/Query/Monad/Simple.hs
--- a/src/Database/Relational/Query/Monad/Simple.hs
+++ b/src/Database/Relational/Query/Monad/Simple.hs
@@ -19,7 +19,7 @@
   simple,
 
   toSQL,
-  toSubQuery
+  toSubQuery,
   ) where
 
 import Database.Relational.Query.Context (Flat)
@@ -30,19 +30,21 @@
 import Database.Relational.Query.Monad.Trans.Join (join')
 import Database.Relational.Query.Monad.Trans.Restricting (restrictings)
 import Database.Relational.Query.Monad.Trans.Ordering
-  (Orderings, orderings, OrderedQuery, extractOrderingTerms)
-import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)
+  (Orderings, orderings, extractOrderingTerms)
+import Database.Relational.Query.Monad.Type
+  (ConfigureQuery, askConfig, QueryCore, extractCore, OrderedQuery)
+import Database.Relational.Query.Projectable (PlaceHolders)
 
 import Database.Relational.Query.Component (Duplication, QueryRestriction, OrderingTerms)
 import Database.Relational.Query.Sub (SubQuery, flatSubQuery, JoinProduct)
 import qualified Database.Relational.Query.Sub as SubQuery
 
 
--- | Simple query (not-aggregated) monad type.
+-- | Simple (not-aggregated) query monad type.
 type QuerySimple = Orderings Flat QueryCore
 
--- | Simple query (not-aggregated) query type. 'SimpleQuery' r == 'QuerySimple' ('Projection' r).
-type SimpleQuery r = OrderedQuery Flat QueryCore r
+-- | Simple (not-aggregated) query type. 'SimpleQuery'' p r == 'QuerySimple' ('PlaceHolders' p, 'Projection' r).
+type SimpleQuery p r = OrderedQuery Flat QueryCore p r
 
 -- | Lift from qualified table forms into 'QuerySimple'.
 simple :: ConfigureQuery a -> QuerySimple a
@@ -52,20 +54,20 @@
 instance MonadQualify ConfigureQuery (Orderings Flat QueryCore) where
   liftQualify = simple
 
-extract :: SimpleQuery r
-        -> ConfigureQuery ((((Projection Flat r, OrderingTerms), QueryRestriction Flat),
+extract :: SimpleQuery p r
+        -> ConfigureQuery (((((PlaceHolders p, Projection Flat r), OrderingTerms), QueryRestriction Flat),
                            JoinProduct), Duplication)
 extract =  extractCore . extractOrderingTerms
 
 -- | Run 'SimpleQuery' to get SQL string with 'Qualify' computation.
-toSQL :: SimpleQuery r         -- ^ 'SimpleQuery' to run
+toSQL :: SimpleQuery p r         -- ^ 'SimpleQuery' to run
       -> ConfigureQuery String -- ^ Result SQL string with 'Qualify' computation
 toSQL =  fmap SubQuery.toSQL . toSubQuery
 
 -- | Run 'SimpleQuery' to get 'SubQuery' with 'Qualify' computation.
-toSubQuery :: SimpleQuery r           -- ^ 'SimpleQuery' to run
+toSubQuery :: SimpleQuery p r        -- ^ 'SimpleQuery'' to run
            -> ConfigureQuery SubQuery -- ^ Result 'SubQuery' with 'Qualify' computation
 toSubQuery q = do
-   ((((pj, ot), rs), pd), da) <- extract q
+   (((((_ph, pj), ot), rs), pd), da) <- extract q
    c <- askConfig
    return $ flatSubQuery c (Projection.untype pj) da pd rs ot
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
@@ -16,7 +16,7 @@
 -- from query into query with ordering.
 module Database.Relational.Query.Monad.Trans.Ordering (
   -- * Transformer into query with ordering
-  Orderings, orderings, OrderedQuery, OrderingTerms,
+  Orderings, orderings, OrderingTerms,
 
   -- * API of query with ordering
   orderBy, asc, desc,
@@ -67,9 +67,6 @@
 -- | 'MonadPartition' with ordering.
 instance MonadPartition m => MonadPartition (Orderings c m) where
   unsafeAddPartitionKey = orderings . unsafeAddPartitionKey
-
--- | OrderedQuery type synonym. Projection must be the same as 'Orderings' type parameter 'p'
-type OrderedQuery c m r = Orderings c m (Projection c r)
 
 -- | Ordering term projection type interface.
 class ProjectableOrdering p where
diff --git a/src/Database/Relational/Query/Monad/Type.hs b/src/Database/Relational/Query/Monad/Type.hs
--- a/src/Database/Relational/Query/Monad/Type.hs
+++ b/src/Database/Relational/Query/Monad/Type.hs
@@ -10,7 +10,8 @@
 -- This module defines core query type.
 module Database.Relational.Query.Monad.Type (
   -- * Core query monad
-  ConfigureQuery, configureQuery, qualifyQuery, askConfig, QueryCore, extractCore
+  ConfigureQuery, configureQuery, qualifyQuery, askConfig, QueryCore, extractCore,
+  OrderedQuery,
   ) where
 
 import Data.Functor.Identity (Identity, runIdentity)
@@ -18,12 +19,14 @@
 import Database.Relational.Query.Component (Config, Duplication, QueryRestriction)
 import Database.Relational.Query.Sub (Qualified, JoinProduct)
 import Database.Relational.Query.Context (Flat)
+import Database.Relational.Query.Projection (Projection)
+import Database.Relational.Query.Projectable (PlaceHolders)
 import qualified Database.Relational.Query.Monad.Trans.Qualify as Qualify
 import Database.Relational.Query.Monad.Trans.Qualify (Qualify, qualify, evalQualifyPrime)
 import Database.Relational.Query.Monad.Trans.Config (QueryConfig, runQueryConfig, askQueryConfig)
 import Database.Relational.Query.Monad.Trans.Join (QueryJoin, extractProduct)
 import Database.Relational.Query.Monad.Trans.Restricting (Restrictings, extractRestrict)
-
+import Database.Relational.Query.Monad.Trans.Ordering (Orderings)
 
 -- | Thin monad type for untyped structure.
 type ConfigureQuery = Qualify (QueryConfig Identity)
@@ -47,3 +50,6 @@
 extractCore :: QueryCore a
             -> ConfigureQuery (((a, QueryRestriction Flat), JoinProduct), Duplication)
 extractCore =  extractProduct . extractRestrict
+
+-- | OrderedQuery monad type with placeholder type 'p'. Projection must be the same as 'Orderings' context type parameter 'c'.
+type OrderedQuery c m p r = Orderings c m (PlaceHolders p, Projection c r)
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
@@ -28,6 +28,7 @@
 import Database.Relational.Query.Monad.Trans.Join (join')
 import Database.Relational.Query.Monad.Trans.Restricting (restrictings)
 import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)
+import Database.Relational.Query.Projectable (PlaceHolders)
 
 import Database.Relational.Query.Component (Duplication, QueryRestriction)
 import Database.Relational.Query.Sub (SubQuery, flatSubQuery, JoinProduct)
@@ -49,9 +50,9 @@
 extract (QueryUnique c) = extractCore c
 
 -- | Run 'SimpleQuery' to get 'SubQuery' with 'Qualify' computation.
-toSubQuery :: QueryUnique (Projection c r) -- ^ 'QueryUnique' to run
+toSubQuery :: QueryUnique (PlaceHolders p, Projection c r) -- ^ 'QueryUnique' to run
            -> ConfigureQuery SubQuery      -- ^ Result 'SubQuery' with 'Qualify' computation
 toSubQuery q = do
-  (((pj, rs), pd), da) <- extract q
+  ((((_ph, pj), rs), pd), da) <- extract q
   c <- askConfig
   return $ flatSubQuery c (Projection.untype pj) da pd rs []
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
@@ -27,7 +27,7 @@
 
   -- * Placeholders
   PlaceHolders, addPlaceHolders, unsafePlaceHolders,
-  placeholder', placeholder,
+  placeholder', placeholder, unitPlaceHolder,
 
   -- * Projectable into SQL strings
   unsafeShowSqlExpr,
@@ -499,6 +499,10 @@
 -- | Unsafely get placeholder parameter
 unsafePlaceHolders :: PlaceHolders p
 unsafePlaceHolders =  PlaceHolders
+
+-- | No placeholder semantics
+unitPlaceHolder :: PlaceHolders ()
+unitPlaceHolder =  unsafePlaceHolders
 
 -- | Unsafely cast placeholder parameter type.
 unsafeCastPlaceHolders :: PlaceHolders a -> PlaceHolders b
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, addPlaceHolders, unsafePlaceHolders, projectZip)
+  (PlaceHolders, unitPlaceHolder, addPlaceHolders, unsafePlaceHolders, projectZip)
 import Database.Relational.Query.ProjectableExtended ((!))
 
 
@@ -153,27 +153,24 @@
           -> m (ListProjection (Projection c) r)
 queryList =  queryList0
 
-unsafeRelation :: SimpleQuery rp -> Relation p r
-unsafeRelation =  SubQuery . Simple.toSubQuery
+addUnitPH :: Functor f => f t -> f (PlaceHolders (), t)
+addUnitPH =  ((,) unitPlaceHolder <$>)
 
+-- | Finalize 'QuerySimple' monad and generate 'Relation' with place-holder parameter 'p'.
+relation' :: SimpleQuery p r -> Relation p r
+relation' =  SubQuery . Simple.toSubQuery
+
 -- | Finalize 'QuerySimple' monad and generate 'Relation'.
 relation :: QuerySimple (Projection Flat r) -> Relation () r
-relation =  unsafeRelation
-
--- | Finalize 'QuerySimple' monad and generate 'Relation' with place-holder parameter 'p'.
-relation' :: QuerySimple (PlaceHolders p, Projection Flat r) -> Relation p r
-relation' =  unsafeRelation . fmap snd
+relation =  relation' . addUnitPH
 
-unsafeAggregateRelation :: AggregatedQuery rp -> Relation p r
-unsafeAggregateRelation =  SubQuery . Aggregate.toSubQuery
+-- | Finalize 'QueryAggregate' monad and geneate 'Relation' with place-holder parameter 'p'.
+aggregateRelation' :: AggregatedQuery p r -> Relation p r
+aggregateRelation' =  SubQuery . Aggregate.toSubQuery
 
 -- | Finalize 'QueryAggregate' monad and geneate 'Relation'.
 aggregateRelation :: QueryAggregate (Projection Aggregated r) -> Relation () r
-aggregateRelation =  unsafeAggregateRelation
-
--- | Finalize 'QueryAggregate' monad and geneate 'Relation' with place-holder parameter 'p'.
-aggregateRelation' :: QueryAggregate (PlaceHolders p, Projection Aggregated r) -> Relation p r
-aggregateRelation' =  unsafeAggregateRelation . fmap snd
+aggregateRelation =  aggregateRelation' . addUnitPH
 
 
 -- | Restriction function type for direct style join operator.
@@ -419,7 +416,7 @@
 
 -- | Finalize 'QueryUnique' monad and generate 'UniqueRelation'.
 uniqueRelation' :: QueryUnique (PlaceHolders p, Projection c r) -> UniqueRelation p c r
-uniqueRelation' =  unsafeUnique . SubQuery . Unique.toSubQuery . fmap snd
+uniqueRelation' =  unsafeUnique . SubQuery . Unique.toSubQuery
 
 -- | Aggregated 'UniqueRelation'.
 aggregatedUnique :: Relation ph r
diff --git a/test/SQLs.hs b/test/SQLs.hs
--- a/test/SQLs.hs
+++ b/test/SQLs.hs
@@ -98,7 +98,7 @@
 
   wheres $ a ?! strA2' .=. b ! mayStrB1'
 
-  return $ fromMaybe' (value 1) (a ?! intA0') >< b
+  return $ fromMaybe (value 1) (a ?! intA0') >< b
 
 maybes :: [Test]
 maybes =  [ eqShow "isJust" justX