Example #1
0
 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;
 }
Example #2
0
 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);
 }