chore: bump version to 0.2.0 and update documentation

Author: Dylan Storey

bindings/python/src/graphqlite/__init__.py

@@ -8,7 +8,7 @@
 from .utils import escape_string, sanitize_rel_type, CYPHER_RESERVED
 from ._platform import get_loadable_path
 
-__version__ = "0.2.0rc2"
+__version__ = "0.2.0"
 __all__ = [
     "Connection", "connect", "wrap", "load", "loadable_path",
     "Graph", "graph", "GraphManager", "graphs",

bindings/rust/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "graphqlite"
-version = "0.2.0-rc.2"
+version = "0.2.0"
 edition = "2021"
 description = "SQLite extension for graph queries using Cypher"
 license = "MIT"

bindings/rust/Cargo.toml

@@ -15,7 +15,7 @@ This creates `build/gqlite`.
 ## Usage
 
 ```bash
-# Interactive mode with default database
+# Interactive mode with default database (graphqlite.db)
 ./build/gqlite
 
 # Specify a database file

docs/src/how-to/cli.md

@@ -7,7 +7,7 @@ pip install graphqlite
 ```
 
 This installs pre-built binaries for:
-- Linux (x86_64)
+- Linux (x86_64, aarch64)
 - macOS (arm64, x86_64)
 - Windows (x86_64)
 
@@ -17,7 +17,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-graphqlite = "0.1"
+graphqlite = "0.2"
 ```
 
 ## From Source

docs/src/how-to/installation.md

@@ -69,6 +69,7 @@ Detects communities by propagating labels through the network.
 ```cypher
 RETURN labelPropagation()
 RETURN labelPropagation(10)  -- max iterations
+RETURN communities()         -- alias
 ```
 
 **Returns**: `[{"node_id": int, "user_id": string, "community": int}, ...]`

docs/src/reference/algorithms.md

@@ -12,6 +12,29 @@ MATCH (a)-[:KNOWS]->(b) RETURN a, b
 MATCH (n:Person {name: 'Alice'}) RETURN n
 ```
 
+### Shortest Path Patterns
+
+Find shortest paths between nodes:
+
+```cypher
+// Find a single shortest path
+MATCH p = shortestPath((a:Person {name: 'Alice'})-[*]-(b:Person {name: 'Bob'}))
+RETURN p, length(p)
+
+// Find all shortest paths (all paths with minimum length)
+MATCH p = allShortestPaths((a:Person)-[*]-(b:Person))
+WHERE a.name = 'Alice' AND b.name = 'Bob'
+RETURN p
+
+// With relationship type filter
+MATCH p = shortestPath((a)-[:KNOWS*]->(b))
+RETURN nodes(p), relationships(p)
+
+// With length constraints
+MATCH p = shortestPath((a)-[*..10]->(b))
+RETURN p
+```
+
 ### OPTIONAL MATCH
 
 Like MATCH, but returns NULL for non-matches (left join semantics):
@@ -137,6 +160,67 @@ MATCH p = (start)-[*]->(end)
 FOREACH (n IN nodes(p) | SET n.visited = true)
 ```
 
+### LOAD CSV
+
+Import data from CSV files:
+
+```cypher
+// With headers (access columns by name)
+LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
+CREATE (n:Person {name: row.name, age: toInteger(row.age)})
+
+// Without headers (access columns by index)
+LOAD CSV FROM 'file:///data.csv' AS row
+CREATE (n:Item {id: row[0], value: row[1]})
+
+// Custom field terminator
+LOAD CSV WITH HEADERS FROM 'file:///data.tsv' AS row FIELDTERMINATOR '\t'
+CREATE (n:Record {field1: row.col1})
+```
+
+**Note**: File paths are relative to the current working directory. Use `file:///` prefix for local files.
+
+## Multi-Graph Queries
+
+### FROM Clause
+
+Query specific graphs when using GraphManager (multi-graph support):
+
+```cypher
+// Query a specific graph
+MATCH (n:Person) FROM social
+RETURN n.name
+
+// Combined with other clauses
+MATCH (p:Person) FROM social
+WHERE p.age > 21
+RETURN p.name, graph(p) AS source_graph
+```
+
+The `graph()` function returns which graph a node came from.
+
+## Combining Results
+
+### UNION
+
+Combine results from multiple queries, removing duplicates:
+
+```cypher
+MATCH (n:Person) WHERE n.city = 'NYC' RETURN n.name
+UNION
+MATCH (n:Person) WHERE n.age > 50 RETURN n.name
+```
+
+### UNION ALL
+
+Combine results keeping all rows (including duplicates):
+
+```cypher
+MATCH (a:Person)-[:KNOWS]->(b) RETURN b.name AS connection
+UNION ALL
+MATCH (a:Person)-[:WORKS_WITH]->(b) RETURN b.name AS connection
+```
+
 ## Return Clause
 
 ### RETURN

docs/src/reference/cypher-clauses.md

@@ -15,6 +15,8 @@
 | `right(s, n)` | Last n characters | `right('hello', 2)` → `'lo'` |
 | `split(s, delim)` | Split into list | `split('a,b,c', ',')` → `['a','b','c']` |
 | `reverse(s)` | Reverse string | `reverse('hello')` → `'olleh'` |
+| `length(s)` | String length | `length('hello')` → `5` |
+| `size(s)` | String length (alias) | `size('hello')` → `5` |
 | `toString(x)` | Convert to string | `toString(123)` → `'123'` |
 
 ## String Predicates
@@ -39,6 +41,7 @@
 | `log10(n)` | Base-10 logarithm | `log10(100)` → `2` |
 | `exp(n)` | e^n | `exp(1)` → `2.718...` |
 | `rand()` | Random 0-1 | `rand()` → `0.42...` |
+| `random()` | Random 0-1 (alias) | `random()` → `0.42...` |
 | `pi()` | π constant | `pi()` → `3.14159...` |
 | `e()` | e constant | `e()` → `2.71828...` |
 
@@ -93,6 +96,7 @@
 |----------|-------------|---------|
 | `nodes(path)` | Get all nodes in path | `nodes(p)` |
 | `relationships(path)` | Get all relationships | `relationships(p)` |
+| `rels(path)` | Get all relationships (alias) | `rels(p)` |
 | `length(path)` | Path length (edges) | `length(p)` |
 
 ## Type Conversion
@@ -113,6 +117,7 @@
 | `time()` | Current time | `time()` |
 | `timestamp()` | Unix timestamp (ms) | `timestamp()` |
 | `localdatetime()` | Local datetime | `localdatetime()` |
+| `randomUUID()` | Generate random UUID | `randomUUID()` → `'550e8400-e29b-...'` |
 
 ## Predicate Functions
 
@@ -130,3 +135,78 @@
 | Function | Description | Example |
 |----------|-------------|---------|
 | `reduce(acc = init, x IN list \| expr)` | Fold/reduce | `reduce(s = 0, x IN [1,2,3] \| s + x)` → `6` |
+
+## CASE Expressions
+
+### Searched CASE
+
+Evaluates conditions in order and returns the first matching result:
+
+```cypher
+RETURN CASE
+    WHEN n.age < 18 THEN 'minor'
+    WHEN n.age < 65 THEN 'adult'
+    ELSE 'senior'
+END AS category
+```
+
+### Simple CASE
+
+Compares an expression against values:
+
+```cypher
+RETURN CASE n.status
+    WHEN 'A' THEN 'Active'
+    WHEN 'I' THEN 'Inactive'
+    WHEN 'P' THEN 'Pending'
+    ELSE 'Unknown'
+END AS status_name
+```
+
+## Comprehensions
+
+### List Comprehension
+
+Create lists by transforming or filtering:
+
+```cypher
+// Transform each element
+RETURN [x IN range(1, 5) | x * 2]
+// → [2, 4, 6, 8, 10]
+
+// Filter elements
+RETURN [x IN range(1, 10) WHERE x % 2 = 0]
+// → [2, 4, 6, 8, 10]
+
+// Filter and transform
+RETURN [x IN range(1, 10) WHERE x % 2 = 0 | x * x]
+// → [4, 16, 36, 64, 100]
+```
+
+### Pattern Comprehension
+
+Extract data from pattern matches within an expression:
+
+```cypher
+// Collect names of friends
+MATCH (p:Person)
+RETURN p.name, [(p)-[:KNOWS]->(friend) | friend.name] AS friends
+
+// With filtering
+RETURN [(p)-[:KNOWS]->(f:Person) WHERE f.age > 21 | f.name] AS adult_friends
+```
+
+### Map Projection
+
+Create maps by selecting properties from nodes:
+
+```cypher
+// Select specific properties
+MATCH (n:Person)
+RETURN n {.name, .age}
+// → {name: "Alice", age: 30}
+
+// Include computed values
+MATCH (n:Person)
+RETURN n {.name, status: 'active', upperName: toUpper(n.name)}
+```

docs/src/reference/cypher-functions.md

@@ -13,15 +13,24 @@ Cypher is a declarative graph query language originally developed by Neo4j. Grap
 | Node patterns | ✅ Full |
 | Relationship patterns | ✅ Full |
 | Variable-length paths | ✅ Full |
+| shortestPath/allShortestPaths | ✅ Full |
 | Parameterized queries | ✅ Full |
 | MATCH/OPTIONAL MATCH | ✅ Full |
 | CREATE/MERGE | ✅ Full |
 | SET/REMOVE/DELETE | ✅ Full |
 | WITH/UNWIND/FOREACH | ✅ Full |
+| LOAD CSV | ✅ Full |
+| UNION/UNION ALL | ✅ Full |
 | RETURN with modifiers | ✅ Full |
 | Aggregation functions | ✅ Full |
-| List comprehensions | ⚠️ Partial |
+| CASE expressions | ✅ Full |
+| List comprehensions | ✅ Full |
+| Pattern comprehensions | ✅ Full |
+| Map projections | ✅ Full |
+| Multi-graph (FROM clause) | ✅ Full |
+| Graph algorithms | ✅ 15+ built-in |
 | CALL procedures | ❌ Not supported |
+| CREATE INDEX/CONSTRAINT | ❌ Use SQLite |
 
 ## Pattern Syntax
 
@@ -70,7 +79,7 @@ See [Operators Reference](./cypher-operators.md) for comparison and logical oper
 GraphQLite implements standard Cypher with some differences from full implementations:
 
 1. **No CALL procedures** - Use built-in graph algorithm functions instead (e.g., `RETURN pageRank()`)
-2. **List comprehensions** - Basic support for `[x IN list | expr]` and `[x IN list WHERE pred | expr]`
-3. **No CREATE CONSTRAINT** - Use SQLite's constraint mechanisms
-4. **EXPLAIN supported** - Returns the generated SQL for debugging
-5. **UNION supported** - Combine results from multiple queries with `UNION` or `UNION ALL`
+2. **No CREATE INDEX/CONSTRAINT** - Use SQLite's indexing and constraint mechanisms directly
+3. **EXPLAIN supported** - Returns the generated SQL for debugging instead of a query plan
+4. **Multi-graph support** - Use the `FROM` clause to query specific graphs with GraphManager
+5. **Substring indexing** - Uses 0-based indexing (Cypher standard), automatically converted for SQLite