Struct RelationDesc

pub struct RelationDesc {
    typ: SqlRelationType,
    metadata: BTreeMap<ColumnIndex, ColumnMetadata>,
}

A description of the shape of a relation.

It bundles a SqlRelationType with ColumnMetadata for each column in the relation.

Examples

A RelationDescs is typically constructed via its builder API:

use mz_repr::{SqlColumnType, RelationDesc, SqlScalarType};

let desc = RelationDesc::builder()
    .with_column("id", SqlScalarType::Int64.nullable(false))
    .with_column("price", SqlScalarType::Float64.nullable(true))
    .finish();

In more complicated cases, like when constructing a RelationDesc in response to user input, it may be more convenient to construct a relation type first, and imbue it with column names to form a RelationDesc later:

use mz_repr::RelationDesc;

let relation_type = plan_query("SELECT * FROM table");
let names = (0..relation_type.arity()).map(|i| match i {
    0 => "first",
    1 => "second",
    _ => "unknown",
});
let desc = RelationDesc::new(relation_type, names);

Next to the SqlRelationType we maintain a map of ColumnIndex to ColumnMetadata, where ColumnIndex is a stable identifier for a column throughout the lifetime of the relation. This allows a RelationDesc to represent a projection over a version of itself.

use std::collections::BTreeSet;
use mz_repr::{ColumnIndex, RelationDesc, SqlScalarType};

let desc = RelationDesc::builder()
    .with_column("name", SqlScalarType::String.nullable(false))
    .with_column("email", SqlScalarType::String.nullable(false))
    .finish();

// Project away the second column.
let demands = BTreeSet::from([1]);
let proj = desc.apply_demand(&demands);

// We projected away the first column.
assert!(!proj.contains_index(&ColumnIndex::from_raw(0)));
// But retained the second.
assert!(proj.contains_index(&ColumnIndex::from_raw(1)));

// The underlying `SqlRelationType` also contains a single column.
assert_eq!(proj.typ().arity(), 1);

To maintain this stable mapping and track the lifetime of a column (e.g. when adding or dropping a column) we use ColumnMetadata. It maintains the index in SqlRelationType that corresponds to a given column, and the version at which this column was added or dropped.

Fields

typ: SqlRelationType

metadata: BTreeMap<ColumnIndex, ColumnMetadata>

Implementations

impl RelationDesc

pub fn builder() -> RelationDescBuilder

Returns a RelationDescBuilder that can be used to construct a RelationDesc.

pub fn empty() -> Self

Constructs a new RelationDesc that represents the empty relation with no columns and no keys.

pub fn is_empty(&self) -> bool

Check if the RelationDesc is empty.

pub fn len(&self) -> usize

Returns the number of columns in this RelationDesc.

pub fn new<I, N>(typ: SqlRelationType, names: I) -> Self

where I: IntoIterator<Item = N>, N: Into<ColumnName>,

Constructs a new RelationDesc from a SqlRelationType and an iterator over column names.

Panics

Panics if the arity of the SqlRelationType is not equal to the number of items in names.

pub fn from_names_and_types<I, T, N>(iter: I) -> Self

where I: IntoIterator<Item = (N, T)>, T: Into<SqlColumnType>, N: Into<ColumnName>,

pub fn concat(self, other: Self) -> Self

Concatenates a RelationDesc onto the end of this RelationDesc.

Panics

Panics if either self or other have columns that were added at a RelationVersion other than RelationVersion::root or if any columns were dropped.

TODO(parkmycar): Move this method to RelationDescBuilder.

pub fn with_key(self, indices: Vec<usize>) -> Self

Adds a new key for the relation.

pub fn without_keys(self) -> Self

Drops all existing keys.

pub fn with_names<I, N>(self, names: I) -> Self

where I: IntoIterator<Item = N>, N: Into<ColumnName>,

Builds a new relation description with the column names replaced with new names.

Panics

Panics if the arity of the relation type does not match the number of items in names.

pub fn arity(&self) -> usize

Computes the number of columns in the relation.

pub fn typ(&self) -> &SqlRelationType

Returns the relation type underlying this relation description.

pub fn iter(&self) -> impl Iterator<Item = (&ColumnName, &SqlColumnType)>

Returns an iterator over the columns in this relation.

