Enum iceberg::spec::Literal

pub enum Literal {
    Primitive(PrimitiveLiteral),
    Struct(Struct),
    List(Vec<Option<Literal>>),
    Map(Map),
}

Values present in iceberg type

Variants

Primitive(PrimitiveLiteral)

A primitive value

Struct(Struct)

A struct is a tuple of typed values. Each field in the tuple is named and has an integer id that is unique in the table schema. Each field can be either optional or required, meaning that values can (or cannot) be null. Fields may be any type. Fields may have an optional comment or doc string. Fields can have default values.

List(Vec<Option<Literal>>)

A list is a collection of values with some element type. The element field has an integer id that is unique in the table schema. Elements can be either optional or required. Element types may be any type.

Map(Map)

A map is a collection of key-value pairs with a key type and a value type. Both the key field and value field each have an integer id that is unique in the table schema. Map keys are required and map values can be either optional or required. Both map keys and map values may be any type, including nested types.

Implementations

impl Literal

pub fn bool<T: Into<bool>>(t: T) -> Self

Creates a boolean value.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t = Literal::bool(true);

assert_eq!(Literal::Primitive(PrimitiveLiteral::Boolean(true)), t);

pub fn bool_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Creates a boolean value from string. See Parse bool from str for reference.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t = Literal::bool_from_str("false").unwrap();

assert_eq!(Literal::Primitive(PrimitiveLiteral::Boolean(false)), t);

pub fn int<T: Into<i32>>(t: T) -> Self

Creates an 32bit integer.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t = Literal::int(23i8);

assert_eq!(Literal::Primitive(PrimitiveLiteral::Int(23)), t);

pub fn long<T: Into<i64>>(t: T) -> Self

Creates an 64bit integer.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t = Literal::long(24i8);

assert_eq!(Literal::Primitive(PrimitiveLiteral::Long(24)), t);

pub fn float<T: Into<f32>>(t: T) -> Self

Creates an 32bit floating point number.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
use ordered_float::OrderedFloat;
let t = Literal::float(32.1f32);

assert_eq!(
    Literal::Primitive(PrimitiveLiteral::Float(OrderedFloat(32.1))),
    t
);

pub fn double<T: Into<f64>>(t: T) -> Self

Creates an 32bit floating point number.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
use ordered_float::OrderedFloat;
let t = Literal::double(32.1f64);

assert_eq!(
    Literal::Primitive(PrimitiveLiteral::Double(OrderedFloat(32.1))),
    t
);

pub fn date(days: i32) -> Self

Creates date literal from number of days from unix epoch directly.

pub fn date_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Creates a date in %Y-%m-%d format, assume in utc timezone.

See NaiveDate::from_str.

Example

use iceberg::spec::Literal;
let t = Literal::date_from_str("1970-01-03").unwrap();

assert_eq!(Literal::date(2), t);

pub fn date_from_ymd(year: i32, month: u32, day: u32) -> Result<Self>

Create a date from calendar date (year, month and day).

See NaiveDate::from_ymd_opt.

Example:

 use iceberg::spec::Literal;
 let t = Literal::date_from_ymd(1970, 1, 5).unwrap();

 assert_eq!(Literal::date(4), t);

pub fn time(value: i64) -> Self

Creates time in microseconds directly

pub fn time_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Creates time in microseconds in %H:%M:%S:.f format.

See NaiveTime::from_str for details.

Example:

use iceberg::spec::Literal;
let t = Literal::time_from_str("01:02:01.888999777").unwrap();

let micro_secs = {
    1 * 3600 * 1_000_000 + // 1 hour
    2 * 60 * 1_000_000 +   // 2 minutes
    1 * 1_000_000 + // 1 second
    888999 // microseconds
};
assert_eq!(Literal::time(micro_secs), t);

pub fn time_from_hms_micro( hour: u32, min: u32, sec: u32, micro: u32, ) -> Result<Self>

Creates time literal from hour, minute, second, and microseconds.

See NaiveTime::from_hms_micro_opt.

