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.4.0.1
+version:             0.5.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/Internal/SQL.hs b/src/Database/Relational/Query/Internal/SQL.hs
--- a/src/Database/Relational/Query/Internal/SQL.hs
+++ b/src/Database/Relational/Query/Internal/SQL.hs
@@ -13,7 +13,7 @@
 
   rowStringSQL, rowPlaceHolderStringSQL,
 
-  rowListStringSQL,
+  rowConsStringSQL, listStringSQL,
   ) where
 
 import Language.SQL.Keyword (Keyword, word, wordShow, fold, (|*|), paren)
@@ -41,6 +41,10 @@
 rowPlaceHolderStringSQL :: Int -> StringSQL
 rowPlaceHolderStringSQL =  rowStringSQL . (`replicate` stringSQL "?")
 
--- | Rows String of SQL.
-rowListStringSQL :: [StringSQL] -> StringSQL
-rowListStringSQL =  paren . fold (|*|)
+-- | List String of SQL.
+rowConsStringSQL :: [StringSQL] -> StringSQL
+rowConsStringSQL =  paren . fold (|*|)
+
+-- | List String of SQL.
+listStringSQL :: [StringSQL] -> StringSQL
+listStringSQL =  paren . fold (|*|)
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
@@ -45,18 +45,16 @@
   caseSearch, caseSearchMaybe, case', caseMaybe,
   in', and', or',
 
-  isNothing, isJust, fromMaybe, fromMaybe',
+  isNothing, isJust, fromMaybe,
   not', exists,
 
-  (.||.), (?||?),
+  (.||.), (?||?), like, likeMaybe, like', likeMaybe',
   (.+.), (.-.), (./.), (.*.), negate', fromIntegral', showNum,
   (?+?), (?-?), (?/?), (?*?), negateMaybe, fromIntegralMaybe, showNumMaybe,
 
   -- * Terms for Window function types
   rank, denseRank, rowNumber, percentRank, cumeDist,
 
-  dense_rank, row_number, percent_rank, cume_dist,
-
   -- * Zipping projections
   projectZip, (><),
   ProjectableIdZip (..),
@@ -70,7 +68,6 @@
 
 import Prelude hiding (pi)
 
-import Data.Int (Int64)
 import Data.String (IsString)
 import Data.Monoid ((<>), mconcat)
 import Control.Applicative ((<$>))
@@ -131,6 +128,12 @@
 instance SqlProjectable (Expr p) where
   unsafeProjectSqlTerms' = UnsafeExpr.Expr . rowStringSQL
 
+class SqlProjectable p => OperatorProjectable p
+instance OperatorProjectable (Projection Flat)
+instance OperatorProjectable (Projection Aggregated)
+instance OperatorProjectable (Expr Flat)
+instance OperatorProjectable (Expr Aggregated)
+
 -- | Unsafely Project single SQL term.
 unsafeProjectSql' :: SqlProjectable p => StringSQL -> p t
 unsafeProjectSql' =  unsafeProjectSqlTerms' . (:[])
@@ -140,23 +143,23 @@
 unsafeProjectSql =  unsafeProjectSql' . stringSQL
 
 -- | Polymorphic projection of SQL null value.
-unsafeValueNull :: SqlProjectable p => p (Maybe a)
+unsafeValueNull :: OperatorProjectable p => p (Maybe a)
 unsafeValueNull =  unsafeProjectSql "NULL"
 
 -- | Generate polymorphic projection of SQL constant values from Haskell value.
-value :: (ShowConstantTermsSQL t, SqlProjectable p) => t -> p t
+value :: (ShowConstantTermsSQL t, OperatorProjectable p) => t -> p t
 value =  unsafeProjectSqlTerms' . showConstantTermsSQL'
 
 -- | Polymorphic proejction of SQL true value.
-valueTrue  :: (SqlProjectable p, ProjectableMaybe p) => p (Maybe Bool)
+valueTrue  :: (OperatorProjectable p, ProjectableMaybe p) => p (Maybe Bool)
 valueTrue  =  just $ value True
 
 -- | Polymorphic proejction of SQL false value.
