sqltype *type;

virtual void out(std::ostream &out) = 0;

virtual ~value_expr() { }

value_expr(prod *p) : prod(p) { }

static shared_ptr<value_expr> factory(prod *p, sqltype *type_constraint, bool can_return_set);

shared_ptr<value_expr> condition;

shared_ptr<value_expr> true_expr;

shared_ptr<value_expr> false_expr;

case_expr(prod *p, sqltype *type_constraint = 0);

virtual void out(std::ostream &out);

virtual void accept(prod_visitor *v);

routine *proc;

bool is_aggregate;

vector<shared_ptr<value_expr> > parms;

virtual void out(std::ostream &out);

virtual ~funcall() { }

funcall(prod *p, sqltype *type_constraint = 0, bool can_return_set = false, bool agg = false);

virtual void accept(prod_visitor *v) {

v->visit(this);

for (auto p : parms)

p->accept(v);

}

op *oper;

shared_ptr<value_expr> lhs, rhs;

virtual ~opcall() { }

opcall(prod *p, sqltype *type_constraint = 0);

virtual void out(std::ostream &o) {

if(oper->left)

o << "(" << *lhs << ") " << oper->name << " (" << *rhs << ")";

else

o << oper->name << " " << *rhs;

}

virtual void accept(prod_visitor *v) {

v->visit(this);

if(oper->left)

lhs->accept(v);

rhs->accept(v);

}

table *tab;

column *col;

int offset;

routine *agg;

atomic_subselect(prod *p, sqltype *type_constraint = 0);

virtual void out(std::ostream &out);

std::string expr;

const_expr(prod *p, sqltype *type_constraint = 0);

virtual void out(std::ostream &out) { out << expr; }

virtual ~const_expr() { }

column_reference(prod *p, sqltype *type_constraint = 0);

virtual void out(std::ostream &out) { out << reference; }

std::string reference;

virtual ~column_reference() { }

const char *abbrev_;

vector<shared_ptr<value_expr> > value_exprs;

virtual ~coalesce() { };

coalesce(prod *p, sqltype *type_constraint = 0, const char *abbrev = "coalesce");

virtual void out(std::ostream &out);

virtual void accept(prod_visitor *v) {

v->visit(this);

for (auto p : value_exprs)

p->accept(v);

}

virtual ~nullif() { };

nullif(prod *p, sqltype *type_constraint = 0)

: coalesce(p, type_constraint, "nullif")

{ };

virtual ~bool_expr() { }

bool_expr(prod *p) : value_expr(p) { type = scope->schema->booltype; }

static shared_ptr<bool_expr> factory(prod *p);

virtual ~truth_value() { }

const char *op;

virtual void out(std::ostream &out) { out << op; }

truth_value(prod *p) : bool_expr(p) {

op = ( (d6() < 4) ? scope->schema->true_literal : scope->schema->false_literal);

}

virtual ~null_predicate() { }

const char *negate;

shared_ptr<value_expr> expr;

null_predicate(prod *p) : bool_expr(p) {

negate = ((d6()<4) ? "not " : "");

expr = value_expr::factory(this, nullptr, false);

}

virtual void out(std::ostream &out) {

out << *expr << " is " << negate << "NULL";

}

virtual void accept(prod_visitor *v) {

v->visit(this);

expr->accept(v);

}

shared_ptr<struct query_spec> subquery;

virtual ~exists_predicate() { }

exists_predicate(prod *p);

virtual void out(std::ostream &out);

virtual void accept(prod_visitor *v);

shared_ptr<value_expr> lhs, rhs;

bool_binop(prod *p) : bool_expr(p) { }

virtual void out(std::ostream &out) = 0;

virtual void accept(prod_visitor *v) {

v->visit(this);

lhs->accept(v);

rhs->accept(v);

}

virtual ~bool_term() { }

const char *op;

virtual void out(std::ostream &out) {

out << "(" << *lhs << ") ";

indent(out);

out << op << " (" << *rhs << ")";

}

bool_term(prod *p) : bool_binop(p)

{

op = ((d6()<4) ? "or" : "and");

lhs = bool_expr::factory(this);

rhs = bool_expr::factory(this);

}

distinct_pred(prod *p);

virtual ~distinct_pred() { };

virtual void out(std::ostream &o) {

o << *lhs << " is distinct from " << *rhs;

}

op *oper;

comparison_op(prod *p);

virtual ~comparison_op() { };

virtual void out(std::ostream &o) {

o << "(" << *lhs << ") " << oper->name << " (" << *rhs << ")";

}

virtual void out(std::ostream &out);

virtual ~window_function() { }

window_function(prod *p, sqltype *type_constraint);

vector<shared_ptr<column_reference> > partition_by;

vector<shared_ptr<column_reference> > order_by;

shared_ptr<funcall> aggregate;

static bool allowed(prod *pprod);

virtual void accept(prod_visitor *v) {

v->visit(this);

aggregate->accept(v);

for (auto p : partition_by)

p->accept(v);

for (auto p : order_by)

p->accept(v);

}