Enum ScalarFieldType 

#[non_exhaustive]
pub enum ScalarFieldType {
    Text,
    Integer,
    Numeric,
    Boolean,
    DateTime,
    Date,
    Time,
    Uuid,
    Vector,
}

Declared scalar type of a JSON field, used to pick the SQL cast.

A JSON/JSONB extraction is always text, so both ORDER BY and WHERE have to cast it before the database can compare it as anything else. Sorting "9" after "10" is the visible symptom for numbers; for WHERE the symptom is a wrong row set (or a hard cast error).

The variant → SQL-type-name mapping lives in exactly one place — SqlDialect::cast_type_name — so ORDER BY and WHERE cannot drift apart.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text

No cast — text comparison (correct for strings, UUIDs, IDs, enum values).

Integer

Integer (::bigint / CAST(… AS BIGINT)).

Numeric

Fixed/floating point (::numeric / CAST(… AS DECIMAL(38,12))).

Boolean

Boolean (::boolean).

DateTime

Instant (::timestamptz / CAST(… AS DATETIME2)).

Date

Calendar date (::date).

Time

Wall-clock time (::time).

Uuid

Identity comparison (ID/UUID) — no cast.

Renders exactly like Self::Text; the variant exists to mark which fields are identities, not to introduce a cast. cast_type_name returns None for it deliberately.

Casting would be the obvious repair and is the wrong one: (data->>'id')::uuid is evaluated per row, so one row holding a non-UUID identity raises SQLSTATE 22P02 for every query — and ID is documented as intentionally spanning uuid / integer / text keys (docs/adr/0017-entity-identity-contract.md), with fixtures holding 'user-1' and a BIGINT pk. Equality is instead made case-insensitive at the literal, which needs no knowledge of the column’s type.

Vector

A declared pgvector field — vector(N), halfvec(N), sparsevec(N) or bit(N) (#1117).

Like Self::Uuid, this marks which fields are of a kind rather than introducing a cast: cast_type_name returns None for it, so every ordinary comparison against a vector field renders exactly as it did.

What it decides is the operand a distance predicate reads. The storage contract requires the backing view to expose a vector as a native column, and nearest has always ordered by it; the threshold operators could not tell a vector field from any other, so they resolved it through data->> and re-parsed every row’s embedding out of text — 2667 ms against the column’s 22 ms, on the same 400 rows.

One variant covers all four pgvector types on purpose: which pgvector type the literal is cast to is decided by the operand’s own shape (an array is ::vector, {1:0.5}/1000 is ::sparsevec, the binary metrics are ::varbit), and that is unchanged by this. What the schema is being asked here is only “is there a native column to read instead of the JSONB text?”.

Trait Implementations

impl Clone for ScalarFieldType

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ScalarFieldType

impl Debug for ScalarFieldType

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

Formats the value using the given formatter.

impl Default for ScalarFieldType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ScalarFieldType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ScalarFieldType

impl PartialEq for ScalarFieldType

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ScalarFieldType

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 ScalarFieldType