S>WITH 
S>  SalesYearlyTotals (SalesPersonID, TotalSales, SalesYear)
S>AS
S>(
S>    SELECT SalesPersonID, SUM(TotalDue) AS TotalSales, YEAR(OrderDate) AS SalesYear
S>    FROM Sales.SalesOrderHeader
S>    WHERE SalesPersonID IS NOT NULL
S>       GROUP BY SalesPersonID, YEAR(OrderDate)
S>),
S>  SalesYearlyAverages
S>AS
S>(
S>    SELECT SalesBranchID, AVG(TotalSales) AS AverageSales, SalesYear
S>    FROM SalesYearlyTotals inner join SalesPersons on SalesYearlyTotals.SalesPersonId = SalesPersons.Id
S>    GROUP BY SalesBranchID, SalesYear
S>)
S>SELECT SalesPersonId 
S>  FROM SalesYearlyTotals 
S>  INNER JOIN SalesPersons on SalesYearlyTotals.SalesPersonID = SalesPersons.SalesPersonID
S>  INNER JOIN SalesYearlyAverages on SalesPersons.SalesBranchID = SalesYearlyAverages.SalesBranchID AND SalesYearlyTotals.SalesYear = SalesYearlyAverages.SalesYear
S>  where SalesYearlyTotals.TotalSales >= SalesYearlyAverages.AverageSales
S>

Sales::Person p; Sales::Order o;
auto y=select(o.person, sum(o.total).as(year_sales), o.year).from(o).where(is_not_null(o.person)).group_by(o.person, o.year).as(sqlpp::alias::y);
auto a=select(p.branch, avg(y.year_sales).as(branch_avg), y.year).from(p.join(y).on(p.id==y.person)).where(true).group_by(p.branch, y.year).as(sqlpp::alias::a);
auto q=select(p.id).from(p.join(y).on(p.id==y.person).join(a).on(p.branch==a.branch)).where(y.year_sales>a.branch_avg);

S>>>    auto x = select(apples.appleId, oranges.orangeId); // WTF is x???
S>>>

// Terminal symbols:
struct Select {} select;
struct Where {} where;

// Nonterminal:
template<typename Left, typename Right> struct Pipeline {};

template<typename T, typename U>
auto operator|(T, U)
{
    return Pipeline<T, U>{};
}

// Utility for print type at compile time:
template<typename T> void type_is(T);

int main()
{
    // Create expression tree by parts, in different expressions:
    // 1:
    auto q1 = select | where;
    // 2:
    auto q2 = q1 | select;
    // Print type of q2:
    type_is(q2);
}

undefined reference to `void type_is<Pipeline<Pipeline<Select, Where>, Select> >(Pipeline<Pipeline<Select, Where>, Select>)'

// Process expression tree:
template<typename _>
struct CheckGrammar
{
    using type = bool;
};

template<typename Left, typename Right>
struct CheckGrammar<Pipeline<Left, Right>>
{
    using type = typename CheckGrammar<Left>::type; // Recurse to left sub-tree
};

template<typename _>
struct CheckGrammar
<
    Pipeline<Pipeline<Pipeline<_, Where>, Select>, Where> // Pattern matching
>
{
    using type = typename _::error_in_grammar_after;
};

template<typename T, typename U>
auto operator|(T, U)
{
    auto result = Pipeline<T, U>{};
    using run = typename CheckGrammar<decltype(result)>::type; // Run grammar check at compile-time
    return result;
}

int main()
{
    auto q1 = where | select | select; // OK
    auto q2 = q1 | where; // OK
    auto q3 = q2 | select | where; // ERROR
}

main.cpp:31:30: error: no type named 'error_in_grammar_after' in 'Pipeline<Pipeline<Where, Select>, Select>'
    using type = typename _::error_in_grammar_after;
                 ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

main.cpp:38:26: note: in instantiation of template class 'CheckGrammar<Pipeline<Pipeline<Pipeline<Pipeline<Pipeline<Where, Select>, Select>, Where>, Select>, Where> >' requested here
    using run = typename CheckGrammar<decltype(result)>::type; // Run grammar check at compile-time
                         ^

main.cpp:46:27: note: in instantiation of function template specialization 'operator|<Pipeline<Pipeline<Pipeline<Pipeline<Where, Select>, Select>, Where>, Select>, Where>' requested here
    auto q3 = q2 | select | where; // ERROR

http://rsdn.ru/forum/flame.comp/6014725.1

Автор: Evgeny.Panasyuk
Дата: 14.04.15

EP>Изначально речь шла про принципиальную возможность. А возможно это не только в C++, но и например в D или Nemerle.
EP>Что же касается конкретного примера — я с СУБД вообще не работаю. Для создания полного примера мне придётся разбираться с одной из упомянутых выше библиотек — на первый взгляд то о чём я говорю там вполне реализуемо, но могут быть некоторые детали которые будут препятствовать реализации, что впрочем никак не будет означать принципиальную невозможность, и соответственно к изначальному тезису не имеет отношения.

EP>Если же есть сомнения в принципиальной реализуемости — то готов ответить на конкретные вопросы.

_>Sales::Person p; Sales::Order o;
_>auto y=select(o.person, sum(o.total).as(year_sales), o.year).from(o).where(is_not_null(o.person)).group_by(o.person, o.year).as(sqlpp::alias::y);
_>auto a=select(p.branch, avg(y.year_sales).as(branch_avg), y.year).from(p.join(y).on(p.id==y.person)).where(true).group_by(p.branch, y.year).as(sqlpp::alias::a);
_>auto q=select(p.id).from(p.join(y).on(p.id==y.person).join(a).on(p.branch==a.branch)).where(y.year_sales>a.branch_avg);
_>

auto y=select(o.person, sum(o.total).as(year_sales), o.year).from(o).where(is_not_null(o.person)).as(sqlpp::alias::y);

S>Вопрос не в том, компилируемый он или нет. Вопрос в том, что помешает скомпилироваться и коду с ошибками.
Помешает логика закодированная в коде который обходит дерево выражения.