You can synchronize a graph loaded into the graph server (PGX) from a property graph view (PG View) with the changes made to the graph in the database.

1. Load the PG View graph into the graph server (PGX) using the readGraphByName() API as shown:
   • JShell
   • Java
   • Python

   opg4j> var graph = session.readGraphByName("BANK_GRAPH_VIEW",GraphSource.PG_VIEW,
                    ReadGraphOption.optimizeFor(GraphOptimizedFor.UPDATES),ReadGraphOption.synchronizable())
   graph ==> PgxGraph[name=BANK_GRAPH_VIEW,N=999,E=4993,created=1660275936010]

   PgxGraph graph = session.readGraphByName("BANK_GRAPH_VIEW",GraphSource.PG_VIEW,
                         ReadGraphOption.optimizeFor(GraphOptimizedFor.UPDATES),ReadGraphOption.synchronizable());

   >>> graph = session.read_graph_by_name('BANK_GRAPH_VIEW','pg_view')

2. Open a new JDBC connection to the database and change the data in the underlying database tables for the PG View graph. For example, the following code updates the database value for one of the edge properties:
   • JShell
   • Java
   • Python

   opg4j> var conn = DriverManager.getConnection(<jdbcUrl>,<username>,<password>)
   conn ==> oracle.jdbc.driver.T4CConnection@60f7261f
   opg4j> var stmt = conn.createStatement()
   stmt ==> oracle.jdbc.driver.OracleStatementWrapper@1a914a00
   opg4j> stmt.executeQuery("UPDATE bank_txns SET amount=4000 WHERE txn_id=3")
   $5 ==> oracle.jdbc.driver.ForwardOnlyResultSet@627d5f99
   opg4j> conn.setAutoCommit(false)
   opg4j> conn.commit()

   Connection conn = DriverManager.getConnection(<jdbcUrl>,<username>,<password>);
   Statement stmt = conn.createStatement();
   stmt.executeQuery("UPDATE bank_txns SET amount=4000 WHERE txn_id=3");
   conn.setAutoCommit(false);
   conn.commit();

   >>> conn = opg4py.pgql.get_connection(<username>,<password>, <jdbcUrl>).get_jdbc_connection()
   >>> conn.prepareStatement("UPDATE bank_txns SET amount=4000 WHERE txn_id=3").execute()
   False
   >>> conn.commit()
   

   Committing the changes to the database causes the graph in the memory to go out of sync with the database source tables.
3. Synchronize the in-memory graph with the database by creating a new synchronizer object as shown in the following code:

   Synchronizer synchronizer = new Synchronizer.Builder<FlashbackSynchronizer>()
       .setType(FlashbackSynchronizer.class)
       .setGraph(graph)
       .setConnection(conn)
       .build();

   Internally, the graph server keeps track of the Oracle system change number (SCN) the current graph snapshot belongs to. The synchronizer is a client-side component which connects to the database, detects changes by comparing state of the original input tables using the current SCN via the flashback mechanism and then sends any changes to the graph server using the changeset API. In order to do so, the synchronizer needs to know how to connect to the database (conn parameter) as well as which graph to keep in sync (graph parameter).

   Alternatively, you can use this equivalent shortcut as shown:

   • JShell
   • Java
   • Python

   opg4j>  var synchronizer = graph.createSynchronizer(FlashbackSynchronizer.class, conn)
   synchronizer ==> oracle.pgx.api.FlashbackSynchronizer@4ac2b4c6

   Synchronizer synchronizer = graph.createSynchronizer(FlashbackSynchronizer.class, conn);

   >>> synchronizer = graph.create_synchronizer(synchronizer_class='oracle.pgx.api.FlashbackSynchronizer', connection=conn)

4. Fetch and apply the database changes by calling the sync() function and create a new in-memory graph snapshot:
   • JShell
   • Java
   • Python

   opg4j> graph=synchronizer.sync()
   g ==> PgxGraph[name=BANK_GRAPH_VIEW,N=999,E=4993,created=1660308128037]

   graph=synchronizer.sync();

   >>> graph = synchronizer.sync()

   Splitting the Fetching and Applying of Changes

   The synchronizer.sync() invocation in the preceding code, fetches the changes and applies them in one call. However, you can encode a more complex update logic by splitting this process into separate fetch() and apply() invocations. For example:

   synchronizer.fetch(); // fetches changes from the database
   if (synchronizer.getGraphDelta().getTotalNumberOfChanges() > 100) {  // only create snapshot if there have been more than 100 changes
     synchronizer.apply();
   }

5. Query the graph to verify the updates to the edge property.
   • JShell
   • Java
   • Python

   opg4j> graph.queryPgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE e.from_acct_id = 179 AND e.to_acct_id=688").print()

   graph.queryPgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE e.from_acct_id = 179 AND e.to_acct_id=688").print();

   >>> graph.query_pgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE e.from_acct_id = 179 AND e.to_acct_id=688").print()

   On execution, the preceding example produces the following output:

   +--------+
   | amount |
   +--------+
   | 4000.0 |
   +--------+

