/// <summary>
/// Applies the current rule set for selecting a join edge from a given set of options.
/// </summary>
/// <param name="joinGraph">The join graph.</param>
/// <returns>
/// The selected join edge.
/// </returns>
public jg::Edge ChooseJoinEdge(jg::Graph joinGraph)
{
//
// we apply each rule in sequence to filter the set of available candidates until we
// either 1) have only one option left or 2) arrive at the last rule, which is then
// forced to make a choice
var candidates = new List <jg::Edge>(joinGraph.Edges);
for (int i = 0; i < m_rulesJoins.Count; i++)
{
//
// if there's only one option left we can return this immediately
if (candidates.Count == 1)
{
return(candidates[0]);
}
if (i == m_rulesJoins.Count - 1)
{
//
// last rule, so force it to choose
return(m_rulesJoins[i].Choose(m_context, candidates, joinGraph));
}
else
{
//
// perform a filtering step
var filtered = new List <jg::Edge>(m_rulesJoins[i].Filter(m_context, candidates, joinGraph));
candidates = filtered;
}
}
//
// if, after application of all rules, we still have not arrived at a conclusive choice,
// we simply select the first option from the candidates we have left
if (candidates.Count > 0)
{
return(candidates[0]);
}
else
{
return(null);
}
}
/// <summary>
/// Merges a pair of given join nodes, causing all edges connecting to either of the two
/// join nodes to connect to the newly formed node which merges the two.
/// </summary>
/// <param name="joinGraph">The join graph.</param>
/// <param name="oldEdge">The old edge which is to be replaced.</param>
/// <param name="newNode">The new node which takes merges the two nodes belonging to the given edge.</param>
private static void MergeJoinNodes(jg::Graph joinGraph, jg::Edge oldEdge, jg::Node newNode)
{
//
// remove the old edge and its nodes from the join graph
joinGraph.Edges.Remove(oldEdge);
joinGraph.Nodes.Remove(oldEdge.Left);
joinGraph.Nodes.Remove(oldEdge.Right);
//
// any edges connecting to the removed nodes will be redirected to the new node that
// merges the two
foreach (var edge in joinGraph.Edges)
{
if (edge.Left.Equals(oldEdge.Left) || edge.Left.Equals(oldEdge.Right))
{
edge.Left = newNode;
}
if (edge.Right.Equals(oldEdge.Left) || edge.Right.Equals(oldEdge.Right))
{
edge.Right = newNode;
}
}
//
// we might end up with duplicate edges pointing to the new node, so make sure to
// filter those out
var uniqueEdges = joinGraph.Edges.Distinct().ToList();
joinGraph.Edges.Clear();
joinGraph.Edges.AddRange(uniqueEdges);
//
// insert the new node into the join graph
joinGraph.Nodes.Add(newNode);
}
/// <summary>
/// Computes a descriptive query plan for a given Basic Graph Pattern within a given
/// database context.
/// </summary>
/// <param name="context">The database context.</param>
/// <param name="pattern">The Basic Graph Pattern.</param>
/// <returns>
/// A descriptive query plan for the given BGP.
/// </returns>
public static QueryPlan ComputePlan(Database context, params Triple <TripleItem, TripleItem, TripleItem>[] pattern)
{
//
// initialize the decision engine
var decisionEngine = GetDecisionEngine(context);
//
// compute the atom collapse
var collapse = AtomCollapse.Compute(pattern);
//
// step 1: compute join graph
//
// working copy of collapse graph nodes
var currentCollapse = new List <ac::Node>();
foreach (var node in collapse.Nodes)
{
currentCollapse.Add(node.Copy());
}
List <ac::Node> seeds;
var todo = new List <Triple <TripleItem, TripleItem, TripleItem> >();
var eval = new List <ac::Node>();
do
{
//
// compute the seeds
seeds = ComputeSeeds(currentCollapse);
//
// pick one
var seed = decisionEngine.ChooseSeed(seeds, collapse, currentCollapse).Copy();
//
// compute new todo's
if (todo.Contains(seed.FirstSAP))
{
todo.Remove(seed.FirstSAP);
}
foreach (var sap in ComputeNewTodos(seed, currentCollapse))
{
todo.AddIfNotPresent(sap);
}
//
// update the current collapse
foreach (var node in currentCollapse)
{
if (node.SAPs.Contains(seed.FirstSAP))
{
node.SAPs.Remove(seed.FirstSAP);
}
}
currentCollapse.RemoveAll(n => n.SAPs.Count == 0);
//
// add the seed to the evaluation list
eval.Add(seed);
} while (todo.Count > 0);
//
// compute edges
var collapseEdges = new List <ac::Edge>();
foreach (var edge in collapse.Edges)
{
foreach (var x in eval)
{
foreach (var y in eval)
{
if (edge.Left.Equals(x) && edge.Right.Equals(y))
{
collapseEdges.Add(edge);
}
}
}
}
//
// create join graph nodes
var joinNodes = new List <jg::Node>();
foreach (var cNode in eval)
{
var jNode = new jg::Node(cNode.Item, cNode.FirstSAP);
joinNodes.Add(jNode);
}
//
// create join graph edges
var joinEdges = new List <jg::Edge>();
foreach (var cEdge in collapseEdges)
{
foreach (var x in joinNodes)
{
foreach (var y in joinNodes)
{
if (cEdge.Left.Item.Equals(x.Item) && cEdge.Left.FirstSAP.Equals(x.SAP))
{
if (cEdge.Right.Item.Equals(y.Item) && cEdge.Right.FirstSAP.Equals(y.SAP))
{
var jEdge = new jg::Edge(x, y);
foreach (var lbl in cEdge.Labels)
{
jEdge.Labels.Add(lbl);
}
joinEdges.Add(jEdge);
}
}
}
}
}
//
// make the join graph
var joinGraph = new jg::Graph(joinNodes, joinEdges);
//
// step 2: compute query plan
if (joinGraph.Edges.Count == 0)
{
var n = joinGraph.Nodes.ElementAt(0);
n.Operator = decisionEngine.ChooseScan(n);
}
else
{
while (joinGraph.Nodes.Count > 1)
{
//
// choose a join to perform
var joinEdge = decisionEngine.ChooseJoinEdge(joinGraph);
//
// compute the join node for this edge
var newNode = decisionEngine.ChooseJoinType(joinEdge);
//
// merge the nodes of the join edge
MergeJoinNodes(joinGraph, joinEdge, newNode);
}
}
//
// create plan object
var plan = new QueryPlan(joinGraph.Nodes.ElementAt(0).Operator);
//
// assign memory to operators
AssignMemory(context, plan.Root);
//
// return the query plan
return(plan);
}
