Examples of lupos.engine.operators.BasicOperator

lupos.engine.operators.BasicOperator
All operators are derived from this class. This class provides fundamental methods for all operators.

    // In case that Generate or TriplePattern has minimum one variable, than
    // minimum one operator has to be inserted
    if (order.size() > 0) {
      final List<BasicOperator> pres = (List<BasicOperator>) generate
          .getPrecedingOperators();
      BasicOperator pre;
      for (int i = 0; i < pres.size(); i++) {
        pre = pres.get(i);
        pre.addSucceedingOperator(new OperatorIDTuple(order.getFirst(),
            0));
        if (filter != null) {
          Collection<Variable> vars = filter
              .getIntersectionVariables();
          if (vars == null)
            vars = new HashSet<Variable>();
          vars.addAll(pre.getIntersectionVariables());
          filter.setIntersectionVariables(vars);
          filter.setUnionVariables(vars);
        }
        pre.removeSucceedingOperator(generate);
        order.getFirst().addPrecedingOperator(pre);
      }


      for (int i = 0; i < order.size() - 1; i++) {
        order.get(i + 1).setPrecedingOperator(order.get(i));
        order.get(i).setSucceedingOperator(
            new OperatorIDTuple(order.get(i + 1), 0));
      }


      final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) pat
          .getSucceedingOperators();
      for (int i = 0; i < succs.size(); i++) {
        succs.get(i).getOperator()
            .addPrecedingOperator(order.getLast());
      }


      final LinkedList<OperatorIDTuple> sops = new LinkedList<OperatorIDTuple>();
      sops.addAll(pat.getSucceedingOperators());
      order.getLast().setSucceedingOperators(sops);
    } else {
      final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) generate
          .getPrecedingOperators();
      final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) pat
          .getSucceedingOperators();
      BasicOperator pre;
      BasicOperator succ;
      for (int i = 0; i < pres.size(); i++) {
        pre = pres.get(i);
        pre.removeSucceedingOperator(generate);
        for (int x = 0; x < succs.size(); x++) {
          pre.addSucceedingOperator(succs.get(x));
          succ = succs.get(x).getOperator();
          succ.removePrecedingOperator(pat);
          succ.addPrecedingOperator(pre);
        }
      }
    }


    // TriplePattern can have more predecessors then Generate..