You can synchronize a published graph by configuring the Flashback Synchronizer with a PartitionedGraphConfig object containing the graph schema along with the database connection details.

{
  ...
  "optimized_for": "updates",
  "vertex_providers": [
      ...
      "username":"<username>",
      ...
  ],
  "edge_providers": [
      ...
      "username":"<username>",
      ...
  ],
  "loading": {
    "snapshots_source": "change_set"
  }
}

GraphConfig cfg = GraphConfigBuilder.forPartitioned()
                      …
                      .setUsername("<username>")
                      .setSnapshotsSource(SnapshotsSource.CHANGE_SET)
                      .setOptimizedFor(GraphOptimizedFor.UPDATES)
                      ...
                      .build();

opg4j> var graph = session.readGraphWithProperties("<path_to_json_config_file>")
graph ==> PgxGraph[name=bank_graph_analytics_fb,N=999,E=4993,created=1664310157103]
opg4j> graph.publishWithSnapshots()

PgxGraph graph = session.readGraphWithProperties("<path_to_json_config_file>");
graph.publishWithSnapshots();

>>> graph = session.read_graph_with_properties("<path_to_json_config_file>")
>>> graph.publish_with_snapshots()

1. Get the published graph as shown:
   • JShell
   • Java
   • Python

   opg4j> var graph = session.getGraph("bank_graph")
   graph ==> PgxGraph[name=bank_graph_analytics_fb,N=999,E=4993,created=1664310157103]

   PgxGraph graph = session.getGraph("bank_graph");

   >>> graph = session.get_graph("bank_graph")

2. Build the graph configuration object using a JSON file path as shown:
   • JShell
   • Java
   • Python

   opg4j> var cfg = GraphConfigFactory.forPartitioned().fromFilePath("path_to_json_config_file")
   cfg ==> {"edge_providers":[{"destination_vertex_provider":"Accounts","database_table_name":"BANK_TXNS","name":"Transfers","key_type":"long",
   "props":[{"type":"float","name":"AMOUNT"},{"type":"string","name":"DESCRIPTION"}],"format":"rdbms","source_vertex_provider":"Accounts",
   "source_column":"FROM_ACCT_ID","key_column":"TXN_ID","destination_column":"TO_ACCT_ID","loading":{"create_key_mapping":true}}],
   "loading":{"snapshots_source":"CHANGE_SET"},"name":"bank_graph","vertex_providers":[{"database_table_name":"BANK_ACCOUNTS",
   "key_column":"ID","name":"Accounts","key_type":"integer","props":[{"type":"integer","name":"ID"},{"type":"string","name":"NAME"}],
   "loading":{"create_key_mapping":true},"format":"rdbms"}]}

   PartitionedGraphConfig cfg = GraphConfigFactory.forPartitioned().fromFilePath("path_to_json_config_file");

   >>> from pypgx.api import GraphConfigFactory
   >>> cfg = GraphConfigFactory.for_partitioned().from_file_path("path_to_json_config_file")

   Alternatively, you can also build the graph configuration object using the GraphConfigBuilder API as shown in Loading a Graph by Defining a Graph Configuration Object.
3. Change the data in the database table using the JDBC connection:
   • JShell
   • Java
   • Python

   opg4j> var conn = DriverManager.getConnection(<jdbcUrl>,<username>,<password>)
   conn ==> oracle.jdbc.driver.T4CConnection@60f7261f
   opg4j> var stmt = conn.createStatement()
   stmt ==> oracle.jdbc.driver.OracleStatementWrapper@1a914a00
   opg4j> stmt.executeQuery("UPDATE bank_txns SET amount=9000 WHERE txn_id=3")
   $5 ==> oracle.jdbc.driver.ForwardOnlyResultSet@627d5f99
   opg4j> conn.setAutoCommit(false)
   opg4j> conn.commit()

   Connection conn = DriverManager.getConnection(<jdbcUrl>,<username>,<password>);
   Statement stmt = conn.createStatement();
   stmt.executeQuery("UPDATE bank_txns SET amount=9000 WHERE txn_id=3");
   conn.setAutoCommit(false);
   conn.commit();

   >>> conn = opg4py.pgql.get_connection("graphuser","graphuser", "jdbc:oracle:thin:@localhost:1521/orclpdb").get_jdbc_connection()
   >>> conn.prepareStatement("UPDATE bank_txns SET amount=9000 WHERE txn_id=3").execute()
   False
   >>> conn.commit()

