/*******************************************************************************
For simple flwor only.
********************************************************************************/
orderby_clause* flwor_expr::get_order_clause() const
{
csize numClauses = num_clauses();
for (csize i = 0; i < numClauses; ++i)
{
if (theClauses[i]->get_kind() == flwor_clause::orderby_clause)
return reinterpret_cast<orderby_clause*>(theClauses[i]);
}
return NULL;
}
/*******************************************************************************
For simple flwor only.
********************************************************************************/
groupby_clause* flwor_expr::get_group_clause() const
{
csize numClauses = num_clauses();
for (csize i = 0; i < numClauses; ++i)
{
if (theClauses[i]->get_kind() == flwor_clause::groupby_clause)
return static_cast<groupby_clause*>(theClauses[i]);
}
return NULL;
}
void flwor_expr::compute_scripting_kind()
{
csize numClauses = num_clauses();
for (csize i = 0; i < numClauses; ++i)
{
const flwor_clause* c = theClauses[i];
flwor_clause::ClauseKind k = c->get_kind();
if (k == flwor_clause::for_clause ||
k == flwor_clause::let_clause ||
k == flwor_clause::window_clause)
{
const forletwin_clause* c2 = static_cast<const forletwin_clause*>(c);
theScriptingKind |= c2->get_expr()->get_scripting_detail();
if (c2->get_expr()->is_sequential())
set_sequential_clauses(true);
}
}
const expr* ret = get_return_expr();
if (ret)
theScriptingKind |= ret->get_scripting_detail();
if (is_sequential(theScriptingKind))
{
theScriptingKind &= ~SIMPLE_EXPR;
theScriptingKind &= ~VACUOUS_EXPR;
}
if (theScriptingKind & UPDATING_EXPR)
{
theScriptingKind &= ~SIMPLE_EXPR;
theScriptingKind &= ~VACUOUS_EXPR;
}
if (theScriptingKind & VACUOUS_EXPR)
{
if (ret && ret->is_vacuous())
theScriptingKind &= ~SIMPLE_EXPR;
else
theScriptingKind &= ~VACUOUS_EXPR;
}
checkScriptingKind();
}
bool flwor_expr::is_single_for(csize& pos) const
{
csize numClauses = num_clauses();
csize numFors = 0;
bool discardable = true;
for (csize i = 0; i < numClauses; ++i)
{
flwor_clause* c = theClauses[i];
switch (c->get_kind())
{
case flwor_clause::for_clause:
{
if (numFors > 0)
return false;
++numFors;
pos = i;
break;
}
case flwor_clause::let_clause:
{
let_clause* lc = static_cast<let_clause*>(c);
if (lc->get_expr()->isNonDiscardable())
{
if (numFors > 0)
return false;
discardable = false;
break;
}
}
default:
return false;
}
}
if (numFors == 1 && discardable)
return true;
return false;
}
void DataAndStatistics::printShort() {
if (exit_state_ == TIMEOUT) {
cout << endl << " TIMEOUT !" << endl;
return;
}
cout << endl << endl;
cout << "variables (total / active / free)\t" << num_variables_ << "/"
<< num_used_variables_ << "/" << num_variables_ - num_used_variables_
<< endl;
cout << "clauses (removed) \t\t\t" << num_original_clauses_ << " ("
<< num_original_clauses_ - num_clauses() << ")" << endl;
cout << "decisions \t\t\t\t" << num_decisions_ << endl;
cout << "conflicts \t\t\t\t" << num_conflicts_ << endl;
cout << "conflict clauses (all/bin/unit) \t";
cout << num_conflict_clauses();
cout << "/" << num_binary_conflict_clauses_ << "/" << num_unit_clauses_
<< endl << endl;
cout << "failed literals found by implicit BCP \t " <<
num_failed_literals_detected_ << endl;;
cout << "implicit BCP miss rate \t " << implicitBCP_miss_rate()*100 << "%";
cout << endl;
cout << "cache size " << cache_bytes_memory_usage_ / 1000 / 1000 << "MB\t"
<< endl;
cout << "cache (stores / hits) \t\t\t" << num_cached_components_ << "/"
<< num_cache_hits_ << endl;
cout << "cache miss rate " << cache_miss_rate() * 100 << "%" << endl;
cout << " avg. variable count (stores / hits) \t" << getAvgComponentSize()
<< "/" << getAvgCacheHitSize() << endl << endl;
cout << "\n# solutions " << endl;
print_final_solution_count();
cout << "\n# END" << endl << endl;
cout << "time: " << time_elapsed_ << "s\n\n";
}
/*****************************************************************************
Returns a set containing all the variables defined by the clauses of this
flwor expr.
******************************************************************************/
void flwor_expr::get_vars(std::vector<var_expr*>& vars) const
{
csize numClauses = num_clauses();
for (csize i = 0; i < numClauses; ++i)
{
const flwor_clause& c = *get_clause(i);
switch (c.get_kind())
{
case flwor_clause::for_clause:
{
const for_clause* fc = static_cast<const for_clause *>(&c);
vars.push_back(fc->get_var());
if (fc->get_pos_var() != NULL)
vars.push_back(fc->get_pos_var());
break;
}
case flwor_clause::let_clause:
{
const let_clause* lc = static_cast<const let_clause *>(&c);
vars.push_back(lc->get_var());
break;
}
case flwor_clause::window_clause:
{
const window_clause* wc = static_cast<const window_clause *>(&c);
vars.push_back(wc->get_var());
if (wc->get_win_start() != NULL)
{
const flwor_wincond* cond = wc->get_win_start();
const flwor_wincond::vars& condvars = cond->get_out_vars();
if (condvars.posvar != NULL) vars.push_back(condvars.posvar);
if (condvars.curr != NULL) vars.push_back(condvars.curr);
if (condvars.prev != NULL) vars.push_back(condvars.prev);
if (condvars.next != NULL) vars.push_back(condvars.next);
}
if (wc->get_win_stop() != NULL)
{
const flwor_wincond* cond = wc->get_win_stop();
const flwor_wincond::vars& condvars = cond->get_out_vars();
if (condvars.posvar != NULL) vars.push_back(condvars.posvar);
if (condvars.curr != NULL) vars.push_back(condvars.curr);
if (condvars.prev != NULL) vars.push_back(condvars.prev);
if (condvars.next != NULL) vars.push_back(condvars.next);
}
break;
}
case flwor_clause::groupby_clause:
{
const groupby_clause* gc = static_cast<const groupby_clause *>(&c);
flwor_clause::rebind_list_t::const_iterator ite = gc->beginGroupVars();
flwor_clause::rebind_list_t::const_iterator end = gc->endGroupVars();
for (; ite != end; ++ite)
{
vars.push_back((*ite).second);
}
ite = gc->beginNonGroupVars();
end = gc->endNonGroupVars();
for (; ite != end; ++ite)
{
vars.push_back((*ite).second);
}
break;
}
case flwor_clause::count_clause:
{
const count_clause* cc = static_cast<const count_clause *>(&c);
vars.push_back(cc->get_var());
break;
}
default:
break;
}
}
}
bool flwor_expr::compute_is_general()
{
bool has_where = false;
bool has_order = false;
bool has_group = false;
csize numClauses = num_clauses();
for (csize i = 0; i < numClauses; ++i)
{
const flwor_clause* c = get_clause(i);
switch (c->get_kind())
{
case flwor_clause::for_clause:
case flwor_clause::let_clause:
{
if (has_group || has_where || has_order)
return true;
const forlet_clause* flc = static_cast<const forlet_clause*>(c);
if (flc->is_allowing_empty())
return true;
break;
}
case flwor_clause::window_clause:
{
return true;
}
case flwor_clause::where_clause:
{
if (has_where || has_group || has_order)
return true;
has_where = true;
break;
}
case flwor_clause::orderby_clause:
{
if (has_order)
return true;
has_order = true;
break;
}
case flwor_clause::groupby_clause:
{
if (has_group || has_order)
return true;
has_group = true;
break;
}
case flwor_clause::count_clause:
{
return true;
}
case flwor_clause::materialize_clause:
{
break;
}
default:
{
ZORBA_ASSERT(false);
}
}
}
return false;
}
