public static bool RewriteQuery(T_Tile toFill, T_Tile toAvoid, out T_Tile rewriting, List <T_Tile> views, RewritingProcessor <T_Tile> qp) { RewritingPass <T_Tile> rewritingPass = new RewritingPass <T_Tile>(toFill, toAvoid, views, qp); if (rewritingPass.RewriteQuery(out rewriting)) { RewritingSimplifier <T_Tile> .TrySimplifyUnionRewriting(ref rewriting, toFill, toAvoid, qp); return(true); } return(false); }
private static bool RewriteQueryInternal(T_Tile toFill, T_Tile toAvoid, out T_Tile rewriting, List <T_Tile> views, HashSet <T_Tile> recentlyUsedViews, RewritingProcessor <T_Tile> qp) { if (qp.REORDER_VIEWS && recentlyUsedViews.Count > 0) { // move recently used views toward the end List <T_Tile> reorderedViews = new List <T_Tile>(); foreach (T_Tile view in views) { if (false == recentlyUsedViews.Contains(view)) { reorderedViews.Add(view); } } reorderedViews.AddRange(recentlyUsedViews); views = reorderedViews; } RewritingPass <T_Tile> rewritingPass = new RewritingPass <T_Tile>(toFill, toAvoid, views, qp); return(rewritingPass.RewriteQuery(out rewriting)); }
public bool RewriteQueryOnce(T_Tile toFill, T_Tile toAvoid, IEnumerable <T_Tile> views, out T_Tile rewriting) { List <T_Tile> viewList = new List <T_Tile>(views); return(RewritingPass <T_Tile> .RewriteQuery(toFill, toAvoid, out rewriting, viewList, this)); }
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); } } bool hasExtraTuples = !m_qp.IsDisjointFrom(rewritingSoFar, m_toAvoid); // try to cut off extra tuples using joins if (hasExtraTuples) { foreach (T_Tile view in AvailableViews) { if (TryJoin(view, ref rewritingSoFar)) { hasExtraTuples = false; break; } } } // try to cut off extra tuples using anti-semijoins if (hasExtraTuples) { foreach (T_Tile 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 T_Tile missingTuples = m_qp.AntiSemiJoin(m_toFill, rewritingSoFar); if (!m_qp.IsEmpty(missingTuples)) { T_Tile rewritingForMissingTuples; if (false == RewritingPass <T_Tile> .RewriteQueryInternal(missingTuples, m_toAvoid, out rewritingForMissingTuples, m_views, new HashSet <T_Tile>(m_usedViews.Keys), 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); }