-valueFalse :: (SqlProjectable p, ProjectableMaybe p) => p (Maybe Bool)
+valueFalse :: (OperatorProjectable p, ProjectableMaybe p) => p (Maybe Bool)
 valueFalse =  just $ value False
 
 -- | Polymorphic proejction of SQL set value from Haskell list.
-values :: (ShowConstantTermsSQL t, SqlProjectable p) => [t] -> ListProjection p t
+values :: (ShowConstantTermsSQL t, OperatorProjectable p) => [t] -> ListProjection p t
 values =  Projection.list . map value
 
 
@@ -215,93 +218,117 @@
 
 
 -- | Compare operator corresponding SQL /=/ .
-(.=.)  :: (SqlProjectable p, ProjectableShowSql p)
+(.=.)  :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.=.)  =  compareBinOp (SQL..=.)
 
 -- | Compare operator corresponding SQL /</ .
-(.<.)  :: (SqlProjectable p, ProjectableShowSql p)
+(.<.)  :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.<.)  =  compareBinOp (SQL..<.)
 
 -- | Compare operator corresponding SQL /<=/ .
-(.<=.)  :: (SqlProjectable p, ProjectableShowSql p)
+(.<=.)  :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.<=.)  =  compareBinOp (SQL..<=.)
 
 -- | Compare operator corresponding SQL />/ .
-(.>.)  :: (SqlProjectable p, ProjectableShowSql p)
+(.>.)  :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.>.)  =  compareBinOp (SQL..>.)
 
 -- | Compare operator corresponding SQL />=/ .
-(.>=.)  :: (SqlProjectable p, ProjectableShowSql p)
+(.>=.)  :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.>=.)  =  compareBinOp (SQL..>=.)
 
 -- | Compare operator corresponding SQL /<>/ .
-(.<>.) :: (SqlProjectable p, ProjectableShowSql p)
+(.<>.) :: (OperatorProjectable p, ProjectableShowSql p)
   => p ft -> p ft -> p (Maybe Bool)
 (.<>.) =  compareBinOp (SQL..<>.)
 
 -- | Logical operator corresponding SQL /AND/ .
-and' :: (SqlProjectable p, ProjectableShowSql p)
+and' :: (OperatorProjectable p, ProjectableShowSql p)
      => p ft -> p ft -> p (Maybe Bool)
 and' =  compareBinOp SQL.and
 
 -- | Logical operator corresponding SQL /OR/ .
-or' :: (SqlProjectable p, ProjectableShowSql p)
+or' :: (OperatorProjectable p, ProjectableShowSql p)
     => p ft -> p ft -> p (Maybe Bool)
 or'  =  compareBinOp SQL.or
 
 -- | Logical operator corresponding SQL /NOT/ .
-not' :: (SqlProjectable p, ProjectableShowSql p)
+not' :: (OperatorProjectable p, ProjectableShowSql p)
     => p (Maybe Bool) -> p (Maybe Bool)
 not' =  unsafeFlatUniOp SQL.NOT
 
 -- | Logical operator corresponding SQL /EXISTS/ .
-exists :: (SqlProjectable p, ProjectableShowSql p)
+exists :: (OperatorProjectable p, ProjectableShowSql p)
        => ListProjection (Projection Exists) r -> p (Maybe Bool)
 exists =  unsafeProjectSql' . SQL.paren . SQL.defineUniOp SQL.EXISTS
           . Projection.unsafeStringSqlList unsafeShowSql'
 
 -- | Concatinate operator corresponding SQL /||/ .
-(.||.) :: (SqlProjectable p, ProjectableShowSql p, IsString a)
+(.||.) :: (OperatorProjectable p, ProjectableShowSql p, IsString a)
        => p a -> p a -> p a
 (.||.) =  unsafeBinOp (SQL..||.)
 
 -- | Concatinate operator corresponding SQL /||/ . Maybe type version.
-(?||?) :: (SqlProjectable p, ProjectableShowSql p, IsString a)
+(?||?) :: (OperatorProjectable p, ProjectableShowSql p, IsString a)
        => p (Maybe a) -> p (Maybe a) -> p (Maybe a)
 (?||?) =  unsafeBinOp (SQL..||.)
 
