Type Alias Term

pub type Term = Reference;

Unbound term before binding to a schema.

Aliased Type

struct Term { /* private fields */ }

Implementations

impl Reference

pub fn new(name: impl Into<String>) -> Self

Create a new unbound reference.

pub fn name(&self) -> &str

Return the name of this reference.

impl Reference

pub fn less_than(self, datum: Datum) -> Predicate

Creates an less than expression. For example, a < 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").less_than(Datum::long(10));

assert_eq!(&format!("{expr}"), "a < 10");

pub fn less_than_or_equal_to(self, datum: Datum) -> Predicate

Creates an less than or equal to expression. For example, a <= 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").less_than_or_equal_to(Datum::long(10));

assert_eq!(&format!("{expr}"), "a <= 10");

pub fn greater_than(self, datum: Datum) -> Predicate

Creates an greater than expression. For example, a > 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").greater_than(Datum::long(10));

assert_eq!(&format!("{expr}"), "a > 10");

pub fn greater_than_or_equal_to(self, datum: Datum) -> Predicate

Creates a greater-than-or-equal-to than expression. For example, a >= 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").greater_than_or_equal_to(Datum::long(10));

assert_eq!(&format!("{expr}"), "a >= 10");

pub fn equal_to(self, datum: Datum) -> Predicate

Creates an equal-to expression. For example, a = 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").equal_to(Datum::long(10));

assert_eq!(&format!("{expr}"), "a = 10");

pub fn not_equal_to(self, datum: Datum) -> Predicate

Creates a not equal-to expression. For example, a!= 10.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").not_equal_to(Datum::long(10));

assert_eq!(&format!("{expr}"), "a != 10");

pub fn starts_with(self, datum: Datum) -> Predicate

Creates a start-with expression. For example, a STARTS WITH "foo".

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").starts_with(Datum::string("foo"));

assert_eq!(&format!("{expr}"), r#"a STARTS WITH "foo""#);

pub fn not_starts_with(self, datum: Datum) -> Predicate

Creates a not start-with expression. For example, a NOT STARTS WITH 'foo'.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;

let expr = Reference::new("a").not_starts_with(Datum::string("foo"));

assert_eq!(&format!("{expr}"), r#"a NOT STARTS WITH "foo""#);

pub fn is_nan(self) -> Predicate

Creates an is-nan expression. For example, a IS NAN.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_nan();

assert_eq!(&format!("{expr}"), "a IS NAN");

pub fn is_not_nan(self) -> Predicate

Creates an is-not-nan expression. For example, a IS NOT NAN.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_not_nan();

assert_eq!(&format!("{expr}"), "a IS NOT NAN");

pub fn is_null(self) -> Predicate

Creates an is-null expression. For example, a IS NULL.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_null();

assert_eq!(&format!("{expr}"), "a IS NULL");

pub fn is_not_null(self) -> Predicate

Creates an is-not-null expression. For example, a IS NOT NULL.

Example

use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_not_null();

assert_eq!(&format!("{expr}"), "a IS NOT NULL");

pub fn is_in(self, literals: impl IntoIterator<Item = Datum>) -> Predicate

Creates an is-in expression. For example, a IS IN (5, 6).

Example

use fnv::FnvHashSet;
use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_in([Datum::long(5), Datum::long(6)]);

let as_string = format!("{expr}");
assert!(&as_string == "a IN (5, 6)" || &as_string == "a IN (6, 5)");

pub fn is_not_in(self, literals: impl IntoIterator<Item = Datum>) -> Predicate

Creates an is-not-in expression. For example, a IS NOT IN (5, 6).

Example

use fnv::FnvHashSet;
use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr = Reference::new("a").is_not_in([Datum::long(5), Datum::long(6)]);

let as_string = format!("{expr}");
assert!(&as_string == "a NOT IN (5, 6)" || &as_string == "a NOT IN (6, 5)");

Trait Implementations

impl Bind for Reference

type Bound = BoundReference

The type of the bound result.

fn bind(&self, schema: SchemaRef, case_sensitive: bool) -> Result<Self::Bound>

Bind an expression to a schema.

impl Clone for Reference

fn clone(&self) -> Reference

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Reference

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Reference

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Reference

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

Formats the value using the given formatter.

impl PartialEq for Reference

fn eq(&self, other: &Reference) -> 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 Reference

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 Reference