OraclePropertyGraphDataLoader (Oracle Spatial and Graph Property Graph)

java.lang.Object
- oracle.pg.rdbms.OraclePropertyGraphDataLoader

```
public class OraclePropertyGraphDataLoader
extends Object
```
This class implements the logic to load a property graph (in Oracle-defined flat files format) into supported backend database.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`EXTERNALTABLE`
`static int`	`JDBC`
`static int`	`NAMEDPIPE`
`static int`	`PIPEDSTREAM`
`static int`	`REGULARFILE`
`static int`	`SQLLOADER`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`commit(OraclePropertyGraph opg)` Commit the changes to the database
`static OraclePropertyGraphDataLoader`	`getInstance()` Returns an instance of OraclePropertyGraphDataLoader
`String`	`getNumToStrColConversion(OraclePropertyGraph opg, String szColName, String szTypeColumn)` Return a conversion expression that can convert a numeric column into a String.
`int`	`getSessionID(OraclePropertyGraph opg)` get the session ID
`String`	`getTimeToStrColConversion(OraclePropertyGraph opg, String szColName, String szTypeColumn)` Return a conversion expression that can convert a timestamp column into a String.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions, DataLoaderListener dll)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szDir, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szDir, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithExtTab(OraclePropertyGraph opg, String[] saVertexFiles, String[] saEdgeFiles, int iDop, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`loadDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions, DataLoaderListener dll)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeData(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, int iBatchSize, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szDir, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szDir, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithExtTab(OraclePropertyGraph opg, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szDir, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, int iDop, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object[] oaVertexSources, Object[] oaEdgeSources, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, boolean bNamedPipe, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, int iDop, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`mergeDataWithSqlLdr(OraclePropertyGraph opg, String szUser, String szPassword, String szDbId, Object obVertexSource, Object obEdgeSource, long lVertexSrcOffsetlines, long lEdgeSrcOffsetlines, long lVertexSrcMaxlines, long lEdgeSrcMaxlines, long lVertexIDOffset, long lEdgeIDOffset, int iDop, int iPartitions, int iOffset, int iSplitterFlag, String szPrefix, String szSqlLoaderPath, boolean bRebuildIndex, String szTbs, String szOptions)` This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
`void`	`setBatchSizeToDebug(long size)` Set the batch size to show debug information

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

- Field Detail
  - EXTERNALTABLE
```
public static final int EXTERNALTABLE
```
    See Also:
    Constant Field Values
  - JDBC
```
public static final int JDBC
```
    See Also:
    Constant Field Values
  - NAMEDPIPE
```
public static final int NAMEDPIPE
```
    See Also:
    Constant Field Values
  - PIPEDSTREAM
```
public static final int PIPEDSTREAM
```
    See Also:
    Constant Field Values
  - REGULARFILE
```
public static final int REGULARFILE
```
    See Also:
    Constant Field Values
  - SQLLOADER
```
public static final int SQLLOADER
```
    See Also:
    Constant Field Values
- Method Detail
  - commit
```
public void commit(OraclePropertyGraph opg)
            throws SQLException
```
    Commit the changes to the database
    
    Throws:
    
    SQLException
  - getInstance
```
public static OraclePropertyGraphDataLoader getInstance()
```
    Returns an instance of OraclePropertyGraphDataLoader
  - getNumToStrColConversion
```
public String getNumToStrColConversion(OraclePropertyGraph opg,
                              String szColName,
                              String szTypeColumn)
```
    Return a conversion expression that can convert a numeric column into a String. szTypeColumn can be integer, float, and double.
  - getSessionID
```
public int getSessionID(OraclePropertyGraph opg)
                 throws SQLException
```
    get the session ID
    
    Throws:
    
    SQLException
  - getTimeToStrColConversion
```
public String getTimeToStrColConversion(OraclePropertyGraph opg,
                               String szColName,
                               String szTypeColumn)
```
    Return a conversion expression that can convert a timestamp column into a String. szTypeColumn can be timestamp.
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iBatchSize,
            boolean bRebuildIndex,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iSplitterFlag,
            int iBatchSize,
            boolean bRebuildIndex,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iSplitterFlag,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM; Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iPartitions,
            int iOffset,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iPartitions,
            int iOffset,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            int iDop,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            long lVertexSrcOffsetlines,
            long lEdgeSrcOffsetlines,
            long lVertexSrcMaxlines,
            long lEdgeSrcMaxlines,
            long lVertexIDOffset,
            long lEdgeIDOffset,
            int iDop,
            int iPartitions,
            int iOffset,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object[] oaVertexSources,
            Object[] oaEdgeSources,
            long lVertexSrcOffsetlines,
            long lEdgeSrcOffsetlines,
            long lVertexSrcMaxlines,
            long lEdgeSrcMaxlines,
            long lVertexIDOffset,
            long lEdgeIDOffset,
            int iDop,
            int iPartitions,
            int iOffset,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions,
            DataLoaderListener dll)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    dll - an instance of DataLoaderListener that can be used to report progress and control the loading process when an error occurs. It can be NULL.
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iBatchSize,
            boolean bRebuildIndex,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iSplitterFlag,
            int iBatchSize,
            boolean bRebuildIndex,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iSplitterFlag,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iPartitions,
            int iOffset,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iPartitions,
            int iOffset,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAE. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            int iDop,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAE. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadData
```
public void loadData(OraclePropertyGraph opg,
            Object obVertexSource,
            Object obEdgeSource,
            long lVertexSrcOffsetlines,
            long lEdgeSrcOffsetlines,
            long lVertexSrcMaxlines,
            long lEdgeSrcMaxlines,
            long lVertexIDOffset,
            long lEdgeIDOffset,
            int iDop,
            int iPartitions,
            int iOffset,
            int iSplitterFlag,
            String szPrefix,
            int iBatchSize,
            boolean bRebuildIndex,
            String szTbs,
            String szOptions)
              throws IllegalArgumentException,
                     OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using JDBC-based loading. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAE. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based loading. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szDir,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      long lVertexSrcOffsetlines,
                      long lEdgeSrcOffsetlines,
                      long lVertexSrcMaxlines,
                      long lEdgeSrcMaxlines,
                      long lVertexIDOffset,
                      long lEdgeIDOffset,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szDir,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      Object obVertexSource,
                      Object obEdgeSource,
                      long lVertexSrcOffsetlines,
                      long lEdgeSrcOffsetlines,
                      long lVertexSrcMaxlines,
                      long lEdgeSrcMaxlines,
                      long lVertexIDOffset,
                      long lEdgeIDOffset,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithExtTab
```
public void loadDataWithExtTab(OraclePropertyGraph opg,
                      String[] saVertexFiles,
                      String[] saEdgeFiles,
                      int iDop,
                      String szDir,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using External table-based loading. It loads a set of vertex and edge flat files at given directory without splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    saVertexFiles - an array of vertex flat files
    saEdgeFiles - an array of edge flat files
    iDop - degree of parallelism. It has to be a positive integer.
    szDir - the database directory for external table based loading
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      int iDop,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object[] oaVertexSources,
                      Object[] oaEdgeSources,
                      long lVertexSrcOffsetlines,
                      long lEdgeSrcOffsetlines,
                      long lVertexSrcMaxlines,
                      long lEdgeSrcMaxlines,
                      long lVertexIDOffset,
                      long lEdgeIDOffset,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      boolean bNamedPipe,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      int iDop,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - loadDataWithSqlLdr
```
public void loadDataWithSqlLdr(OraclePropertyGraph opg,
                      String szUser,
                      String szPassword,
                      String szDbId,
                      Object obVertexSource,
                      Object obEdgeSource,
                      long lVertexSrcOffsetlines,
                      long lEdgeSrcOffsetlines,
                      long lVertexSrcMaxlines,
                      long lEdgeSrcMaxlines,
                      long lVertexIDOffset,
                      long lEdgeIDOffset,
                      int iDop,
                      int iPartitions,
                      int iOffset,
                      int iSplitterFlag,
                      String szPrefix,
                      String szSqlLoaderPath,
                      boolean bRebuildIndex,
                      String szTbs,
                      String szOptions)
                        throws IllegalArgumentException,
                               OraclePropertyGraphException
```
    This method loads given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based loading. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before loading data into the tables, and enable indexes/contraints on the tables after loading data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             int iDop,
             int iBatchSize,
             boolean bRebuildIndex,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             int iDop,
             int iSplitterFlag,
             int iBatchSize,
             boolean bRebuildIndex,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             int iDop,
             int iSplitterFlag,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             int iDop,
             int iPartitions,
             int iOffset,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             int iDop,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             long lVertexSrcOffsetlines,
             long lEdgeSrcOffsetlines,
             long lVertexSrcMaxlines,
             long lEdgeSrcMaxlines,
             long lVertexIDOffset,
             long lEdgeIDOffset,
             int iDop,
             int iPartitions,
             int iOffset,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object[] oaVertexSources,
             Object[] oaEdgeSources,
             long lVertexSrcOffsetlines,
             long lEdgeSrcOffsetlines,
             long lVertexSrcMaxlines,
             long lEdgeSrcMaxlines,
             long lVertexIDOffset,
             long lEdgeIDOffset,
             int iDop,
             int iPartitions,
             int iOffset,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions,
             DataLoaderListener dll)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    dll - an instance of DataLoaderListener that can be used to report progress and control the loading process when an error occurs. It can be NULL.
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             int iDop,
             int iBatchSize,
             boolean bRebuildIndex,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             int iDop,
             int iSplitterFlag,
             int iBatchSize,
             boolean bRebuildIndex,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             int iDop,
             int iSplitterFlag,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             int iDop,
             int iPartitions,
             int iOffset,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             int iDop,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeData
```
public void mergeData(OraclePropertyGraph opg,
             Object obVertexSource,
             Object obEdgeSource,
             long lVertexSrcOffsetlines,
             long lEdgeSrcOffsetlines,
             long lVertexSrcMaxlines,
             long lEdgeSrcMaxlines,
             long lVertexIDOffset,
             long lEdgeIDOffset,
             int iDop,
             int iPartitions,
             int iOffset,
             int iSplitterFlag,
             String szPrefix,
             int iBatchSize,
             boolean bRebuildIndex,
             String szTbs,
             String szOptions)
               throws IllegalArgumentException,
                      OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using JDBC-based merging. It supports regular file, named pipe, and piped stream based spliting.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is PIPEDSTREAM
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    iBatchSize - the batch size of Oracle update in batching mode for JDBC-based merging. Default value is 1000
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szDir,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       long lVertexSrcOffsetlines,
                       long lEdgeSrcOffsetlines,
                       long lVertexSrcMaxlines,
                       long lEdgeSrcMaxlines,
                       long lVertexIDOffset,
                       long lEdgeIDOffset,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szDir,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithExtTab
```
public void mergeDataWithExtTab(OraclePropertyGraph opg,
                       Object obVertexSource,
                       Object obEdgeSource,
                       long lVertexSrcOffsetlines,
                       long lEdgeSrcOffsetlines,
                       long lVertexSrcMaxlines,
                       long lEdgeSrcMaxlines,
                       long lVertexIDOffset,
                       long lEdgeIDOffset,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szDir,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using External table-based merging. Its supports regular file or named pipe-based splitting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szDir - the database directory for external table based merging
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       int iDop,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object[] oaVertexSources,
                       Object[] oaEdgeSources,
                       long lVertexSrcOffsetlines,
                       long lEdgeSrcOffsetlines,
                       long lVertexSrcMaxlines,
                       long lEdgeSrcMaxlines,
                       long lVertexIDOffset,
                       long lEdgeIDOffset,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    oaVertexSources - the input data source of vertices (can be either an array of file names or input streams)
    oaEdgeSources - the input data source of edges (can be either an array of file names or input streams)
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       boolean bNamedPipe,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging.
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    bNamedPipe - setting the flag to true would use named pipe based splitting. otherwise regular filebased splitting would be used
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       int iDop,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    iDop - degree of parallelism. It has to be a positive integer.
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - mergeDataWithSqlLdr
```
public void mergeDataWithSqlLdr(OraclePropertyGraph opg,
                       String szUser,
                       String szPassword,
                       String szDbId,
                       Object obVertexSource,
                       Object obEdgeSource,
                       long lVertexSrcOffsetlines,
                       long lEdgeSrcOffsetlines,
                       long lVertexSrcMaxlines,
                       long lEdgeSrcMaxlines,
                       long lVertexIDOffset,
                       long lEdgeIDOffset,
                       int iDop,
                       int iPartitions,
                       int iOffset,
                       int iSplitterFlag,
                       String szPrefix,
                       String szSqlLoaderPath,
                       boolean bRebuildIndex,
                       String szTbs,
                       String szOptions)
                         throws IllegalArgumentException,
                                OraclePropertyGraphException
```
    This method merges given graph data into an OraclePropertyGraph instance in parallel using SQL*Loader-based merging. It supports regular file or named pipe-based spliting
    
    Parameters:
    opg - an instance of OraclePropertyGraph
    szUser - user name to access the database
    szPassword - password to access the database
    szDbId - service name of the database
    obVertexSource - the input data source of vertex
    obEdgeSource - the input data source of edge
    lVertexSrcOffsetlines - the line offset of vertices. Loading vertices after the offset. Default is 0.
    lEdgeSrcOffsetlines - the line offset of edges. Loading edges after the offset. Default is 0.
    lVertexSrcMaxlines - the max lines of vertices to be loaded. Default is -1 (i.e., load all vertices)
    lEdgeSrcMaxlines - the max lines of edges to be loaded. Default is -1 (i.e., load all edges)
    lVertexIDOffset - the offset of vertex ID. That is, the vertex ID would be vertexID+lVertexIDOffset. Default is 0
    lEdgeIDOffset - the offset of edge ID. That is, the edge ID would be edgeID+lEdgeIDOffset. Default is 0
    iDop - degree of parallelism. It has to be a positive integer.
    iPartitions - number of partitions (i.e., data loading clients)
    iOffset - offset of partitions. It is from 0 to iPartitions-1
    iSplitterFlag - the flag to set splitting: REGULARFILE, NAMEDPIPE, PIPEDSTREAM. Default value is REGULARFILE
    szPrefix - the prefix used to generate splitted files for regular file or named pipe based splitting
    szSqlLoaderPath - the path to SQL*Loader bin/sqlldr
    bRebuildIndex - setting the flag to true would disable indexes/constraints on the tables before merging data into the tables, and enable indexes/contraints on the tables after merging data into the tables
    szTbs - tablespace name
    szOptions - the extra options
    
    Throws:
    
    IllegalArgumentException
    
    OraclePropertyGraphException
  - setBatchSizeToDebug
```
public void setBatchSizeToDebug(long size)
```
    Set the batch size to show debug information
    
    Parameters:
    size - the batch size that has a default value of 10000

Class OraclePropertyGraphDataLoader

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EXTERNALTABLE

JDBC

NAMEDPIPE

PIPEDSTREAM

REGULARFILE

SQLLOADER

Method Detail

commit

getInstance

getNumToStrColConversion

getSessionID

getTimeToStrColConversion

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadData

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithExtTab

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

loadDataWithSqlLdr

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeData

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab

mergeDataWithExtTab