OraclePropertyGraph (Oracle Spatial and Graph Property Graph)

java.lang.Object
- oracle.pg.common.OraclePropertyGraphBase
- - oracle.pg.rdbms.OraclePropertyGraph

All Implemented Interfaces:

Graph, IndexableGraph, KeyIndexableGraph, TransactionalGraph, MesgConsts, OracleChangeTracker, OraclePropertyGraphAnalytics
```
public class OraclePropertyGraph
extends OraclePropertyGraphBase
implements OraclePropertyGraphAnalytics, OracleChangeTracker
```
This class implements the Blueprints Graph interface by using an Oracle backend.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class OraclePropertyGraph.Sort
This enumeration denotes the sorting order for function getTopK
- Nested classes/interfaces inherited from class oracle.pg.common.OraclePropertyGraphBase
  OraclePropertyGraphBase.OptimizationFlag
- Nested classes/interfaces inherited from interface com.tinkerpop.blueprints.TransactionalGraph
  TransactionalGraph.Conclusion

Nested Classes
Modifier and Type	Class and Description
`static class`	`OraclePropertyGraph.Sort` This enumeration denotes the sorting order for function getTopK

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`DEFAULT_NUMBER_FORMAT` This constant denotes the default number format used in SQL Statements
`static String`	`DEFAULT_TIME_FORMAT` This constant denotes the default datetime format used in SQL Statements

