private bool RewriteQuery(out T_Tile rewriting) { rewriting = this.m_toFill; T_Tile rewriting1; if (!this.FindRewritingByIncludedAndDisjoint(out rewriting1) && !this.FindContributingView(out rewriting1)) { return(false); } bool flag = !this.m_qp.IsDisjointFrom(rewriting1, this.m_toAvoid); if (flag) { foreach (T_Tile availableView in this.AvailableViews) { if (this.TryJoin(availableView, ref rewriting1)) { flag = false; break; } } } if (flag) { foreach (T_Tile availableView in this.AvailableViews) { if (this.TryAntiSemiJoin(availableView, ref rewriting1)) { flag = false; break; } } } if (flag) { return(false); } RewritingSimplifier <T_Tile> .TrySimplifyJoinRewriting(ref rewriting1, this.m_toAvoid, this.m_usedViews, this.m_qp); T_Tile tile = this.m_qp.AntiSemiJoin(this.m_toFill, rewriting1); if (!this.m_qp.IsEmpty(tile)) { T_Tile rewriting2; if (!RewritingPass <T_Tile> .RewriteQueryInternal(tile, this.m_toAvoid, out rewriting2, this.m_views, this.m_qp)) { rewriting = rewriting2; return(false); } rewriting1 = !this.m_qp.IsContainedIn(rewriting1, rewriting2) ? this.m_qp.Union(rewriting1, rewriting2) : rewriting2; } rewriting = rewriting1; return(true); }
private bool RewriteQuery(out T_Tile rewriting) { rewriting = m_toFill; T_Tile rewritingSoFar; if (false == FindRewritingByIncludedAndDisjoint(out rewritingSoFar)) { if (false == FindContributingView(out rewritingSoFar)) { return(false); } } var hasExtraTuples = !m_qp.IsDisjointFrom(rewritingSoFar, m_toAvoid); // try to cut off extra tuples using joins if (hasExtraTuples) { foreach (var view in AvailableViews) { if (TryJoin(view, ref rewritingSoFar)) { hasExtraTuples = false; break; } } } // try to cut off extra tuples using anti-semijoins if (hasExtraTuples) { foreach (var view in AvailableViews) { if (TryAntiSemiJoin(view, ref rewritingSoFar)) { hasExtraTuples = false; break; } } } if (hasExtraTuples) { return(false); // won't be able to cut off extra tuples } // remove redundant joins and anti-semijoins RewritingSimplifier <T_Tile> .TrySimplifyJoinRewriting(ref rewritingSoFar, m_toAvoid, m_usedViews, m_qp); // find rewriting for missing tuples, if any var missingTuples = m_qp.AntiSemiJoin(m_toFill, rewritingSoFar); if (!m_qp.IsEmpty(missingTuples)) { T_Tile rewritingForMissingTuples; if (false == RewriteQueryInternal( missingTuples, m_toAvoid, out rewritingForMissingTuples, m_views, m_qp)) { rewriting = rewritingForMissingTuples; return(false); // failure } else { // Although a more general optimization for UNIONs will handle this case, // adding this check reduces the overall number of containment tests if (m_qp.IsContainedIn(rewritingSoFar, rewritingForMissingTuples)) { rewritingSoFar = rewritingForMissingTuples; } else { rewritingSoFar = m_qp.Union(rewritingSoFar, rewritingForMissingTuples); } } } // if we reached this point, we have a successful rewriting rewriting = rewritingSoFar; return(true); }