public TileBinaryOperator(Tile <T_Query> arg1, Tile <T_Query> arg2, TileOpKind opKind, T_Query query)
: base(opKind, query)
{
Debug.Assert(arg1 != null && arg2 != null);
m_arg1 = arg1;
m_arg2 = arg2;
}
public TileBinaryOperator(Tile <T_Query> arg1, Tile <T_Query> arg2, TileOpKind opKind, T_Query query)
: base(opKind, query)
{
DebugCheck.NotNull(arg1);
DebugCheck.NotNull(arg2);
m_arg1 = arg1;
m_arg2 = arg2;
}
public TileBinaryOperator(
Tile <T_Query> arg1,
Tile <T_Query> arg2,
TileOpKind opKind,
T_Query query)
: base(opKind, query)
{
this.m_arg1 = arg1;
this.m_arg2 = arg2;
}
private bool SimplifyRewritingOnce(
T_Tile newRewriting,
HashSet <T_Tile> remainingViews,
out T_Tile simplifiedRewriting)
{
simplifiedRewriting = default(T_Tile);
if (remainingViews.Count == 0)
{
return(false);
}
if (remainingViews.Count == 1)
{
T_Tile key = remainingViews.First <T_Tile>();
if (!(this.m_usedViews[key] != TileOpKind.Union ? this.m_qp.IsContainedIn(this.m_originalRewriting, newRewriting) && this.m_qp.IsDisjointFrom(this.m_toAvoid, newRewriting) : this.m_qp.IsContainedIn(this.m_originalRewriting, newRewriting)))
{
return(false);
}
simplifiedRewriting = newRewriting;
this.m_usedViews.Remove(key);
return(true);
}
int num1 = remainingViews.Count / 2;
int num2 = 0;
T_Tile tile1 = newRewriting;
T_Tile tile2 = newRewriting;
HashSet <T_Tile> remainingViews1 = new HashSet <T_Tile>();
HashSet <T_Tile> remainingViews2 = new HashSet <T_Tile>();
foreach (T_Tile remainingView in remainingViews)
{
TileOpKind usedView = this.m_usedViews[remainingView];
if (num2++ < num1)
{
remainingViews1.Add(remainingView);
tile1 = this.GetRewritingHalf(tile1, remainingView, usedView);
}
else
{
remainingViews2.Add(remainingView);
tile2 = this.GetRewritingHalf(tile2, remainingView, usedView);
}
}
if (!this.SimplifyRewritingOnce(tile1, remainingViews2, out simplifiedRewriting))
{
return(this.SimplifyRewritingOnce(tile2, remainingViews1, out simplifiedRewriting));
}
return(true);
}
private T_Tile GetRewritingHalf(T_Tile halfRewriting, T_Tile remainingView, TileOpKind viewKind)
{
switch (viewKind)
{
case TileOpKind.Join:
halfRewriting = m_qp.Join(halfRewriting, remainingView); break;
case TileOpKind.AntiSemiJoin:
halfRewriting = m_qp.AntiSemiJoin(halfRewriting, remainingView); break;
case TileOpKind.Union:
halfRewriting = m_qp.Union(halfRewriting, remainingView); break;
default: Debug.Fail("unexpected"); break;
}
return(halfRewriting);
}
private T_Tile GetRewritingHalf(
T_Tile halfRewriting,
T_Tile remainingView,
TileOpKind viewKind)
{
switch (viewKind)
{
case TileOpKind.Union:
halfRewriting = this.m_qp.Union(halfRewriting, remainingView);
break;
case TileOpKind.Join:
halfRewriting = this.m_qp.Join(halfRewriting, remainingView);
break;
case TileOpKind.AntiSemiJoin:
halfRewriting = this.m_qp.AntiSemiJoin(halfRewriting, remainingView);
break;
}
return(halfRewriting);
}
// remainingViews may contain either unions only or intersections + differences
private bool SimplifyRewritingOnce(T_Tile newRewriting, HashSet <T_Tile> remainingViews,
out T_Tile simplifiedRewriting)
{
simplifiedRewriting = null;
if (remainingViews.Count == 0)
{
return(false);
}
if (remainingViews.Count == 1)
{
// determine the remaining view
T_Tile remainingView = remainingViews.First();
// check whether rewriting obtained so far is good enough
// try disposing of this remaining view
bool isDisposable = false;
switch (m_usedViews[remainingView])
{
case TileOpKind.Union:
// check whether rewriting still covers toFill
isDisposable = m_qp.IsContainedIn(m_originalRewriting, newRewriting);
break;
default: // intersection
isDisposable = m_qp.IsContainedIn(m_originalRewriting, newRewriting) &&
m_qp.IsDisjointFrom(m_toAvoid, newRewriting);
break;
}
if (isDisposable)
{
// yes, the remaining view is disposable
simplifiedRewriting = newRewriting;
m_usedViews.Remove(remainingView);
return(true);
}
return(false); // no, can't trash the remaining view
}
// split remainingViews into two halves
// Compute rewriting for first half. Call recursively on second half.
// Then, compute rewriting for second half. Call recursively on first half.
int halfCount = remainingViews.Count / 2;
int count = 0;
T_Tile firstHalfRewriting = newRewriting;
T_Tile secondHalfRewriting = newRewriting;
HashSet <T_Tile> firstHalf = new HashSet <T_Tile>();
HashSet <T_Tile> secondHalf = new HashSet <T_Tile>();
foreach (T_Tile remainingView in remainingViews)
{
TileOpKind viewKind = m_usedViews[remainingView];
// add to first half
if (count++ < halfCount)
{
firstHalf.Add(remainingView);
firstHalfRewriting = GetRewritingHalf(firstHalfRewriting, remainingView, viewKind);
}
else // add to second half
{
secondHalf.Add(remainingView);
secondHalfRewriting = GetRewritingHalf(secondHalfRewriting, remainingView, viewKind);
}
}
// now, call recursively
return(SimplifyRewritingOnce(firstHalfRewriting, secondHalf, out simplifiedRewriting) ||
SimplifyRewritingOnce(secondHalfRewriting, firstHalf, out simplifiedRewriting));
}
protected Tile(TileOpKind opKind, T_Query query)
{
m_opKind = opKind;
m_query = query;
}
protected Tile(TileOpKind opKind, T_Query query)
{
this.m_opKind = opKind;
this.m_query = query;
}