Fields inherited from interface oracle.pg.common.MesgConsts
ERR_ARG_CANNOT_BE_NULL, ERR_CODE_NOT_IN_LIST, ERR_DOP_CONSTRAINT, ERR_E_AUTO_IDX_MUST_SOLR_OR_LUCENE, ERR_E_AUTO_IDX_NOT_EXIST, ERR_E_DS_MUSTBE_FILE_OR_IS, ERR_E_MAX_LINE_CONSTRAINT, ERR_EDGE_DIR_NOT_BOTH, ERR_EDGE_WORK_TBL_NOT_CLEAN, ERR_GRAPH_NAME_CANT_BENULL, ERR_HIT_EXCEPTION, ERR_HIT_INTERRUPT, ERR_HIT_IO, ERR_HIT_OPGE, ERR_HIT_PARSEE, ERR_ID_CANNOT_BE_NULL, ERR_IDX_KEY_CANNOT_BE_NULL, ERR_IDX_KEY_NOT_NULL, ERR_IDX_KEYS_NOT_NULL, ERR_IN_DS_EDGE_CANTBE_NULL, ERR_IN_DS_VERT_CANTBE_NULL, ERR_IN_E_FLAT_DOESNT_EXIST, ERR_IN_V_FLAT_DOESNT_EXIST, ERR_INPUT_LIST_NOT_NULL, ERR_INPUT_NOT_NULL, ERR_INVALID_CHANGE_ACTION, ERR_INVALID_NUM_FIELDS, ERR_INVALID_NUM_NOARG, ERR_INVALID_NUMBER, ERR_INVALID_VAL, ERR_KEY_CANNOT_BE_ID, ERR_KEY_CANNOT_BE_NULL, ERR_KEY_CANNOT_BE_NULL_EMPTY, ERR_KEY_NOT_SET_TO, ERR_NO_ELEM_TO_BE_CONSUMED, ERR_NO_OP_SUPPORTED, ERR_NOT_IMPLEMENTED_YET, ERR_NOT_ORACLE_V_E, ERR_NUM_PART_CONSTRAINT, ERR_OFFSET_CONSTRAINT, ERR_OFFSET_E_MUST_BE_POS, ERR_OFFSET_V_MUST_BE_POS, ERR_OPT_FLAG_EDGE_INVALID, ERR_OPT_FLAG_VERT_INVALID, ERR_ORA_TEXT_INVALID_KEY, ERR_ORA_TEXT_ONLY_AUTO, ERR_OUTPUT_LIST_NOT_NULL, ERR_PG_ALREADY_EXISTS, ERR_PG_NOT_EMPTY, ERR_PG_NOT_NULL, ERR_SIZE_MUST_BE_POS, ERR_TIMEOUT_TAB_CREATION, ERR_TXT_IDX_NOT_FOUND, ERR_TYPE_ID_NOT_RECO, ERR_UNSUPPORTED_VAL_TYP, ERR_USER_REQ_OP_CANCEL, ERR_V_AUTO_IDX_MUST_SOLR_OR_LUCENE, ERR_V_AUTO_IDX_NOT_EXIST, ERR_V_DS_MUSTBE_FILE_OR_IS, ERR_V_MAX_LINE_CONSTRAINT, ERR_VALUE_CANNOT_BE_NULL, INFO_EMP_K_NO_P_VAL, INFO_NUL_K_NO_P_VAL

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAttributeToAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop, ProgressListener pl)` Adds an attribute to all edges based on the specified `EdgeOpCallback`.
`void`	`addAttributeToAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop, ProgressListener pl)` Adds an attribute to all vertices based on the specified `VertexOpCallback`.
`Edge`	`addEdge(Object id, Vertex outVertex, Vertex inVertex, String label)` Adds an edge to the graph instance.
`Vertex`	`addVertex(Object id)` Adds an vertex to the graph instance.
`void`	`analyze(float estimatePercent, String methodOpt)` Collects statistics for this graph.
`void`	`analyze(float estimatePercent, String methodOpt, int dop)` Collects statistics for this graph.
`void`	`analyze(int dop)` Collects statistics for this graph.
`void`	`analyzeAuto(int dop)` Collects statistics for this graph.
`void`	`clearCache()` Clears the internal Vertex and Edge cache.
`void`	`clearRepository()` Removes all vertices and edges from this property graph instance.
`void`	`clearUpdateQueue()` Clears the update action queue.
`void`	`commit()` Commit changes done to this property graph instance.
`void`	`commit(boolean bCommitIndices)` Commit changes done to this property graph instance.
`long`	`countEdges(int dop, ProgressListener pll)` Counts all edges using parallel scans and the specified DOP.
`static long`	`countTriangle(Connection conn, String szEdgeTabName, StringBuilder sbUndirWorkTab, int iNumSubPtns, int iDOP, String szTBS, String szOptions)` Returns the number of triangles that exist in this graph.
`long`	`countTriangle(StringBuilder sbUndirWorkTab)` Returns the number of triangles that exist in this graph which is treated as undirected.
`long`	`countTriangle(StringBuilder sbUndirWorkTab, int iNumSubPtns, int iDOP, String szTBS, String szOptions)` Returns the number of triangles that exist in this graph.
`void`	`countTriangleCleanup(StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, String szOptions)` This method does cleanup work after running triangle calculations.
`void`	`countTrianglePrep(StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, String szOptions)` This method does preparation work before running triangle calculations.
`static long`	`countTriangleRenum(Connection conn, String szEdgeTabName, StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, int iNumSubPtns, int iDOP, String szTBS, String szOptions)` Returns the number of triangles that exist in this graph (treated as undirected).
`long`	`countTriangleRenum(StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, int iNumSubPtns, int iDOP, String szTBS, String szOptions)` Returns the number of triangles that exist in this graph (treated as undirected).
`long`	`countVertices(int dop, ProgressListener pll)` Counts all vertices using parallel scan with dop threads
`void`	`createDefaultSpatialIndexOnEdges(int dop)` This API creates a default Spatial index on edges.
`void`	`createDefaultSpatialIndexOnEdges(int dop, boolean bLocal, boolean bUseV2)` This API creates a default Spatial index on edges.
`void`	`createDefaultSpatialIndexOnVertices(int dop)` This API creates a default Spatial index on vertices.
`void`	`createDefaultSpatialIndexOnVertices(int dop, boolean bLocal, boolean bUseV2)` This API creates a default Spatial index on vertices.
`void`	`createStatTable(String statTableName)` Creates a stat table using DBMS_STATS package.
`void`	`disable()` Disables the session flash back.
`List<String>`	`disableEdgeTableConstraints()` Disables all the database constraints of the edge table.
`List<String>`	`disableEdgeTableIndices()` Disables all database indices of the edge table.
`List<String>`	`disableVertexTableConstraints()` Disables all the database constraints of the vertex table.
`List<String>`	`disableVertexTableIndices()` Disables all database indices of the vertex table
`void`	`dispose()` Closes the graph without commiting any changes
`boolean`	`doesEdgeExistAt(String szEdgeID, Long longEndSCN)` Returns TRUE if the edge identified by the given edge ID exist at SCN denoted by the end scn
`boolean`	`doesEdgeExistAt(String szEdgeID, Long longEndSCN, int iQueryDOP)` Returns TRUE if the edge identified by the given edge ID exist at SCN denoted by the end scn
`boolean`	`doesVertexExistAt(String szVertexID, Long longEndSCN)` Returns TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end scn
`boolean`	`doesVertexExistAt(String szVertexID, Long longEndSCN, int iQueryDOP)` Returns TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end scn
`void`	`dropDefaultSpatialIndexOnEdges()` This API drops the default Spatial index on edges.
`void`	`dropDefaultSpatialIndexOnVertices()` This API drops the default Spatial index on vertices.
`void`	`enableAtSCN(Long longSCN)` Sets the session snapshot to the given SCN value
`static long`	`estimateTriangleRenum(Connection conn, String szEdgeTabName, StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, int iNumSubPtns, int iChunk, int iDOP, String szTBS, String szOptions)` This method estimates the number of triangles that exist in this graph (treated as undirected).
`long`	`estimateTriangleRenum(StringBuilder sbUndirBMTab, StringBuilder sbMapWorkTab, StringBuilder sbUndirAMTab, int iNumSubPtns, int iChunk, int iDOP, String szTBS, String szOptions)` This method estimates the number of triangles that exist in this graph (treated as undirected).
`void`	`expEdgeStat(String statTableName, String statid)` Exports the edge table statistics into the given stat table.
`void`	`expVertexStat(String statTableName, String statid)` Exports the vertex table statistics into the given stat table.
`static void`	`findCluster(Connection conn, String szEdgeTabName, StringBuilder sbClusters, StringBuilder sbUndir, StringBuilder sbCluas, StringBuilder sbNewas, StringBuilder sbDelta, int iDOP, String szTBS, String szOptions)` This method finds clusters in a given graph (treated as undirected).
`void`	`findCluster(StringBuilder sbClusters, StringBuilder sbUndir, StringBuilder sbCluas, StringBuilder sbNewas, StringBuilder sbDelta, int iDOP, String szTBS, String szOptions)` This method finds clusters in this property graph (treated as undirected).
`void`	`findClusterCleanup(StringBuilder sbClusters, StringBuilder sbUndir, StringBuilder sbCluas, StringBuilder sbNewas, StringBuilder sbDelta, String szOptions)` This method does cleanup work after running graph cluster detection.
`void`	`findClusterPrep(StringBuilder sbClusters, StringBuilder sbUndir, StringBuilder sbCluas, StringBuilder sbNewas, StringBuilder sbDelta, String szOptions)` This method does preparation work before running graph cluster detection.
`LinkedList<String>`	`getConstraintNames(String szTabName)` Gets a List of all the database constraints associated to the given table.
`Long`	`getCurrentSCN()` Returns the current SCN by invoking DBMS FLASHBACK API.
`Long`	`getCurrentSCNUnsafe()` Returns the current SCN by invoking DBMS FLASHBACK API.
`Class`	`getDatatypeClassFromValueObjForTextIndex(Object value)` Gets the datatype class from the given value object used when executing a query over a text index
`int`	`getDefaultDOPPerPtn()` Returns the default DOP used for partition-wise scan
`OracleEdge`	`getEdge(Object id)` Returns the edge referenced by the object identifier.
`Iterator<EdgeChange>`	`getEdgeChanges(Long longStartSCN, Long longEndSCN)` Returns the changes between the given start SCN and end SCN.
`Iterator<EdgeChange>`	`getEdgeChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP)` Returns the edge changes between the given start SCN and end SCN.
`Iterator<EdgeChange>`	`getEdgeChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP, boolean bFilterOutRemovedInserts)` Returns the edge changes between the given start SCN and end SCN.
`Iterator<EdgeChange>`	`getEdgeChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP, boolean bFilterOutRemovedInserts, String[] keys)` Returns the edge changes between the given start SCN and end SCN.
`OracleEdgeBase`	`getEdgeInstance(Long eid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleEdgeBase.
`OracleEdgeBase`	`getEdgeInstance(OracleVertexBase outVertex, OracleVertexBase inVertex, String edgeLabel, Long eid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleEdgeBase.
`int`	`getEdgePartitionsNumber()` Returns the number of HASH partitions of the edge table.
`int`	`getEdgePropertyNames(int dop, int timeout, Set<String> propertyNames, ProgressListener pl)` Gets the property names of all edges using parallel scans and the specified DOP.
`Iterable<Edge>`	`getEdges()` Returns an iterable to all the edges in the graph.
`Iterable<Edge>`	`getEdges(boolean bOrderBySVID)` Returns an iterable to all the edges in the graph.
`Iterable<Edge>`	`getEdges(boolean bOrderBySVID, Long longEndSCN)` Returns an iterable to all the edges in the graph from the given SCN.
`Iterable<Edge>`	`getEdges(boolean bOrderBySVID, Long longEndSCN, String[] keys, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an `Iterable` to all the edges in the graph that have any of the specified keys and satisfy the specified edge filter callback.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray)` Returns an array of iterables to all the edges in the graph.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray, boolean bOrderBySVID)` Returns an array of iterables to all the edges in the graph.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN)` Returns an array of iterables to all the edges in the graph.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID)` Returns an array of iterables to all the edges in the graph.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String key)` Returns an array of iterables to all the edges in the graph that have a particular key.
`Iterable<Edge>[]`	`getEdges(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>`	`getEdges(Long longEndSCN)` Returns an iterable to all the edges in the graph from the given SCN.
`Iterable<Edge>`	`getEdges(ResultSet rs, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an `Iterable` to all the edges from the ResultSet that satisfy the specified edge filter callback.
`Iterable<Edge>`	`getEdges(String[] keys, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an `Iterable` to all the edges in the graph that have any of the specified keys and satisfy the specified edge filter callback.
`Iterable<Edge>`	`getEdges(String key, Object value, Class dtClass, boolean acceptWildcard, boolean useLuceneSyntax)` Return an iterable to all matching edges that have a particular key/value property.
`Iterable<Edge>[]`	`getEdgesNonPartitioned(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>[]`	`getEdgesNonPartitioned(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean skipStoreToCache, int startPartitionID)` Returns an array of iterables to all the edges in the graph.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean bSkipStoreToCache, int startPartitionID, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the edges in the graph that satisfy the specified edge filter callback.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean skipStoreToCache, int startPartitionID, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the edges in the graph that satisfy the specified edge filter callback.
`Iterable<Edge>[]`	`getEdgesPartitioned(Connection[] connArray, boolean bOrderBySVID, Long longEndSCN, String[] keys)` Returns an array of iterables to all the edges in the graph that have any of the specified keys.
`Iterable<Edge>[]`	`getEdgesPartitioned(ResultSet[] rsArray, boolean bSkipStoreToCache, EdgeFilterCallback efc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the edges from the given array of ResultSet objects that satisfy the specified edge filter callback.
`String`	`getEdgeTabIdxName(String szCode)` Returns the name of an index of the edge table for the specified code
`String`	`getEdgeTabName()` Returns the name of the edge table
`Features`	`getFeatures()` Gets the particular features of the graph implementation.
`String`	`getGraphName()` Returns the name of this property graph instance
`String`	`getGraphOwner()` Returns the owner name of the graph.
`LinkedList<String>`	`getIndexNames(String szTabName)` Gets a List of all the database indexes associated to the given table.
`<T extends Element> OracleIndexParameters`	`getIndexParameters(String indexName, Class<T> indexClass)` Gets the index parameters associated to the given text index.
`static OraclePropertyGraph`	`getInstance(Oracle oracle, String szGraphName)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
`static OraclePropertyGraph`	`getInstance(Oracle oracle, String szGraphName, int iHashPartitionsNum)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
`static OraclePropertyGraph`	`getInstance(Oracle oracle, String szGraphName, int iHashPartitionsNum, int iDOP, String szTBS, String szOptions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
`static OraclePropertyGraph`	`getInstance(Oracle oracle, String szGraphOwner, String szGraphName, int iHashPartitionsNum, int iDOP, String szTBS, String szOptions)` Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
`static OraclePropertyGraph`	`getInstance(oracle.pgx.config.PgRdbmsGraphConfig config)` Gets an OraclePropertyGraph instance from a PGX PgRdbmsGraphConfig object
`Set<Long>`	`getInvalidEdgeIDSet(int dop, ProgressListener pl)` Gets a set of invalid edges that are stored in the property graph.
`long`	`getMaxEdgeID(int dop, ProgressListener pl)` Get the maximum edge ID using parallel scan and the specified DOP.
`long`	`getMaxVertexID(int dop, ProgressListener pl)` Get maximum vertex ID using parallel scans and the specified DOP.
`long`	`getMinEdgeID(int dop, ProgressListener pl)` Get the minimum edge ID using parallel scan with dop threads
`long`	`getMinVertexID(int dop, ProgressListener pl)` Get minimum vertex ID using parallel scans and the specified DOP.
`String`	`getNumberToCharSqlFormatString()` Gets the Char SQL Format used to format a number into a string
`long`	`getOperationQueueSize()` Get the size of the operation queue
`Oracle`	`getOracle()` Returns the underlying Oracle instance associated with the property graph instance
`static Oracle`	`getOracle(oracle.pgx.config.PgRdbmsGraphConfig config)` Gets an Oracle object from a PGX PgRdbmsGraphConfig object
`OracleIndexManager`	`getOracleIndexManager()` Gets the Oracle Index Manager associated to this property graph instance.
`boolean`	`getPGViewOnRDFFlag()` Validates if this property graph instance comes from a Property Graph view over RDF data
`int`	`getQueryFetchSize()` Returns the query fetch size when scanning the vertex and edge tables
`Iterator<Long>`	`getRemovedEdges(Long longStartSCN, Long longEndSCN, int iQueryDOP, String szOptions)` Returns an ordered iterator of IDs of Edges that involved in DELETE operations happened between the two given SCNs.
`Iterator<Long>`	`getRemovedVertices(Long longStartSCN, Long longEndSCN, int iQueryDOP, String szOptions)` Returns an ordered iterator of IDs of Vertices that involved in DELETE operations happened between the two given SCNs.
`int`	`getRowPrefetch()` Returns the number of rows to prefetch when executing a SQL query over the Property graph data tables
`String`	`getSessionID()` Returns the current database Session ID
`int`	`getSessionQueryDOP()` Returns the degree of parallel query execution at the session level.
`String`	`getSkeletonTabIdxName(String szCode)` Returns the name of an index of the graph GT table for the specified code
`String`	`getSkeletonTabName()` Returns the name of the graph skeleton table
`String`	`getSnapshotTabName()` Returns the name of the PGX snapshot table
`String`	`getTextIndexDirectoryPrefix()` Returns the name of this property graph instance
`String`	`getTextIndexTabName()` Returns the name of the index metadata table
`String`	`getTimeToCharSqlFormatString()` Gets the Char SQL Format used to format a datetime into a string
`static ResultSet`	`getTopK(Connection conn, StringBuilder sbTabName, int iColIdx, OraclePropertyGraph.Sort sort, int k, int iDOP)` Returns the top K rows of a given table.
`ResultSet`	`getTopK(StringBuilder sbTabName, int iColIdx, OraclePropertyGraph.Sort sort, int k)` Returns the top K rows of a given table.
`ResultSet`	`getTopK(StringBuilder sbTabName, int iColIdx, OraclePropertyGraph.Sort sort, int k, int iDOP)` Returns the top K rows of a given table.
`OracleVertex`	`getVertex(Object id)` Returns the vertex referenced by the object identifier.
`Iterator<VertexChange>`	`getVertexChanges(Long longStartSCN, Long longEndSCN)` Returns the changes between the given start SCN and end SCN.
`Iterator<VertexChange>`	`getVertexChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP)` Returns the vertex changes between the given start SCN and end SCN using the given query degree of parallelism.
`Iterator<VertexChange>`	`getVertexChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP, boolean bFilterOutRemovedInserts)` Returns the vertex changes between the given start SCN and end SCN.
`Iterator<VertexChange>`	`getVertexChanges(Long longStartSCN, Long longEndSCN, int iQueryDOP, boolean bFilterOutRemovedInserts, String[] keys)` Returns the vertex changes between the given start SCN and end SCN.
`Set<Long>`	`getVertexIDSet(int dop, ProgressListener pl)` Gets a set of Vertex IDs that are stored in the property graph
`OracleVertexBase`	`getVertexInstance(Long vid, boolean bCreateIfAbsentFromCache, boolean bSkipStoreToCache)` Returns an instance of OracleVertexBase.
`int`	`getVertexPartitionsNumber()` Returns the number of HASH partitions of the vertex table.
`int`	`getVertexPropertyNames(int dop, int timeout, Set<String> propertyNames, ProgressListener pl)` Gets the property names of all vertices using parallel scans and the specified DOP.
`String`	`getVertexTabIdxName(String szCode)` Returns the name of an index of the vertex table for the specified code
`String`	`getVertexTabName()` Returns the name of the vertex table
`Iterable<Vertex>`	`getVertices()` Returns an iterable to all the vertices in the graph.
`Iterable<Vertex>[]`	`getVertices(Connection[] connArray)` Returns an array of iterables to all the vertices in the graph.
`Iterable<Vertex>[]`	`getVertices(Connection[] connArray, Long longEndSCN)` Returns an array of iterables to all the vertices in the graph.
`Iterable<Vertex>[]`	`getVertices(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID)` Returns an array of iterables to all the vertices in the graph.
`Iterable<Vertex>[]`	`getVertices(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String key)` Returns an array of iterables to all the vertices in the graph that have a particular key.
`Iterable<Vertex>[]`	`getVertices(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>`	`getVertices(Long longEndSCN, String[] keys, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an `Iterable` to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback.
`Iterable<Vertex>`	`getVertices(ResultSet rs, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an iterable to all the relevant vertices in the graph.
`Iterable<Vertex>`	`getVertices(String[] keys, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an `Iterable` to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback.
`Iterable<Vertex>`	`getVertices(String key, Object value, Class dtClass, boolean acceptWildcard, boolean useLuceneSyntax)` Return an iterable to all matching vertices that have a particular key/value property.
`Iterable<Vertex>[]`	`getVerticesNonPartitioned(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>[]`	`getVerticesNonPartitioned(Connection[] connArray, Long longEndSCN, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, boolean skipStoreToCache, int startPartitionID)` Returns an array of iterables to all the vertices in the graph.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, boolean skipStoreToCache, int startPartitionID, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connections, boolean bSkipStoreToCache, int startPartitionID, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the vertices in the graph that satisfy the specified vertex filter callback.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys, VertexFilterCallback vfc)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, Long longEndSCN, boolean bSkipStoreToCache, int iStartPartitionID, String[] keys, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback.
`Iterable<Vertex>[]`	`getVerticesPartitioned(Connection[] connArray, Long longEndSCN, String[] keys)` Returns an array of iterables to all the vertices in the graph that have any of the specified keys.
`Iterable<Vertex>[]`	`getVerticesPartitioned(ResultSet[] rsArray, boolean bSkipStoreToCache, VertexFilterCallback vfc, OraclePropertyGraphBase.OptimizationFlag flag)` Returns an array of iterables to all the vertices in the graph that satisfy the specified vertex filter callback.
`Date`	`getVTE()` Get the end valid time used in the property graph
`Date`	`getVTS()` Get the start valid time used in the property graph
`void`	`grantAccess(String user, String privilege)` Grants access of this property graph to another user
`void`	`impEdgeStat(String statTableName, String statid)` Imports the edge table statistics from the given stat table.
`void`	`impVertexStat(String statTableName, String statid)` Imports the vertex table statistics from the given stat table.
`boolean`	`isDB11g()` Returns if this property graph instance is working against an 11g database
`boolean`	`isVirtualPropertyGraph()` Validates if this property graph instance is based on a view
`static long`	`pageRank(Connection conn, String szEdgeTabName, StringBuilder sbNodePR, StringBuilder sbNodeNextPR, StringBuilder sbEdgeTabDeg, StringBuilder sbDelta, float d, int iNumIterations, float convergence, int iDOP, String szTBS, String szOptions)` This method calculates the page rank values of vertices in the given graph.
`long`	`pageRank(StringBuilder sbNodePR, StringBuilder sbNodeNextPR, StringBuilder sbEdgeTabDeg, StringBuilder sbDelta, float d, int iNumIterations, float convergence, int iDOP, String szTBS, String szOptions)` This method calculates the page rank values of vertices in this graph.
`void`	`pageRankCleanup(StringBuilder sbNodePR, StringBuilder sbNodeNextPR, StringBuilder sbEdgeTabDeg, StringBuilder sbDelta, String szOptions)` This method does cleanup work before running page rank calculation.
`void`	`pageRankPrep(StringBuilder sbNodePR, StringBuilder sbNodeNextPR, StringBuilder sbEdgeTabDeg, StringBuilder sbDelta, String szOptions)` This method does preparation work before running page rank calculation.
`ResultSet[]`	`parallelExecuteStatements(PreparedStatement[] stmtArray)` Executes the given statements in parallel and returns an array of result sets from each statement.
`String`	`parseValueToCharSQLFormatString(Object value)` Parses a numeric or datetime value object into the String format required by SQL (Oracle Text) using the CharSQL formats used in this property graph instance.
`void`	`rebuildAllIndexPartitions(String szIdx, int iDop)` Rebuilds all the index partitions for the given database index.
`void`	`rebuildEdgeTableConstraints(List<String> llConstraints, int dop, String szOptions)` This method rebuilds all the database constraints of the edge table.
`void`	`rebuildEdgeTableIndices(List<String> llIndices, int dop, String szOptions)` Rebuilds all database indices of the edge table.
`void`	`rebuildVertexTableConstraints(List<String> llConstraints, int dop, String szOptions)` Rebuilds all the database constraints of the vertex table.
`void`	`rebuildVertexTableIndices(List<String> llIndices, int dop, String szOptions)` Rebuilds all database indices of the vertex table.
`void`	`refreshIndices(long lStartSCN, long lEndSCN)` Refreshes all the text indices based on the changes done during the given SCN window.
`void`	`removeAttributeFromAllEdges(EdgeOpCallback eoc, boolean skipStoreToCache, int dop, ProgressListener pl)` Removes an attribute from all edges based on the specified `EdgeOpCallback`.
`void`	`removeAttributeFromAllVertices(VertexOpCallback voc, boolean skipStoreToCache, int dop, ProgressListener pl)` Removes an attribute from all vertices based on the specified `VertexOpCallback`.
`void`	`removeEdge(Edge edge)` Removes the provided edge from the graph.
`void`	`removeVertex(Vertex vertex)` Removes the provided vertex from the graph.
`void`	`rollback()` Rollbacks the operations done to this property graph instance
`void`	`setDefaultDOPPerPtn(int i)` This method sets the default DOP used for partition-wise scan.
`void`	`setLabel(String policy, String label)` Sets the label for the current session.
`void`	`setNumberToCharSqlFormatString(String format)` Sets the Char SQL Format used to format a number into a string
`void`	`setPGViewOnRDFFlag(boolean flag)` Specifies if this property graph instance comes from a Property Graph view over RDF data
`void`	`setQueryFetchSize(int size)` Sets the query fetch size used when scanning the vertex and edge tables
`void`	`setRowLabel(String policy, String label)` Sets the row label for the current session.
`void`	`setRowPrefetch(int i)` Sets the number of rows to prefetch when executing a SQL query over the Property graph data tables
`void`	`setSessionQueryDOP(int dop)` Sets the degree of parallel query execution at the session level.
`void`	`setTimeToCharSqlFormatString(String format)` Sets the Char SQL Format used to format a datetime into a string
`void`	`setVTE(Date dateVTE)` Set the end valid time used in the property graph
`void`	`setVTS(Date dateVTS)` Set the start valid time used in the property graph
`static String`	`shortestPath(Connection conn, String szEdgeTabName, Long lStart, Long lEnd, StringBuilder sbExpTab, StringBuilder sbPathWeights, String szOptions, Long lSCN)` Returns a shortest path in a string format.
`String`	`shortestPath(Long lStart, Long lEnd, StringBuilder sbExpTab)` Returns a shortest path in a string format.
`String`	`shortestPath(Long lStart, Long lEnd, StringBuilder sbExpTab, StringBuilder sbPathWeights, String szOptions)` Returns a shortest path in a string format.
`String`	`shortestPath(Long lStart, Long lEnd, StringBuilder sbExpTab, String szEdgeTabName, StringBuilder sbPathWeights, String szOptions, Long lSCN)` Returns a shortest path in a string format.
`String`	`shortestPath(OracleVertex vStart, OracleVertex vEnd, StringBuilder sbExpTab)` Returns a shortest path in a string format.
`String`	`shortestPath(OracleVertex vStart, OracleVertex vEnd, StringBuilder sbExpTab, StringBuilder sbPathWeights, String szOptions)` Returns a shortest path in a string format.
`void`	`shortestPathCleanup(StringBuilder sbExpTab, String szOptions)` This method does clean up after running shortest path calculations.
`void`	`shortestPathPrep(StringBuilder sbExpTab, String szOptions)` This method does some preparation work before running one or multiple shortest path calculations.
`void`	`shutdown()` Commits all the queued operations and properly closes the graph.
`static void`	`sparsifyGraph(Connection conn, String szEdgeTabName, float fThreshold, int iMinKeep, int iDOP, StringBuilder sbOutTab, StringBuilder sbUndTab, StringBuilder sbHshTab, StringBuilder sbMchTab, String szTBS, String szOptions)` This method sparsifies a given graph (treated as undirected).
`void`	`sparsifyGraph(float fThreshold, int iMinKeep, int iDOP, StringBuilder sbOutTab, StringBuilder sbUndTab, StringBuilder sbHshTab, StringBuilder sbMchTab, String szTBS, String szOptions)` This method sparsifies this graph instance (treated as undirected).
`void`	`sparsifyGraphCleanup(StringBuilder sbOutTab, StringBuilder sbUndTab, StringBuilder sbHshTab, StringBuilder sbMchTab, String szOptions)` This method does cleanup work before running graph sparsification.
`void`	`sparsifyGraphPrep(StringBuilder sbOutTab, StringBuilder sbUndTab, StringBuilder sbHshTab, StringBuilder sbMchTab, String szOptions)` This method does preparation work before running graph sparsification.
`String`	`toString()` Returns a very succinct String representation of this Graph instance

Methods inherited from class oracle.pg.common.OraclePropertyGraphBase
addAttributeToAllEdges, addAttributeToAllEdges, addAttributeToAllVertices, addAttributeToAllVertices, commitIndices, countEdges, countEdges, countVertices, countVertices, createIndex, createKeyIndex, createKeyIndex, createKeyIndex, dropAllAutoIndices, dropAllIndices, dropAllManualIndices, dropIndex, dropKeyIndex, dropKeyIndex, dropKeyIndex, getAutoIndex, getBatchSize, getConfig, getDefaultEdgeOptFlag, getDefaultIndexParameters, getDefaultVertexOptFlag, getEdgeFilterCallback, getEdgePropertyNames, getEdges, getEdges, getEdges, getEdges, getEdges, getEdges, getEdges, getEdgesUsingTextSearch, getIndex, getIndexedKeys, getIndices, getInvalidEdgeIDSet, getInvalidEdgeIDSet, getJustEdgeIdOptFlag, getJustVertexIdOptFlag, getMaxEdgeID, getMaxEdgeID, getMaxVertexID, getMaxVertexID, getMinEdgeID, getMinEdgeID, getMinVertexID, getMinVertexID, getProgressListener, getQueueSize, getShortestPath, getShortestPath, getSimpleDateFormat, getStringForObj, getVertexFilterCallback, getVertexIDSet, getVertexIDSet, getVertexPropertyNames, getVertices, getVertices, getVertices, getVertices, getVertices, getVertices, getVertices, getVerticesUsingTextSearch, isEdgeAutoIndexEnabled, isEmpty, isTransientPropertyGraphInstance, isVertexAutoIndexEnabled, query, refreshAutoIndices, removeAttributeFromAllEdges, removeAttributeFromAllEdges, removeAttributeFromAllVertices, removeAttributeFromAllVertices, serializableToStr, setBatchSize, setDefaultEdgeOptFlag, setDefaultIndexParameters, setDefaultVertexOptFlag, setEdgeFilterCallback, setProgressListener, setQueueSize, setSolrJavaBinFormat, setTransientPropertyGraphInstance, setVertexFilterCallback, startTransaction, stopTransaction, strToSerializable, sum, useSolrJavaBinFormat

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

- Field Detail
  - DEFAULT_NUMBER_FORMAT
```
public static final String DEFAULT_NUMBER_FORMAT
```
    This constant denotes the default number format used in SQL Statements
    
    See Also:
    Constant Field Values
  - DEFAULT_TIME_FORMAT
```
public static final String DEFAULT_TIME_FORMAT
```
    This constant denotes the default datetime format used in SQL Statements
    
    See Also:
    Constant Field Values
- Method Detail
  - addAttributeToAllEdges
```
public void addAttributeToAllEdges(EdgeOpCallback eoc,
                          boolean skipStoreToCache,
                          int dop,
                          ProgressListener pl)
```
    Adds an attribute to all edges based on the specified EdgeOpCallback. NOTE the current transaction will be committed.
    
    Specified by:
    
    addAttributeToAllEdges in class OraclePropertyGraphBase
    
    Parameters:
    eoc - an EdgeOpCallback object.
    skipStoreToCache - if true, the edges instances will not be stored into the cache.
    dop - a positive integer defining the number of threads to use when parallel processing the edges.
    pl - a ProgressListener object.
  - addAttributeToAllVertices
```
public void addAttributeToAllVertices(VertexOpCallback voc,
                             boolean skipStoreToCache,
                             int dop,
                             ProgressListener pl)
```
    Adds an attribute to all vertices based on the specified VertexOpCallback. NOTE the current transaction will be committed.
    
    Specified by:
    
    addAttributeToAllVertices in class OraclePropertyGraphBase
    
    Parameters:
    voc - a VertexOpCallback object.
    skipStoreToCache - if true, the vertices instances will not be stored into the cache.
    dop - a positive integer defining the number of threads to use when parallel processing the vertices.
    pl - a ProgressListener object.
  - addEdge
```
public Edge addEdge(Object id,
           Vertex outVertex,
           Vertex inVertex,
           String label)
```
    Adds an edge to the graph instance. Note that this is just a logical operation. This is not a thread safe method.
    
    Specified by:
    
    addEdge in interface Graph
    
    Specified by:
    
    addEdge in class OraclePropertyGraphBase
    
    Parameters:
    id - the id of the edge
    outVertex - has to be of type OracleVertex
    inVertex - has to be of type OracleVertex
    label - edge label
    
    Returns:
    an OracleEdge object.
  - addVertex
```
public Vertex addVertex(Object id)
```
    Adds an vertex to the graph instance. Note that this is just a logical operation. Note that this is not a thread safe method.
    
    Specified by:
    
    addVertex in interface Graph
    
    Specified by:
    
    addVertex in class OraclePropertyGraphBase
    
    Parameters:
    id - the id of the vertex
    
    Returns:
    an OracleVertex object.
  - analyze
```
public void analyze(float estimatePercent,
           String methodOpt)
             throws SQLException
```
    Collects statistics for this graph. Behind the scenes, Oracle database will invoke DBMS_STATS package and collect statistics for the underlying vertex and edge tables of this graph.
    It is very important that up-to-date statistics be maintained for a graph to ensure efficient execution of query. The SQL Optimizer needs accurate information to choose a good execution plan.
    After a significant amount of change has been done to a graph, this method should be invoked. Notice that however, statistics collection is a time/resource consuming process, so only run it when necessary.
    See Oracle documentation "PL/SQL Packages and Types Reference" for detailed explanations of the parameters.
    
    Parameters:
    estimatePercent - has a valid range of [0.000001,100].
    methodOpt - A typical value for methodOpt is "FOR ALL COLUMNS SIZE AUTO"
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - analyze
```
public void analyze(float estimatePercent,
           String methodOpt,
           int dop)
             throws SQLException
```
    Collects statistics for this graph. Behind the scenes, Oracle database will invoke DBMS_STATS package and collect statistics for the underlying vertex and edge tables of this graph.
    It is very important that up-to-date statistics be maintained for a graph to ensure efficient execution of query. The SQL Optimizer needs accurate information to choose a good execution plan.
    After a significant amount of change has been done to a graph, this method should be invoked. Notice that however, statistics collection is a time/resource consuming process, so only run it when necessary.
    See Oracle documentation "PL/SQL Packages and Types Reference" for detailed explanations of the parameters.
    
    Parameters:
    estimatePercent - has a valid range of [0.000001,100].
    methodOpt - A typical value for methodOpt is "FOR ALL COLUMNS SIZE AUTO"
    dop - degree of parallelism.
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - analyze
```
public void analyze(int dop)
             throws SQLException
```
    Collects statistics for this graph. Behind the scenes, Oracle database will invoke DBMS_STATS package and collect statistics for the underlying vertex and edge tables of this graph.
    It is very important that up-to-date statistics be maintained for a graph to ensure efficient execution of query. The SQL Optimizer needs accurate information to choose a good execution plan.
    After a significant amount of change has been done to a graph, this method should be invoked. Notice that however, statistics collection is a time/resource consuming process, so only run it when necessary.
    See Oracle documentation "PL/SQL Packages and Types Reference" for detailed explanations of the parameters.
    
    Parameters:
    dop - degree of parallelism.
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - analyzeAuto
```
public void analyzeAuto(int dop)
                 throws SQLException
```
    Collects statistics for this graph. Behind the scenes, Oracle database will invoke DBMS_STATS package and collect statistics for the underlying vertex and edge tables of this graph.
    It is very important that up-to-date statistics be maintained for a graph to ensure efficient execution of query. The SQL Optimizer needs accurate information to choose a good execution plan.
    After a significant amount of change has been done to a graph, this method should be invoked. Notice that however, statistics collection is a time/resource consuming process, so only run it when necessary.
    See Oracle documentation "PL/SQL Packages and Types Reference" for detailed explanations of the parameters.
    
    Parameters:
    dop - degree of parallelism.
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - clearCache
```
public void clearCache()
```
    Clears the internal Vertex and Edge cache.
    
    Specified by:
    
    clearCache in class OraclePropertyGraphBase
  - clearRepository
```
public void clearRepository()
                     throws SQLException
```
    Removes all vertices and edges from this property graph instance. Additionally, all existing index are removed from this property graph instance. A DDL (truncate) is executed so there is no way to rollback.
    
    Specified by:
    
    clearRepository in class OraclePropertyGraphBase
    
    Throws:
    
    SQLException
  - clearUpdateQueue
```
public void clearUpdateQueue()
```
    Clears the update action queue.
  - commit
```
public void commit()
```
    Commit changes done to this property graph instance.
    
    Specified by:
    
    commit in interface TransactionalGraph
  - commit
```
public void commit(boolean bCommitIndices)
```
    Commit changes done to this property graph instance.
  - countEdges
```
public long countEdges(int dop,
              ProgressListener pll)
```
    Counts all edges using parallel scans and the specified DOP.
    
    Specified by:
    
    countEdges in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the edges.
    
    Returns:
    the number of edges in the graph
  - countTriangle
```
public static long countTriangle(Connection conn,
                 String szEdgeTabName,
                 StringBuilder sbUndirWorkTab,
                 int iNumSubPtns,
                 int iDOP,
                 String szTBS,
                 String szOptions)
                          throws SQLException
```
    Returns the number of triangles that exist in this graph. By default, the underlying logic will NOT create an undirected graph before counting the number of triangles. To change that behavior, one can add ",CREATE_UNDIRECTED=T," to the szOptions.
    
    Parameters:
    conn - a JDBC Connection instance
    szEdgeTabName - name of the edge table (or view)
    sbUndirWorkTab - a place holder for the name of the undirected working table to be used for calculating triangles. This argument is relevant when "CREATE_UNDIRECTED=T" option is set.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. Set the value to 1 to avoid using partitioned approach.
    iDOP - degree of parallelism to be used
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countTriangle
```
public long countTriangle(StringBuilder sbUndirWorkTab)
                   throws SQLException
```
    Returns the number of triangles that exist in this graph which is treated as undirected. Note that an undirected graph will be created before counting the number of triangles.
    
    Specified by:
    
    countTriangle in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirWorkTab - a place holder for the name of the undirected working table to be used for calculating triangles.
    
    Throws:
    
    SQLException
  - countTriangle
```
public long countTriangle(StringBuilder sbUndirWorkTab,
                 int iNumSubPtns,
                 int iDOP,
                 String szTBS,
                 String szOptions)
                   throws SQLException
```
    Returns the number of triangles that exist in this graph. By default, the underlying logic will NOT create an undirected graph before counting the number of triangles. To change that behavior, one can add ",CREATE_UNDIRECTED=T," to the szOptions.
    
    Specified by:
    
    countTriangle in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirWorkTab - a place holder for the name of the undirected working table to be used for calculating triangles. This argument is relevant when "CREATE_UNDIRECTED=T" option is set.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. Set the value to 1 to avoid using partitioned approach.
    iDOP - degree of parallelism to be used
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countTriangleCleanup
```
public void countTriangleCleanup(StringBuilder sbUndirBMTab,
                        StringBuilder sbMapWorkTab,
                        StringBuilder sbUndirAMTab,
                        String szOptions)
                          throws SQLException
```
    This method does cleanup work after running triangle calculations. Basically, all intermediate working tables will be truncated and dropped.
    
    Specified by:
    
    countTriangleCleanup in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countTrianglePrep
```
public void countTrianglePrep(StringBuilder sbUndirBMTab,
                     StringBuilder sbMapWorkTab,
                     StringBuilder sbUndirAMTab,
                     String szOptions)
                       throws SQLException
```
    This method does preparation work before running triangle calculations.
    
    Specified by:
    
    countTrianglePrep in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles. The map working table is for renumbering vertices.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countTriangleRenum
```
public static long countTriangleRenum(Connection conn,
                      String szEdgeTabName,
                      StringBuilder sbUndirBMTab,
                      StringBuilder sbMapWorkTab,
                      StringBuilder sbUndirAMTab,
                      int iNumSubPtns,
                      int iDOP,
                      String szTBS,
                      String szOptions)
                               throws SQLException
```
    Returns the number of triangles that exist in this graph (treated as undirected). A re-numbering of vertices will be carried out before the actual work of counting is performed.
    
    Parameters:
    conn - a JDBC connection to Oracle Database
    szEdgeTabName - name of a graph edge table (or view)
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. Set the value to 1 to avoid using partitioned approach.
    iDOP - degree of parallelism to be used for creating a working table holding undirected graph data and for executing triangle counting query.
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countTriangleRenum
```
public long countTriangleRenum(StringBuilder sbUndirBMTab,
                      StringBuilder sbMapWorkTab,
                      StringBuilder sbUndirAMTab,
                      int iNumSubPtns,
                      int iDOP,
                      String szTBS,
                      String szOptions)
                        throws SQLException
```
    Returns the number of triangles that exist in this graph (treated as undirected). A re-numbering of vertices will be carried out before the actual work of counting is performed.
    
    Specified by:
    
    countTriangleRenum in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. Set the value to 1 to avoid using partitioned approach.
    iDOP - degree of parallelism to be used for creating a working table holding undirected graph data and for executing triangle counting query.
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - countVertices
```
public long countVertices(int dop,
                 ProgressListener pll)
```
    Counts all vertices using parallel scan with dop threads
    
    Specified by:
    
    countVertices in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pll - a ProgressListener object.
    
    Returns:
    the number of vertices in the graph
  - createDefaultSpatialIndexOnEdges
```
public void createDefaultSpatialIndexOnEdges(int dop)
                                      throws SQLException
```
    This API creates a default Spatial index on edges. It assumes that the mdsys.opg_apis.get_geometry_from_v_t_cols(v,t) PL/SQL is going to be used to create a function-based Spatial index. In addition, it adds a predefined value into user_sdo_geom_metadata. To customize, please refer to the dev guide for adding a row to user_sdo_geom_metadata and then creating a Spatial index manually. Note that, a DDL will be executed so expect an implict commit. If you have changes that do not want to be persisted, run a rollback before calling this method.
    
    Parameters:
    dop - degree of parallelism used to create the Spatial index
    
    Throws:
    
    SQLException
  - createDefaultSpatialIndexOnEdges
```
public void createDefaultSpatialIndexOnEdges(int dop,
                                    boolean bLocal,
                                    boolean bUseV2)
                                      throws SQLException
```
    This API creates a default Spatial index on edges. It assumes that the mdsys.opg_apis.get_geometry_from_v_t_cols(v,t) PL/SQL is going to be used to create a function-based Spatial index. In addition, it adds a predefined value into user_sdo_geom_metadata. To customize, please refer to the dev guide for adding a row to user_sdo_geom_metadata and then creating a Spatial index manually. Note that, a DDL will be executed so expect an implict commit. If you have changes that do not want to be persisted, run a rollback before calling this method.
    
    Parameters:
    dop - degree of parallelism used to create the Spatial index
    bLocal - creates a local index if true
    bUseV2 - uses MDSYS.SPATIAL_INDEX_V2 as the indextype if true, and uses MDSYS.SPATIAL_INDEX as the indextype if false.
    
    Throws:
    
    SQLException
  - createDefaultSpatialIndexOnVertices
```
public void createDefaultSpatialIndexOnVertices(int dop)
                                         throws SQLException
```
    This API creates a default Spatial index on vertices. It assumes that the mdsys.opg_apis.get_geometry_from_v_t_cols(v,t) PL/SQL is going to be used to create a function-based Spatial index. In addition, it adds a predefined value into user_sdo_geom_metadata. To customize, please refer to the dev guide for adding a row to user_sdo_geom_metadata and then creating a Spatial index manually. Note that, a DDL will be executed so expect an implict commit. If you have changes that do not want to be persisted, run a rollback before calling this method.
    
    Parameters:
    dop - degree of parallelism used to create the Spatial index
    
    Throws:
    
    SQLException
  - createDefaultSpatialIndexOnVertices
```
public void createDefaultSpatialIndexOnVertices(int dop,
                                       boolean bLocal,
                                       boolean bUseV2)
                                         throws SQLException
```
    This API creates a default Spatial index on vertices. It assumes that the mdsys.opg_apis.get_geometry_from_v_t_cols(v,t) PL/SQL is going to be used to create a function-based Spatial index. In addition, it adds a predefined value into user_sdo_geom_metadata. To customize, please refer to the dev guide for adding a row to user_sdo_geom_metadata and then creating a Spatial index manually. Note that, a DDL will be executed so expect an implict commit. If you have changes that do not want to be persisted, run a rollback before calling this method.
    
    Parameters:
    dop - degree of parallelism used to create the Spatial index
    bLocal - creates a local index if true
    bUseV2 - uses MDSYS.SPATIAL_INDEX_V2 as the indextype if true, and uses MDSYS.SPATIAL_INDEX as the indextype if false.
    
    Throws:
    
    SQLException
  - createStatTable
```
public void createStatTable(String statTableName)
                     throws SQLException
```
    Creates a stat table using DBMS_STATS package.
    
    Parameters:
    statTableName - name of the stat table.
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - disable
```
public void disable()
             throws SQLException
```
    Disables the session flash back.
    
    Specified by:
    
    disable in interface OracleChangeTracker
    
    Throws:
    
    SQLException
  - disableEdgeTableConstraints
```
public List<String> disableEdgeTableConstraints()
                                         throws SQLException
```
    Disables all the database constraints of the edge table.
    
    Returns:
    a list of the disabled constraint names. The result list must not be NULL.
    
    Throws:
    
    SQLException
  - disableEdgeTableIndices
```
public List<String> disableEdgeTableIndices()
                                     throws SQLException
```
    Disables all database indices of the edge table.
    
    Returns:
    a list of disabled index names. The result list must not be NULL.
    
    Throws:
    
    SQLException
  - disableVertexTableConstraints
```
public List<String> disableVertexTableConstraints()
                                           throws SQLException
```
    Disables all the database constraints of the vertex table.
    
    Returns:
    a list of the disabled constraint names. The result list must not be NULL.
    
    Throws:
    
    SQLException
  - disableVertexTableIndices
```
public List<String> disableVertexTableIndices()
                                       throws SQLException
```
    Disables all database indices of the vertex table
    
    Returns:
    a list of disabled index names. The result list must not be NULL.
    
    Throws:
    
    SQLException
  - dispose
```
public void dispose()
```
    Closes the graph without commiting any changes
  - doesEdgeExistAt
```
public boolean doesEdgeExistAt(String szEdgeID,
                      Long longEndSCN)
                        throws SQLException
```
    Returns TRUE if the edge identified by the given edge ID exist at SCN denoted by the end scn
    
    Specified by:
    
    doesEdgeExistAt in interface OracleChangeTracker
    
    Parameters:
    szEdgeID - ID of the edge
    longEndSCN - scn
    
    Returns:
    TRUE if the edge identified by the given edge ID exist at SCN denoted by the end SCN
    
    Throws:
    
    SQLException
  - doesEdgeExistAt
```
public boolean doesEdgeExistAt(String szEdgeID,
                      Long longEndSCN,
                      int iQueryDOP)
                        throws SQLException
```
    Returns TRUE if the edge identified by the given edge ID exist at SCN denoted by the end scn
    
    Specified by:
    
    doesEdgeExistAt in interface OracleChangeTracker
    
    Parameters:
    szEdgeID - ID of the edge
    longEndSCN - scn
    iQueryDOP - the degree of parallelism to be used to do the check
    
    Returns:
    TRUE if the edge identified by the given edge ID exist at SCN denoted by the end SCN
    
    Throws:
    
    SQLException
  - doesVertexExistAt
```
public boolean doesVertexExistAt(String szVertexID,
                        Long longEndSCN)
                          throws SQLException
```
    Returns TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end scn
    
    Specified by:
    
    doesVertexExistAt in interface OracleChangeTracker
    
    Parameters:
    szVertexID - ID of the vertex
    longEndSCN - scn
    
    Returns:
    TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end SCN
    
    Throws:
    
    SQLException
  - doesVertexExistAt
```
public boolean doesVertexExistAt(String szVertexID,
                        Long longEndSCN,
                        int iQueryDOP)
                          throws SQLException
```
    Returns TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end scn
    
    Specified by:
    
    doesVertexExistAt in interface OracleChangeTracker
    
    Parameters:
    szVertexID - ID of the vertex
    longEndSCN - scn
    iQueryDOP - the degree of parallelism to be used to do the check
    
    Returns:
    TRUE if the vertex identified by the given vertex ID exist at SCN denoted by the end SCN
    
    Throws:
    
    SQLException
  - dropDefaultSpatialIndexOnEdges
```
public void dropDefaultSpatialIndexOnEdges()
                                    throws SQLException
```
    This API drops the default Spatial index on edges.
    
    Throws:
    
    SQLException
  - dropDefaultSpatialIndexOnVertices
```
public void dropDefaultSpatialIndexOnVertices()
                                       throws SQLException
```
    This API drops the default Spatial index on vertices.
    
    Throws:
    
    SQLException
  - enableAtSCN
```
public void enableAtSCN(Long longSCN)
                 throws SQLException
```
    Sets the session snapshot to the given SCN value
    
    Specified by:
    
    enableAtSCN in interface OracleChangeTracker
    
    Parameters:
    longSCN - SCN of the snapshot
    
    Throws:
    
    SQLException
  - estimateTriangleRenum
```
public static long estimateTriangleRenum(Connection conn,
                         String szEdgeTabName,
                         StringBuilder sbUndirBMTab,
                         StringBuilder sbMapWorkTab,
                         StringBuilder sbUndirAMTab,
                         int iNumSubPtns,
                         int iChunk,
                         int iDOP,
                         String szTBS,
                         String szOptions)
                                  throws SQLException
```
    This method estimates the number of triangles that exist in this graph (treated as undirected). A re-numbering of vertices will be carried out before the actual work of counting is performed.
    
    Parameters:
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. As the number of logical partitions grows, the estimation will become faster (and less precise).
    iChunk - an integer in the range of [0, iNumSubPtns*iNumSubPtns - 1]
    iDOP - degree of parallelism to be used
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - estimateTriangleRenum
```
public long estimateTriangleRenum(StringBuilder sbUndirBMTab,
                         StringBuilder sbMapWorkTab,
                         StringBuilder sbUndirAMTab,
                         int iNumSubPtns,
                         int iChunk,
                         int iDOP,
                         String szTBS,
                         String szOptions)
                           throws SQLException
```
    This method estimates the number of triangles that exist in this graph (treated as undirected). A re-numbering of vertices will be carried out before the actual work of counting is performed.
    
    Specified by:
    
    estimateTriangleRenum in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbUndirBMTab - a place holder for the name of the undirected working table (before mapping) to be used for calculating triangles.
    sbMapWorkTab - a place holder for the name of the map working table to be used for calculating triangles.
    sbUndirAMTab - a place holder for the name of the undirected working table (after mapping) to be used for calculating triangles.
    iNumSubPtns - has to be a positive integer and has to be power of two. This value represents the number of logical partitions chosen to do the calculation. As the number of logical partitions grows, the estimation will become faster (and less precise).
    iChunk - an integer in the range of [0, iNumSubPtns*iNumSubPtns - 1]
    iDOP - degree of parallelism to be used
    szTBS - tablespace. It can be NULL.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - expEdgeStat
```
public void expEdgeStat(String statTableName,
               String statid)
                 throws SQLException
```
    Exports the edge table statistics into the given stat table.
    
    Parameters:
    statTableName - name of the stat table.
    statid - identifier of statistics
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - expVertexStat
```
public void expVertexStat(String statTableName,
                 String statid)
                   throws SQLException
```
    Exports the vertex table statistics into the given stat table.
    
    Parameters:
    statTableName - name of the stat table.
    statid - identifier of statistics
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - findCluster
```
public static void findCluster(Connection conn,
               String szEdgeTabName,
               StringBuilder sbClusters,
               StringBuilder sbUndir,
               StringBuilder sbCluas,
               StringBuilder sbNewas,
               StringBuilder sbDelta,
               int iDOP,
               String szTBS,
               String szOptions)
                        throws SQLException
```
    This method finds clusters in a given graph (treated as undirected).
    
    Parameters:
    conn - a JDBC connection to Oracle Database
    szEdgeTabName - name of the edge table (or view). Note that one can create a view on top of existing edge table to filter out unwanted edges.
    sbClusters - a place holder for the name of the output table that holds cluster assignment for vertices
    sbUndir - a place holder for the name of the working table that holds undirected graph
    sbCluas - a place holder for the name of the working table that holds intermediate cluster assignment
    sbNewas - a place holder for the name of the working table that holds updated cluster assignment
    sbDelta - a place holder for the name of the working table that holds delta information
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - findCluster
```
public void findCluster(StringBuilder sbClusters,
               StringBuilder sbUndir,
               StringBuilder sbCluas,
               StringBuilder sbNewas,
               StringBuilder sbDelta,
               int iDOP,
               String szTBS,
               String szOptions)
                 throws SQLException
```
    This method finds clusters in this property graph (treated as undirected).
    
    Specified by:
    
    findCluster in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbClusters - a place holder for the name of the output table that holds cluster assignment for vertices
    sbUndir - a place holder for the name of the working table that holds undirected graph
    sbCluas - a place holder for the name of the working table that holds intermediate cluster assignment
    sbNewas - a place holder for the name of the working table that holds updated cluster assignment
    sbDelta - a place holder for the name of the working table that holds delta information
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - findClusterCleanup
```
public void findClusterCleanup(StringBuilder sbClusters,
                      StringBuilder sbUndir,
                      StringBuilder sbCluas,
                      StringBuilder sbNewas,
                      StringBuilder sbDelta,
                      String szOptions)
                        throws SQLException
```
    This method does cleanup work after running graph cluster detection. All the tables that hold intermediate data and the output cluster assignment will be dropped.
    
    Specified by:
    
    findClusterCleanup in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbClusters - a place holder for the name of the output table that holds cluster assignment for vertices
    sbUndir - a place holder for the name of the working table that holds undirected graph
    sbCluas - a place holder for the name of the working table that holds intermediate cluster assignment
    sbNewas - a place holder for the name of the working table that holds updated cluster assignment
    sbDelta - a place holder for the name of the working table that holds delta information
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - findClusterPrep
```
public void findClusterPrep(StringBuilder sbClusters,
                   StringBuilder sbUndir,
                   StringBuilder sbCluas,
                   StringBuilder sbNewas,
                   StringBuilder sbDelta,
                   String szOptions)
                     throws SQLException
```
    This method does preparation work before running graph cluster detection.
    
    Specified by:
    
    findClusterPrep in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbClusters - a place holder for the name of the output table that holds cluster assignment for vertices
    sbUndir - a place holder for the name of the working table that holds undirected graph
    sbCluas - a place holder for the name of the working table that holds intermediate cluster assignment
    sbNewas - a place holder for the name of the working table that holds updated cluster assignment
    sbDelta - a place holder for the name of the working table that holds delta information
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - getConstraintNames
```
public LinkedList<String> getConstraintNames(String szTabName)
                                      throws SQLException
```
    Gets a List of all the database constraints associated to the given table.
    
    Parameters:
    szTabName - the name of the table
    
    Returns:
    a List with the names of the constraints associated to the given table
    
    Throws:
    
    SQLException
  - getCurrentSCN
```
public Long getCurrentSCN()
                   throws SQLException
```
    Returns the current SCN by invoking DBMS FLASHBACK API.
    
    Specified by:
    
    getCurrentSCN in interface OracleChangeTracker
    
    Throws:
    
    SQLException
  - getCurrentSCNUnsafe
```
public Long getCurrentSCNUnsafe()
                         throws SQLException
```
    Returns the current SCN by invoking DBMS FLASHBACK API. It is "unsafe" because the SCN returned may cause ORA-01466.
    
    Throws:
    
    SQLException
  - getDatatypeClassFromValueObjForTextIndex
```
public Class getDatatypeClassFromValueObjForTextIndex(Object value)
```
    Gets the datatype class from the given value object used when executing a query over a text index
    
    Overrides:
    
    getDatatypeClassFromValueObjForTextIndex in class OraclePropertyGraphBase
  - getDefaultDOPPerPtn
```
public int getDefaultDOPPerPtn()
```
    Returns the default DOP used for partition-wise scan
  - getEdge
```
public OracleEdge getEdge(Object id)
```
    Returns the edge referenced by the object identifier.
    
    Specified by:
    
    getEdge in interface Graph
    
    Specified by:
    
    getEdge in class OraclePropertyGraphBase
    
    Parameters:
    id - the object identifier of the referenced edge
    
    Returns:
    an OracleEdge object
  - getEdgeChanges
```
public Iterator<EdgeChange> getEdgeChanges(Long longStartSCN,
                                  Long longEndSCN)
                                    throws SQLException
```
    Returns the changes between the given start SCN and end SCN.
    
    Specified by:
    
    getEdgeChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    
    Throws:
    
    SQLException
  - getEdgeChanges
```
public Iterator<EdgeChange> getEdgeChanges(Long longStartSCN,
                                  Long longEndSCN,
                                  int iQueryDOP)
                                    throws SQLException
```
    Returns the edge changes between the given start SCN and end SCN.
    
    Specified by:
    
    getEdgeChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    
    Throws:
    
    SQLException
  - getEdgeChanges
```
public Iterator<EdgeChange> getEdgeChanges(Long longStartSCN,
                                  Long longEndSCN,
                                  int iQueryDOP,
                                  boolean bFilterOutRemovedInserts)
                                    throws SQLException
```
    Returns the edge changes between the given start SCN and end SCN.
    
    Specified by:
    
    getEdgeChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    bFilterOutRemovedInserts - if an insert has already been removed by the end of time period, then do not include it in the iterator.
    
    Throws:
    
    SQLException
  - getEdgeChanges
```
public Iterator<EdgeChange> getEdgeChanges(Long longStartSCN,
                                  Long longEndSCN,
                                  int iQueryDOP,
                                  boolean bFilterOutRemovedInserts,
                                  String[] keys)
                                    throws SQLException
```
    Returns the edge changes between the given start SCN and end SCN.
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    bFilterOutRemovedInserts - if an insert has already been removed by the end of time period, then do not include it in the iterator.
    
    Throws:
    
    SQLException
  - getEdgeInstance
```
public OracleEdgeBase getEdgeInstance(Long eid,
                             boolean bCreateIfAbsentFromCache,
                             boolean bSkipStoreToCache)
```
    Returns an instance of OracleEdgeBase. If there is no match in the cache and bCreateIfAbsentFromCache is false, then a NULL value will be returned. If the skipStoreToCache is true, then the vertex will not be stored into the cache.
    
    Specified by:
    
    getEdgeInstance in class OraclePropertyGraphBase
    
    Parameters:
    eid - the id of the edge
    bCreateIfAbsentFromCache - if false, returns a NULL value if there is no match in the cache.
    bSkipStoreToCache - if true, the vertex instance will not be stored into the cache.
    
    Returns:
    a OracleEdgeBase object.
  - getEdgeInstance
```
public OracleEdgeBase getEdgeInstance(OracleVertexBase outVertex,
                             OracleVertexBase inVertex,
                             String edgeLabel,
                             Long eid,
                             boolean bCreateIfAbsentFromCache,
                             boolean bSkipStoreToCache)
```
    Returns an instance of OracleEdgeBase. If there is no match in the cache and bCreateIfAbsentFromCache is false, then a NULL value will be returned. If the skipStoreToCache is true, then the vertex will not be stored into the cache.
    
    Specified by:
    
    getEdgeInstance in class OraclePropertyGraphBase
    
    Parameters:
    eid - the id of the edge
    outVertex - the outgoing Vertex of the edge
    inVertex - the incoming Vertex of the edge
    edgeLabel - the label for the Edge.
    bCreateIfAbsentFromCache - if false, returns a NULL value if there is no match in the cache.
    bSkipStoreToCache - if true, the vertex instance will not be stored into the cache.
    
    Returns:
    a OracleEdgeBase object.
  - getEdgePartitionsNumber
```
public int getEdgePartitionsNumber()
                            throws SQLException
```
    Returns the number of HASH partitions of the edge table. If the underlying table is not a physical table but a view, then return 1.
    
    Throws:
    
    SQLException
  - getEdgePropertyNames
```
public int getEdgePropertyNames(int dop,
                       int timeout,
                       Set<String> propertyNames,
                       ProgressListener pl)
```
    Gets the property names of all edges using parallel scans and the specified DOP.
    
    Specified by:
    
    getEdgePropertyNames in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the edges
    timeout - time out in the unit of seconds
    propertyNames - a set of property names to be returned
    pl - a ProgressListener object.
  - getEdges
```
public Iterable<Edge> getEdges()
```
    Returns an iterable to all the edges in the graph.
    
    Specified by:
    
    getEdges in interface Graph
    
    Overrides:
    
    getEdges in class OraclePropertyGraphBase
  - getEdges
```
public Iterable<Edge> getEdges(boolean bOrderBySVID)
```
    Returns an iterable to all the edges in the graph.
    
    Parameters:
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
  - getEdges
```
public Iterable<Edge> getEdges(boolean bOrderBySVID,
                      Long longEndSCN)
```
    Returns an iterable to all the edges in the graph from the given SCN.
    
    Parameters:
    longEndSCN - the end SCN to read edges from
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
  - getEdges
```
public Iterable<Edge> getEdges(boolean bOrderBySVID,
                      Long longEndSCN,
                      String[] keys,
                      EdgeFilterCallback efc,
                      OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an Iterable to all the edges in the graph that have any of the specified keys and satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified.
    
    Parameters:
    keys - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the edge filter callback will be returned.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    efc - a EdgeFilterCallback object specifying the conditions to keep a edge in the Iterable.
    flag - an OptimizationFlag object specifying if a partial or complete edge object will be returned. It can be NULL which implies the edges created must be complete.
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray)
```
    Returns an array of iterables to all the edges in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray,
                        boolean bOrderBySVID)
```
    Returns an array of iterables to all the edges in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray,
                        boolean bOrderBySVID,
                        Long longEndSCN)
```
    Returns an array of iterables to all the edges in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray,
                        boolean bOrderBySVID,
                        Long longEndSCN,
                        boolean bSkipStoreToCache,
                        int iStartPartitionID)
```
    Returns an array of iterables to all the edges in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray,
                        boolean bOrderBySVID,
                        Long longEndSCN,
                        boolean bSkipStoreToCache,
                        int iStartPartitionID,
                        String key)
```
    Returns an array of iterables to all the edges in the graph that have a particular key. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    key - name of the property. It can be NULL which implies all edges in the graph will be returned.
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
  - getEdges
```
public Iterable<Edge>[] getEdges(Connection[] connArray,
                        boolean bOrderBySVID,
                        Long longEndSCN,
                        boolean bSkipStoreToCache,
                        int iStartPartitionID,
                        String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdges
```
public Iterable<Edge> getEdges(Long longEndSCN)
```
    Returns an iterable to all the edges in the graph from the given SCN.
    
    Parameters:
    longEndSCN - the end SCN to read edges from
  - getEdges
```
public Iterable<Edge> getEdges(ResultSet rs,
                      EdgeFilterCallback efc,
                      OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an Iterable to all the edges from the ResultSet that satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified.
    
    Parameters:
    rs - the resultset where the edges will be read from.
    efc - a EdgeFilterCallback object specifying the conditions to keep a edge in the Iterable.
    flag - an OptimizationFlag object specifying if a partial or complete edge object will be returned. It can be NULLl which implies the edges created must be complete.
  - getEdges
```
public Iterable<Edge> getEdges(String[] keys,
                      EdgeFilterCallback efc,
                      OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an Iterable to all the edges in the graph that have any of the specified keys and satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified.
    
    Specified by:
    
    getEdges in class OraclePropertyGraphBase
    
    Parameters:
    keys - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the edge filter callback will be returned.
    efc - a EdgeFilterCallback object specifying the conditions to keep a edge in the Iterable.
    flag - an OptimizationFlag object specifying if a partial or complete edge object will be returned. It can be NULL which implies the edges created must be complete.
  - getEdges
```
public Iterable<Edge> getEdges(String key,
                      Object value,
                      Class dtClass,
                      boolean acceptWildcard,
                      boolean useLuceneSyntax)
```
    Return an iterable to all matching edges that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching edges.
    
    Specified by:
    
    getEdges in class OraclePropertyGraphBase
    
    Parameters:
    key - the name of the property. It MUST not be NULL.
    value - the value of the property. It can be NULL which will cause all edges with the given key to be returned.
    dtClass - the class representing the datatype of the property value. This can be used to cast the property value to a different datatype. For example, if the value is "3.01" and dtClass is Float.Class, then this value will be treated as a 3.01f. If dtClass is set to NULL, then the query will be executed by trying to match the value object to all the supported datatypes.
    acceptWildcard - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.
    useLuceneSyntax - specifies if the value object is using an Apache Lucene Syntax (further details on Apache Lucene Syntax can be found in https://lucene.apache.org/core/2_9_4/queryparsersyntax.html). If the automatic index is not enabled ahd this flag is set to true, an Exception will be thrown as Lucene Syntax is not supported for database lookups.
  - getEdgesNonPartitioned
```
public Iterable<Edge>[] getEdgesNonPartitioned(Connection[] connArray,
                                      boolean bOrderBySVID,
                                      Long longEndSCN,
                                      boolean bSkipStoreToCache,
                                      String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdgesNonPartitioned
```
public Iterable<Edge>[] getEdgesNonPartitioned(Connection[] connArray,
                                      boolean bOrderBySVID,
                                      Long longEndSCN,
                                      String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean skipStoreToCache,
                                   int startPartitionID)
```
    Returns an array of iterables to all the edges in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    skipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean bSkipStoreToCache,
                                   int startPartitionID,
                                   EdgeFilterCallback efc,
                                   OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the edges in the graph that satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    efc - an EdgeFilterCallback object.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean skipStoreToCache,
                                   int startPartitionID,
                                   String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    skipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean bOrderBySVID,
                                   Long longEndSCN,
                                   boolean bSkipStoreToCache,
                                   int iStartPartitionID,
                                   String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean bOrderBySVID,
                                   Long longEndSCN,
                                   boolean bSkipStoreToCache,
                                   int iStartPartitionID,
                                   String[] keys,
                                   EdgeFilterCallback efc,
                                   OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the edges in the graph that satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    efc - an EdgeFilterCallback object.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(Connection[] connArray,
                                   boolean bOrderBySVID,
                                   Long longEndSCN,
                                   String[] keys)
```
    Returns an array of iterables to all the edges in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the edge table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bOrderBySVID - if true, the iterator will be further ordered by the SVID column value.
    longEndSCN - the end SCN to read edges from
    keys - an array of property key names. It can be NULL which implies all edges in the graph will be returned.
  - getEdgesPartitioned
```
public Iterable<Edge>[] getEdgesPartitioned(ResultSet[] rsArray,
                                   boolean bSkipStoreToCache,
                                   EdgeFilterCallback efc,
                                   OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the edges from the given array of ResultSet objects that satisfy the specified edge filter callback. The information read back from the edges will be complete or partial based on the optimization flag specified.
    
    Parameters:
    rsArray - a ResultSet array
    bSkipStoreToCache - if true, the edge instances retrieved by the scan will not be saved into cache
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    efc - an EdgeFilterCallback object.
  - getEdgeTabIdxName
```
public String getEdgeTabIdxName(String szCode)
```
    Returns the name of an index of the edge table for the specified code
    
    Parameters:
    szCode - the index code name
    
    Returns:
    the name of the index
  - getEdgeTabName
```
public String getEdgeTabName()
```
    Returns the name of the edge table
  - getFeatures
```
public Features getFeatures()
```
    Gets the particular features of the graph implementation.
    
    Specified by:
    
    getFeatures in interface Graph
  - getGraphName
```
public String getGraphName()
```
    Returns the name of this property graph instance
    
    Overrides:
    
    getGraphName in class OraclePropertyGraphBase
  - getGraphOwner
```
public String getGraphOwner()
```
    Returns the owner name of the graph.
  - getIndexNames
```
public LinkedList<String> getIndexNames(String szTabName)
                                 throws SQLException
```
    Gets a List of all the database indexes associated to the given table.
    
    Parameters:
    szTabName - the name of the table
    
    Returns:
    a List with the names of the indexes associated to the given table
    
    Throws:
    
    SQLException
  - getIndexParameters
```
public final <T extends Element> OracleIndexParameters getIndexParameters(String indexName,
                                                           Class<T> indexClass)
```
    Gets the index parameters associated to the given text index.
    
    Overrides:
    
    getIndexParameters in class OraclePropertyGraphBase
    
    Parameters:
    indexName - the name of the manual index to retrieve.
    indexClass - the element class that the index is for.
    
    Returns:
    a OracleIndexParameters object.
  - getInstance
```
public static OraclePropertyGraph getInstance(Oracle oracle,
                              String szGraphName)
                                       throws SQLException
```
    Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    
    Parameters:
    oracle - an Oracle object
    szGraphName - the name of the graph
    
    Throws:
    
    SQLException
  - getInstance
```
public static OraclePropertyGraph getInstance(Oracle oracle,
                              String szGraphName,
                              int iHashPartitionsNum)
                                       throws SQLException
```
    Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    
    Parameters:
    oracle - an Oracle object
    szGraphName - the name of the graph
    iHashPartitionsNum - number of hash partitions to be used.
    
    Throws:
    
    SQLException
  - getInstance
```
public static OraclePropertyGraph getInstance(Oracle oracle,
                              String szGraphName,
                              int iHashPartitionsNum,
                              int iDOP,
                              String szTBS,
                              String szOptions)
                                       throws SQLException
```
    Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    
    Parameters:
    oracle - an Oracle object
    szGraphName - the name of the graph
    iHashPartitionsNum - number of hash partitions to be used.
    iDOP - degree of parallelism to be used for creating the underlying tables and indices.
    szTBS - the tablespace name where the property graph tables will be created.
    szOptions - options to be passed on to the underlying OPG_APIS.CREATE_PG API. It can be NULL.
    
    Throws:
    
    SQLException
  - getInstance
```
public static OraclePropertyGraph getInstance(Oracle oracle,
                              String szGraphOwner,
                              String szGraphName,
                              int iHashPartitionsNum,
                              int iDOP,
                              String szTBS,
                              String szOptions)
                                       throws SQLException
```
    Returns an instance of OraclePropertyGraph using the Oracle connection and graph name provided.
    
    Parameters:
    oracle - an Oracle object
    szGraphName - the name of the graph
    szGraphOwner - owner of the graph. This may be different from the login schema.
    iHashPartitionsNum - number of hash partitions to be used.
    iDOP - degree of parallelism to be used for creating the underlying tables and indices.
    szTBS - the tablespace name where the property graph tables will be created.
    szOptions - options to be passed on to the underlying OPG_APIS.CREATE_PG API. It can be NULL.
    
    Throws:
    
    SQLException
  - getInstance
```
public static OraclePropertyGraph getInstance(oracle.pgx.config.PgRdbmsGraphConfig config)
                                       throws SQLException
```
    Gets an OraclePropertyGraph instance from a PGX PgRdbmsGraphConfig object
    
    Parameters:
    config - the PGX graph config object
    
    Returns:
    an OraclePropertyGraph object
    
    Throws:
    
    SQLException
  - getInvalidEdgeIDSet
```
public Set<Long> getInvalidEdgeIDSet(int dop,
                            ProgressListener pl)
```
    Gets a set of invalid edges that are stored in the property graph. An invalid edge is an edge whose IN or OUT vertex does not exist in the property graph
    
    Specified by:
    
    getInvalidEdgeIDSet in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices and edges.
    pl - a ProgressListener object.
  - getMaxEdgeID
```
public long getMaxEdgeID(int dop,
                ProgressListener pl)
```
    Get the maximum edge ID using parallel scan and the specified DOP.
    
    Specified by:
    
    getMaxEdgeID in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pl - a ProgressListener object.
    
    Returns:
    maximum edge ID in the graph
  - getMaxVertexID
```
public long getMaxVertexID(int dop,
                  ProgressListener pl)
```
    Get maximum vertex ID using parallel scans and the specified DOP.
    
    Specified by:
    
    getMaxVertexID in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pl - a ProgressListener object.
    
    Returns:
    maximum vertex ID in the graph
  - getMinEdgeID
```
public long getMinEdgeID(int dop,
                ProgressListener pl)
```
    Get the minimum edge ID using parallel scan with dop threads
    
    Specified by:
    
    getMinEdgeID in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pl - a ProgressListener object.
    
    Returns:
    minimum edge ID in the graph
  - getMinVertexID
```
public long getMinVertexID(int dop,
                  ProgressListener pl)
```
    Get minimum vertex ID using parallel scans and the specified DOP.
    
    Specified by:
    
    getMinVertexID in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pl - a ProgressListener object.
    
    Returns:
    minimum vertex ID in the graph
  - getNumberToCharSqlFormatString
```
public String getNumberToCharSqlFormatString()
```
    Gets the Char SQL Format used to format a number into a string
  - getOperationQueueSize
```
public long getOperationQueueSize()
```
    Get the size of the operation queue
  - getOracle
```
public Oracle getOracle()
```
    Returns the underlying Oracle instance associated with the property graph instance
  - getOracle
```
public static Oracle getOracle(oracle.pgx.config.PgRdbmsGraphConfig config)
                        throws SQLException
```
    Gets an Oracle object from a PGX PgRdbmsGraphConfig object
    
    Parameters:
    config - the PGX graph config object
    
    Returns:
    the Oracle object
    
    Throws:
    
    SQLException
  - getOracleIndexManager
```
public OracleIndexManager getOracleIndexManager()
```
    Gets the Oracle Index Manager associated to this property graph instance.
    
    Specified by:
    
    getOracleIndexManager in class OraclePropertyGraphBase
    
    Returns:
    a OracleIndexManager object.
  - getPGViewOnRDFFlag
```
public boolean getPGViewOnRDFFlag()
```
    Validates if this property graph instance comes from a Property Graph view over RDF data
    
    Returns:
    true if this property graph instance comes from a Property Graph view over RDF data
  - getQueryFetchSize
```
public int getQueryFetchSize()
```
    Returns the query fetch size when scanning the vertex and edge tables
  - getRemovedEdges
```
public Iterator<Long> getRemovedEdges(Long longStartSCN,
                             Long longEndSCN,
                             int iQueryDOP,
                             String szOptions)
                               throws SQLException
```
    Returns an ordered iterator of IDs of Edges that involved in DELETE operations happened between the two given SCNs. The DELETE operations can be initiated from REST interfaces, Blueprints APIs, or SQL layer. Note that this output contains only IDs of Edges that no longer exist at the end of the SCN range.
    
    Specified by:
    
    getRemovedEdges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN
    longEndSCN - end SCN
    iQueryDOP - degree of parallelism to be used for the underlying query
    szOptions - hints for the underlying query.
    
    Throws:
    
    SQLException
  - getRemovedVertices
```
public Iterator<Long> getRemovedVertices(Long longStartSCN,
                                Long longEndSCN,
                                int iQueryDOP,
                                String szOptions)
                                  throws SQLException
```
    Returns an ordered iterator of IDs of Vertices that involved in DELETE operations happened between the two given SCNs. The DELETE operations can be initiated from REST interfaces, Blueprints APIs, or SQL layer. Note that this output contains only IDs of Vertices that no longer exist at the end of the SCN range.
    
    Specified by:
    
    getRemovedVertices in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN
    longEndSCN - end SCN
    iQueryDOP - degree of parallelism to be used for the underlying query
    szOptions - hints for the underlying query.
    
    Throws:
    
    SQLException
  - getRowPrefetch
```
public int getRowPrefetch()
```
    Returns the number of rows to prefetch when executing a SQL query over the Property graph data tables
  - getSessionID
```
public String getSessionID()
                    throws SQLException
```
    Returns the current database Session ID
    
    Throws:
    
    SQLException
  - getSessionQueryDOP
```
public int getSessionQueryDOP()
```
    Returns the degree of parallel query execution at the session level.
  - getSkeletonTabIdxName
```
public String getSkeletonTabIdxName(String szCode)
```
    Returns the name of an index of the graph GT table for the specified code
    
    Parameters:
    szCode - the index code name
    
    Returns:
    the name of the index
  - getSkeletonTabName
```
public String getSkeletonTabName()
```
    Returns the name of the graph skeleton table
  - getSnapshotTabName
```
public String getSnapshotTabName()
```
    Returns the name of the PGX snapshot table
  - getTextIndexDirectoryPrefix
```
public String getTextIndexDirectoryPrefix()
```
    Returns the name of this property graph instance
    
    Overrides:
    
    getTextIndexDirectoryPrefix in class OraclePropertyGraphBase
  - getTextIndexTabName
```
public String getTextIndexTabName()
```
    Returns the name of the index metadata table
  - getTimeToCharSqlFormatString
```
public String getTimeToCharSqlFormatString()
```
    Gets the Char SQL Format used to format a datetime into a string
  - getTopK
```
public static ResultSet getTopK(Connection conn,
                StringBuilder sbTabName,
                int iColIdx,
                OraclePropertyGraph.Sort sort,
                int k,
                int iDOP)
                         throws SQLException
```
    Returns the top K rows of a given table. Note that the result will include an additional column "ROW_COUNT" that can be used for index purpose. This column can be safely ignored. As a contract, the caller of this API needs to close the result set and its associated JDBC statement after consumption.
    
    Parameters:
    conn - a JDBC connection to Oracle Database
    sbTabName - a place holder for the table name
    iColIdx - the column to be sorted
    sort - ASC or DESC
    k - k rows to be returned. Note that it is an upper bound
    iDOP - degree of parallelism to be used
    
    Returns:
    a JDBC result set.
    
    Throws:
    
    SQLException
  - getTopK
```
public ResultSet getTopK(StringBuilder sbTabName,
                int iColIdx,
                OraclePropertyGraph.Sort sort,
                int k)
                  throws SQLException
```
    Returns the top K rows of a given table. Note that the result will include an additional column "ROW_COUNT" that can be used for index purpose. This column can be safely ignored.
    
    Parameters:
    sbTabName - a place holder for the table name
    iColIdx - the column to be sorted
    sort - ASC or DESC
    k - k rows to be returned. Note that it is an upper bound
    
    Returns:
    a JDBC result set. Note that the query will be executed with a DOP of getSessionQueryDOP.
    
    Throws:
    
    SQLException
  - getTopK
```
public ResultSet getTopK(StringBuilder sbTabName,
                int iColIdx,
                OraclePropertyGraph.Sort sort,
                int k,
                int iDOP)
                  throws SQLException
```
    Returns the top K rows of a given table. Note that the result will include an additional column "ROW_COUNT" that can be used for index purpose. This column can be safely ignored.
    
    Parameters:
    sbTabName - a place holder for the table name
    iColIdx - the column to be sorted
    sort - ASC or DESC
    k - k rows to be returned. Note that it is an upper bound
    iDOP - degree of parallelism to be used
    
    Returns:
    a JDBC result set.
    
    Throws:
    
    SQLException
  - getVertex
```
public OracleVertex getVertex(Object id)
```
    Returns the vertex referenced by the object identifier.
    
    Specified by:
    
    getVertex in interface Graph
    
    Specified by:
    
    getVertex in class OraclePropertyGraphBase
    
    Parameters:
    id - the object identifier of the referenced vertex
    
    Returns:
    an Vertex object
  - getVertexChanges
```
public Iterator<VertexChange> getVertexChanges(Long longStartSCN,
                                      Long longEndSCN)
                                        throws SQLException
```
    Returns the changes between the given start SCN and end SCN.
    
    Specified by:
    
    getVertexChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    
    Throws:
    
    SQLException
  - getVertexChanges
```
public Iterator<VertexChange> getVertexChanges(Long longStartSCN,
                                      Long longEndSCN,
                                      int iQueryDOP)
                                        throws SQLException
```
    Returns the vertex changes between the given start SCN and end SCN using the given query degree of parallelism.
    
    Specified by:
    
    getVertexChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    
    Throws:
    
    SQLException
  - getVertexChanges
```
public Iterator<VertexChange> getVertexChanges(Long longStartSCN,
                                      Long longEndSCN,
                                      int iQueryDOP,
                                      boolean bFilterOutRemovedInserts)
                                        throws SQLException
```
    Returns the vertex changes between the given start SCN and end SCN.
    
    Specified by:
    
    getVertexChanges in interface OracleChangeTracker
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    bFilterOutRemovedInserts - if an insert has already been removed by the end of time period, then do not include it in the iterator.
    
    Throws:
    
    SQLException
  - getVertexChanges
```
public Iterator<VertexChange> getVertexChanges(Long longStartSCN,
                                      Long longEndSCN,
                                      int iQueryDOP,
                                      boolean bFilterOutRemovedInserts,
                                      String[] keys)
                                        throws SQLException
```
    Returns the vertex changes between the given start SCN and end SCN.
    
    Parameters:
    longStartSCN - start SCN value. A NULL value will be treated as MINVALUE to the underlying Oracle Database.
    longEndSCN - end SCN value. A NULL value will be treated as MAXVALUE to the underlying Oracle Database.
    iQueryDOP - the degree of parallelism to be used to identify changes.
    bFilterOutRemovedInserts - if an insert has already been removed by the end of time period, then do not include it in the iterator.
    keys - an array of property key names. It can be NULL which implies all vertices changes will be returned.
    
    Throws:
    
    SQLException
  - getVertexIDSet
```
public Set<Long> getVertexIDSet(int dop,
                       ProgressListener pl)
```
    Gets a set of Vertex IDs that are stored in the property graph
    
    Specified by:
    
    getVertexIDSet in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices.
    pl - a ProgressListener object.
  - getVertexInstance
```
public OracleVertexBase getVertexInstance(Long vid,
                                 boolean bCreateIfAbsentFromCache,
                                 boolean bSkipStoreToCache)
```
    Returns an instance of OracleVertexBase. If there is no match in the cache and bCreateIfAbsentFromCache is false, then a NULL value will be returned. If the skipStoreToCache is true, then the vertex will not be stored into the cache.
    
    Specified by:
    
    getVertexInstance in class OraclePropertyGraphBase
    
    Parameters:
    vid - the id of the vertex
    bCreateIfAbsentFromCache - if false, returns a NULL value if there is no match in the cache.
    bSkipStoreToCache - if true, the vertex instance will not be stored into the cache.
    
    Returns:
    a OracleVertexBase object.
  - getVertexPartitionsNumber
```
public int getVertexPartitionsNumber()
                              throws SQLException
```
    Returns the number of HASH partitions of the vertex table. If the underlying table is not a physical table but a view, then return 1.
    
    Throws:
    
    SQLException
  - getVertexPropertyNames
```
public int getVertexPropertyNames(int dop,
                         int timeout,
                         Set<String> propertyNames,
                         ProgressListener pl)
```
    Gets the property names of all vertices using parallel scans and the specified DOP.
    
    Specified by:
    
    getVertexPropertyNames in class OraclePropertyGraphBase
    
    Parameters:
    dop - a positive integer defining the number of threads to use when parallel scanning the vertices
    timeout - time out in the unit of seconds
    propertyNames - a set of property names to be returned
    pl - a ProgressListener object.
  - getVertexTabIdxName
```
public String getVertexTabIdxName(String szCode)
```
    Returns the name of an index of the vertex table for the specified code
    
    Parameters:
    szCode - the index code name
    
    Returns:
    the name of the index
  - getVertexTabName
```
public String getVertexTabName()
```
    Returns the name of the vertex table
  - getVertices
```
public Iterable<Vertex> getVertices()
```
    Returns an iterable to all the vertices in the graph.
    
    Specified by:
    
    getVertices in interface Graph
    
    Overrides:
    
    getVertices in class OraclePropertyGraphBase
  - getVertices
```
public Iterable<Vertex>[] getVertices(Connection[] connArray)
```
    Returns an array of iterables to all the vertices in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
  - getVertices
```
public Iterable<Vertex>[] getVertices(Connection[] connArray,
                             Long longEndSCN)
```
    Returns an array of iterables to all the vertices in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
  - getVertices
```
public Iterable<Vertex>[] getVertices(Connection[] connArray,
                             Long longEndSCN,
                             boolean bSkipStoreToCache,
                             int iStartPartitionID)
```
    Returns an array of iterables to all the vertices in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
  - getVertices
```
public Iterable<Vertex>[] getVertices(Connection[] connArray,
                             Long longEndSCN,
                             boolean bSkipStoreToCache,
                             int iStartPartitionID,
                             String key)
```
    Returns an array of iterables to all the vertices in the graph that have a particular key. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    key - name of the property. It can be NULL which implies all edges in the graph will be returned.
  - getVertices
```
public Iterable<Vertex>[] getVertices(Connection[] connArray,
                             Long longEndSCN,
                             boolean bSkipStoreToCache,
                             int iStartPartitionID,
                             String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVertices
```
public Iterable<Vertex> getVertices(Long longEndSCN,
                           String[] keys,
                           VertexFilterCallback vfc,
                           OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an Iterable to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback. The information read back from the vertices will be complete or partial based on the optimization flag specified.
    
    Parameters:
    keys - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the vertex filter callback will be returned.
    vfc - a VertexFilterCallback object specifying the conditions to keep a vertex in the Iterable.
    longEndSCN - the end SCN to read vertices from
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
  - getVertices
```
public Iterable<Vertex> getVertices(ResultSet rs,
                           VertexFilterCallback vfc,
                           OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an iterable to all the relevant vertices in the graph.
    
    Parameters:
    rs - an result set for matching vertices
    vfc - an optional VertexFilterCallback object
    flag - an optional OptimizationFlag object to reduce object size
  - getVertices
```
public Iterable<Vertex> getVertices(String[] keys,
                           VertexFilterCallback vfc,
                           OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an Iterable to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback. The information read back from the vertices will be complete or partial based on the optimization flag specified.
    
    Specified by:
    
    getVertices in class OraclePropertyGraphBase
    
    Parameters:
    keys - an array of property key names. It can be NULL which implies all vertices in the graph satisfying the vertex filter callback will be returned.
    vfc - a VertexFilterCallback object specifying the conditions to keep a vertex in the Iterable.
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
  - getVertices
```
public Iterable<Vertex> getVertices(String key,
                           Object value,
                           Class dtClass,
                           boolean acceptWildcard,
                           boolean useLuceneSyntax)
```
    Return an iterable to all matching vertices that have a particular key/value property. When an automatic text index on the given key is absent, a full table scan will be carried out to find matching vertices.
    
    Specified by:
    
    getVertices in class OraclePropertyGraphBase
    
    Parameters:
    key - the name of the property. It MUST not be NULL.
    value - the value of the property. It can be NULL which will cause all vertices with the given key to be returned.
    dtClass - the class representing the datatype of the property value. This can be used to cast the property value to a different datatype. For example, if the value is "3.01" and dtClass is Float.Class, then this value will be treated as a 3.01f. If dtClass is set to NULL, then the query will be executed by trying to match the value object to all the supported datatypes.
    acceptWildcard - specifies if wild cards can be used in the value object. Wild cards can be used only when an automatic text index on the given key is present.
    useLuceneSyntax - specifies if the value object is using an Apache Lucene Syntax (further details on Apache Lucene Syntax can be found in https://lucene.apache.org/core/2_9_4/queryparsersyntax.html). If the automatic index is not enabled ahd this flag is set to true, an Exception will be thrown as Lucene Syntax is not supported for database lookups.
  - getVerticesNonPartitioned
```
public Iterable<Vertex>[] getVerticesNonPartitioned(Connection[] connArray,
                                           Long longEndSCN,
                                           boolean bSkipStoreToCache,
                                           String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVerticesNonPartitioned
```
public Iterable<Vertex>[] getVerticesNonPartitioned(Connection[] connArray,
                                           Long longEndSCN,
                                           String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        boolean skipStoreToCache,
                                        int startPartitionID)
```
    Returns an array of iterables to all the vertices in the graph. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    skipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        boolean skipStoreToCache,
                                        int startPartitionID,
                                        String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    skipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connections,
                                        boolean bSkipStoreToCache,
                                        int startPartitionID,
                                        VertexFilterCallback vfc,
                                        OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the vertices in the graph that satisfy the specified vertex filter callback. The information read back from the vertices will be complete or partial based on the optimization flag specified. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connections - a Connection array used for concurrent querying inside the Oracle property graph.
    startPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    vfc - an VertexFilterCallback object.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        Long longEndSCN,
                                        boolean bSkipStoreToCache,
                                        int iStartPartitionID,
                                        String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        Long longEndSCN,
                                        boolean bSkipStoreToCache,
                                        int iStartPartitionID,
                                        String[] keys,
                                        VertexFilterCallback vfc)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
    vfc - an VertexFilterCallback object.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        Long longEndSCN,
                                        boolean bSkipStoreToCache,
                                        int iStartPartitionID,
                                        String[] keys,
                                        VertexFilterCallback vfc,
                                        OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys and satisfy the specified vertex filter callback. The information read back from the vertices will be complete or partial based on the optimization flag specified. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array].
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    iStartPartitionID - the ID of the starting partition
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    vfc - an VertexFilterCallback object.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(Connection[] connArray,
                                        Long longEndSCN,
                                        String[] keys)
```
    Returns an array of iterables to all the vertices in the graph that have any of the specified keys. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    connArray - a Connection array used for concurrent querying inside the Oracle property graph.
    longEndSCN - the end SCN to read vertices from
    keys - an array of property key names. It can be NULL which implies all vertices in the graph will be returned.
  - getVerticesPartitioned
```
public Iterable<Vertex>[] getVerticesPartitioned(ResultSet[] rsArray,
                                        boolean bSkipStoreToCache,
                                        VertexFilterCallback vfc,
                                        OraclePropertyGraphBase.OptimizationFlag flag)
```
    Returns an array of iterables to all the vertices in the graph that satisfy the specified vertex filter callback. The information read back from the vertices will be complete or partial based on the optimization flag specified. Each element in the Iterable array uses a separate connection provided to fetch a subset of the results from the corresponding partition. Note that we assign an integer ID (in the range of [0, N - 1]) to all the partitions in the vertex table with N partitions. The subset of partitions queried will consist of those partitions with ID value in the range of [startPartitionID, startPartitionID - 1 + size of connections array]. By default, the startPartitionID is set to 0.
    
    Parameters:
    rsArray - a ResultSet array
    bSkipStoreToCache - if true, the vertex instances retrieved by the scan will not be saved into cache
    flag - an OptimizationFlag object specifying if a partial or complete vertex object will be returned. It can be NULL which implies the vertices created must be complete.
    vfc - an VertexFilterCallback object.
  - getVTE
```
public Date getVTE()
```
    Get the end valid time used in the property graph
  - getVTS
```
public Date getVTS()
```
    Get the start valid time used in the property graph
  - grantAccess
```
public void grantAccess(String user,
               String privilege)
                 throws SQLException
```
    Grants access of this property graph to another user
    
    Parameters:
    user - name of the user
    privilege - a string representing priviledges. "R" for read, "S" for select, "I" for insert, "D" for delete, and "U" for update. "RIDUS" can be used to grant read, insert, delete, update, and select in one shot.
    
    Throws:
    
    SQLException
  - impEdgeStat
```
public void impEdgeStat(String statTableName,
               String statid)
                 throws SQLException
```
    Imports the edge table statistics from the given stat table.
    
    Parameters:
    statTableName - name of the stat table.
    statid - identifier of statistics
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - impVertexStat
```
public void impVertexStat(String statTableName,
                 String statid)
                   throws SQLException
```
    Imports the vertex table statistics from the given stat table.
    
    Parameters:
    statTableName - name of the stat table.
    statid - identifier of statistics
    
    Throws:
    
    SQLException - when there is error generated from DBMS_STATS package.
  - isDB11g
```
public boolean isDB11g()
```
    Returns if this property graph instance is working against an 11g database
    
    Returns:
    true if this property graph instance is working against an 11g database
  - isVirtualPropertyGraph
```
public boolean isVirtualPropertyGraph()
```
    Validates if this property graph instance is based on a view
    
    Returns:
    TRUE if this property graph instance is based on a view
  - pageRank
```
public static long pageRank(Connection conn,
            String szEdgeTabName,
            StringBuilder sbNodePR,
            StringBuilder sbNodeNextPR,
            StringBuilder sbEdgeTabDeg,
            StringBuilder sbDelta,
            float d,
            int iNumIterations,
            float convergence,
            int iDOP,
            String szTBS,
            String szOptions)
                     throws SQLException
```
    This method calculates the page rank values of vertices in the given graph.
    
    Parameters:
    conn - a JDBC connection to Oracle Database
    szEdgeTabName - name of a graph edge table (or view)
    sbNodePR - a place holder for the name of the working table that holds the page rank values of the vertices
    sbNodeNextPR - a place holder for the name of the working table that holds the page rank values in the next iteration
    sbEdgeTabDeg - a place holder for the name of the working table that holds edges and node degree information
    sbDelta - a place holder for the name of the working table that holds information about some special vertices
    d - damping factor, 0.85f is often used.
    iNumIterations - number of iterations to perform PR calculations.
    convergence - if positive, then continue PR calculations till sum of PR value changes is less than this convergence setting.
    szOptions - options to be used by the underlying PL/SQL API.
    iDOP - degree of parallelism to be used for creating a working table holding undirected graph data and for executing triangle counting query.
    szTBS - tablespace. It can be NULL.
    
    Returns:
    the number of vertices of the table stored in sbNodePR. The PR values of vertices are stored in the working table sbNodePR
    
    Throws:
    
    SQLException
  - pageRank
```
public long pageRank(StringBuilder sbNodePR,
            StringBuilder sbNodeNextPR,
            StringBuilder sbEdgeTabDeg,
            StringBuilder sbDelta,
            float d,
            int iNumIterations,
            float convergence,
            int iDOP,
            String szTBS,
            String szOptions)
              throws SQLException
```
    This method calculates the page rank values of vertices in this graph.
    
    Specified by:
    
    pageRank in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbNodePR - a place holder for the name of the working table that holds the page rank values of the vertices
    sbNodeNextPR - a place holder for the name of the working table that holds the page rank values in the next iteration
    sbEdgeTabDeg - a place holder for the name of the working table that holds edges and node degree information
    sbDelta - a place holder for the name of the working table that holds information about some special vertices
    d - damping factor, 0.85f is often used.
    iNumIterations - number of iterations to perform PR calculations.
    convergence - if positive, then continue PR calculations till sum of PR value changes is less than this convergence setting.
    szOptions - options to be used by the underlying PL/SQL API.
    iDOP - degree of parallelism to be used for creating a working table holding undirected graph data and for executing triangle counting query.
    szTBS - tablespace. It can be NULL.
    
    Returns:
    the number of vertices of the table stored in sbNodePR. The PR values of vertices are stored in the working table sbNodePR
    
    Throws:
    
    SQLException
  - pageRankCleanup
```
public void pageRankCleanup(StringBuilder sbNodePR,
                   StringBuilder sbNodeNextPR,
                   StringBuilder sbEdgeTabDeg,
                   StringBuilder sbDelta,
                   String szOptions)
                     throws SQLException
```
    This method does cleanup work before running page rank calculation.
    
    Specified by:
    
    pageRankCleanup in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbNodePR - a place holder for the name of the working table that holds the page rank values of the vertices
    sbNodeNextPR - a place holder for the name of the working table that holds the page rank values in the next iteration
    sbEdgeTabDeg - a place holder for the name of the working table that holds edges and node degree information
    sbDelta - a place holder for the name of the working table that holds information about some special vertices
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - pageRankPrep
```
public void pageRankPrep(StringBuilder sbNodePR,
                StringBuilder sbNodeNextPR,
                StringBuilder sbEdgeTabDeg,
                StringBuilder sbDelta,
                String szOptions)
                  throws SQLException
```
    This method does preparation work before running page rank calculation.
    
    Specified by:
    
    pageRankPrep in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbNodePR - a place holder for the name of the working table that holds the page rank values of the vertices
    sbNodeNextPR - a place holder for the name of the working table that holds the page rank values in the next iteration
    sbEdgeTabDeg - a place holder for the name of the working table that holds edges and node degree information
    sbDelta - a place holder for the name of the working table that holds information about some special vertices
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - parallelExecuteStatements
```
public ResultSet[] parallelExecuteStatements(PreparedStatement[] stmtArray)
```
    Executes the given statements in parallel and returns an array of result sets from each statement.
    
    Parameters:
    stmtArray - the array of prepared statements to execute in parallel-
    
    Returns:
    an array of ResultSet objects.
  - parseValueToCharSQLFormatString
```
public String parseValueToCharSQLFormatString(Object value)
```
    Parses a numeric or datetime value object into the String format required by SQL (Oracle Text) using the CharSQL formats used in this property graph instance. Note that this helper API is intended for numeric and date time values only.
    
    Parameters:
    value - the value to parse
  - rebuildAllIndexPartitions
```
public void rebuildAllIndexPartitions(String szIdx,
                             int iDop)
                               throws SQLException
```
    Rebuilds all the index partitions for the given database index.
    
    Parameters:
    szIdx - the name of the index
    iDop - the degree of parallelism used when executing the process
    
    Throws:
    
    SQLException
  - rebuildEdgeTableConstraints
```
public void rebuildEdgeTableConstraints(List<String> llConstraints,
                               int dop,
                               String szOptions)
                                 throws SQLException
```
    This method rebuilds all the database constraints of the edge table.
    
    Parameters:
    llConstraints - a list of constraint names
    dop - degree of parallelism
    szOptions - additional SQL options to add as hints during the rebuild.
    
    Throws:
    
    SQLException
  - rebuildEdgeTableIndices
```
public void rebuildEdgeTableIndices(List<String> llIndices,
                           int dop,
                           String szOptions)
                             throws SQLException
```
    Rebuilds all database indices of the edge table.
    
    Parameters:
    llIndices - a list of index names to rebuild
    dop - degree of parallelism used when rebuilding the indices
    szOptions - additonal SQL options used when rebuilding the indices.
    
    Throws:
    
    SQLException
  - rebuildVertexTableConstraints
```
public void rebuildVertexTableConstraints(List<String> llConstraints,
                                 int dop,
                                 String szOptions)
                                   throws SQLException
```
    Rebuilds all the database constraints of the vertex table.
    
    Parameters:
    llConstraints - a list of constraint names
    dop - degree of parallelism
    szOptions - additional SQL options to add as hints during the rebuild.
    
    Throws:
    
    SQLException
  - rebuildVertexTableIndices
```
public void rebuildVertexTableIndices(List<String> llIndices,
                             int dop,
                             String szOptions)
                               throws SQLException
```
    Rebuilds all database indices of the vertex table.
    
    Parameters:
    llIndices - a list of index names to rebuild
    dop - degree of parallelism used when rebuilding the indices
    szOptions - additonal SQL options used when rebuilding the indices.
    
    Throws:
    
    SQLException
  - refreshIndices
```
public void refreshIndices(long lStartSCN,
                  long lEndSCN)
```
    Refreshes all the text indices based on the changes done during the given SCN window.
  - removeAttributeFromAllEdges
```
public void removeAttributeFromAllEdges(EdgeOpCallback eoc,
                               boolean skipStoreToCache,
                               int dop,
                               ProgressListener pl)
```
    Removes an attribute from all edges based on the specified EdgeOpCallback. NOTE the current transaction will be committed.
    
    Specified by:
    
    removeAttributeFromAllEdges in class OraclePropertyGraphBase
    
    Parameters:
    eoc - a EdgeOpCallback object.
    skipStoreToCache - if true, the edges instances will not be stored into the cache.
    dop - a positive integer defining the number of threads to use when parallel processing the edges.
    pl - a ProgressListener object.
  - removeAttributeFromAllVertices
```
public void removeAttributeFromAllVertices(VertexOpCallback voc,
                                  boolean skipStoreToCache,
                                  int dop,
                                  ProgressListener pl)
```
    Removes an attribute from all vertices based on the specified VertexOpCallback. NOTE the current transaction will be committed.
    
    Specified by:
    
    removeAttributeFromAllVertices in class OraclePropertyGraphBase
    
    Parameters:
    voc - a VertexOpCallback object.
    skipStoreToCache - if true, the vertices instances will not be stored into the cache.
    dop - a positive integer defining the number of threads to use when parallel processing the vertices.
    pl - a ProgressListener object.
  - removeEdge
```
public void removeEdge(Edge edge)
```
    Removes the provided edge from the graph. Note that this is just a logical operation. Note that this is not a thread safe method.
    
    Specified by:
    
    removeEdge in interface Graph
    
    Specified by:
    
    removeEdge in class OraclePropertyGraphBase
    
    Parameters:
    edge - an Edge object to be removed
  - removeVertex
```
public void removeVertex(Vertex vertex)
```
    Removes the provided vertex from the graph. Note that this is just a logical operation. Note that this is not a thread safe method.
    
    Specified by:
    
    removeVertex in interface Graph
    
    Parameters:
    vertex - a Vertex object to be removed
  - rollback
```
public void rollback()
```
    Rollbacks the operations done to this property graph instance
    
    Specified by:
    
    rollback in interface TransactionalGraph
    
    Overrides:
    
    rollback in class OraclePropertyGraphBase
  - setDefaultDOPPerPtn
```
public void setDefaultDOPPerPtn(int i)
```
    This method sets the default DOP used for partition-wise scan.
    
    Parameters:
    i - default DOP used for partition-wise scan. It MUST NOT be negative.
  - setLabel
```
public void setLabel(String policy,
            String label)
              throws SQLException
```
    Sets the label for the current session.
    
    Parameters:
    policy - name of the OLS policy
    label - security label name
    
    Throws:
    
    SQLException
  - setNumberToCharSqlFormatString
```
public void setNumberToCharSqlFormatString(String format)
```
    Sets the Char SQL Format used to format a number into a string
    
    Parameters:
    format - the format used for numeric objects
  - setPGViewOnRDFFlag
```
public void setPGViewOnRDFFlag(boolean flag)
```
    Specifies if this property graph instance comes from a Property Graph view over RDF data
    
    Parameters:
    flag - use true if this property graph instance comes from a Property Graph view over RDF data
  - setQueryFetchSize
```
public void setQueryFetchSize(int size)
```
    Sets the query fetch size used when scanning the vertex and edge tables
    
    Parameters:
    size - the query fetch size
  - setRowLabel
```
public void setRowLabel(String policy,
               String label)
                 throws SQLException
```
    Sets the row label for the current session.
    
    Parameters:
    policy - name of the OLS policy
    label - security label name
    
    Throws:
    
    SQLException
  - setRowPrefetch
```
public void setRowPrefetch(int i)
```
    Sets the number of rows to prefetch when executing a SQL query over the Property graph data tables
    
    Parameters:
    i - the prefetch size
  - setSessionQueryDOP
```
public void setSessionQueryDOP(int dop)
                        throws SQLException
```
    Sets the degree of parallel query execution at the session level.
    
    Parameters:
    dop - degree of parallelism. The value can be zero. If the value is negative, then it is no op.
    
    Throws:
    
    SQLException
  - setTimeToCharSqlFormatString
```
public void setTimeToCharSqlFormatString(String format)
```
    Sets the Char SQL Format used to format a datetime into a string
    
    Parameters:
    format - the format used for datetime objects
  - setVTE
```
public void setVTE(Date dateVTE)
```
    Set the end valid time used in the property graph
  - setVTS
```
public void setVTS(Date dateVTS)
```
    Set the start valid time used in the property graph
  - shortestPath
```
public static String shortestPath(Connection conn,
                  String szEdgeTabName,
                  Long lStart,
                  Long lEnd,
                  StringBuilder sbExpTab,
                  StringBuilder sbPathWeights,
                  String szOptions,
                  Long lSCN)
                           throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Parameters:
    conn - a JDBC connection to Oracle Database
    szEdgeTabName - name of the edge table (or view). Note that one can create a view on top of existing edge table to filter out unwanted edges.
    lStart - start vertex integer ID
    lEnd - destination vertex integer ID
    sbPathWeights - place holder of path weights of the shortest path. The first number represents the number of vertices on the shortest path, the second number represents the total weight and the rest numbers denote weights of edges along the shortest path. All these numbers are delimited by spaces.
    szOptions - options to be passed on to the underlying PL/SQL API.
    lSCN - SCN for the edge table. It can be NULL.
    
    Throws:
    
    SQLException
  - shortestPath
```
public String shortestPath(Long lStart,
                  Long lEnd,
                  StringBuilder sbExpTab)
                    throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Specified by:
    
    shortestPath in interface OraclePropertyGraphAnalytics
    
    Parameters:
    lStart - start vertex integer ID
    lEnd - destination vertex integer ID
    sbExpTab - place holder of expansion table name
    
    Throws:
    
    SQLException
  - shortestPath
```
public String shortestPath(Long lStart,
                  Long lEnd,
                  StringBuilder sbExpTab,
                  StringBuilder sbPathWeights,
                  String szOptions)
                    throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Specified by:
    
    shortestPath in interface OraclePropertyGraphAnalytics
    
    Parameters:
    lStart - start vertex integer ID
    lEnd - destination vertex integer ID
    sbExpTab - place holder of expansion table name
    sbPathWeights - place holder of path weights of the shortest path. The first number represents the number of vertices on the shortest path, the second number represents the total weight and the rest numbers denote weights of edges along the shortest path. All these numbers are delimited by spaces.
    szOptions - options to be passed on to the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - shortestPath
```
public String shortestPath(Long lStart,
                  Long lEnd,
                  StringBuilder sbExpTab,
                  String szEdgeTabName,
                  StringBuilder sbPathWeights,
                  String szOptions,
                  Long lSCN)
                    throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Specified by:
    
    shortestPath in interface OraclePropertyGraphAnalytics
    
    Parameters:
    lStart - start vertex integer ID
    lEnd - destination vertex integer ID
    szEdgeTabName - name of the edge table (or view). Note that one can create a view on top of existing edge table to filter out unwanted edges.
    sbPathWeights - place holder of path weights of the shortest path. The first number represents the number of vertices on the shortest path, the second number represents the total weight and the rest numbers denote weights of edges along the shortest path. All these numbers are delimited by spaces.
    szOptions - options to be passed on to the underlying PL/SQL API.
    lSCN - SCN for the edge table. It can be NULL.
    
    Throws:
    
    SQLException
  - shortestPath
```
public String shortestPath(OracleVertex vStart,
                  OracleVertex vEnd,
                  StringBuilder sbExpTab)
                    throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Specified by:
    
    shortestPath in interface OraclePropertyGraphAnalytics
    
    Parameters:
    vStart - start vertex object
    vEnd - destination vertex object
    sbExpTab - place holder of expansion table name
    
    Throws:
    
    SQLException
  - shortestPath
```
public String shortestPath(OracleVertex vStart,
                  OracleVertex vEnd,
                  StringBuilder sbExpTab,
                  StringBuilder sbPathWeights,
                  String szOptions)
                    throws SQLException
```
    Returns a shortest path in a string format. The path is delimited by space. A NULL value will be returned if there is no path found.
    
    Specified by:
    
    shortestPath in interface OraclePropertyGraphAnalytics
    
    Parameters:
    vStart - start vertex object
    vEnd - destination vertex object
    sbExpTab - place holder of expansion table name
    sbPathWeights - place holder of path weights of the shortest path. The first number represents the number of vertices on the shortest path, the second number represents the total weight and the rest numbers denote weights of edges along the shortest path. All these numbers are delimited by spaces.
    szOptions - options to be passed on to the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - shortestPathCleanup
```
public void shortestPathCleanup(StringBuilder sbExpTab,
                       String szOptions)
                         throws SQLException
```
    This method does clean up after running shortest path calculations.
    
    Specified by:
    
    shortestPathCleanup in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbExpTab - a place holder for the name of the expansion table to be used for Bi-directional, Set Style, Dijkstra search.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - shortestPathPrep
```
public void shortestPathPrep(StringBuilder sbExpTab,
                    String szOptions)
                      throws SQLException
```
    This method does some preparation work before running one or multiple shortest path calculations. This method only needs to be invoked once unless a different expansion table is to be used to calculate shortest paths.
    
    Specified by:
    
    shortestPathPrep in interface OraclePropertyGraphAnalytics
    
    Parameters:
    sbExpTab - a place holder for the name of the expansion table to be used for Bi-directional, Set Style, Dijkstra search. If sbExpTab is empty, an intermediate working table will be created and the table name will be returned in the sbExpTab object.
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - shutdown
```
public void shutdown()
```
    Commits all the queued operations and properly closes the graph.
    
    Specified by:
    
    shutdown in interface Graph
    
    Specified by:
    
    shutdown in interface TransactionalGraph
  - sparsifyGraph
```
public static void sparsifyGraph(Connection conn,
                 String szEdgeTabName,
                 float fThreshold,
                 int iMinKeep,
                 int iDOP,
                 StringBuilder sbOutTab,
                 StringBuilder sbUndTab,
                 StringBuilder sbHshTab,
                 StringBuilder sbMchTab,
                 String szTBS,
                 String szOptions)
                          throws SQLException
```
    This method sparsifies a given graph (treated as undirected). The output edges will be stored in the table denoted by sbOutTab.
    
    Parameters:
    sbOutTab - a place holder for the name of the output table that holds the sparsified graph
    sbUndTab - a place holder for the name of the working table that holds undirected graph
    sbHshTab - a place holder for the name of the working table that holds min hash values
    sbMchTab - a place holder for the name of the working table that holds match counts
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - sparsifyGraph
```
public void sparsifyGraph(float fThreshold,
                 int iMinKeep,
                 int iDOP,
                 StringBuilder sbOutTab,
                 StringBuilder sbUndTab,
                 StringBuilder sbHshTab,
                 StringBuilder sbMchTab,
                 String szTBS,
                 String szOptions)
                   throws SQLException
```
    This method sparsifies this graph instance (treated as undirected). The output edges will be stored in the table denoted by sbOutTab.
    
    Parameters:
    sbOutTab - a place holder for the name of the output table that holds the sparsified graph
    sbUndTab - a place holder for the name of the working table that holds undirected graph
    sbHshTab - a place holder for the name of the working table that holds min hash values
    sbMchTab - a place holder for the name of the working table that holds match counts
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - sparsifyGraphCleanup
```
public void sparsifyGraphCleanup(StringBuilder sbOutTab,
                        StringBuilder sbUndTab,
                        StringBuilder sbHshTab,
                        StringBuilder sbMchTab,
                        String szOptions)
                          throws SQLException
```
    This method does cleanup work before running graph sparsification.
    
    Parameters:
    sbOutTab - a place holder for the name of the output table that holds the sparsified graph
    sbUndTab - a place holder for the name of the working table that holds undirected graph
    sbHshTab - a place holder for the name of the working table that holds min hash values
    sbMchTab - a place holder for the name of the working table that holds match counts
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - sparsifyGraphPrep
```
public void sparsifyGraphPrep(StringBuilder sbOutTab,
                     StringBuilder sbUndTab,
                     StringBuilder sbHshTab,
                     StringBuilder sbMchTab,
                     String szOptions)
                       throws SQLException
```
    This method does preparation work before running graph sparsification.
    
    Parameters:
    sbOutTab - a place holder for the name of the output table that holds the sparsified graph
    sbUndTab - a place holder for the name of the working table that holds undirected graph
    sbHshTab - a place holder for the name of the working table that holds min hash values
    sbMchTab - a place holder for the name of the working table that holds match counts
    szOptions - options to be used by the underlying PL/SQL API.
    
    Throws:
    
    SQLException
  - toString
```
public String toString()
```
    Returns a very succinct String representation of this Graph instance
    
    Overrides:
    
    toString in class Object

Class OraclePropertyGraph

Nested Class Summary

Nested classes/interfaces inherited from class oracle.pg.common.OraclePropertyGraphBase

Nested classes/interfaces inherited from interface com.tinkerpop.blueprints.TransactionalGraph

Field Summary

Fields inherited from class oracle.pg.common.OraclePropertyGraphBase

Fields inherited from interface oracle.pg.common.MesgConsts

Method Summary

Methods inherited from class oracle.pg.common.OraclePropertyGraphBase

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_NUMBER_FORMAT

DEFAULT_TIME_FORMAT

Method Detail

addAttributeToAllEdges

addAttributeToAllVertices

addEdge

addVertex

analyze

analyze

analyze

analyzeAuto

clearCache

clearRepository

clearUpdateQueue

commit

commit

countEdges

countTriangle

countTriangle

countTriangle

countTriangleCleanup

countTrianglePrep

countTriangleRenum

countTriangleRenum

countVertices

createDefaultSpatialIndexOnEdges

createDefaultSpatialIndexOnEdges

createDefaultSpatialIndexOnVertices

createDefaultSpatialIndexOnVertices

createStatTable

disable

disableEdgeTableConstraints

disableEdgeTableIndices

disableVertexTableConstraints

disableVertexTableIndices

dispose

doesEdgeExistAt

doesEdgeExistAt

doesVertexExistAt

doesVertexExistAt

dropDefaultSpatialIndexOnEdges

dropDefaultSpatialIndexOnVertices

enableAtSCN

estimateTriangleRenum

estimateTriangleRenum

expEdgeStat

expVertexStat

findCluster

findCluster

findClusterCleanup

findClusterPrep

getConstraintNames

getCurrentSCN

getCurrentSCNUnsafe

getDatatypeClassFromValueObjForTextIndex

getDefaultDOPPerPtn

getEdge

getEdgeChanges

getEdgeChanges

getEdgeChanges

getEdgeChanges

getEdgeInstance

getEdgeInstance

getEdgePartitionsNumber

getEdgePropertyNames

getEdges

getEdges

getEdges

getEdges