Struct TableSchema

pub struct TableSchema {
    pub table_id: TableId,
    pub table_name: Box<str>,
    pub primary_key: Option<ColId>,
    pub indexes: Vec<IndexSchema>,
    pub constraints: Vec<ConstraintSchema>,
    pub sequences: Vec<SequenceSchema>,
    pub table_type: StTableType,
    pub table_access: StAccess,
    pub schedule: Option<ScheduleSchema>,
    /* private fields */
}

A data structure representing the schema of a database table.

This struct holds information about the table, including its identifier, name, columns, indexes, constraints, sequences, type, and access rights.

Fields

table_id: TableId

The unique identifier of the table within the database.

table_name: Box<str>

The name of the table.

primary_key: Option<ColId>

The primary key of the table, if present. Must refer to a valid column.

Currently, there must be a unique constraint and an index corresponding to the primary key. Eventually, we may remove the requirement for an index.

The database engine does not actually care about this, but client code generation does.

indexes: Vec<IndexSchema>

The indexes on the table.

constraints: Vec<ConstraintSchema>

The constraints on the table.

sequences: Vec<SequenceSchema>

The sequences on the table.

table_type: StTableType

Whether the table was created by a user or by the system.

table_access: StAccess

The visibility of the table.

schedule: Option<ScheduleSchema>

The schedule for the table, if present.

Implementations

impl TableSchema

pub fn new( table_id: TableId, table_name: Box<str>, columns: Vec<ColumnSchema>, indexes: Vec<IndexSchema>, constraints: Vec<ConstraintSchema>, sequences: Vec<SequenceSchema>, table_type: StTableType, table_access: StAccess, schedule: Option<ScheduleSchema>, primary_key: Option<ColId>, ) -> Self

Create a table schema.

pub fn update_table_id(&mut self, id: TableId)

Update the table id of this schema. For use by the core database engine after assigning a table id.

pub fn into_columns(self) -> Vec<ColumnSchema>

Convert a table schema into a list of columns.

pub fn columns(&self) -> &[ColumnSchema]

Get the columns of the table. Only immutable access to the columns is provided. The ordering of the columns is significant. Columns are frequently identified by ColId, that is, position in this list.

pub fn take_adjacent_schemas( &mut self, ) -> (Vec<IndexSchema>, Vec<SequenceSchema>, Vec<ConstraintSchema>)

Extracts all the Self::indexes, Self::sequences, and Self::constraints.

pub fn update_sequence(&mut self, of: SequenceSchema)

Add OR replace the SequenceSchema

pub fn remove_sequence( &mut self, sequence_id: SequenceId, ) -> Option<SequenceSchema>

Removes the given sequence_id

pub fn update_index(&mut self, of: IndexSchema)

Add OR replace the IndexSchema

pub fn remove_index(&mut self, index_id: IndexId) -> Option<IndexSchema>

Removes the given index_id

pub fn update_constraint(&mut self, of: ConstraintSchema)

Add OR replace the ConstraintSchema

pub fn remove_constraint( &mut self, constraint_id: ConstraintId, ) -> Option<ConstraintSchema>

Removes the given index_id

pub fn generate_cols_name(&self, columns: &ColList) -> String

Concatenate the column names from the columns

WARNING: If the ColId not exist, is skipped. TODO(Tyler): This should return an error and not allow this to be constructed if there is an invalid ColId

pub fn get_column_by_field(&self, field: FieldName) -> Option<&ColumnSchema>

Check if the specified field exists in this TableSchema.

Warning

This function ignores the table_id when searching for a column.

