Package lupos.engine.operators

Examples of lupos.engine.operators.BasicOperator


                            return true;
                        }
                    }
                }
           
                BasicOperator nextOp = filterOutestFilter.getPrecedingOperators().get(0);
           
                if(nextOp.equals(this.o1)) {
                    checkFurther = false;
                }
                else {
                    filterOutestFilter = (lupos.engine.operators.singleinput.filter.Filter) nextOp;
                }
View Full Code Here


    final List<OperatorIDTuple> succs = root.getSucceedingOperators();
    if (succs == null | succs.size() == 0) {
      return null;
    }
    for (final OperatorIDTuple succ : succs) {
      final BasicOperator op = succ.getOperator();
      if (op instanceof Result) {
        return (Result) op;
      } else {
        Result res = null;
        if ((res = this.getResult(op)) != null) {
View Full Code Here

       
        HashSet<lupos.datastructures.items.Variable> unionVariables = new HashSet<lupos.datastructures.items.Variable>();
        unionVariables.addAll(this.o1.getUnionVariables());
        unionVariables.addAll(this.o2.getUnionVariables());
       
        BasicOperator tmpOp = j;
       
        while(!tmpOp.equals(this.opt)) {
            tmpOp.setUnionVariables(unionVariables);
            tmpOp.setIntersectionVariables(intersectionVariables);
       
            tmpOp = tmpOp.getSucceedingOperators().get(0).getOperator();
        }
       
        this.opt.setUnionVariables(unionVariables);
        this.opt.setIntersectionVariables(intersectionVariables);
    }
View Full Code Here

        .getPrecedingOperators();
    final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) projection
        .getSucceedingOperators();
    final int index = replaceLit.getOperatorIDTuple(projection).getId();

    BasicOperator pre;
    // Connect the ReplaceLit precessors directly to the Projection
    for (int i = pres.size() - 1; i >= 0; i--) {
      pre = pres.get(i);
      projection.addPrecedingOperator(pre);
      pre.removeSucceedingOperator(replaceLit);
      pre.addSucceedingOperator(new OperatorIDTuple(projection, index));
    }

    // Make ReplaceLit the successor of Projection
    projection.removePrecedingOperator(replaceLit);
    projection.setSucceedingOperator(new OperatorIDTuple(replaceLit, 0));

    replaceLit.setPrecedingOperator(projection);

    final HashSet<Variable> hsv = new HashSet<Variable>();
    hsv.addAll(projection.getIntersectionVariables());
    replaceLit.setIntersectionVariables(hsv);
    replaceLit.setUnionVariables(hsv);

    // Connect ReplaceLit to the Projections successors instead of him
    replaceLit.setSucceedingOperators(succs);
    BasicOperator succ;
    for (int i = succs.size() - 1; i >= 0; i--) {
      succ = succs.get(i).getOperator();
      succ.removePrecedingOperator(projection);
      succ.addPrecedingOperator(replaceLit);
    }

    rootOperator.deleteParents();
    rootOperator.setParents();
    rootOperator.detectCycles();
View Full Code Here

                break;
            }

            // --- handle JumpOver - begin ---
            this.j_end = _precOp_1_0;
            BasicOperator _searchIndex_1_0 = _precOp_1_0;
            boolean _continueFlag_1_0 = false;

            while(_searchIndex_1_0 != null && (_searchIndex_1_0.getClass() == lupos.engine.operators.singleinput.filter.Filter.class)) {
                if(_searchIndex_1_0.getClass() != lupos.engine.operators.singleinput.filter.Filter.class) {
                    _continueFlag_1_0 = true;
                    break;
                }

                if(_searchIndex_1_0.getSucceedingOperators().size() != 1 || _searchIndex_1_0.getPrecedingOperators().size() != 1) {
                    _continueFlag_1_0 = true;
                    break;
                }

                _searchIndex_1_0 = _searchIndex_1_0.getPrecedingOperators().get(0);
            }

            if(_continueFlag_1_0) {
                continue;
            }

            this.j_begin = _searchIndex_1_0.getSucceedingOperators().get(0).getOperator();
            // --- handle JumpOver - end ---


            final List<BasicOperator> _precedingOperators_2_0 = this.j_begin.getPrecedingOperators();
