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.

    final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) filter
        .getSucceedingOperators();


    final int index = genAdd.getOperatorIDTuple(filter).getId();


    BasicOperator pre;
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);
      pre.addSucceedingOperator(new OperatorIDTuple(filter, index));
      pre.removeSucceedingOperator(genAdd);
      filter.addPrecedingOperator(pre);
    }


    filter.removePrecedingOperator(genAdd);
    filter.setSucceedingOperator(new OperatorIDTuple(genAdd, 0));


    genAdd.setPrecedingOperator(filter);
    genAdd.setSucceedingOperators(succs);


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


    rootOperator.deleteParents();
    rootOperator.setParents();
    rootOperator.detectCycles();

View Full Code Here


public abstract class Window extends TripleOperator implements TripleDeleter {


  public PatternMatcher getPatternMatcher() {
    if (this.getSucceedingOperators().size() == 1) {
      final BasicOperator bo = this.getSucceedingOperators().get(0)
          .getOperator();
      if (bo instanceof PatternMatcher)
        return (PatternMatcher) bo;
    }
    System.out.println("Error in Window-Operator!");

View Full Code Here

                    }
                  };
                  bottomToolBar.setEvaluationThread(thread);
                  thread.start();


                  final BasicOperator root = (evaluator instanceof BasicIndexRuleEvaluator)? ((BasicIndexRuleEvaluator)evaluator).getRootNode() :((CommonCoreQueryEvaluator<Node>) evaluator).getRootNode();


                  this.operatorGraphViewer = new Viewer(
                      new GraphWrapperBasicOperator(
                          root),
                          this.prefixInstance,

View Full Code Here

                      .getPrecedingOperators().get(0),
                      basicOperator.getUnionVariables())) {
                operatorMustReceiveSortedData(root, basicOperator
                    .getPrecedingOperators().get(0),
                    basicOperator.getUnionVariables());
                final BasicOperator newOperator = new SortedDataDistinct();
                newOperator.cloneFrom(basicOperator);
                basicOperator.replaceWith(newOperator);
                return newOperator;
              }


            } else if (basicOperator.getClass() == Join.class) {
              // root.deleteParents();
              // root.setParents();
              // root.detectCycles();
              // root.sendMessage(new BoundVariablesMessage());


              // check if MergeJoinWithoutSorting can be used
              boolean flag = true;
              if (basicOperator.getIntersectionVariables().size() > 0) {
                for (final BasicOperator bo : basicOperator
                    .getPrecedingOperators()) {
                  flag = flag
                  && operatorCanReceiveSortedData(
                      bo,
                      basicOperator
                      .getIntersectionVariables());
                }
              } else {
                flag = false;
              }
              if (flag) {
                final LinkedList<BasicOperator> llbo = new LinkedList<BasicOperator>();
                llbo.addAll(basicOperator.getPrecedingOperators());
                for (final BasicOperator bo : llbo) {
                  operatorMustReceiveSortedData(root, bo,
                      basicOperator
                      .getIntersectionVariables());
                }
                final BasicOperator newOperator = new MergeJoinWithoutSorting();
                newOperator.cloneFrom(basicOperator);
                basicOperator.replaceWith(newOperator);
                return newOperator;
              } else {
                // do not insert SIP operator in cycles!
                if(!(basicOperator.getCycleOperands()!=null && basicOperator.getCycleOperands().size()>0)){
                  // insert SIP operator for joins other than
                  // MergeJoinWithoutSorting!
                  int min = -1;
                  int minIndex = -1;
                  int i = 0;
                  for (final BasicOperator bo : basicOperator
                      .getPrecedingOperators()) {
                    final List<TriplePattern> listTps = determineTriplePatterns(
                        basicOperator,
                        new LinkedList<TriplePattern>(),
                        new HashSet<BasicOperator>());
                    if (listTps.size() > 0) {
                      final TriplePattern tp = listTps.get(0);
                      int current = 0;
                      for (final OperatorIDTuple oid : root
                          .getSucceedingOperators()) {
                        if (oid.getOperator() instanceof BasicIndexScan) {
                          if (((BasicIndexScan) oid.getOperator())
                              .getTriplePattern()
                              .contains(tp)) {
                            if (min == -1 || min > current) {
                              min = current;
                              minIndex = i;
                            }
                          }
                        }
                        current++;
                      }
                    }
                    i++;
                  }
                  if (minIndex > -1) {
                    final BasicOperator bo = basicOperator.getPrecedingOperators().get(minIndex);
                    if (bo != null && bo.getSucceedingOperators().size()==1) {
                      if (!this.severalTimesQueryResults(bo, new HashSet<BasicOperator>())) {
                        List<TriplePattern> tpsOfOthers = null;
                        for (final BasicOperator others : basicOperator
                            .getPrecedingOperators()) {
                          if (!others.equals(bo)) {
                            if (tpsOfOthers == null) {
                              tpsOfOthers = determineTriplePatterns(
                                  others,
                                  new LinkedList<TriplePattern>(),
                                  new HashSet<BasicOperator>());
                            } else {
                              tpsOfOthers
                              .addAll(determineTriplePatterns(
                                  others,
                                  new LinkedList<TriplePattern>(),
                                  new HashSet<BasicOperator>()));
                            }
                          }
                        }
                        this.tpsOfSucceedingJoins(basicOperator, tpsOfOthers);
                        if (tpsOfOthers != null) {
                          final SIPFilterOperator sip_op = (replacements
                              .get(Join.class) == HashMapIndexJoin.class) ? new SIPFilterOperatorIterator(
                                  tpsOfOthers,
                                  basicOperator
                                  .getIntersectionVariables())


                          : new SIPFilterOperator(tpsOfOthers, basicOperator.getIntersectionVariables());


                          final List<Variable> intersectionVariables = new LinkedList<Variable>();
                          final List<Variable> unionVariables = new LinkedList<Variable>();
                          intersectionVariables.addAll(bo.getIntersectionVariables());
                          unionVariables.addAll(bo.getUnionVariables());
                          sip_op.setIntersectionVariables(intersectionVariables);
                          sip_op.setUnionVariables(unionVariables);
                          sip_op.addSucceedingOperators(bo.getSucceedingOperators());
                          sip_op.setPrecedingOperator(bo);
                          bo.setSucceedingOperator(new OperatorIDTuple(sip_op, 0));
                          basicOperator.removePrecedingOperator(bo);
                          basicOperator.addPrecedingOperator(sip_op);
                        }
                      }
                    }
                  }
                }
              }
            } else if (basicOperator.getClass() == Optional.class) {
              // root.deleteParents();
              // root.setParents();
              // root.detectCycles();
              // root.sendMessage(new BoundVariablesMessage());


              // check if MergeWithoutSortingOptional can be used
              boolean flag = true;
              if (basicOperator.getIntersectionVariables().size() > 0) {
                for (final BasicOperator bo : basicOperator
                    .getPrecedingOperators()) {
                  flag = flag
                  && operatorCanReceiveSortedData(
                      bo,
                      basicOperator
                      .getIntersectionVariables());
                }
              } else {
                flag = false;
              }
              if (flag) {
                final LinkedList<BasicOperator> llbo = new LinkedList<BasicOperator>();
                llbo.addAll(basicOperator.getPrecedingOperators());
                for (final BasicOperator bo : llbo) {
                  operatorMustReceiveSortedData(root, bo,
                      basicOperator.getIntersectionVariables());
                }
                final BasicOperator newOperator = new MergeWithoutSortingOptional();
                newOperator.cloneFrom(basicOperator);
                basicOperator.replaceWith(newOperator);
                return newOperator;
              }
            } else if (basicOperator instanceof FastSort) {
              if (basicOperator.getPrecedingOperators().size() == 1
                  && !(basicOperator.getPrecedingOperators().get(0) instanceof SIPFilterOperator)
                      && basicOperator.getSucceedingOperators().size() == 1) {
                if (basicOperator.getSucceedingOperators().get(0)
                    .getOperator() instanceof Join) {
                  final Join join = (Join) basicOperator
                  .getSucceedingOperators().get(0)
                  .getOperator();
                  int min = -1;
                  int minIndex = -1;
                  int i = 0;
                  for (final BasicOperator bo : join
                      .getPrecedingOperators()) {
                    final TriplePattern tp = determineTriplePatterns(
                        join,
                        new LinkedList<TriplePattern>(),
                        new HashSet<BasicOperator>())
                        .get(0);
                    int current = 0;
                    for (final OperatorIDTuple oid : root
                        .getSucceedingOperators()) {
                      if (oid.getOperator() instanceof BasicIndexScan) {
                        if (((BasicIndexScan) oid.getOperator())
                            .getTriplePattern()
                            .contains(tp)) {
                          if (min == -1 || min > current) {
                            min = current;
                            minIndex = i;
                          }
                        }
                      }
                      current++;
                    }
                    i++;
                  }
                  final BasicOperator bo = join.getPrecedingOperators().get(minIndex);
                  if (bo != null
                      && bo instanceof FastSort
                      && bo.getPrecedingOperators().size() == 1
                      && !(bo.getPrecedingOperators().get(0) instanceof SIPFilterOperator)) {
                    if (!this.severalTimesQueryResults(bo,
                        new HashSet<BasicOperator>())) {
                      List<TriplePattern> tpsOfOthers = null;
                      for (final BasicOperator others : join
                          .getPrecedingOperators()) {
                        if (!others.equals(bo)) {
                          if (tpsOfOthers == null) {
                            tpsOfOthers = determineTriplePatterns(
                                others,
                                new LinkedList<TriplePattern>(),
                                new HashSet<BasicOperator>());
                          } else {
                            tpsOfOthers
                            .addAll(determineTriplePatterns(
                                others,
                                new LinkedList<TriplePattern>(),
                                new HashSet<BasicOperator>()));
                          }
                        }
                      }
                      this.tpsOfSucceedingJoins(join, tpsOfOthers);
                      final SIPFilterOperator sip_op =
                        // (replacements
                        // .get(Join.class) ==
                        // HashMapIndexJoin.class) ?
                        new SIPFilterOperatorIterator(
                            tpsOfOthers,
                            join.getIntersectionVariables())
                      // : new
                      // SIPFilterOperator(tpsOfOthers,join
                      // .getIntersectionVariables())
                      ;
                      final List<Variable> intersectionVariables = new LinkedList<Variable>();
                      final List<Variable> unionVariables = new LinkedList<Variable>();
                      intersectionVariables.addAll(bo.getIntersectionVariables());
                      unionVariables.addAll(bo.getUnionVariables());
                      sip_op.setIntersectionVariables(intersectionVariables);
                      sip_op.setUnionVariables(unionVariables);
                      if (bo instanceof FastSort) {
                        final BasicOperator bo2 = bo
                        .getPrecedingOperators()
                        .get(0);
                        sip_op.addSucceedingOperators(bo2
                            .getSucceedingOperators());
                        sip_op.setPrecedingOperator(bo2);
                        bo2
                        .setSucceedingOperator(new OperatorIDTuple(
                            sip_op, 0));
                        bo.removePrecedingOperator(bo2);
                        bo.addPrecedingOperator(sip_op);
                      } else {
                        sip_op.addSucceedingOperators(bo.getSucceedingOperators());
                        sip_op.setPrecedingOperator(bo);
                        bo.setSucceedingOperator(new OperatorIDTuple(sip_op, 0));
                        join.removePrecedingOperator(bo);
                        join.addPrecedingOperator(sip_op);
                      }
                    }
                  }
                }
              }
            } else if (basicOperator instanceof Sort) {
              BasicOperator sortlimit = basicOperator;
              if (basicOperator.getPrecedingOperators().size() == 1) {
                final BasicOperator prec = basicOperator
                .getPrecedingOperators().get(0);
                if (prec instanceof SortLimit) {
                  sortlimit = prec;
                }
              }
              final Collection<Variable> sortCriterium = ((Sort) basicOperator)
              .getSortCriterium();
              boolean flag;
              if (sortCriterium != null
                  && (LiteralFactory.getMapType() != LiteralFactory.MapType.LAZYLITERAL)
                  && (LiteralFactory.getMapType() != LiteralFactory.MapType.LAZYLITERALWITHOUTINITIALPREFIXCODEMAP)) {
                flag = true;
                for (final BasicOperator bo : sortlimit
                    .getPrecedingOperators()) {
                  flag = flag
                  && operatorCanReceiveSortedData(bo,
                      sortCriterium);
                }
              } else {
                flag = false;
              }
              if (flag) {
                final LinkedList<BasicOperator> llbo = new LinkedList<BasicOperator>();
                llbo.addAll(sortlimit.getPrecedingOperators());
                for (final BasicOperator bo : llbo) {
                  bo.removeSucceedingOperator(sortlimit);
                  bo.addSucceedingOperators(basicOperator
                      .getSucceedingOperators());
                  for (final OperatorIDTuple oID : basicOperator
                      .getSucceedingOperators()) {
                    oID.getOperator().removePrecedingOperator(
                        basicOperator);
                    oID.getOperator().addPrecedingOperator(bo);
                  }
                  operatorMustReceiveSortedData(root, bo,
                      sortCriterium);
                }
                return null;
              }
            }
          }
        } catch(final CyclesDuringDeterminationofTriplePatternsException e){
        }


        final Class<? extends BasicOperator> newClass = replacements
        .get(basicOperator.getClass());
        BasicOperator newOperator = basicOperator;
        if (newClass != null) {
          try {
            newOperator = newClass.newInstance();
          } catch (final Exception ex) {
            ex.printStackTrace();
            System.err.println(ex);
          }
          newOperator.cloneFrom(basicOperator);
          basicOperator.replaceWith(newOperator);
          if (basicOperator.getClass() == Join.class
              && newOperator instanceof MergeJoinWithoutSortingSeveralIterations) {
            // Insert necessary sort operators here...
            final LinkedList<BasicOperator> llbo = new LinkedList<BasicOperator>();
            llbo.addAll(newOperator.getPrecedingOperators());
            for (final BasicOperator bo : llbo) {
              final List<Variable> sortCriterium = new LinkedList<Variable>();
              sortCriterium.addAll(basicOperator
                  .getIntersectionVariables());
              if (!(root instanceof PatternMatcher)
                  && !(root instanceof Stream)
                  && operatorCanReceiveSortedData(
                      bo,
                      basicOperator
                      .getIntersectionVariables())) {
                operatorMustReceiveSortedData(root, bo,
                    basicOperator
                    .getIntersectionVariables());
              } else {
                final ImmediateSort immediateSort = new ImmediateSort(
                    sortCriterium);
                final List<Variable> vars = new LinkedList<Variable>();
                vars.addAll(basicOperator
                    .getIntersectionVariables());
                immediateSort.setUnionVariables(vars);
                immediateSort.setIntersectionVariables(vars);
                immediateSort.addPrecedingOperator(bo);
                immediateSort
                .addSucceedingOperator(new OperatorIDTuple(
                    newOperator, bo
                    .getOperatorIDTuple(
                        newOperator)
                        .getId()));
                bo.getOperatorIDTuple(newOperator).setOperator(
                    immediateSort);
                newOperator.removePrecedingOperator(bo);
              }
            }
          }
        }
        return newOperator;
      }


      private void tpsOfSucceedingJoins(final BasicOperator bo,
          List<TriplePattern> tpsOfOthers) throws CyclesDuringDeterminationofTriplePatternsException {
        if (bo.getSucceedingOperators().size() == 1) {
          final BasicOperator sbo = bo.getSucceedingOperators()
          .get(0).getOperator();
          if (sbo instanceof Join) {
            if (sbo.getPrecedingOperators().size() == 2) {
              for (final BasicOperator op : sbo
                  .getPrecedingOperators()) {
                if (!op.equals(bo)) {
                  if (tpsOfOthers == null) {
                    tpsOfOthers = determineTriplePatterns(
                        op,
                        new LinkedList<TriplePattern>(),
                        new HashSet<BasicOperator>());
                  } else {
                    tpsOfOthers
                    .addAll(determineTriplePatterns(
                        op,
                        new LinkedList<TriplePattern>(),
                        new HashSet<BasicOperator>()));
                  }
                }
              }
            }
            this.tpsOfSucceedingJoins(sbo, tpsOfOthers);
          }
        }
      }


      private boolean severalTimesQueryResults(
          final BasicOperator basicOperator,
          final Set<BasicOperator> alreadyVisited) {
        if (alreadyVisited.contains(basicOperator)) {
          // loop detected!
          return true;
        }
        alreadyVisited.add(basicOperator);
        if (basicOperator instanceof Union) {
          if (!(basicOperator instanceof MergeUnion)) {
            return true;
          }
        } else if (basicOperator instanceof BasicIndexScan) {
          return false;
        } else {
          if (basicOperator.getPrecedingOperators() != null) {
            for (final BasicOperator predecessor : basicOperator
                .getPrecedingOperators()) {
              if (this.severalTimesQueryResults(predecessor,
                  alreadyVisited)) {
                return true;
              }
            }
          }
        }
        return false;
      }
    };
    final BasicOperator newRoot = (BasicOperator) op.visit(sogv);


    // now replace any merge joins and merge optionals with maybe their
    // parallel versions...


    final SimpleOperatorGraphVisitor sogvMergeJoinsAndOptionals = new SimpleOperatorGraphVisitor() {
      @Override
      public Object visit(final BasicOperator basicOperator) {
        final Class<? extends BasicOperator> newClass = replacementsMergeJoinAndMergeOptional
        .get(basicOperator.getClass());
        BasicOperator newOperator = basicOperator;
        if (newClass != null) {
          try {
            newOperator = newClass.newInstance();
          } catch (final Exception ex) {
            ex.printStackTrace();
            System.err.println(ex);
          }
          newOperator.cloneFrom(basicOperator);
          basicOperator.replaceWith(newOperator);
        }
        return newOperator;
      }
    };

