Kùzu vs SQLite Recursive CTEs

Embedded Graphs in Node.js: Comparing Kùzu and SQLite Recursive CTEs

SitePoint TeamPublished inProgramming·Databases·
September 23, 2026

The AI briefing for Developers

Stay up to date with AI tools, model releases, and developer workflows that matter.

Weekly. Free. One click to leave.

SitePoint Premium
Stay Relevant and Grow Your Career in Tech

• Premium Results
• Publish articles on SitePoint
• Daily curated jobs
• Learning Paths
• Discounts to dev tools

7 Day Free Trial. Cancel Anytime.

Connected and hierarchical data appears in nearly every non-tritural comparison of Kùzu (a native graph engine with Cypher, accessed and SQLite recursive CTEs (a relational workaround accessed, both running embedded in a Node.js/TypeScript process

Kùzu vs SQLite Recursive CTEs Comparison

Table of Contents

Why Embedded Graph Storage Matters for Node.js

Connected and hierarchical data appears in nearly every non-trivial application. Permission systems, org charts, social features, dependency resolution, recommendation engines: all of these are fundamentally graph problems. Yet spinning up a dedicated Neo4j or ArangoDB server introduces operational overhead that is difficult to justify when the graph workload is one feature among many. For developers looking for an embedded graph database in Node.js, two practical paths exist today that avoid the burden of a separate daemon entirely.

An embedded database runs in-process. There is no network hop, no connection pooling, no separate service to monitor. The database engine lives inside the application process, reads and writes to local files (or memory), and exposes its API through direct function calls. SQLite popularized this model for relational data. Kùzu now deploys as simply as SQLite does for graph data, with native Cypher query support.

This article provides a side-by-side architectural comparison of Kùzu (a native graph engine with Cypher, accessed and SQLite recursive CTEs (a relational workaround accessed, both running embedded in a Node.js/TypeScript process. Every query pattern is demonstrated with working code

Embedded Graph Options in Node.js

What Qualifies as “Embedded”?

An embedded database in this context has three properties: zero-server execution (no daemon, no background process, no port binding), in-process operation where your code calls the database directly with no network round-trip, and file-based or in-memory persistence with no network storage dependency.

Kùzu at a Glance

Kùzu is a column-store graph database licensed under Apache 2.0. It implements the OpenCypher query language natively, meaning the engine handles variable-length paths and undirected traversals as built-in operations rather than bolted-on abstractions. The kuzu npm package provides Node.js bindings that compile as a native addon.

SQLite + Recursive CTEs at a Glance

SQLite is the most widely deployed database in existence, and better-sqlite3 is a widely used synchronous binding for Node.js. The WITH RECURSIVE construct, available since SQLite 3.8.3 (2014), enables graph traversal over standard relational tables. This is not a graph engine. It is a workaround, and it carries known limitations around cycle detection, bidirectional traversal, and query verbosity.

An embedded database runs in-process. There is no network hop, no connection pooling, no separate service to monitor.

Setting Up the Project

Prerequisites and Tooling

The examples below target Node.js 24.0.0 or later and TypeScript 5.x, using npm for package management. The --experimental-strip-types flag is experimental; pin your Node.js version and re-test after upgrades. Both kuzu and better-sqlite3 ship as native addons, so a working C++ toolchain is required (Xcode CLI tools on macOS, build-essential on Debian/Ubuntu, or Visual Studio Build Tools on Windows) unless prebuilt binaries are available for your platform. Check the respective package documentation for current prebuilt binary support.

Note on ESM imports: When using “module”: “Node16” with “type”: “module”, all relative TypeScript imports must use explicit .js extensions (e.g., ./seed-data.js for a seed-data.ts. Omitting the extension will produce ERR_MODULE_NOT_FOUND at runtime

Verify package versions before installing: Run npm show kuzu versions and npm show better-sqlite3 versions to confirm the version ranges below are available. Update the ranges if newer versions have been published.

Verify the kuzu ESM export shape before running: Run node --input-type=module -e "import * as k from 'kuzu'; console.log(Object.keys(k))" after installing. If Database and Connection are not listed as exports, consult the kuzu package documentation for the correct import pattern for your installed version.

{"name":"embedded-graph-comparison","version":"1.0.0","type":"module","scripts":{"build":"tsc","start":"node --experimental-strip-types src/main.ts"},"dependencies":{"kuzu":"0.10.0","better-sqlite3":"11.0.0"},"devDependencies":{"@types/better-sqlite3":"^7.6.0","typescript":"^5.5.0"}}

{"compilerOptions":{"target":"ES2022","module":"Node16","moduleResolution":"Node16","outDir":"dist","strict":true,"esModuleInterop":true},"include":["src"]}

npminstall

Shared Data Model: A Bidirectional Social Graph

The domain throughout this article is a small social graph: Person nodes connected by FOLLOWS relationships. Bidirectional relationships stress-test both approaches differently. Kùzu can match undirected patterns natively. SQLite must UNION forward and reverse edge scans inside a recursive CTE, doubling the search space.

exportinterfacePerson{id:number;name:string;}exportinterfaceEdge{fromId:number;toId:number;}exportconst people: Person[]=[{ id:1, name:"Alice"},{ id:2, name:"Bob"},{ id:3, name:"Carol"},{ id:4, name:"Dave"},{ id:5, name:"Eve"},{ id:6, name:"Frank"},{ id:7, name:"Grace"},{ id:8, name:"Heidi"},];exportconst follows: Edge[]=[{ fromId:1, toId:2},{ fromId:1, toId:3},{ fromId:2, toId:4},{ fromId:3, toId:4},{ fromId:3, toId:5},{ fromId:4, toId:6},{ fromId:5, toId:6},{ fromId:5, toId:7},{ fromId:6, toId:8},{ fromId:7, toId:8},{ fromId:8, toId:1},{ fromId:2, toId:5},];

This seed data contains a cycle (Heidi follows Alice, closing the loop), which forces both implementations to handle cycle detection.

Modeling and Querying with Kùzu (Cypher)

Creating the Database, Node Tables, and Relationship Tables

Kùzu enforces a typed schema. Node tables and relationship tables are declared separately, with explicit property definitions. The Database constructor takes a filesystem path; the Connection object executes Cypher statements against that database.

Re-run safety: If the database directory already exists from a prior run, delete it before re-running setup to avoid “table already exists” errors. The code below handles this automatically, but only for paths under the project’s ./kuzu-db directory.

Important: The code below uses string interpolation with sanitized values as a fallback. Verify that conn.query(cypher, params) supports a two-argument parameterized form in your installed version of kuzu before switching to parameterized queries. See the verification command in the note below the code.

⚠ WARNING: The rmSync call below performs a recursive delete. The code includes a safety guard that restricts deletion to paths under the project’s ./kuzu-db prefix. Never pass an unvalidated or user-supplied path as dbPath.

import*as kuzu from"kuzu";import fs from"node:fs";import path from"node:path";import{ people, follows }from"./seed-data.js";if(typeof(kuzu asany).Database !=="function"){thrownewError("kuzu.Database is not a constructor. Check kuzu ESM export shape for this version. "+"Run: node --input-type=module -e "import * as k from 'kuzu'; console.log(Object.keys(k))"");}constSAFE_DB_PREFIX= path.resolve("./kuzu-db");exportasyncfunctionsetupKuzu(dbPath:string):Promise<{ conn: kuzu.Connection; db: kuzu.Database }>{const resolvedPath = path.resolve(dbPath);if(!resolvedPath.startsWith(SAFE_DB_PREFIX)){thrownewError(`Refusing to delete unsafe path:${resolvedPath}. Path must be under${SAFE_DB_PREFIX}`);}fs.rmSync(resolvedPath,{ recursive:true, force:true});const db =new(kuzu asany).Database(dbPath);const conn =new(kuzu asany).Connection(db);await conn.query("CREATE NODE TABLE Person(id INT64, name STRING, PRIMARY KEY (id))");await conn.query("CREATE REL TABLE FOLLOWS(FROM Person TO Person)");for(const p of people){const safeName = p.name.replace(/\/g,"\\").replace(/'/g,"\'");await conn.query(`CREATE (p:Person {id:${p.id}, name: '${safeName}'})`);}for(const e of follows){await conn.query(`MATCH (a:Person {id:${e.fromId}}), (b:Person {id:${e.toId}}) CREATE (a)-[:FOLLOWS]->(b)`);}return{ conn, db };}

Verify parameterized query support: After installing kuzu, run the following to check whether the two-argument conn.query() form works:

node --input-type=module -e"import * as k from 'kuzu';import fs from 'fs';fs.rmSync('./test-kuzu-param', { recursive: true, force: true });const db = new k.Database('./test-kuzu-param');const conn = new k.Connection(db);await conn.query('CREATE NODE TABLE T(id INT64, PRIMARY KEY(id))');await conn.query('CREATE (n:T {id: $id})', { id: 42 });const res = await conn.query('MATCH (n:T) RETURN n.id AS id');console.log('param test:', await res.getAll());await conn.close(); db.close();fs.rmSync('./test-kuzu-param', { recursive: true, force: true });"

If this prints param test: [ { id: 42 } ] (or similar), you can safely switch the inserts above to use parameterized queries.

The CREATE NODE TABLE and CREATE REL TABLE statements are Kùzu’s Cypher DDL extensions. Relationship tables specify directionality at definition time (FROM Person TO Person), but queries can match them in either direction.

Single-Hop and Multi-Hop Queries

Cypher’s pattern matching syntax makes traversal depth explicit and concise. Cypher’s variable-length path syntax (*1..4) is the key differentiator: it replaces the entire recursive CTE machinery that SQLite requires.

import*as kuzu from"kuzu";asyncfunctionsafeGetAll(result:any):Promise<any[]>{if(!result ||typeof result.getAll !=="function"){thrownewError("Invalid QueryResult: getAll() is not available on the returned object");}const rows =await result.getAll();if(!Array.isArray(rows)){thrownewError(`Unexpected getAll() return type:${typeof rows}`);}return rows;}exportasyncfunctionkuzuQueries(conn: kuzu.Connection){const oneHop =await conn.query(`MATCH (a:Person {name: 'Alice'})-[:FOLLOWS]->(b:Person) RETURN b.name AS follower ORDER BY follower`);console.log("Kùzu 1-hop followers of Alice:");console.log((awaitsafeGetAll(oneHop)).map((r:any)=> r.follower));const twoHop =await conn.query(`MATCH (a:Person {name: 'Alice'})-[:FOLLOWS]->()-[:FOLLOWS]->(fof:Person)WHERE fof <> aRETURN DISTINCT fof.name AS fof ORDER BY fof`);console.log("Kùzu 2-hop(friends-of-friends) from Alice:");console.log((awaitsafeGetAll(twoHop)).map((r:any)=> r.fof));const varLen =await conn.query(`MATCH (a:Person {name: 'Alice'})-[:FOLLOWS*1..4]->(reachable:Person)WHERE reachable <> aRETURN DISTINCT reachable.name AS name ORDER BY name`);console.log("Kùzu variable-length(1..4 hops) from Alice:");console.log((awaitsafeGetAll(varLen)).map((r:any)=> r.name));}

Three queries, three levels of complexity, all expressed as single MATCH patterns. The variable-length query *1..4 handles cycle avoidance internally; Kùzu avoids revisiting nodes on the current path, preventing infinite loops. DISTINCT is still required to deduplicate nodes reachable

Bidirectional Traversal

Cypher supports undirected relationship patterns using ()-[]-() without the arrow. This matches the edge in both directions without requiring the developer to duplicate data or construct UNION queries.

import*as kuzu from"kuzu";asyncfunctionsafeGetAll(result:any):Promise<any[]>{if(!result ||typeof result.getAll !=="function"){thrownewError("Invalid QueryResult: getAll() is not available on the returned object");}const rows =await result.getAll();if(!Array.isArray(rows)){thrownewError(`Unexpected getAll() return type:${typeof rows}`);}return rows;}exportasyncfunctionkuzuBidirectional(conn: kuzu.Connection){const result =await conn.query(`MATCH (a:Person {name: 'Alice'})-[:FOLLOWS*1..3]-(connected:Person)WHERE connected <> aRETURN DISTINCT connected.name AS name ORDER BY name`);console.log("Kùzu bidirectional (1..3 hops) from Alice:");console.log((awaitsafeGetAll(result)).map((r:any)=> r.name));}

Removing the arrow from -[:FOLLOWS*1..3]- converts the query from directed to bidirectional. No schema changes, no edge duplication, no additional query complexity.

Cypher’s variable-length path syntax (*1..4) is the key differentiator: it replaces the entire recursive CTE machinery that SQLite requires.

Modeling and Querying with SQLite Recursive CTEs

Relational Schema Design for Graph Data

Mapping graph data onto relational tables requires a persons table for nodes and a follows table for edges. Index both columns of the edge table; without indexes, every recursive step full-scans the table.

import Database from"better-sqlite3";import{ people, follows }from"./seed-data.js";exportfunctionsetupSQLite(dbPath:string): Database.Database {const db =newDatabase(dbPath);db.exec(`CREATE TABLE IF NOT EXISTS persons (id INTEGER PRIMARY KEY,name TEXT NOT NULL);CREATE TABLE IF NOT EXISTS follows (from_id INTEGER NOT NULL REFERENCES persons(id),to_id INTEGER NOT NULL REFERENCES persons(id),PRIMARY KEY (from_id, to_id));CREATE INDEX IF NOT EXISTS idx_follows_to ON follows(to_id);`);const insertPerson = db.prepare("INSERT INTO persons (id, name) VALUES (?, ?)");const insertFollow = db.prepare("INSERT INTO follows (from_id, to_id) VALUES (?, ?)");const tx = db.transaction(()=>{for(const p of people) insertPerson.run(p.id, p.name);for(const e of follows) insertFollow.run(e.fromId, e.toId);});tx();return db;}

The better-sqlite3 transaction wrapper ensures the seed data inserts atomically. Note the explicit index on to_id; the composite primary key already covers lookups by from_id.

Recursive CTE for Multi-Hop Traversal

A WITH RECURSIVE CTE has three components: the anchor member (the starting row), the recursive member (the join that extends the path), and a termination condition. Cycle detection is not automatic. Without it, the query loops indefinitely on cyclic data.

The implementation below uses a comma-delimited string path with sentinel-padded INSTR checks for cycle detection. This approach avoids the json_each correlated subquery (which executes O(depth x path_length) work per recursive row) and is compatible with all SQLite versions. The sentinel commas (',' || r.path || ',' compared against ',' || p2.id || ',') prevent false-positive substring matches for multi-digit IDs.

import Database from"better-sqlite3";exportfunctionsqliteVariableDepth(db: Database.Database, startName:string, maxDepth:number){const stmt = db.prepare(`WITH RECURSIVE reachable(id, name, depth, path) AS (-- Anchor: start node, path is the start ID as textSELECT p.id, p.name, 0, CAST(p.id AS TEXT)FROM persons pWHERE p.name = ?UNION ALL-- Recursive: follow edges, check depth and cycle via sentinel-padded INSTRSELECT p2.id, p2.name, r.depth + 1,r.path || ',' || p2.idFROM reachable rJOIN follows f ON f.from_id = r.idJOIN persons p2 ON p2.id = f.to_idWHERE r.depth < ?AND INSTR(',' || r.path || ',', ',' || p2.id || ',') = 0)SELECT DISTINCT name FROM reachable WHERE depth > 0 ORDER BY name`);const rows = stmt.all(startName, maxDepth);console.log(`SQLite variable-depth (1..${maxDepth}hops) from${startName}:`);console.log(rows.map((r:any)=> r.name));}

The sentinel-padded INSTR check (',' || r.path || ',' searched for ',' || p2.id || ',') ensures that ID 1 does not falsely match inside IDs like 10 or 21. This runs in O(path_length) per row rather than the O(depth x path_length) of a correlated json_each subquery.

Bidirectional Traversal in SQL

Making the recursive CTE bidirectional requires a UNION inside the recursive member that queries the follows table in both directions. This doubles the number of rows examined at each recursion level.

import Database from"better-sqlite3";exportfunctionsqliteBidirectional(db: Database.Database, startName:string, maxDepth:number){const stmt = db.prepare(`WITH RECURSIVE reachable(id, name, depth, path) AS (SELECT p.id, p.name, 0, CAST(p.id AS TEXT)FROM persons pWHERE p.name = ?UNION ALLSELECT p2.id, p2.name, r.depth + 1,r.path || ',' || p2.idFROM reachable rJOIN (SELECT from_id AS src, to_id AS dst FROM followsUNION ALLSELECT to_id AS src, from_id AS dst FROM follows) edges ON edges.src = r.idJOIN persons p2 ON p2.id = edges.dstWHERE r.depth < ?AND INSTR(',' || r.path || ',', ',' || p2.id || ',') = 0)SELECT DISTINCT name FROM reachable WHERE depth > 0 ORDER BY name`);const rows = stmt.all(startName, maxDepth);console.log(`SQLite bidirectional (1..${maxDepth}hops) from${startName}:`);console.log(rows.map((r:any)=> r.name));}

Compare this directly to the Kùzu bidirectional query: removing an arrow character versus adding an entire subquery with UNION ALL. The ergonomic gap is not subtle.

Side-by-Side Comparison

Query Syntax and Readability

Performance Characteristics

Architecturally, Kùzu’s design, as documented by its authors, stores relationships in adjacency lists. Traversal from a given node follows direct pointers rather than performing index lookups. SQLite, by contrast, relies on B-tree index scans for each join in the recursive step. On the 8-node seed dataset used here, both approaches return results in sub-millisecond timescales, and the difference is negligible.

The gap widens with graph depth and fan-out. A recursive CTE that reaches depth 6 on a graph with average fan-out of 10 requires O(fan-out^depth) B-tree index probes in the worst case; Kùzu’s adjacency-list storage avoids this cost structurally. Kùzu’s columnar compression also reduces I/O when scanning properties across many nodes.

The practical takeaway: for graphs under roughly 5,000 nodes with traversals of three hops or less, SQLite’s recursive CTEs work fine. Beyond that, benchmark your own dataset; the crossover point depends on fan-out, depth, and query patterns.

Developer Experience and Ecosystem

Query results from better-sqlite3 arrive as plain JavaScript objects with string keys, matching the SELECT aliases directly. Kùzu’s result API requires calling getAll() to retrieve rows, returning objects with property names matching the Cypher RETURN aliases. Neither provides compile-time type safety out of the box; both require manual type assertions or wrapper functions in TypeScript.

SQLite benefits from decades of ecosystem maturity: documentation dating back to 2004, tooling on every platform, and battle-tested deployment patterns in Electron, serverless functions, and Docker containers. Kùzu’s tooling is comparatively young. The native addon compiles cleanly on major platforms, but Alpine Linux musl builds and ARM architectures may fail to compile; check the Kùzu GitHub issue tracker for workarounds before targeting those environments. Bundle size is also a consideration: compare installed sizes with du -sh node_modules/kuzu vs du -sh node_modules/better-sqlite3 to decide whether the difference matters for your deployment target.

When to Choose Which

Choose SQLite Recursive CTEs When…

Graph queries are a minor feature rather than the core workload, and SQLite is already in the stack (common in Electron apps or projects already using better-sqlite3). The dataset is small with traversals of three hops or fewer. Minimizing dependencies matters more than query ergonomics, and adding another native addon is undesirable.

Choose Kùzu When…

Graph traversal is a primary access pattern, not an occasional query. Variable-depth and bidirectional queries appear frequently, and the data model is relationship-dense or evolving. Query readability matters for team velocity, and you cannot afford the correctness risks of manual cycle detection. The dataset will grow beyond a few thousand nodes, and traversal depth will increase over time.

Running the Project

To assemble and run the project, create thethem together:

import{ setupKuzu }from"./kuzu-setup.js";import{ kuzuQueries }from"./kuzu-queries.js";import{ kuzuBidirectional }from"./kuzu-bidirectional.js";import{ setupSQLite }from"./sqlite-setup.js";import{ sqliteVariableDepth }from"./sqlite-queries.js";import{ sqliteBidirectional }from"./sqlite-bidirectional.js";asyncfunctionmain(){let kuzuDb:any;let sqliteDb:any;try{const{ conn, db }=awaitsetupKuzu("./kuzu-db");kuzuDb = db;awaitkuzuQueries(conn);awaitkuzuBidirectional(conn);if(typeof conn.close ==="function")await conn.close();sqliteDb =setupSQLite(":memory:");sqliteVariableDepth(sqliteDb,"Alice",4);sqliteBidirectional(sqliteDb,"Alice",3);}finally{if(sqliteDb &&typeof sqliteDb.close ==="function") sqliteDb.close();if(kuzuDb &&typeof kuzuDb.close ==="function") kuzuDb.close();}}main().catch((e)=>{console.error(e);process.exit(1);});

npm start

This executes node --experimental-strip-types src/main.ts as defined in the package.json start script.

Expected output (result ordering is deterministic here because all queries include ORDER BY):

Kùzu 1-hop followers of Alice:['Bob', 'Carol']Kùzu 2-hop (friends-of-friends) from Alice:['Dave', 'Eve']Kùzu variable-length (1..4 hops) from Alice:['Bob', 'Carol', 'Dave', 'Eve', 'Frank', 'Grace', 'Heidi']Kùzu bidirectional (1..3 hops) from Alice:['Bob', 'Carol', 'Dave', 'Eve', 'Frank', 'Grace', 'Heidi']SQLite variable-depth (1..4 hops) from Alice:['Bob', 'Carol', 'Dave', 'Eve', 'Frank', 'Grace', 'Heidi']SQLite bidirectional (1..3 hops) from Alice:['Bob', 'Carol', 'Dave', 'Eve', 'Frank', 'Grace', 'Heidi']

Both engines produce equivalent result sets against the same seed data.

Embedded Graphs as a Pragmatic Middle Ground

Embedded graph storage occupies a practical space between forcing all connected data queries through a general-purpose relational database and operating a dedicated graph server. SQLite recursive CTEs are a capable stopgap. They work, they are well-understood, and they require no new dependencies for teams already using better-sqlite3. But they hit ergonomic walls as graph complexity grows: manual cycle detection, verbose bidirectional traversal, and structural limitations in the B-tree storage model.

Kùzu brings genuine graph semantics into the same in-process deployment model that developers already trust with SQLite. Native Cypher support, automatic per-path cycle detection, variable-length path syntax, and adjacency-list storage are not incremental improvements over recursive CTEs. They are a fundamentally different approach to the problem, made accessible without the operational cost of a separate server.

Start with SQLite if graph queries are a small part of your workload today. Migrate to Kùzu when your CTE cycle-detection code becomes a maintenance burden or your traversal depth outgrows what B-tree index probes can handle efficiently.

Sharing our passion for building incredible internet things.