{

using node = Node;

static constexpr std::size_t pos = Pos;

{

using type = Type;

static constexpr std::size_t name = Name;

static constexpr std::size_t next = Next;

{

if constexpr (std::is_same_v<Row, sql::void_row>)

{

return false;

}

else

{

if constexpr (Row::column::name == Name)

{

return true;

}

else

{

return exists<Name, typename Row::next>();

}

}

{

auto curr{ str.cbegin() }, end{ str.cend() };

constexpr Char dot{ '.' }, zro{ '0' }, min{ '-' };

Type acc{}, sign{ 1 }, scalar{ 10 };

if (*curr == min)

{

sign = -1;

++curr;

}

while (curr != end && *curr != dot)

{

acc = (acc * scalar) + (*curr - zro);

++curr;

}

if (curr != end && *curr == dot)

{

scalar = 1;

++curr;

while(curr != end)

{

acc += (*curr - zro) * (scalar /= Type{ 10 });

++curr;

}

}

return value<Type>{ acc * sign };

{

bool result{ false };

for (auto c : tv)

{

result |= (c == '.');

}

return !result;

{

public:

using row_type = std::remove_cvref_t<typename Expr::output_type>;

// seeds row datamember for first dereference

query_iterator(bool end) : end_{ end }, row_{}

{

operator++();

}

inline bool operator==(query_iterator const& it) const noexcept

{

return end_ == it.end_;

}

inline bool operator!=(query_iterator const& it) const noexcept

{

return !(*this == it);

}

inline row_type const& operator*() const noexcept

{

return row_;

}

query_iterator& operator++()

{

if (!end_)

{

try

{

row_ = Expr::next();

}

catch (ra::data_end const& e)

{

end_ = true;

}

}

return *this;

}

private:

bool end_{};

row_type row_{};

{

private:

// where predicate terminal parsing

template <std::size_t Pos, typename Row>

static constexpr auto parse_terms()

{

if constexpr (tokens_[Pos] == "(")

{

constexpr auto next{ parse_or<Pos + 1, Row>() };

using node = typename decltype(next)::node;

static_assert(tokens_[next.pos] == ")", "No closing paranthesis found.");

return context<next.pos + 1, node>{};

}

else if constexpr (isquote(tokens_[Pos]))

{

constexpr cexpr::string<char, tokens_[Pos + 1].length() + 1> name{ tokens_[Pos + 1] };

using str = decltype(name);

using node = sql::constant<value<str>{ name }, Row>;

static_assert(isquote(tokens_[Pos + 2]), "No closing quote found.");

return context<Pos + 3, node>{};

}

else if constexpr (isdigit(tokens_[Pos][0]))

{

constexpr cexpr::string<char, tokens_[Pos].length() + 1> name{ tokens_[Pos] };

using val = decltype(isintegral(tokens_[Pos]) ? std::int64_t{} : double{});

using node = sql::constant<sql::convert<val>(name), Row>;

return context<Pos + 1, node>{};

}

else

{

constexpr cexpr::string<char, tokens_[Pos].length() + 1> name{ tokens_[Pos] };

using node = sql::variable<name, Row>;

return context<Pos + 1, node>{};

}

}

// parses a single compare operation

template <typename Left, typename Row>

static constexpr auto recurse_comparison()

{

if constexpr (!iscomp(tokens_[Left::pos][0]))

{

return Left{};

}

else

{

constexpr auto next{ parse_terms<Left::pos + 1, Row>() };

constexpr cexpr::string<char, tokens_[Left::pos].length() + 1> name{ tokens_[Left::pos] };

using ranode = typename decltype(next)::node;

using node = sql::operation<name, Row, typename Left::node, ranode>;

return context<next.pos, node>{};

}

}

// descend further and attempt to parse a compare operation

template <std::size_t Pos, typename Row>

static constexpr auto parse_comparison()

{

using left = decltype(parse_terms<Pos, Row>());

return recurse_comparison<left, Row>();

}

// attempt to parse a negation operation then descend further

template <std::size_t Pos, typename Row>

static constexpr auto parse_negation()

{

if constexpr (isnot(tokens_[Pos]))

{

constexpr auto next{ parse_comparison<Pos + 1, Row>() };

using ranode = typename decltype(next)::node;

using node = sql::operation<"NOT", Row, ranode>;

return context<next.pos, node>{};

}

else

{

return parse_comparison<Pos, Row>();

}

}

// recursively parse chained AND operations

template <typename Left, typename Row>

static constexpr auto recurse_and()

{

if constexpr (!isand(tokens_[Left::pos]))

{

return Left{};

}

else

{

constexpr auto next{ parse_negation<Left::pos + 1, Row>() };

using ranode = typename decltype(next)::node;

using node = sql::operation<"AND", Row, typename Left::node, ranode>;

return recurse_and<context<next.pos, node>, Row>();

}

}

// descend further then attempt to parse AND operations

template <std::size_t Pos, typename Row>

static constexpr auto parse_and()

{

using left = decltype(parse_negation<Pos, Row>());

return recurse_and<left, Row>();

}

// recursively parse chained OR operations

template <typename Left, typename Row>

static constexpr auto recurse_or()

{

if constexpr (!isor(tokens_[Left::pos]))

{

return Left{};

}

else

{

constexpr auto next{ parse_and<Left::pos + 1, Row>() };

using ranode = typename decltype(next)::node;

using node = sql::operation<"OR", Row, typename Left::node, ranode>;

return recurse_or<context<next.pos, node>, Row>();

}

}

// descend further then attempt to parse OR operations

template <std::size_t Pos, typename Row>

static constexpr auto parse_or()

{

using left = decltype(parse_and<Pos, Row>());

return recurse_or<left, Row>();

}

// find correct schema for terminal relation

template <cexpr::string Name, std::size_t Id, typename Schema, typename... Others>

static constexpr auto recurse_schemas()

{

if constexpr (Name == Schema::name)

{

return ra::relation<Schema, Id>{};

}

else

{

static_assert(sizeof...(Others) != 0, "Schema name used in JOIN was not provided.");

return recurse_schemas<Name, Id, Others...>();

}

}

// wrapper function to determine terminal relation

template <std::size_t Pos>

static constexpr auto parse_schema()

{

if constexpr (tokens_[Pos] == "(")

{

constexpr auto next{ parse_root<Pos + 1>() };

using node = typename decltype(next)::node;

static_assert(tokens_[next.pos] == ")", "No closing paranthesis found.");

return context<next.pos + 1, node>{};

}

else

{

constexpr cexpr::string<char, tokens_[Pos].length() + 1> name{ tokens_[Pos] };

using node = decltype(recurse_schemas<name, Pos, Schemas...>());

return context<Pos + 1, node>{};

}

}

// stub which will choose the specific join RA node

template <std::size_t Pos, typename Left, typename Right>

static constexpr auto choose_join()

{

if constexpr (isnatural(tokens_[Pos]))

{

return ra::natural<Left, Right>{};

}

else

{

return ra::cross<Left, Right>{};

}

}

// parses join colinfo if a join is present else returns the single relation terminal

template <std::size_t Pos>

static constexpr auto parse_join()

{

constexpr auto lnext{ parse_schema<Pos>() };

using lnode = typename decltype(lnext)::node;

if constexpr (lnext.pos + 2 < tokens_.count() && isjoin(tokens_[lnext.pos + 1]))

{

constexpr auto rnext{ parse_schema<lnext.pos + 2>() };

using rnode = typename decltype(rnext)::node;

using join = decltype(choose_join<lnext.pos, lnode, rnode>());

return context<rnext.pos, join>{};

}

else

{

return context<lnext.pos, lnode>{};

}

}

// starting point to parse everything after the from keyword

template <std::size_t Pos>

static constexpr auto parse_from()

{

static_assert(isfrom(tokens_[Pos]), "Expected 'FROM' token not found.");

constexpr auto next{ parse_join<Pos + 1>() };

using node = typename decltype(next)::node;

if constexpr (next.pos < tokens_.count() && iswhere(tokens_[next.pos]))

{

using output = std::remove_cvref_t<typename node::output_type>;

constexpr auto predicate{ parse_or<next.pos + 1, output>() };

using pnext = typename decltype(predicate)::node;

using snode = ra::selection<pnext, node>;

return context<predicate.pos, snode>{};

}

else

{

return context<next.pos, node>{};

}

}

// recursively searches all schemas for the a matching column

template <cexpr::string Name, typename Schema, typename... Others>

static constexpr auto recurse_types()

{

if constexpr (sql::exists<Name, typename Schema::row_type>())

{

return decltype(sql::get<Name>(typename Schema::row_type{})){};

}

else

{

static_assert(sizeof...(Others) != 0, "Column name was not present in any schema.");

return recurse_types<Name, Others...>();

}

}

// wrapper to determine the type for the the column

template <std::size_t Pos>

static constexpr auto column_type()

{

constexpr cexpr::string<char, tokens_[Pos].length() + 1> name{ tokens_[Pos] };

return recurse_types<name, Schemas...>();

}

// asserts token is column separator, and if comma returns one past the comma else start position

template <std::size_t Pos>

static constexpr std::size_t next_column()

{

static_assert(isseparator(tokens_[Pos]), "Expected ',' or 'FROM' token following column.");

if constexpr (iscomma(tokens_[Pos]))

{

return Pos + 1;

}

else

{

return Pos;

}

}

template <std::size_t Pos, bool Rename>

static constexpr auto parse_colinfo()

{

static_assert(iscolumn(tokens_[Pos]), "Invalid token starting column delcaration.");

constexpr bool rename{ isas(tokens_[Pos + 1]) && iscolumn(tokens_[Pos + 2]) };

using col = decltype(column_type<Pos>());

if constexpr (Rename && rename)

{

constexpr auto next{ next_column<Pos + 3>() };

return colinfo<col, Pos + 2, next>{};

}

else if constexpr (rename)

{

constexpr auto next{ next_column<Pos + 3>() };

return colinfo<col, Pos, next>{};

}

else

{

constexpr auto next{ next_column<Pos + 1>() };

return colinfo<col, Pos, next>{};

}

}

// recursively parse all columns projected/renamed in the query

template <std::size_t Pos, bool Rename>

static constexpr auto recurse_columns()

{

if constexpr (isfrom(tokens_[Pos]))

{

return context<Pos, sql::void_row>{};

}

else

{

constexpr auto info{ parse_colinfo<Pos, Rename>() };

constexpr cexpr::string<char, tokens_[info.name].length() + 1> name{ tokens_[info.name] };

constexpr auto child{ recurse_columns<info.next, Rename>() };

using next = std::remove_const_t<typename decltype(child)::node>;

using col = std::remove_const_t<decltype(sql::column<name, typename decltype(info)::type>{})>;

using node = sql::row<col, next>;

return context<child.pos, node>{};

}

}

// wrapper to parse columns as a projection RA node

template <std::size_t Pos>

static constexpr auto parse_projection()

{

constexpr auto proj{ recurse_columns<Pos, false>() };

constexpr auto next{ parse_from<proj.pos>() };

using ranode = typename decltype(proj)::node;

using node = ra::projection<ranode, typename decltype(next)::node>;

return context<next.pos, node>{};

}

// wrapper to parse columns as a rename RA node

template <std::size_t Pos>

static constexpr auto parse_rename()

{

constexpr auto next = parse_projection<Pos>();

using ranode = typename decltype(recurse_columns<Pos, true>())::node;

using node = ra::rename<ranode, typename decltype(next)::node>;

return context<next.pos, node>{};

}

// attempts to match column rename operation pattern on a column

template <std::size_t Pos>

static constexpr bool has_rename()

{

if constexpr (isfrom(tokens_[Pos]) || isfrom(tokens_[Pos + 2]))

{

return false;

}

else if constexpr (iscolumn(tokens_[Pos]) && isas(tokens_[Pos + 1]) && iscolumn(tokens_[Pos + 2]))

{

return true;

}

else

{

constexpr bool comma{ iscomma(tokens_[Pos + 1]) };

static_assert(comma || isfrom(tokens_[Pos + 1]), "Expected ',' or 'FROM' token following column.");

if constexpr (comma)

{

return has_rename<Pos + 2>();

}

else

{

return has_rename<Pos + 1>();

}

}

}

// decide RA node to root the expression tree

template <std::size_t Pos>

static constexpr auto parse_root()

{

static_assert(isselect(tokens_[Pos]), "Expected 'SELECT' token not found.");

if constexpr (tokens_[Pos + 1] == "*")

{

return parse_from<Pos + 2>();

}

else if constexpr (has_rename<Pos + 1>())

{

return parse_rename<Pos + 1>();

}

else

{

return parse_projection<Pos + 1>();

}

}

static constexpr sql::tokens<char, sql::preprocess(Str)> tokens_{ Str };

using expression = typename decltype(parse_root<0>())::node;

bool empty_;

public:

using iterator = query_iterator<expression>;

using row_type = expression::output_type;

query(Schemas const&... tables)

{

try

{

expression::seed(tables...);

empty_ = false;

}

catch(ra::data_end const& e)

{

empty_ = true;

}

}

~query()

{

expression::reset();

}

inline iterator begin() const

{

return iterator{ empty_ };

}

inline iterator end() const

{

return iterator{ true };

}