Java Join.getRightArg方法代码示例

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(final Join node) throws Exception {
    super.meet(node);

    final TupleExpr leftArg = node.getLeftArg();
    final TupleExpr rightArg = node.getRightArg();

    /**
     * if join(join(1, 2), join(3,4))
     * should be:
     * join(join(join(1,2), 3), 4)
     */
    if (leftArg instanceof Join && rightArg instanceof Join) {
        final Join leftJoin = (Join) leftArg;
        final Join rightJoin = (Join) rightArg;
        final TupleExpr right_LeftArg = rightJoin.getLeftArg();
        final TupleExpr right_rightArg = rightJoin.getRightArg();
        final Join inner = new Join(leftJoin, right_LeftArg);
        final Join outer = new Join(inner, right_rightArg);
        node.replaceWith(outer);
    }

}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(final Filter node) throws Exception {
    super.meet(node);

    final ValueExpr condition = node.getCondition();
    final TupleExpr arg = node.getArg();
    if (!(arg instanceof Join)) {
        return;
    }

    final Join join = (Join) arg;
    final TupleExpr leftArg = join.getLeftArg();
    final TupleExpr rightArg = join.getRightArg();

    if (leftArg instanceof StatementPattern && rightArg instanceof StatementPattern) {
        final Filter left = new Filter(leftArg, condition);
        final Filter right = new Filter(rightArg, condition);
        node.replaceWith(new Join(left, right));
    }

}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
    public void meet(final Join node) {
      node.getLeftArg().visit(this);
      final double leftArgCost = cardinality;
      // System.out.println("Left cardinality is " + cardinality);
      node.getRightArg().visit(this);

      if (node.getLeftArg() instanceof FixedStatementPattern && node.getRightArg() instanceof DoNotExpandSP) {
        return;
      }

      try {
        final double selectivity = selectEvalStatsDAO.getJoinSelect(config, node.getLeftArg(), node.getRightArg());
//        System.out.println("CardCalc: left cost of " + node.getLeftArg() + " is " + leftArgCost + " right cost of "
//        + node.getRightArg() + " is " + cardinality);
//         System.out.println("Right cardinality is " + cardinality);
        cardinality += leftArgCost + leftArgCost * cardinality * selectivity;
//        System.out.println("CardCalc: Cardinality is " + cardinality);
//        System.out.println("CardCalc: Selectivity is " + selectivity);
        // System.out.println("Join cardinality is " + cardinality);

      } catch (final Exception e) {
        e.printStackTrace();
      }

    }
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Test
public void testComplexJoin() throws Exception {
    StatementPattern isUndergrad = new StatementPattern(new Var("x"), constant(RDF.TYPE), constant(UNDERGRAD));
    StatementPattern isProfessor = new StatementPattern(new Var("y"), constant(RDF.TYPE), constant(PROFESSOR));
    StatementPattern takesCourse = new StatementPattern(new Var("x"), constant(TAKES), new Var("c"));
    StatementPattern teachesCourse = new StatementPattern(new Var("y"), constant(TEACHES), new Var("c"));
    QueryRoot queryTree = new QueryRoot(new Join(
            new Join(isUndergrad, takesCourse),
            new Join(isProfessor, teachesCourse)));
    SparqlToPipelineTransformVisitor visitor = new SparqlToPipelineTransformVisitor(collection);
    queryTree.visit(visitor);
    Assert.assertTrue(queryTree.getArg() instanceof Join);
    Join topJoin = (Join) queryTree.getArg();
    Assert.assertTrue(topJoin.getLeftArg() instanceof AggregationPipelineQueryNode);
    Assert.assertTrue(topJoin.getRightArg() instanceof AggregationPipelineQueryNode);
    AggregationPipelineQueryNode leftPipeline = (AggregationPipelineQueryNode) topJoin.getLeftArg();
    AggregationPipelineQueryNode rightPipeline = (AggregationPipelineQueryNode) topJoin.getRightArg();
    Assert.assertEquals(Sets.newHashSet("x", "c"), leftPipeline.getAssuredBindingNames());
    Assert.assertEquals(Sets.newHashSet("y", "c"), rightPipeline.getAssuredBindingNames());
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
private boolean isJoinValid(Join join) {

        Set<String> leftBindingNames = join.getLeftArg().getBindingNames();
        Set<String> rightBindingNames = join.getRightArg().getBindingNames();

        
        //System.out.println("Left binding names are " + leftBindingNames + " and right binding names are " + rightBindingNames);
        
        if (Sets.intersection(leftBindingNames, rightBindingNames).size() == 0) {
            if (omitCrossProd) {
                return false;
            } else {
                return true;
            }

        } else {
            if (join.getRightArg() instanceof ExternalTupleSet) {

                return ((ExternalTupleSet) join.getRightArg()).supportsBindingSet(leftBindingNames);

            } else {
                return true;
            }
        }

    }
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(Join node) {

          if (compSet.contains(node.getRightArg())) {
              this.toBeReplaced = node.getRightArg();
              node.replaceChildNode(node.getRightArg(), replacement);
              return;
          } else if (compSet.contains(node.getLeftArg())) {
              this.toBeReplaced = node.getLeftArg();
              node.replaceChildNode(node.getLeftArg(), replacement);
              return;
          } else {
              super.meet(node);
          }

      }
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(Join node) {
    try {
        if (node.getLeftArg() instanceof FixedStatementPattern && node.getRightArg() instanceof DoNotExpandSP) {
            return;
        }
        List<TupleExpr> joinArgs = getJoinArgs(node, new ArrayList<TupleExpr>());
        HashMultimap<String, StatementPattern> varMap = getVarBins(joinArgs);
        while (!varMap.keySet().isEmpty()) {
            String s = getHighestPriorityKey(varMap);
            constructTuple(varMap, joinArgs, s);
        }
        List<TupleExpr> filterChain = getFilterChain(joinArgs);

        for (TupleExpr te : joinArgs) {
            if (!(te instanceof StatementPattern) || !(te instanceof EntityTupleSet)) {
                te.visit(this);
            }
        }
        // Replace old join hierarchy
        node.replaceWith(getNewJoin(joinArgs, filterChain));

    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(Join join) throws RuntimeException {
	
	boolean valid = true;
	
	// visit join arguments and check that all are valid BGPS
	for (TupleExpr expr : new TupleExpr[] { join.getLeftArg(), join.getRightArg() }) {
		expr.visit(this);
		if (lastBGPNode == null) {
			// child is not a BGP -> join is not a BGP
			valid = false;
		} else {
			if (!valid) {
				// last child is a BGP but another child was not
				this.bgpList.add(lastBGPNode);
				lastBGPNode = null;
			}
		}
	}
	if (valid)
		lastBGPNode = join;
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(final Join node) {
    // Extract the metadata that will be stored from the node.
    final String joinNodeId = nodeIds.getOrMakeId(node);
    final QueryModelNode left = node.getLeftArg();
    final QueryModelNode right = node.getRightArg();

    // Update the metadata for the JoinMetadata.Builder.
    makeJoinMetadata(joinNodeId, JoinType.NATURAL_JOIN, left, right);

    // Walk to the next node.
    super.meet(node);
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
@Override
public void meet(final Join n) {
    final List<StatementPattern> bgp = getBGP(n);
    if (bgp != null) {
        emit(bgp);
    } else {
        final TupleExpr l = n.getLeftArg();
        final TupleExpr r = n.getRightArg();
        final boolean norpar = r instanceof Join || r instanceof StatementPattern
                || r instanceof SingletonSet || r instanceof Service || r instanceof Union
                || r instanceof BindingSetAssignment || r instanceof ArbitraryLengthPath;
        emit(l).newline().emit(r, !norpar);
    }
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
private boolean oneLine(Join join) throws QueryEvaluationException {
	TupleExpr la = join.getLeftArg();
	TupleExpr ra = join.getRightArg();
	if (la instanceof StatementPattern && ra instanceof StatementPattern) {
		StatementPattern lp = (StatementPattern) la;
		StatementPattern rp = (StatementPattern) ra;
		if (lp.getSubjectVar().equals(rp.getSubjectVar())
				&& allowAblePredicate(lp.getPredicateVar())
				&& allowAblePredicate(rp.getPredicateVar()))
			return true;
	}
	return false;
}
 

import org.openrdf.query.algebra.Join; //导入方法依赖的package包/类
public BEDFileBindingReader(File file, BindingSet bindings, Join join,
		ValueFactory valueFactory) {
	StatementPattern left = (StatementPattern) join.getLeftArg();
	StatementPattern right = (StatementPattern) join.getRightArg();
	queue = new ArrayBlockingQueue<BindingSet>(1000);
	runner = new BindingReaderRunner(file, queue, left, right,
			valueFactory, bindings);
	exec.submit(runner);
}