// are RelExpr's kids cacheable after this phase?
NABoolean RelExpr::cacheableKids(CacheWA& cwa)
{
switch (cwa.getPhase()) {
case CmpMain::PARSE:
case CmpMain::BIND: {
Int32 arity = getArity();
if (arity <= 0) { // we have no kids
if (cwa.isConditionallyCacheable()) {
// we're conditionally cacheable and have no kids
setCacheableNode(cwa.getPhase());
return TRUE; // so, we're cachable
}
else {
return FALSE; // MAYBECACHEABLE is not cacheable at this phase
// don't mark this node non-cacheable because this
// RelExpr may be cacheable after the next phase.
}
}
// cacheability of child(ren) determine our cacheability
for (Int32 x = 0; x < arity; x++) {
if (!child(x) || // cases like "insert into t default values"
// return 1 from getArity() even if child(0) is NULL; so
// guard against this potential mxcmp crash and consider
// these cases non-cacheable during the PARSE stage.
child(x)->isNonCacheable()) {
// the 1st noncacheable child makes us noncacheable
setNonCacheable();
return FALSE;
}
else if (!child(x)->isCacheableExpr(cwa)) {
// noncacheable child
return FALSE;
// don't mark this node non-cacheable because this
// RelExpr may be cacheable after the next phase.
}
else { // cacheable child
continue; // look at next child
}
}
// all children are cacheable, so we're cacheable too
setCacheableNode(cwa.getPhase());
return TRUE;
}
default:
return FALSE;
}
}
// does this entire ItemExpr qualify query to be cacheable after this phase?
NABoolean ItemExpr::isCacheableExpr(CacheWA& cwa)
{
switch (cwa.getPhase()) {
default: { const NABoolean notYetImplemented = FALSE;
CMPASSERT(notYetImplemented);
break;
}
case CmpMain::PARSE:
// ItemExpr::isCacheableExpr is used by Tuple::isCacheable to
// determine whether a tuple-insert or a tuplelist-insert is
// cacheable after parse. It traverses a tuple's values list
// looking for non-cacheable ItemExprs such as HostVar,
// DynamicParam, Subquery, etc.
// determine cacheability of tuple INSERT's itemexprs here
if (isNonCacheable() || !cwa.isConditionallyCacheable()) {
return FALSE;
}
else { // we're either cacheable or maybecacheable
Int32 arity = getArity();
if (arity <= 0) { // we have no kids & we're conditionally cacheable
return TRUE; // we're cacheable
}
// cacheability of child(ren) determine our cacheability
for (Int32 x = 0; x < arity; x++) {
if (!child(x) || child(x)->isNonCacheable()) {
// the 1st noncacheable child makes us noncacheable
setNonCacheable();
return FALSE;
}
else if (!child(x)->isCacheableExpr(cwa)) {
// noncacheable child
return FALSE;
}
else { // cacheable child
continue; // look at next child
}
}
// all children are cacheable, so we're cacheable too
setCacheableNode(cwa.getPhase());
return TRUE;
}
break;
case CmpMain::BIND:
// does query have too many ExprNodes?
if (cwa.inc_N_check_still_cacheable() == FALSE) {
// yes. query with too many ExprNodes is not cacheable.
return FALSE;
}
// ItemExpr::isCacheableExpr is used in "after BIND" cases to
// visit all operands of an ItemExpr looking for noncacheable
// expressions. For example, it discovers that
// SELECT (SELECT a FROM t2 WHERE MAX(o.c)>1) FROM t1 o;
// is noncacheable only after it visits the outer query's select list.
if (isNonCacheable()) {
return FALSE;
}
else if (isCacheableNode(cwa.getPhase())) {
return TRUE;
}
else { // we're either cacheable or maybecacheable
// Assume this ItemExpr is an operand of a function or a list. In
// this case, a single noncacheable child renders us noncacheable.
Int32 arity = getArity();
for (Int32 x = 0; x < arity; x++) {
if (!child(x) || !child(x)->isCacheableExpr(cwa)) {
// noncacheable child
return FALSE;
}
else { // cacheable child
continue; // look at next child
}
}
// all children are cacheable, so we're cacheable too
setCacheableNode(cwa.getPhase());
return TRUE;
}
break;
}
return FALSE;
}
