public MatchComponent(MatchNode node) : this()
{
Nodes.Add(node.NodeAlias, node);
MaterializedNodeSplitCount[node] = 0;
//SinkNodeStatisticsDict[node] = new Statistics ();
NodeToMaterializedEdgesDict[node.NodeAlias] = new List <Tuple <MatchEdge, MaterializedEdgeType> >();
Cardinality *= node.EstimatedRows;
foreach (var edge in node.Neighbors)
{
var edgeList = UnmaterializedNodeMapping.GetOrCreate(edge.SinkNode);
edgeList.Add(edge);
}
}
public MatchComponent(MatchNode node, List <MatchEdge> populatedEdges, WSqlTableContext context) : this(node)
{
Context = context;
foreach (var edge in populatedEdges)
{
TableRef = SpanTableRef(TableRef, edge, node.RefAlias);
EdgeMaterilizedDict[edge] = true;
StatisticsDict[edge.SinkNode] = Context.GetEdgeStatistics(edge);
var edgeList = UnmaterializedNodeMapping.GetOrCreate(edge.SinkNode);
edgeList.Add(edge);
Nodes.Add(edge.SinkNode);
Size *= edge.AverageDegree;
EstimateSize *= 1000;
}
}
public MatchComponent(MatchNode node, List <MatchEdge> populatedEdges, GraphMetaData metaData) : this(node)
{
foreach (var edge in populatedEdges)
{
TableRef = SpanTableRef(TableRef, edge, node.RefAlias, metaData);
EdgeMaterilizedDict[edge] = true;
SinkNodeStatisticsDict[edge.SinkNode] = edge.Statistics;
var edgeList = UnmaterializedNodeMapping.GetOrCreate(edge.SinkNode);
edgeList.Add(edge);
if (!Nodes.Contains(edge.SinkNode))
{
Nodes.Add(edge.SinkNode);
}
Cardinality *= edge.AverageDegree;
SqlEstimatedSize *= 1000;
}
}
private WBooleanExpression ConstructJoinCondition(
CandidateJoinUnit candidateTree,
IMatchJoinStatisticsCalculator statisticsCalculator,
GraphMetaData metaData,
out double joinSelectivity,
out double sqlEstimatedJoinSelectivity)
{
joinSelectivity = 1.0;
sqlEstimatedJoinSelectivity = 1.0;
var root = candidateTree.TreeRoot;
WBooleanExpression joinCondition = null;
string nodeName = "";
// Update Nodes
if (MaterializedNodeSplitCount.ContainsKey(root))
{
MaterializedNodeSplitCount[root]++;
nodeName = 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;
if (!Nodes.Contains(root))
{
Nodes.Add(root);
}
MaterializedNodeSplitCount[root] = 0;
}
List <double> densityList = new List <double>();
List <MatchEdge> inEdges;
if (UnmaterializedNodeMapping.TryGetValue(root, out inEdges))
{
var firstEdge = inEdges.First();
bool materialized = EdgeMaterilizedDict[firstEdge];
UnmaterializedNodeMapping.Remove(root);
joinSelectivity *= 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
});
densityList.Add(root.GlobalNodeIdDensity);
}
// Component unmaterialized edge to root
else
{
Statistics statistics = null;
foreach (var edge in inEdges)
{
// Update component table
TableRef = SpanTableRef(TableRef, edge, GetNodeRefName(edge.SourceNode), metaData);
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
});
double selectivity;
statistics = Statistics.UpdateHistogram(statistics,
edge.Statistics, out selectivity);
joinSelectivity *= selectivity;
densityList.Add(root.GlobalNodeIdDensity);
}
SinkNodeStatisticsDict[root] = statistics;
}
}
var jointEdges = candidateTree.MaterializedEdges;
foreach (var jointEdge in jointEdges)
{
EdgeMaterilizedDict[jointEdge] = true;
var sinkNode = jointEdge.SinkNode;
// Leaf to component materialized node
if (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
});
Statistics sinkNodeStatistics;
if (!SinkNodeStatisticsDict.TryGetValue(sinkNode, out sinkNodeStatistics))
{
sinkNodeStatistics = null;
joinSelectivity *= 1.0 / sinkNode.TableRowCount;
}
double selectivity;
var statistics = Statistics.UpdateHistogram(sinkNodeStatistics,
jointEdge.Statistics, out selectivity);
joinSelectivity *= selectivity;
SinkNodeStatisticsDict[sinkNode] = statistics;
densityList.Add(sinkNode.GlobalNodeIdDensity);
}
// Leaf to component unmaterialized node
else
{
inEdges = UnmaterializedNodeMapping[sinkNode];
var firstEdge = inEdges.First();
bool materlizedEdge = 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
});
densityList.Add(Statistics.DefaultDensity);
double selectivity;
var statistics = Statistics.UpdateHistogram(SinkNodeStatisticsDict[sinkNode],
jointEdge.Statistics, out selectivity);
joinSelectivity *= selectivity;
SinkNodeStatisticsDict[sinkNode] = statistics;
}
// Leaf to unmaterialized leaf
else
{
Statistics compSinkNodeStatistics = null;
foreach (var inEdge in inEdges)
{
TableRef = SpanTableRef(TableRef, inEdge, GetNodeRefName(inEdge.SourceNode), metaData);
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
});
densityList.Add(Statistics.DefaultDensity);
double selectivity;
var leafToLeafStatistics = statisticsCalculator.GetLeafToLeafStatistics(jointEdge, inEdge,
out selectivity);
joinSelectivity *= selectivity;
compSinkNodeStatistics =
Statistics.UpdateHistogram(compSinkNodeStatistics,
inEdge.Statistics, out selectivity);
}
SinkNodeStatisticsDict[sinkNode] = compSinkNodeStatistics;
}
}
}
var unmatEdges = candidateTree.UnmaterializedEdges;
foreach (var unmatEdge in unmatEdges)
{
EdgeMaterilizedDict[unmatEdge] = false;
if (!Nodes.Contains(unmatEdge.SinkNode))
{
Nodes.Add(unmatEdge.SinkNode);
}
var sinkNodeInEdges = UnmaterializedNodeMapping.GetOrCreate(unmatEdge.SinkNode);
sinkNodeInEdges.Add(unmatEdge);
}
// Calculate Estimated Join Selectivity & Estimated Node Size
densityList.Sort();
for (int i = densityList.Count - 1; i >= 0; i--)
{
sqlEstimatedJoinSelectivity *= Math.Sqrt(sqlEstimatedJoinSelectivity) * densityList[i];
}
return(joinCondition);
}