View Full Code Here

        .getSubstitutionsVariableRight());


    final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) join
        .getPrecedingOperators();


    BasicOperator pre;
    final LinkedList<Integer> indices = new LinkedList<Integer>();
    // Remark the operator-IDs of the precessors
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);
      indices.add(pre.getOperatorIDTuple(join).getId());
    }


    ReplaceVar rep;
    Projection projectionPre;
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);


      // Calculate the new ReplaceVar which will be replaced between the
      // i-th precessor and the join
      rep = getReplaceAfterPre(replaceVar, originalClone, pre, join);


      // Calculate projection after precessor and new ReplaceVar
      projectionPre = getProjectionAfterReplace(rep, pre);


      added.add(rep);
      added.add(projectionPre);


      pre.setSucceedingOperator(new OperatorIDTuple(rep, 0));
      rep.setPrecedingOperator(pre);
      rep.setSucceedingOperator(new OperatorIDTuple(projectionPre, 0));


      projectionPre.setPrecedingOperator(rep);
      projectionPre.setSucceedingOperator(new OperatorIDTuple(join,

View Full Code Here

    // TODO: nur eine Regel enthalten, welche direkt auf die conclusion
    // passt,
    // sp�ter auswahl der richtigen Regel
    final Result result = new Result();


    BasicOperator subOperator = null;
    for (final Rule rule : obj.getRules())
      if (rule.isImplication()) {
        subOperator = (BasicOperator) obj.getRules().iterator().next().accept(this,
            conclusionIndex);
        break;
      }


    // Keine Regel vorhanden, also m�ssen alle Fakten auf vorhandensein vom
    // Pattern �berpr�ft werden
    if (subOperator == null) {
      subOperator = null;
    }


    subOperator.addSucceedingOperator(result);


    if (datasetIndex.isEmpty())
      root.removeSucceedingOperator(datasetIndex);


    return result;

View Full Code Here


    return result;
  }


  public Object visit(Rule obj, Object arg) throws RIFException {
    BasicOperator headOperator = (BasicOperator) obj.getHead()
    .accept(this, null);
    ((BasicOperator) arg).addSucceedingOperator(headOperator);


    // regelk�rper auswerten und unter head h�ngen
    BasicOperator subOperator = (BasicOperator) obj.getBody().accept(this,
        headOperator);


    final MakeBooleanResult mbr = new MakeBooleanResult();
    subOperator.addSucceedingOperator(mbr);


    return mbr;
  }

View Full Code Here

    Set<BasicOperator> operands = new HashSet<BasicOperator>();
    List<RuleFilter> predicates = new ArrayList<RuleFilter>();
    // erst Rulefilter berechnen
    for (IExpression expr : obj.exprs) {
      if (expr instanceof Equality || expr instanceof External) {
        BasicOperator op = (BasicOperator) expr.accept(this, arg);
        predicates.add((RuleFilter) op);
        continue;
      }
    }
    // 3. Predicates davorschalten
    BasicOperator argument = (BasicOperator) arg;
    BasicOperator headOperator = (BasicOperator) arg;
    if (!predicates.isEmpty()) {
      // 3.1 Predicates sortieren, alle m�glichen Assignments nach vorn
      if (predicates.size() > 1) {
        int i = 0;
        Set<RuleFilter> visited = new HashSet<RuleFilter>();
        while (i < predicates.size()) {
          if (!predicates.get(i).getExpression()
              .isPossibleAssignment()
              && !visited.contains(predicates.get(i))) {
            RuleFilter temp = predicates.get(i);
            predicates.remove(temp);
            predicates.add(temp);
            visited.add(temp);
            continue;
          }
          i++;
        }
      }
      // 3.2 Predicates in Baum einordnen
      // Filter einbauen
      for (BasicOperator pred : predicates) {
        argument.removeSucceedingOperator(pred);
        headOperator.addSucceedingOperator(pred);
        headOperator = pred;
      }
    }
    // restliche Operatoren berechnen
    for (IExpression expr : obj.exprs) {
      if (!(expr instanceof Equality) && !(expr instanceof External)) {
        BasicOperator op = (BasicOperator) expr.accept(this,
            headOperator);
        operands.add(op);
      }
    }


    // 1. Mergen von Indexen
    // BasicIndex mainIndex = null;
    //
    // if (indexes.size() > 1) {
    // Iterator<BasicIndex> it = indexes.iterator();
    // mainIndex = it.next();
    // while (it.hasNext()) {
    // BasicIndex mergeIndex = it.next();
    // mainIndex.getTriplePattern().addAll(
    // mergeIndex.getTriplePattern());
    // mergeIndex.getSucceedingOperators().clear();
    // mergeIndex.removeFromOperatorGraph();
    // operands.remove(mergeIndex);
    // }
    // mainIndex.setSucceedingOperator((OperatorIDTuple) arg);
    // }


    // 2. Joins erstellen
    Iterator<BasicOperator> opIt = operands.iterator();
    if (operands.size() > 1) {
      Join bottomJoin = new Join();
      BasicOperator op1 = opIt.next();
      // op1.removeFromOperatorGraph();
      // op1.getPrecedingOperators().clear();
      // headOperator.addSucceedingOperator(op1);
      op1.addSucceedingOperator(new OperatorIDTuple(bottomJoin, 0));
      BasicOperator op2 = opIt.next();
      // op2.removeFromOperatorGraph();
      // op2.getPrecedingOperators().clear();
      // headOperator.addSucceedingOperator(op2);
      op2.addSucceedingOperator(new OperatorIDTuple(bottomJoin, 1));
      while (opIt.hasNext()) {
        Join tempJoin = new Join();
        BasicOperator operand = opIt.next();
        // operand.removeFromOperatorGraph();
        // operand.getPrecedingOperators().clear();
        // headOperator.addSucceedingOperator(operand);
        operand.setSucceedingOperator(new OperatorIDTuple(tempJoin, 0));
        bottomJoin.setSucceedingOperator(new OperatorIDTuple(tempJoin,
            1));
        bottomJoin = tempJoin;
      }
      return bottomJoin;
    } else if (operands.size() == 1) {
      final BasicOperator operand = opIt.next();
      // operand.removeFromOperatorGraph();
      // headOperator.addSucceedingOperator(operand);
      return operand;
    } else
      return headOperator;

View Full Code Here


  public Object visit(ExistExpression obj, Object arg) throws RIFException {
    if (obj.getVariables().isEmpty()) {
      // keine Variablen zum joinen bzw. vereinen -> BooleanResult
      MakeBooleanResult mbr = new MakeBooleanResult();
      BasicOperator subOperator = (BasicOperator) obj.expr.accept(this,
          arg);
      subOperator.addSucceedingOperator(mbr);
      return mbr;
    } else {
      // Variablen zum joinen vorhanden
      return obj.expr.accept(this, arg);
    }

View Full Code Here


  public Object visit(Disjunction obj, Object arg) throws RIFException {
    // jeden einzelnen zweig mit Union zusammenf�hren
    final Union union = new Union();
    for (final IExpression expr : obj.exprs) {
      final BasicOperator subOperator = (BasicOperator) expr.accept(this,
          arg);
      subOperator.addSucceedingOperator(union);
    }
    return union;
  }

View Full Code Here

      if (rule.isImplication()) {
        for (final IExpression expr : rule.getHeadExpressions()) {
          // Tripel mit variablen Praedikat wird generiert
          if (expr instanceof RulePredicate) {
            final RulePredicate pred = (RulePredicate) expr;
            final BasicOperator pattern = this.generatePattern(pred, arg);
            final KEY key = (pattern instanceof TriplePattern)?
                new KeyTriplePattern((TriplePattern)pattern):
                new KeyPredicatePattern((PredicatePattern)pattern);
            this.tripleProducer.put(key, new LinkedHashSet<BasicOperator>());
          } else if (expr instanceof Equality) {
            this.tripleProducer.put(BuildOperatorGraphRuleVisitor.keyEquality, new LinkedHashSet<BasicOperator>());
            this.usesEqualities = true;
          }
        }
      }
    }


    // 3. Operatorgraphen fuer einzelne Regeln berechnen
    final List<BasicOperator> subOperators = new ArrayList<BasicOperator>();
    for (final Rule rule : obj.getRules()) {
      if (rule.isImplication()) {
        final BasicOperator result = (BasicOperator) rule.accept(this, arg);
        subOperators.add(result);
      }
    }


    // 4. Rekursive Verbindungen aufloesen
    for (final Entry<KEY, Set<BasicOperator>> entry : this.tripleProducer.entrySet()) {
      boolean consumerExists = false;
      // find all matching consumers by just getting the previous determined tripleConsumers...
      final Set<BasicOperator> consumers = this.tripleConsumer.get(entry.getKey());
      if(consumers!=null){
        consumerExists = true;
        // Kreuzverbindungen zwischen Produzenten und Konsumenten
        // herstellen
        for (final BasicOperator producer : entry.getValue()) {
          for (final BasicOperator consumer : consumers) {
            producer.addSucceedingOperator(new OperatorIDTuple(consumer, producer.getSucceedingOperators().size()));
            consumer.addPrecedingOperator(producer);
            // Sonderfall: Falls PredicatePattern ->
            // Dann: PredicatePattern -> Distinct ->
            // -----> should now be unnecessary with our new joins with duplicate elimination integrated! <----
//            if (consumer instanceof PredicatePattern) {
//              boolean distinctFound = false;
//              for (OperatorIDTuple opid : consumer
//                  .getSucceedingOperators())
//                if (opid.getOperator() instanceof Distinct)
//                  distinctFound = true;
//              if (!distinctFound) {
//                final Distinct distinct = new Distinct();
//                for(OperatorIDTuple opID: consumer.getSucceedingOperators()){
//                  distinct.getSucceedingOperators().add(new OperatorIDTuple(opID));
//                }
//                consumer.setSucceedingOperator(new OperatorIDTuple(distinct, 0));
//              }
//            }
          }
        }
      }
      // Wenn keine Konsumenten, dann Produzenten entfernen
      if (!consumerExists) {
        for (final BasicOperator producer : entry.getValue()) {
          if (producer instanceof Generate) {
            producer.removeFromOperatorGraph();
          }
        }
      }
    }


    // 5. Ergebniss aller Regeln in einem Result zusammenfuehren
    BasicOperator[] finalResults;
    if (obj.getConclusion() == null) {
      finalResults = new BasicOperator[1];
      finalResults[0] = new Result();
    } else {
      finalResults = this.patternFromConclusion(obj.getConclusion());
    }


    for(final BasicOperator finalResult: finalResults){
      // Verbindungen zum Endergebniss herstellen
      for (final BasicOperator subOperator : subOperators) {
        // Result immer auf linker Seite, damit keine Linksrekursion
        // auftreten kann
        if(!(finalResult instanceof TriplePattern && subOperator instanceof ConstructPredicate)
            &&!(finalResult instanceof PredicatePattern && (subOperator instanceof Construct || subOperator instanceof Generate))){
          if (!subOperator.getSucceedingOperators().isEmpty()) {
            final OperatorIDTuple temp = subOperator.getSucceedingOperators().get(0);
            subOperator.getSucceedingOperators().set(0,new OperatorIDTuple(finalResult, 0));
            finalResult.addPrecedingOperator(subOperator);
            subOperator.addSucceedingOperator(temp);
          } else {
            subOperator.setSucceedingOperator(new OperatorIDTuple(finalResult, 0));
            finalResult.addPrecedingOperator(subOperator);
          }
        }
      }
    }
    for(int i=0; i<finalResults.length; i++){
      BasicOperator finalResult = finalResults[i];
      if (subOperators.isEmpty()) {
        // Root verweist auf EmptyIndex und der direkt auf Result
        if (finalResult instanceof PredicatePattern || finalResult instanceof TriplePattern) {
          finalResult.removeFromOperatorGraph();
          finalResult = null;
        }
        final EmptyIndexScan empty = new EmptyIndexScan(finalResult == null ? null : new OperatorIDTuple(finalResult, 0));
        this.indexScanCreator.getRoot().addSucceedingOperator(new OperatorIDTuple(empty, this.indexScanCreator.getRoot().getSucceedingOperators().size()));
        empty.addPrecedingOperator(this.indexScanCreator.getRoot());
        if (finalResult == null) {
          finalResults[i] = empty;
        }
      }
    }


    if (this.booleanIndex != null
        && this.booleanIndex.getSucceedingOperators().isEmpty()){
      this.indexScanCreator.getRoot().removeSucceedingOperator(this.booleanIndex);
      this.booleanIndex.removePrecedingOperator(this.indexScanCreator.getRoot());
    }


    if(finalResults.length==1 && (finalResults[0] instanceof Result)){
      return finalResults[0];
    }


    // Falls Conclusion vorhanden, noch Result anhaengen, zum Sammeln der Ergebnisse
    final Result result = new Result();
    final BasicOperator makeBooleanResultOrResult;
    if (obj.getConclusion() != null && obj.getConclusion().getVariables().isEmpty()) {
      makeBooleanResultOrResult = new MakeBooleanResult();
      makeBooleanResultOrResult.addSucceedingOperator(result);
      result.addPrecedingOperator(makeBooleanResultOrResult);
    } else {
      makeBooleanResultOrResult = result;
    }


    for(final BasicOperator finalResult: finalResults){
      // DEBUG
      //finalResult.addSucceedingOperator(finalResult = new Distinct());
      finalResult.addSucceedingOperator(makeBooleanResultOrResult);
      makeBooleanResultOrResult.addPrecedingOperator(finalResult);
    }
    return result;
  }