pub fn iter_types(&self) -> impl Iterator<Item = &SqlColumnType>

Returns an iterator over the types of the columns in this relation.

pub fn iter_names(&self) -> impl Iterator<Item = &ColumnName>

Returns an iterator over the names of the columns in this relation.

pub fn iter_all( &self, ) -> impl Iterator<Item = (&ColumnIndex, &ColumnName, &SqlColumnType)>

Returns an iterator over the columns in this relation, with all their metadata.

pub fn iter_similar_names<'a>( &'a self, name: &'a ColumnName, ) -> impl Iterator<Item = &'a ColumnName>

Returns an iterator over the names of the columns in this relation that are “similar” to the provided name.

pub fn contains_index(&self, idx: &ColumnIndex) -> bool

Returns whether this RelationDesc contains a column at the specified index.

pub fn get_by_name(&self, name: &ColumnName) -> Option<(usize, &SqlColumnType)>

Finds a column by name.

Returns the index and type of the column named name. If no column with the specified name exists, returns None. If multiple columns have the specified name, the leftmost column is returned.

pub fn get_name(&self, i: usize) -> &ColumnName

Gets the name of the ith column.

Panics

Panics if i is not a valid column index.

TODO(parkmycar): Migrate all uses of this to RelationDesc::get_name_idx.

pub fn get_name_idx(&self, idx: &ColumnIndex) -> &ColumnName

Gets the name of the column at idx.

Panics

Panics if no column exists at idx.

pub fn get_name_mut(&mut self, i: usize) -> &mut ColumnName

Mutably gets the name of the ith column.

Panics

Panics if i is not a valid column index.

pub fn get_type(&self, idx: &ColumnIndex) -> &SqlColumnType

Gets the SqlColumnType of the column at idx.

Panics

Panics if no column exists at idx.

pub fn get_unambiguous_name(&self, i: usize) -> Option<&ColumnName>

Gets the name of the ith column if that column name is unambiguous.

If at least one other column has the same name as the ith column, returns None. If the ith column has no name, returns None.

Panics

Panics if i is not a valid column index.

pub fn constraints_met( &self, i: usize, d: &Datum<'_>, ) -> Result<(), NotNullViolation>

Verifies that d meets all of the constraints for the ith column of self.

n.b. The only constraint MZ currently supports in NOT NULL, but this structure will be simple to extend.

pub fn apply_demand(&self, demands: &BTreeSet<usize>) -> RelationDesc

Creates a new RelationDesc retaining only the columns specified in demands.

Trait Implementations

impl Arbitrary for RelationDesc

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<RelationDesc>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for RelationDesc

fn clone(&self) -> RelationDesc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelationDesc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelationDesc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RelationDesc

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 IntoIterator for RelationDesc

type Item = (ColumnName, SqlColumnType)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = (ColumnName, SqlColumnType)>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl MzReflect for RelationDesc

fn add_to_reflected_type_info(rti: &mut ReflectedTypeInfo)

Adds names and types of the fields of the struct or enum to rti.

impl PartialEq for RelationDesc

fn eq(&self, other: &RelationDesc) -> 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 RustType<ProtoRelationDesc> for RelationDesc

fn into_proto(&self) -> ProtoRelationDesc

Convert a Self into a Proto value.

fn from_proto(proto: ProtoRelationDesc) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl Schema<Row> for RelationDesc

type ArrowColumn = StructArray

The type of column we decode from, and encoder will finish into.

type Statistics = OptionStats<StructStats>

Statistics we collect for a schema of this type.

type Decoder = RowColumnarDecoder

Type that is able to decode values of T from Self::ArrowColumn.

type Encoder = RowColumnarEncoder

Type that is able to encoder values of T.

fn decoder(&self, col: Self::ArrowColumn) -> Result<Self::Decoder, Error>

Returns a type that is able to decode instances of T from the provider column.

fn encoder(&self) -> Result<Self::Encoder, Error>

Returns a type that can encode values of T.

fn decoder_any(&self, col: &dyn Array) -> Result<Self::Decoder, Error>

Returns a type that is able to decode instances of T from a type erased arrow::array::Array, erroring if the provided array is not Self::ArrowColumn.

impl Serialize for RelationDesc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RelationDesc

impl StructuralPartialEq for RelationDesc