Check if a catalog exists # Arguments `catalog_name` - Name of the catalog to check # Returns `true` if catalog exists, `false` otherwise

Check if an index exists

Infer the type of an expression for validation

ROADMAP v0.5.0 - Type inference for static analysis (see ROADMAP.md §7)

Invalidate entries by graph version

Invalidate caches when graph data changes

Check if an expression contains aggregate functions Originally: optimizer.rs line 2026

List all graph types

List all index names

Add a MATCH pattern to the query Can be called multiple times to add multiple MATCH patterns.

Main entry point for optimizing comma-separated patterns

Recursively optimize a logical node Originally: optimizer.rs line 1508

Optimize logical plan

Set the ORDER BY clause to the query

Set the ORDER BY clause # Arguments `clause` - Order by clause (without the ORDER BY keywords) # Examples ```no_run # use graphlite_sdk::GraphLite

Parse ISO 8601 duration string into total seconds Supports formats like: - P1Y2M3DT4H5M6S (1 year, 2 months, 3 days, 4 hours, 5 minutes, 6 seconds) -

Plan RETURN clause Originally: optimizer.rs line 1307

Pre-execution: WAL logging (permissions are checked at higher level)

Create a new query builder for fluent query construction Returns: QueryBuilder instance

Record a failed or skipped optimization

Resolve graph for execution based on precedence rules

Resolve a graph reference to an actual graph instance This function properly handles session-based graph resolution per ISO GQL standard. When graph_

Set the RETURN clause to the query Specifies what to return from the query. Required for MATCH queries.

Set highlight snippet

Set a session parameter

Set a property value

Set text search score

Set the SKIP value Skips the first N results. # Arguments `n` - Number of results to skip # Examples ```no_run # use graphlite_sdk::GraphLite; #

Validate that a node matches the graph type schema (with graph type directly)

Validate property type

Set the user session

Add an edge type

Add variable information to the plan

Add a vertex type

ROADMAP v0.5.0 - Coercion strategy selection

Apply DISTINCT to remove duplicates

Apply except operation

Apply HAVING filter for post-aggregation filtering

Apply index-aware optimization rules to logical plan

Apply intersect operation

Apply predicate pushdown optimization Originally: optimizer.rs line 1497

Apply projection elimination optimization Originally: optimizer.rs line 1697

Apply subquery unnesting optimization Originally: optimizer.rs line 1714

Apply union operation

Apply WHERE filter to a set of rows

Apply WHERE filter to a vector of rows

Check if two types are comparable

Get the number of arguments

Extract as integer if possible (from number)

Execute query and assert success

Authenticate a user and create a session

Begin a new transaction

Check if EXISTS subquery can be unnested

Get mutable reference to catalog cache

Parse catalog path: /segment1/segment2/... Supports ISO GQL delimited identifiers: /`My-Schema`/`My-Graph`

Check if the graph type already exists

Clean up expired sessions

Clear all caches

Close a session @param sessionId Session ID to close @throws GraphLiteException if session close fails

ROADMAP v0.5.0 - Value type coercion

ROADMAP v0.5.0 - Iterator collection utility for materialization

Get all values from a specific column

Internal commit implementation

Commit a transaction

Check if node contains aggregation

Check if node contains LIMIT

Create logical plan for basic query Originally: optimizer.rs line 512

Get a cost estimator with current statistics

Helper: Create join keys from shared variables

Helper to create plan cache key from query and context

Helper to create query cache key from query string and parameters

Create a new session and return its ID

Create a new session with custom permissions (Advanced API) This is an advanced method for cases where you need fine-grained control over session per

Create a new session for the given user Args: username: Username for the session Returns: Session I

Factory function to create a storage driver based on configuration This is the main entry point for creating storage drivers. It takes a storage type

Helper to create subquery cache key

Mark session as inactive

Deserialize a single row dict into an instance of the target type Args: row: Row dictionary to deserialize t

Deserialize all rows into a vector of the given type Each row is converted to a JSON object and then deserialized into the target type using serde.

Detect if patterns form a linear path that can be executed via traversal

Parse string content with escape sequences

Estimate cost for a given pattern execution strategy

Estimate memory usage of an Edge

Estimate expand (traversal) cost

Estimate memory usage of a Node

Utility function to estimate the improvement of an optimized plan

Estimate cost for a physical plan

Estimate sort cost