jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [19/65] [abbrv] jena git commit: JENA-1397: Rename java packages
Date Tue, 03 Oct 2017 19:34:05 GMT
http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsConst.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsConst.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsConst.java
new file mode 100644
index 0000000..e191ba3
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsConst.java
@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.setup;
+
+import org.apache.jena.dboe.base.block.FileMode;
+import org.apache.jena.dboe.sys.Names;
+import org.apache.jena.tdb2.sys.SystemTDB;
+
+public class StoreParamsConst {
+    // SystemParams are built with a SystemParamsBuilder
+    // Initial values are the system defaults.
+    
+    /** Database and query configuration */ 
+    // Key names are the base name -  encode/decode may add a prefix.
+    
+    public static final String   fFileMode             = "file_mode" ;
+    public static final FileMode fileMode              = SystemTDB.fileMode() ;
+    
+    public static final String   fBlockReadCacheSize   = "block_read_cache_size" ;
+    public static final int      blockReadCacheSize    = SystemTDB.BlockReadCacheSize ;
+    
+    public static final String   fBlockWriteCacheSize  = "block_write_cache_size" ;
+    public static final int      blockWriteCacheSize   = SystemTDB.BlockWriteCacheSize ;
+    
+    public static final String   fNode2NodeIdCacheSize = "node2nodeid_cache_size" ;
+    public static final int      Node2NodeIdCacheSize  = SystemTDB.Node2NodeIdCacheSize ;
+    
+    public static final String   fNodeId2NodeCacheSize = "nodeid2node_cache_size" ;
+    public static final int      NodeId2NodeCacheSize  = SystemTDB.NodeId2NodeCacheSize ;
+    
+    public static final String   fNodeMissCacheSize    = "node_miss_cache_size" ;
+    public static final int      NodeMissCacheSize     = SystemTDB.NodeMissCacheSize ;
+    
+    /** Database layout - ignored after a database is created */
+    public static final String   fBlockSize            = "block_size" ;
+    public static final int      blockSize             = SystemTDB.BlockSize ;
+    
+    public static final String   fNodeTableBaseName    = "nodetable" ;
+    public static final String   nodeTableBaseName     = Names.nodeTableBaseName ;
+    
+    public static final String   fPrimaryIndexTriples  = "triple_index_primary" ;
+    public static final String   primaryIndexTriples   = Names.primaryIndexTriples ;
+    
+    public static final String   fTripleIndexes        = "triple_indexes" ;
+    public static final String[] tripleIndexes         = Names.tripleIndexes ;
+    
+    public static final String   fPrimaryIndexQuads    = "quad_index_primary" ;
+    public static final String   primaryIndexQuads     = Names.primaryIndexQuads ;
+    
+    public static final String   fQuadIndexes          = "quad_indexes" ;
+    public static final String[] quadIndexes           = Names.quadIndexes ;
+    
+    public static final String   fPrefixTableBaseName  = "prefixtable" ;
+    public static final String   prefixTableBaseName   = Names.prefixTableBaseName ;
+   
+    public static final String   fPrimaryIndexPrefix   = "prefix_index_primary" ;
+    public static final String   primaryIndexPrefix    = Names.primaryIndexPrefix ;
+    
+    public static final String   fPrefixIndexes        = "prefix_indexes" ;
+    public static final String[] prefixIndexes         = Names.prefixIndexes ;
+
+    // Must be after the constants above to get initialization order right
+    // because StoreParamsBuilder uses these constants.
+     
+    /** The system default parameters for on-disk databases. */
+    static StoreParams dftStoreParams = StoreParams.builder().build() ;
+
+    /** The system default parameters for in-memory databases. */
+    static StoreParams dftMemStoreParams = StoreParams.builder()
+        .fileMode(FileMode.direct)
+        // Small block caches, mainly so it behaves like a direct on-disk database.  
+        .blockReadCacheSize(10)
+        .blockWriteCacheSize(10)
+        .node2NodeIdCacheSize(10000)
+        .nodeId2NodeCacheSize(10000)
+        .nodeMissCacheSize(100)
+        .build() ;
+    
+    /** The "small store" parameters. */
+    static StoreParams smallStoreParams = StoreParams.builder()
+        .fileMode(FileMode.direct)
+        .blockReadCacheSize(100)
+        .blockWriteCacheSize(100)
+        .node2NodeIdCacheSize(10000)
+        .nodeId2NodeCacheSize(10000)
+        .nodeMissCacheSize(100)
+        .build() ;
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsDynamic.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsDynamic.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsDynamic.java
new file mode 100644
index 0000000..5939acc
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsDynamic.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.setup;
+
+import org.apache.jena.dboe.base.block.FileMode;
+
+/** Store parameters that can be adjusted after a store has been created,
+ *  and given different values when the JVM attachs to a store area. 
+ *  (They are still fixed for any given database once created in a JVM.) 
+ */
+
+public interface StoreParamsDynamic {
+    
+    /** Store-wide file access mode */ 
+    public FileMode getFileMode() ;
+    public boolean isSetFileMode() ;
+    
+    /** Block read cache (note: mapped files do not have a block cache) */
+    public Integer getBlockReadCacheSize() ;
+    public boolean isSetBlockReadCacheSize() ;
+
+    /** Block write cache (note: mapped files do not have a block cache) */
+    public Integer getBlockWriteCacheSize() ;
+    public boolean isSetBlockWriteCacheSize() ;
+    
+    /** Node cache for Node->NodeId. */
+    public Integer getNode2NodeIdCacheSize() ;
+    public boolean isSetNode2NodeIdCacheSize() ;
+    
+    /** Node cache for NodeId->Node. Important for SPARQL results. */
+    public Integer getNodeId2NodeCacheSize() ;
+    public boolean isSetNodeId2NodeCacheSize() ;
+
+    /** Node cache for recording known misses */
+    public Integer getNodeMissCacheSize() ;
+    public boolean isSetNodeMissCacheSize() ;
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsFactory.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsFactory.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsFactory.java
new file mode 100644
index 0000000..741f247
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/StoreParamsFactory.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.setup;
+
+import org.apache.jena.dboe.base.file.Location;
+import org.apache.jena.dboe.sys.Names;
+import org.apache.jena.tdb2.TDB2Factory;
+
+public class StoreParamsFactory {
+    /** Choose the StoreParams.  This is the policy applied when creating or reattaching to a database.
+     *  (extracted and put here to keep the size of DatasetBuildStd  
+     * <p>
+     * If the location has parameters in a <tt>tdb.cfg</tt> file, use them, as modified by any
+     * application-supplied internal parameters.
+     * <p>
+     * Otherwise, if this is a new database, use the application provided
+     * parameters or if there are no application provided 
+     * parameters, use the system default parameters.
+     * Write the parameters used to the location in <tt>tdb.cfg</tt>
+     * <p>If this is an existing database and there are no location recorded parameters,
+     * use system default parameters, modified by application parameters.   
+     * <p>
+     * Notes:
+     * <ul>
+     * <li><i>Modification</i> involves setting any of the parameters than can vary from run to run. 
+     * These are the cache sizes and the file mode. 
+     * <li><i>Block size</i>: it is critical that this set correctly. Silent corruption
+     * of a database may occur if this is changed.  At the moment, it is not possible to provide
+     * a complete check of block size.
+     * <ul>  
+     * <p>
+     * Do not edit store parameters recorded at a location after the database has been created.
+     * Only the dynamic parameters cna be safely changed. That is better done though the application
+     * providing some parameters in the {@link TDB2Factory} call.
+     * <p>
+     * This includes changing filenames,  indexing choices and block size. 
+     * Otherwise, the database may be permanetly and irrecovably corrupted.
+     * You have been warned. 
+     * 
+     * @param location The place where the database is or will be.
+     * @param isNew  Whether the database is being created or whether there is an existing database.
+     * @param pApp   Application-provide store parameters.
+     * @param pLoc   Store parameters foud at the location.
+     * @param pDft   System default store parameters.
+     * @return       StoreParams
+     * 
+     * @see StoreParams
+     * @see StoreParamsDynamic
+     */
+    public static StoreParams decideStoreParams(Location location, boolean isNew, StoreParams pApp, StoreParams pLoc, StoreParams pDft) {
+        StoreParams p = null ;
+        if ( pLoc != null ) {
+            // pLoc so use it, modify by pApp.
+            // Covers new and reconnect cases.
+            p = pLoc ;
+            if ( pApp != null )
+                p = StoreParamsBuilder.modify(pLoc, pApp) ;
+            return p ;
+        }
+        // No pLoc.
+        // Use pApp if available.  Write to location if new.
+        if ( pApp != null ) {
+            if ( isNew ) {
+                if ( ! location.isMem() ) {
+                    String filename = location.getPath(Names.TDB_CONFIG_FILE) ;
+                    StoreParamsCodec.write(filename, pApp) ;
+                }
+                return pApp ;
+            }
+            // Not new : pLoc is implicitly pDft.
+            return StoreParamsBuilder.modify(pDft, pApp) ;
+        }
+        // no pLoc, no pApp
+        return pDft ;
+    }
+
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBBuilder.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBBuilder.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBBuilder.java
new file mode 100644
index 0000000..9b8c694
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBBuilder.java
@@ -0,0 +1,291 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.setup;
+
+import java.io.File ;
+import java.io.FileFilter ;
+import java.util.UUID ;
+
+import org.apache.jena.atlas.lib.tuple.TupleMap ;
+import org.apache.jena.dboe.DBOpEnvException;
+import org.apache.jena.dboe.base.file.*;
+import org.apache.jena.dboe.base.record.RecordFactory;
+import org.apache.jena.dboe.index.Index;
+import org.apache.jena.dboe.index.RangeIndex;
+import org.apache.jena.dboe.sys.Names;
+import org.apache.jena.dboe.trans.bplustree.BPlusTree;
+import org.apache.jena.dboe.trans.bplustree.BPlusTreeFactory;
+import org.apache.jena.dboe.trans.data.TransBinaryDataFile;
+import org.apache.jena.dboe.transaction.txn.ComponentId;
+import org.apache.jena.dboe.transaction.txn.TransactionCoordinator;
+import org.apache.jena.dboe.transaction.txn.TransactionalBase;
+import org.apache.jena.dboe.transaction.txn.TransactionalSystem;
+import org.apache.jena.dboe.transaction.txn.journal.Journal;
+import org.apache.jena.sparql.engine.main.QC ;
+import org.apache.jena.sparql.engine.optimizer.reorder.ReorderLib ;
+import org.apache.jena.tdb2.TDBException;
+import org.apache.jena.tdb2.solver.OpExecutorTDB1;
+import org.apache.jena.tdb2.store.*;
+import org.apache.jena.tdb2.store.nodetable.NodeTable;
+import org.apache.jena.tdb2.store.nodetable.NodeTableCache;
+import org.apache.jena.tdb2.store.nodetable.NodeTableInline;
+import org.apache.jena.tdb2.store.nodetable.NodeTableTRDF;
+import org.apache.jena.tdb2.store.nodetupletable.NodeTupleTable;
+import org.apache.jena.tdb2.store.nodetupletable.NodeTupleTableConcrete;
+import org.apache.jena.tdb2.store.tupletable.TupleIndex;
+import org.apache.jena.tdb2.store.tupletable.TupleIndexRecord;
+import org.apache.jena.tdb2.sys.SystemTDB;
+import org.slf4j.Logger ;
+import org.slf4j.LoggerFactory ;
+
+// Takes from TDB2Builder
+// Converted to statics.
+
+/** Build TDB2 databases.
+ * <p>
+ * <b>Do not call these operations directly - use StoreConnection.</b>
+ */
+public class TDBBuilder {
+    private Logger log = LoggerFactory.getLogger(TDBBuilder.class) ;
+    
+    public static DatasetGraphTxn build(Location location) {
+        return build(location, StoreParams.getDftStoreParams()) ;
+    }
+
+    public static DatasetGraphTxn build(Location location, StoreParams appParams) {
+        StoreParams locParams = StoreParamsCodec.read(location) ;
+        StoreParams dftParams = StoreParams.getDftStoreParams() ;
+        // This can write the chosen parameters if necessary (new database, appParams != null, locParams == null)
+        boolean newArea = isNewDatabaseArea(location) ;
+        if ( newArea ) {
+        }
+        StoreParams params = StoreParamsFactory.decideStoreParams(location, newArea, appParams, locParams, dftParams) ;
+        return create(location, params).build$() ; 
+    }
+
+    private DatasetGraphTxn build$() {
+        NodeTable nodeTable = buildNodeTable(params.getNodeTableBaseName()) ;
+        
+        TripleTable tripleTable = buildTripleTable(nodeTable) ;
+        QuadTable quadTable = buildQuadTable(nodeTable) ;
+        
+        NodeTable nodeTablePrefixes = buildNodeTable(params.getPrefixTableBaseName()) ;
+        DatasetPrefixesTDB prefixes = buildPrefixTable(nodeTablePrefixes) ;
+        
+        TransactionalSystem trans = new TransactionalBase(txnCoord) ;
+        DatasetGraphTxn dsg = new DatasetGraphTDB(trans, 
+                                                  tripleTable, quadTable, prefixes, 
+                                                  ReorderLib.fixed(), location, params) ;
+        QC.setFactory(dsg.getContext(), OpExecutorTDB1.OpExecFactoryTDB) ;
+        txnCoord.start() ;
+        return dsg ;
+    }
+
+    public static TransactionCoordinator buildTransactionCoordinator(Location location) {
+        Journal journal = Journal.create(location) ;
+        TransactionCoordinator txnCoord = new TransactionCoordinator(journal) ;
+        return txnCoord ;
+    }
+
+    public static String choosePrimaryForIndex(StoreParams params, String index) {
+        String primary3 = params.getPrimaryIndexTriples() ;
+        String primary4 = params.getPrimaryIndexQuads() ;
+        
+        if ( index.length() == primary3.length() )
+            return primary3 ;
+        if ( index.length() == primary4.length() )
+            return primary4 ;
+        throw new DBOpEnvException("Can't find primary for '"+index+"'") ;
+    }
+
+    // ---- Object starts
+    final Location location ;
+    final StoreParams params ;
+    final ComponentIdMgr componentIdMgr ;
+    final TransactionCoordinator txnCoord ;
+
+    private TDBBuilder(TransactionCoordinator txnCoord, Location location, StoreParams params, ComponentIdMgr componentIdMgr) {
+        this.txnCoord = txnCoord ;
+        this.location = location ;
+        this.params = params ;
+        this.componentIdMgr = componentIdMgr ;
+    }
+
+    public Location getLocation()               { return location ; }
+    public StoreParams getParams()              { return params ; }
+    public TransactionCoordinator getTxnCoord() { return txnCoord ; }
+
+    public static TDBBuilder create(Location location) {
+        return create(location, StoreParams.getDftStoreParams()) ; 
+    }
+    
+    public static TDBBuilder create(Location location, StoreParams params) {
+        TransactionCoordinator txnCoord = buildTransactionCoordinator(location) ;
+        return new TDBBuilder(txnCoord, location, params, new ComponentIdMgr(UUID.randomUUID())) ;
+    }
+
+    public static TDBBuilder create(TransactionCoordinator txnCoord, Location location, StoreParams params) {
+        return new TDBBuilder(txnCoord, location, params, new ComponentIdMgr(UUID.randomUUID())) ;
+    }
+
+    /** Look at a directory and see if it is a new area */
+    private static boolean isNewDatabaseArea(Location location) {
+        if ( location.isMem() )
+            return true ;
+        File d = new File(location.getDirectoryPath()) ;
+        if ( !d.exists() )
+            return true ;
+        FileFilter ff = fileFilterNewDB ;
+        File[] entries = d.listFiles(ff) ;
+        return entries.length == 0 ;
+    }
+    
+    /** FileFilter
+     * Skips "..", ".", "tdb.lock" and "tdb.cfg"
+     * 
+     */
+  private static  FileFilter fileFilterNewDB  = (pathname)->{
+        String fn = pathname.getName() ;
+        if ( fn.equals(".") || fn.equals("..") )
+            return false ;
+        if ( pathname.isDirectory() )
+            return true ;
+        if ( fn.equals(Names.TDB_LOCK_FILE) )
+            return false ;
+        if ( fn.equals(Names.TDB_CONFIG_FILE) )
+            return false ;
+        
+        return true ;
+    } ;
+    
+    public TripleTable buildTripleTable(NodeTable nodeTable) {    
+        String primary = params.getPrimaryIndexTriples() ;
+        String[] indexes = params.getTripleIndexes() ;
+
+        // Validation checks - common index forms.  
+        if ( indexes.length != 3 && indexes.length != 2 )
+            error(log, "Wrong number of triple table indexes: "+String.join(",", indexes)) ;
+        log.debug("Triple table: "+primary+" :: "+String.join(",", indexes)) ;
+
+        TupleIndex tripleIndexes[] = makeTupleIndexes(primary, indexes) ;
+
+        if ( tripleIndexes.length != indexes.length )
+            error(log, "Wrong number of triple table tuples indexes: "+tripleIndexes.length) ;
+        TripleTable tripleTable = new TripleTable(tripleIndexes, nodeTable) ;
+        return tripleTable ;
+    }
+
+    public QuadTable buildQuadTable(NodeTable nodeTable) {    
+        String primary = params.getPrimaryIndexQuads() ;
+        String[] indexes = params.getQuadIndexes() ;
+
+        // Validation checks - common index forms.  
+        if ( indexes.length != 6 && indexes.length != 4 )
+            error(log, "Wrong number of quad table indexes: "+String.join(",", indexes)) ;
+        log.debug("Quad table: "+primary+" :: "+String.join(",", indexes)) ;
+
+        TupleIndex tripleIndexes[] = makeTupleIndexes(primary, indexes) ;
+
+        if ( tripleIndexes.length != indexes.length )
+            error(log, "Wrong number of triple table tuples indexes: "+tripleIndexes.length) ;
+        QuadTable tripleTable = new QuadTable(tripleIndexes, nodeTable) ;
+        return tripleTable ;
+    }
+
+    public DatasetPrefixesTDB buildPrefixTable(NodeTable prefixNodes) {
+        String primary = params.getPrimaryIndexPrefix() ;
+        String[] indexes = params.getPrefixIndexes() ;
+
+        TupleIndex prefixIndexes[] = makeTupleIndexes(primary, indexes) ;
+        if ( prefixIndexes.length != 1 )
+            error(log, "Wrong number of triple table tuples indexes: "+prefixIndexes.length) ;
+
+        // No cache - the prefix mapping is a cache
+        //NodeTable prefixNodes = makeNodeTable(location, pnNode2Id, pnId2Node, -1, -1, -1)  ;
+        NodeTupleTable prefixTable = new NodeTupleTableConcrete(primary.length(),
+                                                                prefixIndexes,
+                                                                prefixNodes) ;
+        DatasetPrefixesTDB prefixes = new DatasetPrefixesTDB(prefixTable) ; 
+        log.debug("Prefixes: "+primary+" :: "+String.join(",", indexes)) ;
+        return prefixes ;
+    }
+
+    // ---- Build structures
+
+    public TupleIndex[] makeTupleIndexes(String primary, String[] indexNames) {
+        int indexRecordLen = primary.length()*SystemTDB.SizeOfNodeId ;
+        TupleIndex indexes[] = new TupleIndex[indexNames.length] ;
+        for (int i = 0 ; i < indexes.length ; i++) {
+            String indexName = indexNames[i] ;
+            String indexLabel = indexNames[i] ;
+            indexes[i] = buildTupleIndex(primary, indexName, indexLabel) ;
+        }
+        return indexes ;
+    }
+
+    public TupleIndex buildTupleIndex(String primary, String index, String name) {
+        TupleMap cmap = TupleMap.create(primary, index) ;
+        RecordFactory rf = new RecordFactory(SystemTDB.SizeOfNodeId * cmap.length(), 0) ;
+        RangeIndex rIdx = buildRangeIndex(rf, index) ;
+        TupleIndex tIdx = new TupleIndexRecord(primary.length(), cmap, index, rf, rIdx) ;
+        return tIdx ;
+    }
+    
+    public RangeIndex buildRangeIndex(RecordFactory recordFactory, String name) {
+        ComponentId cid = componentIdMgr.getComponentId(name) ;
+        FileSet fs = new FileSet(location, name) ;
+        BPlusTree bpt = BPlusTreeFactory.createBPTree(cid, fs, recordFactory) ;
+        txnCoord.add(bpt) ;
+        return bpt ;
+    }
+    
+    public NodeTable buildNodeTable(String name) {
+        NodeTable nodeTable = buildBaseNodeTable(name) ;
+        nodeTable = NodeTableCache.create(nodeTable, params) ;
+        nodeTable = NodeTableInline.create(nodeTable) ;
+        return nodeTable ;
+    }
+
+    public NodeTable buildBaseNodeTable(String name) {
+        RecordFactory recordFactory = new RecordFactory(SystemTDB.LenNodeHash, SystemTDB.SizeOfNodeId) ;
+        Index index = buildRangeIndex(recordFactory, name) ;
+        
+        String dataname = name+"-data" ; 
+        TransBinaryDataFile transBinFile = buildBinaryDataFile(dataname) ;
+        txnCoord.add(transBinFile) ;
+        return new NodeTableTRDF(index, transBinFile) ;
+    }
+    
+    public TransBinaryDataFile buildBinaryDataFile(String name) {
+        ComponentId cid = componentIdMgr.getComponentId(name) ;
+        FileSet fs = new FileSet(location, name) ; 
+        BinaryDataFile binFile = FileFactory.createBinaryDataFile(fs, Names.extObjNodeData) ;
+        BufferChannel pState = FileFactory.createBufferChannel(fs, Names.extBdfState) ;
+        // ComponentId mgt.
+        TransBinaryDataFile transBinFile = new TransBinaryDataFile(binFile, cid, pState) ;
+        return transBinFile ;
+    }
+    
+    private void error(Logger log, String msg)
+    {
+        if ( log != null )
+            log.error(msg) ;
+        throw new TDBException(msg) ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBDatasetDetails.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBDatasetDetails.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBDatasetDetails.java
new file mode 100644
index 0000000..37b8998
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/setup/TDBDatasetDetails.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.setup;
+
+import org.apache.jena.atlas.lib.ArrayUtils ;
+import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.tdb2.store.DatasetGraphTDB;
+import org.apache.jena.tdb2.store.nodetable.NodeTable;
+import org.apache.jena.tdb2.store.nodetable.NodeTableCache;
+import org.apache.jena.tdb2.store.nodetable.NodeTableInline;
+import org.apache.jena.tdb2.store.tupletable.TupleIndex;
+
+public class TDBDatasetDetails {
+    public final TupleIndex[] tripleIndexes ;
+    public final TupleIndex[] quadIndexes ;
+    public final NodeTable ntTop ;
+    public NodeTableInline ntInline ;
+    public NodeTableCache ntCache ;
+    public NodeTable ntBase ;
+    
+    
+    public TDBDatasetDetails(DatasetGraphTDB dsg) {
+        ntTop = dsg.getTripleTable().getNodeTupleTable().getNodeTable() ;
+        tripleIndexes = ArrayUtils.copy(dsg.getTripleTable().getNodeTupleTable().getTupleTable().getIndexes()) ;
+        quadIndexes = ArrayUtils.copy(dsg.getQuadTable().getNodeTupleTable().getTupleTable().getIndexes()) ;
+        
+        fillInNodeTableDetails() ;
+        fillInIndexDetails() ;
+    }
+
+    private void fillInNodeTableDetails() {
+        // Nodetable.
+        NodeTable ntx = ntTop ;
+        while(ntx.wrapped() != null ) {
+            if ( ntx instanceof NodeTableInline ) {
+                if ( ntInline != null )
+                    Log.warn(this, "Multiple NodeTableInline") ;
+                ntInline = (NodeTableInline)ntx ;
+            }
+            else if ( ntx instanceof NodeTableCache ) {
+                if ( ntCache != null )
+                    Log.warn(this, "Multiple NodeTableCache") ;
+                ntCache = (NodeTableCache)ntx ;
+            }
+            ntx = ntx.wrapped() ;
+        } 
+        
+        ntBase = ntx ;
+        
+        if ( ntInline == null )
+            Log.warn(this, "No NodeTableInline") ;
+        if ( ntCache == null )
+            Log.warn(this, "No NodeTableCache") ;
+        if ( ntBase == null )
+            Log.warn(this, "No base NodeTable") ;
+    }
+    
+    private void fillInIndexDetails() {
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/Abortable.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/Abortable.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/Abortable.java
new file mode 100644
index 0000000..486336f
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/Abortable.java
@@ -0,0 +1,21 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+interface Abortable { public void abort() ; }

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingNodeId.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingNodeId.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingNodeId.java
new file mode 100644
index 0000000..dc516c2
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingNodeId.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.HashMap;
+import java.util.Iterator ;
+import java.util.Map;
+
+import org.apache.jena.atlas.lib.Map2 ;
+
+
+
+import org.apache.jena.sparql.core.Var ;
+import org.apache.jena.sparql.engine.binding.Binding ;
+import org.apache.jena.tdb2.store.NodeId;
+
+/** Class for a Binding-like structure except it works on NodeIds, not on Nodes */  
+public class BindingNodeId extends Map2<Var, NodeId>
+{
+    // This is the parent binding - which may be several steps up the chain. 
+    // This just carried around for later use when we go BindingNodeId back to Binding.
+    private final Binding parentBinding ;
+
+    // Possible optimization: there are at most 3 possible values so HashMap is overkill.
+    // Use a chain of small objects.
+    
+    private BindingNodeId(Map<Var, NodeId> map1, Map2<Var, NodeId> map2, Binding parentBinding)
+    {
+        super(map1, map2) ;
+        this.parentBinding = parentBinding ;
+    }
+
+    // Make from an existing BindingNodeId 
+    public BindingNodeId(BindingNodeId other)
+    {
+        this(new HashMap<Var, NodeId>(), other, other.getParentBinding()) ;
+    }
+    
+    // Make from an existing Binding 
+    public BindingNodeId(Binding binding)
+    {
+        this(new HashMap<Var, NodeId>(), null, binding) ;
+    }
+
+    public BindingNodeId()
+    {
+        this(new HashMap<Var, NodeId>(), null, null) ;
+    }
+    
+    public Binding getParentBinding()    { return parentBinding ; } 
+    
+    //@Override public NodeId get(Var v)    { return super.get(v) ; } 
+    
+    @Override public void put(Var v, NodeId n)
+    {
+        if ( v == null || n == null )
+            throw new IllegalArgumentException("("+v+","+n+")") ;
+        super.put(v, n) ;
+    }
+    
+    public void putAll(BindingNodeId other)
+    {
+        Iterator<Var> vIter = other.iterator() ;
+        
+        for ( ; vIter.hasNext() ; )
+        {
+            Var v = vIter.next() ;
+            if ( v == null )
+                throw new IllegalArgumentException("Null key") ;
+            NodeId n = other.get(v) ;
+            if ( n == null )
+                throw new IllegalArgumentException("("+v+","+n+")") ;
+            super.put(v, n) ;
+        }
+    }
+    
+    @Override
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder() ;
+        
+        boolean first = true ;
+        for ( Var v : this )
+        {
+            if ( ! first )
+                sb.append(" ") ;
+            first = false ;
+            NodeId x = get(v) ;
+            sb.append(v) ;
+            sb.append(" = ") ;
+            sb.append(x) ;
+        }
+            
+        return sb.toString() ;
+        
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingTDB.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingTDB.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingTDB.java
new file mode 100644
index 0000000..25e0534
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/BindingTDB.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.* ;
+
+import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.graph.Node ;
+import org.apache.jena.riot.out.NodeFmtLib ;
+import org.apache.jena.sparql.core.Var ;
+import org.apache.jena.sparql.engine.binding.Binding ;
+import org.apache.jena.sparql.engine.binding.BindingBase ;
+import org.apache.jena.tdb2.store.NodeId;
+import org.apache.jena.tdb2.store.nodetable.NodeTable;
+
+/** Bind that delays turning a NodeId into a Node until explicitly needed by get() */
+
+public class BindingTDB extends BindingBase
+{
+    private final NodeTable nodeTable ;
+    private final BindingNodeId idBinding ;
+    
+    private static final boolean caching = false ;
+    // Whether the cache is worthwhile is unclear - the NodeTable keeps a cache. 
+    private final Map<Var,Node> cache = ( caching ? new HashMap<>() : null ) ;
+
+    public BindingTDB(BindingNodeId idBinding, NodeTable nodeTable)
+    {
+        // BindingNodeId contains the bindings actually used  copied down when created. 
+        super(idBinding.getParentBinding()) ;
+        this.idBinding = idBinding ;
+        this.nodeTable = nodeTable ;
+    }
+
+    @Override
+    protected int size1() { return idBinding.size(); }
+    
+    private List<Var> vars = null ;
+    
+    /** Iterate over all the names of variables. */
+    @Override
+    protected Iterator<Var> vars1() 
+    {
+        if ( vars == null )
+            vars = calcVars() ;
+        return vars.iterator() ;
+    }
+
+    private List<Var> calcVars()
+    {
+        List<Var> vars = new ArrayList<>(4) ;
+        // Only if not in parent.
+        // A (var/value) binding may have been copied down to record it's NodeId.  
+        
+        Binding b = idBinding.getParentBinding() ;
+        
+        Iterator<Var> iter = idBinding.iterator() ;
+        for ( Var v : idBinding )
+        {
+            if ( b == null || ! b.contains(v) )
+                vars.add(v) ;
+        }
+        return vars ;
+    }
+    
+    @Override
+    protected boolean isEmpty1()
+    {
+        return size1() == 0 ;
+    }
+
+    @Override
+    public boolean contains1(Var var)
+    {
+        return idBinding.containsKey(var) ;
+    }
+    
+    public BindingNodeId getBindingId() { return idBinding ; }
+    
+    public NodeId getNodeId(Var var)
+    {
+        NodeId id = idBinding.get(var) ;
+        if ( id != null )
+            return id ;
+        
+        if ( parent == null )
+            return null ; 
+
+        // Maybe in the parent.
+        if ( parent instanceof BindingTDB )
+            return ((BindingTDB)parent).getNodeId(var) ;
+        return null ;
+    }
+    
+    @Override
+    public Node get1(Var var)
+    {
+        try {
+            Node n = cacheGet(var) ;
+            if ( n != null )
+                return n ;
+            
+            NodeId id = idBinding.get(var) ;
+            if ( id == null )
+                return null ; 
+            n = nodeTable.getNodeForNodeId(id) ;
+            // Update cache.
+            cachePut(var, n) ;
+            return n ;
+        } catch (Exception ex)
+        {
+            Log.error(this, String.format("get1(%s)", var), ex) ;
+            return null ;
+        }
+    }
+
+    private void cachePut(Var var, Node n)
+    {
+        if ( cache != null ) cache.put(var, n) ; 
+    }
+
+    private Node cacheGet(Var var)
+    { 
+        if ( cache == null ) return null ;
+        return cache.get(var) ;
+    }
+    
+    @Override
+    protected void format(StringBuffer sbuff, Var var)
+    {
+        NodeId id = idBinding.get(var) ;
+        String extra = "" ;
+        if ( id != null )
+            extra = "/"+id ;
+        Node node = get(var) ;
+        String tmp = NodeFmtLib.displayStr(node) ;
+        sbuff.append("( ?"+var.getVarName()+extra+" = "+tmp+" )") ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/OpExecutorTDB1.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/OpExecutorTDB1.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/OpExecutorTDB1.java
new file mode 100644
index 0000000..828bcab
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/OpExecutorTDB1.java
@@ -0,0 +1,428 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.function.Predicate;
+
+import org.apache.jena.atlas.lib.tuple.Tuple ;
+import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.graph.Graph ;
+import org.apache.jena.graph.Node ;
+import org.apache.jena.sparql.ARQInternalErrorException ;
+import org.apache.jena.sparql.algebra.Op ;
+import org.apache.jena.sparql.algebra.op.* ;
+import org.apache.jena.sparql.algebra.optimize.TransformFilterPlacement ;
+import org.apache.jena.sparql.core.BasicPattern ;
+import org.apache.jena.sparql.core.Quad ;
+import org.apache.jena.sparql.core.Substitute ;
+import org.apache.jena.sparql.core.Var ;
+import org.apache.jena.sparql.engine.ExecutionContext ;
+import org.apache.jena.sparql.engine.QueryIterator ;
+import org.apache.jena.sparql.engine.iterator.QueryIterPeek ;
+import org.apache.jena.sparql.engine.main.OpExecutor ;
+import org.apache.jena.sparql.engine.main.OpExecutorFactory ;
+import org.apache.jena.sparql.engine.main.QC ;
+import org.apache.jena.sparql.engine.main.iterator.QueryIterGraph ;
+import org.apache.jena.sparql.engine.optimizer.reorder.ReorderProc ;
+import org.apache.jena.sparql.engine.optimizer.reorder.ReorderTransformation ;
+import org.apache.jena.sparql.expr.ExprList ;
+import org.apache.jena.sparql.mgt.Explain ;
+import org.apache.jena.tdb2.store.DatasetGraphTDB;
+import org.apache.jena.tdb2.store.GraphTDB;
+import org.apache.jena.tdb2.store.NodeId;
+import org.slf4j.Logger ;
+import org.slf4j.LoggerFactory ;
+
+/** TDB executor for algebra expressions.  It is the standard ARQ executor
+ *  except for basic graph patterns and filtered basic graph patterns (currently).  
+ * 
+ * See also: StageGeneratorDirectTDB, a non-reordering 
+ */
+public class OpExecutorTDB1 extends OpExecutor
+{
+    private static final Logger log = LoggerFactory.getLogger(OpExecutorTDB1.class) ;
+    
+    public final static OpExecutorFactory OpExecFactoryTDB = new OpExecutorFactory()
+    {
+        @Override
+        public OpExecutor create(ExecutionContext execCxt)
+        { return new OpExecutorTDB1(execCxt) ; }
+    } ;
+    
+    private final boolean isForTDB ;
+    
+    // A new compile object is created for each op compilation.
+    // So the execCxt is changing as we go through the query-compile-execute process  
+    public OpExecutorTDB1(ExecutionContext execCxt)
+    {
+        super(execCxt) ;
+        // NB. The dataset may be a TDB one, or a general one.
+        // Any merged union graph magic (for a TDB dataset was handled
+        // in QueryEngineTDB).
+        
+        isForTDB = (execCxt.getActiveGraph() instanceof GraphTDB) ;
+    }
+
+    @Override
+    protected QueryIterator exec(Op op, QueryIterator input) {
+        if ( level < 0 )
+            // Print only at top level (and we're called before level++) 
+            Explain.explain("TDB", op, super.execCxt.getContext()) ;
+        return super.exec(op, input) ;
+    } 
+    
+    // Retrieving nodes isn't so bad because they will be needed anyway.
+    // And if their duplicates, likely to be cached.
+    // Need to work with SolverLib which wraps the NodeId bindgins with a converter. 
+    
+    @Override
+    protected QueryIterator execute(OpDistinct opDistinct, QueryIterator input)
+    {
+        return super.execute(opDistinct, input) ;
+    }
+    
+    @Override
+    protected QueryIterator execute(OpReduced opReduced, QueryIterator input)
+    {
+        return super.execute(opReduced, input) ;
+    }
+    
+    @Override
+    protected QueryIterator execute(OpFilter opFilter, QueryIterator input)
+    {
+        if ( ! isForTDB )
+            return super.execute(opFilter, input) ;
+        
+        // If the filter does not apply to the input??
+        // Where does ARQ catch this?
+        
+        // (filter (bgp ...))
+        if ( OpBGP.isBGP(opFilter.getSubOp()) )
+        {
+            // Still may be a TDB graph in a non-TDB dataset (e.g. a named model)
+            GraphTDB graph = (GraphTDB)execCxt.getActiveGraph() ;
+            OpBGP opBGP = (OpBGP)opFilter.getSubOp() ;
+            return executeBGP(graph, opBGP, input, opFilter.getExprs(), execCxt) ;
+        }
+        
+        // (filter (quadpattern ...))
+        if ( opFilter.getSubOp() instanceof OpQuadPattern )
+        {
+            OpQuadPattern quadPattern = (OpQuadPattern)opFilter.getSubOp() ;
+            DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
+            return optimizeExecuteQuads(ds, input,
+                                        quadPattern.getGraphNode(), quadPattern.getBasicPattern(),
+                                        opFilter.getExprs(), execCxt) ;
+        }
+    
+        // (filter (anything else))
+        return super.execute(opFilter, input) ;
+        }
+
+    // ---- Triple patterns
+    
+    @Override
+    protected QueryIterator execute(OpBGP opBGP, QueryIterator input)
+    {
+        if ( ! isForTDB )
+            return super.execute(opBGP, input) ;
+        
+        GraphTDB graph = (GraphTDB)execCxt.getActiveGraph() ;
+        return executeBGP(graph, opBGP, input, null, execCxt) ;
+       
+    }
+
+    @Override
+    protected QueryIterator execute(OpQuadPattern quadPattern, QueryIterator input)
+    {
+        if ( ! isForTDB )
+            return super.execute(quadPattern, input) ;
+            
+    //        DatasetGraph dg = execCxt.getDataset() ;
+    //        if ( ! ( dg instanceof DatasetGraphTDB ) )
+    //            throw new InternalErrorException("Not a TDB backed dataset in quad pattern execution") ;
+        
+        DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
+        BasicPattern bgp = quadPattern.getBasicPattern() ;
+        Node gn = quadPattern.getGraphNode() ;
+        return optimizeExecuteQuads(ds, input, gn, bgp, null, execCxt) ;
+    }
+
+    @Override
+    protected QueryIterator execute(OpGraph opGraph, QueryIterator input)
+    {
+        // Path evaluation or dataset sets which do not go straight to the DatasetGraphTDB  
+        return new QueryIterGraph(input, opGraph, execCxt) ;
+    }
+
+    /** Execute a BGP (and filters) on a TDB graph, which may be in default storage or it may be a named graph */ 
+    private static QueryIterator executeBGP(GraphTDB graph, OpBGP opBGP, QueryIterator input, ExprList exprs, 
+                                            ExecutionContext execCxt)
+    {
+        // Is it the real default graph (normal route or explicitly named)?
+        if ( ! isDefaultGraphStorage(graph.getGraphName()))
+        {
+            // Not default storage - it's a named graph in storage. 
+            DatasetGraphTDB ds = graph.getDSG() ;
+            return optimizeExecuteQuads(ds, input, graph.getGraphName(), opBGP.getPattern(), exprs, execCxt) ;
+        }
+        
+        // Execute a BGP on the real default graph
+        return optimizeExecuteTriples(graph, input, opBGP.getPattern(), exprs, execCxt) ;
+    }
+
+    /** Execute, with optimization, a basic graph pattern on the default graph storage */
+    private static QueryIterator optimizeExecuteTriples(GraphTDB graph, QueryIterator input,
+                                                        BasicPattern pattern, ExprList exprs,
+                                                        ExecutionContext execCxt)
+    {
+        if ( ! input.hasNext() )
+            return input ;
+    
+        // -- Input
+        // Must pass this iterator into the next stage.
+        if ( pattern.size() >= 2 )
+        {
+            // Must be 2 or triples to reorder. 
+            ReorderTransformation transform = graph.getDSG().getReorderTransform() ;
+            if ( transform != null )
+            {
+                QueryIterPeek peek = QueryIterPeek.create(input, execCxt) ;
+                input = peek ; // Must pass on
+                pattern = reorder(pattern, peek, transform) ;
+            }
+        }
+        // -- Filter placement
+            
+        Op op = null ;
+        if ( exprs != null )
+            op = TransformFilterPlacement.transform(exprs, pattern) ;
+        else
+            op = new OpBGP(pattern) ;
+        
+        return plainExecute(op, input, execCxt) ;
+    }
+
+    /** Execute, with optimization, a quad pattern */
+    private static QueryIterator optimizeExecuteQuads(DatasetGraphTDB ds, 
+                                                      QueryIterator input, 
+                                                      Node gn, BasicPattern bgp,
+                                                      ExprList exprs, ExecutionContext execCxt)
+    {
+        if ( ! input.hasNext() )
+            return input ;
+
+        // ---- Graph names with special meaning. 
+
+        gn = decideGraphNode(gn, execCxt) ;
+        if ( gn == null )
+            return optimizeExecuteTriples(ds.getDefaultGraphTDB(), input, bgp, exprs, execCxt) ;
+        
+        // ---- Execute quads+filters
+        if ( bgp.size() >= 2 )
+        {
+            ReorderTransformation transform = ds.getReorderTransform() ;
+    
+            if ( transform != null )
+            {
+                QueryIterPeek peek = QueryIterPeek.create(input, execCxt) ;
+                input = peek ; // Original input now invalid.
+                bgp = reorder(bgp, peek, transform) ;
+            }
+        }
+        // -- Filter placement
+        Op op = null ;
+        if ( exprs != null )
+            op = TransformFilterPlacement.transform(exprs, gn, bgp) ;
+        else
+            op = new OpQuadPattern(gn, bgp) ;
+
+        return plainExecute(op, input, execCxt) ;
+    }
+
+    /** Execute without modification of the op - does <b>not</b> apply special graph name translations */ 
+    private static QueryIterator plainExecute(Op op, QueryIterator input, ExecutionContext execCxt)
+    {
+        // -- Execute
+        // Switch to a non-reordering executor
+        // The Op may be a sequence due to TransformFilterPlacement
+        // so we need to do a full execution step, not go straight to the SolverLib.
+        
+        ExecutionContext ec2 = new ExecutionContext(execCxt) ;
+        ec2.setExecutor(plainFactory) ;
+
+        // Solve without going through this executor again.
+        // There would be issues of nested patterns but this is only a
+        // (filter (bgp...)) or (filter (quadpattern ...)) or sequences of these.
+        // so there are no nested patterns to reorder.
+        return QC.execute(op, input, ec2) ;
+    }
+
+    private static BasicPattern reorder(BasicPattern pattern, QueryIterPeek peek, ReorderTransformation transform)
+    {
+        if ( transform != null )
+        {
+            // This works by getting one result from the peek iterator,
+            // and creating the more gounded BGP. The tranform is used to
+            // determine the best order and the transformation is returned. This
+            // transform is applied to the unsubstituted pattern (which will be
+            // substituted as part of evaluation.
+            
+            if ( ! peek.hasNext() )
+                throw new ARQInternalErrorException("Peek iterator is already empty") ;
+ 
+            BasicPattern pattern2 = Substitute.substitute(pattern, peek.peek() ) ;
+            // Calculate the reordering based on the substituted pattern.
+            ReorderProc proc = transform.reorderIndexes(pattern2) ;
+            // Then reorder original patten
+            pattern = proc.reorder(pattern) ;
+        }
+        return pattern ;
+    }
+    
+    /** Handle special graph node names.  
+     * Returns null for default graph in storage (use the triple table).
+     * Returns Node.ANY for the union graph
+     */
+    public static Node decideGraphNode(Node gn, ExecutionContext execCxt)
+    {
+     // ---- Graph names with special meaning. 
+    
+        // Graph names with special meaning:
+        //   Quad.defaultGraphIRI -- the IRI used in GRAPH <> to mean the default graph.
+        //   Quad.defaultGraphNodeGenerated -- the internal marker node used for the quad form of queries.
+        //   Quad.unionGraph -- the IRI used in GRAPH <> to mean the union of named graphs
+    
+        if ( isDefaultGraphStorage(gn) ) 
+        {
+            // Storage concrete, default graph. 
+            // Either outside GRAPH (no implicit union)
+            // or using the "name" of the default graph
+            return null ;
+        }
+
+        // Not default storage graph.
+        // ---- Union (RDF Merge) of named graphs
+
+        if ( Quad.isUnionGraph(gn) ) 
+            return Node.ANY ;
+        boolean doingUnion = false ;
+        
+        return gn ;
+    }
+
+    // Is this a query against the real default graph in the storage (in a 3-tuple table). 
+    private static boolean isDefaultGraphStorage(Node gn)
+    {
+        if ( gn == null )
+            return true ;
+        
+        // Is it the implicit name for default graph.
+        if ( Quad.isDefaultGraph(gn) )
+            // Not accessing the union of named graphs as the default graph
+            // and pattern is directed to the default graph.
+            return true ;
+    
+        return false ;
+    }
+    
+    @Override
+    protected QueryIterator execute(OpDatasetNames dsNames, QueryIterator input)
+    { 
+        DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
+        Predicate<Tuple<NodeId>> filter = QC2.getFilter(execCxt.getContext()) ;
+        Node gn = dsNames.getGraphNode() ;
+        if ( Var.isVar(gn) )
+            return SolverLib.graphNames(ds, dsNames.getGraphNode(), input, filter, execCxt) ;
+        else
+            return SolverLib.testForGraphName(ds, dsNames.getGraphNode(), input, filter, execCxt) ;
+    }
+
+    // ---- OpExecute factories and plain executor.
+    
+    private static OpExecutorFactory plainFactory = new OpExecutorPlainFactoryTDB() ;
+    private static class OpExecutorPlainFactoryTDB implements OpExecutorFactory
+    {
+        @Override
+        public OpExecutor create(ExecutionContext execCxt)
+        {
+            return new OpExecutorPlainTDB(execCxt) ;
+        }
+    }
+
+    /** An op executor that simply executes a BGP or QuadPattern without any reordering */ 
+    private static class OpExecutorPlainTDB extends OpExecutor
+    {
+        Predicate<Tuple<NodeId>> filter = null ;
+        
+        public OpExecutorPlainTDB(ExecutionContext execCxt)
+        {
+            super(execCxt) ;
+            filter = QC2.getFilter(execCxt.getContext()) ;
+        }
+        
+        @Override
+        public QueryIterator execute(OpBGP opBGP, QueryIterator input)
+        {
+            Graph g = execCxt.getActiveGraph() ;
+            
+            if ( g instanceof GraphTDB )
+            {
+                BasicPattern bgp = opBGP.getPattern() ;
+                Explain.explain("Execute", bgp, execCxt.getContext()) ;
+                // Triple-backed (but may be named as explicit default graph).
+                //return SolverLib.execute((GraphTDB)g, bgp, input, filter, execCxt) ;
+                GraphTDB gtdb = (GraphTDB)g ;
+                Node gn = decideGraphNode(gtdb.getGraphName(), execCxt) ;
+                return SolverLib.execute(gtdb.getDSG(), gn, bgp, input, filter, execCxt) ;
+            }
+            Log.warn(this, "Non-GraphTDB passed to OpExecutorPlainTDB") ;
+            return super.execute(opBGP, input) ;
+        }
+        
+        @Override
+        public QueryIterator execute(OpQuadPattern opQuadPattern, QueryIterator input)
+        {
+            Node gn = opQuadPattern.getGraphNode() ;
+            gn = decideGraphNode(gn, execCxt) ;
+            
+            if ( execCxt.getDataset() instanceof DatasetGraphTDB )
+            {
+                DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
+                Explain.explain("Execute", opQuadPattern.getPattern(), execCxt.getContext()) ;
+                BasicPattern bgp = opQuadPattern.getBasicPattern() ;
+                return SolverLib.execute(ds, gn, bgp, input, filter, execCxt) ;
+            }
+            // Maybe a TDB named graph inside a non-TDB dataset.
+            Graph g = execCxt.getActiveGraph() ;
+            if ( g instanceof GraphTDB )
+            {
+                // Triples graph from TDB (which is the default graph of the dataset),
+                // used a named graph in a composite dataset.
+                BasicPattern bgp = opQuadPattern.getBasicPattern() ;
+                Explain.explain("Execute", bgp, execCxt.getContext()) ;
+                // Don't pass in G -- gn may be different.
+                return SolverLib.execute(((GraphTDB)g).getDSG(), gn, bgp, input, filter, execCxt) ;
+            }
+            Log.warn(this, "Non-DatasetGraphTDB passed to OpExecutorPlainTDB") ;
+            return super.execute(opQuadPattern, input) ;
+        }
+
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QC2.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QC2.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QC2.java
new file mode 100644
index 0000000..181acbf
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QC2.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.function.Predicate;
+
+import org.apache.jena.atlas.lib.tuple.Tuple ;
+import org.apache.jena.sparql.util.Context ;
+import org.apache.jena.tdb2.TDBException;
+import org.apache.jena.tdb2.store.NodeId;
+import org.apache.jena.tdb2.sys.SystemTDB;
+
+public class QC2
+{
+    public static Predicate<Tuple<NodeId>> getFilter(Context context)
+    {
+        Object x = context.get(SystemTDB.symTupleFilter) ;
+
+        try {
+            @SuppressWarnings("unchecked")
+            Predicate<Tuple<NodeId>> f = (Predicate<Tuple<NodeId>>)x ;
+            return f ;
+        } catch (ClassCastException ex)
+        {
+            throw new TDBException("Not a Filter<Tuple<NodeId>>:"+x, ex) ;
+        }
+    }
+
+    public static void setFilter(Context context, Predicate<Tuple<NodeId>> filter)
+    {
+        context.set(SystemTDB.symTupleFilter, filter) ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryEngineTDB.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryEngineTDB.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryEngineTDB.java
new file mode 100644
index 0000000..f57f76f
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryEngineTDB.java
@@ -0,0 +1,207 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import org.apache.jena.atlas.lib.Lib ;
+import org.apache.jena.query.Query ;
+import org.apache.jena.sparql.algebra.Algebra ;
+import org.apache.jena.sparql.algebra.Op ;
+import org.apache.jena.sparql.core.DatasetDescription ;
+import org.apache.jena.sparql.core.DatasetGraph ;
+import org.apache.jena.sparql.core.DynamicDatasets ;
+import org.apache.jena.sparql.core.Substitute ;
+import org.apache.jena.sparql.engine.Plan ;
+import org.apache.jena.sparql.engine.QueryEngineFactory ;
+import org.apache.jena.sparql.engine.QueryEngineRegistry ;
+import org.apache.jena.sparql.engine.QueryIterator ;
+import org.apache.jena.sparql.engine.binding.Binding ;
+import org.apache.jena.sparql.engine.binding.BindingFactory ;
+import org.apache.jena.sparql.engine.iterator.QueryIteratorWrapper ;
+import org.apache.jena.sparql.engine.main.QueryEngineMain ;
+import org.apache.jena.sparql.mgt.Explain ;
+import org.apache.jena.sparql.util.Context ;
+import org.apache.jena.tdb2.TDB2;
+import org.apache.jena.tdb2.TDBException;
+import org.apache.jena.tdb2.migrate.A2;
+import org.apache.jena.tdb2.store.DatasetGraphTDB;
+import org.apache.jena.tdb2.sys.TDBInternal;
+
+// This exists to intercept the query execution setup.
+//  e.g choose the transformation optimizations
+// then to make the quad form.
+// TDB also uses a custom OpExecutor to intercept certain part 
+// of the Op evaluations
+
+public class QueryEngineTDB extends QueryEngineMain
+{
+    // ---- Wiring
+    static public QueryEngineFactory getFactory() { return factory ; } 
+    static public void register()       { QueryEngineRegistry.addFactory(factory) ; }
+    static public void unregister()     { QueryEngineRegistry.removeFactory(factory) ; }
+    
+    private Binding initialInput ;
+
+    // ---- Object
+    protected QueryEngineTDB(Op op, DatasetGraphTDB dataset, Binding input, Context context)
+    {
+        super(op, dataset, input, context) ;
+        this.initialInput = input ;
+    }
+    
+    private boolean doingDynamicDatasetBySpecialDataset = false ;
+    
+    protected QueryEngineTDB(Query query, DatasetGraphTDB dataset, Binding input, Context cxt)
+    { 
+        super(query, dataset, input, cxt) ; 
+        DatasetDescription dsDesc = DatasetDescription.create(query, context) ;
+        
+        if ( dsDesc != null )
+        {
+            doingDynamicDatasetBySpecialDataset = true ;
+            super.dataset = DynamicDatasets.dynamicDataset(dsDesc, dataset, cxt.isTrue(TDB2.symUnionDefaultGraph) ) ;
+        }
+        this.initialInput = input ; 
+    }
+    
+    // Choose the algebra-level optimizations to invoke. 
+    @Override
+    protected Op modifyOp(Op op)
+    {
+        op = Substitute.substitute(op, initialInput) ;
+        // Optimize (high-level)
+        op = super.modifyOp(op) ;
+
+        // Quadification
+        // Only apply if not a rewritten DynamicDataset
+        if ( ! doingDynamicDatasetBySpecialDataset )
+            op = Algebra.toQuadForm(op) ;
+        
+        // Record it.
+        setOp(op) ;
+        return op ;
+    }
+
+    @Override
+    public QueryIterator eval(Op op, DatasetGraph dsg, Binding input, Context context)
+    {
+        // Top of execution of a query.
+        // Op is quad'ed by now but there still may be some (graph ....) forms e.g. paths
+        
+        // Fix DatasetGraph for global union.
+        if ( context.isTrue(TDB2.symUnionDefaultGraph) && ! doingDynamicDatasetBySpecialDataset ) 
+        {
+            op = A2.unionDefaultGraphQuads(op) ;
+            Explain.explain("REWRITE(Union default graph)", op, context) ;
+        }
+        QueryIterator results = super.eval(op, dsg, input, context) ;
+        results = new QueryIteratorMaterializeBinding(results) ;
+        return results ; 
+    }
+    
+    /** Copy from any TDB internal BindingTDB to a Binding that
+     *  does not have any connection to the database.   
+     */
+    static class QueryIteratorMaterializeBinding extends QueryIteratorWrapper
+    {
+        public QueryIteratorMaterializeBinding(QueryIterator qIter)
+        {
+            super(qIter) ;
+        }
+        
+        @Override
+        protected Binding moveToNextBinding()
+        { 
+            Binding b = super.moveToNextBinding() ;
+            b = BindingFactory.materialize(b) ;
+            return b ;
+        }
+    }
+    
+    // Execution time (needs wiring to ARQ).
+    public long getMillis() { return -1 ; }
+    
+    // ---- Factory
+    protected static QueryEngineFactory factory = new QueryEngineFactoryTDB() ;
+        
+    protected static class QueryEngineFactoryTDB implements QueryEngineFactory
+    {
+        private static boolean isHandledByTDB(DatasetGraph dataset) {
+            return TDBInternal.isBackedByTDB(dataset);
+        }
+        
+        protected DatasetGraphTDB dsgToQuery(DatasetGraph dataset) {
+            try { 
+                return TDBInternal.requireStorage(dataset);
+            } catch (TDBException ex) {
+                // Check to a more specific message. 
+                throw new TDBException("Internal inconsistency: trying to execute query on unrecognized kind of DatasetGraph: "+Lib.className(dataset)) ;
+            }
+        }
+        
+        @Override
+        public boolean accept(Query query, DatasetGraph dataset, Context context) 
+        { return isHandledByTDB(dataset) ; }
+
+        @Override
+        public Plan create(Query query, DatasetGraph dataset, Binding input, Context context)
+        {
+            QueryEngineTDB engine = new QueryEngineTDB(query, dsgToQuery(dataset), input, context) ;
+            return engine.getPlan() ;
+        }
+        
+        @Override
+        public boolean accept(Op op, DatasetGraph dataset, Context context) 
+        { return isHandledByTDB(dataset) ; }
+
+        @Override
+        public Plan create(Op op, DatasetGraph dataset, Binding binding, Context context)
+        {
+            QueryEngineTDB engine = new QueryEngineTDB(op, dsgToQuery(dataset), binding, context) ;
+            return engine.getPlan() ;
+        }
+    }
+    
+//    // By rewrite, not using a general purpose dataset with the right graphs in.
+//    private static Op dynamicDatasetOp(Op op,  Context context)
+//    {
+//        Transform transform = null ;
+//    
+//        try {
+//            @SuppressWarnings("unchecked")
+//            Set<Node> defaultGraphs = (Set<Node>)(context.get(SystemTDB.symDatasetDefaultGraphs)) ;
+//            @SuppressWarnings("unchecked")
+//            Set<Node> namedGraphs = (Set<Node>)(context.get(SystemTDB.symDatasetNamedGraphs)) ;
+//            if ( defaultGraphs != null || namedGraphs != null )
+//                transform = new TransformDynamicDataset(defaultGraphs, 
+//                                                        namedGraphs, 
+//                                                        context.isTrue(TDB.symUnionDefaultGraph)) ;
+//        } catch (ClassCastException ex)
+//        {
+//            Log.warn(QueryEngineTDB.class, "Bad dynamic dataset description (ClassCastException)", ex) ;
+//            transform = null ;
+//            return op ;
+//        }
+//
+//        // Apply dynamic dataset modifications.
+//        if ( transform != null )
+//            op = Transformer.transform(transform, op) ;
+//        return op ;
+//    }        
+//    
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryIterTDB.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryIterTDB.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryIterTDB.java
new file mode 100644
index 0000000..b4ebc3e
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/QueryIterTDB.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.Iterator ;
+import java.util.List ;
+
+import org.apache.jena.sparql.engine.ExecutionContext ;
+import org.apache.jena.sparql.engine.QueryIterator ;
+import org.apache.jena.sparql.engine.binding.Binding ;
+import org.apache.jena.sparql.engine.iterator.QueryIterPlainWrapper ;
+
+public class QueryIterTDB extends QueryIterPlainWrapper
+{
+    final private QueryIterator originalInput ;
+    private List<Abortable> killList ;
+    
+    // The original input needs closing as well.
+    public QueryIterTDB(Iterator<Binding> iterBinding, List<Abortable> killList , QueryIterator originalInput, ExecutionContext execCxt)
+    {
+        super(iterBinding, execCxt) ;
+        this.originalInput = originalInput ;
+        this.killList = killList ;
+    }
+    
+    @Override
+    protected void closeIterator()
+    { 
+        if ( originalInput != null )
+            originalInput.close();
+        super.closeIterator() ;
+    }
+
+    @Override
+    protected void requestCancel()
+    { 
+        if ( killList != null )
+            for ( Abortable it : killList )
+                it.abort() ;
+        if ( originalInput != null )
+            originalInput.cancel(); 
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/3d456654/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/SolverLib.java
----------------------------------------------------------------------
diff --git a/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/SolverLib.java b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/SolverLib.java
new file mode 100644
index 0000000..3f0cc3c
--- /dev/null
+++ b/jena-db/jena-tdb2/src/main/java/org/apache/jena/tdb2/solver/SolverLib.java
@@ -0,0 +1,341 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.tdb2.solver;
+
+import java.util.* ;
+import java.util.function.Function ;
+import java.util.function.Predicate ;
+
+import org.apache.jena.atlas.iterator.Iter ;
+import org.apache.jena.atlas.iterator.IteratorWrapper ;
+import org.apache.jena.atlas.lib.tuple.Tuple ;
+import org.apache.jena.atlas.lib.tuple.TupleFactory ;
+import org.apache.jena.graph.Node ;
+import org.apache.jena.graph.Triple ;
+import org.apache.jena.query.QueryCancelledException ;
+import org.apache.jena.sparql.core.BasicPattern ;
+import org.apache.jena.sparql.core.Quad ;
+import org.apache.jena.sparql.core.Var ;
+import org.apache.jena.sparql.engine.ExecutionContext ;
+import org.apache.jena.sparql.engine.QueryIterator ;
+import org.apache.jena.sparql.engine.binding.Binding ;
+import org.apache.jena.sparql.engine.binding.BindingFactory ;
+import org.apache.jena.sparql.engine.binding.BindingMap ;
+import org.apache.jena.sparql.engine.iterator.QueryIterNullIterator ;
+import org.apache.jena.tdb2.TDBException;
+import org.apache.jena.tdb2.lib.NodeLib;
+import org.apache.jena.tdb2.store.DatasetGraphTDB;
+import org.apache.jena.tdb2.store.GraphTDB;
+import org.apache.jena.tdb2.store.NodeId;
+import org.apache.jena.tdb2.store.nodetable.NodeTable;
+import org.apache.jena.tdb2.store.nodetupletable.NodeTupleTable;
+import org.apache.jena.tdb2.sys.TDBInternal;
+import org.slf4j.Logger ;
+import org.slf4j.LoggerFactory ;
+
+/** Utilities used within the TDB BGP solver : local TDB store */
+public class SolverLib
+{
+    private static Logger log = LoggerFactory.getLogger(SolverLib.class) ; 
+    
+    /** Non-reordering execution of a basic graph pattern, given a iterator of bindings as input */ 
+    public static QueryIterator execute(GraphTDB graph, BasicPattern pattern, 
+                                        QueryIterator input, Predicate<Tuple<NodeId>> filter,
+                                        ExecutionContext execCxt)
+    {
+        // Maybe default graph or named graph.
+        NodeTupleTable ntt = graph.getNodeTupleTable() ;
+        return execute(ntt, graph.getGraphName(), pattern, input, filter, execCxt) ;
+    }
+    
+    /** Non-reordering execution of a quad pattern, given a iterator of bindings as input.
+     *  GraphNode is Node.ANY for execution over the union of named graphs.
+     *  GraphNode is null for execution over the real default graph.
+     */ 
+    public static QueryIterator execute(DatasetGraphTDB ds, Node graphNode, BasicPattern pattern,
+                                        QueryIterator input, Predicate<Tuple<NodeId>> filter,
+                                        ExecutionContext execCxt)
+    {
+        NodeTupleTable ntt = ds.chooseNodeTupleTable(graphNode) ;
+        return execute(ntt, graphNode, pattern, input, filter, execCxt) ;
+    }
+    
+    public static Iterator<BindingNodeId> convertToIds(Iterator<Binding> iterBindings, NodeTable nodeTable)
+    { return Iter.map(iterBindings, convFromBinding(nodeTable)) ; }
+    
+    /** Convert from Iterator<BindingNodeId> to Iterator<Binding>, conversion "on demand" 
+     * (in convToBinding(BindingNodeId, NodeTable)
+     */
+    public static Iterator<Binding> convertToNodes(Iterator<BindingNodeId> iterBindingIds, NodeTable nodeTable)
+    { return Iter.map(iterBindingIds, bindingNodeIds -> convToBinding(bindingNodeIds, nodeTable)) ; }
+    
+    // The worker.  Callers choose the NodeTupleTable.  
+    //     graphNode may be Node.ANY, meaning we should make triples unique.
+    //     graphNode may be null, meaning default graph
+
+    private static QueryIterator execute(NodeTupleTable nodeTupleTable, Node graphNode, BasicPattern pattern, 
+                                         QueryIterator input, Predicate<Tuple<NodeId>> filter,
+                                         ExecutionContext execCxt)
+    {
+        if ( Quad.isUnionGraph(graphNode) )
+            graphNode = Node.ANY ;
+        if ( Quad.isDefaultGraph(graphNode) )
+            graphNode = null ;
+        
+        List<Triple> triples = pattern.getList() ;
+        boolean anyGraph = (graphNode==null ? false : (Node.ANY.equals(graphNode))) ;
+        
+        int tupleLen = nodeTupleTable.getTupleTable().getTupleLen() ;
+        if ( graphNode == null ) {
+            if ( 3 != tupleLen )
+                throw new TDBException("SolverLib: Null graph node but tuples are of length "+tupleLen) ;
+        } else {
+            if ( 4 != tupleLen )
+                throw new TDBException("SolverLib: Graph node specified but tuples are of length "+tupleLen) ;
+        }
+        
+        // Convert from a QueryIterator (Bindings of Var/Node) to BindingNodeId
+        NodeTable nodeTable = nodeTupleTable.getNodeTable() ;
+        
+        Iterator<BindingNodeId> chain = Iter.map(input, SolverLib.convFromBinding(nodeTable)) ;
+        List<Abortable> killList = new ArrayList<>() ;
+        
+        for ( Triple triple : triples )
+        {
+            Tuple<Node> tuple = null ;
+            if ( graphNode == null )
+                // 3-tuples
+                tuple = TupleFactory.tuple(triple.getSubject(), triple.getPredicate(), triple.getObject()) ;
+            else
+                // 4-tuples.
+                tuple = TupleFactory.tuple(graphNode, triple.getSubject(), triple.getPredicate(), triple.getObject()) ;
+            chain = solve(nodeTupleTable, tuple, anyGraph, chain, filter, execCxt) ;
+            chain = makeAbortable(chain, killList) ; 
+        }
+        
+        // DEBUG POINT
+        if ( false )
+        {
+            if ( chain.hasNext())
+                chain = Iter.debug(chain) ;
+            else
+                System.out.println("No results") ;
+        }
+        
+        // Timeout wrapper ****
+        // QueryIterTDB gets called async.
+        // Iter.abortable?
+        // Or each iterator has a place to test.
+        // or pass in a thing to test?
+        
+        
+        // Need to make sure the bindings here point to parent.
+        Iterator<Binding> iterBinding = convertToNodes(chain, nodeTable) ;
+        
+        // "input" will be closed by QueryIterTDB but is otherwise unused.
+        // "killList" will be aborted on timeout.
+        return new QueryIterTDB(iterBinding, killList, input, execCxt) ;
+    }
+    
+    /** Create an abortable iterator, storing it in the killList.
+     *  Just return the input iterator if kilList is null. 
+     */
+    static <T> Iterator<T> makeAbortable(Iterator<T> iter, List<Abortable> killList)
+    {
+        if ( killList == null )
+            return iter ;
+        IterAbortable<T> k = new IterAbortable<>(iter) ;
+        killList.add(k) ;
+        return k ;
+    }
+    
+    /** Iterator that adds an abort operation which can be called
+     *  at any time, including from another thread, and causes the
+     *  iterator to throw an exception when next touched (hasNext, next).  
+     */
+    static class IterAbortable<T> extends IteratorWrapper<T> implements Abortable
+    {
+        volatile boolean abortFlag = false ;
+        
+        public IterAbortable(Iterator<T> iterator)
+        {
+            super(iterator) ;
+        }
+        
+        /** Can call asynchronously at anytime */
+        @Override
+        public void abort() { 
+            abortFlag = true ;
+        }
+        
+        @Override
+        public boolean hasNext()
+        {
+            if ( abortFlag )
+                throw new QueryCancelledException() ;
+            return iterator.hasNext() ; 
+        }
+        
+        @Override
+        public T next()
+        {
+            if ( abortFlag )
+                throw new QueryCancelledException() ;
+            return iterator.next() ; 
+        }
+    }
+    
+    public static Iterator<BindingNodeId> solve(NodeTupleTable nodeTupleTable, 
+                                                Tuple<Node> tuple,
+                                                boolean anyGraph,
+                                                Iterator<BindingNodeId> chain, Predicate<Tuple<NodeId>> filter,
+                                                ExecutionContext execCxt)
+    {
+        return new StageMatchTuple(nodeTupleTable, chain, tuple, anyGraph, filter, execCxt) ;
+    }
+
+    public static Binding convToBinding(BindingNodeId bindingNodeIds, NodeTable nodeTable) {
+        if ( true )
+            return new BindingTDB(bindingNodeIds, nodeTable) ;
+        else {
+            // Makes nodes immediately. Causing unnecessary NodeTable accesses
+            // (e.g. project)
+            BindingMap b = BindingFactory.create() ;
+            for (Var v : bindingNodeIds) {
+                NodeId id = bindingNodeIds.get(v) ;
+                Node n = nodeTable.getNodeForNodeId(id) ;
+                b.add(v, n) ;
+            }
+            return b ;
+        }
+    }
+    
+    // Transform : Binding ==> BindingNodeId
+    public static Function<Binding, BindingNodeId> convFromBinding(final NodeTable nodeTable)
+    {
+        return binding -> SolverLib.convert(binding, nodeTable);
+    }
+    
+    /** Binding ==> BindingNodeId, given a NodeTable */
+    public static BindingNodeId convert(Binding binding, NodeTable nodeTable) 
+    {
+        if ( binding instanceof BindingTDB )
+            return ((BindingTDB)binding).getBindingId() ;
+
+        BindingNodeId b = new BindingNodeId(binding) ;
+        // and copy over, getting NodeIds.
+        Iterator<Var> vars = binding.vars() ;
+
+        for ( ; vars.hasNext() ; )
+        {
+            Var v = vars.next() ;
+            Node n = binding.get(v) ;  
+            if ( n == null )
+                // Variable mentioned in the binding but not actually defined.
+                // Can occur with BindingProject
+                continue ;
+
+            // Rely on the node table cache for efficency - we will likely be
+            // repeatedly looking up the same node in different bindings.
+            NodeId id = nodeTable.getNodeIdForNode(n) ;
+            // Even put in "does not exist" for a node now known not to be in the DB.
+            b.put(v, id) ;
+        }
+        return b ;
+    }
+    
+    /** Find whether a specific graph name is in the quads table. */
+    public static QueryIterator testForGraphName(DatasetGraphTDB ds, Node graphNode, QueryIterator input,
+                                                 Predicate<Tuple<NodeId>> filter, ExecutionContext execCxt) {
+        NodeId nid = TDBInternal.getNodeId(ds, graphNode) ;
+        boolean exists = !NodeId.isDoesNotExist(nid) ;
+        if ( exists ) {
+            // Node exists but is it used in the quad position?
+            NodeTupleTable ntt = ds.getQuadTable().getNodeTupleTable() ;
+            // Don't worry about abortable - this iterator should be fast
+            // (with normal indexing - at least one G???).
+            // Either it finds a starting point, or it doesn't.  We are only 
+            // interested in the first .hasNext.
+            Iterator<Tuple<NodeId>> iter1 = ntt.find(nid, NodeId.NodeIdAny, NodeId.NodeIdAny, NodeId.NodeIdAny) ;
+            if ( filter != null )
+                iter1 = Iter.filter(iter1, filter) ;
+            exists = iter1.hasNext() ;
+        }
+
+        if ( exists )
+            return input ;
+        else {
+            input.close() ;
+            return QueryIterNullIterator.create(execCxt) ;
+        }
+    }
+
+    /** Find all the graph names in the quads table. */
+    public static QueryIterator graphNames(DatasetGraphTDB ds, Node graphNode, QueryIterator input,
+                                           Predicate<Tuple<NodeId>> filter, ExecutionContext execCxt) {
+        List<Abortable> killList = new ArrayList<>() ;
+        Iterator<Tuple<NodeId>> iter1 = ds.getQuadTable().getNodeTupleTable().find(NodeId.NodeIdAny, NodeId.NodeIdAny,
+                                                                                   NodeId.NodeIdAny, NodeId.NodeIdAny) ;
+        if ( filter != null )
+            iter1 = Iter.filter(iter1, filter) ;
+
+        Iterator<NodeId> iter2 = Iter.map(iter1, t -> t.get(0)) ;
+        // Project is cheap - don't brother wrapping iter1
+        iter2 = makeAbortable(iter2, killList) ;
+
+        Iterator<NodeId> iter3 = Iter.distinct(iter2) ;
+        iter3 = makeAbortable(iter3, killList) ;
+
+        Iterator<Node> iter4 = NodeLib.nodes(ds.getQuadTable().getNodeTupleTable().getNodeTable(), iter3) ;
+
+        final Var var = Var.alloc(graphNode) ;
+        Iterator<Binding> iterBinding = Iter.map(iter4, node -> BindingFactory.binding(var, node)) ;
+        // Not abortable.
+        return new QueryIterTDB(iterBinding, killList, input, execCxt) ;
+    }
+
+    public static Set<NodeId> convertToNodeIds(Collection<Node> nodes, DatasetGraphTDB dataset)
+    {
+        Set<NodeId> graphIds = new HashSet<>() ;
+        NodeTable nt = dataset.getQuadTable().getNodeTupleTable().getNodeTable() ;
+        for ( Node n : nodes )
+            graphIds.add(nt.getNodeIdForNode(n)) ;
+        return graphIds ;
+    }
+
+    public static Iterator<Tuple<NodeId>> unionGraph(NodeTupleTable ntt)
+    {
+        Iterator<Tuple<NodeId>> iter = ntt.find((NodeId)null, null, null, null) ;
+        iter = Iter.map(iter, quadsToAnyTriples) ;
+        //iterMatches = Iter.distinct(iterMatches) ;
+        
+        // This depends on the way indexes are choose and
+        // the indexing pattern. It assumes that the index 
+        // chosen ends in G so same triples are adjacent 
+        // in a union query.
+        /// See TupleTable.scanAllIndex that ensures this.
+        iter = Iter.distinctAdjacent(iter) ;
+        return iter ;
+    }
+    
+    private static Function<Tuple<NodeId>, Tuple<NodeId>> quadsToAnyTriples = item -> {
+        return TupleFactory.create4(NodeId.NodeIdAny, item.get(1), item.get(2), item.get(3) ) ;
+    } ;
+
+}


Mime
View raw message