Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.7 KB
Raw Blame
//! `ALTER TABLE … ALTER COLUMN … TYPE …` and the column types it names.

use nom::Parser;
use nom::branch::alt;
use nom::combinator::{cut, not, opt};
use nom::sequence::{preceded, terminated};
use strum::IntoEnumIterator;

use models_databases::cast::ColumnTypeName;
use models_databases::{ColumnKind as OpColumnKind, EntityKind as OpEntityKind};

use super::super::ast::AlterColumnType;
use super::super::lexer::TokenKind;
use super::{ParseResult, Tokens, identifier, keyword, message_at, next_token, table, token, word};
use crate::catalog::EntityKind;

const COLUMN_TYPES: &str = "text, number, boolean, date, date_range, link, select, select_number, tag or \
                            entity(<KIND>) such as entity(USER); add [] after select, \
                            select_number or entity(…) for several values";

pub(super) fn alter(input: Tokens<'_>) -> ParseResult<'_, AlterColumnType> {
    let (input, ()) = word("alter", "ALTER")(input)?;
    let (input, ()) = cut(word("table", "TABLE after ALTER")).parse(input)?;
    let (input, table) =
        cut(table("a table name after ALTER TABLE, like database.table")).parse(input)?;
    let (input, ()) = cut(word(
        "alter",
        "ALTER COLUMN after the table name (ALTER TABLE only changes a column's type)",
    ))
    .parse(input)?;
    // A column itself named `column` is the one followed by `TYPE`.
    let (input, column) = cut(preceded(
        opt(terminated(word("column", ""), not(word("type", "")))),
        identifier("the column to change after ALTER COLUMN"),
    ))
    .parse(input)?;
    let (input, ()) = cut(word("type", "TYPE and the new type after the column")).parse(input)?;
    let (input, to) = column_type(input)?;
    Ok((input, AlterColumnType { table, column, to }))
}

/// `name` or `entity(KIND)`, either with `[]` for several values.
pub(super) fn column_type(input: Tokens<'_>) -> ParseResult<'_, OpColumnKind> {
    alt((preceded(word("entity", ""), cut(entity_type)), plain_type)).parse(input)
}

/// `[]` after a type: whether a cell holds several values.
fn several(input: Tokens<'_>) -> ParseResult<'_, bool> {
    opt(preceded(
        keyword(TokenKind::LeftBracket),
        cut(token(TokenKind::RightBracket, "] after [")),
    ))
    .map(|brackets| brackets.is_some())
    .parse(input)
}

fn plain_type(input: Tokens<'_>) -> ParseResult<'_, OpColumnKind> {
    let (rest, name) = cut(next_token(
        format!("a column type: {COLUMN_TYPES}"),
        |token| match &token.kind {
            TokenKind::Identifier(name) => Some(name.as_str()),
            TokenKind::Select => Some("select"),
            _ => None,
        },
    ))
    .parse(input)?;
    let unknown = || {
        nom::Err::Failure(message_at(
            input,
            &format!("unknown column type \"{name}\"; the types are {COLUMN_TYPES}"),
        ))
    };
    let type_name: ColumnTypeName = name.parse().map_err(|_| unknown())?;
    let (end, multi) = several(rest)?;
    let single = |to: OpColumnKind| {
        if multi {
            let name: &'static str = type_name.into();
            Err(nom::Err::Failure(message_at(
                rest,
                &format!("{name} holds one value; [] is for select, select_number and entity(…)"),
            )))
        } else {
            Ok(to)
        }
    };
    let to = match type_name {
        ColumnTypeName::Text => single(OpColumnKind::Text)?,
        ColumnTypeName::Number => single(OpColumnKind::Number)?,
        ColumnTypeName::Boolean => single(OpColumnKind::Boolean)?,
        ColumnTypeName::Date => single(OpColumnKind::Date)?,
        ColumnTypeName::DateRange => single(OpColumnKind::DateRange)?,
        ColumnTypeName::Link => single(OpColumnKind::Link)?,
        ColumnTypeName::Select => OpColumnKind::Select { multi },
        ColumnTypeName::SelectNumber => OpColumnKind::SelectNumber { multi },
        ColumnTypeName::Tag if multi => {
            return Err(nom::Err::Failure(message_at(
                rest,
                "tag always holds several values; write tag",
            )));
        }
        ColumnTypeName::Tag => OpColumnKind::Tag,
        // `entity` is only a type with its kind, and a relation is made
        // through the server schema grammar.
        ColumnTypeName::Entity | ColumnTypeName::Relation => return Err(unknown()),
    };
    Ok((end, to))
}

/// `(KIND)` after `entity`, and the `[]` that may follow.
fn entity_type(input: Tokens<'_>) -> ParseResult<'_, OpColumnKind> {
    let (input, ()) = cut(token(
        TokenKind::LeftParen,
        "( and an entity kind after entity, like entity(USER)",
    ))
    .parse(input)?;
    let (rest, written) = cut(next_token(
        "an entity kind such as USER",
        |token| match &token.kind {
            TokenKind::Identifier(written) => Some(written.as_str()),
            _ => None,
        },
    ))
    .parse(input)?;
    let target = match written.parse::<EntityKind>() {
        Ok(kind) => OpEntityKind::try_from(kind).map_err(|_| {
            nom::Err::Failure(message_at(
                input,
                "use relation([database.]table) to reference another table's rows",
            ))
        })?,
        Err(_) => {
            let kinds: Vec<&str> = EntityKind::iter()
                .filter(|kind| *kind != EntityKind::Row)
                .map(EntityKind::sql_name)
                .collect();
            return Err(nom::Err::Failure(message_at(
                input,
                &format!(
                    "unknown entity kind \"{written}\"; the kinds are {}",
                    kinds.join(", ")
                ),
            )));
        }
    };
    let (rest, ()) = cut(token(TokenKind::RightParen, ") after the entity kind")).parse(rest)?;
    let (rest, multi) = several(rest)?;
    Ok((rest, OpColumnKind::Entity { target, multi }))
}