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.0.1.2
+version:             0.0.1.3
 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/Projection.hs b/src/Database/Relational/Query/Projection.hs
--- a/src/Database/Relational/Query/Projection.hs
+++ b/src/Database/Relational/Query/Projection.hs
@@ -20,6 +20,7 @@
 
   unsafeFromColumns,
   unsafeFromQualifiedSubQuery,
+  unsafeFromScalarSubQuery,
   unsafeFromTable,
 
   -- * Projections
@@ -53,9 +54,9 @@
 import Database.Relational.Query.Pi (Pi)
 import qualified Database.Relational.Query.Pi.Unsafe as UnsafePi
 import Database.Relational.Query.Sub
-  (SubQuery, Qualified, ProjectionUnit,
+  (SubQuery, Qualified,
    UntypedProjection, widthOfUntypedProjection, columnsOfUntypedProjection,
-   untypedProjectionFromColumns, untypedProjectionFromSubQuery)
+   untypedProjectionFromColumns, untypedProjectionFromJoinedSubQuery, untypedProjectionFromScalarSubQuery)
 import qualified Database.Relational.Query.Sub as SubQuery
 
 
@@ -65,12 +66,6 @@
 typedProjection :: UntypedProjection -> Projection c t
 typedProjection =  Projection
 
-units :: Projection c t -> [ProjectionUnit]
-units =  untypeProjection
-
-fromUnits :: [ProjectionUnit] -> Projection c t
-fromUnits =  typedProjection
-
 -- | Width of 'Projection'.
 width :: Projection c r -> Int
 width =  widthOfUntypedProjection . untypeProjection
@@ -90,10 +85,14 @@
                   -> Projection c r -- ^ Result 'Projection'
 unsafeFromColumns =  typedProjection . untypedProjectionFromColumns
 
--- | Unsafely generate  'Projection' from qualified subquery.
+-- | Unsafely generate  'Projection' from qualified (joined) subquery.
 unsafeFromQualifiedSubQuery :: Qualified SubQuery -> Projection c t
-unsafeFromQualifiedSubQuery =  typedProjection . untypedProjectionFromSubQuery
+unsafeFromQualifiedSubQuery =  typedProjection . untypedProjectionFromJoinedSubQuery
 
+-- | Unsafely generate 'Projection' from scalar subquery.
+unsafeFromScalarSubQuery :: SubQuery -> Projection c t
+unsafeFromScalarSubQuery =  typedProjection . untypedProjectionFromScalarSubQuery
+
 -- | Unsafely generate unqualified 'Projection' from 'Table'.
 unsafeFromTable :: Table r
                 -> Projection c r
@@ -163,7 +162,7 @@
 
 -- | Projectable ap of 'Projection' type.
 pap :: Projection c (a -> b) -> Projection c a -> Projection c b
-pf `pap` pa = fromUnits $ units pf ++ units pa
+pf `pap` pa = typedProjection $ untypeProjection pf ++ untypeProjection pa
 
 -- | Projection type for row list.
 data ListProjection p t = List [p t]
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
@@ -60,7 +60,7 @@
 import Database.Relational.Query.Monad.Unique (QueryUnique)
 import qualified Database.Relational.Query.Monad.Unique as Unique
 
-import Database.Relational.Query.Component (columnSQL, Config, defaultConfig, Duplication (Distinct, All))
+import Database.Relational.Query.Component (Config, defaultConfig, Duplication (Distinct, All))
 import Database.Relational.Query.Table (Table, TableDerivable, derivedTable)
 import Database.Relational.Query.Internal.SQL (StringSQL, showStringSQL)
 import Database.Relational.Query.Internal.Product (NodeAttr(Just', Maybe))
@@ -432,9 +432,9 @@
 queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r)
              => UniqueRelation p c r
              -> m (PlaceHolders p, Projection c r)
-queryScalar' ur = addPlaceHolders . liftQualify $
-  Projection.unsafeFromColumns . (:[]) . columnSQL . SubQuery.unitSQL
-  <$> subQueryQualifyFromRelation (unUnique ur)
+queryScalar' ur =
+  addPlaceHolders . liftQualify $
+  Projection.unsafeFromScalarSubQuery <$> subQueryQualifyFromRelation (unUnique ur)
 
 -- | Scalar subQuery.
 queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r)
