NodeSQL (OpenAnzo 2.5.1 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.openanzo.common.rdb.sql
Class NodeSQL

java.lang.Object
  org.openanzo.common.rdb.sql.NodeSQL

public class NodeSQL
extends java.lang.Object
extends java.lang.Object

NodeSQL provides wrappers around SQL queries and transforms ResultSets into java objects

Author:: Generated Source from org.openanzo.jdbc.utils.opgen.jet

Nested Class Summary
`static class`	`NodeSQL.BatchInsertCommonValue` Batch operation for adding parameters to the InsertCommonValue prepared statement
`static class`	`NodeSQL.BatchStoreBulkLiteral` Batch operation for adding parameters to the StoreBulkLiteral prepared statement
`static class`	`NodeSQL.BatchStoreBulkLongLiteral` Batch operation for adding parameters to the StoreBulkLongLiteral prepared statement
`static class`	`NodeSQL.BatchStoreBulkLongNode` Batch operation for adding parameters to the StoreBulkLongNode prepared statement
`static class`	`NodeSQL.BatchStoreBulkNode` Batch operation for adding parameters to the StoreBulkNode prepared statement
`static class`	`NodeSQL.BatchStoreResolveId` Batch operation for adding parameters to the StoreResolveId prepared statement
`static class`	`NodeSQL.BatchStoreResolveLiteral` Batch operation for adding parameters to the StoreResolveLiteral prepared statement
`static class`	`NodeSQL.BatchStoreResolveLiteralLong` Batch operation for adding parameters to the StoreResolveLiteralLong prepared statement
`static class`	`NodeSQL.BatchStoreResolveNode` Batch operation for adding parameters to the StoreResolveNode prepared statement
`static class`	`NodeSQL.BatchStoreResolveNodeLong` Batch operation for adding parameters to the StoreResolveNodeLong prepared statement
`static interface`	`NodeSQL.FetchAllCommonValuesResult` Interface for holding the results of the fetchAllCommonValues prepared statement.
`static class`	`NodeSQL.FetchAllCommonValuesResultImpl` Default implementation of FetchAllCommonValuesResult
`static interface`	`NodeSQL.FetchLiteralNodeIDParams` Interface for managing the parameters to the fetchLiteralNodeID prepared statement.
`static class`	`NodeSQL.FetchLiteralNodeIDParamsImpl` Default implementation of FetchLiteralNodeIDParams
`static interface`	`NodeSQL.FetchLiteralNodeValueResult` Interface for holding the results of the fetchLiteralNodeValue prepared statement.
`static class`	`NodeSQL.FetchLiteralNodeValueResultImpl` Default implementation of FetchLiteralNodeValueResult
`static interface`	`NodeSQL.FetchLongLiteralNodeIDParams` Interface for managing the parameters to the fetchLongLiteralNodeID prepared statement.
`static class`	`NodeSQL.FetchLongLiteralNodeIDParamsImpl` Default implementation of FetchLongLiteralNodeIDParams
`static interface`	`NodeSQL.FetchLongLiteralNodeIDResult` Interface for holding the results of the fetchLongLiteralNodeID prepared statement.
`static class`	`NodeSQL.FetchLongLiteralNodeIDResultImpl` Default implementation of FetchLongLiteralNodeIDResult
`static interface`	`NodeSQL.FetchLongNodeIDResult` Interface for holding the results of the fetchLongNodeID prepared statement.
`static class`	`NodeSQL.FetchLongNodeIDResultImpl` Default implementation of FetchLongNodeIDResult
`static interface`	`NodeSQL.FindNodeIDParams` Interface for managing the parameters to the findNodeID prepared statement.
`static class`	`NodeSQL.FindNodeIDParamsImpl` Default implementation of FindNodeIDParams
`static interface`	`NodeSQL.GetAllLiteralsResult` Interface for holding the results of the getAllLiterals prepared statement.
`static class`	`NodeSQL.GetAllLiteralsResultImpl` Default implementation of GetAllLiteralsResult
`static interface`	`NodeSQL.InsertCommonValueParams` Interface for managing the parameters to the insertCommonValue prepared statement.
`static class`	`NodeSQL.InsertCommonValueParamsImpl` Default implementation of InsertCommonValueParams
`static interface`	`NodeSQL.ResolveIdsLiteralResult` Interface for holding the results of the resolveIdsLiteral prepared statement.
`static class`	`NodeSQL.ResolveIdsLiteralResultImpl` Default implementation of ResolveIdsLiteralResult
`static interface`	`NodeSQL.ResolveIdsUriResult` Interface for holding the results of the resolveIdsUri prepared statement.
`static class`	`NodeSQL.ResolveIdsUriResultImpl` Default implementation of ResolveIdsUriResult
`static interface`	`NodeSQL.ResolveLiteralsResult` Interface for holding the results of the resolveLiterals prepared statement.
`static class`	`NodeSQL.ResolveLiteralsResultImpl` Default implementation of ResolveLiteralsResult
`static interface`	`NodeSQL.ResolveNodesResult` Interface for holding the results of the resolveNodes prepared statement.
`static class`	`NodeSQL.ResolveNodesResultImpl` Default implementation of ResolveNodesResult
`static interface`	`NodeSQL.SelectAllIdsResult` Interface for holding the results of the selectAllIds prepared statement.
`static class`	`NodeSQL.SelectAllIdsResultImpl` Default implementation of SelectAllIdsResult
`static interface`	`NodeSQL.SelectAllResolvedLiteralIdsResult` Interface for holding the results of the selectAllResolvedLiteralIds prepared statement.
`static class`	`NodeSQL.SelectAllResolvedLiteralIdsResultImpl` Default implementation of SelectAllResolvedLiteralIdsResult
`static interface`	`NodeSQL.SelectAllResolvedUriIdsResult` Interface for holding the results of the selectAllResolvedUriIds prepared statement.
`static class`	`NodeSQL.SelectAllResolvedUriIdsResultImpl` Default implementation of SelectAllResolvedUriIdsResult
`static interface`	`NodeSQL.SelectResolvedLiteralIdsResult` Interface for holding the results of the selectResolvedLiteralIds prepared statement.
`static class`	`NodeSQL.SelectResolvedLiteralIdsResultImpl` Default implementation of SelectResolvedLiteralIdsResult
`static interface`	`NodeSQL.SelectResolvedUriIdsResult` Interface for holding the results of the selectResolvedUriIds prepared statement.
`static class`	`NodeSQL.SelectResolvedUriIdsResultImpl` Default implementation of SelectResolvedUriIdsResult
`static interface`	`NodeSQL.StoreBulkLiteralParams` Interface for managing the parameters to the storeBulkLiteral prepared statement.
`static class`	`NodeSQL.StoreBulkLiteralParamsImpl` Default implementation of StoreBulkLiteralParams
`static interface`	`NodeSQL.StoreBulkLongLiteralParams` Interface for managing the parameters to the storeBulkLongLiteral prepared statement.
`static class`	`NodeSQL.StoreBulkLongLiteralParamsImpl` Default implementation of StoreBulkLongLiteralParams
`static interface`	`NodeSQL.StoreBulkLongNodeParams` Interface for managing the parameters to the storeBulkLongNode prepared statement.
`static class`	`NodeSQL.StoreBulkLongNodeParamsImpl` Default implementation of StoreBulkLongNodeParams
`static interface`	`NodeSQL.StoreBulkNodeParams` Interface for managing the parameters to the storeBulkNode prepared statement.
`static class`	`NodeSQL.StoreBulkNodeParamsImpl` Default implementation of StoreBulkNodeParams
`static interface`	`NodeSQL.StoreResolveLiteralLongParams` Interface for managing the parameters to the storeResolveLiteralLong prepared statement.
`static class`	`NodeSQL.StoreResolveLiteralLongParamsImpl` Default implementation of StoreResolveLiteralLongParams
`static interface`	`NodeSQL.StoreResolveLiteralParams` Interface for managing the parameters to the storeResolveLiteral prepared statement.
`static class`	`NodeSQL.StoreResolveLiteralParamsImpl` Default implementation of StoreResolveLiteralParams
`static interface`	`NodeSQL.StoreResolveNodeLongParams` Interface for managing the parameters to the storeResolveNodeLong prepared statement.
`static class`	`NodeSQL.StoreResolveNodeLongParamsImpl` Default implementation of StoreResolveNodeLongParams

Field Summary
`static java.lang.String`	`commitUnResolvedLiterals` Constant "commitUnResolvedLiterals" used to reference prepared statement node.commitUnResolvedLiterals `INSERT INTO ${b} (ID,MODIFIER_ID,VALUE) SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1`
`static java.lang.String`	`commitUnResolvedUris` Constant "commitUnResolvedUris" used to reference prepared statement node.commitUnResolvedUris `INSERT INTO ${b} (ID,VALUE) SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1`
`static java.lang.String`	`countTempTable` Constant "countTempTable" used to reference prepared statement node.countTempTable `SELECT COUNT(*) FROM ${a}`
`static java.lang.String`	`fetchAllCommonValues` Constant "fetchAllCommonValues" used to reference prepared statement node.fetchAllCommonValues `SELECT ID, VALUE FROM ${a}`
`static java.lang.String`	`fetchCommonValue` Constant "fetchCommonValue" used to reference prepared statement node.fetchCommonValue `SELECT VALUE FROM ${a} WHERE ID = ? ${b}`
`static java.lang.String`	`fetchCommonValueID` Constant "fetchCommonValueID" used to reference prepared statement node.fetchCommonValueID `SELECT ID FROM ${a} WHERE VALUE = ? ${b}`
`static java.lang.String`	`fetchLiteralNodeID` Constant "fetchLiteralNodeID" used to reference prepared statement node.fetchLiteralNodeID `SELECT ID FROM ${a} WHERE VALUE = ? AND MODIFIER_ID = ? ${b}`
`static java.lang.String`	`fetchLiteralNodeValue` Constant "fetchLiteralNodeValue" used to reference prepared statement node.fetchLiteralNodeValue `SELECT VALUE, MODIFIER_ID FROM ${a} WHERE ID = ? ${b}`
`static java.lang.String`	`fetchLongLiteralNodeID` Constant "fetchLongLiteralNodeID" used to reference prepared statement node.fetchLongLiteralNodeID `SELECT ID,VALUE FROM ${a} WHERE HASH = ? AND MODIFIER_ID = ?`
`static java.lang.String`	`fetchLongNodeID` Constant "fetchLongNodeID" used to reference prepared statement node.fetchLongNodeID `SELECT ID,VALUE FROM ${a} WHERE HASH = ?`
`static java.lang.String`	`fetchNodeID` Constant "fetchNodeID" used to reference prepared statement node.fetchNodeID `SELECT ID FROM ${a} WHERE VALUE = ? ${b}`
`static java.lang.String`	`fetchNodeValue` Constant "fetchNodeValue" used to reference prepared statement node.fetchNodeValue `SELECT VALUE FROM ${a} WHERE ID = ? ${b}`
`static java.lang.String`	`findNodeID` Constant "findNodeID" used to reference prepared statement node.findNodeID `SELECT ID FROM ${a} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ? ${b}`
`static java.lang.String`	`getAllLiterals` Constant "getAllLiterals" used to reference prepared statement node.getAllLiterals `SELECT ID,MODIFIER_ID,VALUE FROM ${a} ${b}`
`static java.lang.String`	`insertCommonValue` Constant "insertCommonValue" used to reference prepared statement node.insertCommonValue `INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)`
`static java.lang.String`	`purge` Constant "purge" used to reference prepared statement node.purge `DELETE FROM ${a}`
`static java.lang.String`	`resolveIdsLiteral` Constant "resolveIdsLiteral" used to reference prepared statement node.resolveIdsLiteral `SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a} WHERE ${b}.ID =${a}.ID`
`static java.lang.String`	`resolveIdsUri` Constant "resolveIdsUri" used to reference prepared statement node.resolveIdsUri `SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE ${b}.ID=${a}.ID`
`static java.lang.String`	`resolveLiterals` Constant "resolveLiterals" used to reference prepared statement node.resolveLiterals `SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a} WHERE ${b}.VALUE=${a}.VALUE AND ${b}.MODIFIER_ID = ${a}.MODIFIER_ID`
`static java.lang.String`	`resolveNodes` Constant "resolveNodes" used to reference prepared statement node.resolveNodes `SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE ${b}.VALUE=${a}.VALUE`
`static java.lang.String`	`selectAllIds` Constant "selectAllIds" used to reference prepared statement node.selectAllIds `SELECT ${a}.TYPE,${a}.ID,${a}.VALUE FROM ${a}`
`static java.lang.String`	`selectAllResolvedLiteralIds` Constant "selectAllResolvedLiteralIds" used to reference prepared statement node.selectAllResolvedLiteralIds `SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL`
`static java.lang.String`	`selectAllResolvedUriIds` Constant "selectAllResolvedUriIds" used to reference prepared statement node.selectAllResolvedUriIds `SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL`
`static java.lang.String`	`selectResolvedLiteralIds` Constant "selectResolvedLiteralIds" used to reference prepared statement node.selectResolvedLiteralIds `SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2`
`static java.lang.String`	`selectResolvedLiterals` Constant "selectResolvedLiterals" used to reference prepared statement node.selectResolvedLiterals `SELECT COUNT(${b}.ID) FROM ${a} L,${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE`
`static java.lang.String`	`selectResolvedUriIds` Constant "selectResolvedUriIds" used to reference prepared statement node.selectResolvedUriIds `SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2`
`static java.lang.String`	`storeBulkLiteral` Constant "storeBulkLiteral" used to reference prepared statement node.storeBulkLiteral `INSERT INTO ${a} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?)`
`static java.lang.String`	`storeBulkLongLiteral` Constant "storeBulkLongLiteral" used to reference prepared statement node.storeBulkLongLiteral `INSERT INTO ${a} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?)`
`static java.lang.String`	`storeBulkLongNode` Constant "storeBulkLongNode" used to reference prepared statement node.storeBulkLongNode `INSERT INTO ${a} (ID, HASH, VALUE) VALUES(?, ?, ?)`
`static java.lang.String`	`storeBulkNode` Constant "storeBulkNode" used to reference prepared statement node.storeBulkNode `INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)`
`static java.lang.String`	`storeResolveId` Constant "storeResolveId" used to reference prepared statement node.storeResolveId `INSERT INTO ${a} (ID) VALUES(?)`
`static java.lang.String`	`storeResolveLiteral` Constant "storeResolveLiteral" used to reference prepared statement node.storeResolveLiteral `INSERT INTO ${a} (VALUE,MODIFIER_ID) VALUES(?,?)`
`static java.lang.String`	`storeResolveLiteralLong` Constant "storeResolveLiteralLong" used to reference prepared statement node.storeResolveLiteralLong `INSERT INTO ${a} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?)`
`static java.lang.String`	`storeResolveNode` Constant "storeResolveNode" used to reference prepared statement node.storeResolveNode `INSERT INTO ${a} (VALUE) VALUES(?)`
`static java.lang.String`	`storeResolveNodeLong` Constant "storeResolveNodeLong" used to reference prepared statement node.storeResolveNodeLong `INSERT INTO ${a} (VALUE,HASH) VALUES(?,?)`
`static java.lang.String`	`updateResolvedLiterals` Constant "updateResolvedLiterals" used to reference prepared statement node.updateResolvedLiterals `UPDATE ${a} AS L SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE)`
`static java.lang.String`	`updateResolvedUris` Constant "updateResolvedUris" used to reference prepared statement node.updateResolvedUris `UPDATE ${a} AS A SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.VALUE=A.VALUE)`
`static java.lang.String`	`updateUnResolvedIds` Constant "updateUnResolvedIds" used to reference prepared statement node.updateUnResolvedIds `UPDATE ${a} AS A SET TYPE=1,ID=(NEXTVAL FOR ${b}) WHERE A.ID IS NULL`

Constructor Summary
`NodeSQL()`

Method Summary
`static int`	`commitUnResolvedLiterals(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the commitUnResolvedLiterals prepared statement.
`static int`	`commitUnResolvedUris(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the commitUnResolvedUris prepared statement.
`static java.lang.Long`	`countTempTable(PreparedStatementCache sqlCache, java.lang.String bulkLiteralTableName)` Runs the countTempTable prepared statement.
`static ClosableIterator<NodeSQL.FetchAllCommonValuesResult>`	`fetchAllCommonValues(PreparedStatementCache sqlCache, java.lang.String commonValuesTable)` Runs the fetchAllCommonValues prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.FetchAllCommonValuesResult>`	`fetchAllCommonValues(PreparedStatementCache sqlCache, java.lang.String commonValuesTable, Transformer<NodeSQL.FetchAllCommonValuesResult> transform)` Runs the fetchAllCommonValues prepared statement.
`static java.lang.String`	`fetchCommonValue(PreparedStatementCache sqlCache, long id, java.lang.String commonValuesTable, java.lang.String optimization)` Runs the fetchCommonValue prepared statement.
`static java.lang.Long`	`fetchCommonValueID(PreparedStatementCache sqlCache, java.lang.String value, java.lang.String commonValuesTable, java.lang.String optimization)` Runs the fetchCommonValueID prepared statement.
`static java.lang.Long`	`fetchLiteralNodeID(PreparedStatementCache sqlCache, NodeSQL.FetchLiteralNodeIDParams params, java.lang.String literalNodeTableName, java.lang.String optimization)` Runs the fetchLiteralNodeID prepared statement.
`static java.lang.Long`	`fetchLiteralNodeID(PreparedStatementCache sqlCache, java.lang.String value, long modifier_id, java.lang.String literalNodeTableName, java.lang.String optimization)` Runs the fetchLiteralNodeID prepared statement.
`static NodeSQL.FetchLiteralNodeValueResult`	`fetchLiteralNodeValue(PreparedStatementCache sqlCache, long id, java.lang.String literalNodeTableName, java.lang.String optimization)` Runs the fetchLiteralNodeValue prepared statement.
`static NodeSQL.FetchLiteralNodeValueResult`	`fetchLiteralNodeValue(PreparedStatementCache sqlCache, long id, java.lang.String literalNodeTableName, java.lang.String optimization, NodeSQL.FetchLiteralNodeValueResult result)` Runs the fetchLiteralNodeValue prepared statement.
`static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult>`	`fetchLongLiteralNodeID(PreparedStatementCache sqlCache, long hash, long modifier_id, java.lang.String longLiteralNodeTableName)` Runs the fetchLongLiteralNodeID prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult>`	`fetchLongLiteralNodeID(PreparedStatementCache sqlCache, long hash, long modifier_id, java.lang.String longLiteralNodeTableName, Transformer<NodeSQL.FetchLongLiteralNodeIDResult> transform)` Runs the fetchLongLiteralNodeID prepared statement.
`static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult>`	`fetchLongLiteralNodeID(PreparedStatementCache sqlCache, NodeSQL.FetchLongLiteralNodeIDParams params, java.lang.String longLiteralNodeTableName)` Runs the fetchLongLiteralNodeID prepared statement.
`static ClosableIterator<NodeSQL.FetchLongNodeIDResult>`	`fetchLongNodeID(PreparedStatementCache sqlCache, long hash, java.lang.String nodeTableName)` Runs the fetchLongNodeID prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.FetchLongNodeIDResult>`	`fetchLongNodeID(PreparedStatementCache sqlCache, long hash, java.lang.String nodeTableName, Transformer<NodeSQL.FetchLongNodeIDResult> transform)` Runs the fetchLongNodeID prepared statement.
`static java.lang.Long`	`fetchNodeID(PreparedStatementCache sqlCache, java.lang.String value, java.lang.String nodeTableName, java.lang.String optimization)` Runs the fetchNodeID prepared statement.
`static java.lang.String`	`fetchNodeValue(PreparedStatementCache sqlCache, long id, java.lang.String nodeTableName, java.lang.String optimization)` Runs the fetchNodeValue prepared statement.
`static ClosableIterator<java.lang.Long>`	`findNodeID(PreparedStatementCache sqlCache, long modifierId, java.lang.String value, java.lang.String nodeTableName, java.lang.String optimization)` Runs the findNodeID prepared statement with the default transformer.
`static ClosableIterator<java.lang.Long>`	`findNodeID(PreparedStatementCache sqlCache, long modifierId, java.lang.String value, java.lang.String nodeTableName, java.lang.String optimization, Transformer<java.lang.Long> transform)` Runs the findNodeID prepared statement.
`static ClosableIterator<java.lang.Long>`	`findNodeID(PreparedStatementCache sqlCache, NodeSQL.FindNodeIDParams params, java.lang.String nodeTableName, java.lang.String optimization)` Runs the findNodeID prepared statement.
`static ClosableIterator<NodeSQL.GetAllLiteralsResult>`	`getAllLiterals(PreparedStatementCache sqlCache, java.lang.String nodeTableName, java.lang.String optimization)` Runs the getAllLiterals prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.GetAllLiteralsResult>`	`getAllLiterals(PreparedStatementCache sqlCache, java.lang.String nodeTableName, java.lang.String optimization, Transformer<NodeSQL.GetAllLiteralsResult> transform)` Runs the getAllLiterals prepared statement.
`static void`	`insertCommonValue(PreparedStatementCache sqlCache, long id, java.lang.String value, java.lang.String commonValuesTable)` Runs the insertCommonValue prepared statement.
`static void`	`insertCommonValue(PreparedStatementCache sqlCache, NodeSQL.InsertCommonValueParams params, java.lang.String commonValuesTable)` Runs the insertCommonValue prepared statement.
`static void`	`prepareCommitUnResolvedLiterals(java.sql.PreparedStatement ps)` Sets the input parameters for the commitUnResolvedLiterals prepared statement.
`static void`	`prepareCommitUnResolvedUris(java.sql.PreparedStatement ps)` Sets the input parameters for the commitUnResolvedUris prepared statement.
`static void`	`prepareCountTempTable(java.sql.PreparedStatement ps)` Sets the input parameters for the countTempTable prepared statement.
`static void`	`prepareFetchAllCommonValues(java.sql.PreparedStatement ps)` Sets the input parameters for the fetchAllCommonValues prepared statement.
`static void`	`prepareFetchCommonValue(java.sql.PreparedStatement ps, long id)` Sets the input parameters for the fetchCommonValue prepared statement.
`static void`	`prepareFetchCommonValueID(java.sql.PreparedStatement ps, java.lang.String value)` Sets the input parameters for the fetchCommonValueID prepared statement.
`static void`	`prepareFetchLiteralNodeID(java.sql.PreparedStatement ps, java.lang.String value, long modifier_id)` Sets the input parameters for the fetchLiteralNodeID prepared statement.
`static void`	`prepareFetchLiteralNodeValue(java.sql.PreparedStatement ps, long id)` Sets the input parameters for the fetchLiteralNodeValue prepared statement.
`static void`	`prepareFetchLongLiteralNodeID(java.sql.PreparedStatement ps, long hash, long modifier_id)` Sets the input parameters for the fetchLongLiteralNodeID prepared statement.
`static void`	`prepareFetchLongNodeID(java.sql.PreparedStatement ps, long hash)` Sets the input parameters for the fetchLongNodeID prepared statement.
`static void`	`prepareFetchNodeID(java.sql.PreparedStatement ps, java.lang.String value)` Sets the input parameters for the fetchNodeID prepared statement.
`static void`	`prepareFetchNodeValue(java.sql.PreparedStatement ps, long id)` Sets the input parameters for the fetchNodeValue prepared statement.
`static void`	`prepareFindNodeID(java.sql.PreparedStatement ps, long modifierId, java.lang.String value)` Sets the input parameters for the findNodeID prepared statement.
`static void`	`prepareGetAllLiterals(java.sql.PreparedStatement ps)` Sets the input parameters for the getAllLiterals prepared statement.
`static void`	`prepareInsertCommonValue(java.sql.PreparedStatement ps, long id, java.lang.String value)` Sets the input parameters for the insertCommonValue prepared statement.
`static void`	`preparePurge(java.sql.PreparedStatement ps)` Sets the input parameters for the purge prepared statement.
`static void`	`prepareResolveIdsLiteral(java.sql.PreparedStatement ps)` Sets the input parameters for the resolveIdsLiteral prepared statement.
`static void`	`prepareResolveIdsUri(java.sql.PreparedStatement ps)` Sets the input parameters for the resolveIdsUri prepared statement.
`static void`	`prepareResolveLiterals(java.sql.PreparedStatement ps)` Sets the input parameters for the resolveLiterals prepared statement.
`static void`	`prepareResolveNodes(java.sql.PreparedStatement ps)` Sets the input parameters for the resolveNodes prepared statement.
`static void`	`prepareSelectAllIds(java.sql.PreparedStatement ps)` Sets the input parameters for the selectAllIds prepared statement.
`static void`	`prepareSelectAllResolvedLiteralIds(java.sql.PreparedStatement ps)` Sets the input parameters for the selectAllResolvedLiteralIds prepared statement.
`static void`	`prepareSelectAllResolvedUriIds(java.sql.PreparedStatement ps)` Sets the input parameters for the selectAllResolvedUriIds prepared statement.
`static void`	`prepareSelectResolvedLiteralIds(java.sql.PreparedStatement ps)` Sets the input parameters for the selectResolvedLiteralIds prepared statement.
`static void`	`prepareSelectResolvedLiterals(java.sql.PreparedStatement ps)` Sets the input parameters for the selectResolvedLiterals prepared statement.
`static void`	`prepareSelectResolvedUriIds(java.sql.PreparedStatement ps)` Sets the input parameters for the selectResolvedUriIds prepared statement.
`static void`	`prepareStoreBulkLiteral(java.sql.PreparedStatement ps, long id, java.lang.String value, long modifier_id)` Sets the input parameters for the storeBulkLiteral prepared statement.
`static void`	`prepareStoreBulkLongLiteral(java.sql.PreparedStatement ps, long id, java.lang.String value, long hash, long modifier_id)` Sets the input parameters for the storeBulkLongLiteral prepared statement.
`static void`	`prepareStoreBulkLongNode(java.sql.PreparedStatement ps, long id, long hash, java.lang.String value)` Sets the input parameters for the storeBulkLongNode prepared statement.
`static void`	`prepareStoreBulkNode(java.sql.PreparedStatement ps, long id, java.lang.String value)` Sets the input parameters for the storeBulkNode prepared statement.
`static void`	`prepareStoreResolveId(java.sql.PreparedStatement ps, java.lang.Long id)` Sets the input parameters for the storeResolveId prepared statement.
`static void`	`prepareStoreResolveLiteral(java.sql.PreparedStatement ps, java.lang.String value, long modifier_id)` Sets the input parameters for the storeResolveLiteral prepared statement.
`static void`	`prepareStoreResolveLiteralLong(java.sql.PreparedStatement ps, java.lang.String value, java.lang.Long hash, long modifier_id)` Sets the input parameters for the storeResolveLiteralLong prepared statement.
`static void`	`prepareStoreResolveNode(java.sql.PreparedStatement ps, java.lang.String value)` Sets the input parameters for the storeResolveNode prepared statement.
`static void`	`prepareStoreResolveNodeLong(java.sql.PreparedStatement ps, java.lang.String value, java.lang.Long hash)` Sets the input parameters for the storeResolveNodeLong prepared statement.
`static void`	`prepareUpdateResolvedLiterals(java.sql.PreparedStatement ps)` Sets the input parameters for the updateResolvedLiterals prepared statement.
`static void`	`prepareUpdateResolvedUris(java.sql.PreparedStatement ps)` Sets the input parameters for the updateResolvedUris prepared statement.
`static void`	`prepareUpdateUnResolvedIds(java.sql.PreparedStatement ps)` Sets the input parameters for the updateUnResolvedIds prepared statement.
`static int`	`purge(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the purge prepared statement.
`static ClosableIterator<NodeSQL.ResolveIdsLiteralResult>`	`resolveIdsLiteral(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the resolveIdsLiteral prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.ResolveIdsLiteralResult>`	`resolveIdsLiteral(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName, Transformer<NodeSQL.ResolveIdsLiteralResult> transform)` Runs the resolveIdsLiteral prepared statement.
`static ClosableIterator<NodeSQL.ResolveIdsUriResult>`	`resolveIdsUri(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the resolveIdsUri prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.ResolveIdsUriResult>`	`resolveIdsUri(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName, Transformer<NodeSQL.ResolveIdsUriResult> transform)` Runs the resolveIdsUri prepared statement.
`static ClosableIterator<NodeSQL.ResolveLiteralsResult>`	`resolveLiterals(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the resolveLiterals prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.ResolveLiteralsResult>`	`resolveLiterals(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName, Transformer<NodeSQL.ResolveLiteralsResult> transform)` Runs the resolveLiterals prepared statement.
`static ClosableIterator<NodeSQL.ResolveNodesResult>`	`resolveNodes(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the resolveNodes prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.ResolveNodesResult>`	`resolveNodes(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName, Transformer<NodeSQL.ResolveNodesResult> transform)` Runs the resolveNodes prepared statement.
`static ClosableIterator<NodeSQL.SelectAllIdsResult>`	`selectAllIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the selectAllIds prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.SelectAllIdsResult>`	`selectAllIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, Transformer<NodeSQL.SelectAllIdsResult> transform)` Runs the selectAllIds prepared statement.
`static ClosableIterator<NodeSQL.SelectAllResolvedLiteralIdsResult>`	`selectAllResolvedLiteralIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the selectAllResolvedLiteralIds prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.SelectAllResolvedLiteralIdsResult>`	`selectAllResolvedLiteralIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, Transformer<NodeSQL.SelectAllResolvedLiteralIdsResult> transform)` Runs the selectAllResolvedLiteralIds prepared statement.
`static ClosableIterator<NodeSQL.SelectAllResolvedUriIdsResult>`	`selectAllResolvedUriIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the selectAllResolvedUriIds prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.SelectAllResolvedUriIdsResult>`	`selectAllResolvedUriIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, Transformer<NodeSQL.SelectAllResolvedUriIdsResult> transform)` Runs the selectAllResolvedUriIds prepared statement.
`static ClosableIterator<NodeSQL.SelectResolvedLiteralIdsResult>`	`selectResolvedLiteralIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the selectResolvedLiteralIds prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.SelectResolvedLiteralIdsResult>`	`selectResolvedLiteralIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, Transformer<NodeSQL.SelectResolvedLiteralIdsResult> transform)` Runs the selectResolvedLiteralIds prepared statement.
`static java.lang.Long`	`selectResolvedLiterals(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the selectResolvedLiterals prepared statement.
`static ClosableIterator<NodeSQL.SelectResolvedUriIdsResult>`	`selectResolvedUriIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName)` Runs the selectResolvedUriIds prepared statement with the default transformer.
`static ClosableIterator<NodeSQL.SelectResolvedUriIdsResult>`	`selectResolvedUriIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, Transformer<NodeSQL.SelectResolvedUriIdsResult> transform)` Runs the selectResolvedUriIds prepared statement.
`static void`	`storeBulkLiteral(PreparedStatementCache sqlCache, long id, java.lang.String value, long modifier_id, java.lang.String bulkLiteralTableName)` Runs the storeBulkLiteral prepared statement.
`static void`	`storeBulkLiteral(PreparedStatementCache sqlCache, NodeSQL.StoreBulkLiteralParams params, java.lang.String bulkLiteralTableName)` Runs the storeBulkLiteral prepared statement.
`static void`	`storeBulkLongLiteral(PreparedStatementCache sqlCache, long id, java.lang.String value, long hash, long modifier_id, java.lang.String bulkLiteralTableName)` Runs the storeBulkLongLiteral prepared statement.
`static void`	`storeBulkLongLiteral(PreparedStatementCache sqlCache, NodeSQL.StoreBulkLongLiteralParams params, java.lang.String bulkLiteralTableName)` Runs the storeBulkLongLiteral prepared statement.
`static void`	`storeBulkLongNode(PreparedStatementCache sqlCache, long id, long hash, java.lang.String value, java.lang.String bulkNodeTableName)` Runs the storeBulkLongNode prepared statement.
`static void`	`storeBulkLongNode(PreparedStatementCache sqlCache, NodeSQL.StoreBulkLongNodeParams params, java.lang.String bulkNodeTableName)` Runs the storeBulkLongNode prepared statement.
`static void`	`storeBulkNode(PreparedStatementCache sqlCache, long id, java.lang.String value, java.lang.String bulkNodeTableName)` Runs the storeBulkNode prepared statement.
`static void`	`storeBulkNode(PreparedStatementCache sqlCache, NodeSQL.StoreBulkNodeParams params, java.lang.String bulkNodeTableName)` Runs the storeBulkNode prepared statement.
`static void`	`storeResolveId(PreparedStatementCache sqlCache, java.lang.Long id, java.lang.String bulkResolutionTableName)` Runs the storeResolveId prepared statement.
`static void`	`storeResolveLiteral(PreparedStatementCache sqlCache, NodeSQL.StoreResolveLiteralParams params, java.lang.String bulkResolutionTableName)` Runs the storeResolveLiteral prepared statement.
`static void`	`storeResolveLiteral(PreparedStatementCache sqlCache, java.lang.String value, long modifier_id, java.lang.String bulkResolutionTableName)` Runs the storeResolveLiteral prepared statement.
`static void`	`storeResolveLiteralLong(PreparedStatementCache sqlCache, NodeSQL.StoreResolveLiteralLongParams params, java.lang.String bulkResolutionTableName)` Runs the storeResolveLiteralLong prepared statement.
`static void`	`storeResolveLiteralLong(PreparedStatementCache sqlCache, java.lang.String value, java.lang.Long hash, long modifier_id, java.lang.String bulkResolutionTableName)` Runs the storeResolveLiteralLong prepared statement.
`static void`	`storeResolveNode(PreparedStatementCache sqlCache, java.lang.String value, java.lang.String bulkResolutionTableName)` Runs the storeResolveNode prepared statement.
`static void`	`storeResolveNodeLong(PreparedStatementCache sqlCache, NodeSQL.StoreResolveNodeLongParams params, java.lang.String bulkResolutionTableName)` Runs the storeResolveNodeLong prepared statement.
`static void`	`storeResolveNodeLong(PreparedStatementCache sqlCache, java.lang.String value, java.lang.Long hash, java.lang.String bulkResolutionTableName)` Runs the storeResolveNodeLong prepared statement.
`static int`	`updateResolvedLiterals(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the updateResolvedLiterals prepared statement.
`static int`	`updateResolvedUris(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String nodeTableName)` Runs the updateResolvedUris prepared statement.
`static int`	`updateUnResolvedIds(PreparedStatementCache sqlCache, java.lang.String bulkResolutionTableName, java.lang.String sequenceName)` Runs the updateUnResolvedIds prepared statement.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

getAllLiterals

public static final java.lang.String getAllLiterals

Constant "getAllLiterals" used to reference prepared statement node.getAllLiterals


                SELECT ID,MODIFIER_ID,VALUE FROM ${a} ${b}

See Also:: Constant Field Values

findNodeID

public static final java.lang.String findNodeID

Constant "findNodeID" used to reference prepared statement node.findNodeID


                SELECT ID FROM ${a} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ?  ${b}

See Also:: Constant Field Values

fetchNodeID

public static final java.lang.String fetchNodeID

Constant "fetchNodeID" used to reference prepared statement node.fetchNodeID


                SELECT ID FROM ${a} WHERE VALUE = ?  ${b}

See Also:: Constant Field Values

fetchNodeValue

public static final java.lang.String fetchNodeValue

Constant "fetchNodeValue" used to reference prepared statement node.fetchNodeValue


                SELECT VALUE FROM ${a} WHERE ID = ?  ${b}

See Also:: Constant Field Values

fetchLongNodeID

public static final java.lang.String fetchLongNodeID

Constant "fetchLongNodeID" used to reference prepared statement node.fetchLongNodeID


                SELECT ID,VALUE FROM ${a} WHERE HASH = ?

See Also:: Constant Field Values

fetchLiteralNodeValue

public static final java.lang.String fetchLiteralNodeValue

Constant "fetchLiteralNodeValue" used to reference prepared statement node.fetchLiteralNodeValue


                SELECT VALUE, MODIFIER_ID FROM ${a} WHERE ID = ?  ${b}

See Also:: Constant Field Values

fetchLiteralNodeID

public static final java.lang.String fetchLiteralNodeID

Constant "fetchLiteralNodeID" used to reference prepared statement node.fetchLiteralNodeID


                SELECT ID FROM ${a} WHERE VALUE = ? AND MODIFIER_ID = ?  ${b}

See Also:: Constant Field Values

fetchLongLiteralNodeID

public static final java.lang.String fetchLongLiteralNodeID

Constant "fetchLongLiteralNodeID" used to reference prepared statement node.fetchLongLiteralNodeID


                SELECT ID,VALUE FROM ${a} WHERE HASH = ? AND MODIFIER_ID = ?

See Also:: Constant Field Values

insertCommonValue

public static final java.lang.String insertCommonValue

Constant "insertCommonValue" used to reference prepared statement node.insertCommonValue


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

See Also:: Constant Field Values

fetchCommonValueID

public static final java.lang.String fetchCommonValueID

Constant "fetchCommonValueID" used to reference prepared statement node.fetchCommonValueID


                SELECT ID FROM ${a} WHERE VALUE = ?  ${b}

See Also:: Constant Field Values

fetchCommonValue

public static final java.lang.String fetchCommonValue

Constant "fetchCommonValue" used to reference prepared statement node.fetchCommonValue


                SELECT VALUE FROM ${a} WHERE ID = ?  ${b}

See Also:: Constant Field Values

fetchAllCommonValues

public static final java.lang.String fetchAllCommonValues

Constant "fetchAllCommonValues" used to reference prepared statement node.fetchAllCommonValues


                SELECT ID, VALUE FROM ${a}

See Also:: Constant Field Values

storeBulkNode

public static final java.lang.String storeBulkNode

Constant "storeBulkNode" used to reference prepared statement node.storeBulkNode


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

See Also:: Constant Field Values

storeBulkLongNode

public static final java.lang.String storeBulkLongNode

Constant "storeBulkLongNode" used to reference prepared statement node.storeBulkLongNode


                INSERT INTO ${a} (ID, HASH, VALUE) VALUES(?, ?, ?)

See Also:: Constant Field Values

storeBulkLiteral

public static final java.lang.String storeBulkLiteral

Constant "storeBulkLiteral" used to reference prepared statement node.storeBulkLiteral


                INSERT INTO ${a} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?)

See Also:: Constant Field Values

storeBulkLongLiteral

public static final java.lang.String storeBulkLongLiteral

Constant "storeBulkLongLiteral" used to reference prepared statement node.storeBulkLongLiteral


                INSERT INTO ${a} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?)

See Also:: Constant Field Values

countTempTable

public static final java.lang.String countTempTable

Constant "countTempTable" used to reference prepared statement node.countTempTable


                SELECT COUNT(*) FROM  ${a}

See Also:: Constant Field Values

storeResolveId

public static final java.lang.String storeResolveId

Constant "storeResolveId" used to reference prepared statement node.storeResolveId


                INSERT INTO ${a} (ID) VALUES(?)

See Also:: Constant Field Values

storeResolveNode

public static final java.lang.String storeResolveNode

Constant "storeResolveNode" used to reference prepared statement node.storeResolveNode


                INSERT INTO ${a} (VALUE) VALUES(?)

See Also:: Constant Field Values

storeResolveNodeLong

public static final java.lang.String storeResolveNodeLong

Constant "storeResolveNodeLong" used to reference prepared statement node.storeResolveNodeLong


                INSERT INTO ${a} (VALUE,HASH) VALUES(?,?)

See Also:: Constant Field Values

storeResolveLiteral

public static final java.lang.String storeResolveLiteral

Constant "storeResolveLiteral" used to reference prepared statement node.storeResolveLiteral


                INSERT INTO ${a} (VALUE,MODIFIER_ID) VALUES(?,?)

See Also:: Constant Field Values

storeResolveLiteralLong

public static final java.lang.String storeResolveLiteralLong

Constant "storeResolveLiteralLong" used to reference prepared statement node.storeResolveLiteralLong


                INSERT INTO ${a} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?)

See Also:: Constant Field Values

resolveNodes

public static final java.lang.String resolveNodes

Constant "resolveNodes" used to reference prepared statement node.resolveNodes


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE  ${b}.VALUE=${a}.VALUE

See Also:: Constant Field Values

resolveLiterals

public static final java.lang.String resolveLiterals

Constant "resolveLiterals" used to reference prepared statement node.resolveLiterals


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a}               WHERE           ${b}.VALUE=${a}.VALUE AND ${b}.MODIFIER_ID = ${a}.MODIFIER_ID

See Also:: Constant Field Values

resolveIdsUri

public static final java.lang.String resolveIdsUri

Constant "resolveIdsUri" used to reference prepared statement node.resolveIdsUri


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE ${b}.ID=${a}.ID

See Also:: Constant Field Values

updateResolvedUris

public static final java.lang.String updateResolvedUris

Constant "updateResolvedUris" used to reference prepared statement node.updateResolvedUris


                UPDATE ${a} AS A SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.VALUE=A.VALUE)

See Also:: Constant Field Values

updateUnResolvedIds

public static final java.lang.String updateUnResolvedIds

Constant "updateUnResolvedIds" used to reference prepared statement node.updateUnResolvedIds


                UPDATE ${a} AS A SET TYPE=1,ID=(NEXTVAL FOR ${b}) WHERE A.ID IS NULL

See Also:: Constant Field Values

commitUnResolvedUris

public static final java.lang.String commitUnResolvedUris

Constant "commitUnResolvedUris" used to reference prepared statement node.commitUnResolvedUris


                INSERT INTO ${b} (ID,VALUE)     SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1

See Also:: Constant Field Values

selectAllResolvedUriIds

public static final java.lang.String selectAllResolvedUriIds

Constant "selectAllResolvedUriIds" used to reference prepared statement node.selectAllResolvedUriIds


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

See Also:: Constant Field Values

selectResolvedUriIds

public static final java.lang.String selectResolvedUriIds

Constant "selectResolvedUriIds" used to reference prepared statement node.selectResolvedUriIds


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

See Also:: Constant Field Values

selectAllIds

public static final java.lang.String selectAllIds

Constant "selectAllIds" used to reference prepared statement node.selectAllIds


                SELECT ${a}.TYPE,${a}.ID,${a}.VALUE FROM ${a}

See Also:: Constant Field Values

selectAllResolvedLiteralIds

public static final java.lang.String selectAllResolvedLiteralIds

Constant "selectAllResolvedLiteralIds" used to reference prepared statement node.selectAllResolvedLiteralIds


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

See Also:: Constant Field Values

selectResolvedLiteralIds

public static final java.lang.String selectResolvedLiteralIds

Constant "selectResolvedLiteralIds" used to reference prepared statement node.selectResolvedLiteralIds


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

See Also:: Constant Field Values

updateResolvedLiterals

public static final java.lang.String updateResolvedLiterals

Constant "updateResolvedLiterals" used to reference prepared statement node.updateResolvedLiterals


                UPDATE ${a} AS L SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE)

See Also:: Constant Field Values

selectResolvedLiterals

public static final java.lang.String selectResolvedLiterals

Constant "selectResolvedLiterals" used to reference prepared statement node.selectResolvedLiterals


                SELECT COUNT(${b}.ID) FROM ${a} L,${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE

See Also:: Constant Field Values

commitUnResolvedLiterals

public static final java.lang.String commitUnResolvedLiterals

Constant "commitUnResolvedLiterals" used to reference prepared statement node.commitUnResolvedLiterals


                INSERT INTO ${b} (ID,MODIFIER_ID,VALUE) SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1

See Also:: Constant Field Values

resolveIdsLiteral

public static final java.lang.String resolveIdsLiteral

Constant "resolveIdsLiteral" used to reference prepared statement node.resolveIdsLiteral


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a} WHERE ${b}.ID =${a}.ID

See Also:: Constant Field Values

purge

public static final java.lang.String purge

Constant "purge" used to reference prepared statement node.purge


                DELETE FROM ${a}

See Also:: Constant Field Values

Constructor Detail

NodeSQL

public NodeSQL()

Method Detail

getAllLiterals

public static ClosableIterator<NodeSQL.GetAllLiteralsResult> getAllLiterals(PreparedStatementCache sqlCache,
                                                                            java.lang.String nodeTableName,
                                                                            java.lang.String optimization)
                                                                     throws RdbException

Runs the getAllLiterals prepared statement with the default transformer.


                SELECT ID,MODIFIER_ID,VALUE FROM ${a} ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; nodeTableName - template parameter; optimization - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

getAllLiterals

public static ClosableIterator<NodeSQL.GetAllLiteralsResult> getAllLiterals(PreparedStatementCache sqlCache,
                                                                            java.lang.String nodeTableName,
                                                                            java.lang.String optimization,
                                                                            Transformer<NodeSQL.GetAllLiteralsResult> transform)
                                                                     throws RdbException

Runs the getAllLiterals prepared statement.


                SELECT ID,MODIFIER_ID,VALUE FROM ${a} ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; nodeTableName - template parameter; optimization - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareGetAllLiterals

public static void prepareGetAllLiterals(java.sql.PreparedStatement ps)
                                  throws java.sql.SQLException

Sets the input parameters for the getAllLiterals prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

findNodeID

public static ClosableIterator<java.lang.Long> findNodeID(PreparedStatementCache sqlCache,
                                                          NodeSQL.FindNodeIDParams params,
                                                          java.lang.String nodeTableName,
                                                          java.lang.String optimization)
                                                   throws RdbException

Runs the findNodeID prepared statement.


                SELECT ID FROM ${a} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; params - FindNodeIDParams input Interface; nodeTableName - template parameter; optimization - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator containing the results of the SQL operation
Throws:: RdbException

findNodeID

public static ClosableIterator<java.lang.Long> findNodeID(PreparedStatementCache sqlCache,
                                                          long modifierId,
                                                          java.lang.String value,
                                                          java.lang.String nodeTableName,
                                                          java.lang.String optimization)
                                                   throws RdbException

Runs the findNodeID prepared statement with the default transformer.


                SELECT ID FROM ${a} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; modifierId - template parameter; value - template parameter; nodeTableName - template parameter; optimization - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

findNodeID

public static ClosableIterator<java.lang.Long> findNodeID(PreparedStatementCache sqlCache,
                                                          long modifierId,
                                                          java.lang.String value,
                                                          java.lang.String nodeTableName,
                                                          java.lang.String optimization,
                                                          Transformer<java.lang.Long> transform)
                                                   throws RdbException

Runs the findNodeID prepared statement.


                SELECT ID FROM ${a} WHERE (MODIFIER_ID=0 OR MODIFIER_ID=?) AND VALUE LIKE ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; modifierId - template parameter; value - template parameter; nodeTableName - template parameter; optimization - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareFindNodeID

public static void prepareFindNodeID(java.sql.PreparedStatement ps,
                                     long modifierId,
                                     java.lang.String value)
                              throws java.sql.SQLException

Sets the input parameters for the findNodeID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; modifierId - template parameter; value - template parameter
Throws:: java.sql.SQLException

fetchNodeID

public static java.lang.Long fetchNodeID(PreparedStatementCache sqlCache,
                                         java.lang.String value,
                                         java.lang.String nodeTableName,
                                         java.lang.String optimization)
                                  throws RdbException

Runs the fetchNodeID prepared statement.


                SELECT ID FROM ${a} WHERE VALUE = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; nodeTableName - template parameter; optimization - template parameter
Returns:: Long
Throws:: RdbException

prepareFetchNodeID

public static void prepareFetchNodeID(java.sql.PreparedStatement ps,
                                      java.lang.String value)
                               throws java.sql.SQLException

Sets the input parameters for the fetchNodeID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter
Throws:: java.sql.SQLException

fetchNodeValue

public static java.lang.String fetchNodeValue(PreparedStatementCache sqlCache,
                                              long id,
                                              java.lang.String nodeTableName,
                                              java.lang.String optimization)
                                       throws RdbException

Runs the fetchNodeValue prepared statement.


                SELECT VALUE FROM ${a} WHERE ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; nodeTableName - template parameter; optimization - template parameter
Returns:: String
Throws:: RdbException

prepareFetchNodeValue

public static void prepareFetchNodeValue(java.sql.PreparedStatement ps,
                                         long id)
                                  throws java.sql.SQLException

Sets the input parameters for the fetchNodeValue prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter
Throws:: java.sql.SQLException

fetchLongNodeID

public static ClosableIterator<NodeSQL.FetchLongNodeIDResult> fetchLongNodeID(PreparedStatementCache sqlCache,
                                                                              long hash,
                                                                              java.lang.String nodeTableName)
                                                                       throws RdbException

Runs the fetchLongNodeID prepared statement with the default transformer.


                SELECT ID,VALUE FROM ${a} WHERE HASH = ?

Parameters:: sqlCache - factory and cache of PreparedStatments; hash - template parameter; nodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

fetchLongNodeID

public static ClosableIterator<NodeSQL.FetchLongNodeIDResult> fetchLongNodeID(PreparedStatementCache sqlCache,
                                                                              long hash,
                                                                              java.lang.String nodeTableName,
                                                                              Transformer<NodeSQL.FetchLongNodeIDResult> transform)
                                                                       throws RdbException

Runs the fetchLongNodeID prepared statement.


                SELECT ID,VALUE FROM ${a} WHERE HASH = ?

Parameters:: sqlCache - factory and cache of PreparedStatments; hash - template parameter; nodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareFetchLongNodeID

public static void prepareFetchLongNodeID(java.sql.PreparedStatement ps,
                                          long hash)
                                   throws java.sql.SQLException

Sets the input parameters for the fetchLongNodeID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; hash - template parameter
Throws:: java.sql.SQLException

fetchLiteralNodeValue

public static NodeSQL.FetchLiteralNodeValueResult fetchLiteralNodeValue(PreparedStatementCache sqlCache,
                                                                        long id,
                                                                        java.lang.String literalNodeTableName,
                                                                        java.lang.String optimization)
                                                                 throws RdbException

Runs the fetchLiteralNodeValue prepared statement.


                SELECT VALUE, MODIFIER_ID FROM ${a} WHERE ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; literalNodeTableName - template parameter; optimization - template parameter
Returns:: FetchLiteralNodeValueResult containing the results of the SQL operation
Throws:: RdbException

fetchLiteralNodeValue

public static NodeSQL.FetchLiteralNodeValueResult fetchLiteralNodeValue(PreparedStatementCache sqlCache,
                                                                        long id,
                                                                        java.lang.String literalNodeTableName,
                                                                        java.lang.String optimization,
                                                                        NodeSQL.FetchLiteralNodeValueResult result)
                                                                 throws RdbException

Runs the fetchLiteralNodeValue prepared statement.


                SELECT VALUE, MODIFIER_ID FROM ${a} WHERE ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; literalNodeTableName - template parameter; optimization - template parameter; result - FetchLiteralNodeValueResult result object
Returns:: FetchLiteralNodeValueResult
Throws:: RdbException

prepareFetchLiteralNodeValue

public static void prepareFetchLiteralNodeValue(java.sql.PreparedStatement ps,
                                                long id)
                                         throws java.sql.SQLException

Sets the input parameters for the fetchLiteralNodeValue prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter
Throws:: java.sql.SQLException

fetchLiteralNodeID

public static java.lang.Long fetchLiteralNodeID(PreparedStatementCache sqlCache,
                                                NodeSQL.FetchLiteralNodeIDParams params,
                                                java.lang.String literalNodeTableName,
                                                java.lang.String optimization)
                                         throws RdbException

Runs the fetchLiteralNodeID prepared statement.


                SELECT ID FROM ${a} WHERE VALUE = ? AND MODIFIER_ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; params - FetchLiteralNodeIDParams input Interface; literalNodeTableName - template parameter; optimization - template parameter
Returns:: Long containing the results of the SQL operation
Throws:: RdbException

fetchLiteralNodeID

public static java.lang.Long fetchLiteralNodeID(PreparedStatementCache sqlCache,
                                                java.lang.String value,
                                                long modifier_id,
                                                java.lang.String literalNodeTableName,
                                                java.lang.String optimization)
                                         throws RdbException

Runs the fetchLiteralNodeID prepared statement.


                SELECT ID FROM ${a} WHERE VALUE = ? AND MODIFIER_ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; modifier_id - template parameter; literalNodeTableName - template parameter; optimization - template parameter
Returns:: Long
Throws:: RdbException

prepareFetchLiteralNodeID

public static void prepareFetchLiteralNodeID(java.sql.PreparedStatement ps,
                                             java.lang.String value,
                                             long modifier_id)
                                      throws java.sql.SQLException

Sets the input parameters for the fetchLiteralNodeID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

fetchLongLiteralNodeID

public static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult> fetchLongLiteralNodeID(PreparedStatementCache sqlCache,
                                                                                            NodeSQL.FetchLongLiteralNodeIDParams params,
                                                                                            java.lang.String longLiteralNodeTableName)
                                                                                     throws RdbException

Runs the fetchLongLiteralNodeID prepared statement.


                SELECT ID,VALUE FROM ${a} WHERE HASH = ? AND MODIFIER_ID = ?

Parameters:: sqlCache - factory and cache of PreparedStatments; params - FetchLongLiteralNodeIDParams input Interface; longLiteralNodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator containing the results of the SQL operation
Throws:: RdbException

fetchLongLiteralNodeID

public static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult> fetchLongLiteralNodeID(PreparedStatementCache sqlCache,
                                                                                            long hash,
                                                                                            long modifier_id,
                                                                                            java.lang.String longLiteralNodeTableName)
                                                                                     throws RdbException

Runs the fetchLongLiteralNodeID prepared statement with the default transformer.


                SELECT ID,VALUE FROM ${a} WHERE HASH = ? AND MODIFIER_ID = ?

Parameters:: sqlCache - factory and cache of PreparedStatments; hash - template parameter; modifier_id - template parameter; longLiteralNodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

fetchLongLiteralNodeID

public static ClosableIterator<NodeSQL.FetchLongLiteralNodeIDResult> fetchLongLiteralNodeID(PreparedStatementCache sqlCache,
                                                                                            long hash,
                                                                                            long modifier_id,
                                                                                            java.lang.String longLiteralNodeTableName,
                                                                                            Transformer<NodeSQL.FetchLongLiteralNodeIDResult> transform)
                                                                                     throws RdbException

Runs the fetchLongLiteralNodeID prepared statement.


                SELECT ID,VALUE FROM ${a} WHERE HASH = ? AND MODIFIER_ID = ?

Parameters:: sqlCache - factory and cache of PreparedStatments; hash - template parameter; modifier_id - template parameter; longLiteralNodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareFetchLongLiteralNodeID

public static void prepareFetchLongLiteralNodeID(java.sql.PreparedStatement ps,
                                                 long hash,
                                                 long modifier_id)
                                          throws java.sql.SQLException

Sets the input parameters for the fetchLongLiteralNodeID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; hash - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

insertCommonValue

public static void insertCommonValue(PreparedStatementCache sqlCache,
                                     NodeSQL.InsertCommonValueParams params,
                                     java.lang.String commonValuesTable)
                              throws RdbException

Runs the insertCommonValue prepared statement.


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - InsertCommonValueParams input Interface; commonValuesTable - template parameter
Throws:: RdbException

insertCommonValue

public static void insertCommonValue(PreparedStatementCache sqlCache,
                                     long id,
                                     java.lang.String value,
                                     java.lang.String commonValuesTable)
                              throws RdbException

Runs the insertCommonValue prepared statement.


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; value - template parameter; commonValuesTable - template parameter
Throws:: RdbException

prepareInsertCommonValue

public static void prepareInsertCommonValue(java.sql.PreparedStatement ps,
                                            long id,
                                            java.lang.String value)
                                     throws java.sql.SQLException

Sets the input parameters for the insertCommonValue prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter; value - template parameter
Throws:: java.sql.SQLException

fetchCommonValueID

public static java.lang.Long fetchCommonValueID(PreparedStatementCache sqlCache,
                                                java.lang.String value,
                                                java.lang.String commonValuesTable,
                                                java.lang.String optimization)
                                         throws RdbException

Runs the fetchCommonValueID prepared statement.


                SELECT ID FROM ${a} WHERE VALUE = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; commonValuesTable - template parameter; optimization - template parameter
Returns:: Long
Throws:: RdbException

prepareFetchCommonValueID

public static void prepareFetchCommonValueID(java.sql.PreparedStatement ps,
                                             java.lang.String value)
                                      throws java.sql.SQLException

Sets the input parameters for the fetchCommonValueID prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter
Throws:: java.sql.SQLException

fetchCommonValue

public static java.lang.String fetchCommonValue(PreparedStatementCache sqlCache,
                                                long id,
                                                java.lang.String commonValuesTable,
                                                java.lang.String optimization)
                                         throws RdbException

Runs the fetchCommonValue prepared statement.


                SELECT VALUE FROM ${a} WHERE ID = ?  ${b}

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; commonValuesTable - template parameter; optimization - template parameter
Returns:: String
Throws:: RdbException

prepareFetchCommonValue

public static void prepareFetchCommonValue(java.sql.PreparedStatement ps,
                                           long id)
                                    throws java.sql.SQLException

Sets the input parameters for the fetchCommonValue prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter
Throws:: java.sql.SQLException

fetchAllCommonValues

public static ClosableIterator<NodeSQL.FetchAllCommonValuesResult> fetchAllCommonValues(PreparedStatementCache sqlCache,
                                                                                        java.lang.String commonValuesTable)
                                                                                 throws RdbException

Runs the fetchAllCommonValues prepared statement with the default transformer.


                SELECT ID, VALUE FROM ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; commonValuesTable - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

fetchAllCommonValues

public static ClosableIterator<NodeSQL.FetchAllCommonValuesResult> fetchAllCommonValues(PreparedStatementCache sqlCache,
                                                                                        java.lang.String commonValuesTable,
                                                                                        Transformer<NodeSQL.FetchAllCommonValuesResult> transform)
                                                                                 throws RdbException

Runs the fetchAllCommonValues prepared statement.


                SELECT ID, VALUE FROM ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; commonValuesTable - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareFetchAllCommonValues

public static void prepareFetchAllCommonValues(java.sql.PreparedStatement ps)
                                        throws java.sql.SQLException

Sets the input parameters for the fetchAllCommonValues prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

storeBulkNode

public static void storeBulkNode(PreparedStatementCache sqlCache,
                                 NodeSQL.StoreBulkNodeParams params,
                                 java.lang.String bulkNodeTableName)
                          throws RdbException

Runs the storeBulkNode prepared statement.


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreBulkNodeParams input Interface; bulkNodeTableName - template parameter
Throws:: RdbException

storeBulkNode

public static void storeBulkNode(PreparedStatementCache sqlCache,
                                 long id,
                                 java.lang.String value,
                                 java.lang.String bulkNodeTableName)
                          throws RdbException

Runs the storeBulkNode prepared statement.


                INSERT INTO ${a} (ID, VALUE) VALUES(?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; value - template parameter; bulkNodeTableName - template parameter
Throws:: RdbException

prepareStoreBulkNode

public static void prepareStoreBulkNode(java.sql.PreparedStatement ps,
                                        long id,
                                        java.lang.String value)
                                 throws java.sql.SQLException

Sets the input parameters for the storeBulkNode prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter; value - template parameter
Throws:: java.sql.SQLException

storeBulkLongNode

public static void storeBulkLongNode(PreparedStatementCache sqlCache,
                                     NodeSQL.StoreBulkLongNodeParams params,
                                     java.lang.String bulkNodeTableName)
                              throws RdbException

Runs the storeBulkLongNode prepared statement.


                INSERT INTO ${a} (ID, HASH, VALUE) VALUES(?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreBulkLongNodeParams input Interface; bulkNodeTableName - template parameter
Throws:: RdbException

storeBulkLongNode

public static void storeBulkLongNode(PreparedStatementCache sqlCache,
                                     long id,
                                     long hash,
                                     java.lang.String value,
                                     java.lang.String bulkNodeTableName)
                              throws RdbException

Runs the storeBulkLongNode prepared statement.


                INSERT INTO ${a} (ID, HASH, VALUE) VALUES(?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; hash - template parameter; value - template parameter; bulkNodeTableName - template parameter
Throws:: RdbException

prepareStoreBulkLongNode

public static void prepareStoreBulkLongNode(java.sql.PreparedStatement ps,
                                            long id,
                                            long hash,
                                            java.lang.String value)
                                     throws java.sql.SQLException

Sets the input parameters for the storeBulkLongNode prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter; hash - template parameter; value - template parameter
Throws:: java.sql.SQLException

storeBulkLiteral

public static void storeBulkLiteral(PreparedStatementCache sqlCache,
                                    NodeSQL.StoreBulkLiteralParams params,
                                    java.lang.String bulkLiteralTableName)
                             throws RdbException

Runs the storeBulkLiteral prepared statement.


                INSERT INTO ${a} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreBulkLiteralParams input Interface; bulkLiteralTableName - template parameter
Throws:: RdbException

storeBulkLiteral

public static void storeBulkLiteral(PreparedStatementCache sqlCache,
                                    long id,
                                    java.lang.String value,
                                    long modifier_id,
                                    java.lang.String bulkLiteralTableName)
                             throws RdbException

Runs the storeBulkLiteral prepared statement.


                INSERT INTO ${a} (ID, VALUE, MODIFIER_ID) VALUES(?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; value - template parameter; modifier_id - template parameter; bulkLiteralTableName - template parameter
Throws:: RdbException

prepareStoreBulkLiteral

public static void prepareStoreBulkLiteral(java.sql.PreparedStatement ps,
                                           long id,
                                           java.lang.String value,
                                           long modifier_id)
                                    throws java.sql.SQLException

Sets the input parameters for the storeBulkLiteral prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter; value - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

storeBulkLongLiteral

public static void storeBulkLongLiteral(PreparedStatementCache sqlCache,
                                        NodeSQL.StoreBulkLongLiteralParams params,
                                        java.lang.String bulkLiteralTableName)
                                 throws RdbException

Runs the storeBulkLongLiteral prepared statement.


                INSERT INTO ${a} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreBulkLongLiteralParams input Interface; bulkLiteralTableName - template parameter
Throws:: RdbException

storeBulkLongLiteral

public static void storeBulkLongLiteral(PreparedStatementCache sqlCache,
                                        long id,
                                        java.lang.String value,
                                        long hash,
                                        long modifier_id,
                                        java.lang.String bulkLiteralTableName)
                                 throws RdbException

Runs the storeBulkLongLiteral prepared statement.


                INSERT INTO ${a} (ID, VALUE, HASH, MODIFIER_ID) VALUES(?, ?, ?, ?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; value - template parameter; hash - template parameter; modifier_id - template parameter; bulkLiteralTableName - template parameter
Throws:: RdbException

prepareStoreBulkLongLiteral

public static void prepareStoreBulkLongLiteral(java.sql.PreparedStatement ps,
                                               long id,
                                               java.lang.String value,
                                               long hash,
                                               long modifier_id)
                                        throws java.sql.SQLException

Sets the input parameters for the storeBulkLongLiteral prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter; value - template parameter; hash - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

countTempTable

public static java.lang.Long countTempTable(PreparedStatementCache sqlCache,
                                            java.lang.String bulkLiteralTableName)
                                     throws RdbException

Runs the countTempTable prepared statement.


                SELECT COUNT(*) FROM  ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkLiteralTableName - template parameter
Returns:: Long
Throws:: RdbException

prepareCountTempTable

public static void prepareCountTempTable(java.sql.PreparedStatement ps)
                                  throws java.sql.SQLException

Sets the input parameters for the countTempTable prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

storeResolveId

public static void storeResolveId(PreparedStatementCache sqlCache,
                                  java.lang.Long id,
                                  java.lang.String bulkResolutionTableName)
                           throws RdbException

Runs the storeResolveId prepared statement.


                INSERT INTO ${a} (ID) VALUES(?)

Parameters:: sqlCache - factory and cache of PreparedStatments; id - template parameter; bulkResolutionTableName - template parameter
Throws:: RdbException

prepareStoreResolveId

public static void prepareStoreResolveId(java.sql.PreparedStatement ps,
                                         java.lang.Long id)
                                  throws java.sql.SQLException

Sets the input parameters for the storeResolveId prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; id - template parameter
Throws:: java.sql.SQLException

storeResolveNode

public static void storeResolveNode(PreparedStatementCache sqlCache,
                                    java.lang.String value,
                                    java.lang.String bulkResolutionTableName)
                             throws RdbException

Runs the storeResolveNode prepared statement.


                INSERT INTO ${a} (VALUE) VALUES(?)

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; bulkResolutionTableName - template parameter
Throws:: RdbException

prepareStoreResolveNode

public static void prepareStoreResolveNode(java.sql.PreparedStatement ps,
                                           java.lang.String value)
                                    throws java.sql.SQLException

Sets the input parameters for the storeResolveNode prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter
Throws:: java.sql.SQLException

storeResolveNodeLong

public static void storeResolveNodeLong(PreparedStatementCache sqlCache,
                                        NodeSQL.StoreResolveNodeLongParams params,
                                        java.lang.String bulkResolutionTableName)
                                 throws RdbException

Runs the storeResolveNodeLong prepared statement.


                INSERT INTO ${a} (VALUE,HASH) VALUES(?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreResolveNodeLongParams input Interface; bulkResolutionTableName - template parameter
Throws:: RdbException

storeResolveNodeLong

public static void storeResolveNodeLong(PreparedStatementCache sqlCache,
                                        java.lang.String value,
                                        java.lang.Long hash,
                                        java.lang.String bulkResolutionTableName)
                                 throws RdbException

Runs the storeResolveNodeLong prepared statement.


                INSERT INTO ${a} (VALUE,HASH) VALUES(?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; hash - template parameter; bulkResolutionTableName - template parameter
Throws:: RdbException

prepareStoreResolveNodeLong

public static void prepareStoreResolveNodeLong(java.sql.PreparedStatement ps,
                                               java.lang.String value,
                                               java.lang.Long hash)
                                        throws java.sql.SQLException

Sets the input parameters for the storeResolveNodeLong prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter; hash - template parameter
Throws:: java.sql.SQLException

storeResolveLiteral

public static void storeResolveLiteral(PreparedStatementCache sqlCache,
                                       NodeSQL.StoreResolveLiteralParams params,
                                       java.lang.String bulkResolutionTableName)
                                throws RdbException

Runs the storeResolveLiteral prepared statement.


                INSERT INTO ${a} (VALUE,MODIFIER_ID) VALUES(?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreResolveLiteralParams input Interface; bulkResolutionTableName - template parameter
Throws:: RdbException

storeResolveLiteral

public static void storeResolveLiteral(PreparedStatementCache sqlCache,
                                       java.lang.String value,
                                       long modifier_id,
                                       java.lang.String bulkResolutionTableName)
                                throws RdbException

Runs the storeResolveLiteral prepared statement.


                INSERT INTO ${a} (VALUE,MODIFIER_ID) VALUES(?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; modifier_id - template parameter; bulkResolutionTableName - template parameter
Throws:: RdbException

prepareStoreResolveLiteral

public static void prepareStoreResolveLiteral(java.sql.PreparedStatement ps,
                                              java.lang.String value,
                                              long modifier_id)
                                       throws java.sql.SQLException

Sets the input parameters for the storeResolveLiteral prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

storeResolveLiteralLong

public static void storeResolveLiteralLong(PreparedStatementCache sqlCache,
                                           NodeSQL.StoreResolveLiteralLongParams params,
                                           java.lang.String bulkResolutionTableName)
                                    throws RdbException

Runs the storeResolveLiteralLong prepared statement.


                INSERT INTO ${a} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; params - StoreResolveLiteralLongParams input Interface; bulkResolutionTableName - template parameter
Throws:: RdbException

storeResolveLiteralLong

public static void storeResolveLiteralLong(PreparedStatementCache sqlCache,
                                           java.lang.String value,
                                           java.lang.Long hash,
                                           long modifier_id,
                                           java.lang.String bulkResolutionTableName)
                                    throws RdbException

Runs the storeResolveLiteralLong prepared statement.


                INSERT INTO ${a} (VALUE,HASH,MODIFIER_ID) VALUES(?,?,?)

Parameters:: sqlCache - factory and cache of PreparedStatments; value - template parameter; hash - template parameter; modifier_id - template parameter; bulkResolutionTableName - template parameter
Throws:: RdbException

prepareStoreResolveLiteralLong

public static void prepareStoreResolveLiteralLong(java.sql.PreparedStatement ps,
                                                  java.lang.String value,
                                                  java.lang.Long hash,
                                                  long modifier_id)
                                           throws java.sql.SQLException

Sets the input parameters for the storeResolveLiteralLong prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set; value - template parameter; hash - template parameter; modifier_id - template parameter
Throws:: java.sql.SQLException

resolveNodes

public static ClosableIterator<NodeSQL.ResolveNodesResult> resolveNodes(PreparedStatementCache sqlCache,
                                                                        java.lang.String bulkResolutionTableName,
                                                                        java.lang.String nodeTableName)
                                                                 throws RdbException

Runs the resolveNodes prepared statement with the default transformer.


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE  ${b}.VALUE=${a}.VALUE

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

resolveNodes

public static ClosableIterator<NodeSQL.ResolveNodesResult> resolveNodes(PreparedStatementCache sqlCache,
                                                                        java.lang.String bulkResolutionTableName,
                                                                        java.lang.String nodeTableName,
                                                                        Transformer<NodeSQL.ResolveNodesResult> transform)
                                                                 throws RdbException

Runs the resolveNodes prepared statement.


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE  ${b}.VALUE=${a}.VALUE

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareResolveNodes

public static void prepareResolveNodes(java.sql.PreparedStatement ps)
                                throws java.sql.SQLException

Sets the input parameters for the resolveNodes prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

resolveLiterals

public static ClosableIterator<NodeSQL.ResolveLiteralsResult> resolveLiterals(PreparedStatementCache sqlCache,
                                                                              java.lang.String bulkResolutionTableName,
                                                                              java.lang.String nodeTableName)
                                                                       throws RdbException

Runs the resolveLiterals prepared statement with the default transformer.


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a}               WHERE           ${b}.VALUE=${a}.VALUE AND ${b}.MODIFIER_ID = ${a}.MODIFIER_ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

resolveLiterals

public static ClosableIterator<NodeSQL.ResolveLiteralsResult> resolveLiterals(PreparedStatementCache sqlCache,
                                                                              java.lang.String bulkResolutionTableName,
                                                                              java.lang.String nodeTableName,
                                                                              Transformer<NodeSQL.ResolveLiteralsResult> transform)
                                                                       throws RdbException

Runs the resolveLiterals prepared statement.


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a}               WHERE           ${b}.VALUE=${a}.VALUE AND ${b}.MODIFIER_ID = ${a}.MODIFIER_ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareResolveLiterals

public static void prepareResolveLiterals(java.sql.PreparedStatement ps)
                                   throws java.sql.SQLException

Sets the input parameters for the resolveLiterals prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

resolveIdsUri

public static ClosableIterator<NodeSQL.ResolveIdsUriResult> resolveIdsUri(PreparedStatementCache sqlCache,
                                                                          java.lang.String bulkResolutionTableName,
                                                                          java.lang.String nodeTableName)
                                                                   throws RdbException

Runs the resolveIdsUri prepared statement with the default transformer.


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE ${b}.ID=${a}.ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

resolveIdsUri

public static ClosableIterator<NodeSQL.ResolveIdsUriResult> resolveIdsUri(PreparedStatementCache sqlCache,
                                                                          java.lang.String bulkResolutionTableName,
                                                                          java.lang.String nodeTableName,
                                                                          Transformer<NodeSQL.ResolveIdsUriResult> transform)
                                                                   throws RdbException

Runs the resolveIdsUri prepared statement.


                SELECT ${b}.ID,${b}.VALUE FROM ${b},${a} WHERE ${b}.ID=${a}.ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareResolveIdsUri

public static void prepareResolveIdsUri(java.sql.PreparedStatement ps)
                                 throws java.sql.SQLException

Sets the input parameters for the resolveIdsUri prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

updateResolvedUris

public static int updateResolvedUris(PreparedStatementCache sqlCache,
                                     java.lang.String bulkResolutionTableName,
                                     java.lang.String nodeTableName)
                              throws RdbException

Runs the updateResolvedUris prepared statement.


                UPDATE ${a} AS A SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.VALUE=A.VALUE)

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: int
Throws:: RdbException

prepareUpdateResolvedUris

public static void prepareUpdateResolvedUris(java.sql.PreparedStatement ps)
                                      throws java.sql.SQLException

Sets the input parameters for the updateResolvedUris prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

updateUnResolvedIds

public static int updateUnResolvedIds(PreparedStatementCache sqlCache,
                                      java.lang.String bulkResolutionTableName,
                                      java.lang.String sequenceName)
                               throws RdbException

Runs the updateUnResolvedIds prepared statement.


                UPDATE ${a} AS A SET TYPE=1,ID=(NEXTVAL FOR ${b}) WHERE A.ID IS NULL

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; sequenceName - template parameter
Returns:: int
Throws:: RdbException

prepareUpdateUnResolvedIds

public static void prepareUpdateUnResolvedIds(java.sql.PreparedStatement ps)
                                       throws java.sql.SQLException

Sets the input parameters for the updateUnResolvedIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

commitUnResolvedUris

public static int commitUnResolvedUris(PreparedStatementCache sqlCache,
                                       java.lang.String bulkResolutionTableName,
                                       java.lang.String nodeTableName)
                                throws RdbException

Runs the commitUnResolvedUris prepared statement.


                INSERT INTO ${b} (ID,VALUE)     SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: int
Throws:: RdbException

prepareCommitUnResolvedUris

public static void prepareCommitUnResolvedUris(java.sql.PreparedStatement ps)
                                        throws java.sql.SQLException

Sets the input parameters for the commitUnResolvedUris prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectAllResolvedUriIds

public static ClosableIterator<NodeSQL.SelectAllResolvedUriIdsResult> selectAllResolvedUriIds(PreparedStatementCache sqlCache,
                                                                                              java.lang.String bulkResolutionTableName)
                                                                                       throws RdbException

Runs the selectAllResolvedUriIds prepared statement with the default transformer.


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

selectAllResolvedUriIds

public static ClosableIterator<NodeSQL.SelectAllResolvedUriIdsResult> selectAllResolvedUriIds(PreparedStatementCache sqlCache,
                                                                                              java.lang.String bulkResolutionTableName,
                                                                                              Transformer<NodeSQL.SelectAllResolvedUriIdsResult> transform)
                                                                                       throws RdbException

Runs the selectAllResolvedUriIds prepared statement.


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareSelectAllResolvedUriIds

public static void prepareSelectAllResolvedUriIds(java.sql.PreparedStatement ps)
                                           throws java.sql.SQLException

Sets the input parameters for the selectAllResolvedUriIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectResolvedUriIds

public static ClosableIterator<NodeSQL.SelectResolvedUriIdsResult> selectResolvedUriIds(PreparedStatementCache sqlCache,
                                                                                        java.lang.String bulkResolutionTableName)
                                                                                 throws RdbException

Runs the selectResolvedUriIds prepared statement with the default transformer.


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

selectResolvedUriIds

public static ClosableIterator<NodeSQL.SelectResolvedUriIdsResult> selectResolvedUriIds(PreparedStatementCache sqlCache,
                                                                                        java.lang.String bulkResolutionTableName,
                                                                                        Transformer<NodeSQL.SelectResolvedUriIdsResult> transform)
                                                                                 throws RdbException

Runs the selectResolvedUriIds prepared statement.


                SELECT ${a}.ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareSelectResolvedUriIds

public static void prepareSelectResolvedUriIds(java.sql.PreparedStatement ps)
                                        throws java.sql.SQLException

Sets the input parameters for the selectResolvedUriIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectAllIds

public static ClosableIterator<NodeSQL.SelectAllIdsResult> selectAllIds(PreparedStatementCache sqlCache,
                                                                        java.lang.String bulkResolutionTableName)
                                                                 throws RdbException

Runs the selectAllIds prepared statement with the default transformer.


                SELECT ${a}.TYPE,${a}.ID,${a}.VALUE FROM ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

selectAllIds

public static ClosableIterator<NodeSQL.SelectAllIdsResult> selectAllIds(PreparedStatementCache sqlCache,
                                                                        java.lang.String bulkResolutionTableName,
                                                                        Transformer<NodeSQL.SelectAllIdsResult> transform)
                                                                 throws RdbException

Runs the selectAllIds prepared statement.


                SELECT ${a}.TYPE,${a}.ID,${a}.VALUE FROM ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareSelectAllIds

public static void prepareSelectAllIds(java.sql.PreparedStatement ps)
                                throws java.sql.SQLException

Sets the input parameters for the selectAllIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectAllResolvedLiteralIds

public static ClosableIterator<NodeSQL.SelectAllResolvedLiteralIdsResult> selectAllResolvedLiteralIds(PreparedStatementCache sqlCache,
                                                                                                      java.lang.String bulkResolutionTableName)
                                                                                               throws RdbException

Runs the selectAllResolvedLiteralIds prepared statement with the default transformer.


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

selectAllResolvedLiteralIds

public static ClosableIterator<NodeSQL.SelectAllResolvedLiteralIdsResult> selectAllResolvedLiteralIds(PreparedStatementCache sqlCache,
                                                                                                      java.lang.String bulkResolutionTableName,
                                                                                                      Transformer<NodeSQL.SelectAllResolvedLiteralIdsResult> transform)
                                                                                               throws RdbException

Runs the selectAllResolvedLiteralIds prepared statement.


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE TYPE IS NOT NULL

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareSelectAllResolvedLiteralIds

public static void prepareSelectAllResolvedLiteralIds(java.sql.PreparedStatement ps)
                                               throws java.sql.SQLException

Sets the input parameters for the selectAllResolvedLiteralIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectResolvedLiteralIds

public static ClosableIterator<NodeSQL.SelectResolvedLiteralIdsResult> selectResolvedLiteralIds(PreparedStatementCache sqlCache,
                                                                                                java.lang.String bulkResolutionTableName)
                                                                                         throws RdbException

Runs the selectResolvedLiteralIds prepared statement with the default transformer.


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

selectResolvedLiteralIds

public static ClosableIterator<NodeSQL.SelectResolvedLiteralIdsResult> selectResolvedLiteralIds(PreparedStatementCache sqlCache,
                                                                                                java.lang.String bulkResolutionTableName,
                                                                                                Transformer<NodeSQL.SelectResolvedLiteralIdsResult> transform)
                                                                                         throws RdbException

Runs the selectResolvedLiteralIds prepared statement.


                SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=2

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareSelectResolvedLiteralIds

public static void prepareSelectResolvedLiteralIds(java.sql.PreparedStatement ps)
                                            throws java.sql.SQLException

Sets the input parameters for the selectResolvedLiteralIds prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

updateResolvedLiterals

public static int updateResolvedLiterals(PreparedStatementCache sqlCache,
                                         java.lang.String bulkResolutionTableName,
                                         java.lang.String nodeTableName)
                                  throws RdbException

Runs the updateResolvedLiterals prepared statement.


                UPDATE ${a} AS L SET TYPE=2,ID=(SELECT ${b}.ID FROM ${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE)

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: int
Throws:: RdbException

prepareUpdateResolvedLiterals

public static void prepareUpdateResolvedLiterals(java.sql.PreparedStatement ps)
                                          throws java.sql.SQLException

Sets the input parameters for the updateResolvedLiterals prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

selectResolvedLiterals

public static java.lang.Long selectResolvedLiterals(PreparedStatementCache sqlCache,
                                                    java.lang.String bulkResolutionTableName,
                                                    java.lang.String nodeTableName)
                                             throws RdbException

Runs the selectResolvedLiterals prepared statement.


                SELECT COUNT(${b}.ID) FROM ${a} L,${b} WHERE ${b}.MODIFIER_ID=L.MODIFIER_ID AND ${b}.VALUE=L.VALUE

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: Long
Throws:: RdbException

prepareSelectResolvedLiterals

public static void prepareSelectResolvedLiterals(java.sql.PreparedStatement ps)
                                          throws java.sql.SQLException

Sets the input parameters for the selectResolvedLiterals prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

commitUnResolvedLiterals

public static int commitUnResolvedLiterals(PreparedStatementCache sqlCache,
                                           java.lang.String bulkResolutionTableName,
                                           java.lang.String nodeTableName)
                                    throws RdbException

Runs the commitUnResolvedLiterals prepared statement.


                INSERT INTO ${b} (ID,MODIFIER_ID,VALUE) SELECT ${a}.ID,${a}.MODIFIER_ID,${a}.VALUE FROM ${a} WHERE ${a}.TYPE=1

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: int
Throws:: RdbException

prepareCommitUnResolvedLiterals

public static void prepareCommitUnResolvedLiterals(java.sql.PreparedStatement ps)
                                            throws java.sql.SQLException

Sets the input parameters for the commitUnResolvedLiterals prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

resolveIdsLiteral

public static ClosableIterator<NodeSQL.ResolveIdsLiteralResult> resolveIdsLiteral(PreparedStatementCache sqlCache,
                                                                                  java.lang.String bulkResolutionTableName,
                                                                                  java.lang.String nodeTableName)
                                                                           throws RdbException

Runs the resolveIdsLiteral prepared statement with the default transformer.


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a} WHERE ${b}.ID =${a}.ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

resolveIdsLiteral

public static ClosableIterator<NodeSQL.ResolveIdsLiteralResult> resolveIdsLiteral(PreparedStatementCache sqlCache,
                                                                                  java.lang.String bulkResolutionTableName,
                                                                                  java.lang.String nodeTableName,
                                                                                  Transformer<NodeSQL.ResolveIdsLiteralResult> transform)
                                                                           throws RdbException

Runs the resolveIdsLiteral prepared statement.


                SELECT ${b}.ID,${b}.VALUE,${b}.MODIFIER_ID FROM ${b},${a} WHERE ${b}.ID =${a}.ID

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter; nodeTableName - template parameter; transform - org.openanzo.jdbc.utils.Transformer used to transform results into java objects
Returns:: org.openanzo.jdbc.utils.ClosableIterator
Throws:: RdbException

prepareResolveIdsLiteral

public static void prepareResolveIdsLiteral(java.sql.PreparedStatement ps)
                                     throws java.sql.SQLException

Sets the input parameters for the resolveIdsLiteral prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

purge

public static int purge(PreparedStatementCache sqlCache,
                        java.lang.String bulkResolutionTableName)
                 throws RdbException

Runs the purge prepared statement.


                DELETE FROM ${a}

Parameters:: sqlCache - factory and cache of PreparedStatments; bulkResolutionTableName - template parameter
Returns:: int
Throws:: RdbException

preparePurge

public static void preparePurge(java.sql.PreparedStatement ps)
                         throws java.sql.SQLException

Sets the input parameters for the purge prepared statement.

Parameters:: ps - PreparedStatement to whose parameters are set
Throws:: java.sql.SQLException

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.openanzo.common.rdb.sql Class NodeSQL

getAllLiterals

findNodeID

fetchNodeID

fetchNodeValue

fetchLongNodeID

fetchLiteralNodeValue

fetchLiteralNodeID

fetchLongLiteralNodeID

insertCommonValue

fetchCommonValueID

fetchCommonValue

fetchAllCommonValues

storeBulkNode

storeBulkLongNode

storeBulkLiteral

storeBulkLongLiteral

countTempTable

storeResolveId

storeResolveNode

storeResolveNodeLong

storeResolveLiteral

storeResolveLiteralLong

resolveNodes

resolveLiterals

resolveIdsUri

updateResolvedUris

updateUnResolvedIds

commitUnResolvedUris

selectAllResolvedUriIds

selectResolvedUriIds

selectAllIds

selectAllResolvedLiteralIds

selectResolvedLiteralIds

updateResolvedLiterals

selectResolvedLiterals

commitUnResolvedLiterals

resolveIdsLiteral

purge

NodeSQL

getAllLiterals

getAllLiterals

prepareGetAllLiterals

findNodeID

findNodeID

findNodeID

prepareFindNodeID

fetchNodeID

prepareFetchNodeID

fetchNodeValue

prepareFetchNodeValue

fetchLongNodeID

fetchLongNodeID

prepareFetchLongNodeID

fetchLiteralNodeValue

fetchLiteralNodeValue

prepareFetchLiteralNodeValue

fetchLiteralNodeID

fetchLiteralNodeID

prepareFetchLiteralNodeID

fetchLongLiteralNodeID

fetchLongLiteralNodeID

fetchLongLiteralNodeID

prepareFetchLongLiteralNodeID

insertCommonValue

insertCommonValue

prepareInsertCommonValue

fetchCommonValueID

prepareFetchCommonValueID

fetchCommonValue

prepareFetchCommonValue

fetchAllCommonValues

fetchAllCommonValues

prepareFetchAllCommonValues

storeBulkNode

storeBulkNode

prepareStoreBulkNode

storeBulkLongNode

storeBulkLongNode

prepareStoreBulkLongNode

org.openanzo.common.rdb.sql
Class NodeSQL