cquill/schema

Types

Schema

A schema describes the structure of a database table. It contains metadata about fields, primary keys, and table-level constraints.

pub type Schema {
  Schema(
    source: String,
    table_schema: option.Option(String),
    fields: List(field.Field),
    primary_key: List(String),
    table_constraints: List(TableConstraint),
    comment: option.Option(String),
  )
}

Constructors

```
Schema(
  source: String,
  table_schema: option.Option(String),
  fields: List(field.Field),
  primary_key: List(String),
  table_constraints: List(TableConstraint),
  comment: option.Option(String),
)
```
Arguments

source

The source table name in the database

table_schema

Schema/namespace (e.g., “public” in Postgres)

fields

Ordered list of fields

primary_key

Primary key column names (supports composite keys)

table_constraints

Table-level constraints (multi-column unique, etc.)

comment

Table comment/documentation

SchemaDiff

</>

Compare two schemas and find differences Useful for schema migration planning

pub type SchemaDiff {
  FieldAdded(field.Field)
  FieldRemoved(String)
  FieldTypeChanged(
    name: String,
    old_type: field.FieldType,
    new_type: field.FieldType,
  )
  PrimaryKeyChanged(old_pk: List(String), new_pk: List(String))
}

Constructors

```
FieldAdded(field.Field)
```
```
FieldRemoved(String)
```

FieldTypeChanged(
  name: String,
  old_type: field.FieldType,
  new_type: field.FieldType,
)

PrimaryKeyChanged(old_pk: List(String), new_pk: List(String))

SchemaError

</>

Validation errors for schemas

pub type SchemaError {
  InvalidPrimaryKey(column: String)
  DuplicateField(name: String)
  EmptySchema
  InvalidTableName(name: String)
  InvalidConstraintColumn(
    constraint_name: String,
    column: String,
  )
}

Constructors

```
InvalidPrimaryKey(column: String)
```
Primary key references non-existent field
```
DuplicateField(name: String)
```
Duplicate field name
```
EmptySchema
```
Empty schema (no fields)
```
InvalidTableName(name: String)
```
Invalid table name

InvalidConstraintColumn(constraint_name: String, column: String)

Table constraint references invalid column

TableConstraint

</>

Table-level constraints (apply to multiple columns)

pub type TableConstraint {
  UniqueConstraint(name: String, columns: List(String))
  Index(name: String, columns: List(String), unique: Bool)
  TableCheck(name: String, expression: String)
  CompositeForeignKey(
    name: String,
    columns: List(String),
    references_table: String,
    references_columns: List(String),
  )
}

Constructors

UniqueConstraint(name: String, columns: List(String))

Multi-column unique constraint

Index(name: String, columns: List(String), unique: Bool)

Multi-column index (not enforced, but for documentation)

TableCheck(name: String, expression: String)

Table-level check constraint

CompositeForeignKey(
  name: String,
  columns: List(String),
  references_table: String,
  references_columns: List(String),
)

Composite foreign key

Values

add_constraint

</>

pub fn add_constraint(
  schema: Schema,
  constraint: TableConstraint,
) -> Schema

Add a table-level constraint

add_field

</>

pub fn add_field(
  schema: Schema,
  new_field: field.Field,
) -> Schema

Add a field to the schema Fields are added in order and the order is preserved

auto_increment_fields

</>

pub fn auto_increment_fields(schema: Schema) -> List(field.Field)

Get all auto-increment fields

diff

</>

pub fn diff(
  old_schema: Schema,
  new_schema: Schema,
) -> List(SchemaDiff)

Find differences between two schemas

exclude_fields

</>

pub fn exclude_fields(
  schema: Schema,
  names: List(String),
) -> Schema

Create a new schema excluding the specified fields Useful for creating public schemas without sensitive fields

field

</>

pub fn field(schema: Schema, new_field: field.Field) -> Schema

Alias for add_field - more concise in pipelines

field_count

</>

pub fn field_count(schema: Schema) -> Int

Get field count

field_names

</>

pub fn field_names(schema: Schema) -> List(String)

Get all field names in order

foreign_key_fields

</>

pub fn foreign_key_fields(schema: Schema) -> List(field.Field)

Get fields with foreign key constraints

get_field

</>

pub fn get_field(
  schema: Schema,
  name: String,
) -> option.Option(field.Field)

Get a field by name

get_fields

</>

pub fn get_fields(schema: Schema) -> List(field.Field)

Get all fields in order

get_primary_key

</>

pub fn get_primary_key(schema: Schema) -> List(String)

Get the primary key columns

get_qualified_name

</>

pub fn get_qualified_name(schema: Schema) -> String

Get the fully qualified table name (schema.table or just table)

get_source

</>

pub fn get_source(schema: Schema) -> String

Get the source table name

has_field

</>

pub fn has_field(schema: Schema, name: String) -> Bool

Check if schema has a field with the given name

has_primary_key

</>

pub fn has_primary_key(schema: Schema) -> Bool

Check if schema has a primary key defined

in_schema

</>

pub fn in_schema(schema: Schema, table_schema: String) -> Schema

Set the table schema/namespace

index

</>

pub fn index(
  schema: Schema,
  name: String,
  columns: List(String),
  unique: Bool,
) -> Schema

Add an index

insertable_fields

</>

pub fn insertable_fields(schema: Schema) -> Schema

Create a new schema with only non-auto-generated fields Useful for insert schemas

is_valid

</>

pub fn is_valid(schema: Schema) -> Bool

Check if schema is valid

new

</>

pub fn new(source: String) -> Schema

Create a new empty schema for a table

new_with_schema

</>

pub fn new_with_schema(
  source: String,
  table_schema: String,
) -> Schema

Create a new schema with a specific database schema/namespace

non_primary_key_fields

</>

pub fn non_primary_key_fields(
  schema: Schema,
) -> List(field.Field)

Get fields that are NOT part of the primary key

nullable_fields

</>

pub fn nullable_fields(schema: Schema) -> List(field.Field)

Get all nullable fields

primary_key

</>

pub fn primary_key(
  schema: Schema,
  columns: List(String),
) -> Schema

Set the primary key columns Supports composite primary keys

primary_key_fields

</>

pub fn primary_key_fields(schema: Schema) -> List(field.Field)

Get fields that are part of the primary key

rename_field

</>

pub fn rename_field(
  schema: Schema,
  old_name: String,
  new_name: String,
) -> Schema

Rename a field in the schema

required_fields

</>

pub fn required_fields(schema: Schema) -> List(field.Field)

Get all required (non-nullable, no default) fields

select_fields

</>

pub fn select_fields(
  schema: Schema,
  names: List(String),
) -> Schema

Create a new schema with only the specified fields Useful for creating insert/update schemas without auto-generated fields

single_primary_key

</>

pub fn single_primary_key(
  schema: Schema,
  column: String,
) -> Schema

Set a single-column primary key

table_check

</>

pub fn table_check(
  schema: Schema,
  name: String,
  expression: String,
) -> Schema

Add a table-level check constraint

unique_constraint

</>

pub fn unique_constraint(
  schema: Schema,
  name: String,
  columns: List(String),
) -> Schema

Add a multi-column unique constraint

validate

</>

pub fn validate(schema: Schema) -> List(SchemaError)

Validate a schema and return any errors

with_comment

</>

pub fn with_comment(schema: Schema, text: String) -> Schema

Add a comment to the schema

Constructors

Arguments

Constructors

Constructors

Constructors