+unsafeLike :: (OperatorProjectable p, ProjectableShowSql p)
+           => p a -> p b -> p (Maybe Bool)
+unsafeLike = unsafeBinOp (SQL.defineBinOp SQL.LIKE)
+
+-- | String-compare operator corresponding SQL /LIKE/ .
+like' :: (OperatorProjectable p, ProjectableShowSql p, IsString a)
+      => p a -> p a -> p (Maybe Bool)
+x `like'` y = x `unsafeLike` y
+
+-- | String-compare operator corresponding SQL /LIKE/ .
+likeMaybe' :: (OperatorProjectable p, ProjectableShowSql p, IsString a)
+           => p (Maybe a) -> p (Maybe a) -> p (Maybe Bool)
+x `likeMaybe'` y = x `unsafeLike` y
+
+-- | String-compare operator corresponding SQL /LIKE/ .
+like :: (OperatorProjectable p, ProjectableShowSql p, IsString a, ShowConstantTermsSQL a)
+       => p a -> a -> p (Maybe Bool)
+x `like` a = x `like'` value a
+
+-- | String-compare operator corresponding SQL /LIKE/ . Maybe type version.
+likeMaybe :: (OperatorProjectable p, ProjectableShowSql p, IsString a, ShowConstantTermsSQL a)
+       => p (Maybe a) -> a -> p (Maybe Bool)
+x `likeMaybe` a = x `unsafeLike` value a
+
 -- | Unsafely make number projection binary operator from SQL operator string.
 monoBinOp' :: (SqlProjectable p, ProjectableShowSql p)
           => Keyword -> p a -> p a -> p a
 monoBinOp' = monoBinOp . SQL.defineBinOp
 
 -- | Number operator corresponding SQL /+/ .
-(.+.) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(.+.) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p a -> p a -> p a
 (.+.) =  monoBinOp' "+"
 
 -- | Number operator corresponding SQL /-/ .
-(.-.) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(.-.) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p a -> p a -> p a
 (.-.) =  monoBinOp' "-"
 
 -- | Number operator corresponding SQL /// .
-(./.) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(./.) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p a -> p a -> p a
 (./.) =  monoBinOp' "/"
 
 -- | Number operator corresponding SQL /*/ .
-(.*.) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(.*.) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p a -> p a -> p a
 (.*.) =  monoBinOp' "*"
 
 -- | Number negate uni-operator corresponding SQL /-/.
-negate' :: (SqlProjectable p, ProjectableShowSql p, Num a)
+negate' :: (OperatorProjectable p, ProjectableShowSql p, Num a)
         => p a -> p a
 negate' =  unsafeFlatUniOp $ SQL.word "-"
 
@@ -320,27 +347,27 @@
 showNum =  unsafeCastProjectable
 
 -- | Number operator corresponding SQL /+/ .
-(?+?) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(?+?) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p (Maybe a) -> p (Maybe a) -> p (Maybe a)
 (?+?) =  monoBinOp' "+"
 
 -- | Number operator corresponding SQL /-/ .
-(?-?) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(?-?) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p (Maybe a) -> p (Maybe a) -> p (Maybe a)
 (?-?) =  monoBinOp' "-"
 
 -- | Number operator corresponding SQL /// .
-(?/?) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(?/?) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p (Maybe a) -> p (Maybe a) -> p (Maybe a)
 (?/?) =  monoBinOp' "/"
 
 -- | Number operator corresponding SQL /*/ .
-(?*?) :: (SqlProjectable p, ProjectableShowSql p, Num a)
+(?*?) :: (OperatorProjectable p, ProjectableShowSql p, Num a)
   => p (Maybe a) -> p (Maybe a) -> p (Maybe a)
 (?*?) =  monoBinOp' "*"
 
 -- | Number negate uni-operator corresponding SQL /-/.
-negateMaybe :: (SqlProjectable p, ProjectableShowSql p, Num a)
+negateMaybe :: (OperatorProjectable p, ProjectableShowSql p, Num a)
             => p (Maybe a) -> p (Maybe a)
 negateMaybe =  unsafeFlatUniOp $ SQL.word "-"
 
