diff --git a/relational-record.cabal b/relational-record.cabal
--- a/relational-record.cabal
+++ b/relational-record.cabal
@@ -1,5 +1,5 @@
 name:                relational-record
-version:             0.0.1.1
+version:             0.0.1.2
 synopsis:            Meta package of Relational Record
 description:         Meta package to install Relational Record quickly
 homepage:            http://khibino.github.io/haskell-relational-record/
diff --git a/src/Database/Relational/Query/Documentation.hs b/src/Database/Relational/Query/Documentation.hs
--- a/src/Database/Relational/Query/Documentation.hs
+++ b/src/Database/Relational/Query/Documentation.hs
@@ -40,7 +40,22 @@
   relation,
   aggregateRelation,
 
-  -- *** Projection Operators
+  -- *** Projection
+  -- $projection
+
+  -- **** Projection Type
+  -- $projectionType
+  Projection,
+
+  Flat, Aggregated,
+
+  Exists, OverWindow,
+
+  -- **** Projection Path
+  -- $projectionPath
+  Pi, (!), (<.>),
+
+  -- **** Projection Operators
   -- $projectionOperators
   (.=.), (.<.), (.<=.), (.>.), (.>=.), (.<>.),
   casesOrElse, case',
@@ -67,6 +82,9 @@
 
   -- *** Maybe Projections
   -- $maybeProjection
+  (?!), (?!?),
+  (<?.>), (<?.?>),
+
   (?+?),
   negateMaybe,
   sumMaybe,
@@ -139,7 +157,7 @@
  -}
 
 {- $monadicContext
-This DSL accumulates query structures into monadic context.
+On building query, query structures can be accumulated in monadic context.
  -}
 
 {- $monadicOperator
@@ -158,40 +176,96 @@
 Not monadic style join is supported by some direct join operators.
 
 'inner', 'left', 'right', 'full' operators can construct join products directly like SQL.
-'on'' specifies condition of join product.
+'on'' operator specifies condition of join product.
  -}
 
 {- $finalize
-Several operators are defined to finalize query monadic context.
+Several operators are defined to make 'Relation' type with finalizing query monadic context.
 
 'relation' operator finalizes flat (not aggregated) query monadic context,
 and 'aggregateRelation' operator finalizes aggregated query monadic context.
  -}
 
+{- $projection
+SQL expression can be projected to haskell phantom type in this DSL.
+ -}
+
+{- $projectionType
+'Projection' /c/ /t/ is SQL value type projection to haskell type with context type /c/ correspond haskell type /t/.
+
+'Flat' is not aggregated query context type,
+'Aggregated' is aggregated query context type,
+'OverWindow' is window function context type, and so on.
+
+Module "Database.Relational.Query.Context" contains documentation of other context types.
+ -}
+
+{- $projectionPath
+'!' operator is projected value selector using projection path type 'Pi' /r0/ /r1/.
+'Pi' /r0/ /r1/ is projection path type selecting column type /r1/ from record type /r0/.
+'<.>' operator makes composed projection path from two projection paths.
+ -}
+
 {- $projectionOperators
-Some operators are defined to caluculate projections.
+Some operators are defined to caluculate projected values.
+
+For example,
+'.=.' operator is equal compare operation of projected value correspond to SQL =,
+'.+.' operator is plus operation of projected value coresspond to SQL +, and so on.
+
+Module "Database.Relational.Query.Projectable" contains documentation of other projection operators.
  -}
 
 {- $aggregateFunctions
-Typed aggregate operators are defined.
+Typed aggregate function operators are defined.
 Aggregated value types is distinguished with Flat value types.
+
+For example,
+'sum'' operator is aggregate function of projected flat (not aggregated) value
+correspond to SQL SUM(...),
+'rank' operator is window function of projected value coresspond to SQL RANK(), and so on.
+
+Module "Database.Relational.Query.Projectable" contains documentation of
+other aggregate function operators and window function operators.
  -}
 
 {- $setOperators
 Several operators are defined to manipulate relation set.
- -}
 
+'union' operator makes union relation set of two relation set correspond to SQL UNION.
+'except' operator makes difference relation set of two relation set correspond to SQL EXCEPT.
+'intersect' operator makes intersection relation set of two relation set correspond to SQL INTERSECT.
+-}
+
 {- $maybeProjection
-Operators of projection and aggregation are also provided Maybe type versions.
+'Maybe' type flavor of operators against projection path, projection and aggregation are also provided.
+
+For example,
+'?!' operator is maybe flavor of '!',
+'<?.>' operator is maybe flavor of '<.>'.
+'?!?' opeartor and '<?.?>' operator 'join' two 'Maybe' phantom functors.
+
+'?+?' operator is maybe flavor of '.+.',
+'nagateMaybe' operator is maybe flavor of 'nagate',
+'sumMaybe' operator is maybe flavor of 'sum''.
+
+Module "Database.Relational.Query.Projectable" contains documentation of
+other 'Maybe' flavor projection operators.
  -}
 
 {- $placeholder
-Some operators are defined to realize type safe placeholder.
- -}
+Placeholder flavor of operators against query operation and set operation are also provided, to realize type safe placeholder.
 
+'query'', 'left'', 'relation'' and 'union''
+operator is placeholder flavor 'query', 'left', 'relation' and union.
 
+Module "Database.Relational.Query.Relation" contains documentation of
+other placeholder flavor operators.
+-}
+
+
 {- $databaseOperations
-Some actions are defined for database site effects.
+Some actions are defined for database side effects.
  -}
 
 {- $generalizedStmt