Enum EnumValues 

pub enum EnumValues {
    String(Vec<String>),
    Integer(Vec<NumValue>),
}

The set of allowed values for an enum column, either string-based or integer-based.

String enums map to a native PostgreSQL ENUM type. Adding or removing values requires a database migration (ALTER TYPE).

Integer enums are stored as INTEGER. New variants can be added to the model without any database migration because the underlying column type never changes.

Choose integer enums for expandable value sets (roles, priorities) and string enums for stable, human-readable status fields.

Variants

String(Vec<String>)

String enum: each variant is a plain string stored in a native DB enum type.

Integer(Vec<NumValue>)

Integer enum: each variant has an explicit numeric value stored as INTEGER.

Implementations

impl EnumValues

pub fn is_string(&self) -> bool

Check if this is a string enum

pub fn is_integer(&self) -> bool

Check if this is an integer enum

pub fn variant_names_joined(&self, separator: &str) -> String

Join every variant name with separator, writing straight into one buffer — no intermediate Vec<&str> allocation.

Unlike Self::sql_values_joined (which emits SQL literals: quoted strings / integer values), this emits the human-readable variant names for diagnostics such as “allowed values are: a, b, c”. For an integer enum the member names are used.

use vespertide_core::{EnumValues, NumValue};

let s = EnumValues::String(vec!["active".into(), "inactive".into()]);
assert_eq!(s.variant_names_joined(", "), "active, inactive");

let i = EnumValues::Integer(vec![
    NumValue { name: "low".into(),  value: 0  },
    NumValue { name: "high".into(), value: 10 },
]);
assert_eq!(i.variant_names_joined(", "), "low, high");

let empty = EnumValues::String(vec![]);
assert_eq!(empty.variant_names_joined(", "), "");

pub fn len(&self) -> usize

Get the number of variants

pub fn is_empty(&self) -> bool

Check if there are no variants

pub fn contains_value(&self, value: &str) -> bool

Returns true when value matches any variant of this enum.

For string enums the comparison is exact-string against each variant. For integer enums the value is first parsed as i64 (matching the NumValue::value storage type): successful parses match against NumValue::value, failed parses fall back to matching against NumValue::name. Mirrors the loose JSON-default behaviour expected by the planner validator so a model author can write either the numeric literal (5) or the variant name ("Active") for an integer enum default.

pub fn sql_values_joined(&self, separator: &str) -> String

Format every variant for CREATE TYPE … AS ENUM(...) / CHECK (col IN (...)) and join with separator, writing into one buffer — no intermediate Vec<String> allocation.

Mirrors vespertide_query::sql::helpers::quote_idents and vespertide_core::schema::names::join_column_names.

use vespertide_core::{EnumValues, NumValue};

let s = EnumValues::String(vec!["active".into(), "O'Brien".into()]);
assert_eq!(s.sql_values_joined(", "), "'active', 'O''Brien'");

let i = EnumValues::Integer(vec![
    NumValue { name: "low".into(),  value: 0  },
    NumValue { name: "high".into(), value: 10 },
]);
assert_eq!(i.sql_values_joined(", "), "0, 10");

let empty = EnumValues::String(vec![]);
assert_eq!(empty.sql_values_joined(", "), "");

Trait Implementations

impl Clone for EnumValues

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnumValues

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EnumValues

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EnumValues

impl From<Vec<&str>> for EnumValues

fn from(values: Vec<&str>) -> Self

Converts to this type from the input type.

impl From<Vec<String>> for EnumValues

fn from(values: Vec<String>) -> Self

Converts to this type from the input type.

impl JsonSchema for EnumValues

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EnumValues

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EnumValues

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EnumValues