#[non_exhaustive]pub enum Scalar {
Null,
Int(i64),
Float(f64),
Text(String),
Bool(bool),
Timestamp(i64),
Date(i64),
Interval {
months: i64,
days: i64,
micros: i64,
},
}Expand description
A typed scalar value — the closed set the function library speaks.
Deliberately narrower than SQL’s type zoo: kevy’s sql face maps
bigint/int → Int, double/numeric-literal → Float, text/varchar
→ Text, boolean → Bool, and SQL NULL → Null. Types the
engine refuses (money, inet, enum, …) never reach this crate.
§Examples
use kevy_scalar::{Scalar, eval};
// NULL is a value here, not an absence, and it PROPAGATES: a strict
// function with a NULL argument answers NULL rather than erroring.
assert_eq!(eval("upper", &[Scalar::Null]).unwrap(), Scalar::Null);
assert_eq!(
eval("upper", &[Scalar::Text("ada".into())]).unwrap(),
Scalar::Text("ADA".into())
);Variants (Non-exhaustive)§
This enum is marked as non-exhaustive
Null
SQL NULL. Propagates: any strict function with a NULL argument answers NULL (the null-family module documents its exceptions).
use kevy_scalar::{Scalar, eval};
assert_eq!(eval("lower", &[Scalar::Null])?, Scalar::Null);
assert_eq!(eval("coalesce", &[Scalar::Null, Scalar::Int(1)])?, Scalar::Int(1));Int(i64)
A 64-bit integer.
use kevy_scalar::{Scalar, eval};
assert_eq!(eval("length", &[Scalar::Text("kevy".into())])?, Scalar::Int(4));
assert_eq!(Scalar::Int(-7).render(), "-7");Float(f64)
A 64-bit float. PG’s numeric literals fold through here; the sql face renders results back with PG’s trailing-zero rules.
use kevy_scalar::{Scalar, binop};
let half = binop('/', &Scalar::Float(1.0), &Scalar::Int(2))?;
assert_eq!(half, Scalar::Float(0.5));
assert_eq!(half.render(), "0.5");Text(String)
A UTF-8 string.
use kevy_scalar::{Scalar, eval};
let out = eval("initcap", &[Scalar::Text("hello world".into())])?;
assert_eq!(out, Scalar::Text("Hello World".into()));Bool(bool)
A boolean.
use kevy_scalar::{Scalar, logic_not};
assert_eq!(logic_not(&Scalar::Bool(true))?, Scalar::Bool(false));
assert_eq!(Scalar::Bool(false).render(), "f");Timestamp(i64)
A timestamp (no time zone): microseconds since the Unix epoch.
Probe 38’s lesson is baked in: now() and friends must be
TYPED, not text — the sql face rewrites them to this variant.
use kevy_scalar::{Scalar, parse_timestamp};
let us = parse_timestamp("1970-01-02 00:00:00").unwrap();
assert_eq!(us, 86_400_000_000);
assert_eq!(Scalar::Timestamp(us).render(), "1970-01-02 00:00:00");Date(i64)
A calendar date: days since the Unix epoch.
use kevy_scalar::{Scalar, binop, parse_date};
let d = Scalar::Date(parse_date("2024-02-28").unwrap());
let next = binop('+', &d, &Scalar::Int(1))?;
assert_eq!(next.render(), "2024-02-29");Interval
An interval in PG’s three-component shape: months, days and
microseconds never mix (probe 10’s 1 day - 12 hours stays
1 day -12:00:00 — no normalization across components). Month
arithmetic clamps to month ends; the other two are exact.
use kevy_scalar::{Scalar, binop, parse_date};
let jan31 = Scalar::Date(parse_date("2024-01-31").unwrap());
let month = Scalar::Interval { months: 1, days: 0, micros: 0 };
// clamped to the last day of February
assert_eq!(binop('+', &jan31, &month)?.render(), "2024-02-29 00:00:00");Fields
months: i64Whole calendar months (12 per year).
use kevy_scalar::{Scalar, parse_interval};
let (months, _, _) = parse_interval("1 year 2 mons").unwrap();
assert_eq!(months, 14);
let iv = Scalar::Interval { months, days: 0, micros: 0 };
assert_eq!(iv.render(), "1 year 2 mons");days: i64Whole days — separate from micros because PG keeps them separate (visible in rendering and component extraction).
use kevy_scalar::Scalar;
// 1 day minus 12 hours stays as two components
let iv = Scalar::Interval { months: 0, days: 1, micros: -43_200_000_000 };
assert_eq!(iv.render(), "1 day -12:00:00");Implementations§
Source§impl Scalar
impl Scalar
Sourcepub fn is_null(&self) -> bool
pub fn is_null(&self) -> bool
Whether this is SQL NULL.
§Examples
use kevy_scalar::Scalar;
assert!(Scalar::Null.is_null());
assert!(!Scalar::Int(0).is_null(), "zero is a value, not a NULL");
assert!(!Scalar::Text(String::new()).is_null(), "so is the empty string");Sourcepub fn render(&self) -> String
pub fn render(&self) -> String
PG’s text output form for this value. Null renders as the
empty string here — a caller that needs a NULL marker (the
sqllogictest runner does) checks Scalar::is_null first.
§Examples
use kevy_scalar::Scalar;
assert_eq!(Scalar::Int(42).render(), "42");
assert_eq!(Scalar::Text("ada".into()).render(), "ada");
assert_eq!(Scalar::Bool(true).render(), "t", "PG's boolean output");