diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,9 +1,5 @@
 <!-- -*- Markdown -*- -->
 
-## 0.11.4.1
-
-- backport fix of fromMaybe record width.
-
 ## 0.11.4.0
 
 - add xxxNoPH effect APIs of arrow-interface.
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.11.4.1
+version:             0.12.0.0
 synopsis:            Typeful, Modular, Relational, algebraic query engine
 description:         This package contiains typeful relation structure and
                      relational-algebraic query building DSL which can
@@ -70,12 +70,6 @@
                        Database.Relational.Type
                        Database.Relational.Derives
                        Database.Relational.TH
-
-                       -- definitions and namespaces compatible with <= 0.9
-                       Database.Relational.Compat
-                       Database.Relational.Query
-                       Database.Relational.Query.Arrow
-                       Database.Relational.Query.TH
 
                        -- for GHC version equal or more than 8.0
                        Database.Relational.OverloadedProjection
diff --git a/src/Database/Relational/Compat.hs b/src/Database/Relational/Compat.hs
deleted file mode 100644
--- a/src/Database/Relational/Compat.hs
+++ /dev/null
@@ -1,123 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE KindSignatures #-}
-
--- |
--- Module      : Database.Relational.Compat
--- Copyright   : 2017 Kei Hibino
--- License     : BSD3
---
--- Maintainer  : ex8k.hibino@gmail.com
--- Stability   : experimental
--- Portability : unknown
---
--- This module contains backward compatibility definitions of
--- relational-query <= 0.9.*
-module Database.Relational.Compat
-  {-# DEPRECATED "backward compatibility definitions relational-query <= 0.9.*" #-} (
-  -- * deprecated types
-  Projection, ListProjection,
-
-  -- * deprecated classes
-  ProductConstructor (..),
-  ProjectableFunctor, (|$|), ProjectableApplicative, (|*|),
-
-  ProjectableIdZip, rightId, leftId,
-
-  SqlProjectable (..), unsafeProjectSql,
-  ProjectableShowSql (..), unsafeShowSql,
-
-  -- * deprecated defintions about Pi
-  pfmap, pap, pzero,
-  ) where
-
-import Data.Functor.ProductIsomorphic
-  (ProductIsoFunctor, (|$|), ProductIsoApplicative, (|*|),
-   ProductIsoEmpty, pureE, peRight, peLeft, )
-import Data.Functor.ProductIsomorphic.Unsafe (ProductConstructor (..))
-
-import Database.Relational hiding (unsafeShowSql', unsafeShowSql, unsafeProjectSqlTerms, unsafeProjectSql, )
-import Database.Relational.Internal.String (showStringSQL, stringSQL)
-import qualified Database.Relational.Record as Record
-import qualified Database.Relational.Projectable as Projectable
-
-{-# DEPRECATED Projection "Replaced by Record type" #-}
--- | deprecated 'Projection' type replaced by 'Record' type.
-type Projection = Record
-
-{-# DEPRECATED ListProjection "Replaced by RecordList type" #-}
--- | deprecated 'Projection' type replaced by 'Record' type.
-type ListProjection = RecordList
-
-{-# DEPRECATED ProjectableFunctor "use ProductIsoFunctor in Data.Functor.ProductIsomorphic instead of this. " #-}
--- | deprecated 'ProjectableFunctor' class replaced by 'ProductIsoFunctor' class.
-type ProjectableFunctor = ProductIsoFunctor
-
-{-# DEPRECATED ProjectableApplicative "use ProductIsoApplicative in Data.Functor.ProductIsomorphic instead of this. " #-}
--- | deprecated 'ProjectableApplicative' class replaced by 'ProductIsoApplicative' class.
-type ProjectableApplicative = ProductIsoApplicative
-
-{-# DEPRECATED ProjectableIdZip "use ProductIsoEmpty in Data.Functor.ProductIsomorphic instead of this. " #-}
--- | deprecated 'ProjectableIdZip' class replaced by 'ProductIsoEmpty' class.
-type ProjectableIdZip p = ProductIsoEmpty p ()
-
-{-# DEPRECATED rightId "use peRight in Data.Functor.ProductIsomorphic instead of this. " #-}
--- | deprecated right-id-law definition replaced by 'peRight'
-rightId :: ProjectableIdZip p => p (a, ()) -> p a
-rightId = peRight
-
-{-# DEPRECATED leftId "use peLeft in Data.Functor.ProductIsomorphic instead of this. " #-}
--- | deprecated left-id-law definition replaced by 'peLeft'
-leftId :: ProjectableIdZip p => p ((), a) -> p a
-leftId = peLeft
-
--- Pi
-
-{-# DEPRECATED pfmap "use (|$|) in Data.Functor.ProductIsomorphic instead of this." #-}
--- | deprecated map definition for Pi type. use ('|$|') instead of this.
-pfmap :: ProductConstructor (a -> b) => (a -> b) -> Pi r a -> Pi r b
-pfmap = (|$|)
-
-{-# DEPRECATED pap "use (|*|) in Data.Functor.ProductIsomorphic instead of this." #-}
--- | deprecated ap definition for Pi type. use ('|*|') instead of this.
-pap :: Pi r (a -> b) -> Pi r a -> Pi r b
-pap = (|*|)
-
-{-# DEPRECATED pzero "use pureE in Data.Functor.ProductIsomorphic instead of this." #-}
--- | deprecated empty definition for Pi type. use 'pureE' instead of this.
-pzero :: Pi a ()
-pzero = pureE
-
--- type classes
-
-{-# DEPRECATED SqlProjectable "use 'SqlContext c => Record c a' instead of 'SqlProjectable p => p a'." #-}
--- | Interface to project SQL terms unsafely.
-class SqlProjectable p where
-  -- | Unsafely project from SQL expression terms.
-  unsafeProjectSqlTerms :: [StringSQL] -- ^ SQL expression strings
-                        -> p t         -- ^ Result record
-{-# DEPRECATED unsafeProjectSqlTerms "Use Database.Relational.unsafeProjectSqlTerms instead of this." #-}
-
--- | Unsafely make 'Record' from SQL terms.
-instance SqlContext c => SqlProjectable (Record c) where
-  unsafeProjectSqlTerms = Projectable.unsafeProjectSqlTerms
-
-{-# DEPRECATED unsafeProjectSql "Use Database.Relational.unsafeProjectSql instead of this." #-}
--- | Deprecated. Use Database.Relational.unsafeProjectSql instead of this.
-unsafeProjectSql :: SqlProjectable p => String -> p a
-unsafeProjectSql = unsafeProjectSqlTerms . (:[]) . stringSQL
-
-{-# DEPRECATED ProjectableShowSql "specialized type 'Record c' should be used instead of this constraint." #-}
--- | Interface to get SQL expression from a record.
-class ProjectableShowSql p where
-  unsafeShowSql' :: p a -> StringSQL
-{-# DEPRECATED unsafeShowSql' "Use Database.Relational.unsafeShowSql' instead of this." #-}
-
-instance ProjectableShowSql (Record c) where
-  unsafeShowSql' = Record.unsafeStringSql
-
-{-# DEPRECATED unsafeShowSql "Use Database.Relational.unsafeShowSql instead of this." #-}
--- | Deprecated. Use Database.Relational.unsafeShowSql instead of this.
-unsafeShowSql :: ProjectableShowSql p => p a -> String
-unsafeShowSql = showStringSQL . unsafeShowSql'
diff --git a/src/Database/Relational/Effect.hs b/src/Database/Relational/Effect.hs
--- a/src/Database/Relational/Effect.hs
+++ b/src/Database/Relational/Effect.hs
@@ -46,7 +46,7 @@
 import Database.Relational.Table (Table, TableDerivable, derivedTable)
 import qualified Database.Relational.Table as Table
 import qualified Database.Relational.Record as Record
-import Database.Relational.ProjectableClass (ShowConstantTermsSQL)
+import Database.Relational.ProjectableClass (LiteralSQL)
 import Database.Relational.Projectable
   (PlaceHolders, unitPH, pwPlaceholder, placeholder, (><), value, )
 import Database.Relational.Monad.Trans.Assigning (assignings, (<-#))
@@ -194,7 +194,7 @@
 sqlFromInsertTarget config = sqlChunkFromInsertTarget' config 1
 
 -- | Make 'StringSQL' strings of SQL INSERT strings from records list
-sqlChunksFromRecordList :: ShowConstantTermsSQL r'
+sqlChunksFromRecordList :: LiteralSQL r'
                         => Config
                         -> Table r
                         -> Pi r r'
diff --git a/src/Database/Relational/Internal/Config.hs b/src/Database/Relational/Internal/Config.hs
--- a/src/Database/Relational/Internal/Config.hs
+++ b/src/Database/Relational/Internal/Config.hs
@@ -27,8 +27,14 @@
   identifierQuotation,
   nameConfig,
 
-  NameConfig (..),
+  NameConfig,
   defaultNameConfig,
+
+  {- field labels of 'NameConfig' type.
+     To avoid haddock bug ( https://github.com/haskell/haddock/issues/456 ),
+     they are not listed in NameConfig ( ... ). -}
+  recordConfig,
+  relationVarName,
 
   ProductUnitSupport (..), SchemaNameMode (..), IdentifierQuotation (..),
   ) where
diff --git a/src/Database/Relational/InternalTH/Base.hs b/src/Database/Relational/InternalTH/Base.hs
--- a/src/Database/Relational/InternalTH/Base.hs
+++ b/src/Database/Relational/InternalTH/Base.hs
@@ -13,7 +13,7 @@
 --
 -- This module defines templates for internally using.
 module Database.Relational.InternalTH.Base (
-  defineTupleShowConstantInstance,
+  defineTupleShowLiteralInstance,
   defineTuplePi,
 
   defineRecordProjections,
@@ -30,7 +30,7 @@
   (PersistableWidth, persistableWidth,
    PersistableRecordWidth, runPersistableRecordWidth)
 
-import Database.Relational.ProjectableClass (ShowConstantTermsSQL (..))
+import Database.Relational.ProjectableClass (LiteralSQL (..))
 import Database.Relational.Pi.Unsafe (Pi, definePi)
 
 
@@ -40,14 +40,14 @@
     ns = [ mkName $ "a" ++ show j | j <- [1 .. n] ]
     vs = map varT ns
 
--- | Make template of 'ShowConstantTermsSQL' instance of tuple type.
-defineTupleShowConstantInstance :: Int -> Q [Dec]
-defineTupleShowConstantInstance n = do
+-- | Make template of 'LiteralSQL' instance of tuple type.
+defineTupleShowLiteralInstance :: Int -> Q [Dec]
+defineTupleShowLiteralInstance n = do
   let ((_, vs), tty)  =  tupleN n
   (:[]) <$> instanceD
     -- in template-haskell 2.8 or older, Pred is not Type
-    (mapM (classP ''ShowConstantTermsSQL . (:[])) vs)
-    [t| ShowConstantTermsSQL $tty |]
+    (mapM (classP ''LiteralSQL . (:[])) vs)
+    [t| LiteralSQL $tty |]
     []
 
 -- | Make polymorphic projection templates.
diff --git a/src/Database/Relational/InternalTH/Overloaded.hs b/src/Database/Relational/InternalTH/Overloaded.hs
--- a/src/Database/Relational/InternalTH/Overloaded.hs
+++ b/src/Database/Relational/InternalTH/Overloaded.hs
@@ -95,13 +95,10 @@
 tupleProjection n = do
     p <- polymorphicProjections tyRec avs ["fst", "snd"] cts
     q <- polymorphicProjections tyRec avs sels cts
-    r <- polymorphicProjections tyRec avs oldSels cts -- DEPRECATED. drop in 0.12.0
-    return $ p ++ q ++ r
+    return $ p ++ q
   where
     sels = [ "pi" ++ show i
            | i <- [ 0 .. n - 1] ]
-    oldSels = [ "tuplePi" ++ show n ++ "_" ++ show i
-              | i <- [ 0 .. n - 1] ]
     ((avs, cts), tyRec) = tupleN
     tupleN :: (([Name], [TypeQ]), TypeQ)
     --- same as tupleN of InternalTH.Base, merge after dropping GHC 7.x
diff --git a/src/Database/Relational/Projectable.hs b/src/Database/Relational/Projectable.hs
--- a/src/Database/Relational/Projectable.hs
+++ b/src/Database/Relational/Projectable.hs
@@ -99,7 +99,7 @@
 import Database.Relational.TupleInstances ()
 import Database.Relational.Pi (Pi)
 import Database.Relational.ProjectableClass
-  (ShowConstantTermsSQL, showConstantTermsSQL, )
+  (LiteralSQL, showLiteral, )
 import Database.Relational.Record (RecordList)
 import qualified Database.Relational.Record as Record
 import Database.Relational.Projectable.Unsafe
@@ -124,8 +124,8 @@
     proxyWidth w = unsafeProjectSqlTerms $ replicate (runPersistableRecordWidth w) SQL.NULL
 
 -- | Generate record with polymorphic type of SQL constant values from Haskell value.
-value :: (ShowConstantTermsSQL t, OperatorContext c) => t -> Record c t
-value = unsafeProjectSqlTerms . showConstantTermsSQL
+value :: (LiteralSQL t, OperatorContext c) => t -> Record c t
+value = unsafeProjectSqlTerms . showLiteral
 
 -- | Record with polymorphic type of SQL true value.
 valueTrue  :: OperatorContext c => Record c (Maybe Bool)
@@ -136,7 +136,7 @@
 valueFalse =  just $ value False
 
 -- | RecordList with polymorphic type of SQL set value from Haskell list.
-values :: (ShowConstantTermsSQL t, OperatorContext c) => [t] -> RecordList (Record c) t
+values :: (LiteralSQL t, OperatorContext c) => [t] -> RecordList (Record c) t
 values =  Record.list . map value
 
 
@@ -259,12 +259,12 @@
 x `likeMaybe'` y = x `unsafeLike` y
 
 -- | String-compare operator corresponding SQL /LIKE/ .
-like :: (OperatorContext c, IsString a, ShowConstantTermsSQL a)
+like :: (OperatorContext c, IsString a, LiteralSQL a)
        => Record c a -> a -> Record c (Maybe Bool)
 x `like` a = x `like'` value a
 
 -- | String-compare operator corresponding SQL /LIKE/ . Maybe type version.
-likeMaybe :: (OperatorContext c, IsString a, ShowConstantTermsSQL a)
+likeMaybe :: (OperatorContext c, IsString a, LiteralSQL a)
           => Record c (Maybe a) -> a -> Record c (Maybe Bool)
 x `likeMaybe` a = x `unsafeLike` value a
 
@@ -300,7 +300,7 @@
 
 unsafeCastProjectable :: SqlContext c
                       => Record c a -> Record c b
-unsafeCastProjectable = Syntax.record . Syntax.untypeRecord
+unsafeCastProjectable = unsafeProjectSql' . unsafeShowSql'
 
 -- | Number fromIntegral uni-operator.
 fromIntegral' :: (SqlContext c, Integral a, Num b)
diff --git a/src/Database/Relational/ProjectableClass.hs b/src/Database/Relational/ProjectableClass.hs
--- a/src/Database/Relational/ProjectableClass.hs
+++ b/src/Database/Relational/ProjectableClass.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE ConstraintKinds #-}
 
 -- |
 -- Module      : Database.Relational.ProjectableClass
@@ -15,9 +16,11 @@
 -- direct product projections.
 module Database.Relational.ProjectableClass (
   -- * Literal SQL terms
-  ShowConstantTermsSQL (..), showConstantTermsSQL,
+  LiteralSQL (..), showLiteral,
   StringSQL,
 
+  -- * Deprecated.
+  ShowConstantTermsSQL, showConstantTermsSQL', showConstantTermsSQL,
   ) where
 
 import GHC.Generics (Generic, Rep, U1 (..), K1 (..), M1 (..), (:*:)(..), from)
@@ -27,18 +30,18 @@
 import Database.Relational.Internal.String (StringSQL)
 
 
--- | Convert from haskell record to SQL terms list.
-showConstantTermsSQL :: ShowConstantTermsSQL a
-                     => a
-                     -> [StringSQL]
-showConstantTermsSQL = toList . showConstantTermsSQL'
+-- | Convert from haskell record to SQL literal row-value.
+showLiteral :: LiteralSQL a
+            => a
+            -> [StringSQL]
+showLiteral = toList . showLiteral'
 
 {- |
-'ShowConstantTermsSQL' 'a' is implicit rule to derive function to convert
-from haskell record type 'a' into constant SQL terms.
+'LiteralSQL' 'a' is implicit rule to derive function to convert
+from haskell record type 'a' into SQL literal row-value.
 
 Generic programming (<https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming>)
-with default signature is available for 'ShowConstantTermsSQL' class,
+with default signature is available for 'LiteralSQL' class,
 so you can make instance like below:
 
 @
@@ -46,28 +49,45 @@
   import GHC.Generics (Generic)
   --
   data Foo = Foo { ... } deriving Generic
-  instance ShowConstantTermsSQL Foo
+  instance LiteralSQL Foo
 @
 
 -}
-class ShowConstantTermsSQL a where
-  showConstantTermsSQL' :: a -> DList StringSQL
+class LiteralSQL a where
+  showLiteral' :: a -> DList StringSQL
 
-  default showConstantTermsSQL' :: (Generic a, GShowConstantTermsSQL (Rep a)) => a -> DList StringSQL
-  showConstantTermsSQL' = gShowConstantTermsSQL . from
+  default showLiteral' :: (Generic a, GLiteralSQL (Rep a)) => a -> DList StringSQL
+  showLiteral' = gShowLiteral . from
 
-class GShowConstantTermsSQL f where
-  gShowConstantTermsSQL :: f a -> DList StringSQL
+class GLiteralSQL f where
+  gShowLiteral :: f a -> DList StringSQL
 
-instance GShowConstantTermsSQL U1 where
-  gShowConstantTermsSQL U1 = mempty
+instance GLiteralSQL U1 where
+  gShowLiteral U1 = mempty
 
-instance (GShowConstantTermsSQL a, GShowConstantTermsSQL b) =>
-         GShowConstantTermsSQL (a :*: b) where
-  gShowConstantTermsSQL (a :*: b) = gShowConstantTermsSQL a <> gShowConstantTermsSQL b
+instance (GLiteralSQL a, GLiteralSQL b) =>
+         GLiteralSQL (a :*: b) where
+  gShowLiteral (a :*: b) = gShowLiteral a <> gShowLiteral b
 
-instance GShowConstantTermsSQL a => GShowConstantTermsSQL (M1 i c a) where
-  gShowConstantTermsSQL (M1 a) = gShowConstantTermsSQL a
+instance GLiteralSQL a => GLiteralSQL (M1 i c a) where
+  gShowLiteral (M1 a) = gShowLiteral a
 
-instance ShowConstantTermsSQL a => GShowConstantTermsSQL (K1 i a) where
-  gShowConstantTermsSQL (K1 a) = showConstantTermsSQL' a
+instance ShowConstantTermsSQL a => GLiteralSQL (K1 i a) where
+  gShowLiteral (K1 a) = showLiteral' a
+
+---
+
+{-# DEPRECATED ShowConstantTermsSQL "Use `LiteralSQL` instead of this." #-}
+-- | Deprecated.
+type ShowConstantTermsSQL = LiteralSQL
+
+{-# DEPRECATED showConstantTermsSQL' "Use `showLiteral'` instead of this." #-}
+showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL
+showConstantTermsSQL' = showLiteral'
+
+{-# DEPRECATED showConstantTermsSQL "Use `showLiteral` instead of this." #-}
+-- | Deprecated.
+showConstantTermsSQL :: ShowConstantTermsSQL a
+                     => a
+                     -> [StringSQL]
+showConstantTermsSQL = toList . showConstantTermsSQL'
diff --git a/src/Database/Relational/Pure.hs b/src/Database/Relational/Pure.hs
--- a/src/Database/Relational/Pure.hs
+++ b/src/Database/Relational/Pure.hs
@@ -37,7 +37,7 @@
 
 import Database.Relational.Internal.String (StringSQL, stringSQL, boolSQL)
 
-import Database.Relational.ProjectableClass (ShowConstantTermsSQL (..))
+import Database.Relational.ProjectableClass (LiteralSQL (..))
 
 
 -- | Constant integral SQL terms.
@@ -59,56 +59,56 @@
 stringTermsSQL = pure . stringExprSQL
 
 -- | Constant SQL terms of '()'.
-instance ShowConstantTermsSQL ()
+instance LiteralSQL ()
 
 -- | Constant SQL terms of 'Int8'.
-instance ShowConstantTermsSQL Int8 where
-  showConstantTermsSQL' = intTermsSQL
+instance LiteralSQL Int8 where
+  showLiteral' = intTermsSQL
 
 -- | Constant SQL terms of 'Int16'.
-instance ShowConstantTermsSQL Int16 where
-  showConstantTermsSQL' = intTermsSQL
+instance LiteralSQL Int16 where
+  showLiteral' = intTermsSQL
 
 -- | Constant SQL terms of 'Int32'.
-instance ShowConstantTermsSQL Int32 where
-  showConstantTermsSQL' = intTermsSQL
+instance LiteralSQL Int32 where
+  showLiteral' = intTermsSQL
 
 -- | Constant SQL terms of 'Int64'.
-instance ShowConstantTermsSQL Int64 where
-  showConstantTermsSQL' = intTermsSQL
+instance LiteralSQL Int64 where
+  showLiteral' = intTermsSQL
 
 -- | Constant SQL terms of 'Int'.
 --   Use this carefully, because this is architecture dependent size of integer type.
-instance ShowConstantTermsSQL Int where
-  showConstantTermsSQL' = intTermsSQL
+instance LiteralSQL Int where
+  showLiteral' = intTermsSQL
 
 -- | Constant SQL terms of 'String'.
-instance ShowConstantTermsSQL String where
-  showConstantTermsSQL' = stringTermsSQL
+instance LiteralSQL String where
+  showLiteral' = stringTermsSQL
 
 -- | Constant SQL terms of 'ByteString'.
-instance ShowConstantTermsSQL ByteString where
-  showConstantTermsSQL' = stringTermsSQL . T.unpack . T.decodeUtf8
+instance LiteralSQL ByteString where
+  showLiteral' = stringTermsSQL . T.unpack . T.decodeUtf8
 
 -- | Constant SQL terms of 'LB.ByteString'.
-instance ShowConstantTermsSQL LB.ByteString where
-  showConstantTermsSQL' = stringTermsSQL . LT.unpack . LT.decodeUtf8
+instance LiteralSQL LB.ByteString where
+  showLiteral' = stringTermsSQL . LT.unpack . LT.decodeUtf8
 
 -- | Constant SQL terms of 'Text'.
-instance ShowConstantTermsSQL Text where
-  showConstantTermsSQL' = stringTermsSQL . T.unpack
+instance LiteralSQL Text where
+  showLiteral' = stringTermsSQL . T.unpack
 
 -- | Constant SQL terms of 'LT.Text'.
-instance ShowConstantTermsSQL LT.Text where
-  showConstantTermsSQL' = stringTermsSQL . LT.unpack
+instance LiteralSQL LT.Text where
+  showLiteral' = stringTermsSQL . LT.unpack
 
 -- | Constant SQL terms of 'Char'.
-instance ShowConstantTermsSQL Char where
-  showConstantTermsSQL' = stringTermsSQL . (:"")
+instance LiteralSQL Char where
+  showLiteral' = stringTermsSQL . (:"")
 
 -- | Constant SQL terms of 'Bool'.
-instance ShowConstantTermsSQL Bool where
-  showConstantTermsSQL' = pure . boolSQL
+instance LiteralSQL Bool where
+  showLiteral' = pure . boolSQL
 
 floatTerms :: (PrintfArg a, Ord a, Num a)=> a -> DList StringSQL
 floatTerms f = pure . stringSQL $ printf fmt f  where
@@ -117,44 +117,44 @@
     | otherwise = "(%f)"
 
 -- | Constant SQL terms of 'Float'. Caution for floating-point error rate.
-instance ShowConstantTermsSQL Float where
-  showConstantTermsSQL' = floatTerms
+instance LiteralSQL Float where
+  showLiteral' = floatTerms
 
 -- | Constant SQL terms of 'Double'. Caution for floating-point error rate.
-instance ShowConstantTermsSQL Double where
-  showConstantTermsSQL' = floatTerms
+instance LiteralSQL Double where
+  showLiteral' = floatTerms
 
 constantTimeTerms :: FormatTime t => Keyword -> String -> t -> DList StringSQL
 constantTimeTerms kw fmt t = pure $ kw <> stringExprSQL (formatTime defaultTimeLocale fmt t)
 
 -- | Constant SQL terms of 'Day'.
-instance ShowConstantTermsSQL Day where
-  showConstantTermsSQL' = constantTimeTerms DATE "%Y-%m-%d"
+instance LiteralSQL Day where
+  showLiteral' = constantTimeTerms DATE "%Y-%m-%d"
 
 -- | Constant SQL terms of 'TimeOfDay'.
-instance ShowConstantTermsSQL TimeOfDay where
-  showConstantTermsSQL' = constantTimeTerms TIME "%H:%M:%S"
+instance LiteralSQL TimeOfDay where
+  showLiteral' = constantTimeTerms TIME "%H:%M:%S"
 
 -- | Constant SQL terms of 'LocalTime'.
-instance ShowConstantTermsSQL LocalTime where
-  showConstantTermsSQL' = constantTimeTerms TIMESTAMP "%Y-%m-%d %H:%M:%S"
+instance LiteralSQL LocalTime where
+  showLiteral' = constantTimeTerms TIMESTAMP "%Y-%m-%d %H:%M:%S"
 
 -- | Constant SQL terms of 'ZonedTime'.
 --   This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal.
-instance ShowConstantTermsSQL ZonedTime where
-  showConstantTermsSQL' = constantTimeTerms TIMESTAMPTZ "%Y-%m-%d %H:%M:%S%z"
+instance LiteralSQL ZonedTime where
+  showLiteral' = constantTimeTerms TIMESTAMPTZ "%Y-%m-%d %H:%M:%S%z"
 
 -- | Constant SQL terms of 'UTCTime'.
 --   This generates ***NOT STANDARD*** SQL of TIMESTAMPTZ literal with UTC timezone.
-instance ShowConstantTermsSQL UTCTime where
-  showConstantTermsSQL' = constantTimeTerms TIMESTAMPTZ "%Y-%m-%d %H:%M:%S%z"
+instance LiteralSQL UTCTime where
+  showLiteral' = constantTimeTerms TIMESTAMPTZ "%Y-%m-%d %H:%M:%S%z"
 
-showMaybeTerms :: ShowConstantTermsSQL a => PersistableRecordWidth a -> Maybe a -> DList StringSQL
+showMaybeTerms :: LiteralSQL a => PersistableRecordWidth a -> Maybe a -> DList StringSQL
 showMaybeTerms wa = d  where
-  d (Just a) = showConstantTermsSQL' a
+  d (Just a) = showLiteral' a
   d Nothing  = fromList . replicate (runPersistableRecordWidth wa) $ stringSQL "NULL"
 
 -- | Constant SQL terms of 'Maybe' type. Width inference is required.
-instance (PersistableWidth a, ShowConstantTermsSQL a)
-         => ShowConstantTermsSQL (Maybe a) where
-  showConstantTermsSQL' = showMaybeTerms persistableWidth
+instance (PersistableWidth a, LiteralSQL a)
+         => LiteralSQL (Maybe a) where
+  showLiteral' = showMaybeTerms persistableWidth
diff --git a/src/Database/Relational/Query.hs b/src/Database/Relational/Query.hs
deleted file mode 100644
--- a/src/Database/Relational/Query.hs
+++ /dev/null
@@ -1,19 +0,0 @@
--- |
--- Module      : Database.Relational.Query
--- Copyright   : 2017 Kei Hibino
--- License     : BSD3
---
--- Maintainer  : ex8k.hibino@gmail.com
--- Stability   : experimental
--- Portability : unknown
---
--- This module contains backword compatibility interface of
--- relational-query <= 0.9.*
-module Database.Relational.Query
-       {-# DEPRECATED "Should switch namespace to Database.Relational" #-}
-       ( module Database.Relational,
-         module Database.Relational.Compat,
-       )  where
-
-import Database.Relational hiding (unsafeShowSql', unsafeShowSql, unsafeProjectSqlTerms, unsafeProjectSql)
-import Database.Relational.Compat
diff --git a/src/Database/Relational/Query/Arrow.hs b/src/Database/Relational/Query/Arrow.hs
deleted file mode 100644
--- a/src/Database/Relational/Query/Arrow.hs
+++ /dev/null
@@ -1,19 +0,0 @@
--- |
--- Module      : Database.Relational.Query.Arrow
--- Copyright   : 2017 Kei Hibino
--- License     : BSD3
---
--- Maintainer  : ex8k.hibino@gmail.com
--- Stability   : experimental
--- Portability : unknown
---
--- This module contains backword compatibility interface of
--- relational-query <= 0.9.*
-module Database.Relational.Query.Arrow
-       {-# DEPRECATED "Should switch namespace to Database.Relational.Arrow" #-}
-       ( module Database.Relational.Arrow,
-         module Database.Relational.Compat,
-       )  where
-
-import Database.Relational.Arrow hiding (unsafeShowSql', unsafeShowSql, unsafeProjectSqlTerms, unsafeProjectSql)
-import Database.Relational.Compat
diff --git a/src/Database/Relational/Query/TH.hs b/src/Database/Relational/Query/TH.hs
deleted file mode 100644
--- a/src/Database/Relational/Query/TH.hs
+++ /dev/null
@@ -1,17 +0,0 @@
--- |
--- Module      : Database.Relational.Query.TH
--- Copyright   : 2018 Kei Hibino
--- License     : BSD3
---
--- Maintainer  : ex8k.hibino@gmail.com
--- Stability   : experimental
--- Portability : unknown
---
--- This module contains backword compatibility interface of
--- relational-query <= 0.9.*
-module Database.Relational.Query.TH
-  {-# DEPRECATED "Should switch namespace to Database.Relational.TH" #-}
-  ( module Database.Relational.TH
-  ) where
-
-import Database.Relational.TH
diff --git a/src/Database/Relational/Sequence.hs b/src/Database/Relational/Sequence.hs
--- a/src/Database/Relational/Sequence.hs
+++ b/src/Database/Relational/Sequence.hs
@@ -42,7 +42,7 @@
 import Database.Relational.Constraint
   (HasConstraintKey (..), Key, Primary, projectionKey)
 import Database.Relational.Projectable ((.<=.), value, unitPH, (!))
-import Database.Relational.ProjectableClass (ShowConstantTermsSQL)
+import Database.Relational.ProjectableClass (LiteralSQL)
 import Database.Relational.Relation (tableOf)
 import qualified Database.Relational.Relation as Relation
 import Database.Relational.Effect (updateTarget')
@@ -135,7 +135,7 @@
 ($$) = ($$!)
 
 -- | Update statement for sequence table
-updateNumber' :: (PersistableWidth s, Integral i, ShowConstantTermsSQL i)
+updateNumber' :: (PersistableWidth s, Integral i, LiteralSQL i)
               => Config
               -> i            -- ^ sequence number to set. expect not SQL injectable.
               -> Sequence s i -- ^ sequence table
@@ -147,7 +147,7 @@
   return unitPH
 
 -- | Update statement for sequence table
-updateNumber :: (PersistableWidth s, Integral i, ShowConstantTermsSQL i)
+updateNumber :: (PersistableWidth s, Integral i, LiteralSQL i)
              => i            -- ^ sequence number to set. expect not SQL injectable.
              -> Sequence s i -- ^ sequence table
              -> Update ()
diff --git a/src/Database/Relational/TH.hs b/src/Database/Relational/TH.hs
--- a/src/Database/Relational/TH.hs
+++ b/src/Database/Relational/TH.hs
@@ -86,7 +86,7 @@
 import qualified Database.Record.TH as Record
 
 import Database.Relational
-  (Table, Pi, id', Relation, ShowConstantTermsSQL,
+  (Table, Pi, id', Relation, LiteralSQL,
    NameConfig (..), SchemaNameMode (..), IdentifierQuotation (..), defaultConfig,
    Config (normalizedTableName, disableOverloadedProjection, disableSpecializedProjection,
            schemaNameMode, nameConfig, identifierQuotation),
@@ -329,7 +329,7 @@
   let recConfig = recordConfig $ nameConfig config
   recD    <- defineRecordTypeWithConfig recConfig schema table columns derives
   rconD   <- defineProductConstructorInstanceWithConfig config schema table [t | (_, t) <- columns]
-  ctD     <- [d| instance ShowConstantTermsSQL $(fst $ recordTemplate recConfig schema table) |]
+  ctD     <- [d| instance LiteralSQL $(fst $ recordTemplate recConfig schema table) |]
   tableDs <- defineTableTypesWithConfig config schema table columns
   return $ recD ++ rconD ++ ctD ++ tableDs
 
@@ -494,8 +494,8 @@
         return $ cols ++ ovls
 
   pc <- defineProductConstructor recTypeName
-  let scPred v = classP ''ShowConstantTermsSQL [varT v]
-  ct <- instanceD (mapM scPred vars) (appT [t| ShowConstantTermsSQL |] tyCon) []
+  let scPred v = classP ''LiteralSQL [varT v]
+  ct <- instanceD (mapM scPred vars) (appT [t| LiteralSQL |] tyCon) []
   return $ concat [pw, cols, pc, [ct]]
 
 -- | Generate all templates against defined record like type constructor
diff --git a/src/Database/Relational/Table.hs b/src/Database/Relational/Table.hs
--- a/src/Database/Relational/Table.hs
+++ b/src/Database/Relational/Table.hs
@@ -11,7 +11,6 @@
 module Database.Relational.Table (
   -- * Phantom typed table type
   Table, untype, name, shortName, width, columns, index, table, toMaybe, recordWidth,
-  unType,
 
   toSubQuery,
 
@@ -36,11 +35,6 @@
 -- | Untype table.
 untype :: Table t -> Untyped
 untype (Table u) = u
-
-{-# DEPRECATED unType "Use untype instead of this." #-}
--- | Deprecated. use 'untype'.
-unType :: Table t -> Untyped
-unType = untype
 
 -- | Name string of table in SQL
 name :: Table r -> String
diff --git a/src/Database/Relational/TupleInstances.hs b/src/Database/Relational/TupleInstances.hs
--- a/src/Database/Relational/TupleInstances.hs
+++ b/src/Database/Relational/TupleInstances.hs
@@ -22,11 +22,11 @@
 
 import Database.Relational.Pi (Pi)
 import Database.Relational.InternalTH.Base
-  (defineTuplePi, defineTupleShowConstantInstance,)
+  (defineTuplePi, defineTupleShowLiteralInstance,)
 
 
 $(concat <$> mapM defineTuplePi [2..7])
-$(concat <$> mapM defineTupleShowConstantInstance [2..7])
+$(concat <$> mapM defineTupleShowLiteralInstance [2..7])
 -- Generic instances of tuple types are generated from 2 to 7 in GHC.Generics.
 
 -- | Projection path for fst of tuple.
diff --git a/src/Database/Relational/Type.hs b/src/Database/Relational/Type.hs
--- a/src/Database/Relational/Type.hs
+++ b/src/Database/Relational/Type.hs
@@ -77,7 +77,7 @@
    sqlChunkFromInsertTarget, sqlFromInsertTarget, sqlChunksFromRecordList)
 import Database.Relational.Pi (Pi)
 import Database.Relational.Table (Table, TableDerivable, derivedTable)
-import Database.Relational.ProjectableClass (ShowConstantTermsSQL)
+import Database.Relational.ProjectableClass (LiteralSQL)
 import Database.Relational.Projectable (PlaceHolders, unitPH)
 import Database.Relational.SimpleSql
   (QuerySuffix, showsQuerySuffix, insertPrefixSQL,
@@ -337,7 +337,7 @@
 derivedInsertValue = insertValue
 
 -- | Make typed 'Insert' list from 'Config' and records list.
-insertValueList' :: (TableDerivable r, ShowConstantTermsSQL r')
+insertValueList' :: (TableDerivable r, LiteralSQL r')
                  => Config
                  -> Pi r r'
                  -> [r']
@@ -347,7 +347,7 @@
   . sqlChunksFromRecordList config derivedTable pi'
 
 -- | Make typed 'Insert' list from records list.
-insertValueList :: (TableDerivable r, ShowConstantTermsSQL r')
+insertValueList :: (TableDerivable r, LiteralSQL r')
                 => Pi r r'
                 -> [r']
                 -> [Insert ()]
diff --git a/test/sqlsEq.hs b/test/sqlsEq.hs
--- a/test/sqlsEq.hs
+++ b/test/sqlsEq.hs
@@ -414,15 +414,6 @@
 
   return $ fromMaybe (value 1) (a ?! intA0') >< b
 
-maybeY :: Relation () (SetA, SetB)
-maybeY =  relation $ do
-  a <- queryMaybe setA
-  b <- query setB
-
-  wheres $ a ?! strA2' .=. b ! mayStrB1'
-
-  return $ fromMaybe (SetA |$| value 1 |*| value "foo" |*| value "var") a >< b
-
 notX :: Relation () (Maybe Bool)
 notX = relation $
   return $ not' valueFalse
@@ -446,12 +437,6 @@
   , eqProp "fromMaybe" maybeX
     "SELECT ALL CASE WHEN (T0.int_a0 IS NULL) THEN 1 ELSE T0.int_a0 END AS f0, \
     \           T1.int_b0 AS f1, T1.may_str_b1 AS f2, T1.str_b2 AS f3 \
-    \  FROM TEST.set_a T0 RIGHT JOIN TEST.set_b T1 ON (0=0) WHERE (T0.str_a2 = T1.may_str_b1)"
-  , eqProp "fromMaybe record" maybeY
-    "SELECT ALL CASE WHEN (T0.int_a0 IS NULL) THEN 1 ELSE T0.int_a0 END AS f0, \
-    \           CASE WHEN (T0.int_a0 IS NULL) THEN 'foo' ELSE T0.str_a1 END AS f1, \
-    \           CASE WHEN (T0.int_a0 IS NULL) THEN 'var' ELSE T0.str_a2 END AS f2, \
-    \           T1.int_b0 AS f3, T1.may_str_b1 AS f4, T1.str_b2 AS f5 \
     \  FROM TEST.set_a T0 RIGHT JOIN TEST.set_b T1 ON (0=0) WHERE (T0.str_a2 = T1.may_str_b1)"
   , eqProp "not" notX
     "SELECT ALL (NOT (0=1)) AS f0"