pub fn get_columns<'a>( &'a self, columns: &'a ColList, ) -> impl 'a + Iterator<Item = (ColId, Option<&'a ColumnSchema>)>

Look up a list of columns by their positions in the table. Invalid column positions are permitted.

pub fn get_column(&self, pos: usize) -> Option<&ColumnSchema>

Get a reference to a column by its position (pos) in the table.

pub fn get_column_by_name(&self, col_name: &str) -> Option<&ColumnSchema>

Check if the col_name exist on this TableSchema

pub fn get_column_id_by_name(&self, col_name: &str) -> Option<ColId>

Check if the col_name exist on this TableSchema

Warning: It ignores the table_name

pub fn col_list_for_index_id(&self, index_id: IndexId) -> ColList

Retrieve the column ids for this index id

pub fn is_unique(&self, cols: &ColList) -> bool

Is there a unique constraint for this set of columns?

pub fn project( &self, indexes: impl Iterator<Item = ColId>, ) -> Result<Vec<&ColumnSchema>, InvalidFieldError>

Project the fields from the supplied indexes.

pub fn project_not_empty( &self, indexes: ColList, ) -> Result<Vec<&ColumnSchema>, InvalidFieldError>

Utility for project the fields from the supplied indexes that is a ColList, used for when the list of field indexes have at least one value.

pub fn get_row_type(&self) -> &ProductType

IMPORTANT: Is required to have this cached to avoid a perf drop on datastore operations

pub fn into_row_type(self) -> ProductType

Utility to avoid cloning in row_type_for_table

pub fn backcompat_constraints(&self) -> BTreeMap<ColList, Constraints>

Get backwards-compatible constraints for this table.

This is closer to how TableSchema used to work.

pub fn backcompat_column_constraints(&self) -> BTreeMap<ColList, Constraints>

Get backwards-compatible constraints for this table.

Resolves the constraints per each column. If the column don’t have one, auto-generate Constraints::unset(). This guarantee all columns can be queried for it constraints.

pub fn pk(&self) -> Option<&ColumnSchema>

Get the column corresponding to the primary key, if any.

pub fn validated(self) -> Result<Self, Vec<SchemaError>>

Verify the definitions of this schema are valid:

• Check all names are not empty
• All columns exists
• Only 1 PK
• Only 1 sequence per column
• Only Btree Indexes

Deprecated. This will eventually be replaced by the schema crate.

pub fn janky_fix_column_defs(&mut self, module_def: &ModuleDef)

The C# and Rust SDKs are inconsistent about whether v8 column defs store resolved or unresolved algebraic types. This method works around this problem by copying the column types from the module def into the table schema. It can be removed once v8 is removed, since v9 will reject modules with an inconsistency like this.

pub fn normalize(&mut self)

Normalize a TableSchema. The result is semantically equivalent, but may have reordered indexes, constraints, or sequences. Columns will not be reordered.

Trait Implementations

impl Clone for TableSchema

fn clone(&self) -> TableSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableSchema

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

Formats the value using the given formatter.

impl From<&TableSchema> for DbTable

fn from(value: &TableSchema) -> Self

Converts to this type from the input type.

impl From<&TableSchema> for Header

fn from(value: &TableSchema) -> Self

Converts to this type from the input type.

impl From<&TableSchema> for ProductType

fn from(value: &TableSchema) -> Self

Converts to this type from the input type.

impl From<TableSchema> for Header

fn from(schema: TableSchema) -> Self

Converts to this type from the input type.

impl PartialEq for TableSchema

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

type Def = TableDef

The Def type corresponding to this schema type.

type Id = TableId

The Id type corresponding to this schema type.

type ParentId = ()

The Id type corresponding to the parent of this schema type. Set to () if there is no parent.

fn from_module_def( module_def: &ModuleDef, def: &Self::Def, _parent_id: Self::ParentId, table_id: Self::Id, ) -> Self

Construct a schema entity from a validated ModuleDef. Panics if module_def does not contain def.

fn check_compatible( &self, module_def: &ModuleDef, def: &Self::Def, ) -> Result<(), Error>

Check that a schema entity is compatible with a definition.

impl Eq for TableSchema

impl StructuralPartialEq for TableSchema