import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
@Override
public Op transform(OpJoin opJoin, Op left, Op right) {
	if(left instanceof OpLabel){
		if(right instanceof OpLabel){
			return OpLabel.create(PRUNED ,null);
		}else
		{
			return substitute((Op0) right);
		}
	}else{
		if(right instanceof OpLabel){
			return substitute((Op0) left);
		}
	}
	return substitute(opJoin, left, right);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
public Op compile(Query query) {
    Op pattern = compile(query.getQueryPattern());     // Not compileElement - may need to apply simplification.
    Op op = compileModifiers(query, pattern);
    
    if (query.hasValues()) {
        List<Binding> bindings = query.getValuesData();
        Table table = TableFactory.create();
        for ( Binding binding : bindings )
            table.addBinding(binding);
        OpTable opTable = OpTable.create(table);
        op = OpJoin.create(op, opTable);
    }
    
    return op ;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
@Override
public void visit(OpJoin opJoin) {
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
@Override
public void visit(OpJoin opJoin) {
    SqlOp rightOp = stack.pop();
    SqlOp leftOp = stack.pop();
    stack.push(new SqlJoin(opJoin, leftOp, rightOp, prefixes));
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
public SqlJoin(OpJoin _opJoin, SqlOp _leftOp, SqlOp _rightOp,
		PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opJoin = _opJoin;
	resultName = Tags.JOIN;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
public PigJoin(OpJoin _opJoin, PigOp _leftOp, PigOp _rightOp, PrefixMapping _prefixes) {
    super(_leftOp, _rightOp, _prefixes);
    opJoin = _opJoin;
    resultName = Tags.JOIN;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
@Override
public void visit(OpJoin opJoin) {
	ImpalaOp rightOp = stack.pop();
	ImpalaOp leftOp = stack.pop();
	stack.push(new ImpalaJoin(opJoin, leftOp, rightOp, prefixes));
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
public ImpalaJoin(OpJoin _opJoin, ImpalaOp _leftOp, ImpalaOp _rightOp,
		PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opJoin = _opJoin;
	resultName = Tags.JOIN;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
/**
 * Checks first if a filterexpression can be moved down. And after visits
 * the operator
 */
private void checkMoveDownFilterExprAndVisitOpJoin(OpJoin opJoin) {
	Op left = null;
	Op right = null;
	Op newOp;
	List<Expr> filterExprBeforeOpJoin, filterExprAfterOpJoin, notMoveableFilterExpr;

	// contains the filterexpressions that are valid before this op2
	filterExprBeforeOpJoin = new ArrayList<Expr>(this.filterExpr);
	// contains the filterexpressions that are valid after this op2
	// this is needed because during the bottom-up-stepping all
	// filterexpressions
	// which could not be transformed down, must be inserted by means of an
	// OpFilter
	// above this op2
	filterExprAfterOpJoin = new ArrayList<Expr>();

	// check left subtree
	if ((left = opJoin.getLeft()) != null) {
		// calculate the set of filterexpressions that are also valid for
		// the
		// left subtree
		this.filterExpr = calcValidFilterExpr(filterExprBeforeOpJoin, left);
		filterExprAfterOpJoin.addAll(this.filterExpr);
		// step down
		opJoin.getLeft().visit(this);
		left = stack.pop();
	}

	// check the right subtree
	if ((right = opJoin.getRight()) != null) {
		// calculate the set of filterexpressions that are also valid for
		// the
		// right subtree
		this.filterExpr = calcValidFilterExpr(filterExprBeforeOpJoin, right);
		filterExprAfterOpJoin.addAll(this.filterExpr);
		// step down
		opJoin.getRight().visit(this);
		right = stack.pop();
	}

	// note: filterExprAfterOpUnion contains now all filterexpressions which
	// could
	// be moved down
	// now calculate all filterexpressions which were not moveable
	notMoveableFilterExpr = new ArrayList<Expr>(filterExprBeforeOpJoin);
	notMoveableFilterExpr.removeAll(filterExprAfterOpJoin);

	// if there are some filterexpressions which could not be moved down,
	// an opFilter must be inserted that contains this filterexpressions
	if (!notMoveableFilterExpr.isEmpty()) {
		// create the filter
		newOp = OpFilter.filter(OpJoin.create(left, right));
		// add the conditions
		((OpFilter) newOp).getExprs().getList()
				.addAll(notMoveableFilterExpr);
	} else {
		// nothing must be done
		newOp = opJoin;
	}

	// restore filterexpressions
	this.filterExpr = filterExprBeforeOpJoin;

	this.stack.push(newOp);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
@Override
public Op transform(OpJoin opJoin, Op left, Op right) {
	return mergeToBGP(left, right);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
public JoinRouter(ExecContext context, OpJoin op, 
        OpRouter left, OpRouter right) {
    super(context, op, left, right);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
protected Op join(Op current, Op newOp) { 
    return OpJoin.create(current, newOp);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpJoin; //导入依赖的package包/类
/**
 * When visiting an OpJoin 3 conditions for moving down the filterconditions
 * are checked. Only when a condition is satisfied, the filtercondition can
 * be moved down to the next operator in the tree. Otherwise the condition
 * will stay here and during the bottum-up-stepping an OpFilter containing
 * these remained filterconditions will be inserted in the operator-tree.
 * Conditions for moving down a filtercondition: (M1, M2 are graphpatterns,
 * F is a filtercondition) 1) Filter(Join(M1, M2), F)) will become
 * Join(Filter(M1, F), M2) when the filterexpression is only referenced to
 * M1 2) Filter(Join(M1, M2), F)) will become Join(M1, Filter(M2, F)) when
 * the filterexpression is only referenced to M2 3) Filter(Join(M1, M2), F))
 * will become Join(Filter(M1, F), Filter(M2, F)) when the filterexpression
 * is referenced to M1 and M2
 */
public void visit(OpJoin opJoin) {
	checkMoveDownFilterExprAndVisitOpJoin(opJoin);
}