4. Configure the Flashback synchronizer using the graph configuration object and the connection details:
   • JShell
   • Java
   • Python

   opg4j> var synchronizer = new Synchronizer.Builder<FlashbackSynchronizer>().
   ...>      setType(FlashbackSynchronizer.class).
   ...>      setGraph(graph).
   ...>      setConnection(conn).
   ...>      setGraphConfiguration(cfg).
   ...>      build()
   synchronizer ==> oracle.pgx.api.FlashbackSynchronizer@1f122cbb

   Synchronizer synchronizer = new Synchronizer.Builder<FlashbackSynchronizer>()
       .setType(FlashbackSynchronizer.class)
       .setGraph(graph)
       .setConnection(conn)
       .setGraphConfiguration(cfg)
       .build();

   >>> synchronizer = graph.create_synchronizer(synchronizer_class='oracle.pgx.api.FlashbackSynchronizer',
                             connection=conn, graph_config=cfg)

5. Synchronize the published graph as shown:
   • JShell
   • Java
   • Python

   opg4j> graph=synchronizer.sync()
   graph ==> PgxGraph[name=bank_graph,N=999,E=4993,created=1664454171605]

   graph=synchronizer.sync();

   >>> graph = synchronizer.sync()

6. Query the graph to verify the updates to the edge property.
   • JShell
   • Java
   • Python

   opg4j> graph.queryPgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE v1.ID=179 and v2.ID=688").print()

   graph.queryPgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE v1.ID=179 and v2.ID=688").print();

   graph.query_pgql("SELECT e.amount FROM MATCH (v1:Accounts)-[e:Transfers]->(v2:Accounts) WHERE v1.ID=179 and v2.ID=688").print();

   On execution, the preceding example produces the following output:

   +--------+
   | amount |
   +--------+
   | 9000.0 |
   +--------+

1. Set the following two configuration parameters in the conf/pgx.conf file:
   • Set the graph_algorithm_language option to JAVA.
   • Set the java_home_dir option to the path to your Java home (use <system-java-home-dir> to have PGX infer Java home from the system properties).

   {
     "graph_algorithm_language": "JAVA",
     "java_home_dir": "<system-java-home-dir>"
   }

2. Create a session.
   • JShell
   • Java
   • Python

   cd /opt/oracle/graph
   ./bin/opg4j 

   import oracle.pgx.algorithm.*;
   PgxSession session = Pgx.createSession("my-session");

   session = instance.create_session("my-session")

3. Compile a PGX Algorithm. For example:
   • JShell
   • Java
   • Python

   opg4j> var myAlgorithm = session.compileProgram("/path/to/MyAlgorithm.java")
   myAlgorithm ==> CompiledProgram[name=MyAlgorithm]

   import oracle.pgx.algorithm.CompiledProgram;
   CompiledProgram myAlgorithm = session.compileProgram("/path/to/MyAlgorithm.java");

   my_algorithm = session.compile_program("/path/to/MyAlgorithm.java")

4. Run the algorithm. For example:
   • JShell
   • Java
   • Python

   opg4j> var graph =session.readGraphWithProperties("/path/to/bank_graph_analytics.json")
   graph ==> PgxGraph[name=bank_graph_analytics,N=1000,E=5001,created=1633504705054]
   opg4j> var property = graph.createVertexProperty(PropertyType.INTEGER)
   property ==> VertexProperty[name=vertex_prop_integer_9,type=integer,graph=bank_graph_analytics]
   opg4j> myAlgorithm.run(graph, property)
   $6 ==> {
     "success" : true,
     "canceled" : false,
     "exception" : null,
     "returnValue" : 42,
     "executionTimeMs" : 0
   }

   import oracle.pgx.algorithm.VertexProperty;
   PgxGraph graph = session.readGraphWithProperties("/path/to/bank_graph_analytics.json");
   VertexProperty property = graph.createVertexProperty(PropertyType.INTEGER);
   myAlgorithm.run(graph, property);

   graph = session.read_graph_with_properties("/path/to/bank_graph_analytics.json")
   property = graph.create_vertex_property("integer")
   my_algorithm.run(graph, property)
   {'success': True, 'canceled': False, 'exception': None, 'return_value': 42, 'execution_time(ms)': 1}

This section explains a few special considerations when you enable auto-refresh for graphs in the graph server (PGX):

• If you call graph.destroy(), auto-refresh does not immediately stop.

  It only stops once the graph is actually freed from the server memory.

  This happens when all the following conditions are true:

  1. No other session is referencing that graph.
  2. PGX consumes more than release_memory_threshold memory.

     release_memory_threshold is a pgx.conf option that defaults to 85% of available system memory.

  3. The PGX "garbage collector" has been run.

     memory_cleanup_interval is a pgx.conf option which defaults to once every 10 minutes.

• If you configure the graph to be loaded with auto-refresh, you cannot omit the jdbc url, username and keystore parameters from the graph configuration file since auto-refreshed graphs are not "user bound". You cannot obtain the connection settings from the user who initiated it.