feat: ADR-0035 4a — SQL CREATE TABLE command, worker, and exit gate
Command + builder + worker for advanced-mode SQL CREATE TABLE (sub-phase 4a), executed structurally through do_create_table: - Command::SqlCreateTable + build_sql_create_table (ddl.rs): aliases via from_sql_name (incl. double precision), column- and table-level PRIMARY KEY, redundant-flag de-dup off a sole PK, IF NOT EXISTS. Advanced REGISTRY entry on the shared `create` word (SQL-first, DSL fallback); no-PK tables allowed (user-confirmed). - Worker (db.rs): Request::SqlCreateTable + CreateOutcome + snapshot_then (one undo step); IF NOT EXISTS no-op (no snapshot, but journalled, like read-only commands). do_create_table inline-PK rule aligned with the rebuild generator schema_to_ddl — no round-trip DDL drift; serial autoincrement is independent of inline-PK (verified by round-trip tests). - Runtime/App: dispatch + CommandOutcome::SchemaSkipped + AppEvent::DslCreateSkipped (structure + "already exists — skipped" note). Friendly catalog keys added (engine-neutral). DEFAULT/CHECK/table-level UNIQUE are absent from the 4a grammar (parse error with usage skeleton; friendly message + support land in the 4a.2 constraint slice) — user-confirmed. Tests: type resolver, grammar shape, builder (incl. the PK detection bug they caught), and tests/sql_create_table.rs (worker round-trip, serial autoincrement first/non-first across rebuild, IF NOT EXISTS no-op + journalling, no-PK table, one undo step) + a replay-as- write test. 1739 pass / 0 fail / 1 ignored; clippy clean. Exit gate: ADR-0035 Proposed -> Accepted (validated end-to-end by 4a); README + requirements.md Q1 updated.
This commit is contained in:
claude@clouddev1
@@ -1288,6 +1288,135 @@ pub static CREATE: CommandNode = CommandNode {
|
||||
help_id: Some("ddl.create"),
|
||||
usage_ids: &["parse.usage.create_table"],};
|
||||
|
||||
/// Build a `Command::SqlCreateTable` from the advanced-mode SQL
|
||||
/// `CREATE TABLE` shape (ADR-0035 §1, sub-phase 4a). Executes
|
||||
/// structurally — extracts the same `ColumnSpec`/`primary_key` the
|
||||
/// simple-mode builder produces so the worker reuses `do_create_table`.
|
||||
///
|
||||
/// 4a surface: columns + types (the §3 alias map incl. `double
|
||||
/// precision`) + `NOT NULL` / `UNIQUE` / column- and table-level
|
||||
/// `PRIMARY KEY` + `IF NOT EXISTS`. `DEFAULT` / `CHECK` /
|
||||
/// table-level `UNIQUE` are absent from the grammar (4a.2), so they
|
||||
/// never reach this builder.
|
||||
fn build_sql_create_table(path: &MatchedPath, _source: &str) -> Result<Command, ValidationError> {
|
||||
let name = require_ident(path, "table_name")?;
|
||||
// `if` only appears in the `IF NOT EXISTS` prefix (the `not` of
|
||||
// `NOT NULL` never carries an `if`), so its presence is the flag.
|
||||
let if_not_exists = path
|
||||
.items
|
||||
.iter()
|
||||
.any(|i| matches!(i.kind, MatchedKind::Word("if")));
|
||||
|
||||
let mut columns: Vec<ColumnSpec> = Vec::new();
|
||||
let mut primary_key: Vec<String> = Vec::new();
|
||||
let mut pending_name: Option<String> = None;
|
||||
let mut items = path.items.iter().peekable();
|
||||
while let Some(item) = items.next() {
|
||||
match &item.kind {
|
||||
// A column name stashes until its type finalises the spec.
|
||||
MatchedKind::Ident { role: "col_name", .. } => {
|
||||
pending_name = Some(item.text.clone());
|
||||
}
|
||||
// Single-word type — resolve through the SQL alias map.
|
||||
MatchedKind::Ident { role: "col_type", .. } => {
|
||||
let ty = Type::from_sql_name(&item.text).ok_or_else(|| ValidationError {
|
||||
message_key: "parse.error_wrapper",
|
||||
args: vec![("detail", "unknown type".to_string())],
|
||||
})?;
|
||||
let col_name = pending_name.take().ok_or_else(|| ValidationError {
|
||||
message_key: "parse.error_wrapper",
|
||||
args: vec![("detail", "column type without a name".to_string())],
|
||||
})?;
|
||||
columns.push(ColumnSpec::new(col_name, ty));
|
||||
}
|
||||
// `double precision` — the two-word alias maps to `real`.
|
||||
// The grammar guarantees `precision` follows `double`.
|
||||
MatchedKind::Word("double") => {
|
||||
if matches!(
|
||||
items.peek().map(|i| &i.kind),
|
||||
Some(MatchedKind::Word("precision"))
|
||||
) {
|
||||
items.next();
|
||||
}
|
||||
let col_name = pending_name.take().ok_or_else(|| ValidationError {
|
||||
message_key: "parse.error_wrapper",
|
||||
args: vec![("detail", "column type without a name".to_string())],
|
||||
})?;
|
||||
columns.push(ColumnSpec::new(col_name, Type::Real));
|
||||
}
|
||||
// A table-level `PRIMARY KEY (col, …)` column reference.
|
||||
MatchedKind::Ident { role: "pk_column", .. } => {
|
||||
primary_key.push(item.text.clone());
|
||||
}
|
||||
// `not null` column constraint (only once a column exists;
|
||||
// the `IF NOT EXISTS` `not` precedes every column).
|
||||
MatchedKind::Word("not") => {
|
||||
if matches!(
|
||||
items.peek().map(|i| &i.kind),
|
||||
Some(MatchedKind::Word("null"))
|
||||
) {
|
||||
items.next();
|
||||
if let Some(last) = columns.last_mut() {
|
||||
last.not_null = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
MatchedKind::Word("unique") => {
|
||||
if let Some(last) = columns.last_mut() {
|
||||
last.unique = true;
|
||||
}
|
||||
}
|
||||
// `primary key` — either a column-level constraint (mark
|
||||
// the most recent column) or the table-level clause (whose
|
||||
// `pk_column` idents follow and are collected above).
|
||||
MatchedKind::Word("primary") => {
|
||||
if matches!(items.peek().map(|i| &i.kind), Some(MatchedKind::Word("key"))) {
|
||||
items.next();
|
||||
// Table-level `PRIMARY KEY (…)` is followed by `(`
|
||||
// (then `pk_column` idents, collected above);
|
||||
// column-level `PRIMARY KEY` is not, and marks the
|
||||
// most-recent column.
|
||||
let table_level = matches!(
|
||||
items.peek().map(|i| &i.kind),
|
||||
Some(MatchedKind::Punct('('))
|
||||
);
|
||||
if !table_level && let Some(last) = columns.last() {
|
||||
primary_key.push(last.name.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
// De-dup redundant flags off a sole primary-key column (ADR-0035
|
||||
// §6.5): a single-column PK is already NOT NULL + UNIQUE, so
|
||||
// emitting them again would create a spurious index. Advanced mode
|
||||
// accepts the redundant spelling (real SQL does) rather than
|
||||
// rejecting it like simple mode (ADR-0029 §9).
|
||||
if primary_key.len() == 1
|
||||
&& let Some(c) = columns.iter_mut().find(|c| c.name == primary_key[0])
|
||||
{
|
||||
c.not_null = false;
|
||||
c.unique = false;
|
||||
}
|
||||
|
||||
Ok(Command::SqlCreateTable {
|
||||
name,
|
||||
columns,
|
||||
primary_key,
|
||||
if_not_exists,
|
||||
})
|
||||
}
|
||||
|
||||
pub static SQL_CREATE_TABLE: CommandNode = CommandNode {
|
||||
entry: Word::keyword("create"),
|
||||
shape: Node::Subgrammar(&super::sql_create_table::SQL_CREATE_TABLE_SHAPE),
|
||||
ast_builder: build_sql_create_table,
|
||||
help_id: Some("ddl.sql_create_table"),
|
||||
usage_ids: &["parse.usage.sql_create_table"],
|
||||
};
|
||||
|
||||
// =================================================================
|
||||
// Tests — `create table` column constraints (ADR-0029 §2.1, §9)
|
||||
// =================================================================
|
||||
|
||||
@@ -584,6 +584,12 @@ pub static REGISTRY: &[(&CommandNode, CommandCategory)] = &[
|
||||
(&data::SQL_INSERT, CommandCategory::Advanced),
|
||||
(&data::SQL_UPDATE, CommandCategory::Advanced),
|
||||
(&data::SQL_DELETE, CommandCategory::Advanced),
|
||||
// Shared entry word `create` (ADR-0035 §2): the simple
|
||||
// `ddl::CREATE` (above) and this advanced SQL node. The
|
||||
// dispatcher tries SQL first in advanced mode and falls back to
|
||||
// the `create table … with pk …` DSL node when the SQL shape
|
||||
// does not match — the `insert` precedent.
|
||||
(&ddl::SQL_CREATE_TABLE, CommandCategory::Advanced),
|
||||
];
|
||||
|
||||
/// Whether `entry` names an advanced-mode-only command (ADR-0030
|
||||
|
||||
@@ -367,10 +367,177 @@ mod tests {
|
||||
fn deferred_constraints_are_not_accepted_in_4a() {
|
||||
// DEFAULT / CHECK / table-level UNIQUE belong to the 4a.2
|
||||
// constraint slice; their shapes are absent here, so they do
|
||||
// not walk (the builder turns this into a friendly
|
||||
// "not yet supported" — tested there).
|
||||
// not walk (surfacing as a parse error with the usage
|
||||
// skeleton, which lists the supported surface).
|
||||
bad("table t (id int default 0)");
|
||||
bad("table t (id int check (id > 0))");
|
||||
bad("table t (a int, b int, unique (a, b))");
|
||||
}
|
||||
}
|
||||
|
||||
// =================================================================
|
||||
// Builder tests — `parse_command` (advanced mode) lowers the SQL
|
||||
// `CREATE TABLE` to `Command::SqlCreateTable` with the right fields
|
||||
// (ADR-0035 §1/§3, sub-phase 4a).
|
||||
// =================================================================
|
||||
|
||||
#[cfg(test)]
|
||||
mod builder_tests {
|
||||
use crate::dsl::command::Command;
|
||||
use crate::dsl::parser::{parse_command, parse_command_in_mode};
|
||||
use crate::dsl::types::Type;
|
||||
use crate::mode::Mode;
|
||||
|
||||
/// Parse in advanced mode and unwrap the `SqlCreateTable` fields.
|
||||
fn sct(input: &str) -> (String, Vec<(String, Type)>, Vec<String>, bool) {
|
||||
match parse_command(input).expect("should parse as SQL CREATE TABLE") {
|
||||
Command::SqlCreateTable {
|
||||
name,
|
||||
columns,
|
||||
primary_key,
|
||||
if_not_exists,
|
||||
} => (
|
||||
name,
|
||||
columns.into_iter().map(|c| (c.name, c.ty)).collect(),
|
||||
primary_key,
|
||||
if_not_exists,
|
||||
),
|
||||
other => panic!("expected SqlCreateTable, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn minimal_columns_and_types() {
|
||||
let (name, cols, pk, ine) = sct("create table t (id int, name text)");
|
||||
assert_eq!(name, "t");
|
||||
assert_eq!(
|
||||
cols,
|
||||
vec![("id".to_string(), Type::Int), ("name".to_string(), Type::Text)]
|
||||
);
|
||||
assert!(pk.is_empty(), "no PK declared");
|
||||
assert!(!ine);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn integer_primary_key_is_plain_int_not_serial() {
|
||||
// ADR-0035 §3: the type map is lexical; INTEGER PRIMARY KEY is
|
||||
// a plain int PK, NOT auto-increment (that is `serial`).
|
||||
let (_, cols, pk, _) = sct("create table t (id integer primary key)");
|
||||
assert_eq!(cols, vec![("id".to_string(), Type::Int)]);
|
||||
assert_eq!(pk, vec!["id".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn standard_sql_aliases_map_to_playground_types() {
|
||||
let (_, cols, _, _) = sct(
|
||||
"create table t (a bigint, b varchar, c boolean, d timestamp, \
|
||||
e numeric, f float, g binary)",
|
||||
);
|
||||
assert_eq!(
|
||||
cols,
|
||||
vec![
|
||||
("a".to_string(), Type::Int),
|
||||
("b".to_string(), Type::Text),
|
||||
("c".to_string(), Type::Bool),
|
||||
("d".to_string(), Type::DateTime),
|
||||
("e".to_string(), Type::Decimal),
|
||||
("f".to_string(), Type::Real),
|
||||
("g".to_string(), Type::Blob),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_precision_maps_to_real() {
|
||||
let (_, cols, _, _) = sct("create table t (id int, x double precision)");
|
||||
assert_eq!(
|
||||
cols,
|
||||
vec![("id".to_string(), Type::Int), ("x".to_string(), Type::Real)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn length_args_are_ignored() {
|
||||
let (_, cols, _, _) = sct("create table t (a varchar(255), b numeric(10, 2))");
|
||||
assert_eq!(
|
||||
cols,
|
||||
vec![("a".to_string(), Type::Text), ("b".to_string(), Type::Decimal)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn column_level_primary_key_populates_pk() {
|
||||
let (_, _, pk, _) = sct("create table t (id serial primary key, name text)");
|
||||
assert_eq!(pk, vec!["id".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_level_compound_primary_key() {
|
||||
let (_, _, pk, _) = sct("create table t (a int, b int, primary key (a, b))");
|
||||
assert_eq!(pk, vec!["a".to_string(), "b".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn if_not_exists_sets_the_flag() {
|
||||
let (name, _, _, ine) = sct("create table if not exists t (id int)");
|
||||
assert_eq!(name, "t");
|
||||
assert!(ine);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn not_null_and_unique_attach_to_their_column() {
|
||||
match parse_command("create table t (id int primary key, code text not null unique)")
|
||||
.expect("parses")
|
||||
{
|
||||
Command::SqlCreateTable { columns, .. } => {
|
||||
let code = columns.iter().find(|c| c.name == "code").expect("code col");
|
||||
assert!(code.not_null && code.unique);
|
||||
}
|
||||
other => panic!("expected SqlCreateTable, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn redundant_constraints_deduped_off_sole_pk_column() {
|
||||
// ADR-0035 §6.5: advanced mode accepts the redundant spelling
|
||||
// and silently drops the flags off the sole PK column.
|
||||
match parse_command("create table t (id int primary key not null unique)")
|
||||
.expect("parses")
|
||||
{
|
||||
Command::SqlCreateTable {
|
||||
columns,
|
||||
primary_key,
|
||||
..
|
||||
} => {
|
||||
assert_eq!(primary_key, vec!["id".to_string()]);
|
||||
let id = &columns[0];
|
||||
assert!(!id.not_null && !id.unique, "redundant flags deduped off PK");
|
||||
}
|
||||
other => panic!("expected SqlCreateTable, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn simple_create_still_parses_as_dsl_in_both_modes() {
|
||||
// The shared `create` entry word: the DSL `with pk` form falls
|
||||
// back to `Command::CreateTable` even in advanced mode, and is
|
||||
// the only shape in simple mode (ADR-0035 §2 dispatch).
|
||||
for mode in [Mode::Simple, Mode::Advanced] {
|
||||
let cmd = parse_command_in_mode("create table T with pk id(serial)", mode)
|
||||
.unwrap_or_else(|e| panic!("{mode:?} should parse the DSL form: {e:?}"));
|
||||
assert!(
|
||||
matches!(cmd, Command::CreateTable { .. }),
|
||||
"{mode:?}: expected DSL CreateTable, got {cmd:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sql_create_is_advanced_only() {
|
||||
// The SQL `( … )` form is not available in simple mode.
|
||||
assert!(
|
||||
parse_command_in_mode("create table t (id int)", Mode::Simple).is_err(),
|
||||
"SQL CREATE TABLE must not parse in simple mode"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user