Struct Cardinality

pub struct Cardinality {
    lo: usize,
    hi: Hi,
}

The cardinality of the output rows of a plan node. Bounds are inclusive.

The default value is 0.., i.e. the number of rows is unknown.

Fields

lo: usize

hi: Hi

Implementations

impl Cardinality

pub const fn unknown() -> Self

Creates a new Cardinality of 0.., i.e. the number of rows is unknown.

pub fn new(lo: usize, hi: impl Into<Hi>) -> Self

Creates a new Cardinality with the given lower and upper bounds.

pub fn lo(self) -> usize

Returns the lower bound of the cardinality.

pub fn hi(self) -> Option<usize>

Returns the upper bound of the cardinality, None if the upper bound is unlimited.

pub fn min(self, rhs: impl Into<Self>) -> Self

Returns the minimum of the two cardinalities, where the lower and upper bounds are respectively the minimum of the lower and upper bounds of the two cardinalities.

let card1 = Cardinality::from(3..);
let card2 = Cardinality::from(5..=8);
let card3 = Cardinality::from(3..=8);
assert_eq!(card1.min(card2), card3);

// Limit both the lower and upper bounds to a single value, a.k.a. "limit_to".
let card1 = Cardinality::from(3..=10);
let card2 = Cardinality::from(5);
let card3 = Cardinality::from(3..=5);
assert_eq!(card1.min(card2), card3);

// Limit the lower bound to a value, a.k.a. "as_low_as".
let card1 = Cardinality::from(3..=10);
let card2 = Cardinality::from(1..);
let card3 = Cardinality::from(1..=10);
assert_eq!(card1.min(card2), card3);

pub fn max(self, rhs: impl Into<Self>) -> Self

Returns the maximum of the two cardinalities, where the lower and upper bounds are respectively the maximum of the lower and upper bounds of the two cardinalities.

let card1 = Cardinality::from(3..);
let card2 = Cardinality::from(5..=8);
let card3 = Cardinality::from(5..);
assert_eq!(card1.max(card2), card3);

impl Cardinality

pub fn get_exact(self) -> Option<usize>

Returns the cardinality if it is exact, None otherwise.

let card = Cardinality::from(3..=3);
assert_eq!(card.get_exact(), Some(3));

let card = Cardinality::from(3..=4);
assert_eq!(card.get_exact(), None);

pub fn is_at_most(self, count: usize) -> bool

Returns true if the cardinality is at most count rows.

let card = Cardinality::from(3..=5);
assert!(card.is_at_most(5));
assert!(card.is_at_most(6));
assert!(!card.is_at_most(4));

let card = Cardinality::from(3..);
assert!(!card.is_at_most(usize::MAX));

impl Cardinality

pub fn to_protobuf(self) -> PbCardinality

pub fn from_protobuf(pb: &PbCardinality) -> Self

Trait Implementations

impl<T: Into<Cardinality>> Add<T> for Cardinality

fn add(self, rhs: T) -> Self::Output

Returns the sum of the two cardinalities, where the lower and upper bounds are respectively the sum of the lower and upper bounds of the two cardinalities.

let card1 = Cardinality::from(3..=5);
let card2 = Cardinality::from(5..=10);
let card3 = Cardinality::from(8..=15);
assert_eq!(card1 + card2, card3);

let card1 = Cardinality::from(3..);
let card2 = Cardinality::from(5..=10);
let card3 = Cardinality::from(8..);
assert_eq!(card1 + card2, card3);

type Output = Cardinality

The resulting type after applying the + operator.

impl Clone for Cardinality

fn clone(&self) -> Cardinality

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cardinality

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

Formats the value using the given formatter.

impl Default for Cardinality

fn default() -> Self

Returns the “default value” for a type.

impl Display for Cardinality

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

Formats the value using the given formatter.

impl From<RangeFrom<usize>> for Cardinality

fn from(value: RangeFrom<usize>) -> Self

Converts a range with unlimited upper bound to a Cardinality.

let card = Cardinality::from(10..);
assert_eq!(card.lo(), 10);
assert_eq!(card.hi(), None);

impl From<RangeInclusive<usize>> for Cardinality

fn from(value: RangeInclusive<usize>) -> Self

Converts an inclusive range to a Cardinality.

let card = Cardinality::from(0..=10);
assert_eq!(card.lo(), 0);
assert_eq!(card.hi(), Some(10));

impl From<usize> for Cardinality

fn from(value: usize) -> Self

Converts a single value to a Cardinality with the same lower and upper bounds, i.e. the value is exact.

let card = Cardinality::from(10);
assert_eq!(card.lo(), 10);
assert_eq!(card.hi(), Some(10));

impl Hash for Cardinality

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<T: Into<Cardinality>> Mul<T> for Cardinality

fn mul(self, rhs: T) -> Self::Output

Returns the product of the two cardinalities, where the lower and upper bounds are respectively the product of the lower and upper bounds of the two cardinalities.

let card1 = Cardinality::from(2..=4);
let card2 = Cardinality::from(3..=5);
let card3 = Cardinality::from(6..=20);
assert_eq!(card1 * card2, card3);

let card1 = Cardinality::from(2..);
let card2 = Cardinality::from(3..=5);
let card3 = Cardinality::from(6..);
assert_eq!(card1 * card2, card3);

let card1 = Cardinality::from((usize::MAX - 1)..=(usize::MAX));
let card2 = Cardinality::from(3..=5);
let card3 = Cardinality::from((usize::MAX)..);
assert_eq!(card1 * card2, card3);

// Or directly with a scalar.
let card = Cardinality::from(3..=5);
assert_eq!(card * 2, Cardinality::from(6..=10));

let card = Cardinality::from(3..);
assert_eq!(card * 2, Cardinality::from(6..));

let card = Cardinality::from((usize::MAX - 1)..=(usize::MAX));
assert_eq!(card * 2, Cardinality::from((usize::MAX)..));

type Output = Cardinality

The resulting type after applying the * operator.

impl PartialEq for Cardinality

fn eq(&self, other: &Cardinality) -> 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 Sub<usize> for Cardinality

fn sub(self, rhs: usize) -> Self::Output

Returns the cardinality with both lower and upper bounds subtracted by rhs.

let card = Cardinality::from(3..=5);
assert_eq!(card - 2, Cardinality::from(1..=3));
assert_eq!(card - 4, Cardinality::from(0..=1));
assert_eq!(card - 6, Cardinality::from(0));

let card = Cardinality::from(3..);
assert_eq!(card - 2, Cardinality::from(1..));
assert_eq!(card - 4, Cardinality::from(0..));

type Output = Cardinality

The resulting type after applying the - operator.

impl Copy for Cardinality

impl Eq for Cardinality

impl StructuralPartialEq for Cardinality