org.aksw.limes.core.execution.engine

Class SimpleExecutionEngine

java.lang.Object

org.aksw.limes.core.execution.engine.ExecutionEngine

org.aksw.limes.core.execution.engine.SimpleExecutionEngine

All Implemented Interfaces:

IExecutionEngine

public class SimpleExecutionEngine
extends ExecutionEngine

Implements the default execution engine class. The idea is that the engine gets as input a link specification and a planner type, executes the independent parts of the plan returned from the planner sequentially and returns a MemoryMemoryMapping.

Version:

1.0

Author:

Axel-C. Ngonga Ngomo (ngonga@informatik.uni-leipzig.de), Kleanthi Georgala (georgala@informatik.uni-leipzig.de)

Field Summary

Fields inherited from class org.aksw.limes.core.execution.engine.ExecutionEngine

buffer, source, sourceVariable, target, targetVariable

Constructor Summary

Constructors

Constructor and Description
SimpleExecutionEngine(ACache source, ACache target, String sourceVar, String targetVar) Constructor for a simple execution engine.

Method Summary

Modifier and Type	Method and Description
AMapping	execute(LinkSpecification spec, IPlanner planner) Executes a link specification.
AMapping	executeDifference(AMapping m1, AMapping m2) Implements the difference between two mappings.
AMapping	executeDynamic(LinkSpecification spec, DynamicPlanner planner) Executes an input link specification L in a dynamic fashion.
AMapping	executeFilter(Instruction inst, AMapping input) Runs the filtering operator.
AMapping	executeInstructions(Plan plan) Implementation of the execution of a plan.
AMapping	executeIntersection(AMapping m1, AMapping m2) Implements the intersection between two mappings.
AMapping	executeRun(Instruction inst) Implements the execution of the RUN operator.
AMapping	executeStatic(NestedPlan plan) Executes an immutable nested plan in lNr depth first oder.
AMapping	executeUnion(AMapping m1, AMapping m2) Implements the union between two mappings.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SimpleExecutionEngine

public SimpleExecutionEngine(ACache source,
                             ACache target,
                             String sourceVar,
                             String targetVar)

Constructor for a simple execution engine.

Parameters:

source - Source cache

target - Target cache

sourceVar - Source variable

targetVar - Target variable

Method Detail

executeInstructions

public AMapping executeInstructions(Plan plan)

Implementation of the execution of a plan. It receives a plan as a set of instructions and executes them sequentially. This function does not execute nested plans. In case of a RUN command, the instruction must include an atomic link specification.

Parameters:

plan - An execution plan

Returns:

The mapping obtained from executing the plan

executeRun

public AMapping executeRun(Instruction inst)

Implements the execution of the RUN operator. The input instruction must include an atomic link specification.

Parameters:

inst - Atomic RUN instruction

Returns:

The mapping obtained from executing the atomic RUN instruction

executeFilter

public AMapping executeFilter(Instruction inst,
                              AMapping input)

Runs the filtering operator.

Parameters:

inst - Input instruction with FILTER command

input - Mapping that is to be filtered

Returns:

filtered Mapping

executeDifference

public AMapping executeDifference(AMapping m1,
                                  AMapping m2)

Implements the difference between two mappings.

Parameters:

m1 - First Mapping

m2 - Second Mapping

Returns:

Difference of m1 and m2

executeIntersection

public AMapping executeIntersection(AMapping m1,
                                    AMapping m2)

Implements the intersection between two mappings.

Parameters:

m1 - First Mapping

m2 - Second Mapping

Returns:

Intersection of m1 and m2

executeUnion

public AMapping executeUnion(AMapping m1,
                             AMapping m2)

Implements the union between two mappings.

Parameters:

m1 - First Mapping

m2 - Second Mapping

Returns:

Intersection of m1 and m2

executeStatic

public AMapping executeStatic(NestedPlan plan)

Executes an immutable nested plan in lNr depth first oder. See execute(LinkSpecification, IPlanner). If a plan is atomic, it is executed and the result mapping is returned. If it is complex, the operator is used on the top 2 previously retrieved mappings and the result mapping of the previous step gets filtered using the filtering instruction of the plan (if any).

Parameters:

plan - A nested plan created by a static planner (Canonical or Helios)

Returns:

The mapping obtained from executing the plan

executeDynamic

public AMapping executeDynamic(LinkSpecification spec,
                               DynamicPlanner planner)

Executes an input link specification L in a dynamic fashion. See execute(LinkSpecification, IPlanner). If L is already executed, then the corresponding mapping is retrieved from the dynamicResults and returned. If L is not executed, then the function checks if there is another previously executed specification A with the same fullExpression ( LinkSpecification.fullExpression but lower threshold. If A exists, then it retrieves the mapping of A, filters it with input link specification threshold and returns the mapping. If A does not exist, the function checks whether L is atomic or not. If L is atomic then the planner creates a nested plan P with a RUN instruction. The function executes P and the retrieved mapping is returned. If L is not atomic, then the planner creates an initial plan P for L and the function executes the first subPlan of P, P1. Then, if L has an OR or XOR operator, the second subPlan of P, P2 is executed, the operator functions is applied to the mappings returned by P1 and P2 and the resulting mapping is filtered and returned. In case of an AND or MINUS operator, the executeDynamic function invokes the planning function again to re-plan the remaining non-executed parts of P (if any). Then it executes the second sub-plan of P, that can vary given from the initial given the intermediate executed steps of the first plan.

Parameters:

spec - The input link specification

planner, - The dynamic planner

Returns:

The mapping obtained from executing the link specification.

execute

public AMapping execute(LinkSpecification spec,
                        IPlanner planner)

Executes a link specification. The execution engine chooses which execute function is going to be invoked given the planner. For the Canonical and Helios planner, the execution of link specifications has been modeled as a linear process wherein a LS is potentially first rewritten, planned and finally executed. Subsequently, the plan never changes and is simply executed. For the Dynamic planner, we enable a flow of information from the execution engine back to the planner, that uses intermediary execution results to improve plans generated previously.

Parameters:

spec - The link specification, after it was re-written

planner - The chosen planner

Returns:

The mapping obtained from executing the plan of the input link specification