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

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
protected Op compileElementOptional(ElementOptional eltOpt, Op current) {
    Element subElt = eltOpt.getOptionalElement();
    Op op = compileElement(subElt);
    
    ExprList exprs = null;
    if (op instanceof OpFilter) {
        OpFilter f = (OpFilter)op;
        //f = OpFilter.tidy(f) ;  // Collapse filter(filter(..))
        Op sub = f.getSubOp();
        if (sub instanceof OpFilter)
            broken("compile/Optional/nested filters - unfinished") ; 
        exprs = f.getExprs();
        op = sub;
    }
    current = OpLeftJoin.create(current, op, exprs);
    return current;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
@Override
   protected void visitLeftJoin(OpLeftJoin op) {
if (op.getLeft() != null)
    op.getLeft().visit(this);
if (op.getRight() != null)
    op.getRight().visit(this);
op.visit(visitor);
   }
 

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
@Override
   public void visit(OpLeftJoin opLeftJoin) {
executionQueue.add(new SparkLeftJoin(opLeftJoin, prefixes));
if (opLeftJoin.getExprs() != null) {
    addExpressionsToBGPLeftJoin(opLeftJoin.getExprs());
}
   }
 

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
public SparkLeftJoin(OpLeftJoin op, PrefixMapping prefixes) {
this.op = op;
this.prefixes = prefixes;
   }
 

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

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
public SqlLeftJoin(OpLeftJoin _opLeftJoin, SqlOp _leftOp,
		SqlOp _rightOp, PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opLeftJoin = _opLeftJoin;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
public PigLeftJoin(OpLeftJoin _opLeftJoin, PigOp _leftOp, PigOp _rightOp, PrefixMapping _prefixes) {
    super(_leftOp, _rightOp, _prefixes);
    opLeftJoin = _opLeftJoin;
    resultName = Tags.LEFT_JOIN;
}
 

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

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
public ImpalaLeftJoin(OpLeftJoin _opLeftJoin, ImpalaOp _leftOp,
		ImpalaOp _rightOp, PrefixMapping _prefixes) {
	super(_leftOp, _rightOp, _prefixes);
	opLeftJoin = _opLeftJoin;
}
 

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

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
@Override
public Op applyConstraint(Op op, Var reason) {
	
	logger.debug("Applying constraint with value='" + this.getValue() + "' and expression=" + this.getExpression());
	
	if (value == null || value.isEmpty()) {
		return op;
	}


	Node rdfsLabel = RDFS.label.asNode();

	Var reasonLabel = Var.alloc("reasonlabel");
	Expr reasonLabelExpr = new ExprVar(reasonLabel);

	Expr reasonExpr = new ExprVar(reason);
	
	// create Triple
	BasicPattern optionalPattern = new BasicPattern();

	// ?source rdfs:label ?sourcelabel.
	optionalPattern
			.add(Triple.create(reason, rdfsLabel, reasonLabel));

	
	op = OpLeftJoin.create(op, new OpBGP(optionalPattern),new ExprList());

	Expr filter = new E_Conditional(
			new E_IsIRI(reasonExpr),
			reasonLabelExpr,
			reasonExpr);
	
	filter = this.getExpression().getFilter(filter, value);
	if (filter == null) {
		return op;
	}
	
	return OpFilter.filter(filter, op);

}
 

import com.hp.hpl.jena.sparql.algebra.op.OpLeftJoin; //导入依赖的package包/类
/**
 * When visiting an OpJoin 2 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(LeftJoin(M1, M2), F)) will become
 * LeftJoin(Filter(M1, F), M2) when the filterexpression is only referenced
 * to M1 2) Filter(LeftJoin(M1, M2), F)) will become LeftJoin(Filter(M1, F),
 * Filter(M2, F)) when the filterexpression is referenced to M1 and M2
 */
public void visit(OpLeftJoin opLeftJoin) {
	checkMoveDownFilterExprAndVisitOpLeftJoin(opLeftJoin);
}