Enum CheckExpr 

pub enum CheckExpr {
    True,
    Col(u16),
    Lit(Value),
    IsNull(u16),
    IsNotNull(u16),
    Eq(Box<CheckExpr>, Box<CheckExpr>),
    Ne(Box<CheckExpr>, Box<CheckExpr>),
    Lt(Box<CheckExpr>, Box<CheckExpr>),
    Le(Box<CheckExpr>, Box<CheckExpr>),
    Gt(Box<CheckExpr>, Box<CheckExpr>),
    Ge(Box<CheckExpr>, Box<CheckExpr>),
    And(Box<CheckExpr>, Box<CheckExpr>),
    Or(Box<CheckExpr>, Box<CheckExpr>),
    Not(Box<CheckExpr>),
    Regex {
        col: u16,
        pattern: String,
        negated: bool,
        case_insensitive: bool,
        cached: OnceLock<Regex>,
    },
}

A minimal boolean expression IR for CHECK constraints, evaluated against a row’s cells. Terms (CheckExpr::Col / CheckExpr::Lit) resolve to Value; comparisons and logical ops are boolean. Any comparison involving Value::Null yields three-valued Unknown.

The CheckExpr::Regex variant stores the pattern string for serde/equality and caches the compiled regex::Regex in a std::sync::OnceLock (populated on first evaluation). The cache is #[serde(skip)] and excluded from PartialEq.

Variants

True

Constant true (the trivially-satisfied CHECK).

Col(u16)

A bare column reference used as a boolean (truthiness coercion).

Lit(Value)

A literal value.

IsNull(u16)

IsNotNull(u16)

Eq(Box<CheckExpr>, Box<CheckExpr>)

Ne(Box<CheckExpr>, Box<CheckExpr>)

Lt(Box<CheckExpr>, Box<CheckExpr>)

Le(Box<CheckExpr>, Box<CheckExpr>)

Gt(Box<CheckExpr>, Box<CheckExpr>)

Ge(Box<CheckExpr>, Box<CheckExpr>)

And(Box<CheckExpr>, Box<CheckExpr>)

Or(Box<CheckExpr>, Box<CheckExpr>)

Not(Box<CheckExpr>)

Regex

Regex pattern match against a column’s value (PostgreSQL ~/~*/!~/!~*). The column value must be Value::Bytes (UTF-8 string); non-bytes and null yield Unknown (CHECK passes). negated inverts the match result; case_insensitive enables case-insensitive matching. The Rust regex crate is linear-time (no catastrophic backtracking), so ReDoS is not a concern.

Fields

col: u16

pattern: String

negated: bool

case_insensitive: bool

cached: OnceLock<Regex>

Implementations

impl CheckExpr

pub fn satisfied(&self, cells: &HashMap<u16, Value>) -> bool

Evaluate the expression against a row’s cells. A CHECK constraint is satisfied unless this returns [Tri::False].

pub fn validate(&self) -> Result<()>

Validate that all regex patterns in this expression compile successfully. Call at DDL time (table creation / constraint addition) so invalid patterns are rejected eagerly rather than silently never-matching at first commit.

Trait Implementations

impl Clone for CheckExpr

fn clone(&self) -> CheckExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CheckExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CheckExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CheckExpr

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CheckExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.