@@ -354,7 +381,7 @@
                    => p (Maybe a) -> p (Maybe b)
 showNumMaybe = unsafeCastProjectable
 
-whensClause :: (SqlProjectable p, ProjectableShowSql p)
+whensClause :: (OperatorProjectable p, ProjectableShowSql p)
             => String       -- ^ Error tag
             -> [(p a, p b)] -- ^ Each when clauses
             -> p b          -- ^ Else result projection
@@ -367,28 +394,28 @@
 
 -- | Search case operator correnponding SQL search /CASE/.
 --   Like, /CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END/
-caseSearch :: (SqlProjectable p, ProjectableShowSql p)
+caseSearch :: (OperatorProjectable p, ProjectableShowSql p)
            => [(p (Maybe Bool), p a)] -- ^ Each when clauses
            -> p a                     -- ^ Else result projection
            -> p a                     -- ^ Result projection
 caseSearch cs e = unsafeProjectSql' $ SQL.CASE <> whensClause "caseSearch" cs e
 
 -- | Same as 'caseSearch', but you can write like <when list> `casesOrElse` <else clause>.
-casesOrElse :: (SqlProjectable p, ProjectableShowSql p)
+casesOrElse :: (OperatorProjectable p, ProjectableShowSql p)
             => [(p (Maybe Bool), p a)] -- ^ Each when clauses
             -> p a                     -- ^ Else result projection
             -> p a                     -- ^ Result projection
 casesOrElse = caseSearch
 
 -- | Null default version of 'caseSearch'.
-caseSearchMaybe :: (ProjectableShowSql p, SqlProjectable p)
+caseSearchMaybe :: (OperatorProjectable p, ProjectableShowSql p)
                 => [(p (Maybe Bool), p (Maybe a))] -- ^ Each when clauses
                 -> p (Maybe a)                     -- ^ Result projection
 caseSearchMaybe cs = caseSearch cs unsafeValueNull
 
 -- | Simple case operator correnponding SQL simple /CASE/.
 --   Like, /CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END/
-case' :: (SqlProjectable p, ProjectableShowSql p)
+case' :: (OperatorProjectable p, ProjectableShowSql p)
       => p a          -- ^ Projection value to match
       -> [(p a, p b)] -- ^ Each when clauses
       -> p b          -- ^ Else result projection