diff --git a/src/Database/Relational/Query/Sub.hs b/src/Database/Relational/Query/Sub.hs
--- a/src/Database/Relational/Query/Sub.hs
+++ b/src/Database/Relational/Query/Sub.hs
@@ -27,7 +27,7 @@
   -- * Untyped projection
   ProjectionUnit, UntypedProjection,
 
-  untypedProjectionFromColumns, untypedProjectionFromSubQuery,
+  untypedProjectionFromColumns, untypedProjectionFromJoinedSubQuery, untypedProjectionFromScalarSubQuery,
   widthOfUntypedProjection, columnsOfUntypedProjection,
 
 
@@ -262,11 +262,15 @@
 -- | Projection structure unit
 data ProjectionUnit = Columns (Array Int ColumnSQL)
                     | Normalized (Qualified Int)
+                    | Scalar SubQuery
                     deriving Show
 
 projectionUnitFromColumns :: [ColumnSQL] -> ProjectionUnit
 projectionUnitFromColumns cs = Columns $ listArray (0, length cs - 1) cs
 
+projectionUnitFromScalarSubQuery :: SubQuery -> ProjectionUnit
+projectionUnitFromScalarSubQuery =  Scalar
+
 -- | Untyped projection. Forgot record type.
 type UntypedProjection = [ProjectionUnit]
 
@@ -277,9 +281,13 @@
 untypedProjectionFromColumns :: [ColumnSQL] -> UntypedProjection
 untypedProjectionFromColumns =  unitUntypedProjection . projectionUnitFromColumns
 
--- | Make untyped projection from sub query.
-untypedProjectionFromSubQuery :: Qualified SubQuery -> UntypedProjection
-untypedProjectionFromSubQuery qs = d $ unQualify qs  where  --  unitUntypedProjection . Sub
+-- | Make untyped projection from scalar sub-query.
+untypedProjectionFromScalarSubQuery :: SubQuery -> UntypedProjection
+untypedProjectionFromScalarSubQuery =  unitUntypedProjection . projectionUnitFromScalarSubQuery
+
+-- | Make untyped projection from joined sub-query.
+untypedProjectionFromJoinedSubQuery :: Qualified SubQuery -> UntypedProjection
+untypedProjectionFromJoinedSubQuery qs = d $ unQualify qs  where  --  unitUntypedProjection . Sub
   normalized = unitUntypedProjection . Normalized $ fmap width qs
   d (Table _)               =  untypedProjectionFromColumns . map (column qs)
                                $ take (queryWidth qs) [0..]
@@ -292,6 +300,7 @@
 widthOfProjectionUnit =  d  where
   d (Columns a)     = mx - mn + 1 where (mn, mx) = Array.bounds a
   d (Normalized qw) = unQualify qw
+  d (Scalar _)      = 1
 
 -- | Get column of ProjectionUnit.
 columnOfProjectionUnit :: ProjectionUnit -> Int -> ColumnSQL
@@ -302,6 +311,8 @@
   d (Normalized qw) i | i < w          = qualifier qw `columnFromId` i
                       | otherwise      = error $ "index out of bounds (normalized unit): " ++ show i
     where w = unQualify qw
+  d (Scalar sub)    0                  = columnSQL' $ showUnitSQL sub
+  d (Scalar _)      i                  = error $ "index out of bounds (scalar unit): " ++ show i
 
 -- | Width of 'UntypedProjection'.
 widthOfUntypedProjection :: UntypedProjection -> Int