View Full Code Here

        equalities.add((Equality) expr);
      }
    }


    // 1. Unteroperatorgraph berechnen
    BasicOperator subOperator = (BasicOperator) obj.getBody().accept(this, null);
    for(final OperatorIDTuple opID: subOperator.getSucceedingOperators()){
      opID.getOperator().removePrecedingOperator(subOperator);
    }
    subOperator.getSucceedingOperators().clear();
    // is one of the previous operators a join, which also eliminates duplicates?
    boolean foundJoin = false;
    BasicOperator current = subOperator;
    do {
      if(subOperator instanceof IndexJoinWithDuplicateElimination){
        foundJoin = true;
      } else {
        if(current.getPrecedingOperators().size()!=1){
          // Distinct is necessary!
          break;
        }
        current = current.getPrecedingOperators().get(0);
      }
    } while(!foundJoin);


    if(!foundJoin){
      // add DISTINCT operator in order to avoid infinity loops
      final Distinct distinct = new Distinct();
      subOperator.addSucceedingOperator(distinct);
      distinct.addPrecedingOperator(subOperator);
      subOperator = distinct;
    }


    // add nots under subOperator
    for(final IExpression not: obj.getNots()){
      // TODO check for recursion in not expression and throw error in that case
      // (In the current implementation, negation in rules retrieves reasonable results only for non-recursive rules)
      // first determine operator graph for the not expression:
      final BasicOperator notOperator = (BasicOperator) not.accept(this, null);
      for(final OperatorIDTuple opID: notOperator.getSucceedingOperators()){
        opID.getOperator().removePrecedingOperator(notOperator);
      }
      notOperator.getSucceedingOperators().clear();
      // now add a not operator below subOperator and notOperator!
      // Luckily, the semantics of the not operator is exactly the same as of the minus operator!
      final Minus minus = new Minus(false);
      subOperator.addSucceedingOperator(minus, 0);
      notOperator.addSucceedingOperator(minus, 1);
      minus.addPrecedingOperator(subOperator);
      minus.addPrecedingOperator(notOperator);
      subOperator = minus;
    }

