use crate::{
ast::{ColumnDef, TableKeyConstraint, TableKeyConstraintKind},
SQLError,
};
pub struct AddedKeyRelation<'a> {
pub table: &'a str,
pub columns: &'a [ColumnDef],
pub keys: &'a [TableKeyConstraint],
pub partition: Option<&'a crate::ast::PartitionSpec>,
}
mod not_null;
pub use not_null::{
validate_primary_key_not_null_child, validate_primary_key_not_null_constraint,
validate_primary_key_not_null_constraints, validate_primary_key_not_null_target,
};
pub fn validate_added_key(
relation: &AddedKeyRelation<'_>,
key: &TableKeyConstraint,
) -> Result<(), SQLError> {
validate_added_key_declaration(relation.columns, key)?;
if key.kind == TableKeyConstraintKind::PrimaryKey {
for name in &key.columns {
validate_primary_key_not_null_target(relation.table, relation.columns, name)?;
}
}
definition::validate_added_key_definition(
&definition::KeyRelation {
table: relation.table,
columns: relation.columns,
partition: relation.partition,
has_primary_key: relation
.keys
.iter()
.any(|existing| existing.kind == TableKeyConstraintKind::PrimaryKey),
},
key,
)
}
pub fn validate_added_key_declaration(
columns: &[ColumnDef],
key: &TableKeyConstraint,
) -> Result<(), SQLError> {
if let Some(column) = key
.columns
.iter()
.enumerate()
.find_map(|(position, column)| key.columns[..position].contains(column).then_some(column))
{
return Err(definition::repeated_key_column(key.kind, column));
}
let column = |name: &str| columns.iter().find(|column| column.name == name);
let system = definition::is_system_column;
if key.without_overlaps {
if let Some(period) = key.columns.last() {
if let Some(found) = column(period) {
definition::validate_overlaps_column(period, Some(&found.ty))?;
} else if system(period) {
definition::validate_overlaps_column(period, None)?;
}
}
}
definition::validate_overlaps_key_length(key)?;
Ok(())
}
pub fn transform_column_keys(
relation: &str,
keys: &[TableKeyConstraint],
) -> Result<Vec<TableKeyConstraint>, SQLError> {
if keys
.iter()
.filter(|key| key.kind == TableKeyConstraintKind::PrimaryKey)
.count()
> 1
{
return Err(definition::multiple_primary_keys(relation));
}
Ok(definition::index_order(keys.to_vec()))
}
pub fn apply_primary_key_columns(
table: &str,
constraint: &TableKeyConstraint,
columns: &mut [ColumnDef],
) -> Result<(), String> {
if constraint.kind == TableKeyConstraintKind::PrimaryKey {
for key_column in &constraint.columns {
let column = columns
.iter_mut()
.find(|column| column.name == *key_column)
.ok_or_else(|| {
format!("column `{key_column}` does not exist on table `{table}`")
})?;
column.not_null = true;
}
}
Ok(())
}
pub mod definition;
#[cfg(test)]
mod tests;