import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
private Op mergeToBGP(Op left, Op right) {
	BasicPattern bgp = new BasicPattern();
	if (OpBGP.isBGP(left)) {
		bgp.addAll(((OpBGP) left).getPattern());
	} else {
		if (!(left instanceof OpTable))
		Log.warn(this, "mergeToBGP left not valid BGP " + left.toString());
	}
	if (OpBGP.isBGP(right)) {
		bgp.addAll(((OpBGP) right).getPattern());
		;
	} else {
		if (!(right instanceof OpTable))
		Log.warn(this, "mergeToBGP right not valid BGP"+ right.toString());
	}
	return new OpBGP(bgp);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
protected Op compileElementGroup(ElementGroup groupElt) {
    Op current = OpTable.unit();
    // First: get all filters, merge adjacent BGPs. This includes BGP-FILTER-BGP
    // This is done in finalizeSyntax after which the new ElementGroup is in
    // the right order w.r.t. BGPs and filters. 
    // This is a delay from parsing time so a printed query
    // keeps filters where the query author put them.
    
    List<Element> groupElts = finalizeSyntax(groupElt);

    // Second: compile the consolidated group elements.
    // Assumes that filters moved to end.
    for (Iterator<Element> iter = groupElts.listIterator(); iter.hasNext(); ) {
        Element elt = iter.next();
        current = compileOneInGroup(elt, current);
    }
    return current;
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的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.OpTable; //导入依赖的package包/类
protected Op compilePathBlock(PathBlock pathBlock) {
    // Empty path block : the parser does not generate this case.
    if ( pathBlock.isEmpty() ) {
        return OpTable.unit();
    }
    // Always turns the most basic paths to triples.
    return PathLib.pathToTriples(pathBlock);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
public void visit(OpTable opTable) {
	wrapInCurrentFilter(opTable);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
@Override
public Op effectiveOp() {
	return OpTable.unit();
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
public OpUnionTableSQL(Collection<OpTableSQL> tableOps) {
	this(tableOps, OpTable.unit());
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
@Override
public void visit(OpTable opTable) {
	variables.addAll(opTable.getTable().getVars());
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
@Override
public Op transform(OpTable opTable) {
	return substitute(opTable);
}
 

import com.hp.hpl.jena.sparql.algebra.op.OpTable; //导入依赖的package包/类
@Override
public Op transform(OpTable opTable) {
	return (opTable);
	//return new OpBGP();
}