View Full Code Here

    final Set<BasicOperator> operands = new LinkedHashSet<BasicOperator>();
    final Set<BasicIndexScan> indexes = new LinkedHashSet<BasicIndexScan>();
    final List<RuleFilter> predicates = new ArrayList<RuleFilter>();


    for (final IExpression expr : obj.exprs) {
      final BasicOperator op = (BasicOperator) expr.accept(this, arg);
      if (op instanceof RuleFilter) {
        predicates.add((RuleFilter) op);
        continue;
      }
      operands.add(op);
      if (op instanceof BasicIndexScan && !(op instanceof IteratorIndexScan)) {
        indexes.add((BasicIndexScan) op);
      }
    }
    // 1. Mergen von Indexen
    BasicIndexScan mainIndex = null;


    if (indexes.size() > 1) {
      final Iterator<BasicIndexScan> it = indexes.iterator();
      mainIndex = it.next();
      while (it.hasNext()) {
        final BasicIndexScan mergeIndex = it.next();
        mainIndex.getTriplePattern().addAll(mergeIndex.getTriplePattern());
        for(final OperatorIDTuple opID: mergeIndex.getSucceedingOperators()){
          opID.getOperator().removePrecedingOperator(mergeIndex);
        }
        mergeIndex.getSucceedingOperators().clear();
        mergeIndex.removeFromOperatorGraph();
        operands.remove(mergeIndex);
      }
      if(arg!=null){
        mainIndex.setSucceedingOperator((OperatorIDTuple) arg);
        ((OperatorIDTuple) arg).getOperator().addPrecedingOperator(mainIndex);
      }
    }
    // 2. Joins erstellen
    BasicOperator headOperator = null;
    final Iterator<BasicOperator> opIt = operands.iterator();
    if (operands.size() > 1) {
      Join bottomJoin = new IndexJoinWithDuplicateElimination();
      final BasicOperator op1 = opIt.next();
      for(final OperatorIDTuple opID: op1.getSucceedingOperators()){
        opID.getOperator().removePrecedingOperator(op1);
      }
      op1.getSucceedingOperators().clear();
      op1.addSucceedingOperator(new OperatorIDTuple(bottomJoin, 0));
      bottomJoin.addPrecedingOperator(op1);
      final BasicOperator op2 = opIt.next();
      for(final OperatorIDTuple opID: op2.getSucceedingOperators()){
        opID.getOperator().removePrecedingOperator(op2);
      }
      op2.getSucceedingOperators().clear();
      op2.addSucceedingOperator(new OperatorIDTuple(bottomJoin, 1));
      bottomJoin.addPrecedingOperator(op2);
      if(arg!=null){
        bottomJoin.setSucceedingOperator((OperatorIDTuple) arg);
        ((OperatorIDTuple) arg).getOperator().addPrecedingOperator(bottomJoin);
      }
      while (opIt.hasNext()) {
        final Join tempJoin = new IndexJoinWithDuplicateElimination();
        final BasicOperator operand = opIt.next();
        for(final OperatorIDTuple opID: operand.getSucceedingOperators()){
          opID.getOperator().removePrecedingOperator(operand);
        }
        operand.getSucceedingOperators().clear();
        operand.setSucceedingOperator(new OperatorIDTuple(tempJoin, 0));
        tempJoin.addPrecedingOperator(operand);
        for(final OperatorIDTuple opID: bottomJoin.getSucceedingOperators()){
          opID.getOperator().removePrecedingOperator(bottomJoin);
        }
        bottomJoin.getSucceedingOperators().clear();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of lupos.engine.operators.BasicOperator

lupos.datastructures.queryresult.QueryResultDebug

lupos.distributed.operator.format.SubgraphContainerFormatter

lupos.distributed.p2p.rules.JoinSGRule

lupos.distributed.p2p.rules.PartitionSubgraphRule

lupos.engine.evaluators.BasicIndexQueryEvaluator

lupos.engine.evaluators.StreamQueryEvaluator

lupos.engine.operators.index.adaptedRDF3X.RDF3XIndexScan

lupos.engine.operators.messages.BoundVariablesMessage

lupos.engine.operators.messages.Message

lupos.engine.operators.singleinput.filter.expressionevaluation.EvaluationVisitorImplementation

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.