Add benchmark results and summaries for stackoverflow-large dataset

- Created README.md files for benchmark results on 21-Mar-2026 and 24-Mar-2026, detailing OLTP and OLAP performance metrics for the stackoverflow-large dataset.
- Added summary markdown files for OLTP and OLAP benchmarks, including detailed per-operation metrics and cross-DB hash checks.
- Updated scripts for running benchmarks to increase thread count and memory limits for improved performance in OLTP and graph OLAP tests.
- Noted improvements in index times and query performance, particularly for graph OLAP queries.

Author: tae898

bindings/python/docs/examples/16_import_database_vs_transactional_graph_ingest.md

@@ -20,19 +20,21 @@ Example 16 is the graph-ingest comparison harness for embedded Python.
 ## Current Repository Guidance
 
 - This example exists because ingest winners are workload-dependent
-- Current results show that `GraphBatch` is the best bulk graph ingest option in this
-  repository
+- Current results for the 5M/5M benchmark shape show that `IMPORT DATABASE` with
+  `--parallel 4` is the fastest option in this repository
+- `GraphBatch` remains competitive and is the strongest non-import path in the current
+  snapshot
 - Async SQL is still useful as a baseline comparison, but it is not the recommended
   bulk graph ingest path here
-- SQL `IMPORT DATABASE` remains available, but it is not the preferred graph bulk-load
-  path from Python
+- SQL `IMPORT DATABASE` is now a preferred bulk graph load path for this benchmark shape
+  when parallel import is enabled
 
 ## Recent Benchmark Snapshot
 
 For this shape:
 
-- `vertices=2,000,000`
-- `edges=2,000,000`
+- `vertices=5,000,000`
+- `edges=5,000,000`
 - `vertex-int-props=10`
 - `vertex-str-props=10`
 - `edge-int-props=10`
@@ -43,16 +45,14 @@ For this shape:
 
 Measured times:
 
-- `Transactional` (`single-threaded`): `253.615s`
-- `GraphBatch` (`--parallel 1`): `177.150s`
-- `GraphBatch` (`--parallel 4`): `187.681s`
-- `GraphBatch` (`--parallel 8`): `134.836s`
-- `Async SQL` (`--async-parallel 1`): `230.192s`
-- `IMPORT DATABASE` (`--parallel 1`): `444.357s`
-- `IMPORT DATABASE` (`--parallel 4`): `336.206s`
+- `Transactional` (`1 thread`): `575.078s`
+- `Async SQL` (`--async-parallel 1`): `701.080s`
+- `GraphBatch` (`--parallel 1`): `507.983s`
+- `GraphBatch` (`--parallel 4`): `359.672s`
+- `IMPORT DATABASE` (`--parallel 1`): `453.481s`
+- `IMPORT DATABASE` (`--parallel 4`): `275.325s`
 
-This is why the broader graph example set now treats `GraphBatch` as the default bulk
-graph ingest path from Python.
+All four methods produced the same final graph output for this benchmark shape.
 
 ## Run
 

bindings/python/examples/07_stackoverflow_tables_oltp.py

@@ -653,10 +653,11 @@ def configure_arcadedb_async_loader(db, batch_size: int, parallelism: int = 1):
     return async_exec
 
 
-def reset_arcadedb_async_loader(db):
-    db.async_executor().wait_completion()
+def reset_arcadedb_async_loader(db, async_exec):
+    async_exec.wait_completion()
+    async_exec.close()
     db.set_read_your_writes(True)
-    db.async_executor().set_transaction_use_wal(True)
+    async_exec.set_transaction_use_wal(True)
 
 
 def insert_batch_sqlite(conn, table: Dict[str, Any], rows: List[Dict[str, Any]]):
@@ -792,7 +793,7 @@ def on_error(exc: Exception):
 
         return id_pools, next_ids, time.time() - start
     finally:
-        reset_arcadedb_async_loader(db)
+        reset_arcadedb_async_loader(db, async_exec)
 
 
 def load_tables(

bindings/python/examples/08_stackoverflow_tables_olap.py

@@ -627,10 +627,11 @@ def configure_arcadedb_async_loader(db, batch_size: int, parallelism: int = 1):
     return async_exec
 
 
-def reset_arcadedb_async_loader(db):
-    db.async_executor().wait_completion()
+def reset_arcadedb_async_loader(db, async_exec):
+    async_exec.wait_completion()
+    async_exec.close()
     db.set_read_your_writes(True)
-    db.async_executor().set_transaction_use_wal(True)
+    async_exec.set_transaction_use_wal(True)
 
 
 def sqlite_type(field_type: str) -> str:
@@ -1587,7 +1588,7 @@ def on_error(exc: Exception):
             print(f"     {count:,} rows in {elapsed:.2f}s")
         load_total = time.time() - load_start
     finally:
-        reset_arcadedb_async_loader(db)
+        reset_arcadedb_async_loader(db, async_exec)
 
     load_counts_start = time.time()
     table_counts_after_load = count_table_rows_arcadedb(db)

bindings/python/examples/13_stackoverflow_hybrid_queries.py

@@ -495,10 +495,11 @@ def configure_arcadedb_async_loader(db, batch_size: int, parallelism: int = 1):
     return async_exec
 
 
-def reset_arcadedb_async_loader(db):
-    db.async_executor().wait_completion()
+def reset_arcadedb_async_loader(db, async_exec):
+    async_exec.wait_completion()
+    async_exec.close()
     db.set_read_your_writes(True)
-    db.async_executor().set_transaction_use_wal(True)
+    async_exec.set_transaction_use_wal(True)
 
 
 def load_table_arcadedb_async(
@@ -1721,7 +1722,7 @@ def on_error(exc: Exception):
                 )
             load_time = time.time() - load_start
         finally:
-            reset_arcadedb_async_loader(db)
+            reset_arcadedb_async_loader(db, async_exec)
 
         index_time = create_indexes_with_retry(
             db,

bindings/python/examples/16_import_database_vs_transactional_graph_ingest.py

@@ -11,10 +11,10 @@
 
 Goal: compare graph ingest speed for equivalent synthetic data shape.
 
-Observed benchmark result (2026-03-19):
+Observed benchmark result (2026-03-24):
 For:
-- vertices=2,000,000
-- edges=2,000,000
+- vertices=5,000,000
+- edges=5,000,000
 - vertex-int-props=10
 - vertex-str-props=10
 - edge-int-props=10
@@ -24,13 +24,15 @@
 - heap-size=8g
 
 Measured ingest times:
-- Transactional (`single-threaded`): 253.615s
-- GraphBatch (`single-threaded`, `--parallel 1`): 177.150s
-- GraphBatch (`4 threads`, `--parallel 4`): 187.681s
-- GraphBatch (`8 threads`, `--parallel 8`): 134.836s
-- Async SQL (`single-threaded`, `--async-parallel 1`): 230.192s
-- IMPORT DATABASE (`single-threaded`, `--parallel 1`): 444.357s
-- IMPORT DATABASE (`4 threads`, `--parallel 4`): 336.206s
+- Transactional (`single-threaded`, `1 thread`): 575.078s
+- Async SQL (`single-threaded`, `--async-parallel 1`): 701.080s
+- GraphBatch (`single-threaded`, `--parallel 1`): 507.983s
+- GraphBatch (`4 threads`, `--parallel 4`): 359.672s
+- IMPORT DATABASE (`single-threaded`, `--parallel 1`): 453.481s
+- IMPORT DATABASE (`4 threads`, `--parallel 4`): 275.325s
+
+Logical parity:
+- All four methods produced the same final graph output
 
 Known limitation:
 Current `IMPORT DATABASE` behavior can vary by import path and data shape. In some