@@ -396,91 +423,65 @@
 case' v cs e = unsafeProjectSql' $ SQL.CASE <> unsafeShowSql' v <> whensClause "case'" cs e
 
 -- | Uncurry version of 'case'', and you can write like ... `casesOrElse'` <else clause>.
-casesOrElse' :: (SqlProjectable p, ProjectableShowSql p)
+casesOrElse' :: (OperatorProjectable p, ProjectableShowSql p)
              => (p a, [(p a, p b)]) -- ^ Projection value to match and each when clauses list
              -> p b                 -- ^ Else result projection
              -> p b                 -- ^ Result projection
 casesOrElse' =  uncurry case'
 
 -- | Null default version of 'case''.
-caseMaybe :: (SqlProjectable p, ProjectableShowSql p, ProjectableMaybe p)
+caseMaybe :: (OperatorProjectable p, ProjectableShowSql p, ProjectableMaybe p)
           => p a                  -- ^ Projection value to match
           -> [(p a, p (Maybe b))] -- ^ Each when clauses
           -> p (Maybe b)          -- ^ Result projection
 caseMaybe v cs = case' v cs unsafeValueNull
 
 -- | Binary operator corresponding SQL /IN/ .
-in' :: (SqlProjectable p, ProjectableShowSql p)
+in' :: (OperatorProjectable p, ProjectableShowSql p)
     => p t -> ListProjection p t -> p (Maybe Bool)
 in' a lp = unsafeProjectSql' . SQL.paren
            $ SQL.in' (unsafeShowSql' a) (Projection.unsafeStringSqlList unsafeShowSql' lp)
 
 -- | Operator corresponding SQL /IS NULL/ , and extended against record types.
-isNothing :: (SqlProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
+isNothing :: (OperatorProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
           => Projection c (Maybe r) -> Projection c (Maybe Bool)
 isNothing mr = unsafeProjectSql' $
                SQL.paren $ (SQL.defineBinOp SQL.IS)
                (Projection.unsafeStringSqlNotNullMaybe mr) SQL.NULL
 
 -- | Operator corresponding SQL /NOT (... IS NULL)/ , and extended against record type.
-isJust :: (SqlProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
+isJust :: (OperatorProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
           => Projection c (Maybe r) -> Projection c (Maybe Bool)
 isJust =  not' . isNothing
 
 -- | Operator from maybe type using record extended 'isNull'.
-fromMaybe :: (SqlProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
+fromMaybe :: (OperatorProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
           => Projection c r -> Projection c (Maybe r) -> Projection c r
 fromMaybe d p = [ (isNothing p, d) ] `casesOrElse` unsafeCastProjectable p
 
--- | Deprecated. Operator from maybe type using record extended 'isNull'.
-fromMaybe' :: (SqlProjectable (Projection c), ProjectableShowSql (Projection c), HasColumnConstraint NotNull r)
-           => Projection c r -> Projection c (Maybe r) -> Projection c r
-fromMaybe' =  fromMaybe
-{-# DEPRECATED fromMaybe' "Use fromMaybe instead of this." #-}
-
 unsafeUniTermFunction :: SqlProjectable p => Keyword -> p t
 unsafeUniTermFunction =  unsafeProjectSql' . (SQL.<++> stringSQL "()")
 
 -- | /RANK()/ term.
-rank :: Projection OverWindow Int64
+rank :: Integral a => Projection OverWindow a
 rank =  unsafeUniTermFunction SQL.RANK
 
 -- | /DENSE_RANK()/ term.
-denseRank :: Projection OverWindow Int64
+denseRank :: Integral a => Projection OverWindow a
 denseRank =  unsafeUniTermFunction SQL.DENSE_RANK
 
--- | /DENSE_RANK()/ term.
-dense_rank :: Projection OverWindow Int64
-dense_rank =  denseRank
-{-# DEPRECATED dense_rank "Use denseRank instead of this." #-}
-
 -- | /ROW_NUMBER()/ term.
-rowNumber :: Projection OverWindow Int64
+rowNumber :: Integral a => Projection OverWindow a
 rowNumber =  unsafeUniTermFunction SQL.ROW_NUMBER
 
--- | /ROW_NUMBER()/ term.
-row_number :: Projection OverWindow Int64
-row_number =  rowNumber
-{-# DEPRECATED row_number "Use rowNumber instead of this." #-}
-
 -- | /PERCENT_RANK()/ term.
 percentRank :: Projection OverWindow Double
 percentRank =  unsafeUniTermFunction SQL.PERCENT_RANK
 
--- | /PERCENT_RANK()/ term.
-percent_rank :: Projection OverWindow Double
-percent_rank =  percentRank
-{-# DEPRECATED percent_rank "Use percentRank instead of this." #-}
-
 -- | /CUME_DIST()/ term.
 cumeDist :: Projection OverWindow Double
 cumeDist =  unsafeUniTermFunction SQL.CUME_DIST
 
--- | /CUME_DIST()/ term.
-cume_dist :: Projection OverWindow Double
-cume_dist =  cumeDist
-{-# DEPRECATED cume_dist "Use cumeDist instead of this." #-}
-
 -- | Placeholder parameter type which has real parameter type arguemnt 'p'.
 data PlaceHolders p = PlaceHolders
 
@@ -603,7 +604,7 @@
 infixl 6 .+., .-., ?+?, ?-?
 infixl 5 .||., ?||?
 infixl 4 |$|, |*|
-infix  4 .=., .<>., .>., .>=., .<., .<=., `in'`
+infix  4 .=., .<>., .>., .>=., .<., .<=., `in'`, `like`, `likeMaybe`, `like'`, `likeMaybe'`
 infixr 3 `and'`
 infixr 2 `or'`
 infixl 1  ><
