Java Union类代码示例

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * Construct a SELECT query for a grouped bound check.
 * 
 * Pattern:
 * 
 * SELECT DISTINCT ?o_1 .. ?o_N WHERE { { s1 p1 ?o_1 FILTER ?o_1=o1 } UNION ... UNION { sN pN ?o_N FILTER ?o_N=oN }}
 * 
 * @param stmt
 * @param unionBindings
 * @return
 */
public static TupleExpr selectQueryStringBoundCheck(StatementPattern stmt, List<BindingSet> unionBindings) {
	
	Set<String> varNames = new HashSet<String>();
	
	Union union = new Union();
	union.setLeftArg(constructStatementCheckId(stmt, 0, varNames, unionBindings.get(0)) );
	Union tmp = union;
	int idx;
	for (idx=1; idx<unionBindings.size()-1; idx++) {
		Union _u = new Union();
		_u.setLeftArg( constructStatementCheckId(stmt, idx, varNames, unionBindings.get(idx)) );
		tmp.setRightArg(_u);
		tmp = _u;
	}
	tmp.setRightArg( constructStatementCheckId(stmt, idx, varNames, unionBindings.get(idx) ));
	
	ProjectionElemList projList = new ProjectionElemList();
	for (String var : varNames)
		projList.addElement( new ProjectionElem(var));
	
	Projection proj = new Projection(union, projList);

	return proj;
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
protected static Union constructInnerUnion(StatementPattern stmt, int outerID, Set<String> varNames, List<BindingSet> bindings) {
	
	Union union = new Union();
	union.setLeftArg(constructStatementId(stmt, outerID + "_0", varNames, bindings.get(0)) );
	Union tmp = union;
	int idx;
	for (idx=1; idx<bindings.size()-1; idx++) {
		Union _u = new Union();
		_u.setLeftArg( constructStatementId(stmt, outerID + "_" + idx, varNames, bindings.get(idx)) );
		tmp.setRightArg(_u);
		tmp = _u;
	}
	tmp.setRightArg( constructStatementId(stmt, outerID + "_" + idx, varNames, bindings.get(idx)));
	
	return union;
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
@Override
protected void meetNode(QueryModelNode node) {
	if (node instanceof StatementPattern) {
		meet((StatementPattern)node);
	} else if (node instanceof Filter) {
		meet((Filter)node);
	} else if (node instanceof Union) {
		meet((Union)node);
	} else if (node instanceof ExclusiveGroup) {
		meet((ExclusiveGroup)node);
	} else if (node instanceof NJoin) {
		meet((NJoin)node);
	} else {
		super.meetNode(node);
	}
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * Evaluate {@link BinaryTupleOperator} query model nodes
 * @param parent
 * @param expr
 * @param bindings
 */
private void evaluateBinaryTupleOperator(BindingSetPipe parent, BinaryTupleOperator expr, BindingSet bindings) {
    if (expr instanceof Join) {
        evaluateJoin(parent, (Join) expr, bindings);
    } else if (expr instanceof LeftJoin) {
        evaluateLeftJoin(parent, (LeftJoin) expr, bindings);
    } else if (expr instanceof Union) {
        evaluateUnion(parent, (Union) expr, bindings);
    } else if (expr instanceof Intersection) {
        evaluateIntersection(parent, (Intersection) expr, bindings);
    } else if (expr instanceof Difference) {
        evaluateDifference(parent, (Difference) expr, bindings);
    } else if (expr == null) {
        parent.handleException(new IllegalArgumentException("expr must not be null"));
    } else {
        parent.handleException(new QueryEvaluationException("Unsupported binary tuple operator type: " + expr.getClass()));
    }
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * Evaluate {@link Union} query model nodes.
 * @param parent
 * @param union
 * @param bindings
 */
private void evaluateUnion(BindingSetPipe parent, Union union, BindingSet bindings) {
    BindingSetPipe pipe = new BindingSetPipe(parent) {
        AtomicInteger args = new AtomicInteger(2);
        @Override
        public boolean push(BindingSet bs) throws InterruptedException {
            if (bs == null) {
                if (args.decrementAndGet() == 0) {
                    return parent.push(null);
                } else {
                    return false;
                }
            } else {
                return parent.push(bs);
            }
        }
    };
    evaluateTupleExpr(pipe, union.getLeftArg(), bindings);
    evaluateTupleExpr(pipe, union.getRightArg(), bindings);
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * @inheritDoc
 */
@Override
public void meet(Union theOp)
        throws Exception
{
    ctxOpen(theOp);

    String aLeft = renderTupleExpr(theOp.getLeftArg());
    if (aLeft.endsWith("\n")) {
        aLeft = aLeft.substring(0, aLeft.length() - 1);
    }

    String aRight = renderTupleExpr(theOp.getRightArg());
    if (aRight.endsWith("\n")) {
        aRight = aRight.substring(0, aRight.length() - 1);
    }

    mJoinBuffer.append(indent()).append("{\n").append(aLeft).append("\n").append(indent()).append("}\n").append(
            indent()).append("union\n").append(indent()).append("{\n").append(aRight).append("\n").append(
            indent()).append("}.\n");

    ctxClose(theOp);
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
public Collection<Plan> getUnionPlan(CompilerContext context, Collection<Plan> p1, Collection<Plan> p2) {

        if (p1.isEmpty())
            return p2;

        if (p2.isEmpty())
            return p1;

        //FIXME: try also ordered union merge
        //FIXME: check that pp1 and pp2 is in the same site or need shipping

        RequestedPlanProperties props = new RequestedPlanProperties();
        props.setSite(LocalSite.getInstance());

        return context.enforceProps(p1, props).stream().flatMap(pp1 ->
                context.enforceProps(p2, props).stream().flatMap(pp2 ->
                        Stream.of(context.asPlan(new Union(pp1, pp2)))
                )
        ).collect(Collectors.toList());
    }
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
@Override
protected void meetNode(QueryModelNode node)
{
	if (node instanceof StatementTupleExpr) {
		nTriples++;
	} else if (node instanceof StatementPattern) {
		nTriples++;
	} else if (node instanceof Filter) {
		simple=false;
	} else if (node instanceof Union){
		simple=false;
	}
		
	super.meetNode(node);
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * Construct a SELECT query expression for a bound union.
 * 
 * Pattern:
 * 
 * SELECT ?v_1 ?v_2 ?v_N WHERE { { ?v_1 p o } UNION { ?v_2 p o } UNION ... } 
 * 
 * Note that the filterExpr is not evaluated at the moment.
 * 
 * @param stmt
 * @param unionBindings
 * @param filterExpr
 * @param evaluated
 * 			parameter can be used outside this method to check whether FILTER has been evaluated, false in beginning
 * 
 * @return
 */
public static TupleExpr selectQueryBoundUnion( StatementPattern stmt, List<BindingSet> unionBindings, FilterValueExpr filterExpr, Boolean evaluated) {
	
	// TODO add FILTER expressions
	
	Set<String> varNames = new HashSet<String>();
	
	Union union = new Union();
	union.setLeftArg(constructStatementId(stmt, Integer.toString(0), varNames, unionBindings.get(0)) );
	Union tmp = union;
	int idx;
	for (idx=1; idx<unionBindings.size()-1; idx++) {
		Union _u = new Union();
		_u.setLeftArg( constructStatementId(stmt, Integer.toString(idx), varNames, unionBindings.get(idx)) );
		tmp.setRightArg(_u);
		tmp = _u;
	}
	tmp.setRightArg( constructStatementId(stmt, Integer.toString(idx), varNames, unionBindings.get(idx) ));
			
	ProjectionElemList projList = new ProjectionElemList();
	for (String var : varNames)
		projList.addElement( new ProjectionElem(var));
	
	Projection proj = new Projection(union, projList);

	return proj;
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
@Override
public void meet(Union union) {
	
	// retrieve the union arguments, also those of nested unions
	List<TupleExpr> args = new ArrayList<TupleExpr>();
	handleUnionArgs(union, args);
	
	// remove any tuple expressions that do not produce any result
	List<TupleExpr> filtered = new ArrayList<TupleExpr>(args.size());
	for (TupleExpr arg : args) {
		if (arg instanceof EmptyResult)
			continue;
		filtered.add(arg);
	}
	
	// create a NUnion having the arguments in one layer
	// however, check if we only have zero or one argument first
	if (filtered.size()==0) {
		union.replaceWith(new EmptyNUnion(args, queryInfo));
	}
	
	else if (filtered.size()==1) {
		union.replaceWith(filtered.get(0));
	}
	
	else {
		union.replaceWith( new NUnion(filtered, queryInfo) );			
	}
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * Add the union arguments to the args list, includes a recursion 
 * step for nested unions.
 * 
 * @param union
 * @param args
 */
protected void handleUnionArgs(Union union, List<TupleExpr> args) {
	
	if (union.getLeftArg() instanceof Union) {
		handleUnionArgs((Union)union.getLeftArg(), args);
	} else {
		args.add(union.getLeftArg());
	}
	
	if (union.getRightArg() instanceof Union) {
		handleUnionArgs((Union)union.getRightArg(), args);
	} else {
		args.add(union.getRightArg());
	}
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
@Override
public void meet(Union union) {
	union.getLeftArg().visit(this);
	NodeDescriptor temp = current;
	reset();
	union.getRightArg().visit(this);
	if (temp.card == Long.MAX_VALUE || current.card == Long.MAX_VALUE) {
		current.card = Long.MAX_VALUE;
	} else {
		current.card += temp.card;
	}
	current.sel = Math.min(current.sel, temp.sel);
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
/**
 * @inheritDoc
 */
@Override
public void meet(Union theOp)
        throws Exception
{
    binaryOpMeet(theOp, theOp.getLeftArg(), theOp.getRightArg());
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
public Flux<BindingSet> evaluateReactorInternal(TupleExpr expr, List<BindingSet> bindingList)
        throws QueryEvaluationException
{
    if (expr instanceof Plan)
        return evaluateReactorInternal(((Plan) expr).getArg(), bindingList);
    else if (expr instanceof Union)
        return evaluateReactorInternal((Union) expr, bindingList);
    else if (expr instanceof SourceQuery)
        return evaluateReactorInternal((SourceQuery) expr, bindingList);
    else
        return evaluateReactiveDefault(expr, bindingList);
}
 

import org.eclipse.rdf4j.query.algebra.Union; //导入依赖的package包/类
private Collection<Plan> union(CompilerContext context, Plan p1, Plan p2)
{
    RequestedPlanProperties props = new RequestedPlanProperties();

    props.setSite(LocalSite.getInstance());

    Collection<Plan> pc1 = context.enforceProps(p1, props);
    Collection<Plan> pc2 = context.enforceProps(p2, props);

    return pc1.stream()
            .flatMap( s1 -> pc2.stream().map( s2 ->
                        context.asPlan(new Union(s1, s2))
            )).collect(Collectors.toList());
}