// is this entire expression cacheable after this phase? NABoolean RelExpr::isCacheableExpr(CacheWA& cwa) { switch (cwa.getPhase()) { case CmpMain::PARSE: 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; } if (isNonCacheable()) { // this node is not cacheable return FALSE; // so the entire expression is not cacheable // don't mark this node non-cacheable because this // RelExpr may be cacheable after the next phase. } if (isCacheableNode(cwa.getPhase())) { // must be an INSERT, UPDATE, DELETE, or SELECT node; // so, mark this expression as conditionally cacheable. cwa.setConditionallyCacheable(); } // must descend to scans to get cwa.numberOfScans_ if (!cacheableKids(cwa)) { return FALSE; } // this node is either cacheable or maybecacheable // check its selection predicate ItemExpr *pred = selPredTree() ? selPredTree() : getSelectionPred().rebuildExprTree(); if (pred) { cwa.setHasPredicate(); // is selection predicate cacheable? if (pred->hasNoLiterals(cwa)) { // predicate with no literals is cacheable } else { cwa.setPredHasNoLit(FALSE); if (!pred->isCacheableExpr(cwa)) { // a non-cacheable selection predicate // renders entire RelExpr non-cacheable. setNonCacheable(); return FALSE; } } } return TRUE; // RelExpr may be cacheable } default: { const NABoolean notYetImplemented = FALSE; CMPASSERT(notYetImplemented); return FALSE; } } }
// return true if ItemExpr & its descendants have no constants & noncacheables NABoolean ItemExpr::hasNoLiterals(CacheWA& cwa) { if (isNonCacheable()) { return FALSE; } OperatorTypeEnum opTyp = getOperatorType(); switch (opTyp) { case ITM_CONSTANT: case ITM_HOSTVAR: case ITM_DYN_PARAM: case ITM_CACHE_PARAM: return FALSE; default: // fall thru break; } NABoolean result = TRUE; Int32 arity = getArity(); for (Int32 x = 0; x < arity && result; x++) { if (child(x)) { result = child(x)->hasNoLiterals(cwa); } } return result; }
// 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; }