Package lupos.engine.operators.multiinput

Examples of lupos.engine.operators.multiinput.Union


public class RuleFactorOutUnionInJoin extends Rule {

  @Override
  protected void init() {
    final Union union = new Union();
    final Join join = new Join();

    union.setSucceedingOperator(new OperatorIDTuple(join, -1));
    join.setPrecedingOperator(union);

    subGraphMap = new HashMap<BasicOperator, String>();
    subGraphMap.put(union, "union");
    subGraphMap.put(join, "join");
View Full Code Here


  public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
      final Map<String, BasicOperator> mso,
      final BasicOperator rootOperator) {
    final Collection<BasicOperator> deleted = new LinkedList<BasicOperator>();
    final Collection<BasicOperator> added = new LinkedList<BasicOperator>();
    final Union union = (Union) mso.get("union");
    final Join join = (Join) mso.get("join");
    final int id = union.getOperatorIDTuple(join).getId();
    final List<BasicOperator> unionOperands = union.getPrecedingOperators();
    union.setPrecedingOperator(join);
    union.setSucceedingOperators(join.getSucceedingOperators());
    for (final OperatorIDTuple oid : join.getSucceedingOperators()) {
      oid.getOperator().removePrecedingOperator(join);
      oid.getOperator().addPrecedingOperator(union);
    }
    final List<OperatorIDTuple> precedingOperatorsJoin = new LinkedList<OperatorIDTuple>();
    for (final BasicOperator bo : join.getPrecedingOperators()) {
      if (!(bo.equals(union))) {
        precedingOperatorsJoin.add(new OperatorIDTuple(bo, bo
            .getOperatorIDTuple(join).getId()));
      }
    }
    boolean firstTime = true;
    for (final BasicOperator toMove : unionOperands) {
      Join joinNew;
      if (firstTime) {
        // use existing join operator
        joinNew = join;
        joinNew.removePrecedingOperator(union);
        firstTime = false;
      } else {
        // clone join operator plus its other operands
        joinNew = new Join();
        added.add(joinNew);
        union.addPrecedingOperator(joinNew);

        for (final OperatorIDTuple oid : precedingOperatorsJoin) {
          final BasicOperator toClone = oid.getOperator();
          final BasicOperator clone = toClone.clone();
          added.add(clone);
          clone.setSucceedingOperator(new OperatorIDTuple(joinNew,
              oid.getId()));
          joinNew.addPrecedingOperator(clone);
          cloneFurther(clone, toClone, added);
        }

      }
      joinNew.setSucceedingOperator(new OperatorIDTuple(union, union
          .getPrecedingOperators().size() - 1));
      joinNew.addPrecedingOperator(toMove);

      final LinkedList<Variable> intersectionVariables = new LinkedList<Variable>();
      final LinkedList<Variable> unionVariables = new LinkedList<Variable>();
View Full Code Here

public class RuleGenerateAddOverUnion extends Rule {

  @Override
  protected void init() {
    final GenerateAddEnv genAdd = new GenerateAddEnv();
    final Union union = new Union();

    genAdd.setSucceedingOperator(new OperatorIDTuple(union, -1));
    union.setPrecedingOperator(genAdd);

    subGraphMap = new HashMap<BasicOperator, String>();
    subGraphMap.put(genAdd, "genAdd");
    subGraphMap.put(union, "union");
View Full Code Here

  public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
      final Map<String, BasicOperator> mso,
      final BasicOperator rootOperator) {
    final GenerateAddEnv genAdd = (GenerateAddEnv) mso.get("genAdd");
    final Union union = (Union) mso.get("union");

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

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

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

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

    BasicOperator succ;
View Full Code Here

public class RuleReplaceLitOverUnion extends Rule {

  @Override
  protected void init() {
    final ReplaceLit replaceLit = new ReplaceLit();
    final Union union = new Union();

    replaceLit.setSucceedingOperator(new OperatorIDTuple(union, -1));
    union.setPrecedingOperator(replaceLit);

    subGraphMap = new HashMap<BasicOperator, String>();
    subGraphMap.put(replaceLit, "replaceLit");
    subGraphMap.put(union, "union");
View Full Code Here

  @Override
  public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
      final Map<String, BasicOperator> mso,
      final BasicOperator rootOperator) {
    final ReplaceLit replaceLit = (ReplaceLit) mso.get("replaceLit");
    final Union union = (Union) mso.get("union");

    final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) replaceLit
        .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);
View Full Code Here

public class RuleFactorOutUnionInGenerate extends Rule {

  @Override
  protected void init() {
    final Union union = new Union();
    final Generate generate = new Generate();

    union.setSucceedingOperator(new OperatorIDTuple(generate, -1));
    generate.setPrecedingOperator(union);

    subGraphMap = new HashMap<BasicOperator, String>();
    subGraphMap.put(union, "union");
    subGraphMap.put(generate, "generate");
View Full Code Here

  public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
      final Map<String, BasicOperator> mso,
      final BasicOperator rootOperator) {
    final Collection<BasicOperator> deleted = new LinkedList<BasicOperator>();
    final Collection<BasicOperator> added = new LinkedList<BasicOperator>();
    final Union union = (Union) mso.get("union");
    final Generate generate = (Generate) mso.get("generate");
    final List<BasicOperator> unionOperands = union.getPrecedingOperators();
    generate.removePrecedingOperator(union);
    deleted.add(union);
    boolean firstTime = true;
    if (generate.getPrecedingOperators().size() > 0) {
      firstTime = false;
View Full Code Here

      final List<OperatorIDTuple> succs = _indexScan
          .getSucceedingOperators();

      // create union - operation
      final Collection<Variable> v = _indexScan.getIntersectionVariables();
      final Union union = new Union();
      // the succeding of the union of all subgraphs is the succeding of the indexScan
      union.addSucceedingOperators(succs);
      union.setIntersectionVariables(v);
      union.setUnionVariables(v);
     
      /*
       * here we collect all used subgraphs
       */
      Collection<BasicOperator> subgraphs = new ArrayList<BasicOperator>();
     

      /*
       * for each key for the given triple pattern ...
       */
      int countingSubgraphs = 0;
      for (Object key : keys) {
        /*
         * create new inner root
         */
        final Root rootNodeOfSubGraph = rootNodeOfOuterGraph
            .newInstance(rootNodeOfOuterGraph.dataset);
        /*
         * create subgraph
         */
        final SubgraphContainer container = new SubgraphContainer(
            rootNodeOfSubGraph, key, subgraphExecutor);
       
        /*
         * store new basic index scan instead of using it n-times, because same object used
         */
        BasicIndexScan indexScan = new QueryClientIndexScan(_indexScan.getRoot(),_indexScan.getTriplePattern());
       
        /*
         * store variables
         */
        final HashSet<Variable> variables = new HashSet<Variable>(
            _indexScan.getIntersectionVariables());
        container.setUnionVariables(variables);
        container.setIntersectionVariables(variables);

       
        // generate new connections...
        final Filter filter = this.getFilterFromIndexScan(indexScan);
        if (filter != null) {
          if (indexScan.getUnionVariables().containsAll(
              filter.getUsedVariables())) {
            Filter newFilter;
            try {
              newFilter = new Filter(filter.toString().substring(
                  0, filter.toString().length() - 2));
              indexScan
                  .setSucceedingOperator(new OperatorIDTuple(
                      newFilter, 0));
              newFilter
                  .setSucceedingOperator(new OperatorIDTuple(
                      new Result(), 0));
            } catch (final ParseException e) {
              e.printStackTrace();
            }

          } else {
            indexScan.setSucceedingOperator(new OperatorIDTuple(
                new Result(), 0));
          }
        } else {
          indexScan.setSucceedingOperator(new OperatorIDTuple(
              new Result(), 0));
        }

        // indexScan.setSucceedingOperator(new OperatorIDTuple(new
        // Result(),
        // 0));
       
        //connect indexScan in subgraph container
        rootNodeOfSubGraph.setSucceedingOperator(new OperatorIDTuple(
            indexScan, countingSubgraphs));
        rootNodeOfSubGraph.deleteParents();
        rootNodeOfSubGraph.setParents();

        // original connections set at new graph
        /*
         * create Operator for union of all subgraphs
         */
        OperatorIDTuple unionIDOperator = new OperatorIDTuple(union, countingSubgraphs++);
        container.setSucceedingOperator(unionIDOperator);
       
        /*
         * store this subgraph
         */
        subgraphs.add(container);
      }
     
      //connect all subgraphs as predecessor of the new union
      union.addPrecedingOperators(subgraphs);

     
      /*
       * create list of OperatorIDTuples connected to the subgraphs
       */
 
View Full Code Here

  private void transformOperands(final int id,
      final LinkedList<BasicOperator> operands, final Join join,
      final Collection<BasicOperator> added) {
    if (operands.size() > 1) {
      final LinkedList<Variable> vars = new LinkedList<Variable>();
      final Union union = new Union();
      added.add(union);
      union.setSucceedingOperator(new OperatorIDTuple(join, id));
      join.addPrecedingOperator(union);
      int i = 0;
      for (final BasicOperator prec : operands) {
        join.removePrecedingOperator(prec);
        prec.removeSucceedingOperator(join);
        vars.addAll(prec.getUnionVariables());
        prec.addSucceedingOperator(new OperatorIDTuple(union, i));
        i++;
      }
      union.setIntersectionVariables(vars);
      union.setUnionVariables(vars);
    }
  }
View Full Code Here

TOP

Related Classes of lupos.engine.operators.multiinput.Union

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.