Java DatasetGraphTDB类代码示例

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
/** Execute for one input binding */  
protected QueryIterator evaluateBlockFilterSub(DatasetGraphTDB dsgtdb, Node graphNode, BasicPattern bgp, ExprList exprs, Binding input1) {
    Explain2.explain(Quack.quackExec, "%s, BGP =\n%s", graphNode, bgp) ;  
    PhysicalPlan<NodeId> plan = new PhysicalPlan<>() ;
    bgp = Substitute.substitute(bgp, input1) ;
    
    if ( exprs != null ) {
        Op op ;
        if ( graphNode == null )
            op = TransformFilterPlacement.transform(exprs, bgp) ;
        else
            op = TransformFilterPlacement.transform(exprs, graphNode, bgp) ;
        accumulatePlan(plan, graphNode, op);
    } else {
        accumulatePlan(plan, graphNode, bgp) ;
    }
    
    return executePlan$(plan, input1) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
public static void main(String... args) {
    System.out.printf("%s\n", IndexRef.parse("DB[SPO]")) ;
    System.out.printf("%s\n", IndexRef.parse("[SPO]")) ;
    System.exit(0) ;
    
    
    Quack.init() ;
    QuackPredObj.init() ;
    Quack.setOpExecutorFactory(OpExecutorQuackTDB.factorySubstitute) ;
    
    
    DatasetGraphTDB dsgtdb = build(Location.mem()) ;
    AccessorTDB accessor = AccessorTDB.create(new StorageTDB(dsgtdb)) ; 
    Planner planner = new PlannerPredObjList(accessor) ;
    BasicPattern bgp = SSE.parseBGP("(bgp (?s :q ?v) (?s :p 123))") ;
    
    Node p = SSE.parseNode(":p") ;
    Node q = SSE.parseNode(":q") ;
    
    accessor.getNodeTable().getAllocateNodeId(p) ;
    accessor.getNodeTable().getAllocateNodeId(q) ;
    
    List<Tuple<Slot<NodeId>>> tuples = ELibTDB.convertTriples(bgp.getList(), accessor.getNodeTable()) ;
    PhysicalPlan<NodeId> plan = planner.generatePlan(tuples) ;
    RowList<NodeId> input = RowLib.identityRowList()  ;
    plan.execute(input) ;
    
    System.out.println(plan) ;
    System.exit(0) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
public static NodeTupleTable chooseNodeTupleTable(DatasetGraphTDB dsgtdb, Node graphNode) {
    if ( OpExecLib.isDefaultGraph(graphNode) )
        return dsgtdb.getTripleTable().getNodeTupleTable() ;
    if ( OpExecLib.isUnionGraph(graphNode) )
        return dsgtdb.getQuadTable().getNodeTupleTable() ;
    return dsgtdb.getQuadTable().getNodeTupleTable() ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
@Override
public Plan create(Query query, DatasetGraph dataset, Binding input, Context context)
{
    // This is the usual route.
    DatasetGraphTDB dsgtdb = dsgToQuery(dataset) ;
    setup(dsgtdb, context) ;
    QueryEngineQuackTDB engine = new QueryEngineQuackTDB(query, dsgtdb, input, context) ;
    return engine.getPlan() ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
protected DatasetGraphTDB dsgToQuery(DatasetGraph dataset)
{
    if (dataset instanceof DatasetGraphTDB) return (DatasetGraphTDB)dataset ;
    if (dataset instanceof DatasetGraphTransaction) 
        return ((DatasetGraphTransaction)dataset).getDatasetGraphToQuery() ;
    throw new TDBException("Internal inconsistency: trying to execute query on unrecognized kind of DatasetGraph: "+Lib.className(dataset)) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
public static DatasetGraph createDatasetGraph(Location location, OpExecutorFactory executorFactory) {
    LogCtl.setError(FileRef.class) ;
    StoreParams sParams = StoreParams.builder()
        // Test to see if POS exists but PSO does not.
        .tripleIndexes(new String[] { primaryIndexTriples, "POS", "PSO", "OSP" })
        //{ primaryIndexQuads, "GPOS", "GOSP", "POSG", "OSPG", "SPOG"} ;
        .quadIndexes(new String[] { primaryIndexQuads, "GPOS", "GPSO", "GOSP", 
        "POSG", "PSOG", "OSPG", "SPOG"})
        .build() ;
    DatasetGraphTDB dsg = DatasetBuilderStd.stdBuilder().build(location, sParams) ;
    QC.setFactory(dsg.getContext(), executorFactory) ;
    return dsg ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
@Deprecated
public static NodeTupleTable chooseNodeTupleTable(DatasetGraphTDB dsgtdb, Node graphNode) {
    if ( OpExecLib.isDefaultGraph(graphNode) )
        return dsgtdb.getTripleTable().getNodeTupleTable() ;
    if ( OpExecLib.isUnionGraph(graphNode) )
        return dsgtdb.getQuadTable().getNodeTupleTable() ;
    return dsgtdb.getQuadTable().getNodeTupleTable() ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
private static DatasetGraphTDB build(Location loc) {
    String[] indexes = { "SOP", "POS", "PSO", "OSP" } ;
    return build(loc, indexes) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
public StorageTDB(DatasetGraphTDB dsg) {
     this.dsg = dsg ;
     this.tripleTuples = dsg.getTripleTable().getNodeTupleTable().getTupleTable() ;
     this.quadTuples = dsg.getQuadTable().getNodeTupleTable().getTupleTable() ;
     this.nodeTable = dsg.getTripleTable().getNodeTupleTable().getNodeTable() ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
private void setup(DatasetGraphTDB dataset, Context context) {
    OpExecutorFactory opExecfactory = Quack.getOpExecutorFactory(context) ;
    if ( opExecfactory != null )
        QC.setFactory(context, opExecfactory) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
private static boolean isHandledByTDB(DatasetGraph dataset)
{
    if (dataset instanceof DatasetGraphTDB) return true ;
    if (dataset instanceof DatasetGraphTransaction ) return true ;
    return false ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
@Override
public AccessorTDB initAccessor(DatasetGraphTDB dsgtdb) {
    return AccessorTDB.create(new StorageTDB(dsgtdb)) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
@Override
public Planner initPlanner(DatasetGraphTDB dsgtdb, AccessorTDB accessor) {
    return new PlannerSubstitution(accessor) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
protected QueryEngineQuackTDB(Op op, DatasetGraphTDB dataset, Binding input, Context context) {
    super(op, dataset, input, context) ;
}
 

import com.hp.hpl.jena.tdb.store.DatasetGraphTDB; //导入依赖的package包/类
/** As for {@link OpExecutorBlockFilter#executeBlockFilter} but with the DatasetGraphTDB included. */
protected abstract QueryIterator evaluateBlockFilter(DatasetGraphTDB dsgtdb, 
                                                     Node graphNode, BasicPattern bgp, 
                                                     ExprList exprs, 
                                                     QueryIterator input) ;