public List <WBooleanExpression> Invoke(WBooleanExpression expr)
{
this.normalizedList = new List <WBooleanExpression>();
expr.Accept(this);
return(this.normalizedList);
}
internal static WBooleanParenthesisExpression GetBooleanParenthesisExpr(WBooleanExpression booleanExpr)
{
return(new WBooleanParenthesisExpression()
{
Expression = booleanExpr
});
}
public string Invoke(WBooleanExpression node, Dictionary <string, string> columnToTable)
{
_tableBind = false;
_columnToTable = columnToTable;
node.Accept(this);
return(_tableName);
}
public void Invoke(WBooleanExpression booleanExpression)
{
if (booleanExpression != null)
{
booleanExpression.Accept(this);
}
}
internal static WWhereClause GetWhereClause(WBooleanExpression predicate)
{
return(new WWhereClause()
{
SearchCondition = predicate
});
}
private void Attach(WBooleanExpression expr)
{
var table = _booleanTabRefVisitor.Invoke(expr);
// Only expression who reference one table can be attached
var tableName = table.Count == 1 ? table.First().Key : "";
MatchEdge edge;
MatchNode node;
if (_graph.TryGetEdge(tableName, out edge))
{
if (edge.Predicates == null)
{
edge.Predicates = new List <WBooleanExpression>();
}
edge.Predicates.Add(expr);
}
else if (_graph.TryGetNode(tableName, out node))
{
if (node.Predicates == null)
{
node.Predicates = new List <WBooleanExpression>();
}
node.Predicates.Add(expr);
}
else
{
FailedToAssign.Add(expr);
}
}
// <table name, properties referenced>
public Dictionary <string, HashSet <string> > Invoke(WBooleanExpression expr)
{
_tableandPropertiesDict = new Dictionary <string, HashSet <string> >();
expr.Accept(this);
return(_tableandPropertiesDict);
}
internal static WBooleanExpression ConcatBooleanExpressionList(List <WBooleanExpression> booleanExprList,
BooleanBinaryExpressionType type)
{
if (booleanExprList.Count == 1)
{
return(booleanExprList.First());
}
WBooleanExpression concatExpr = null;
foreach (var booleanExpr in booleanExprList)
{
if (booleanExpr == null)
{
continue;
}
WBooleanExpression newExpr = type == BooleanBinaryExpressionType.Or
? GetBooleanParenthesisExpr(booleanExpr)
: booleanExpr;
concatExpr = concatExpr == null ? booleanExpr
: GetBooleanBinaryExpr(concatExpr, newExpr, type);
}
if (concatExpr == null)
{
return(null);
}
if (type == BooleanBinaryExpressionType.Or)
{
return(GetBooleanParenthesisExpr(concatExpr));
}
return(concatExpr);
}
/// <summary>
/// Converts edge attribute predicates into a boolean expression, which is used for
/// constructing queries for retrieving edge statistics
/// </summary>
/// <returns></returns>
public override WBooleanExpression RetrievePredicatesExpression()
{
if (AttributeValueDict != null)
{
WBooleanExpression res = null;
foreach (var tuple in AttributeValueDict)
{
res = WBooleanBinaryExpression.Conjunction(res, new WBooleanComparisonExpression
{
ComparisonType = BooleanComparisonType.Equals,
FirstExpr =
new WColumnReferenceExpression
{
MultiPartIdentifier =
new WMultiPartIdentifier(new Identifier {
Value = LinkAlias
},
new Identifier {
Value = tuple.Key
})
},
SecondExpr = new WValueExpression {
Value = tuple.Value
}
});
}
return(res);
}
return(null);
}
internal void AddPredicate(WBooleanExpression newPredicate)
{
if (newPredicate == null)
{
return;
}
Predicates = Predicates == null ? newPredicate : SqlUtil.GetAndBooleanBinaryExpr(Predicates, newPredicate);
}
public Dictionary <string, string> Invoke(WBooleanExpression booleanExpression)
{
if (booleanExpression != null)
{
booleanExpression.Accept(this);
}
return(this.referencedProperties);
}
internal static WBooleanBinaryExpression GetBooleanBinaryExpr(WBooleanExpression firstExpr,
WBooleanExpression secondExpr, BooleanBinaryExpressionType type)
{
return(new WBooleanBinaryExpression()
{
BooleanExpressionType = type,
FirstExpr = firstExpr,
SecondExpr = secondExpr
});
}
public int Invoke(
WBooleanExpression booleanExpression)
{
runtimeFunctionCount = 0;
if (booleanExpression != null)
{
booleanExpression.Accept(this);
}
return(runtimeFunctionCount);
}
/// <summary>
/// Converts edge attribute predicates into a boolean expression, which is used for
/// constructing queries for retrieving edge statistics
/// </summary>
/// <returns></returns>
public virtual WBooleanExpression RetrievePredicatesExpression()
{
if (Predicates != null)
{
WBooleanExpression res = null;
foreach (var expression in Predicates)
{
res = WBooleanBinaryExpression.Conjunction(res, expression);
}
return(res);
}
return(null);
}
internal void HasLabel(GremlinVariable lastVariable, List <object> values)
{
List <WBooleanExpression> booleanExprList = new List <WBooleanExpression>();
foreach (var value in values)
{
WScalarExpression firstExpr = lastVariable.GetVariableProperty(GremlinKeyword.Label).ToScalarExpression();
WScalarExpression secondExpr = SqlUtil.GetValueExpr(value);
booleanExprList.Add(SqlUtil.GetEqualBooleanComparisonExpr(firstExpr, secondExpr));
}
WBooleanExpression concatSql = SqlUtil.ConcatBooleanExprWithOr(booleanExprList);
AddPredicate(SqlUtil.GetBooleanParenthesisExpr(concatSql));
}
private void Attach(WBooleanExpression expr)
{
var table = _bindTableVisitor.Invoke(expr, _columnTableMapping);
MatchEdge edge, revEdge;
MatchNode node;
if (_graph.TryGetEdge(table, out edge))
{
if (edge.Predicates == null)
{
edge.Predicates = new List <WBooleanExpression>();
}
edge.Predicates.Add(expr);
if (_graph.ReversedEdgeDict.TryGetValue(edge.EdgeAlias, out revEdge))
{
if (revEdge.Predicates == null)
{
revEdge.Predicates = new List <WBooleanExpression>();
}
// take care when an edge is using a default alias
var revExpr = ObjectExtensions.Copy(expr);
var compExpr = revExpr as WBooleanComparisonExpression;
if (compExpr != null)
{
var columnExpr = compExpr.FirstExpr as WColumnReferenceExpression ?? compExpr.SecondExpr as WColumnReferenceExpression;
if (columnExpr != null)
{
var column = columnExpr.MultiPartIdentifier.Identifiers;
if (column.Count >= 2)
{
column[column.Count - 2].Value = revEdge.EdgeAlias;
}
}
}
revEdge.Predicates.Add(revExpr);
}
}
else if (_graph.TryGetNode(table, out node))
{
if (node.Predicates == null)
{
node.Predicates = new List <WBooleanExpression>();
}
node.Predicates.Add(expr);
}
}
public void UpdateWherClause(WWhereClause whereClause, WBooleanExpression node)
{
if (whereClause.SearchCondition == null)
{
whereClause.SearchCondition = node;
}
else
{
whereClause.SearchCondition = new WBooleanBinaryExpression
{
FirstExpr = whereClause.SearchCondition,
SecondExpr = node,
BooleanExpressionType = BooleanBinaryExpressionType.And
};
}
}
/// <summary>
/// Conjuncts two boolean expressions
/// </summary>
/// <param name="joinCondition">The first boolean expression</param>
/// <param name="newCondition">The second boolean expression</param>
/// <returns>The conjunctive boolean expression</returns>
public static WBooleanExpression Conjunction(WBooleanExpression joinCondition, WBooleanExpression newCondition)
{
if (joinCondition == null)
{
return(newCondition);
}
if (newCondition == null)
{
return(joinCondition);
}
return(new WBooleanBinaryExpression
{
FirstExpr = joinCondition,
SecondExpr = newCondition,
BooleanExpressionType = BooleanBinaryExpressionType.And
});
}
public bool TryAttachPredicate(WBooleanExpression predicate, Dictionary <string, HashSet <string> > tableColumnReferences)
{
// Attach fail if it is a cross-table predicate
if (tableColumnReferences.Count > 1)
{
return(false);
}
MatchEdge edge;
MatchNode node;
bool attachFlag = false;
foreach (var tableColumnReference in tableColumnReferences)
{
var tableName = tableColumnReference.Key;
var properties = tableColumnReference.Value;
if (TryGetEdge(tableName, out edge))
{
if (edge.Predicates == null)
{
edge.Predicates = new List <WBooleanExpression>();
}
edge.Predicates.Add(predicate);
// Attach edge's propeties for later runtime evaluation
AttachProperties(new Dictionary <string, HashSet <string> > {
{ tableName, properties }
});
attachFlag = true;
}
else if (TryGetNode(tableName, out node))
{
if (node.Predicates == null)
{
node.Predicates = new List <WBooleanExpression>();
}
node.Predicates.Add(predicate);
AttachProperties(new Dictionary <string, HashSet <string> > {
{ tableName, properties }
});
attachFlag = true;
}
}
return(attachFlag);
}
/// <summary>
/// Calculate the number used for adjusting the SQL Server estimation in the downsize function.
/// </summary>
/// <param name="component"></param>
/// <param name="joinCondition"></param>
private static WTableReference AdjustEstimation(MatchComponent component, out WBooleanExpression joinCondition, out double affectedSqlEstimatedSize)
{
const int sizeFactor = 10;
int estimateFactor = 0;
double size = component.Cardinality;
double estimatedSize = component.SqlEstimatedSize;
double shrinkSize = component.RightestTableRefSize;
WTableReference tableReference = component.TableRef;
affectedSqlEstimatedSize = 1.0;
joinCondition = null;
if (size > sizeFactor * estimatedSize)
{
estimateFactor = (int)Math.Ceiling(size / estimatedSize);
}
else if (sizeFactor * size < estimatedSize)
{
shrinkSize = 1.0 / (1 - Math.Pow((1 - 1.0 / shrinkSize), 1.5));
if (estimatedSize < shrinkSize)
{
affectedSqlEstimatedSize /= estimatedSize;
estimatedSize = 1;
}
else
{
affectedSqlEstimatedSize /= shrinkSize;
estimatedSize /= shrinkSize;
}
estimateFactor = (int)Math.Ceiling(size / estimatedSize);
joinCondition = ConstructDownSizeJoinCondition(component.RightestTableAlias);
}
if (estimateFactor > 1)
{
double affectedUpSize;
tableReference = ConstructUpSizeTableReference(tableReference, estimateFactor,
out affectedUpSize);
affectedSqlEstimatedSize *= affectedUpSize;
}
return(tableReference);
}
private void Attach(WBooleanExpression expr)
{
var table = _bindTableVisitor.Invoke(expr, _columnTableMapping);
MatchEdge edge;
MatchNode node;
if (_graph.TryGetEdge(table, out edge))
{
if (edge.Predicates == null)
{
edge.Predicates = new List <WBooleanExpression>();
}
edge.Predicates.Add(expr);
}
else if (_graph.TryGetNode(table, out node))
{
if (node.Predicates == null)
{
node.Predicates = new List <WBooleanExpression>();
}
node.Predicates.Add(expr);
}
}
public PredicateLink(WBooleanExpression booleanExpression)
{
this.BooleanExpression = booleanExpression;
this.LinkAlias = booleanExpression.ToString();
}
public virtual void Visit(WBooleanExpression node)
{
node.AcceptChildren(this);
}
public void Invoke(WBooleanExpression booleanExpression)
{
booleanExpression?.Accept(this);
}
internal virtual void Not(GremlinToSqlContext currentContext, GremlinToSqlContext notContext)
{
WBooleanExpression booleanExpr = SqlUtil.GetNotExistPredicate(notContext.ToSelectQueryBlock());
currentContext.AddPredicate(booleanExpr);
}
internal virtual void Where(GremlinToSqlContext currentContext, GremlinToSqlContext whereContext)
{
WBooleanExpression wherePredicate = whereContext.ToSqlBoolean();
currentContext.AddPredicate(wherePredicate);
}
/// <summary>
/// Transit from current component to the new component in the next state given the Node Unit
/// </summary>
/// <param name="candidateTree"></param>
/// <param name="densityDict"></param>
/// <param name="subGraph"></param>
/// <param name="statisticsCalculator"></param>
/// <returns></returns>
public MatchComponent GetNextState(
OneHeightTree candidateTree,
Dictionary <string, double> densityDict,
IMatchJoinStatisticsCalculator statisticsCalculator)
{
var newComponent = new MatchComponent(this);
var root = candidateTree.TreeRoot;
WBooleanExpression joinCondition = null;
string nodeName = "";
// Update Nodes
if (newComponent.MaterializedNodeSplitCount.ContainsKey(root))
{
newComponent.MaterializedNodeSplitCount[root]++;
nodeName = newComponent.GetNodeRefName(root);
joinCondition = new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = root.RefAlias
},
new Identifier {
Value = "GlobalNodeId"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = nodeName
},
new Identifier {
Value = "GlobalNodeId"
}
),
},
ComparisonType = BooleanComparisonType.Equals
};
}
else
{
nodeName = root.RefAlias;
newComponent.Nodes.Add(root);
newComponent.MaterializedNodeSplitCount[root] = 0;
newComponent.StatisticsDict[root] = new ColumnStatistics {
Selectivity = 1.0 / root.TableRowCount
};
}
// Constructs table reference
WTableReference nodeTable = new WNamedTableReference
{
Alias = new Identifier {
Value = nodeName
},
TableObjectName = root.TableObjectName
};
WTableReference compTable = newComponent.TableRef;
// Updates join conditions
double selectivity = 1.0;
double degrees = 1.0;
var DensityCount = new Dictionary <string, int>(StringComparer.CurrentCultureIgnoreCase);
List <MatchEdge> inEdges;
if (newComponent.UnmaterializedNodeMapping.TryGetValue(root, out inEdges))
{
var firstEdge = inEdges.First();
bool materialized = newComponent.EdgeMaterilizedDict[firstEdge];
newComponent.UnmaterializedNodeMapping.Remove(root);
selectivity *= 1.0 / root.TableRowCount;
// Component materialized edge to root
if (materialized)
{
joinCondition = WBooleanBinaryExpression.Conjunction(joinCondition, new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = firstEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = nodeName
},
new Identifier {
Value = "GlobalNodeId"
}
)
},
ComparisonType = BooleanComparisonType.Equals
});
//var statistics = ColumnStatistics.UpdateHistogram(newComponent.StatisticsDict[root],
// new ColumnStatistics {Selectivity = 1.0/root.TableRowCount});
//selectivity *= statistics.Selectivity;
//newComponent.StatisticsDict[root] = statistics;
if (DensityCount.ContainsKey(root.TableObjectName.ToString()))
{
DensityCount[root.TableObjectName.ToString()]++;
}
else
{
DensityCount[root.TableObjectName.ToString()] = 1;
}
}
// Component unmaterialized edge to root
else
{
ColumnStatistics statistics = null;
foreach (var edge in inEdges)
{
// Update component table
compTable = SpanTableRef(compTable, edge, newComponent.GetNodeRefName(edge.SourceNode));
newComponent.EdgeMaterilizedDict[edge] = true;
joinCondition = WBooleanBinaryExpression.Conjunction(joinCondition,
new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = edge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = nodeName
},
new Identifier {
Value = "GlobalNodeId"
}
)
},
ComparisonType = BooleanComparisonType.Equals
});
statistics = ColumnStatistics.UpdateHistogram(statistics,
newComponent.Context.GetEdgeStatistics(edge));
selectivity *= statistics.Selectivity;
}
newComponent.StatisticsDict[root] = statistics;
if (DensityCount.ContainsKey(root.TableObjectName.ToString()))
{
DensityCount[root.TableObjectName.ToString()] += inEdges.Count;
}
else
{
DensityCount[root.TableObjectName.ToString()] = inEdges.Count;
}
}
}
var jointEdges = candidateTree.MaterializedEdges;
int sinkToSinkCount = 0;
foreach (var jointEdge in jointEdges)
{
// Update node table
nodeTable = SpanTableRef(nodeTable, jointEdge, nodeName);
degrees *= jointEdge.AverageDegree;
newComponent.EdgeMaterilizedDict[jointEdge] = true;
var sinkNode = jointEdge.SinkNode;
// Leaf to component materialized node
if (newComponent.MaterializedNodeSplitCount.ContainsKey(sinkNode))
{
joinCondition = WBooleanBinaryExpression.Conjunction(joinCondition,
new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = jointEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = sinkNode.RefAlias
},
new Identifier {
Value = "GlobalNodeId"
}
)
},
ComparisonType = BooleanComparisonType.Equals
});
var statistics = ColumnStatistics.UpdateHistogram(newComponent.StatisticsDict[sinkNode],
newComponent.Context.GetEdgeStatistics(jointEdge));
selectivity *= statistics.Selectivity;
newComponent.StatisticsDict[sinkNode] = statistics;
if (DensityCount.ContainsKey(sinkNode.TableObjectName.ToString()))
{
DensityCount[sinkNode.TableObjectName.ToString()]++;
}
else
{
DensityCount[sinkNode.TableObjectName.ToString()] = 1;
}
}
// Leaf to component unmaterialized node
else
{
inEdges = newComponent.UnmaterializedNodeMapping[sinkNode];
var firstEdge = inEdges.First();
bool materlizedEdge = newComponent.EdgeMaterilizedDict[firstEdge];
// Leaf to materialized leaf
if (materlizedEdge)
{
joinCondition = WBooleanBinaryExpression.Conjunction(joinCondition,
new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = jointEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = firstEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
)
},
ComparisonType = BooleanComparisonType.Equals
});
sinkToSinkCount++;
var statistics = ColumnStatistics.UpdateHistogram(newComponent.StatisticsDict[sinkNode],
newComponent.Context.GetEdgeStatistics(jointEdge));
selectivity *= statistics.Selectivity;
newComponent.StatisticsDict[sinkNode] = statistics;
}
// Leaf to unmaterialized leaf
else
{
ColumnStatistics compSinkNodeStatistics = null;
foreach (var inEdge in inEdges)
{
compTable = SpanTableRef(compTable, inEdge, newComponent.GetNodeRefName(inEdge.SourceNode));
newComponent.EdgeMaterilizedDict[inEdge] = true;
joinCondition = WBooleanBinaryExpression.Conjunction(joinCondition,
new WBooleanComparisonExpression
{
FirstExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = jointEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
),
},
SecondExpr = new WColumnReferenceExpression
{
ColumnType = ColumnType.Regular,
MultiPartIdentifier = new WMultiPartIdentifier(
new Identifier {
Value = inEdge.EdgeAlias
},
new Identifier {
Value = "Sink"
}
)
},
ComparisonType = BooleanComparisonType.Equals
});
sinkToSinkCount++;
var leafToLeafStatistics = statisticsCalculator.GetLeafToLeafStatistics(jointEdge, inEdge);
selectivity *= leafToLeafStatistics.Selectivity;
compSinkNodeStatistics =
ColumnStatistics.UpdateHistogram(compSinkNodeStatistics,
newComponent.Context.GetEdgeStatistics(inEdge));
}
newComponent.StatisticsDict[sinkNode] = compSinkNodeStatistics;
}
}
}
var unmatEdges = candidateTree.UnmaterializedEdges;
foreach (var unmatEdge in unmatEdges)
{
newComponent.EdgeMaterilizedDict[unmatEdge] = false;
newComponent.Nodes.Add(unmatEdge.SinkNode);
var sinkNodeInEdges = newComponent.UnmaterializedNodeMapping.GetOrCreate(unmatEdge.SinkNode);
sinkNodeInEdges.Add(unmatEdge);
degrees *= unmatEdge.AverageDegree;
}
// Calculate Estimated Join Selectivity & Estimated Node Size
double estimatedSelectity = 1.0;
int count = 0;
bool sinkJoin = false;
foreach (var item in densityDict.Where(e => DensityCount.ContainsKey(e.Key)))
{
var density = item.Value;
var curJoinCount = DensityCount[item.Key];
var curJoinSelectitivy = Math.Pow(density, 2 - Math.Pow(2, 1 - curJoinCount));
if (!sinkJoin && ColumnStatistics.DefaultDensity < density)
{
var curSinkJoinSelectivity = Math.Pow(ColumnStatistics.DefaultDensity,
2 - Math.Pow(2, 1 - sinkToSinkCount));
estimatedSelectity *= Math.Pow(curSinkJoinSelectivity, Math.Pow(2, -count));
count += sinkToSinkCount;
sinkJoin = true;
}
estimatedSelectity *= Math.Pow(curJoinSelectitivy, Math.Pow(2, -count));
count += curJoinCount;
}
var estimatedNodeUnitSize = root.EstimatedRows *
Math.Pow(1000, candidateTree.MaterializedEdges.Count + candidateTree.UnmaterializedEdges.Count);
// Update Table Reference
newComponent.TableRef = GetPlanAndUpdateCost(candidateTree, newComponent, nodeTable, compTable, joinCondition,
degrees, selectivity, estimatedNodeUnitSize, estimatedSelectity);
return(newComponent);
}
/// <summary>
/// Calculate join costs and update components using optimal join method & order
/// </summary>
/// <param name="nodeUnitCandidate"></param>
/// <param name="component"></param>
/// <param name="nodeTable"></param>
/// <param name="componentTable"></param>
/// <param name="joinCondition"></param>
/// <param name="nodeDegrees"></param>
/// <param name="estimatedNodeUnitSize"></param>
/// <param name="estimatedSelectivity"></param>
/// <returns></returns>
private static WTableReference GetPlanAndUpdateCost(
OneHeightTree nodeUnitCandidate,
MatchComponent component,
WTableReference nodeTable,
WTableReference componentTable,
WBooleanExpression joinCondition,
double nodeDegrees,
double joinSelectivity,
double estimatedNodeUnitSize,
double estimatedSelectivity)
{
var nodeUnitSize = nodeUnitCandidate.TreeRoot.EstimatedRows * nodeDegrees;
var componentSize = component.Size;
var estimatedCompSize = component.EstimateSize;
var cost = nodeUnitSize + componentSize;
//var joinSelectivity =
// nodeWithJoinMapping.SelectivityProduct;
//nodeWithJoinMapping.ExponentialSelevtivityProduct;
WQualifiedJoin joinTable = new WQualifiedJoin
{
FirstTableRef = componentTable,
SecondTableRef = nodeTable,
JoinCondition = joinCondition,
QualifiedJoinType = QualifiedJoinType.Inner,
JoinHint = JoinHint.Hash
};
var node = nodeUnitCandidate.TreeRoot;
// If the node is already in the component, then only multiply the degree to get the size
double nodeUnitActualSize;
if (component.MaterializedNodeSplitCount[node] > 0)
{
nodeUnitActualSize = nodeDegrees;
var cEstEdge = Math.Pow(1000, component.EdgeMaterilizedDict.Count(e => !e.Value));
var cSize = component.EstimateSize / cEstEdge;
var nSize = node.EstimatedRows;
if (nSize > cSize)
{
component.EstimateSize = estimatedNodeUnitSize * cEstEdge * estimatedSelectivity;
}
else
{
component.EstimateSize = component.EstimateSize * Math.Pow(1000, nodeUnitCandidate.UnmaterializedEdges.Count) *
estimatedSelectivity;
}
}
else
{
nodeUnitActualSize = nodeUnitSize;
component.EstimateSize *= estimatedNodeUnitSize * estimatedSelectivity;
}
//Update Size
component.Size *= nodeUnitActualSize * joinSelectivity;
// Update Cost
component.Cost += cost;
// Debug
#if DEBUG
//Trace.Write(component.NodeUnits.Count+" ");
//foreach (var n in component.NodeUnits.Where(e => e.Key != node.Node.ExposedName))
//{
// Trace.Write(n.Value.NodeRefName);
//}
//Trace.Write(component.NodeUnits[node.Node.ExposedName].NodeRefName+" ");
//Trace.Write(" "+(long)component.Cost+" "+(long)component.Size);
//Trace.Write(" ");
//foreach (var item in component.PopulatedEdgesName)
//{
// Trace.Write(item + " ");
//}
//Trace.Write("; ");
//foreach (var unpopulatedEdge in component.UnpopulatedEdges)
//{
// Trace.Write(unpopulatedEdge.Alias + " ");
//}
//Trace.WriteLine("");
#endif
// Update TableRef
// Only consider the size in the first join
if (component.MaterializedNodeSplitCount.Count == 2 && component.MaterializedNodeSplitCount.All(e => e.Value == 0))
{
var nodeInComp = component.MaterializedNodeSplitCount.Keys.First(e => e != node);
if (nodeUnitSize < componentSize)
{
joinTable.FirstTableRef = nodeTable;
joinTable.SecondTableRef = componentTable;
component.TotalMemory = component.DeltaMemory = nodeUnitSize;
component.EstimateTotalMemory = component.EstimateDeltaMemory = estimatedNodeUnitSize;
component.RightestTableRefSize = nodeInComp.EstimatedRows;
component.FatherOfRightestTableRef = new Tuple <WQualifiedJoin, String>(joinTable,
component.GetNodeRefName(nodeInComp));
AdjustEstimation(component, nodeTable, joinTable, nodeUnitSize, estimatedNodeUnitSize,
nodeUnitCandidate.TreeRoot.EstimatedRows, new Tuple <WQualifiedJoin, string>(joinTable, component.GetNodeRefName(node)));
}
else
{
component.TotalMemory = component.DeltaMemory = componentSize;
component.EstimateTotalMemory = component.EstimateDeltaMemory = component.EstimateSize;
component.RightestTableRefSize = nodeUnitCandidate.TreeRoot.EstimatedRows;
component.FatherOfRightestTableRef = new Tuple <WQualifiedJoin, String>(joinTable, component.GetNodeRefName(node));
AdjustEstimation(component, componentTable, joinTable, componentSize, estimatedCompSize,
nodeInComp.EstimatedRows, new Tuple <WQualifiedJoin, string>(joinTable, component.GetNodeRefName(nodeInComp)));
}
}
else
{
double sizeFactor = 5;//1000;
double maxMemory = 1e8;
double loopJoinInnerThreshold = 10000;
double loopJoinOuterThreshold = 1000000;
// Left Deep
if (componentSize * sizeFactor < nodeUnitSize)
{
var curDeltaMemory = componentSize;
component.TotalMemory = component.DeltaMemory + curDeltaMemory;
component.DeltaMemory = curDeltaMemory;
var curDeltaEstimateMemory = component.EstimateSize;
component.EstimateTotalMemory = component.EstimateDeltaMemory + curDeltaEstimateMemory;
component.EstimateDeltaMemory = curDeltaEstimateMemory;
// Adjust estimation in sql server
AdjustEstimation(component, componentTable, joinTable, componentSize, estimatedCompSize,
component.RightestTableRefSize, component.FatherOfRightestTableRef);
component.FatherOfRightestTableRef = new Tuple <WQualifiedJoin, string>(joinTable, component.GetNodeRefName(node));
component.RightestTableRefSize = nodeUnitCandidate.TreeRoot.EstimatedRows;
}
else
{
// Loop Join
if (
//((nodeUnitSize < loopJoinInnerThreshold /*&& componentSize < loopJoinOuterThreshold*/) || component.DeltaMemory + componentSize > maxMemory / 100) &&
((nodeUnitSize < loopJoinInnerThreshold && componentSize < loopJoinOuterThreshold) ||
component.DeltaMemory + componentSize > maxMemory) &&
nodeUnitCandidate.MaterializedEdges.Count == 0)
{
component.TotalMemory = component.DeltaMemory;
component.EstimateTotalMemory = component.EstimateDeltaMemory;
joinTable.JoinHint = JoinHint.Loop;
component.EstimateSize = estimatedCompSize * estimatedNodeUnitSize /
nodeUnitCandidate.TreeRoot.TableRowCount;
}
// Right Deep
else
{
joinTable.FirstTableRef = nodeTable;
joinTable.SecondTableRef = componentTable;
AdjustEstimation(component, nodeTable, joinTable, nodeUnitSize, estimatedNodeUnitSize,
node.EstimatedRows, new Tuple <WQualifiedJoin, string>(joinTable, component.GetNodeRefName(node)));
component.TotalMemory += nodeUnitSize;
component.DeltaMemory = component.TotalMemory;
component.EstimateTotalMemory += estimatedNodeUnitSize;
component.EstimateDeltaMemory = component.EstimateTotalMemory;
}
}
}
return(new WParenthesisTableReference
{
Table = joinTable
});
}
public bool Invoke(WBooleanExpression node)
{
_referencedByNodeAndEdge = true;
node.Accept(this);
return(_referencedByNodeAndEdge);
}
private void Extract(WBooleanExpression expr)
{
this.normalizedList.Add(expr);
}
