Struct Project 

pub struct Project {
    pub databases: Vec<Database>,
    pub dependency_graph: BTreeMap<ObjectId, BTreeSet<ObjectId>>,
    pub external_dependencies: BTreeSet<ObjectId>,
    pub cluster_dependencies: BTreeSet<Cluster>,
    pub tests: Vec<(ObjectId, UnitTest)>,
    pub replacement_schemas: BTreeSet<SchemaQualifier>,
    pub compile_dirty: BTreeSet<ObjectId>,
}

A project graph with full dependency tracking.

Fields

databases: Vec<Database>

dependency_graph: BTreeMap<ObjectId, BTreeSet<ObjectId>>

Global dependency graph: object_id -> set of dependencies

external_dependencies: BTreeSet<ObjectId>

External dependencies: objects referenced but not defined in this project

cluster_dependencies: BTreeSet<Cluster>

Cluster dependencies: clusters referenced by indexes and materialized views

tests: Vec<(ObjectId, UnitTest)>

Unit tests defined in the project, organized by the object they test

replacement_schemas: BTreeSet<SchemaQualifier>

Schemas that use replacement materialized views, derived from SET api = stable statements.

compile_dirty: BTreeSet<ObjectId>

Objects whose compiled artifact was a cache miss in this run. Drives incremental typechecking: a miss means the file content changed (or never compiled before), so the object’s typecheck result must be recomputed.

Implementations

impl Project

pub fn topological_sort(&self) -> Result<Vec<ObjectId>, DependencyError>

Get topologically sorted objects for deployment.

Returns objects in an order where dependencies come before dependents. External dependencies are excluded from the sort as they are not deployable.

pub fn get_tables(&self) -> impl Iterator<Item = ObjectId>

Returns all table-like objects (CREATE TABLE and CREATE TABLE ... FROM SOURCE).

pub fn get_tables_from_source(&self) -> impl Iterator<Item = ObjectId> + '_

Returns only CREATE TABLE ... FROM SOURCE objects.

Unlike get_tables, this excludes plain CREATE TABLE objects whose schemas can be derived from the SQL AST. Only CreateTableFromSource tables need their columns queried from the live server (via types.lock), because their columns depend on the external source.

fn visit( &self, object_id: &ObjectId, visited: &mut BTreeSet<ObjectId>, in_progress: &mut BTreeSet<ObjectId>, sorted: &mut Vec<ObjectId>, ) -> Result<(), DependencyError>

pub fn get_sorted_objects( &self, ) -> Result<Vec<(ObjectId, &DatabaseObject)>, DependencyError>

Get all database objects in topological order with their compiled statements.

Returns a vector of (ObjectId, compiled object) tuples in deployment order. This allows access to the fully qualified SQL statements for each object.

fn find_typed_object(&self, object_id: &ObjectId) -> Option<&DatabaseObject>

Find the compiled object for a given ObjectId.

pub fn iter_mod_statements(&self) -> Vec<ModStatement<'_>>

Returns all module-level statements in execution order.

Module statements are executed before object statements and come from database.sql or schema.sql files. They’re used for setup like grants, comments, and other database/schema-level configuration.

Execution Order

1. All database-level mod statements (in the order databases appear)
2. All schema-level mod statements (in the order schemas appear)

This ensures that database setup happens before schema setup, which happens before object creation.

Returns

A vector of ModStatement enums, each containing:

• Context (database name, schema name for schema-level statements)
• Reference to the statement to execute

pub fn build_reverse_dependency_graph( &self, ) -> BTreeMap<ObjectId, BTreeSet<ObjectId>>

Build a reverse dependency graph.

Maps each object to the set of objects that depend on it. Used for incremental deployment to find downstream dependencies.

Returns

HashMap where key is an ObjectId and value is the set of objects that depend on it

pub fn get_sorted_objects_filtered( &self, filter: &BTreeSet<ObjectId>, ) -> Result<Vec<(ObjectId, &DatabaseObject)>, DependencyError>

Get topologically sorted objects filtered by a set of object IDs.

Returns objects in deployment order, but only those in the filter set. Maintains topological ordering within the filtered subset.

Arguments

• filter - Set of ObjectIds to include in the result

Returns

Vector of (ObjectId, compiled object) tuples in deployment order

pub fn iter_objects(&self) -> impl Iterator<Item = &DatabaseObject>

Iterate over all database objects in the project.

This flattens the database → schema → object hierarchy into a single iterator.

Returns

Iterator over references to all DatabaseObject instances in the project

Example

for obj in project.iter_objects() {
    println!("Object: {}", obj.id);
}

pub fn find_object(&self, id: &ObjectId) -> Option<&DatabaseObject>

Find a database object by its ObjectId.

This is more efficient than manually iterating through the hierarchy.

Arguments

• id - The ObjectId to search for

Returns

Some(&DatabaseObject) if found, None otherwise

Example

if let Some(obj) = project.find_object(&object_id) {
    println!("Found: {}", obj.id);
}

pub fn validate_cluster_isolation( &self, sources_by_cluster: &BTreeMap<String, Vec<String>>, ) -> Result<(), (String, Vec<String>, Vec<String>)>

Validate that sources and sinks don’t share clusters with indexes or materialized views.

This validation prevents accidentally recreating sources/sinks when updating compute objects.

Arguments

• sources_by_cluster - Map of cluster name to list of source FQNs from the database

Returns

• Ok(()) if no conflicts found
• Err((cluster_name, compute_objects, storage_objects)) if conflicts detected

Trait Implementations

impl Debug for Project

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Project> for Project

fn from(compiled_project: Project) -> Self

Converts a compiled project into a dependency-aware project graph.

Graph assembly is structured as collect → process → reassemble:

1. Collect — Flatten all compiled objects into TypedObjectTasks and collect defined object IDs for external dependency detection.

2. Process — Extract dependencies and clusters from each object. This is the CPU-intensive step.

3. Reassemble — Merge results into the dependency graph and hierarchical Project structure.