View Full Code Here

                return flag;
            }

            if(this.op instanceof lupos.engine.operators.multiinput.optional.Optional || this.op instanceof lupos.engine.operators.multiinput.optional.parallel.ParallelOptional || this.op instanceof lupos.engine.operators.multiinput.optional.parallel.MergeParallelOptional) {
                if(this.op.getPrecedingOperators().size() == 2) {
                    final BasicOperator o = this.op.getPrecedingOperatorWithID(0);

                    if(o.getUnionVariables().containsAll(this.f.getUsedVariables()) && !(o instanceof lupos.engine.operators.singleinput.filter.Filter && this.f.equalFilterExpression((lupos.engine.operators.singleinput.filter.Filter) o))) {
                    return true;
                    }
                }

                return false;
            }

            if(this.op instanceof lupos.engine.operators.multiinput.join.Join) {
                // check if the join has preceding this.ops in a loop
                if(this.op.getCycleOperands() != null && this.op.getCycleOperands().size() > 0) {
                    return false;
                }
            }

            for(final BasicOperator o : this.op.getPrecedingOperators()) {
                if(o.getSucceedingOperators().size() == 1 && o.getUnionVariables().containsAll(this.f.getUsedVariables()) && !(o instanceof lupos.engine.operators.singleinput.filter.Filter && this.f.equalFilterExpression((lupos.engine.operators.singleinput.filter.Filter) o))) {
                    return true;
                }
            }

            return false;