Example:

use iceberg::spec::Literal;
let t = Literal::time_from_hms_micro(22, 15, 33, 111).unwrap();

assert_eq!(Literal::time_from_str("22:15:33.000111").unwrap(), t);

pub fn timestamp(value: i64) -> Self

Creates a timestamp from unix epoch in microseconds.

pub fn timestamptz(value: i64) -> Self

Creates a timestamp with timezone from unix epoch in microseconds.

pub fn timestamp_from_datetime<T: TimeZone>(dt: DateTime<T>) -> Self

Creates a timestamp from DateTime.

pub fn timestamptz_from_datetime<T: TimeZone>(dt: DateTime<T>) -> Self

Creates a timestamp with timezone from DateTime.

pub fn timestamp_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Parse a timestamp in RFC3339 format.

See DateTime<Utc>::from_str.

Example:

use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime};
use iceberg::spec::Literal;
let t = Literal::timestamp_from_str("2012-12-12 12:12:12.8899-04:00").unwrap();

let t2 = {
    let date = NaiveDate::from_ymd_opt(2012, 12, 12).unwrap();
    let time = NaiveTime::from_hms_micro_opt(12, 12, 12, 889900).unwrap();
    let dt = NaiveDateTime::new(date, time);
    Literal::timestamp_from_datetime(DateTime::<FixedOffset>::from_local(
        dt,
        FixedOffset::west_opt(4 * 3600).unwrap(),
    ))
};

assert_eq!(t, t2);

pub fn timestamptz_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Similar to Literal::timestamp_from_str, but return timestamp with timezone literal.

pub fn string<S: ToString>(s: S) -> Self

Creates a string literal.

pub fn uuid(uuid: Uuid) -> Self

Creates uuid literal.

pub fn uuid_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Creates uuid from str. See Uuid::parse_str.

Example:

use iceberg::spec::Literal;
use uuid::Uuid;
let t1 = Literal::uuid_from_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8").unwrap();
let t2 = Literal::uuid(Uuid::from_u128_le(0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1));

assert_eq!(t1, t2);

pub fn fixed<I: IntoIterator<Item = u8>>(input: I) -> Self

Creates a fixed literal from bytes.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t1 = Literal::fixed(vec![1u8, 2u8]);
let t2 = Literal::Primitive(PrimitiveLiteral::Binary(vec![1u8, 2u8]));

assert_eq!(t1, t2);

pub fn binary<I: IntoIterator<Item = u8>>(input: I) -> Self

Creates a binary literal from bytes.

Example:

use iceberg::spec::{Literal, PrimitiveLiteral};
let t1 = Literal::binary(vec![1u8, 2u8]);
let t2 = Literal::Primitive(PrimitiveLiteral::Binary(vec![1u8, 2u8]));

assert_eq!(t1, t2);

pub fn decimal(decimal: i128) -> Self

Creates a decimal literal.

pub fn decimal_from_str<S: AsRef<str>>(s: S) -> Result<Self>

Creates decimal literal from string. See [Decimal::from_str_exact].

Example:

use iceberg::spec::Literal;
use rust_decimal::Decimal;
let t1 = Literal::decimal(12345);
let t2 = Literal::decimal_from_str("123.45").unwrap();

assert_eq!(t1, t2);

impl Literal

pub fn try_from_json(value: JsonValue, data_type: &Type) -> Result<Option<Self>>

Create iceberg value from a json value

See this spec for reference.

pub fn try_into_json(self, type: &Type) -> Result<JsonValue>

Converting iceberg value to json value.

See this spec for reference.

pub fn into_any(self) -> Box<dyn Any>

Convert Value to the any type

Trait Implementations

impl Clone for Literal

fn clone(&self) -> Literal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Literal

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

Formats the value using the given formatter.

impl From<Datum> for Literal

fn from(value: Datum) -> Self

Converts to this type from the input type.

impl Hash for Literal

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 PartialEq for Literal

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Literal

impl StructuralPartialEq for Literal