Upgrade Graphina to version 0.4.0-alpha.5 (#24)

Author: habedi

.github/workflows/web.yml

@@ -42,11 +42,24 @@ jobs:
           pattern: onager-${{ env.DUCKDB_VERSION }}-extension-wasm_*
           path: wasm-extensions
 
+      - name: Vendor DuckDB-Wasm
+        working-directory: web/vendor-src
+        run: |
+          set -euo pipefail
+          npm ci
+          npm run bundle
+
       - name: Assemble playground tree
         run: |
           set -euo pipefail
           mkdir -p playground
           cp -R web/. playground/
+          rm -rf playground/vendor-src
+          mkdir -p playground/vendor/duckdb-wasm
+          cp web/vendor-src/out/duckdb-browser.mjs \
+            web/vendor-src/node_modules/@duckdb/duckdb-wasm/dist/duckdb-browser-mvp.worker.js \
+            web/vendor-src/node_modules/@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm \
+            playground/vendor/duckdb-wasm/
           printf '{"branch": "%s", "commit": "%s"}\n' \
             "${GITHUB_REF_NAME}" "${GITHUB_SHA:0:5}" > playground/build-info.json
           for platform in wasm_eh wasm_mvp; do

.gitignore

@@ -101,3 +101,7 @@ bug*.md
 .codex
 .antigravitycli/
 .agents/
+
+# Playground vendor build (web/vendor-src)
+web/vendor-src/node_modules/
+web/vendor-src/out/

docs/guide/community.md

@@ -112,9 +112,8 @@ order by label, node_id;
 ```
 
 !!! note "Determinism"
-    The seed controls the order in which nodes update their labels, but the underlying
-    implementation currently breaks label ties nondeterministically, so seeded runs can
-    still differ between sessions.
+    The seed controls the order in which nodes update their labels, and label ties break
+    deterministically, so runs with the same seed produce the same partition.
 
 ---
 
@@ -173,9 +172,8 @@ Optional parameters:
 - `seed`: Random seed for the node visit order
 
 !!! note "Determinism"
-    As with label propagation, the seed controls the node visit order, but the underlying
-    implementation currently breaks ties nondeterministically, so seeded runs can still
-    differ between sessions.
+    As with label propagation, the seed controls the node visit order, and ties break
+    deterministically, so runs with the same seed produce the same partition.
 
 ---
 

docs/guide/parallel.md

@@ -51,8 +51,14 @@ Optional parameters:
 - `tolerance` (default 1e-6): Convergence threshold for early termination
 - `directed` (default false): Treat each edge as one-way instead of undirected
 
-The parallel implementation treats every edge as having weight 1.0.
-For weighted PageRank, use `onager_ctr_pagerank` with a third `double` column.
+Like `onager_ctr_pagerank`, the parallel version accepts an optional third `double` column with edge weights.
+When the column is absent, every edge gets weight 1.0.
+
+```sql
+select node_id, round(rank, 4) as rank
+from onager_par_pagerank((select src, dst, (src + dst)::double as weight from edges))
+order by rank desc;
+```
 
 ---
 

docs/reference/input-formats.md

@@ -47,7 +47,7 @@ select onager_node_in_degree('social', 1);
     - `onager_apx_tsp`: Traveling salesman approximation
     - `onager_pth_dijkstra`: Shortest paths with nonnegative weights (the weights column is optional)
 
-    `onager_ctr_pagerank` also uses a third `double` column as edge weights when it is present, and falls back to weight 1.0 for every edge when it is absent. `onager_par_pagerank` is unweighted. Weight values must not be NULL or NaN, and PageRank additionally rejects negative weights.
+    `onager_ctr_pagerank` and `onager_par_pagerank` also use a third `double` column as edge weights when it is present, and fall back to weight 1.0 for every edge when it is absent. Weight values must not be NULL or NaN, and PageRank additionally rejects negative weights.
 
     Pass weights like this:
     ```sql

docs/reference/sql-functions.md

@@ -126,7 +126,7 @@ The default is `false` for every function, which treats the input edge list as u
 
 | Function                                   | Returns                | Description                      |
 |--------------------------------------------|------------------------|----------------------------------|
-| `onager_par_pagerank(edges [, damping, iterations, tolerance, directed])` | `node_id, rank`        | Parallel PageRank                |
+| `onager_par_pagerank(edges [+ weights] [, damping, iterations, tolerance, directed])` | `node_id, rank`        | Parallel PageRank                |
 | `onager_par_bfs(edges [, source or sources, directed])` | `[source,] node_id`    | Parallel BFS traversal           |
 | `onager_par_shortest_paths(edges [, source or sources, directed])` | `[source,] node_id, distance` | Parallel shortest paths |
 | `onager_par_components(edges)`             | `node_id, component`   | Parallel connected components    |

external/graphina

@@ -176,4 +176,4 @@ markdown_extensions:
 
 extra_javascript:
   - assets/js/mathjax.js
-  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+  - https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-mml-chtml.js

mkdocs.yml

@@ -20,18 +20,20 @@ struct ParallelPageRankBindData : public TableFunctionData {
   int64_t iterations = 100;
   double tolerance = 1e-6;
   bool directed = false;
+  bool weighted = false;
 };
 struct ParallelPageRankGlobalState : public GlobalTableFunctionState {
   std::mutex input_mutex;
   std::vector<int64_t> src_nodes, dst_nodes, result_nodes;
-  std::vector<double> result_ranks;
+  std::vector<double> weights, result_ranks;
   idx_t output_idx = 0; bool computed = false;
   idx_t MaxThreads() const override { return 1; }
 };
 
 static unique_ptr<FunctionData> ParallelPageRankBind(ClientContext &ctx, TableFunctionBindInput &input, vector<LogicalType> &rt, vector<string> &nm) {
   auto bd = make_uniq<ParallelPageRankBindData>();
   CheckInt64Input(input, "onager_par_pagerank");
+  bd->weighted = input.input_table_types.size() >= 3 && input.input_table_types[2] == LogicalType::DOUBLE;
   for (auto &kv : input.named_parameters) {
     if (kv.first == "damping") bd->damping = GetRequiredParam<double>("onager_par_pagerank", "damping", kv.second);
     if (kv.first == "iterations") bd->iterations = GetNonNegativeParam("onager_par_pagerank", "iterations", kv.second);
@@ -44,22 +46,26 @@ static unique_ptr<FunctionData> ParallelPageRankBind(ClientContext &ctx, TableFu
 }
 static unique_ptr<GlobalTableFunctionState> ParallelPageRankInitGlobal(ClientContext &ctx, TableFunctionInitInput &input) { return make_uniq<ParallelPageRankGlobalState>(); }
 static OperatorResultType ParallelPageRankInOut(ExecutionContext &ctx, TableFunctionInput &data, DataChunk &input, DataChunk &output) {
+  auto &bd = data.bind_data->Cast<ParallelPageRankBindData>();
   auto &gs = data.global_state->Cast<ParallelPageRankGlobalState>();
   std::lock_guard<std::mutex> lock(gs.input_mutex);
-  AppendInt64Edges(input, gs.src_nodes, gs.dst_nodes, "onager_par_pagerank");
+  if (bd.weighted) {
+    AppendWeightedEdges(input, gs.src_nodes, gs.dst_nodes, gs.weights, "onager_par_pagerank");
+  } else {
+    AppendInt64Edges(input, gs.src_nodes, gs.dst_nodes, "onager_par_pagerank");
+  }
   ONAGER_SET_CARDINALITY(output, 0); return OperatorResultType::NEED_MORE_INPUT;
 }
 static OperatorFinalizeResultType ParallelPageRankFinal(ExecutionContext &ctx, TableFunctionInput &data, DataChunk &output) {
   auto &bd = data.bind_data->Cast<ParallelPageRankBindData>(); auto &gs = data.global_state->Cast<ParallelPageRankGlobalState>();
   std::lock_guard<std::mutex> lock(gs.input_mutex);
   if (!gs.computed) {
     if (gs.src_nodes.empty()) { gs.computed = true; ONAGER_SET_CARDINALITY(output, 0); return OperatorFinalizeResultType::FINISHED; }
-    // graphina's pagerank_parallel ignores edge weights, so no weights are passed here.
-    // Weighted PageRank is available through onager_ctr_pagerank.
-    int64_t nc = ::onager::onager_compute_pagerank_parallel(gs.src_nodes.data(), gs.dst_nodes.data(), gs.src_nodes.size(), nullptr, 0, bd.damping, bd.iterations, bd.tolerance, bd.directed, nullptr, nullptr);
+    const double *w = gs.weights.empty() ? nullptr : gs.weights.data();
+    int64_t nc = ::onager::onager_compute_pagerank_parallel(gs.src_nodes.data(), gs.dst_nodes.data(), gs.src_nodes.size(), w, gs.weights.size(), bd.damping, bd.iterations, bd.tolerance, bd.directed, nullptr, nullptr);
     if (nc < 0) throw InvalidInputException("Parallel PageRank failed: " + GetOnagerError());
     gs.result_nodes.resize(nc); gs.result_ranks.resize(nc);
-    int64_t rc = ::onager::onager_compute_pagerank_parallel(gs.src_nodes.data(), gs.dst_nodes.data(), gs.src_nodes.size(), nullptr, 0, bd.damping, bd.iterations, bd.tolerance, bd.directed, gs.result_nodes.data(), gs.result_ranks.data());
+    int64_t rc = ::onager::onager_compute_pagerank_parallel(gs.src_nodes.data(), gs.dst_nodes.data(), gs.src_nodes.size(), w, gs.weights.size(), bd.damping, bd.iterations, bd.tolerance, bd.directed, gs.result_nodes.data(), gs.result_ranks.data());
     if (rc != nc) throw InvalidInputException("Parallel PageRank failed: " + GetOnagerError());
     gs.computed = true;
   }