Enum TableConstraint 

pub enum TableConstraint<X: Extension = NoExt> {
    PrimaryKey {
        columns: ThinVec<IndexColumn<X>>,
        include: ThinVec<Ident>,
        meta: Meta,
    },
    Unique {
        columns: ThinVec<IndexColumn<X>>,
        nulls_not_distinct: Option<bool>,
        include: ThinVec<Ident>,
        meta: Meta,
    },
    Check {
        expr: Box<Expr<X>>,
        meta: Meta,
    },
    Exclude {
        exclude: Box<ExcludeConstraint<X>>,
        meta: Meta,
    },
    ForeignKey {
        columns: ThinVec<Ident>,
        references: Box<ForeignKeyRef>,
        meta: Meta,
    },
    Bare {
        meta: Meta,
    },
    Other {
        ext: X,
        meta: Meta,
    },
}

The SQL table constraint forms represented by the AST.

Variants

PrimaryKey

A PRIMARY KEY (col, …) table constraint.

Fields

columns: ThinVec<IndexColumn<X>>

The key columns. Each is an IndexColumn — the same “indexed-column” shape CreateIndex uses — so a column may carry a COLLATE <collation> postfix (folded into IndexColumn::expr as an Expr::Collate) and an ASC/DESC sort order. The bare-column case is an Expr::Column with asc/nulls_first unset — the shape every dialect produces. The COLLATE/ordering decoration is gated for acceptance by ConstraintSyntax::constraint_column_collate_order (SQLite): off elsewhere, where a bare name is the only accepted form and a trailing COLLATE/ASC/DESC is a clean parse error. SQLite prohibits general expressions and NULLS FIRST/LAST in this position, so the parser never fills nulls_first nor produces a non-column/non-collate expr here.

include: ThinVec<Ident>

The INCLUDE (<col>, ...) covering-index columns (PostgreSQL): non-key payload columns stored in the primary key’s implicit index (PRIMARY KEY (a) INCLUDE (b)). Empty when no INCLUDE clause is written. Gated for acceptance by ConstraintSyntax::index_constraint_parameters; off elsewhere, where INCLUDE after the key list is a clean parse error.

meta: Meta

Source location and node identity.

Unique

A UNIQUE (col, …) table constraint.

Fields

columns: ThinVec<IndexColumn<X>>

The key columns, as on PrimaryKey: IndexColumns admitting a per-column COLLATE <collation> and ASC/DESC under the same ConstraintSyntax::constraint_column_collate_order gate.

nulls_not_distinct: Option<bool>

The NULLS [NOT] DISTINCT null-treatment (PostgreSQL 15+), as on the column-level ColumnOption::Unique. Some(false) = NULLS NOT DISTINCT, Some(true) = the explicit NULLS DISTINCT default, None = unwritten. Gated for acceptance by ConstraintSyntax::index_constraint_parameters.

include: ThinVec<Ident>

The INCLUDE (<col>, ...) covering-index columns (PostgreSQL), as on PrimaryKey. Empty when unwritten. Same gate.

meta: Meta

Source location and node identity.

Check

A CHECK (<predicate>) table constraint.

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

meta: Meta

Source location and node identity.

Exclude

A PostgreSQL EXCLUDE [USING <method>] (<element> WITH <operator> [, ...]) [INCLUDE (...)] [WITH (...)] [USING INDEX TABLESPACE ...] [WHERE (...)] exclusion constraint — no two rows may hold values that all pairwise satisfy the named operators. The whole clause is boxed into ExcludeConstraint so this cold, rarely-written variant does not widen the warm TableConstraint enum (the box/inline budget — the same reason ForeignKey boxes its ForeignKeyRef). Gated for acceptance by ConstraintSyntax::exclusion_constraints; off elsewhere (DuckDB included, which rejects it), where EXCLUDE at a constraint position is a clean parse error.

Fields

exclude: Box<ExcludeConstraint<X>>

The exclusion-constraint specification; see ExcludeConstraint.

meta: Meta

Source location and node identity.

ForeignKey

A FOREIGN KEY (col, …) REFERENCES … table constraint.

Fields

columns: ThinVec<Ident>

Columns in source order.

references: Box<ForeignKeyRef>

The foreign-key target table, columns, and options; see ForeignKeyRef.

meta: Meta

Source location and node identity.

Bare

A trailing bodyless CONSTRAINT <name> (SQLite), standalone in the table-element list (CREATE TABLE t (a INT, CONSTRAINT cn)) — the TableConstraintDef::name is written but no constraint element follows it. SQLite also lets the comma separating this from a preceding table constraint be omitted (UNIQUE(a) CONSTRAINT cn, engine-measured accepted); the parser’s table-element loop handles that comma elision, not this variant. Gated for acceptance by ConstraintSyntax::bare_constraint_name; off elsewhere, where a CONSTRAINT <name> with nothing following is a clean parse error.

Fields

meta: Meta

Source location and node identity.

Other

Dialect extension node supplied by the extension type.

Fields

ext: X

The dialect extension node value.

meta: Meta

Source location and node identity.

Trait Implementations

impl<X: Clone + Extension> Clone for TableConstraint<X>

fn clone(&self) -> TableConstraint<X>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<X: Debug + Extension> Debug for TableConstraint<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for TableConstraint<X>

where X: Deserialize<'de> + Extension,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X: Eq + Extension> Eq for TableConstraint<X>

impl<X: Hash + Extension> Hash for TableConstraint<X>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<X: PartialEq + Extension> PartialEq for TableConstraint<X>

fn eq(&self, other: &TableConstraint<X>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<X: Extension + Render> Render for TableConstraint<X>

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

Return the render for this value.

fn operand_binding_power(&self) -> Option<BindingPower>

The binding power this node contributes when it appears as an operand, or None (the default) for a self-delimiting node — an atom, call, or constructor — that never needs parentheses.

impl<X> Serialize for TableConstraint<X>

where X: Serialize + Extension,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: Extension> Spanned for TableConstraint<X>

fn span(&self) -> Span

Return the span for this value.

impl<X: PartialEq + Extension> StructuralPartialEq for TableConstraint<X>