View Full Code Here

    super();
  }

  @Override
  protected boolean checkPrecondition(final Map<String, BasicOperator> mso) {
    BasicOperator operator = mso.get("operator");
    final Filter filter = (Filter) mso.get("filter");
    while (operator instanceof Filter) {
      if (operator.getPrecedingOperators().size() > 1
          || operator.getSucceedingOperators().size() > 1)
        return false;
      operator = operator.getPrecedingOperators().get(0);
    }
    if (operator.getSucceedingOperators().size() > 1)
      return false;
    if (operator instanceof TriplePattern
        || operator instanceof lupos.engine.operators.index.BasicIndexScan
        || operator instanceof lupos.engine.operators.index.Root)
      return false;
    if (operator instanceof Union) {
      for (final BasicOperator o : operator.getPrecedingOperators())
        if (o.getSucceedingOperators().size() > 1
            || !(o.getUnionVariables().containsAll(
                filter.getUsedVariables()) && !(o instanceof Filter && filter
                .equalFilterExpression((Filter) o))))
          return false;
      return true;
    }
    if (operator instanceof Optional) {
      if (operator.getPrecedingOperators().size() == 2) {
        BasicOperator o = operator.getPrecedingOperators().get(0);
        if (// o.getSucceedingOperators().size() == 1 &&
        o.getUnionVariables().containsAll(filter.getUsedVariables())
            && !(o instanceof Filter && filter
                .equalFilterExpression((Filter) o))) {
          o = operator.getPrecedingOperators().get(1);
          if (// o.getSucceedingOperators().size() == 1 &&
          o.getUnionVariables()
              .containsAll(filter.getUsedVariables())
              && !(o instanceof Filter && filter
                  .equalFilterExpression((Filter) o)))
            return true;
        }
      }
      return false;
    }
    if (operator instanceof Join) {
      // check if the join has preceding operators in a loop
      if (operator.getCycleOperands() != null
          && operator.getCycleOperands().size() > 0)
        return false;
    }
    for (final BasicOperator o : operator.getPrecedingOperators()) {
      if (o.getSucceedingOperators().size() == 1
          && o.getUnionVariables().containsAll(
              filter.getUsedVariables())
          && !(o instanceof Filter && filter
              .equalFilterExpression((Filter) o)))
        return true;
    }
View Full Code Here

        // additional replace method code...
        boolean deleteFilter = true;

        for(int i = 0; i < this.o.length; i += 1) {
            final BasicOperator o2 = this.o[i];

            if(!(o2 instanceof lupos.engine.operators.singleinput.filter.Filter && this.f.equalFilterExpression((lupos.engine.operators.singleinput.filter.Filter) o2))) {
                if(o2.getUnionVariables().containsAll(this.f.getUsedVariables())) {
                    f_new[i].setIntersectionVariables(new HashSet<lupos.datastructures.items.Variable>(o2.getUnionVariables()));
                    f_new[i].setUnionVariables(new HashSet<lupos.datastructures.items.Variable>(o2.getUnionVariables()));
                    f_new[i].setNodePointer(this.f.getNodePointer());
                    f_new[i].setCollectionForExistNodes(this.f.getCollectionForExistNodes());
                    f_new[i].getUsedEvaluationVisitor().setEvaluator(this.f.getUsedEvaluationVisitor().getEvaluator());
                } else {
                    if(deleteFilter) {
                        for(final lupos.datastructures.items.Variable v : o2.getUnionVariables()) {
                            if(this.f.getUsedVariables().contains(v)) {
                                deleteFilter = false;

                                break;
                            }
View Full Code Here

      final Map<String, BasicOperator> mso,
      final BasicOperator rootOperator) {
    final Collection<BasicOperator> deleted = new LinkedList<BasicOperator>();
    final Collection<BasicOperator> added = new LinkedList<BasicOperator>();
   
    BasicOperator operator = mso.get("operator");
    final Filter filter = (Filter) mso.get("filter");

    while (operator instanceof Filter)
      operator = operator.getPrecedingOperators().get(0);
    boolean deleteFilter = true;
    boolean change = true;
    while (change) {
      deleteFilter = true;
      change = false;
      if (operator.getPrecedingOperators() != null) {
        for (final BasicOperator o : operator.getPrecedingOperators()) {
          if (!(o instanceof Filter && filter
              .equalFilterExpression((Filter) o))) {
            if (o.getUnionVariables().containsAll(
                filter.getUsedVariables())) {
              // System.out.println("TTTTTTTTTTTTTbefore:"+o.
              // graphString
              // ());
              final Filter filter2 = (Filter) filter.clone();
              added.add(filter2);
              final OperatorIDTuple oit = o
                  .getOperatorIDTuple(operator);
              filter2.setSucceedingOperator(new OperatorIDTuple(
                  operator, oit.getId()));
              final HashSet<Variable> hsv = new HashSet<Variable>();
              hsv.addAll(o.getIntersectionVariables());
              filter2.setIntersectionVariables(hsv);
              filter2.setUnionVariables(hsv);
              // System.out.println("TTTTTTTTTTTTToit:"+oit);
              o.replaceOperatorIDTuple(oit, new OperatorIDTuple(
                  filter2, 0));
              operator
                  .setPrecedingOperators(new LinkedList<BasicOperator>());
              //System.out.println("TTTTTTTTTTTTT"+o.graphString()
              // );
              rootOperator.deleteParents();
              rootOperator.setParents();
              rootOperator.detectCycles();
              // should have been done manually:
              // rootOperator.sendMessage(new
              // BoundVariablesMessage());
              change = true;
              break;
            } else {
              if (deleteFilter) {
                for (final Variable v : o.getUnionVariables())
                  if (filter.getUsedVariables().contains(v)) {
                    deleteFilter = false;
                    break;
                  }
              }
            }
          }
        }
      }
    }
    if (deleteFilter || operator instanceof Join) {
      final BasicOperator op2 = filter.getPrecedingOperators().get(0);
      op2.setSucceedingOperators(filter.getSucceedingOperators());
      rootOperator.deleteParents();
      rootOperator.setParents();
      rootOperator.sendMessage(new BoundVariablesMessage());
      deleted.add(filter);
    }
View Full Code Here

        .getPrecedingOperators();
    final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) union
        .getSucceedingOperators();
    final int index = replaceLit.getOperatorIDTuple(union).getId();

    BasicOperator pre;
    // Connect the precessors of the ReplaceLit directly to the Union
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);
      union.addPrecedingOperator(pre);
      pre.removeSucceedingOperator(replaceLit);
      pre.addSucceedingOperator(new OperatorIDTuple(union, index));
    }
    union.removePrecedingOperator(replaceLit);

    // ReplaceLit becomes the new sucessor of Union
    union.setSucceedingOperator(new OperatorIDTuple(replaceLit, 0));

    // ReplaceLit gets the joins old sucessors
    replaceLit.setPrecedingOperator(union);
    replaceLit.setSucceedingOperators(succs);

    BasicOperator succ;
    for (int i = 0; i < succs.size(); i++) {
      succ = succs.get(i).getOperator();
      succ.removePrecedingOperator(union);
      succ.addPrecedingOperator(replaceLit);
    }

    rootOperator.deleteParents();
    rootOperator.setParents();
    rootOperator.detectCycles();
View Full Code Here

TOP

Related Classes of lupos.engine.operators.BasicOperator

Copyright © 2018 www.massapicom. All rights reserved.
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.