View Full Code Here

    }
    return false;
  }


  private static BasicOperator getLeftOperand(final BasicOperator bo) {
    BasicOperator result = null;
    for (final BasicOperator boi : bo.getPrecedingOperators()) {
      final OperatorIDTuple oid = boi.getOperatorIDTuple(bo);
      if (oid.getId() == 0) {
        if (result != null) {
          // several left operands currently not supported here!

View Full Code Here

      final LinkedList<BasicOperator> llbo = new LinkedList<BasicOperator>();
      llbo.addAll(basicOperator.getPrecedingOperators());
      for (final BasicOperator before : llbo) {
        operatorMustReceiveSortedData(root, before, sortCriterium);
      }
      final BasicOperator newOperator = new MergeUnion(sortCriterium);
      newOperator.cloneFrom(basicOperator);
      basicOperator.replaceWith(newOperator);
      return true;
    } else if (basicOperator.getClass() == MergeJoinWithoutSorting.class
        || basicOperator.getClass() == MergeWithoutSortingOptional.class
        || basicOperator.getClass() == FastSort.class) {
      // is the input data sorted in the right way?
      boolean flag = true;
      final Iterator<Variable> it_sortCriteriumVars = sortCriterium
      .iterator();
      final Iterator<Variable> it_sortCriteriumJoin =
          (basicOperator.getClass() == FastSort.class) ?
              ((FastSort) basicOperator).getSortCriterium().iterator()
              : basicOperator.getIntersectionVariables().iterator();
      while (it_sortCriteriumJoin.hasNext()) {
        if (!it_sortCriteriumVars.hasNext()) {
          flag = false;
          break;
        }
        final Variable v1 = it_sortCriteriumJoin.next();
        final Variable v2 = it_sortCriteriumVars.next();
        if (!v1.equals(v2)) {
          flag = false;
          break;
        }
      }
      if (it_sortCriteriumVars.hasNext()) {
        flag = false;
      }
      if (flag) {
        return true;
      }
    } else if (basicOperator instanceof Sort) {
      // it has already been checked that it is sorted in the right way!
      return true;
    } else if (basicOperator.getClass() == Optional.class) {
      if(basicOperator.getIntersectionVariables().containsAll(sortCriterium)) {
        if(basicOperator.getPrecedingOperators().size() == 2) {
          final BasicOperator newOperator = new MergeWithoutSortingOptional();
          newOperator.cloneFrom(basicOperator);
          basicOperator.replaceWith(newOperator);
          return   operatorMustReceiveSortedData(root, basicOperator.getPrecedingOperators().get(0), sortCriterium) &&
              operatorMustReceiveSortedData(root, basicOperator.getPrecedingOperators().get(1), sortCriterium);
        }
      }

View Full Code Here


public abstract class ServiceGeneratorToJoinWithOriginal extends ServiceGenerator {
  @Override
  public void insertFederatedQueryOperator(final ASTService node, final OperatorConnection connection){
    SeveralSucceedingOperators sso = new SeveralSucceedingOperators();
    BasicOperator federatedQuery = this.getFederatedQuery(node);
    Node child0 = node.jjtGetChild(0);
    if(child0 instanceof ASTVar){
      Sort sort = new Sort();
      LinkedList<Variable> listOfVars = new LinkedList<Variable>();
      listOfVars.add(new Variable(((ASTVar)child0).getName()));
      ComparatorVariables comparator = new ComparatorVariables(listOfVars);
      sort.setComparator(comparator);
      Group group = new Group(comparator);
      sort.addSucceedingOperator(group);
      group.addSucceedingOperator(federatedQuery);
      sso.addSucceedingOperator(sort);
    } else {
      sso.addSucceedingOperator(federatedQuery);
    }
    Join join = new Join();
    federatedQuery.addSucceedingOperator(join, 1);
    sso.addSucceedingOperator(join, 0);
    connection.connect(join);
    connection.setOperatorConnection(sso);
  }

View Full Code Here

  @Override
  protected void replace(HashMap<Class<?>, HashSet<BasicOperator>> _startNodes) {
    /*
     * just make sure, that the formation in operator graph is right!
     */
    BasicOperator opp = sg1.getPrecedingOperators().size() > 0 ? sg1
        .getPrecedingOperators().get(0) : null;


    /*
     * we just accept subgraphs which succeeding operator is the union
     * operator

View Full Code Here

  private BasicIndexScan getIndexScan(final BasicOperator root) {
    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 BasicIndexScan) {
        return (BasicIndexScan) op;
      } else {
        BasicIndexScan res = null;
        /*

View Full Code Here

                // delete joins which otherwise would have one
                // operand
                for (final TriplePattern tp2 : tps) {
                  for (final OperatorIDTuple oidtuple : tp2
                      .getSucceedingOperators()) {
                    final BasicOperator bo = oidtuple
                    .getOperator();
                    if (bo instanceof Join) {
                      bo.removePrecedingOperator(tp2);
                      if (!bo.equals(tj)) {
                        bo.removeFromOperatorGraph();
                      }
                    }
                  }
                }
              }

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.