diff --git a/src/Database/Relational/Query/ProjectableExtended.hs b/src/Database/Relational/Query/ProjectableExtended.hs
--- a/src/Database/Relational/Query/ProjectableExtended.hs
+++ b/src/Database/Relational/Query/ProjectableExtended.hs
@@ -38,7 +38,6 @@
   )  where
 
 import Prelude hiding (pi)
-import Data.Int (Int64)
 
 import qualified Language.SQL.Keyword as SQL
 
@@ -69,8 +68,8 @@
 unsafeAggregateOp op = unsafeUniOp ((op SQL.<++>) . SQL.paren)
 
 -- | Aggregation function COUNT.
-count :: (AggregatedContext ac, SqlProjectable (p ac))
-      => Projection Flat a -> p ac Int64
+count :: (Integral b, AggregatedContext ac, SqlProjectable (p ac))
+      => Projection Flat a -> p ac b
 count =  unsafeAggregateOp SQL.COUNT
 
 -- | Aggregation function SUM.
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
@@ -48,7 +48,7 @@
 import Database.Record (HasColumnConstraint, NotNull, NotNullColumnConstraint)
 import qualified Database.Record.KeyConstraint as KeyConstraint
 
-import Database.Relational.Query.Internal.SQL (StringSQL, rowStringSQL, rowListStringSQL)
+import Database.Relational.Query.Internal.SQL (StringSQL, rowStringSQL, listStringSQL)
 import Database.Relational.Query.Context (Aggregated, Flat)
 import Database.Relational.Query.Component (ColumnSQL, showsColumnSQL, columnSQL')
 import Database.Relational.Query.Table (Table)
@@ -197,5 +197,5 @@
 -- | Map projection show operatoions and concatinate to single SQL expression.
 unsafeStringSqlList :: (p t -> StringSQL) -> ListProjection p t -> StringSQL
 unsafeStringSqlList sf = d  where
-  d (List ps) = rowListStringSQL $ map sf ps
+  d (List ps) = listStringSQL $ map sf ps
   d (Sub sub) = SQL.paren $ SubQuery.showSQL sub
diff --git a/src/Database/Relational/Query/Pure.hs b/src/Database/Relational/Query/Pure.hs
--- a/src/Database/Relational/Query/Pure.hs
+++ b/src/Database/Relational/Query/Pure.hs
@@ -91,6 +91,11 @@
 instance ShowConstantTermsSQL Int64 where
   showConstantTermsSQL' = intTermsSQL
 
+-- | Constant SQL terms of 'Int'.
+--   Use this carefully, because this is architecture dependent size of integer type.
+instance ShowConstantTermsSQL Int where
+  showConstantTermsSQL' = intTermsSQL
+
 -- | Constant SQL terms of 'String'.
 instance ShowConstantTermsSQL String where
   showConstantTermsSQL' = stringTermsSQL
diff --git a/src/Database/Relational/Query/SQL.hs b/src/Database/Relational/Query/SQL.hs
--- a/src/Database/Relational/Query/SQL.hs
+++ b/src/Database/Relational/Query/SQL.hs
@@ -34,7 +34,7 @@
 
 import Database.Record.ToSql (untypedUpdateValuesIndex)
 
-import Database.Relational.Query.Internal.SQL (StringSQL, stringSQL, showStringSQL, rowStringSQL)
+import Database.Relational.Query.Internal.SQL (StringSQL, stringSQL, showStringSQL, rowConsStringSQL)
 import Database.Relational.Query.Pi (Pi)
 import qualified Database.Relational.Query.Pi.Unsafe as UnsafePi
 import Database.Relational.Query.Component (ColumnSQL, showsColumnSQL, showsColumnSQL)
@@ -94,7 +94,7 @@
 -- | Generate prefix string of insert SQL.
 insertPrefixSQL :: Pi r r' -> Table r -> StringSQL
 insertPrefixSQL pi' table =
-  INSERT <> INTO <> stringSQL (name table) <> rowStringSQL [showsColumnSQL c | c <- cols]  where
+  INSERT <> INTO <> stringSQL (name table) <> rowConsStringSQL [showsColumnSQL c | c <- cols]  where
     cols = Projection.columns . Projection.pi (Projection.unsafeFromTable table) $ pi'
 
 -- | Generate records chunk insert SQL.
@@ -106,7 +106,7 @@
   n | n0 >= 1    =  n0
     | otherwise  =  error $ "Invalid chunk count value: " ++ show n0
   w = UnsafePi.width pi'
-  vs = SQL.fold (|*|) . replicate n $ rowStringSQL (replicate w "?")
+  vs = SQL.fold (|*|) . replicate n $ rowConsStringSQL (replicate w "?")
 
 -- | Generate size measured records chunk insert SQL.
 insertSizedChunkSQL :: Pi r r'       -- ^ Columns selector to insert
diff --git a/src/Database/Relational/Query/TH.hs b/src/Database/Relational/Query/TH.hs
--- a/src/Database/Relational/Query/TH.hs
+++ b/src/Database/Relational/Query/TH.hs
@@ -436,7 +436,7 @@
 -- | Generate all templates against defined record like type constructor
 --   other than depending on sql-value type.
 makeRelationalRecordDefault :: Name    -- ^ Type constructor name
-                             -> Q [Dec] -- ^ Resutl declaration
+                             -> Q [Dec] -- ^ Result declaration
 makeRelationalRecordDefault recTypeName = do
   let recTypeConName = ConName recTypeName
   ((tyCon, dataCon), (mayNs, cts)) <- Record.reifyRecordType recTypeName
diff --git a/test/Model.hs b/test/Model.hs
--- a/test/Model.hs
+++ b/test/Model.hs
@@ -32,6 +32,10 @@
   [] [0] $ Just 0)
 
 
