Module graph 

Graphs in a session: their definitions and where they are kept.

A graph is defined by CREATE PROPERTY GRAPH (SQL/PGQ) over tables or views already in the session: one edge table with a source and a destination column, and optionally one vertex table keyed by an id column. Without a vertex table, the nodes are the endpoints of the edges.

This module is the contract between the graph DDL (which creates and drops GraphDefs) and everything that reads graphs: the <graph>.nodes and <graph>.edges tables and the algorithm table functions. Definitions are held per session in a GraphRegistry, stored as a session config extension so any code holding the session state can reach it.

A definition names tables; it does not copy or pin their rows. Every query plans the edge table afresh, so a graph over a view of a file sees the file’s current contents.

An edge or vertex table may also be a file path or URL, as in FROM (EDGE TABLES ('edges.csv' SOURCE KEY (src) DESTINATION KEY (dst))). It is opened once, when the graph is created, as a listing table that the registry keeps for that graph (GraphRegistry::file_table); it is not registered under any name, so it never shows in a listing. Like a view over the file, it fixes the file’s columns at that point and reads the file’s current rows on every query.

Tables a graph uses cannot be dropped, or replaced by ones the graph’s definition no longer fits, while the graph exists (check_drop, check_replace). If one disappears anyway (through the DataFusion API), <graph>.nodes and <graph>.edges fail when queried, and session listings keep working.

Algorithms over a graph are table functions, FROM pagerank(g), planned as a GraphAlgorithmNode whose child is the edge table (functions, relation, node, exec), with the built index cached per session (IndexCache).

Traversals (hop, shortest_path, random_walk) are table functions too, planned as a GraphTraversalNode over the same edge plan, with one more child per node-id argument (a list, or a subquery that runs when the node runs); see traversal.

Re-exports

pub use schema::edges_plan;

pub use schema::edges_plan_from;

pub use schema::nodes_plan;

pub use schema::nodes_plan_from;

pub use schema::GraphSchema;

Modules

functions

The graph functions in SQL: which of ursa_core::catalog’s functions a query can call, how a call’s SQL arguments become a catalog Call, and the wording of every message about them.

schema

A graph as a schema: <graph>.edges and <graph>.nodes.

traversal

The traversals in SQL: hop, shortest_path and random_walk.

Structs

EdgeTable

The edge table: each row is an edge from source to destination.

FileIdentity

The identity of one source file, as its store reports it.

FileTable

A table a graph opened from a file path or URL when it was created.

GraphAlgorithmExec

Builds or fetches a graph index from its child’s edge rows, and runs graph functions over it.

GraphAlgorithmNode

Run graph functions over the edges its input produces.

GraphDef

One graph, as CREATE PROPERTY GRAPH defined it.

GraphIndex

A built graph: its topology, and the map from dense node indexes back to the edges’ ids.

GraphPlanner

Plans Ursa’s graph nodes.

GraphRegistry

The graphs defined in one session, by name. Names are compared as given (the DDL normalizes identifiers the way DataFusion does for tables).

GraphTraversalExec

Builds or fetches a graph index from its first child’s edge rows, reads the node ids its other children produce, and runs a traversal.

GraphTraversalNode

Run a traversal (hop, shortest_path, random_walk) over the edges its first input produces.

IndexCache

The session’s graph indexes (a session config extension).

KeepEdgeOrder

Keeps a graph node’s edge rows in the order the plan produces them, and gives them a fixed order where the plan has none.

Output

One output column of a graph node: output field of call, named name.

UrsaFunctions

The ursa_functions() table function.

UrsaQueryPlanner

A query planner whose physical planner knows Ursa’s graph nodes.

VertexTable

The vertex table: each row is a node, keyed by key.

Functions

check_ddl

Refuse a DDL statement, planned as plan, that would break a graph:

check_drop

Refuse to drop table (a kind: “table” or “view”) while a graph uses it.

check_drop_schema

Refuse to drop the schema schema while it is a graph’s, or holds a table a graph uses.

check_replace

Refuse to replace table (a kind) by one with the columns schema while a graph uses it and its definition does not fit those columns. None: the new columns are not known yet, so the replacement is refused whenever a graph uses the table.

closest_name

The closest of candidates to name by edit distance, if any is close enough to be a likely typo: for “did you mean” suggestions.

create_graph

Define def in ctx, as CREATE [OR REPLACE] PROPERTY GRAPH [IF NOT EXISTS] does. Follows DataFusion’s CREATE TABLE: an existing graph is an error, unless or_replace (replace it) or if_not_exists (keep it, do nothing).

describe_graph

DESCRIBE GRAPH name: one row per column of <name>.nodes, then of <name>.edges, saying what each is and where it comes from.

drop_graph

Drop the graph called name and its schema, as DROP PROPERTY GRAPH [IF EXISTS] does.

index_builds

How many graph indexes ctx has built: for tests of the cache.

index_loads

How many graph indexes ctx has loaded from its database’s stored indexes instead of building them: for tests of stored indexes.

registry

The session’s graph registry.

registry_of

The graph registry of ctx.

show_graphs

SHOW GRAPHS: one row per graph, sorted by name, with its definition.

unknown_graph

The error for a graph that does not exist, with a suggestion.

Type Aliases

Weights

Weight columns, one f64 per edge row each, in the order of a node’s weight expressions.