Struct SchemaBuilder 

pub struct SchemaBuilder<'a> { /* private fields */ }

Builder for defining and modifying the graph schema.

Use this builder to define labels, edge types, properties, and indexes. Changes are batched and applied atomically when .apply() is called.

Example

db.schema()
    .label("Person")
        .property("name", uni_db::DataType::String)
        .property("age", uni_db::DataType::Int64)
        .vector("embedding", 1536) // Adds property AND vector index
        .index("name", uni_db::IndexType::Scalar(uni_db::ScalarType::BTree))
    .edge_type("KNOWS", &["Person"], &["Person"])
        .property("since", uni_db::DataType::Date)
    .apply()
    .await?;

Implementations

impl<'a> SchemaBuilder<'a>

pub fn new(db: &'a Uni) -> Self

pub fn current(&self) -> Arc<Schema>

Get the current schema (read-only snapshot).

pub fn with_changes(self, changes: Vec<SchemaChange>) -> Self

Add pre-built schema changes to this builder.

pub fn label(self, name: &str) -> LabelBuilder<'a>

Create a label (node type) in the schema.

Labels can be schemaless (no properties defined) or typed (with properties).

Schemaless Labels

Labels without property definitions support flexible, dynamic properties:

• Properties not in schema are stored in overflow_json (JSONB binary)
• Queries on overflow properties are automatically rewritten to JSONB functions
• No schema migration needed to add new properties

Example: Schemaless Label

// Create label with no properties
db.schema().label("Document").apply().await?;

// Create with arbitrary properties
db.execute("CREATE (:Document {title: 'Article', author: 'Alice', year: 2024})").await?;

// Query works transparently (automatic query rewriting)
db.query("MATCH (d:Document) WHERE d.author = 'Alice' RETURN d.title, d.year").await?;

Example: Typed Label with Overflow

// Define core properties in schema
db.schema()
    .label("Person")
    .property("name", DataType::String)
    .property("age", DataType::Int)
    .apply().await?;

// Can still add overflow properties dynamically
db.execute("CREATE (:Person {name: 'Bob', age: 25, city: 'NYC'})").await?;
//                                                   ^^^^^^^^^^^
//                                                   overflow property

// Query mixing schema and overflow properties
db.query("MATCH (p:Person) WHERE p.name = 'Bob' AND p.city = 'NYC' RETURN p.age").await?;

Performance Note: Schema properties use typed columns (faster filtering/sorting), while overflow properties use JSONB (flexible but slower). Use schema properties for core, frequently-queried fields.

pub fn edge_type( self, name: &str, from: &[&str], to: &[&str], ) -> EdgeTypeBuilder<'a>

pub async fn apply(self) -> Result<()>