+$(defineTableDefault defaultConfig "TEST" "set_i"
+  [ ("int_i0" ,    [t| Int32 |])  ]
+  [] [0] $ Just 0)
+
 data ABC =
   ABC
   { xJustA :: SetA
diff --git a/test/SQLs.hs b/test/SQLs.hs
--- a/test/SQLs.hs
+++ b/test/SQLs.hs
@@ -16,6 +16,14 @@
 numBin op = relation $ do
   return $ value 5 `op` value 3
 
+strConcat :: Relation () String
+strConcat = relation $ do
+  return $ value "Hello, " .||. value "World!"
+
+strLike :: Relation () (Maybe Bool)
+strLike = relation $ do
+  return $ value "Hoge" `like` "H%"
+
 _p_numBin :: (Projection Flat Int32 -> Projection Flat Int32 -> Projection Flat r) -> IO ()
 _p_numBin = print . numBin
 
@@ -25,6 +33,8 @@
   , eqProp "minus" (numBin (.-.)) "SELECT ALL (5 - 3) AS f0"
   , eqProp "mult"  (numBin (.*.)) "SELECT ALL (5 * 3) AS f0"
   , eqProp "div"   (numBin (./.)) "SELECT ALL (5 / 3) AS f0"
+  , eqProp "string concat" strConcat "SELECT ALL ('Hello, ' || 'World!') AS f0"
+  , eqProp "like" strLike "SELECT ALL ('Hoge' LIKE 'H%') AS f0"
   ]
 
 tables :: [Test]
@@ -279,6 +289,9 @@
 insertX :: Insert SetA
 insertX =  derivedInsert id'
 
+insertI :: Insert SetI
+insertI =  derivedInsert id'
+
 insertQueryX :: InsertQuery ()
 insertQueryX =  derivedInsertQuery setAFromB setA
 
@@ -300,6 +313,8 @@
 effs =
   [ eqProp "insert" insertX
     "INSERT INTO TEST.set_a (int_a0, str_a1, str_a2) VALUES (?, ?, ?)"
+  , eqProp "insert1" insertI
+    "INSERT INTO TEST.set_i (int_i0) VALUES (?)"
   , eqProp "insertQuery" insertQueryX
     "INSERT INTO TEST.set_b (int_b0, str_b2, str_b2) SELECT int_a0, str_a1, str_a2 FROM TEST.set_a"
   , eqProp "updateKey" updateKeyX