public ITupleIterator execute(IDatabase source, IDatabase target) {
List<ITupleIterator> tupleIterators = new ArrayList<ITupleIterator>();
for (IAlgebraOperator child : children) {
ITupleIterator childrenTuple = child.execute(source, target);
tupleIterators.add(childrenTuple);
}
ITupleIterator firstChild = tupleIterators.remove(0);
ITupleIterator secondChild = tupleIterators.remove(0);
ITupleIterator currentResult = computeSimpleCartesianProduct(firstChild, secondChild);
while (!tupleIterators.isEmpty()) {
currentResult = computeSimpleCartesianProduct(currentResult, tupleIterators.remove(0));
}
for (ITupleIterator tupleIterator : tupleIterators) {
tupleIterator.close();
}
return currentResult;
}
private ITupleIterator computeSimpleCartesianProduct(
ITupleIterator leftTuples, ITupleIterator rightTuples) {
List<Tuple> result = new ArrayList<Tuple>();
while (leftTuples.hasNext()) {
Tuple leftTuple = leftTuples.next();
if (logger.isDebugEnabled()) logger.debug("Left tuple in cartesian product: " + leftTuple);
while (rightTuples.hasNext()) {
Tuple rightTuple = rightTuples.next();
if (logger.isDebugEnabled())
logger.debug("Right tuple in cartesian product: " + rightTuple);
Tuple joinedTuple = joinTuples(leftTuple, rightTuple);
result.add(joinedTuple);
}
rightTuples.reset();
}
leftTuples.reset();
return new ListTupleIterator(result);
}
private EquivalenceClassForSymmetricEGD readNextEquivalenceClass(
ITupleIterator it,
Dependency egd,
IDatabase deltaDB,
String stepId,
IChaseState chaseState,
Scenario scenario) {
if (!it.hasNext() && (this.lastTupleHandled || this.lastTuple == null)) {
return null;
}
EquivalenceClassForSymmetricEGD equivalenceClass = createEquivalenceClass(egd);
if (lastTuple != null && !this.lastTupleHandled) {
if (logger.isDebugEnabled())
logger.debug("Reading tuple : " + this.lastTuple.toStringWithOIDAndAlias());
addTuple(
this.lastTuple,
equivalenceClass,
scenario.getCostManagerConfiguration(),
deltaDB,
stepId,
scenario);
this.lastTupleHandled = true;
}
if (logger.isDebugEnabled()) logger.debug("Reading next equivalence class...");
while (it.hasNext()) {
if (chaseState.isCancelled())
ChaseUtility.stopChase(
chaseState); // throw new ChaseException("Chase interrupted by user");
Tuple tuple = it.next();
if (logger.isDebugEnabled())
logger.debug("Reading tuple : " + tuple.toStringWithOIDAndAlias());
if (lastTuple == null
|| equivalenceClass.isEmpty()
|| EquivalenceClassUtility.sameEquivalenceClass(tuple, this.lastTuple, egd)) {
addTuple(
tuple,
equivalenceClass,
scenario.getCostManagerConfiguration(),
deltaDB,
stepId,
scenario);
this.lastTuple = tuple;
this.lastTupleHandled = true;
} else {
if (logger.isDebugEnabled()) logger.debug("Equivalence class is finished...");
if (equivalenceClass.isEmpty()) {
throw new IllegalArgumentException(
"Unable to create equivalence class for egd:\n"
+ egd
+ "\nLast tuple: \n"
+ lastTuple
+ "\nCurrent tuple: \n"
+ tuple);
}
this.lastTuple = tuple;
this.lastTupleHandled = false;
break;
}
}
if (logger.isDebugEnabled()) logger.debug("Equivalence class loaded");
if (logger.isDebugEnabled())
logger.debug("-------- Equivalence class:\n" + equivalenceClass + "\n---------------");
return equivalenceClass;
}
@Override
public NewChaseSteps chaseDependency(
DeltaChaseStep currentNode,
Dependency egd,
IAlgebraOperator premiseQuery,
Scenario scenario,
IChaseState chaseState,
IDatabase databaseForStep) {
if (logger.isDebugEnabled())
logger.debug("***** Step: " + currentNode.getId() + " - Chasing dependency: " + egd);
if (logger.isTraceEnabled()) logger.trace(databaseForStep.printInstances());
this.lastTuple = null;
this.lastTupleHandled = false;
if (logger.isDebugEnabled()) logger.debug("Executing premise query: " + premiseQuery);
if (logger.isTraceEnabled())
logger.debug(
"Result:\n"
+ LunaticUtility.printIterator(
queryRunner.run(premiseQuery, scenario.getSource(), databaseForStep)));
long violationQueryStart = new Date().getTime();
ITupleIterator it = queryRunner.run(premiseQuery, scenario.getSource(), databaseForStep);
long violationQueryEnd = new Date().getTime();
ChaseStats.getInstance()
.addStat(ChaseStats.EGD_VIOLATION_QUERY_TIME, violationQueryEnd - violationQueryStart);
List<Repair> repairsForDependency = new ArrayList<Repair>();
try {
while (true) {
long equivalenceClassStart = new Date().getTime();
EquivalenceClassForSymmetricEGD equivalenceClass =
readNextEquivalenceClass(
it, egd, currentNode.getDeltaDB(), currentNode.getId(), chaseState, scenario);
long equivalenceClassEnd = new Date().getTime();
ChaseStats.getInstance()
.addStat(
ChaseStats.EGD_EQUIVALENCE_CLASS_TIME, equivalenceClassEnd - equivalenceClassStart);
if (equivalenceClass == null) {
break;
}
ICostManager costManager = CostManagerFactory.getCostManager(egd, scenario);
long choosingRepairStart = new Date().getTime();
List<Repair> repairsForEquivalenceClass =
costManager.chooseRepairStrategy(
new EquivalenceClassForEGDProxy(equivalenceClass),
currentNode.getRoot(),
repairsForDependency,
scenario,
currentNode.getId(),
occurrenceHandler);
long choosingRepairEnd = new Date().getTime();
ChaseStats.getInstance()
.addStat(ChaseStats.EGD_CHOOSING_REPAIR_TIME, choosingRepairEnd - choosingRepairStart);
if (logger.isDebugEnabled())
logger.debug(
"Repairs for equivalence class: "
+ LunaticUtility.printCollection(repairsForEquivalenceClass));
repairsForDependency =
ChaseUtility.accumulateRepairs(repairsForDependency, repairsForEquivalenceClass);
if (noMoreTuples(it)) {
break;
}
if (logger.isDebugEnabled())
logger.debug("Repairs for equivalence classes so far: " + repairsForDependency.size());
}
} catch (ChaseFailedException e) {
throw e;
} finally {
it.close();
}
if (logger.isDebugEnabled())
logger.debug(
"Total repairs for dependency: " + LunaticUtility.printCollection(repairsForDependency));
long repairStart = new Date().getTime();
NewChaseSteps newSteps = applyRepairs(currentNode, repairsForDependency, egd, scenario);
long repairEnd = new Date().getTime();
ChaseStats.getInstance().addStat(ChaseStats.EGD_REPAIR_TIME, repairEnd - repairStart);
return newSteps;
}
private boolean noMoreTuples(ITupleIterator it) {
return (!it.hasNext() && lastTupleHandled);
}