import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
@Override
public Op transform(OpUnion opUnion, 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(opUnion, left, right);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
public SparkUnion(OpUnion op) {
this.op = op;
   }
 

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
@Override
   public void visit(OpUnion opUnion) {
executionQueue.add(new SparkUnion(opUnion));
   }
 

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

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
public SQLUnion(OpUnion _opUnion, SqlOp _leftOp, SqlOp _rightOp,
		PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opUnion = _opUnion;
	resultName = Tags.UNION;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
public PigUnion(OpUnion _opUnion, PigOp _leftOp, PigOp _rightOp, PrefixMapping _prefixes) {
    super(_leftOp, _rightOp, _prefixes);
    opUnion = _opUnion;
    resultName = Tags.UNION;
}
 

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

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
public ImpalaUnion(OpUnion _opUnion, ImpalaOp _leftOp, ImpalaOp _rightOp,
		PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opUnion = _opUnion;
	resultName = Tags.UNION;
}
 

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

	// contains the filterexpressions that are valid before this op2
	filterExprBeforeOpUnion = 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
	filterExprAfterOpUnion = new ArrayList<Expr>();

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

	// check the right subtree
	if ((right = opUnion.getRight()) != null) {
		// calculate the set of filterexpressions that are also valid for
		// the
		// right subtree
		this.filterExpr = calcValidFilterExpr(filterExprBeforeOpUnion,
				right);
		filterExprAfterOpUnion.addAll(this.filterExpr);
		// step down
		opUnion.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>(filterExprBeforeOpUnion);
	notMoveableFilterExpr.removeAll(filterExprAfterOpUnion);

	// 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(OpUnion.create(left, right));
		// add the conditions
		((OpFilter) newOp).getExprs().getList()
				.addAll(notMoveableFilterExpr);
	} else {
		newOp = opUnion;
	}

	// restore filterexpressions
	this.filterExpr = filterExprBeforeOpUnion;

	this.stack.push(newOp);
}
 

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

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

import com.hp.hpl.jena.sparql.algebra.op.OpUnion; //导入依赖的package包/类
/**
 * When visiting an OpUnion also 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(Union(M1, M2),
 * F)) will become Union(Filter(M1, F), M2) when the filterexpression is
 * only referenced to M1 2) Filter(Union(M1, M2), F)) will become Union(M1,
 * Filter(M2, F)) when the filterexpression is only referenced to M2
 * 
 * TODO: Dubious! Shouldn't this be Union(Filter(M1,F), Filter(M2,F))? What
 * does the code actually do?
 * 
 * 3) Filter(Union(M1, M2), F)) will become Join(Union(M1, F), Union(M2, F))
 * when the filterexpression is referenced to M1 and M2
 */
public void visit(OpUnion opUnion) {
	checkMoveDownFilterExprAndVisitOpUnion(opUnion);
}