Struct mz_repr::relation::RelationDesc

pub struct RelationDesc {
    typ: RelationType,
    names: Vec<ColumnName>,
}

A description of the shape of a relation.

It bundles a RelationType with the name of each column in the relation. Individual column names are optional.

Examples

A RelationDescs is typically constructed via its builder API:

use mz_repr::{ColumnType, RelationDesc, ScalarType};

let desc = RelationDesc::empty()
    .with_column("id", ScalarType::Int64.nullable(false))
    .with_column("price", ScalarType::Float64.nullable(true));

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);

Fields

typ: RelationType

names: Vec<ColumnName>

Implementations

impl RelationDesc

pub fn empty() -> Self

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

pub fn new<I, N>(typ: RelationType, names: I) -> Selfwhere
    I: IntoIterator<Item = N>,
    N: Into<ColumnName>,

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

Panics

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

pub fn from_names_and_types<I, T, N>(iter: I) -> Selfwhere
    I: IntoIterator<Item = (N, T)>,
    T: Into<ColumnType>,
    N: Into<ColumnName>,

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

Concatenates a RelationDesc onto the end of this RelationDesc.

pub fn with_column<N>(self, name: N, column_type: ColumnType) -> Selfwhere
    N: Into<ColumnName>,

Appends a column with the specified name and type.

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) -> Selfwhere
    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) -> &RelationType

Returns the relation type underlying this relation description.

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

Returns an iterator over the columns in this relation.

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

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 get_by_name(&self, name: &ColumnName) -> Option<(usize, &ColumnType)>

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.

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_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.

Trait Implementations

impl Arbitrary for RelationDesc

type Parameters = (<RelationType as Arbitrary>::Parameters, <Vec<ColumnName, Global> as Arbitrary>::Parameters)

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

type Strategy = Map<(<RelationType as Arbitrary>::Strategy, <Vec<ColumnName, Global> as Arbitrary>::Strategy), fn((RelationType, Vec<ColumnName, Global>)) -> RelationDesc>

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

fn arbitrary_with(_top: 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 copy 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,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for RelationDesc

type Item = (ColumnName, ColumnType)

The type of the elements being iterated over.

type IntoIter = Zip<IntoIter<ColumnName, Global>, IntoIter<ColumnType, Global>>

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

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

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

impl StructuralPartialEq for RelationDesc