rudb_parse/

transform.rs

//! From the parse tree to the AST.
//!
//! This is the one module that reads rule names out of the vendored grammar, and that is deliberate
//! containment: an upstream bump that renames a rule breaks a match arm here and nothing else in
//! the repository. `spec/04-architecture.md` section 4.5 says this transformer is ours and has to
//! be total over the rule table, and total is the load bearing word. Every rule reaches a defined
//! answer. For the ones this milestone covers that answer is an AST node, and for the rest it is a
//! `Not implemented` error naming the construct, which is what DuckDB itself answers for syntax it
//! parses and does not support. There is no arm that panics and none that silently drops a clause,
//! because a dropped clause is a wrong answer and a wrong answer is worse than an error.
//!
//! The mechanism that makes it tractable is the default arm. Two thirds of the parse tree is the
//! expression precedence chain, twenty rules of the form `X <- Y Tail*` that exist to make the
//! grammar unambiguous and that carry no meaning once it has been parsed. Rather than name all
//! twenty, the expression walker handles the case where a rule matched something interesting and
//! otherwise descends through any node with exactly one child. That is not a shortcut. It is the
//! statement that a rule with one child said nothing, which is true of every chain link, and it
//! means the twenty first precedence level upstream adds costs us nothing.

use std::collections::HashMap;

use rudb_common::{Error, IdentifierCase, Result, Value};

use crate::ast::{
    Ast, BinaryOp, CaseArm, ColumnDef, CreateTable, CreateView, Distinct, DropTable, Expr, ExprRef,
    Insert, JoinKind, LiteralKind, Nulls, Order, OrderItem, Quantifier, Query, QueryBody, QueryRef,
    Scope, Select, SelectRef, SetOp, Setting, Slice, Source, SourceRef, Statement, StrRef, Target,
    UnaryOp,
};
use crate::generated::rules::PROGRAM;
use crate::matcher::{NONE, Tree, parse_tokens};
use crate::token::{Kind, Token};
use crate::tokenize::tokenize;

/// Parse a script and transform it into the AST.
///
/// The tokens are produced once and handed to both halves. Calling [`crate::parse`] here instead
/// would be shorter and would tokenize the query a second time, which `cargo xtask bench` prices
/// at about a tenth of the whole front end.
pub fn parse_ast(query: &str) -> Result<Ast> {
    parse_ast_with_case(query, IdentifierCase::Preserve)
}

/// Parse a script while folding its unquoted identifiers for this session.
pub fn parse_ast_with_case(query: &str, identifier_case: IdentifierCase) -> Result<Ast> {
    let tokens = tokenize(query)?;
    let tree = parse_tokens(query, &tokens, PROGRAM, true)?;
    transform_with_case(query, &tokens, &tree, identifier_case)
}

/// Transform a parse tree that has already been produced.
pub fn transform(query: &str, tokens: &[Token], tree: &Tree) -> Result<Ast> {
    transform_with_case(query, tokens, tree, IdentifierCase::Preserve)
}

/// Transform a parse tree while folding its unquoted identifiers for this session.
pub fn transform_with_case(
    query: &str,
    tokens: &[Token],
    tree: &Tree,
    identifier_case: IdentifierCase,
) -> Result<Ast> {
    let mut transform = Transform {
        query,
        tokens,
        tree,
        ast: Ast::default(),
        interned: HashMap::new(),
        anonymous: 0,
        identifier_case,
    };
    transform.program(tree.root())?;
    Ok(transform.ast)
}

struct Transform<'a> {
    query: &'a str,
    tokens: &'a [Token],
    tree: &'a Tree,
    ast: Ast,
    interned: HashMap<String, StrRef>,
    /// How many bare `?` parameters have been seen, which is what numbers the next one.
    anonymous: u32,
    identifier_case: IdentifierCase,
}

impl<'a> Transform<'a> {
    // The parts that walk the parse tree without caring what it says.

    /// The text a node covers.
    fn text(&self, node: u32) -> &'a str {
        self.tree.text(node, self.query, self.tokens)
    }

    /// The name of the rule a node is.
    fn name(&self, node: u32) -> &'static str {
        self.tree.name(node)
    }

    /// The children of a node.
    ///
    /// Returned with the tree's lifetime rather than the borrow of `self`, so that the caller can
    /// iterate it while calling the `&mut self` methods that build the arena. Copying the `&Tree`
    /// out first is what buys that, and it is why every walker here starts by doing so.
    fn kids(&self, node: u32) -> impl Iterator<Item = u32> + use<'a> {
        let tree = self.tree;
        tree.children(node)
    }

    /// How many children a node has.
    fn count(&self, node: u32) -> usize {
        self.kids(node).count()
    }

    /// The n'th child, or `NONE`.
    fn nth(&self, node: u32, n: usize) -> u32 {
        self.kids(node).nth(n).unwrap_or(NONE)
    }

    /// The first child, or `NONE`.
    fn first(&self, node: u32) -> u32 {
        self.nth(node, 0)
    }

    /// The first child named `name`, or `NONE`.
    ///
    /// Optional parts of a sequence do not leave a placeholder behind, so `SimpleSelect` with a
    /// `WHERE` and no `GROUP BY` has the where clause as its second child and a `SimpleSelect` with
    /// neither has something else there. Positional indexing into an optional sequence is the
    /// single easiest way to write a transformer that is subtly wrong, so nothing here does it.
    fn find(&self, node: u32, name: &str) -> u32 {
        self.kids(node).find(|&kid| self.name(kid) == name).unwrap_or(NONE)
    }

    /// Every leaf of a subtree, in order.
    ///
    /// A leaf is a rule that matched only terminals, which for a name is the identifier itself. It
    /// is how all thirty odd spellings of a qualified name collapse into one walk: whether the
    /// parse said `SchemaQualification ReservedTableQualification ReservedColumnName` or
    /// `IdentifierDot IdentifierDot ColumnName`, the leaves are the parts in order.
    fn leaves(&self, node: u32, out: &mut Vec<u32>) {
        let mut any = false;
        for kid in self.kids(node) {
            any = true;
            self.leaves(kid, &mut *out);
        }
        if !any {
            out.push(node);
        }
    }

    // The parts that build the arena.

    /// Intern a string, returning its index.
    fn intern(&mut self, text: &str) -> StrRef {
        if let Some(&index) = self.interned.get(text) {
            return index;
        }
        let index = u32::try_from(self.ast.strings.len())
            .map_err(|_| Error::internal("more than four billion strings in one query"))
            .unwrap_or(NONE);
        self.ast.strings.push(text.to_string());
        self.interned.insert(text.to_string(), index);
        index
    }

    /// Push an expression and return its index.
    fn push(&mut self, expr: Expr) -> ExprRef {
        let index = self.ast.exprs.len() as u32;
        self.ast.exprs.push(expr);
        index
    }

    /// Push a from item and return its index.
    fn push_source(&mut self, source: Source) -> SourceRef {
        let index = self.ast.sources.len() as u32;
        self.ast.sources.push(source);
        index
    }

    /// Push a query and return its index.
    fn push_query(&mut self, query: Query) -> QueryRef {
        let index = self.ast.queries.len() as u32;
        self.ast.queries.push(query);
        index
    }

    /// Push a select and return its index.
    fn push_select(&mut self, select: Select) -> SelectRef {
        let index = self.ast.selects.len() as u32;
        self.ast.selects.push(select);
        index
    }

    /// Turn a vector of expressions into a slice of the expression list arena.
    fn expr_slice(&mut self, items: Vec<ExprRef>) -> Slice {
        let start = self.ast.expr_lists.len() as u32;
        self.ast.expr_lists.extend(items);
        Slice { start, len: self.ast.expr_lists.len() as u32 - start }
    }

    /// Turn a vector of strings into a slice of the name arena.
    fn part_slice(&mut self, items: Vec<StrRef>) -> Slice {
        let start = self.ast.parts.len() as u32;
        self.ast.parts.extend(items);
        Slice { start, len: self.ast.parts.len() as u32 - start }
    }

    /// Turn a vector of column definitions into a slice of the column arena.
    fn column_def_slice(&mut self, items: Vec<ColumnDef>) -> Slice {
        let start = self.ast.column_defs.len() as u32;
        self.ast.column_defs.extend(items);
        Slice { start, len: self.ast.column_defs.len() as u32 - start }
    }

    /// Turn a vector of targets into a slice of the target arena.
    fn target_slice(&mut self, items: Vec<Target>) -> Slice {
        let start = self.ast.targets.len() as u32;
        self.ast.targets.extend(items);
        Slice { start, len: self.ast.targets.len() as u32 - start }
    }

    /// Turn a vector of qualified names into a slice of the name list arena.
    fn name_list_slice(&mut self, items: Vec<Slice>) -> Slice {
        let start = self.ast.name_lists.len() as u32;
        self.ast.name_lists.extend(items);
        Slice { start, len: self.ast.name_lists.len() as u32 - start }
    }

    /// The error for a construct the transformer does not cover yet.
    ///
    /// Both halves matter. The text is what the user wrote, which is the only part they can act on,
    /// and the rule name is what we act on, because it is the exact grammar rule to go implement.
    fn unsupported<T>(&self, node: u32) -> Result<T> {
        let text = self.text(node);
        let text = if text.chars().count() > 60 {
            let cut = text.char_indices().nth(60).map_or(text.len(), |(at, _)| at);
            format!("{}...", &text[..cut])
        } else {
            text.to_string()
        };
        Err(Error::not_implemented(format!(
            "{text} is not supported yet, the grammar rule is {}",
            self.name(node)
        )))
    }

    // Names.

    /// One identifier out of a subtree, with the quoting and any trailing dot removed.
    fn identifier(&mut self, node: u32) -> StrRef {
        let mut leaves = Vec::new();
        self.leaves(node, &mut leaves);
        let text = leaves.last().map_or("", |&leaf| self.text(leaf));
        let text = self.fold_identifier(text.strip_suffix('.').unwrap_or(text));
        self.intern(&text)
    }

    /// Every part of a qualified name, outermost first.
    fn name_parts(&mut self, node: u32) -> Slice {
        let mut leaves = Vec::new();
        self.leaves(node, &mut leaves);
        let mut parts = Vec::with_capacity(leaves.len());
        for leaf in leaves {
            let text = self.text(leaf);
            // A node that covers no tokens is an optional part that was not written, and a bare
            // `*` is the star and not a name part. Neither is a component of anything.
            if text.is_empty() || text == "*" {
                continue;
            }
            let text = self.fold_identifier(text.strip_suffix('.').unwrap_or(text));
            let interned = self.intern(&text);
            parts.push(interned);
        }
        self.part_slice(parts)
    }

    fn fold_identifier(&self, text: &str) -> String {
        if text.starts_with(['"', '\'']) {
            return unquote(text);
        }
        match self.identifier_case {
            IdentifierCase::Preserve => text.to_string(),
            IdentifierCase::Lower => text.to_ascii_lowercase(),
            IdentifierCase::Upper => text.to_ascii_uppercase(),
        }
    }

    // Statements.

    /// `Program <- TopLevelStatement*`.
    fn program(&mut self, node: u32) -> Result<()> {
        for top in self.kids(node) {
            // A script that ends in a semicolon produces a last `TopLevelStatement` whose only
            // child is the end of input, because the grammar says `Statement? (';'+ / EndOfInput)`
            // and both halves of that are happy to match nothing. It is a real node and it is not a
            // statement, so it is dropped here rather than pretended away in the matcher.
            let Some(statement) = self.kids(top).find(|&kid| self.name(kid) == "Statement") else {
                continue;
            };
            let statement = self.statement(statement)?;
            self.ast.statements.push(statement);
        }
        Ok(())
    }

    /// `Statement <- SelectStatement / ...`, twenty seven alternatives of which four are done.
    fn statement(&mut self, node: u32) -> Result<Statement> {
        let inner = self.first(node);
        match self.name(inner) {
            "SelectStatement" => {
                let query = self.query(self.first(inner))?;
                Ok(Statement::Query(query))
            }
            "CreateStatement" => self.create_statement(inner),
            "DropStatement" => self.drop_statement(inner),
            "InsertStatement" => self.insert_statement(inner),
            "SetStatement" => self.set_statement(inner),
            "ResetStatement" => self.reset_statement(inner),
            "PragmaStatement" => self.pragma_statement(inner),
            "ExplainStatement" => self.explain_statement(inner),
            "CheckpointStatement" => Ok(Statement::Checkpoint),
            _ => self.unsupported(inner),
        }
    }

    /// `ExplainStatement <- 'EXPLAIN' AnalyzeKeyword? ExplainOptionList? ExplainableStatements`.
    ///
    /// Of the twenty one explainable statements, the one that is done is the query. The other
    /// twenty either do not exist here yet or have nothing to show: a plan is what `EXPLAIN`
    /// prints, and a `SET` has no plan. An `INSERT` has a plan for its source and showing that
    /// would answer a question nobody asked, since the source is not what the statement does.
    ///
    /// The option list is a refusal. `EXPLAIN (FORMAT JSON)` asks for the plan in a shape nothing
    /// here writes, and answering it with the text form would be answering a different question
    /// quietly.
    fn explain_statement(&mut self, node: u32) -> Result<Statement> {
        let analyze = self.find(node, "AnalyzeKeyword") != NONE;
        let options = self.find(node, "ExplainOptionList");
        if options != NONE {
            return self.unsupported(options);
        }
        let inner = self.first(self.find(node, "ExplainableStatements"));
        if self.name(inner) != "ExplainSelectStatement" {
            return self.unsupported(inner);
        }
        let query = self.query(self.find(inner, "SelectStatementInternal"))?;
        Ok(Statement::Explain { query, analyze })
    }

    /// `SetStatement <- 'SET' SetAssignmentOrTimeZone`.
    ///
    /// Of the three assignments, `StandardAssignment` is the one that is done. `SET SCHEMA` and
    /// `SET TIME ZONE` are each a setting this database has nothing to do with yet, and they are a
    /// refusal rather than a silent success, because a statement that says where to look for a
    /// table and is ignored is a statement that changes an answer.
    fn set_statement(&mut self, node: u32) -> Result<Statement> {
        let inner = self.first(self.find(node, "SetAssignmentOrTimeZone"));
        if self.name(inner) == "SetTimeZone" {
            return self.set_time_zone(inner);
        }
        if self.name(inner) != "StandardAssignment" {
            return self.unsupported(inner);
        }
        let (name, scope) = self.setting_name(self.find(inner, "SetVariableOrSetting"))?;
        let assignment = self.find(inner, "SetAssignment");
        let list = self.find(assignment, "VariableList");
        let mut values = Vec::new();
        for kid in self.kids(list) {
            values.push(self.expr(kid)?);
        }
        // The grammar takes a list because `SET search_path = a, b` is a list in postgres. Nothing
        // here has a setting that reads one, and taking the first of several would be worse than
        // saying so.
        let [value] = values[..] else {
            return self.unsupported(list);
        };
        let index = self.ast.settings.len() as u32;
        self.ast.settings.push(Setting { name, scope, value });
        Ok(Statement::Set(index))
    }

    /// `SET TIME ZONE value`, normalized to the `TimeZone` setting DuckDB exposes beside it.
    fn set_time_zone(&mut self, node: u32) -> Result<Statement> {
        let zone = self.first(self.find(node, "ZoneValue"));
        let name = self.intern("TimeZone");
        if matches!(self.name(zone), "ZoneDefault" | "ZoneLocal") {
            let index = self.ast.settings.len() as u32;
            self.ast.settings.push(Setting { name, scope: Scope::Unwritten, value: NONE });
            return Ok(Statement::Reset(index));
        }
        let text = match self.name(zone) {
            "ZoneStringLiteral" => self.string_value(self.find(zone, "StringLiteral"))?,
            "ZoneIdentifier" => {
                let identifier = self.find(zone, "Identifier");
                let identifier = self.identifier(identifier);
                self.ast.string(identifier).to_string()
            }
            _ => return self.unsupported(zone),
        };
        let text = self.intern(&text);
        let value = self.push(Expr::Literal { kind: LiteralKind::String, text });
        let index = self.ast.settings.len() as u32;
        self.ast.settings.push(Setting { name, scope: Scope::Unwritten, value });
        Ok(Statement::Set(index))
    }

    /// `ResetStatement <- 'RESET' SetVariableOrSetting`.
    fn reset_statement(&mut self, node: u32) -> Result<Statement> {
        let (name, scope) = self.setting_name(self.find(node, "SetVariableOrSetting"))?;
        let index = self.ast.settings.len() as u32;
        self.ast.settings.push(Setting { name, scope, value: NONE });
        Ok(Statement::Reset(index))
    }

    /// `PragmaStatement <- 'PRAGMA' PragmaAssignOrFunction`, which is two statements in one word.
    ///
    /// `PRAGMA memory_limit = '1GB'` is a `SET` with a different spelling and nothing else, so it
    /// lands on the same [`Statement::Set`] and the same setting arena entry. The scope is
    /// unwritten because the grammar has no room for one here, which is the same thing as a plain
    /// `SET` with no scope word.
    ///
    /// `PRAGMA version` is a query. Upstream rewrites it to `SELECT * FROM pragma_version()` and
    /// gives that away in its own error messages, which print the rewritten call back, so the
    /// rewrite happens here rather than being a statement kind the planner has to know about. The
    /// whole family comes out of it for free: an unknown pragma is the catalog's complaint, a bad
    /// argument is the function's, and the answer is a relation like any other.
    fn pragma_statement(&mut self, node: u32) -> Result<Statement> {
        let inner = self.first(self.find(node, "PragmaAssignOrFunction"));
        match self.name(inner) {
            "PragmaAssign" => self.pragma_assign(inner),
            "PragmaFunction" => self.pragma_function(inner),
            _ => self.unsupported(inner),
        }
    }

    /// `PragmaAssign <- SettingName '=' VariableList`, which is a `SET` and is treated as one.
    fn pragma_assign(&mut self, node: u32) -> Result<Statement> {
        let name = self.identifier(self.find(node, "SettingName"));
        let list = self.find(node, "VariableList");
        let mut values = Vec::new();
        for kid in self.kids(list) {
            values.push(self.expr(kid)?);
        }
        // The same refusal `set_statement` makes about a list, for the same reason. Nothing here
        // reads one and taking the first of several would be worse than saying so.
        let [value] = values[..] else {
            return self.unsupported(list);
        };
        let index = self.ast.settings.len() as u32;
        self.ast.settings.push(Setting { name, scope: Scope::Unwritten, value });
        Ok(Statement::Set(index))
    }

    /// `PragmaFunction <- PragmaName PragmaParameters?`, rewritten into the call it stands for.
    ///
    /// The name is written without the prefix and the function carries it, so `PRAGMA table_info`
    /// is `pragma_table_info`. The case the user wrote is kept rather than folded, because the name
    /// goes back out in the message about a pragma that does not exist and upstream prints that
    /// name back as it was typed.
    ///
    /// `PRAGMA version()` with empty parentheses is a parser error rather than a call, on both
    /// engines, and that falls out of the grammar here without anything being done about it:
    /// `PragmaParameters` is `Parens(List(Expression))` and a list of no expressions does not match.
    fn pragma_function(&mut self, node: u32) -> Result<Statement> {
        let interned = self.identifier(self.find(node, "PragmaName"));
        let written = self.ast.string(interned).to_string();
        let part = self.intern(&format!("pragma_{written}"));
        let name = self.part_slice(vec![part]);
        // The parameters are optional in the rule, so `PRAGMA version` has no node here at all
        // rather than a node covering nothing.
        let parameters = self.find(node, "PragmaParameters");
        let mut args = Vec::new();
        if parameters != NONE {
            for kid in self.kids(parameters) {
                let expr = self.expr(kid)?;
                args.push(Target { expr: self.quoted(expr), alias: NONE });
            }
        }
        let args = self.target_slice(args);
        let source = self.push_source(Source::Function {
            name,
            args,
            alias: NONE,
            columns: Slice::default(),
            pragma: true,
        });
        Ok(Statement::Query(self.star_over(source)))
    }

    /// A bare name in a pragma's parentheses is the name of a thing and not a column reference.
    ///
    /// `PRAGMA table_info(t)` and `PRAGMA table_info('t')` are the same statement on the pin, and
    /// so are `PRAGMA table_info(s.u)` and `PRAGMA table_info('s.u')`, because there is no `FROM`
    /// clause here for a column to come out of. Only a name is turned: `PRAGMA table_info(1)` stays
    /// an integer and is told there is no overload that takes one, which is what the pin says too.
    fn quoted(&mut self, expr: ExprRef) -> ExprRef {
        let Expr::Column { name } = self.ast.exprs[expr as usize] else {
            return expr;
        };
        let written: Vec<&str> = self.ast.name(name).collect();
        let joined = written.join(".");
        let text = self.intern(&joined);
        self.push(Expr::Literal { kind: LiteralKind::String, text })
    }

    /// `SetVariableOrSetting <- SetVariable / SetSetting`, where the setting carries a scope word.
    ///
    /// `SET VARIABLE x = 1` is the other alternative and is a different feature: a variable is a
    /// value the session holds and `getvariable` reads back, where a setting is a knob on the
    /// engine. Refused rather than treated as a setting of that name.
    fn setting_name(&mut self, node: u32) -> Result<(StrRef, Scope)> {
        let inner = self.first(node);
        if self.name(inner) != "SetSetting" {
            return self.unsupported(inner);
        }
        let written = self.find(inner, "SettingScope");
        let scope = if written == NONE {
            Scope::Unwritten
        } else {
            match self.name(self.first(written)) {
                "GlobalScope" => Scope::Global,
                "SessionScope" => Scope::Session,
                "LocalScope" => Scope::Local,
                _ => return self.unsupported(written),
            }
        };
        Ok((self.identifier(self.find(inner, "SettingName")), scope))
    }

    /// `CreateStatement <- 'CREATE' OrReplace? Temporary? CreateStatementVariation`.
    ///
    /// Of the nine variations, `CreateTableStmt` and `CreateViewStmt` are the ones that are done.
    /// The other seven are a macro, a sequence, a type, a schema, an index, a secret and a trigger,
    /// and each of them is a catalog entry this database has no room for yet.
    fn create_statement(&mut self, node: u32) -> Result<Statement> {
        let or_replace = self.find(node, "OrReplace") != NONE;
        let temporary = self.find(node, "Temporary") != NONE;
        let variation = self.find(node, "CreateStatementVariation");
        let inner = self.first(variation);
        // duckdb refuses this pair in the parser, with a caret under the `NOT`, because none of its
        // create rules has room for both. The vendored grammar has room for both, so the refusal is
        // here instead, which is the same stage and therefore the same sentence.
        if or_replace && self.find(inner, "IfNotExists") != NONE {
            return Err(Error::parser(
                "Cannot specify both OR REPLACE and IF NOT EXISTS within single create statement",
            ));
        }
        match self.name(inner) {
            "CreateTableStmt" => self.create_table_statement(inner, or_replace, temporary),
            "CreateViewStmt" => self.create_view_statement(inner, or_replace, temporary),
            _ => self.unsupported(inner),
        }
    }

    /// `CreateTableStmt <- 'TABLE' IfNotExists? QualifiedName CreateTableDefinition`.
    fn create_table_statement(
        &mut self,
        inner: u32,
        or_replace: bool,
        temporary: bool,
    ) -> Result<Statement> {
        let name = self.name_parts(self.find(inner, "QualifiedName"));
        let if_not_exists = self.find(inner, "IfNotExists") != NONE;
        let definition = self.find(inner, "CreateTableDefinition");
        let body = self.first(definition);
        let (columns, query) = match self.name(body) {
            "CreateColumnList" => (self.column_list(body)?, NONE),
            "CreateTableAs" => self.create_table_as(body)?,
            _ => return self.unsupported(body),
        };
        let index = self.ast.create_tables.len() as u32;
        self.ast.create_tables.push(CreateTable {
            name,
            columns,
            query,
            if_not_exists,
            or_replace,
            temporary,
        });
        Ok(Statement::CreateTable(index))
    }

    /// `CreateViewStmt <- CreateSecure? CreateRecursive? 'VIEW' IfNotExists? QualifiedName
    /// InsertColumnList? WithList? 'AS' SelectStatementInternal`.
    ///
    /// The body is transformed here as well as kept as text. Transforming it is what makes a view
    /// whose body does not parse a parse error at creation, which is where it belongs, and the text
    /// is what the catalog keeps so that the body can be bound again at every reference.
    fn create_view_statement(
        &mut self,
        inner: u32,
        or_replace: bool,
        temporary: bool,
    ) -> Result<Statement> {
        for kid in self.kids(inner) {
            // `SECURE` is a column and row policy, `RECURSIVE` is a different shape of view
            // entirely, and `WITH` carries options. Dropping any of the three silently would make a
            // view that is not the view that was asked for.
            if matches!(self.name(kid), "CreateSecure" | "CreateRecursive" | "WithList") {
                return self.unsupported(kid);
            }
        }
        let name = self.name_parts(self.find(inner, "QualifiedName"));
        let if_not_exists = self.find(inner, "IfNotExists") != NONE;
        let list = self.find(inner, "InsertColumnList");
        let columns = if list == NONE {
            Slice::default()
        } else {
            let mut parts = Vec::new();
            for kid in self.kids(self.find(list, "ColumnList")) {
                parts.push(self.identifier(kid));
            }
            self.part_slice(parts)
        };
        let body = self.find(inner, "SelectStatementInternal");
        let sql = self.text(body).to_string();
        let sql = self.intern(&sql);
        let query = self.query(body)?;
        let index = self.ast.create_views.len() as u32;
        self.ast.create_views.push(CreateView {
            name,
            columns,
            query,
            sql,
            if_not_exists,
            or_replace,
            temporary,
        });
        Ok(Statement::CreateView(index))
    }

    /// `CreateColumnList <- Parens(CreateTableColumnList?) PartitionSortedOptions? WithList?`.
    fn column_list(&mut self, node: u32) -> Result<Slice> {
        for kid in self.kids(node) {
            if matches!(self.name(kid), "PartitionOptions" | "SortedOptions" | "WithList") {
                return self.unsupported(kid);
            }
        }
        let list = self.find(node, "CreateTableColumnList");
        if list == NONE {
            // `CREATE TABLE t ()` parses. It is a table of no columns, and the catalog is entitled
            // to refuse it, but that is not this layer's refusal to make.
            return Ok(Slice::default());
        }
        let mut defs = Vec::new();
        for element in self.kids(list) {
            let inner = self.first(element);
            if self.name(inner) != "CreateTableColumnDefinition" {
                // A table level `PRIMARY KEY`, `UNIQUE`, `CHECK` or `FOREIGN KEY`. Constraints are
                // not enforced anywhere yet and silently dropping one is a wrong answer waiting to
                // happen, so it is refused instead.
                return self.unsupported(inner);
            }
            defs.push(self.column_definition(self.first(inner))?);
        }
        Ok(self.column_def_slice(defs))
    }

    /// `ColumnDefinition <- DottedIdentifier Type? GeneratedColumn? ConstraintNameClause?
    /// ColumnConstraint*`.
    fn column_definition(&mut self, node: u32) -> Result<ColumnDef> {
        let name = self.identifier(self.find(node, "DottedIdentifier"));
        let type_node = self.find(node, "Type");
        let ty = if type_node == NONE {
            NONE
        } else {
            let text = self.text(type_node).to_string();
            self.intern(&text)
        };
        if self.find(node, "GeneratedColumn") != NONE {
            return self.unsupported(self.find(node, "GeneratedColumn"));
        }
        let mut not_null = false;
        for kid in self.kids(node) {
            if self.name(kid) != "ColumnConstraint" {
                continue;
            }
            let constraint = self.first(kid);
            match self.name(constraint) {
                "NotNullConstraint" => {
                    not_null = self.name(self.first(constraint)) == "NotNullColumnConstraint";
                }
                _ => return self.unsupported(constraint),
            }
        }
        Ok(ColumnDef { name, ty, not_null })
    }

    /// `CreateTableAs <- IdentifierList? PartitionSortedOptions? WithList? 'AS' Statement
    /// WithData?`.
    ///
    /// The names in the `IdentifierList` become column definitions with no type, because the types
    /// are the query's and only the names are the syntax's to say.
    fn create_table_as(&mut self, node: u32) -> Result<(Slice, QueryRef)> {
        for kid in self.kids(node) {
            if matches!(
                self.name(kid),
                "PartitionOptions" | "SortedOptions" | "WithList" | "WithData"
            ) {
                return self.unsupported(kid);
            }
        }
        let names = self.find(node, "IdentifierList");
        let columns = if names == NONE {
            Slice::default()
        } else {
            let mut defs = Vec::new();
            for kid in self.kids(names) {
                let name = self.identifier(kid);
                defs.push(ColumnDef { name, ty: NONE, not_null: false });
            }
            self.column_def_slice(defs)
        };
        let statement = self.find(node, "Statement");
        let inner = self.first(statement);
        if self.name(inner) != "SelectStatement" {
            return self.unsupported(inner);
        }
        let query = self.query(self.first(inner))?;
        Ok((columns, query))
    }

    /// `DropStatement <- 'DROP' DropEntries DropBehavior?`.
    ///
    /// `DropTable <- TableOrView IfExists? List(BaseTableName)`, and `TableOrView` covers `VIEW`
    /// and `MATERIALIZED VIEW` as well as `TABLE`, so it is checked rather than assumed. The first
    /// two are done and a materialized view is not a thing this database has.
    fn drop_statement(&mut self, node: u32) -> Result<Statement> {
        if self.find(node, "DropBehavior") != NONE {
            return self.unsupported(self.find(node, "DropBehavior"));
        }
        let entries = self.find(node, "DropEntries");
        let inner = self.first(entries);
        if self.name(inner) != "DropTable" {
            return self.unsupported(inner);
        }
        let kind = self.find(inner, "TableOrView");
        let view = match self.name(self.first(kind)) {
            "CommentTable" => false,
            "CommentView" => true,
            _ => return self.unsupported(kind),
        };
        let if_exists = self.find(inner, "IfExists") != NONE;
        let mut names = Vec::new();
        for kid in self.kids(inner) {
            if self.name(kid) == "BaseTableName" {
                names.push(self.name_parts(kid));
            }
        }
        let names = self.name_list_slice(names);
        let index = self.ast.drop_tables.len() as u32;
        self.ast.drop_tables.push(DropTable { names, if_exists, view });
        Ok(Statement::DropTable(index))
    }

    /// `InsertStatement <- ... InsertTarget InsertColumnList? InsertValues ...`.
    ///
    /// `ON CONFLICT`, `RETURNING`, `BY NAME`, `BY POSITION`, `OR REPLACE` and the rest of the
    /// clauses the grammar hangs off this are each a refusal, because every one of them changes
    /// what the statement means and none of them changes it in a way anything downstream would
    /// notice if it were dropped.
    fn insert_statement(&mut self, node: u32) -> Result<Statement> {
        for kid in self.kids(node) {
            if matches!(
                self.name(kid),
                "InsertTarget" | "InsertColumnList" | "InsertValues" | "WithClause"
            ) {
                continue;
            }
            return self.unsupported(kid);
        }
        if self.find(node, "WithClause") != NONE {
            return self.unsupported(self.find(node, "WithClause"));
        }
        let name = self.name_parts(self.find(self.find(node, "InsertTarget"), "BaseTableName"));
        let list = self.find(node, "InsertColumnList");
        let columns = if list == NONE {
            Slice::default()
        } else {
            let mut parts = Vec::new();
            for kid in self.kids(self.find(list, "ColumnList")) {
                parts.push(self.identifier(kid));
            }
            self.part_slice(parts)
        };
        let values = self.find(node, "InsertValues");
        let inner = self.first(values);
        if self.name(inner) != "SelectInsertValues" {
            return self.unsupported(inner);
        }
        let source = self.query(self.find(inner, "SelectStatementInternal"))?;
        let index = self.ast.inserts.len() as u32;
        self.ast.inserts.push(Insert { name, columns, source });
        Ok(Statement::Insert(index))
    }

    /// `SelectStatementInternal <- WithClause? SelectSetOpChain ResultModifiers?`.
    fn query(&mut self, node: u32) -> Result<QueryRef> {
        if self.find(node, "WithClause") != NONE {
            return self.unsupported(self.find(node, "WithClause"));
        }
        let chain = self.find(node, "SelectSetOpChain");
        if chain == NONE {
            return self.unsupported(node);
        }
        let query = self.set_op_chain(chain)?;
        let modifiers = self.find(node, "ResultModifiers");
        if modifiers != NONE {
            self.result_modifiers(query, modifiers)?;
        }
        Ok(query)
    }

    /// `SelectSetOpChain <- IntersectChain SelectSetOpChainTail*`, left associative.
    fn set_op_chain(&mut self, node: u32) -> Result<QueryRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut left = self.intersect_chain(head)?;
        for tail in kids {
            // `SelectSetOpChainTail <- SetopClause IntersectChain`.
            let clause = self.first(tail);
            let (op, quantifier, by_name) = self.setop_clause(clause)?;
            let right = self.intersect_chain(self.nth(tail, 1))?;
            left = self.push_query(Query::bare(QueryBody::SetOp {
                op,
                quantifier,
                by_name,
                left,
                right,
            }));
        }
        Ok(left)
    }

    /// `IntersectChain <- SelectAtom IntersectChainTail*`, which binds tighter than union.
    fn intersect_chain(&mut self, node: u32) -> Result<QueryRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut left = self.select_atom(head)?;
        for tail in kids {
            // `IntersectChainTail <- SetIntersectClause SelectAtom`.
            let clause = self.first(tail);
            let quantifier = self.quantifier(self.find(clause, "DistinctOrAll"));
            let right = self.select_atom(self.nth(tail, 1))?;
            left = self.push_query(Query::bare(QueryBody::SetOp {
                op: SetOp::Intersect,
                quantifier,
                by_name: false,
                left,
                right,
            }));
        }
        Ok(left)
    }

    /// `SetopClause <- SetopType DistinctOrAll? ByName?`.
    fn setop_clause(&mut self, node: u32) -> Result<(SetOp, Quantifier, bool)> {
        let kind = self.find(node, "SetopType");
        let op = match self.name(self.first(kind)) {
            "SetopUnion" => SetOp::Union,
            "SetopExcept" => SetOp::Except,
            _ => return self.unsupported(kind),
        };
        let quantifier = self.quantifier(self.find(node, "DistinctOrAll"));
        Ok((op, quantifier, self.find(node, "ByName") != NONE))
    }

    /// `DistinctOrAll <- DistinctKeyword / AllKeyword`, absent included.
    fn quantifier(&self, node: u32) -> Quantifier {
        if node == NONE {
            return Quantifier::Unstated;
        }
        match self.name(self.first(node)) {
            "DistinctKeyword" => Quantifier::Distinct,
            "AllKeyword" => Quantifier::All,
            _ => Quantifier::Unstated,
        }
    }

    /// `SelectAtom <- SelectParens / SelectStatementType`.
    fn select_atom(&mut self, node: u32) -> Result<QueryRef> {
        let inner = self.first(node);
        match self.name(inner) {
            // `SelectParens <- Parens(SelectStatementInternal)`, so the parens buy a query that
            // carries its own order by and limit and nothing else.
            "SelectParens" => self.query(self.first(inner)),
            "SelectStatementType" => {
                let kind = self.first(inner);
                match self.name(kind) {
                    "OptionalParensSimpleSelect" => {
                        let select = self.simple_select(self.unwrap_parens(kind))?;
                        Ok(self.push_query(Query::bare(QueryBody::Select(select))))
                    }
                    "ValuesClause" => {
                        let rows = self.values_clause(kind)?;
                        Ok(self.push_query(Query::bare(QueryBody::Values(rows))))
                    }
                    "DescribeStatement" => self.describe_statement(kind),
                    _ => self.unsupported(kind),
                }
            }
            _ => self.unsupported(inner),
        }
    }

    /// `DescribeStatement <- ShowTables / ShowDeprecatedSelect / DescribeSelect / ShowAllTables /
    /// ShowByName / DescribeByName`.
    ///
    /// Two of the six are done and they are the two that describe a relation. The four that are
    /// not are `SHOW`, which is a different statement wearing this rule: three of its four forms
    /// list what the database has rather than what a query returns, and the fourth is `SHOW <query>`,
    /// which upstream documents as deprecated. Describing something through a deprecated spelling
    /// is not worth implementing before the spelling that replaced it has users.
    ///
    /// `SUMMARIZE` shares `DescribeByName` and `DescribeSelect` with `DESCRIBE` and is refused
    /// here, because it returns twelve columns of statistics rather than six of schema and reading
    /// it as a describe would answer a different question than the one that was asked.
    fn describe_statement(&mut self, node: u32) -> Result<QueryRef> {
        let inner = self.first(node);
        match self.name(inner) {
            "DescribeSelect" => {
                self.describe_and_not_summarize(inner)?;
                let query = self.query(self.find(inner, "SelectStatementInternal"))?;
                Ok(self.push_query(Query::bare(QueryBody::Describe(query))))
            }
            "DescribeByName" => {
                self.describe_and_not_summarize(inner)?;
                let target = self.find(inner, "DescribeTarget");
                if target == NONE {
                    return self.unsupported(inner);
                }
                let source = self.describe_target(target)?;
                let query = self.star_over(source);
                Ok(self.push_query(Query::bare(QueryBody::Describe(query))))
            }
            "ShowByName" => {
                let target = self.find(inner, "ShowTarget");
                if target == NONE {
                    return self.unsupported(inner);
                }
                let name = self.name_parts(target);
                let source = self.push_source(Source::Table {
                    name,
                    alias: NONE,
                    columns: Slice::default(),
                });
                let relation = self.star_over(source);
                Ok(self.push_query(Query::bare(QueryBody::Show { name, relation })))
            }
            _ => self.unsupported(inner),
        }
    }

    /// `DescribeOrSummarize <- DescribeRule / Summarize`, where only the first is done.
    fn describe_and_not_summarize(&mut self, node: u32) -> Result<()> {
        let word = self.find(node, "DescribeOrSummarize");
        if word == NONE || self.name(self.first(word)) != "DescribeRule" {
            return self.unsupported(if word == NONE { node } else { word });
        }
        Ok(())
    }

    /// `DescribeTarget <- DescribeBaseTableName / DescribeStringLiteral`, as a source to read from.
    ///
    /// Both become a `FROM` item and not a lookup of their own, because the string form is the
    /// replacement scan and the binder already knows how to turn `'hits.parquet'` into a reader.
    /// A name that is a table, a view, a file or nothing at all then gets one answer from one place.
    fn describe_target(&mut self, node: u32) -> Result<SourceRef> {
        let inner = self.first(node);
        let name = match self.name(inner) {
            "DescribeBaseTableName" => self.name_parts(self.find(inner, "BaseTableName")),
            "DescribeStringLiteral" => {
                let text = self.string_value(self.find(inner, "StringLiteral"))?;
                let part = self.intern(&text);
                self.part_slice(vec![part])
            }
            _ => return self.unsupported(inner),
        };
        Ok(self.push_source(Source::Table { name, alias: NONE, columns: Slice::default() }))
    }

    /// `SELECT * FROM <source>`, which is what `DESCRIBE t` means.
    fn star_over(&mut self, source: SourceRef) -> QueryRef {
        let star =
            self.push(Expr::Star { qualifier: Slice::default(), replacements: Slice::default() });
        let targets = self.target_slice(vec![Target { expr: star, alias: NONE }]);
        let start = self.ast.source_lists.len() as u32;
        self.ast.source_lists.push(source);
        let from = Slice { start, len: 1 };
        let select = self.push_select(Select { targets, from, ..Select::empty() });
        self.push_query(Query::bare(QueryBody::Select(select)))
    }

    /// `ValuesClause <- 'VALUES' List(ValuesExpressions)`, each of which is `Parens(List(Expression))`.
    ///
    /// The rows are not checked against each other for width here. Two rows of different widths
    /// parse, and saying so is the binder's job, because the message wants to name the column count
    /// it expected and the parser does not know it for `INSERT` where the table decides.
    fn values_clause(&mut self, node: u32) -> Result<Slice> {
        let mut rows = Vec::new();
        for kid in self.kids(node) {
            if self.name(kid) != "ValuesExpressions" {
                continue;
            }
            let mut items = Vec::new();
            for expr in self.kids(kid) {
                items.push(self.expr(expr)?);
            }
            let slice = self.expr_slice(items);
            rows.push(slice);
        }
        let start = self.ast.rows.len() as u32;
        self.ast.rows.extend(rows);
        Ok(Slice { start, len: self.ast.rows.len() as u32 - start })
    }

    /// `OptionalParensSimpleSelect <- SimpleSelectParens / SimpleSelect`, down to the select.
    fn unwrap_parens(&self, node: u32) -> u32 {
        let mut node = self.first(node);
        while self.name(node) == "SimpleSelectParens" {
            node = self.first(node);
        }
        node
    }

    /// `ResultModifiers <- OrderByClause? LimitOffset?`.
    fn result_modifiers(&mut self, query: QueryRef, node: u32) -> Result<()> {
        let order = self.find(node, "OrderByClause");
        if order != NONE {
            let (items, all) = self.order_by(order)?;
            let start = self.ast.order_items.len() as u32;
            self.ast.order_items.extend(items);
            self.ast.queries[query as usize].order_by =
                Slice { start, len: self.ast.order_items.len() as u32 - start };
            self.ast.queries[query as usize].order_by_all = all;
        }
        let limit = self.find(node, "LimitOffset");
        if limit != NONE {
            self.limit_offset(query, self.first(limit))?;
        }
        Ok(())
    }

    /// The four spellings of a limit and an offset, in either order and either one alone.
    fn limit_offset(&mut self, query: QueryRef, node: u32) -> Result<()> {
        match self.name(node) {
            "LimitOffsetClause" | "OffsetLimitClause" => {
                let limit = self.find(node, "LimitClause");
                if limit != NONE {
                    self.limit(query, limit)?;
                }
                let offset = self.find(node, "OffsetClause");
                if offset != NONE {
                    self.offset(query, offset)?;
                }
                Ok(())
            }
            _ => self.unsupported(node),
        }
    }

    /// `LimitClause <- 'LIMIT' LimitValue`.
    fn limit(&mut self, query: QueryRef, node: u32) -> Result<()> {
        let value = self.first(node);
        let inner = self.first(value);
        match self.name(inner) {
            // `LIMIT ALL` is no limit at all, which is what an absent limit already means.
            "LimitAll" => Ok(()),
            // `LimitExpression <- Expression '%'?`. The percent sign is a terminal so it leaves no
            // node behind, and the only thing that says it was written is the text of the rule that
            // matched it.
            "LimitExpression" => {
                let expr = self.expr(self.first(inner))?;
                self.ast.queries[query as usize].limit = expr;
                self.ast.queries[query as usize].limit_percent = self.text(inner).ends_with('%');
                Ok(())
            }
            "LimitLiteralPercent" => {
                let expr = self.expr(self.first(inner))?;
                self.ast.queries[query as usize].limit = expr;
                self.ast.queries[query as usize].limit_percent = true;
                Ok(())
            }
            _ => self.unsupported(inner),
        }
    }

    /// `OffsetClause <- 'OFFSET' OffsetValue`, where `OffsetValue <- Expression RowOrRows?`.
    fn offset(&mut self, query: QueryRef, node: u32) -> Result<()> {
        let value = self.first(node);
        let expr = self.expr(self.first(value))?;
        self.ast.queries[query as usize].offset = expr;
        Ok(())
    }

    /// `SimpleSelect <- SelectFrom WhereClause? GroupByClause? HavingClause? WindowClause?
    /// QualifyClause? SampleClause?`.
    fn simple_select(&mut self, node: u32) -> Result<SelectRef> {
        for name in ["WindowClause", "QualifyClause", "SampleClause"] {
            let clause = self.find(node, name);
            if clause != NONE {
                return self.unsupported(clause);
            }
        }
        let mut select = Select::empty();
        self.select_from(&mut select, self.first(node))?;
        let filter = self.find(node, "WhereClause");
        if filter != NONE {
            select.filter = self.expr(self.first(filter))?;
        }
        let group = self.find(node, "GroupByClause");
        if group != NONE {
            self.group_by(&mut select, self.first(group))?;
        }
        let having = self.find(node, "HavingClause");
        if having != NONE {
            select.having = self.expr(self.first(having))?;
        }
        Ok(self.push_select(select))
    }

    /// `SelectFrom <- SelectFromClause / FromSelectClause`, which is `SELECT ... FROM ...` and
    /// DuckDB's `FROM ... SELECT ...` written the other way round.
    fn select_from(&mut self, select: &mut Select, node: u32) -> Result<()> {
        let clause = self.first(node);
        let targets = self.find(clause, "SelectClause");
        let from = self.find(clause, "FromClause");
        if from != NONE {
            select.from = self.sources(from)?;
        }
        if targets == NONE {
            // `FROM t` on its own. DuckDB reads it as `SELECT * FROM t`, and inventing the star
            // here rather than in the binder keeps the binder from having to know the shape of the
            // clause that was missing.
            let star = self
                .push(Expr::Star { qualifier: Slice::default(), replacements: Slice::default() });
            let start = self.ast.targets.len() as u32;
            self.ast.targets.push(Target { expr: star, alias: NONE });
            select.targets = Slice { start, len: 1 };
            return Ok(());
        }
        self.select_clause(select, targets)
    }

    /// `SelectClause <- 'SELECT' DistinctClause? TargetList?`.
    fn select_clause(&mut self, select: &mut Select, node: u32) -> Result<()> {
        let distinct = self.find(node, "DistinctClause");
        if distinct != NONE {
            let inner = self.first(distinct);
            select.distinct = match self.name(inner) {
                // `SELECT ALL` is the default spelled out.
                "DistinctAll" => Distinct::No,
                "DistinctOn" => {
                    let on = self.find(inner, "DistinctOnTargets");
                    if on == NONE {
                        Distinct::Yes
                    } else {
                        let mut items = Vec::new();
                        for kid in self.kids(on) {
                            items.push(self.expr(kid)?);
                        }
                        Distinct::On(self.expr_slice(items))
                    }
                }
                _ => return self.unsupported(inner),
            };
        }
        let list = self.find(node, "TargetList");
        if list == NONE {
            return Ok(());
        }
        let mut targets = Vec::new();
        for kid in self.kids(list) {
            targets.push(self.target(kid)?);
        }
        select.targets = self.target_slice(targets);
        Ok(())
    }

    /// `AliasedExpression <- ColIdExpression / ExpressionAsCollabel / ExpressionOptIdentifier`.
    fn target(&mut self, node: u32) -> Result<Target> {
        let inner = self.first(node);
        match self.name(inner) {
            // `ColIdExpression <- ColId ':' Expression`, the alias written first.
            "ColIdExpression" => {
                let alias = self.identifier(self.first(inner));
                let expr = self.expr(self.nth(inner, 1))?;
                Ok(Target { expr, alias })
            }
            "ExpressionAsCollabel" => {
                let expr = self.expr(self.first(inner))?;
                let alias = self.identifier(self.nth(inner, 1));
                Ok(Target { expr, alias })
            }
            "ExpressionOptIdentifier" => {
                let expr = self.expr(self.first(inner))?;
                let alias =
                    if self.count(inner) > 1 { self.identifier(self.nth(inner, 1)) } else { NONE };
                Ok(Target { expr, alias })
            }
            _ => self.unsupported(inner),
        }
    }

    /// `GroupByClause <- 'GROUP' 'BY' GroupByExpressions`.
    fn group_by(&mut self, select: &mut Select, node: u32) -> Result<()> {
        let inner = self.first(node);
        match self.name(inner) {
            "GroupByAll" => {
                select.group_by_all = true;
                Ok(())
            }
            "GroupByList" => {
                let mut items = Vec::new();
                for kid in self.kids(inner) {
                    // `GroupByExpression <- EmptyGroupingItem / CubeOrRollupClause /
                    // GroupingSetsClause / GroupByBaseExpression`.
                    let expression = self.first(kid);
                    if self.name(expression) != "GroupByBaseExpression" {
                        return self.unsupported(expression);
                    }
                    items.push(self.expr(self.first(expression))?);
                }
                select.group_by = self.expr_slice(items);
                Ok(())
            }
            _ => self.unsupported(inner),
        }
    }

    /// `OrderByClause <- 'ORDER' 'BY' OrderByExpressions`, where `OrderByExpressions <- OrderByAll
    /// / OrderByExpressionList`.
    fn order_by(&mut self, node: u32) -> Result<(Vec<OrderItem>, bool)> {
        let inner = self.first(self.first(node));
        match self.name(inner) {
            "OrderByAll" => {
                let (order, nulls) = self.sort_options(inner);
                Ok((vec![OrderItem { expr: NONE, order, nulls }], true))
            }
            "OrderByExpressionList" => {
                let mut items = Vec::new();
                for kid in self.kids(inner) {
                    // `OrderByExpression <- Expression DescOrAsc? NullsFirstOrLast?`.
                    let expr = self.expr(self.first(kid))?;
                    let (order, nulls) = self.sort_options(kid);
                    items.push(OrderItem { expr, order, nulls });
                }
                Ok((items, false))
            }
            _ => self.unsupported(inner),
        }
    }

    /// The direction and the null placement of one sort key, either of which may be unwritten.
    fn sort_options(&self, node: u32) -> (Order, Nulls) {
        let direction = self.find(node, "DescOrAsc");
        let order = if direction == NONE {
            Order::Unstated
        } else if self.name(self.first(direction)) == "DescendingOrder" {
            Order::Descending
        } else {
            Order::Ascending
        };
        let placement = self.find(node, "NullsFirstOrLast");
        let nulls = if placement == NONE {
            Nulls::Unstated
        } else if self.name(self.first(placement)) == "NullsFirst" {
            Nulls::First
        } else {
            Nulls::Last
        };
        (order, nulls)
    }

    // From clauses.

    /// `FromClause <- 'FROM' List(TableRef)`.
    fn sources(&mut self, node: u32) -> Result<Slice> {
        let mut items = Vec::new();
        for kid in self.kids(node) {
            items.push(self.table_ref(kid)?);
        }
        let start = self.ast.source_lists.len() as u32;
        self.ast.source_lists.extend(items);
        Ok(Slice { start, len: self.ast.source_lists.len() as u32 - start })
    }

    /// `TableRef <- InnerTableRef JoinOrPivot*`, left associative like the set operators.
    fn table_ref(&mut self, node: u32) -> Result<SourceRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut left = self.inner_table_ref(head)?;
        for tail in kids {
            let clause = self.first(tail);
            if self.name(clause) != "JoinClause" {
                return self.unsupported(clause);
            }
            left = self.join(left, self.first(clause))?;
        }
        Ok(left)
    }

    /// `InnerTableRef <- ValuesRef / TableFunction / TableSubquery / BaseTableRef / ParensTableRef`.
    fn inner_table_ref(&mut self, node: u32) -> Result<SourceRef> {
        let inner = if self.name(node) == "InnerTableRef" { self.first(node) } else { node };
        match self.name(inner) {
            "BaseTableRef" => {
                if self.find(inner, "TableAliasColon") != NONE {
                    return self.unsupported(inner);
                }
                for name in ["AtClause", "SampleClause"] {
                    let clause = self.find(inner, name);
                    if clause != NONE {
                        return self.unsupported(clause);
                    }
                }
                let name = self.name_parts(self.find(inner, "BaseTableName"));
                let (alias, columns) = self.table_alias(self.find(inner, "TableAlias"));
                Ok(self.push_source(Source::Table { name, alias, columns }))
            }
            "TableSubquery" => {
                if self.find(inner, "TableAliasColon") != NONE
                    || self.find(inner, "Lateral") != NONE
                {
                    return self.unsupported(inner);
                }
                // `SubqueryReference <- Parens(SelectStatementInternal)`.
                let reference = self.find(inner, "SubqueryReference");
                let query = self.query(self.first(reference))?;
                let (alias, columns) = self.table_alias(self.find(inner, "TableAlias"));
                Ok(self.push_source(Source::Subquery { query, alias, columns }))
            }
            // `TableFunction <- TableFunctionLateralOpt / TableFunctionAliasColon`, and
            // `TableFunctionLateralOpt <- Lateral? QualifiedTableFunction TableFunctionArguments
            // WithOrdinality? TableAlias?`. The colon form and `LATERAL` are their own work, and
            // `WITH ORDINALITY` adds a column, so all three are turned away rather than dropped.
            "TableFunction" => {
                let form = self.first(inner);
                for name in ["TableAliasColon", "Lateral", "WithOrdinality", "SampleClause"] {
                    let clause = self.find(form, name);
                    if clause != NONE {
                        return self.unsupported(clause);
                    }
                }
                let name = self.name_parts(self.find(form, "QualifiedTableFunction"));
                let mut args = Vec::new();
                // `TableFunctionArguments <- Parens(List(FunctionArgument)?)`, so a call with no
                // arguments has the wrapper and no list under it.
                let list = self.find(form, "TableFunctionArguments");
                for kid in self.kids(list) {
                    args.push(self.table_argument(kid)?);
                }
                let args = self.target_slice(args);
                let (alias, columns) = self.table_alias(self.find(form, "TableAlias"));
                Ok(self.push_source(Source::Function { name, args, alias, columns, pragma: false }))
            }
            "ValuesRef" => {
                if self.find(inner, "TableAliasColon") != NONE {
                    return self.unsupported(inner);
                }
                let rows = self.values_clause(self.find(inner, "ValuesClause"))?;
                let (alias, columns) = self.table_alias(self.find(inner, "TableAlias"));
                Ok(self.push_source(Source::Values { rows, alias, columns }))
            }
            "ParensTableRef" => {
                if self.find(inner, "TableAliasColon") != NONE
                    || self.find(inner, "SampleClause") != NONE
                    || self.find(inner, "TableAlias") != NONE
                {
                    return self.unsupported(inner);
                }
                self.table_ref(self.find(inner, "TableRef"))
            }
            _ => self.unsupported(inner),
        }
    }

    /// `TableAlias <- TableAliasAs / TableAliasWithoutAs`, either with a column alias list.
    fn table_alias(&mut self, node: u32) -> (StrRef, Slice) {
        if node == NONE {
            return (NONE, Slice::default());
        }
        let inner = self.first(node);
        let alias = self.identifier(self.first(inner));
        let list = self.find(inner, "ColumnAliases");
        if list == NONE {
            return (alias, Slice::default());
        }
        let mut columns = Vec::new();
        for kid in self.kids(list) {
            let name = self.identifier(kid);
            columns.push(name);
        }
        (alias, self.part_slice(columns))
    }

    /// `JoinClause <- JoinByClause / RegularJoinClause / JoinWithoutOnClause / NearestJoinClause`.
    fn join(&mut self, left: SourceRef, node: u32) -> Result<SourceRef> {
        match self.name(node) {
            // `RegularJoinClause <- Asof? JoinType? 'JOIN' TableRef JoinQualifier`.
            "RegularJoinClause" => {
                if self.find(node, "Asof") != NONE {
                    return self.unsupported(node);
                }
                let kind = self.join_type(self.find(node, "JoinType"));
                let right = self.table_ref(self.find(node, "TableRef"))?;
                let (on, using) = self.join_qualifier(self.find(node, "JoinQualifier"))?;
                Ok(self.push_source(Source::Join { left, right, kind, natural: false, on, using }))
            }
            // `JoinWithoutOnClause <- JoinPrefix 'JOIN' InnerTableRef`, which is cross, natural and
            // positional. Those three are exactly the joins that carry no condition.
            "JoinWithoutOnClause" => {
                let prefix = self.first(self.find(node, "JoinPrefix"));
                let (kind, natural) = match self.name(prefix) {
                    "CrossJoinPrefix" => (JoinKind::Cross, false),
                    "PositionalJoinPrefix" => (JoinKind::Positional, false),
                    "NaturalJoinPrefix" => (self.join_type(self.find(prefix, "JoinType")), true),
                    _ => return self.unsupported(prefix),
                };
                let right = self.inner_table_ref(self.find(node, "InnerTableRef"))?;
                Ok(self.push_source(Source::Join {
                    left,
                    right,
                    kind,
                    natural,
                    on: NONE,
                    using: Slice::default(),
                }))
            }
            _ => self.unsupported(node),
        }
    }

    /// `JoinType <- FullJoin / LeftJoin / RightJoin / SemiJoin / AntiJoin / InnerJoin`, absent
    /// meaning inner, which is what SQL has always meant by a bare `JOIN`.
    fn join_type(&self, node: u32) -> JoinKind {
        if node == NONE {
            return JoinKind::Inner;
        }
        match self.name(self.first(node)) {
            "FullJoin" => JoinKind::Full,
            "LeftJoin" => JoinKind::Left,
            "RightJoin" => JoinKind::Right,
            "SemiJoin" => JoinKind::Semi,
            "AntiJoin" => JoinKind::Anti,
            _ => JoinKind::Inner,
        }
    }

    /// `JoinQualifier <- OnClause / UsingClause`.
    fn join_qualifier(&mut self, node: u32) -> Result<(ExprRef, Slice)> {
        let inner = self.first(node);
        match self.name(inner) {
            "OnClause" => Ok((self.expr(self.first(inner))?, Slice::default())),
            "UsingClause" => {
                let mut columns = Vec::new();
                for kid in self.kids(inner) {
                    let name = self.identifier(kid);
                    columns.push(name);
                }
                Ok((NONE, self.part_slice(columns)))
            }
            _ => self.unsupported(inner),
        }
    }

    // Expressions.

    /// One expression, from wherever in the precedence chain it starts.
    ///
    /// The loop is the whole design. A rule that says something gets an arm, a rule with exactly
    /// one child that said nothing is stepped through, and anything else is an error naming itself.
    /// The chain rules never get an arm for their one child case, which is why adding a precedence
    /// level upstream costs nothing here.
    ///
    /// Said nothing means covered no text of its own. A keyword is not a child of the node that
    /// spells it, so `TRIM(x)` is a rule with one child and that child is `x`, and stepping through
    /// on the child count alone threw the `TRIM` away and answered the untrimmed string. Comparing
    /// the two spans is what tells the two cases apart: a precedence rule with one child covers
    /// exactly what its child covers, and a rule that wrote a keyword or a bracket covers more.
    /// That is the rule rather than a list of the names it happened to be wrong about, because the
    /// grammar has eleven hundred rules and the ones with a keyword and one child are not enumerable
    /// by reading the ones that are wrong today.
    fn expr(&mut self, node: u32) -> Result<ExprRef> {
        let mut node = node;
        loop {
            let count = self.count(node);
            let name = self.name(node);
            match name {
                "LogicalOrExpression" if count > 1 => return self.logical(node, BinaryOp::Or),
                "LogicalAndExpression" if count > 1 => return self.logical(node, BinaryOp::And),
                "LogicalNotExpression" if count > 1 => return self.logical_not(node),
                "IsExpression" if count > 1 => return self.is_expression(node),
                "BetweenInLikeExpression" if count > 1 => return self.between_in_like(node),
                "PrefixExpression" if count > 1 => return self.prefix(node),
                "BaseExpression" if count > 1 => return self.indirection(node),
                "LambdaArrowExpression"
                | "IsDistinctFromExpression"
                | "ComparisonExpression"
                | "OtherOperatorExpression"
                | "BitwiseExpression"
                | "AdditiveExpression"
                | "MultiplicativeExpression"
                | "ExponentiationExpression"
                | "CollateExpression"
                | "AtTimeZoneExpression"
                    if count > 1 =>
                {
                    return self.tail_chain(node);
                }
                "ColumnReference" => {
                    let name = self.name_parts(node);
                    return Ok(self.push(Expr::Column { name }));
                }
                "StarExpression" => return self.star(node),
                "NumberLiteral" => {
                    let text = self.text(node).to_string();
                    let text = self.intern(&text);
                    return Ok(self.push(Expr::Literal { kind: LiteralKind::Number, text }));
                }
                "StringLiteral" => return self.string_literal(node),
                "NullLiteral" | "TrueLiteral" | "FalseLiteral" => {
                    let kind = match name {
                        "NullLiteral" => LiteralKind::Null,
                        "TrueLiteral" => LiteralKind::True,
                        _ => LiteralKind::False,
                    };
                    return Ok(self.push(Expr::Literal { kind, text: NONE }));
                }
                "FunctionExpression" => return self.function(node),
                "CoalesceExpression" => return self.coalesce(node),
                "NullIfExpression" => return self.null_if(node),
                "SubstringExpression" => return self.substring(node),
                "PositionExpression" => return self.position(node),
                "TrimExpression" => return self.trim(node),
                "OverlayExpression" => return self.overlay(node),
                "ExtractExpression" => return self.extract(node),
                "CastExpression" => return self.cast(node),
                "TypeLiteral" => return self.typed_literal(node),
                "IntervalLiteral" => return self.interval_literal(node),
                "CaseExpression" => return self.case(node),
                "ParenthesisExpression" => return self.row(node),
                // `ParensExpression <- Parens(Expression)` covers more text than its child and
                // still says nothing about the value, because the brackets are grouping. It is the
                // one rule of that shape, which is why it is an arm rather than a second rule in
                // the step below. `ParenthesisExpression` is not this: it holds a list, and a list
                // of more than one is a row.
                "ParensExpression" if count == 1 => node = self.first(node),
                "BoundedListExpression" => return self.list(node),
                "QuestionMarkNumberedParameter"
                | "AnonymousParameter"
                | "NumberedParameter"
                | "ColLabelParameter" => return self.parameter(node),
                "SubqueryExpression" => return self.subquery(node),
                _ if count == 1 && self.text(self.first(node)) == self.text(node) => {
                    node = self.first(node);
                }
                _ => return self.unsupported(node),
            }
        }
    }

    /// `X <- Y XTail*` where `XTail <- Operator Y`, the shape ten precedence levels share.
    fn tail_chain(&mut self, node: u32) -> Result<ExprRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut left = self.expr(head)?;
        for tail in kids {
            let operator = self.first(tail);
            let op = self.binary_op(operator)?;
            // `ComparisonExpressionTail <- ComparisonOperator NotExpression? BetweenInLikeExpression`
            // is the one tail with an optional middle, so the operand is the last child and not the
            // second one. Taking the last is right for every tail and wrong for none.
            let operand = self.kids(tail).last().unwrap_or(NONE);
            if self.count(tail) > 2 {
                return self.unsupported(tail);
            }
            let right = self.expr(operand)?;
            left = self.push(Expr::Binary { op, left, right });
        }
        Ok(left)
    }

    /// Which infix operator a tail's operator node is.
    fn binary_op(&mut self, node: u32) -> Result<BinaryOp> {
        // The operator rules nest: `ComparisonOperator` over `OperatorGreaterThan` over the symbol
        // itself. Every one of them covers the same tokens, so the text is the same at every level
        // and reading it once at the top is enough. The name is not, which is why the bottom of the
        // chain is walked to as well: `OtherOperator` says nothing and `OperatorLiteral` says
        // everything, and they are three levels apart.
        let mut leaf = node;
        while self.count(leaf) == 1 {
            leaf = self.first(leaf);
        }
        let text = self.text(node);
        let upper = text.to_ascii_uppercase();
        let op = match upper.as_str() {
            "OR" => BinaryOp::Or,
            "AND" => BinaryOp::And,
            "=" | "==" => BinaryOp::Eq,
            "!=" | "<>" => BinaryOp::NotEq,
            "<" => BinaryOp::Lt,
            ">" => BinaryOp::Gt,
            "<=" => BinaryOp::LtEq,
            ">=" => BinaryOp::GtEq,
            "+" => BinaryOp::Add,
            "-" => BinaryOp::Subtract,
            "*" => BinaryOp::Multiply,
            "/" => BinaryOp::Divide,
            "//" => BinaryOp::IntegerDivide,
            "%" => BinaryOp::Modulo,
            "^" | "**" => BinaryOp::Power,
            "&" => BinaryOp::BitAnd,
            "|" => BinaryOp::BitOr,
            "<<" => BinaryOp::ShiftLeft,
            ">>" => BinaryOp::ShiftRight,
            "||" => BinaryOp::Concat,
            "COLLATE" => BinaryOp::Collate,
            "->" => BinaryOp::Arrow,
            "->>" => BinaryOp::LongArrow,
            "@>" => BinaryOp::Contains,
            "<@" => BinaryOp::ContainedBy,
            "&&" => BinaryOp::Overlaps,
            "^@" => BinaryOp::StartsWith,
            "<<=" => BinaryOp::InetContainedByOrEq,
            ">>=" => BinaryOp::InetContainsOrEq,
            _ if self.name(leaf) == "AtTimeZoneOperator" => BinaryOp::AtTimeZone,
            // `IsDistinctFromOp <- 'IS' 'NOT'? 'DISTINCT' 'FROM'`, told apart by the middle word,
            // which is not in the tree because keywords are terminals.
            _ if self.name(leaf) == "IsDistinctFromOp" => {
                if upper.split_whitespace().any(|word| word == "NOT") {
                    BinaryOp::IsNotDistinctFrom
                } else {
                    BinaryOp::IsDistinctFrom
                }
            }
            // `OperatorLiteral` is the open end of the operator set. Its body in the grammar text
            // says `Identifier`, but it is one of the 24 rules whose body the matcher does not
            // walk and the matcher it is overridden to is the bare operator one, so what it
            // actually accepts is any run of operator characters that is not already a token.
            // `a <=> b` is such a run, DuckDB resolves it as a two argument function of that name,
            // and rejecting it here would reject SQL DuckDB accepts.
            _ if self.name(leaf) == "OperatorLiteral" => {
                let interned = self.intern(text);
                BinaryOp::Named(interned)
            }
            _ => return self.unsupported(node),
        };
        Ok(op)
    }

    /// `LogicalOrExpression <- LogicalAndExpression LogicalOrExpressionTail*`, and the `AND` twin.
    ///
    /// Separate from the other tails because the tail here is `'OR' LogicalAndExpression` with the
    /// keyword as a terminal, so there is no operator node to read and the operator is the rule.
    fn logical(&mut self, node: u32, op: BinaryOp) -> Result<ExprRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut left = self.expr(head)?;
        for tail in kids {
            let right = self.expr(self.first(tail))?;
            left = self.push(Expr::Binary { op, left, right });
        }
        Ok(left)
    }

    /// `LogicalNotExpression <- NotExpression? IsExpression`, where `NotExpression <- NotKeyword+`.
    ///
    /// The plus matters. `NOT NOT x` is two nodes in the parse tree and two negations in the AST,
    /// and folding them here would be an optimizer decision taken in the parser.
    fn logical_not(&mut self, node: u32) -> Result<ExprRef> {
        let negations = self.count(self.first(node));
        let mut expr = self.expr(self.nth(node, 1))?;
        for _ in 0..negations {
            expr = self.push(Expr::Unary { op: UnaryOp::Not, operand: expr });
        }
        Ok(expr)
    }

    /// `IsExpression <- IsDistinctFromExpression IsTest*`, the postfix null and boolean tests.
    fn is_expression(&mut self, node: u32) -> Result<ExprRef> {
        let mut kids = self.kids(node);
        let head = kids.next().unwrap_or(NONE);
        let mut expr = self.expr(head)?;
        for test in kids {
            let inner = self.first(test);
            let negated = self.text(inner).to_ascii_uppercase().contains("NOT");
            let op = match self.name(inner) {
                "NotNull" => UnaryOp::IsNotNull,
                "IsNull" => UnaryOp::IsNull,
                // `IsLiteral <- 'IS' 'NOT'? IsLiteralValue`, and the value rule is one more level
                // down again because it is a choice of four and not four alternatives inlined.
                "IsLiteral" => match self.name(self.first(self.first(inner))) {
                    "NullLiteral" if negated => UnaryOp::IsNotNull,
                    "NullLiteral" => UnaryOp::IsNull,
                    "TrueLiteral" if negated => UnaryOp::IsNotTrue,
                    "TrueLiteral" => UnaryOp::IsTrue,
                    "FalseLiteral" if negated => UnaryOp::IsNotFalse,
                    "FalseLiteral" => UnaryOp::IsFalse,
                    "UnknownLiteral" if negated => UnaryOp::IsNotUnknown,
                    "UnknownLiteral" => UnaryOp::IsUnknown,
                    _ => return self.unsupported(inner),
                },
                _ => return self.unsupported(inner),
            };
            expr = self.push(Expr::Unary { op, operand: expr });
        }
        Ok(expr)
    }

    /// `BetweenInLikeExpression <- OtherOperatorExpression BetweenInLikeOp?`.
    fn between_in_like(&mut self, node: u32) -> Result<ExprRef> {
        let operand = self.expr(self.first(node))?;
        // `BetweenInLikeOp <- 'NOT'? BetweenInLikeOpExpression`. The `NOT` is a terminal, so what
        // says it was written is that the op node covers a token the inner node does not.
        let op = self.nth(node, 1);
        let negated = self.text(op).to_ascii_uppercase().starts_with("NOT");
        let inner = self.first(self.first(op));
        match self.name(inner) {
            // `BetweenClause <- 'BETWEEN' x 'AND' y`.
            "BetweenClause" => {
                let low = self.expr(self.first(inner))?;
                let high = self.expr(self.nth(inner, 1))?;
                Ok(self.push(Expr::Between { operand, low, high, negated }))
            }
            // `InClause <- 'IN' InExpression`.
            "InClause" => {
                let expression = self.first(self.first(inner));
                match self.name(expression) {
                    "InExpressionList" => {
                        let mut items = Vec::new();
                        for kid in self.kids(expression) {
                            items.push(self.expr(kid)?);
                        }
                        let list = self.expr_slice(items);
                        Ok(self.push(Expr::In { operand, list, negated }))
                    }
                    _ => self.unsupported(expression),
                }
            }
            // `LikeClause <- LikeVariations x EscapeClause?`.
            "LikeClause" => {
                if self.find(inner, "EscapeClause") != NONE {
                    return self.unsupported(inner);
                }
                let variation = self.name(self.first(self.first(inner)));
                let op = match (variation, negated) {
                    ("LikeToken", false) | ("NotLikeOp", true) => BinaryOp::Like,
                    ("LikeToken", true) | ("NotLikeOp", false) => BinaryOp::NotLike,
                    ("ILikeToken", false) | ("NotILikeOp", true) => BinaryOp::ILike,
                    ("ILikeToken", true) | ("NotILikeOp", false) => BinaryOp::NotILike,
                    // Glob and the bare regex match have no negated spelling of their own in
                    // `LikeVariations`, so a `NOT` in front of either stays an explicit negation.
                    ("GlobToken", _) => BinaryOp::Glob,
                    ("RegexMatchToken", _) => BinaryOp::Regex,
                    ("SimilarToToken", false) => BinaryOp::SimilarTo,
                    ("SimilarToToken", true) => BinaryOp::NotSimilarTo,
                    ("NotSimilarToOp", false) => BinaryOp::NotRegex,
                    ("NotSimilarToOp", true) => BinaryOp::Regex,
                    ("RegexInsensitiveMatchToken", false)
                    | ("NotRegexInsensitiveMatchOp", true) => BinaryOp::RegexInsensitive,
                    ("RegexInsensitiveMatchToken", true)
                    | ("NotRegexInsensitiveMatchOp", false) => BinaryOp::NotRegexInsensitive,
                    _ => return self.unsupported(inner),
                };
                let right = self.expr(self.nth(inner, 1))?;
                let expr = self.push(Expr::Binary { op, left: operand, right });
                // The like family folds its negation into the operator because it has a spelling
                // for the negated form. Glob and regex do not, so theirs stays where it was.
                if negated && matches!(op, BinaryOp::Glob | BinaryOp::Regex) {
                    return Ok(self.push(Expr::Unary { op: UnaryOp::Not, operand: expr }));
                }
                Ok(expr)
            }
            _ => self.unsupported(inner),
        }
    }

    /// `PrefixExpression <- PrefixOperator* BaseExpression`, applied right to left.
    fn prefix(&mut self, node: u32) -> Result<ExprRef> {
        let kids: Vec<u32> = self.kids(node).collect();
        let mut expr = self.expr(kids[kids.len() - 1])?;
        for &operator in kids[..kids.len() - 1].iter().rev() {
            let op = match self.name(self.first(operator)) {
                "MinusPrefixOperator" => UnaryOp::Negate,
                "PlusPrefixOperator" => UnaryOp::Plus,
                "TildePrefixOperator" => UnaryOp::BitNot,
                _ => return self.unsupported(operator),
            };
            expr = self.push(Expr::Unary { op, operand: expr });
        }
        Ok(expr)
    }

    /// `BaseExpression <- SingleExpression IndirectionList?`, the postfix chain.
    fn indirection(&mut self, node: u32) -> Result<ExprRef> {
        let mut expr = self.expr(self.first(node))?;
        for step in self.kids(self.nth(node, 1)) {
            let inner = self.first(step);
            expr = match self.name(inner) {
                // `CastOperator <- '::' Type`.
                "CastOperator" => {
                    let text = self.text(self.first(inner)).to_string();
                    let ty = self.intern(&text);
                    self.push(Expr::Cast { operand: expr, ty, try_cast: false })
                }
                "DotOperator" => {
                    let dot = self.first(inner);
                    match self.name(dot) {
                        // `DotColumnOperator <- '.' ColLabel`, which DuckDB resolves as a call of
                        // `struct_extract`. Writing it as that call rather than as its own node
                        // keeps the binder from needing a rule for a thing that is already a
                        // function.
                        "DotColumnOperator" => {
                            let field = self.identifier(self.first(dot));
                            let text = self.ast.string(field).to_string();
                            let literal = self.intern(&text);
                            let key = self
                                .push(Expr::Literal { kind: LiteralKind::String, text: literal });
                            let name = self.function_name("struct_extract");
                            let args = self.expr_slice(vec![expr, key]);
                            self.push(Expr::Function { name, args, distinct: false })
                        }
                        // `DotMethodOperator <- '.' MethodExpression`, where `x.f(a)` is `f(x, a)`.
                        "DotMethodOperator" => {
                            let method = self.first(dot);
                            let text = self.text(self.first(method)).to_string();
                            let text = unquote(&text);
                            let name = self.function_name(&text);
                            let mut args = vec![expr];
                            let list = self.find(method, "MethodExpressionArguments");
                            if list != NONE {
                                let inner = self.first(list);
                                let arguments = self.find(inner, "MethodFunctionArguments");
                                if arguments != NONE {
                                    for kid in self.kids(arguments) {
                                        args.push(self.argument(kid)?);
                                    }
                                }
                            }
                            let args = self.expr_slice(args);
                            self.push(Expr::Function { name, args, distinct: false })
                        }
                        _ => return self.unsupported(dot),
                    }
                }
                // `SliceExpression <- '[' SliceBound ']'` over
                // `SliceBound <- Expression? EndSliceBound? StepSliceBound?`, so a subscript is one
                // index when neither colon is there and a range when either of them is. Both become
                // a call, the same two calls DuckDB's own transformer writes.
                "SliceExpression" => self.subscript(inner, expr)?,
                // `PostfixOperator <- '!'`.
                "PostfixOperator" => {
                    self.push(Expr::Unary { op: UnaryOp::Factorial, operand: expr })
                }
                _ => return self.unsupported(inner),
            };
        }
        Ok(expr)
    }

    /// `SliceExpression <- '[' SliceBound ']'`, which is `array_extract` or `array_slice`.
    ///
    /// The three parts of the bound are all optional and any of the eight combinations parses, so
    /// which call this is comes from which parts are there rather than from how many children the
    /// bound has. One expression and no colon is an index. Anything with a colon in it is a range,
    /// and a range the query did not write both ends of gets the ends DuckDB's transformer gives it:
    /// a missing begin is 1 and a missing end is -1, which is the last element, so `x[:]` is the
    /// whole of `x` and `array_slice(x, 1, -1)` answers the same thing.
    ///
    /// `EndSliceMinus` is the `-` in `x[1:-]`, which upstream reads as a range with no end rather
    /// than as a subtraction of nothing, and it answers `x[1:]`. So it is the missing end too.
    ///
    /// The step is the odd one. `x[1:2:]` is a step that is written and empty, and what upstream
    /// does with it is pass a list where the step goes, which then fails to bind because the fourth
    /// parameter is a BIGINT. The empty list here is that, measured off the pinned binary: it says
    /// `array_slice(INTEGER[], INTEGER_LITERAL, INTEGER_LITERAL, INTEGER[])` has no match, and the
    /// fourth type in that sentence is the list. Writing a 1 there instead would answer a row where
    /// the reference refuses.
    fn subscript(&mut self, node: u32, target: ExprRef) -> Result<ExprRef> {
        let bound = self.first(node);
        let (mut begin, mut end, mut step) = (NONE, NONE, NONE);
        for kid in self.kids(bound) {
            match self.name(kid) {
                "EndSliceBound" => end = kid,
                "StepSliceBound" => step = kid,
                _ => begin = kid,
            }
        }
        if end == NONE && step == NONE {
            if begin == NONE {
                return Err(Error::parser("Empty subscript '[]' is not allowed"));
            }
            let index = self.expr(begin)?;
            let name = self.function_name("array_extract");
            let args = self.expr_slice(vec![target, index]);
            return Ok(self.push(Expr::Function { name, args, distinct: false }));
        }
        let first = if begin == NONE { self.literal_number("1") } else { self.expr(begin)? };
        // `EndSliceBound <- ':' EndSliceValue?` and `EndSliceValue <- Expression / EndSliceMinus`,
        // so the end is written only when the value is there and is not the lone hyphen.
        let value = if end == NONE { NONE } else { self.find(end, "EndSliceValue") };
        let written = if value == NONE { NONE } else { self.first(value) };
        let last = if written == NONE || self.name(written) == "EndSliceMinus" {
            self.literal_number("-1")
        } else {
            self.expr(written)?
        };
        let mut args = vec![target, first, last];
        if step != NONE {
            let by = self.first(step);
            args.push(if by == NONE {
                self.push(Expr::List { items: Slice::default() })
            } else {
                self.expr(by)?
            });
        }
        let name = self.function_name("array_slice");
        let args = self.expr_slice(args);
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// A number literal the transformer writes rather than reads, for a bound a range left out.
    fn literal_number(&mut self, digits: &str) -> ExprRef {
        let text = self.intern(digits);
        self.push(Expr::Literal { kind: LiteralKind::Number, text })
    }

    /// A one part function name, for the calls the transformer invents rather than reads.
    fn function_name(&mut self, name: &str) -> Slice {
        let interned = self.intern(name);
        self.part_slice(vec![interned])
    }

    /// `StarExpression <- StarQualifierList? '*' ExcludeList? ReplaceList? RenameList?`.
    fn star(&mut self, node: u32) -> Result<ExprRef> {
        for name in ["ExcludeList", "RenameList"] {
            let list = self.find(node, name);
            if list != NONE {
                return self.unsupported(list);
            }
        }
        let replace = self.find(node, "ReplaceList");
        let replacements =
            if replace == NONE { Slice::default() } else { self.replacements(replace)? };
        let qualifier = self.find(node, "StarQualifierList");
        let qualifier =
            if qualifier == NONE { Slice::default() } else { self.name_parts(qualifier) };
        Ok(self.push(Expr::Star { qualifier, replacements }))
    }

    /// `ReplaceList <- 'REPLACE' ReplaceEntries`, where an entry is `Expression 'AS'
    /// ColumnReference` and the entries are one bare entry or a parenthesized list of them.
    ///
    /// The duplicate check is here rather than in the binder because that is where DuckDB does it:
    /// naming the same column twice is a Parser Error there, and it is one of the few things about
    /// a star that can be decided without knowing what the star stands for.
    fn replacements(&mut self, node: u32) -> Result<Slice> {
        // `ReplaceEntries <- ReplaceEntrySingle / ReplaceEntryList` and both of those hold the
        // entries as their own children, so the same walk reads either shape.
        let entries = self.first(self.first(node));
        let listed: Vec<u32> =
            self.kids(entries).filter(|&kid| self.name(kid) == "ReplaceEntry").collect();
        let mut replacements = Vec::with_capacity(listed.len());
        for entry in listed {
            let expr = self.expr(self.first(entry))?;
            let alias = self.identifier(self.nth(entry, 1));
            let written = self.ast.string(alias).to_string();
            if replacements
                .iter()
                .any(|held: &Target| self.ast.string(held.alias).eq_ignore_ascii_case(&written))
            {
                return Err(Error::parser(format!(
                    "Duplicate entry \"{written}\" in REPLACE list"
                )));
            }
            replacements.push(Target { expr, alias });
        }
        Ok(self.target_slice(replacements))
    }

    /// `FunctionExpression <- FunctionIdentifier FunctionExpressionArguments WithinGroupClause?
    /// FilterClause? ExportClause? OverClause?`.
    fn function(&mut self, node: u32) -> Result<ExprRef> {
        for name in ["WithinGroupClause", "FilterClause", "ExportClause", "OverClause"] {
            let clause = self.find(node, name);
            if clause != NONE {
                return self.unsupported(clause);
            }
        }
        let name = self.name_parts(self.first(node));
        // `FunctionExpressionArguments <- Parens(FunctionExpressionArgumentList)` and
        // `FunctionExpressionArgumentList <- DistinctOrAll? FunctionArgumentList? OrderByClause?
        // IgnoreOrRespectNulls?`, so a call with no arguments still has both wrappers.
        let list = self.first(self.nth(node, 1));
        for name in ["OrderByClause", "IgnoreOrRespectNulls"] {
            let clause = self.find(list, name);
            if clause != NONE {
                return self.unsupported(clause);
            }
        }
        let distinct = self.quantifier(self.find(list, "DistinctOrAll")) == Quantifier::Distinct;
        let mut args = Vec::new();
        let arguments = self.find(list, "FunctionArgumentList");
        if arguments != NONE {
            for kid in self.kids(arguments) {
                args.push(self.argument(kid)?);
            }
        }
        // `IFNULL` is an ordinary call in the grammar and is not one by the time DuckDB's parser is
        // done with it: `ifnull(NULL, 3)` comes back named `COALESCE(NULL, 3)` there, and so does
        // `main.ifnull(NULL, 3)`, so the qualifier goes with the rewrite. The count is checked here
        // because that is where upstream checks it, with the sentence below rather than the binder's
        // arity error, and it is checked before the two arguments are looked at.
        if self.ast.name(name).last().is_some_and(|part| part.eq_ignore_ascii_case("ifnull")) {
            if args.len() != 2 {
                return Err(Error::parser("Wrong number of arguments to IFNULL."));
            }
            let args = self.expr_slice(args);
            let name = self.function_name("coalesce");
            return Ok(self.push(Expr::Function { name, args, distinct }));
        }
        let args = self.expr_slice(args);
        Ok(self.push(Expr::Function { name, args, distinct }))
    }

    /// `CoalesceExpression <- 'COALESCE' Parens(List(Expression))`.
    ///
    /// A keyword is not a child and the two wrappers are transparent, so the children are the
    /// arguments. One of them is enough for the grammar and none of them is a syntax error, which is
    /// why there is no count checked here.
    ///
    /// The call is written with the canonical name rather than the one the query used, since there is
    /// nothing else to keep: the keyword is the name. Upstream prints the column in capitals whatever
    /// case was written, because `COALESCE` is an operator there and not a function name that its
    /// parser folded, and the binder is where that is decided here.
    fn coalesce(&mut self, node: u32) -> Result<ExprRef> {
        let mut args = Vec::new();
        for kid in self.kids(node) {
            args.push(self.expr(kid)?);
        }
        let args = self.expr_slice(args);
        let name = self.function_name("coalesce");
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `NullIfExpression <- 'NULLIF' Parens(NullIfArguments)` and
    /// `NullIfArguments <- Expression ',' Expression`.
    ///
    /// Exactly two arguments, because the rule says so: `nullif(1)` and `nullif(1, 2, 3)` are syntax
    /// errors upstream and are syntax errors here for the same reason, so there is no arity to check
    /// after the parse.
    ///
    /// It stays a function called `nullif` rather than becoming the `CASE` upstream's macro expands
    /// to, since the column it produces is named after the call and not after the expansion.
    fn null_if(&mut self, node: u32) -> Result<ExprRef> {
        let arguments = self.find(node, "NullIfArguments");
        if arguments == NONE {
            return self.unsupported(node);
        }
        let mut args = Vec::new();
        for kid in self.kids(arguments) {
            args.push(self.expr(kid)?);
        }
        let args = self.expr_slice(args);
        let name = self.function_name("nullif");
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `SubstringExpression <- 'SUBSTRING' Parens(SubstringArguments)` and
    /// `SubstringArguments <- SubstringParameters / SubstringExpressionList`.
    ///
    /// Both spellings are the same call and DuckDB's parser writes both of them back out as one:
    /// `substring(s FROM a FOR b)` comes back as the column `"substring"(s, a, b)` there, and so does
    /// `substring(s, a, b)`. The `FOR` on its own is the one worth pointing at, since it is not the
    /// two argument call it looks like. `substring('abcdef' FOR 3)` is `"substring"('abcdef', 1, 3)`
    /// upstream, so the start is filled in with a literal 1 here rather than left out.
    fn substring(&mut self, node: u32) -> Result<ExprRef> {
        let shape = self.first(self.first(node));
        let mut args = Vec::new();
        match self.name(shape) {
            "SubstringExpressionList" => {
                for kid in self.kids(shape) {
                    args.push(self.expr(kid)?);
                }
            }
            "SubstringParameters" => {
                args.push(self.expr(self.first(shape))?);
                // `SubstringFromFor <- SubstringFromOptionalFor / SubstringFor`, and both of those
                // hold the bounds as `FromExpression` and `ForExpression`, so finding them by name
                // reads either shape and neither one has to be told apart from the other.
                let bounds = self.first(self.nth(shape, 1));
                let from = self.find(bounds, "FromExpression");
                let start =
                    if from == NONE { self.number("1") } else { self.expr(self.first(from))? };
                args.push(start);
                let count = self.find(bounds, "ForExpression");
                if count != NONE {
                    args.push(self.expr(self.first(count))?);
                }
            }
            _ => return self.unsupported(shape),
        }
        let args = self.expr_slice(args);
        let name = self.function_name("substring");
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `PositionExpression <- 'POSITION' Parens(PositionArguments)` and
    /// `PositionArguments <- OtherOperatorExpression 'IN' Expression`.
    ///
    /// The two arguments swap. `position('c' IN 'abcdef')` is `"position"('abcdef', 'c')` upstream,
    /// which is the same order `strpos` and `instr` are written in, so the haystack comes first in
    /// the call and second in the query.
    fn position(&mut self, node: u32) -> Result<ExprRef> {
        let arguments = self.first(node);
        if self.count(arguments) != 2 {
            return self.unsupported(arguments);
        }
        let needle = self.expr(self.first(arguments))?;
        let haystack = self.expr(self.nth(arguments, 1))?;
        let args = self.expr_slice(vec![haystack, needle]);
        let name = self.function_name("position");
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `TrimExpression <- 'TRIM' Parens(TrimArguments)` and
    /// `TrimArguments <- TrimDirection? TrimSource? List(Expression)`.
    ///
    /// The direction is not an argument, it is the function: `LEADING` is `ltrim` upstream and
    /// `TRAILING` is `rtrim`, while `BOTH` and the bare form are both `trim`. The characters to strip
    /// are the last argument whichever way they were written, so `trim(BOTH 'x' FROM 'xxaxx')` and
    /// `trim('xxaxx', 'x')` are the same call, which is why the source goes on the end of the list
    /// rather than in front of it.
    fn trim(&mut self, node: u32) -> Result<ExprRef> {
        let arguments = self.first(node);
        let direction = self.find(arguments, "TrimDirection");
        let name = match direction {
            NONE => "trim",
            held => match self.name(self.first(held)) {
                "TrimLeading" => "ltrim",
                "TrimTrailing" => "rtrim",
                _ => "trim",
            },
        };
        let mut args = Vec::new();
        for kid in self.kids(arguments) {
            if matches!(self.name(kid), "TrimDirection" | "TrimSource") {
                continue;
            }
            args.push(self.expr(kid)?);
        }
        // `TrimSource <- Expression? 'FROM'`, so `trim(LEADING FROM s)` has the node with nothing
        // under it and there is no second argument to add.
        let source = self.find(arguments, "TrimSource");
        if source != NONE && self.count(source) == 1 {
            args.push(self.expr(self.first(source))?);
        }
        let args = self.expr_slice(args);
        let name = self.function_name(name);
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `OverlayExpression <- 'OVERLAY' Parens(OverlayArguments)` and
    /// `OverlayArguments <- OverlayParameters / OverlayExpressionList`, where
    /// `OverlayParameters <- Expression 'PLACING' Expression FromExpression ForExpression?`.
    ///
    /// The arguments are already in the order the call takes them, so the keyword spelling is the
    /// list spelling with `PLACING`, `FROM` and `FOR` where the commas would be:
    /// `overlay('abcdef' PLACING 'X' FROM 2 FOR 1)` is `"overlay"('abcdef', 'X', 2, 1)` upstream.
    fn overlay(&mut self, node: u32) -> Result<ExprRef> {
        let shape = self.first(self.first(node));
        if !matches!(self.name(shape), "OverlayParameters" | "OverlayExpressionList") {
            return self.unsupported(shape);
        }
        let mut args = Vec::new();
        for kid in self.kids(shape) {
            let kid = match self.name(kid) {
                "FromExpression" | "ForExpression" => self.first(kid),
                _ => kid,
            };
            args.push(self.expr(kid)?);
        }
        let args = self.expr_slice(args);
        let name = self.function_name("overlay");
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// A number literal the query did not write, for the one place a lowering has to supply one.
    fn number(&mut self, text: &str) -> ExprRef {
        let text = self.intern(text);
        self.push(Expr::Literal { kind: LiteralKind::Number, text })
    }

    /// `ExtractExpression <- 'EXTRACT' Parens(ExtractArguments)` and
    /// `ExtractArguments <- ExtractArgument 'FROM' Expression`.
    ///
    /// `EXTRACT` is not a function in the grammar because its argument list is not an argument
    /// list, and it is a function everywhere after here because DuckDB's parser does the same
    /// rewrite: `EXTRACT(minute FROM t)` is `date_part('minute', t)` and there is no separate
    /// implementation of one of them. The part is a keyword, an identifier or a string in the
    /// grammar, and all three become the string, which is why this is a rewrite and not a node.
    fn extract(&mut self, node: u32) -> Result<ExprRef> {
        let arguments = self.find(node, "ExtractArguments");
        if arguments == NONE {
            return self.unsupported(node);
        }
        let argument = self.first(self.first(arguments));
        let part = match self.name(argument) {
            "ExtractStringArgument" => self.string_value(argument)?,
            // A keyword, which is one of the thirteen the grammar names and is written back as the
            // one spelling that keyword has. `EXTRACT(seconds FROM t)` and `EXTRACT(SECOND FROM t)`
            // are both `date_part('SECOND', t)`, which was measured, and it shows up in the column
            // name as well as in the deparse, since an unaliased column is named after the call.
            "ExtractDatePartArgument" => date_part(self.text(argument)),
            // An identifier, taken as written. Which specifier names are legal is not a question
            // about syntax, so the answer to it lives with the function.
            "ExtractIdentifierArgument" => self.text(argument).to_string(),
            _ => return self.unsupported(argument),
        };
        let text = self.intern(&part);
        let part = self.push(Expr::Literal { kind: LiteralKind::String, text });
        let operand = self.expr(self.nth(arguments, 1))?;
        let name = self.function_name("date_part");
        let args = self.expr_slice(vec![part, operand]);
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `FunctionArgument <- NamedFunctionArgument / PositionalFunctionArgument`.
    fn argument(&mut self, node: u32) -> Result<ExprRef> {
        let inner = self.first(node);
        match self.name(inner) {
            "PositionalFunctionArgument" => self.expr(self.first(inner)),
            _ => self.unsupported(inner),
        }
    }

    /// One argument of a table function, which is the same rule plus the names.
    ///
    /// `NamedParameter <- TypeFuncName Type? NamedParameterAssignment Expression` and
    /// `NamedParameterAssignment <- ':=' / '=>'`, so those two spellings are what the grammar has.
    /// The binary accepts a third, `name = value`, which the grammar has no rule for because it
    /// parses as an equality and is picked apart afterwards. That is what happens here too: a
    /// positional argument that is a comparison between a bare name and something else is a named
    /// parameter, which is the reading upstream's own transformer gives it. `read_parquet(f,
    /// binary_as_string=True)` is the query that matters and it is the spelling the ClickBench
    /// entry uses.
    ///
    /// The name is not resolved here and neither is the value. Which parameters a function takes
    /// is the binder's question, and so is whether `binary_as_string=True` means anything to the
    /// function it was written on.
    fn table_argument(&mut self, node: u32) -> Result<Target> {
        let inner = self.first(node);
        if self.name(inner) == "NamedFunctionArgument" {
            let named = self.first(inner);
            if self.count(named) != 3 {
                // The optional `Type` between the name and the assignment, which is a macro
                // parameter's declaration and not a call.
                return self.unsupported(named);
            }
            let alias = self.identifier(self.first(named));
            let expr = self.expr(self.nth(named, 2))?;
            return Ok(Target { expr, alias });
        }
        let expr = self.expr(self.first(inner))?;
        if let Expr::Binary { op: BinaryOp::Eq, left, right } = self.ast.expr(expr) {
            if let Expr::Column { name } = self.ast.expr(left) {
                if name.len == 1 {
                    let alias = self.ast.parts[name.start as usize];
                    return Ok(Target { expr: right, alias });
                }
            }
        }
        Ok(Target { expr, alias: NONE })
    }

    /// `CastExpression <- CastOrTryCast Parens(CastArguments)`.
    fn cast(&mut self, node: u32) -> Result<ExprRef> {
        let try_cast = self.name(self.first(self.first(node))) == "TryCastKeyword";
        // `CastArguments <- Expression 'AS' Type`.
        let arguments = self.nth(node, 1);
        let operand = self.expr(self.first(arguments))?;
        let text = self.text(self.nth(arguments, 1)).to_string();
        let ty = self.intern(&text);
        Ok(self.push(Expr::Cast { operand, ty, try_cast }))
    }

    /// `TypeLiteral <- Type StringLiteral`, which is the cast written the other way round.
    ///
    /// `DATE '1995-09-01'` and `CAST('1995-09-01' AS DATE)` are the same expression upstream, and
    /// the proof is the column name: the pinned binary answers both of them in a column called
    /// `CAST('1995-09-01' AS DATE)`. So this is the cast node and nothing else, which means every
    /// type the cast already takes is a typed literal for free and the two can never drift.
    ///
    /// The string is the literal the grammar matched rather than any expression, so there is no
    /// constant folding question here. `DATE x` does not parse in the first place.
    fn typed_literal(&mut self, node: u32) -> Result<ExprRef> {
        let text = self.text(self.first(node)).to_string();
        let ty = self.intern(&text);
        let operand = self.expr(self.nth(node, 1))?;
        Ok(self.push(Expr::Cast { operand, ty, try_cast: false }))
    }

    /// `IntervalLiteral <- 'INTERVAL' IntervalParameter Interval?`, which is a function call.
    ///
    /// There is no interval node and there does not need to be one, because DuckDB's own
    /// transformer rewrites the literal into a call and the column name says so: `INTERVAL 1 DAY`
    /// comes back from the pinned binary in a column called
    /// `to_days(CAST(trunc(CAST(1 AS DOUBLE)) AS INTEGER))`. So the literal and a handwritten
    /// `to_days(1)` are the same expression from here on and the two cannot drift apart.
    ///
    /// Every unit goes through a DOUBLE on the way in, which is what makes `INTERVAL 1.5 DAY` one
    /// day rather than a day and a half: the truncation is in the rewrite and not in the function.
    /// The two units that can carry a fraction skip the truncation and stay a DOUBLE all the way,
    /// so `INTERVAL 2.7 SECOND` really is two and seven tenths of a second.
    ///
    /// A literal with no unit is the cast written the other way round, so `INTERVAL '1 day'` is
    /// `CAST('1 day' AS INTERVAL)`. That arm also catches a word the grammar does not read as a
    /// unit, since `INTERVAL 1 d` parses as this rule with no `Interval` child and a column alias
    /// after it, which is why upstream answers it with a cast error about an INTEGER.
    fn interval_literal(&mut self, node: u32) -> Result<ExprRef> {
        let parameter = self.find(node, "IntervalParameter");
        if parameter == NONE {
            return self.unsupported(node);
        }
        let operand = self.expr(self.first(parameter))?;
        let unit = self.find(node, "Interval");
        if unit == NONE {
            let ty = self.intern("INTERVAL");
            return Ok(self.push(Expr::Cast { operand, ty, try_cast: false }));
        }
        let spelling = self.name(self.first(unit));
        // The seven range forms parse and then refuse, in upstream's words, with the unit names
        // spelled the canonical way rather than the way they were written: `interval 1 days to
        // hours` is `DAY TO HOUR` there as well.
        if spelling == "IntervalToInterval" {
            let pair = self.name(self.first(self.first(unit)));
            return Err(Error::parser(format!("{} is not supported", worded(pair))));
        }
        let Some(&(_, function, width)) = UNITS.iter().find(|(rule, _, _)| *rule == spelling)
        else {
            return self.unsupported(unit);
        };
        let double = self.intern("DOUBLE");
        let mut count = self.push(Expr::Cast { operand, ty: double, try_cast: false });
        if let Some(width) = width {
            let name = self.function_name("trunc");
            let args = self.expr_slice(vec![count]);
            let whole = self.push(Expr::Function { name, args, distinct: false });
            let ty = self.intern(width);
            count = self.push(Expr::Cast { operand: whole, ty, try_cast: false });
        }
        let name = self.function_name(function);
        let args = self.expr_slice(vec![count]);
        Ok(self.push(Expr::Function { name, args, distinct: false }))
    }

    /// `CaseExpression <- 'CASE' Expression? CaseWhenThen+ CaseElse? 'END'`.
    fn case(&mut self, node: u32) -> Result<ExprRef> {
        let mut operand = NONE;
        let mut arms = Vec::new();
        let mut otherwise = NONE;
        for kid in self.kids(node) {
            match self.name(kid) {
                // `CaseWhenThen <- 'WHEN' Expression 'THEN' Expression`.
                "CaseWhenThen" => {
                    let when = self.expr(self.first(kid))?;
                    let then = self.expr(self.nth(kid, 1))?;
                    arms.push(CaseArm { when, then });
                }
                // `CaseElse <- 'ELSE' Expression`.
                "CaseElse" => otherwise = self.expr(self.first(kid))?,
                // The bare `Expression` before the first `WHEN`, which makes it a simple case.
                _ => operand = self.expr(kid)?,
            }
        }
        let start = self.ast.case_arms.len() as u32;
        self.ast.case_arms.extend(arms);
        let arms = Slice { start, len: self.ast.case_arms.len() as u32 - start };
        Ok(self.push(Expr::Case { operand, arms, otherwise }))
    }

    /// `ParenthesisExpression <- Parens(List(Expression)?)`, which is a row value.
    ///
    /// One item is not a row. `(a)` is `a` in every dialect and reading it as a one column row
    /// would change what `(a) = (b)` means.
    fn row(&mut self, node: u32) -> Result<ExprRef> {
        let mut items = Vec::new();
        for kid in self.kids(node) {
            items.push(self.expr(kid)?);
        }
        if items.len() == 1 {
            return Ok(items[0]);
        }
        let items = self.expr_slice(items);
        Ok(self.push(Expr::Row { items }))
    }

    /// `Parameter <- '?' Number / '?' / '$' Number / '$' ColLabel`, a prepared statement parameter.
    ///
    /// The identifier is what follows the marker, so `?1` and `$1` are both the parameter named 1,
    /// and a bare `?` takes the next number by where it was written. That is what DuckDB does, which
    /// is why `? + $2` prints as `$1 + $2`: the counting is its own and does not skip a number
    /// because a later parameter claimed it.
    fn parameter(&mut self, node: u32) -> Result<ExprRef> {
        let written = self.text(node).trim();
        let written = written.trim_start_matches(['?', '$']).trim();
        let name = if written.is_empty() {
            self.anonymous += 1;
            self.anonymous.to_string()
        } else {
            written.to_string()
        };
        let name = self.intern(&name);
        Ok(self.push(Expr::Parameter { name }))
    }

    /// `BoundedListExpression <- '[' List(Expression)? ']'`, which is a LIST value.
    ///
    /// One item is a list of one here, unlike the parenthesised form, because the brackets are what
    /// say list and there is nothing else `[a]` could mean.
    fn list(&mut self, node: u32) -> Result<ExprRef> {
        let mut items = Vec::new();
        for kid in self.kids(node) {
            items.push(self.expr(kid)?);
        }
        let items = self.expr_slice(items);
        Ok(self.push(Expr::List { items }))
    }

    /// `SubqueryExpression <- SubqueryNot? SubqueryExists? SubqueryReference`.
    fn subquery(&mut self, node: u32) -> Result<ExprRef> {
        if self.find(node, "SubqueryNot") != NONE || self.find(node, "SubqueryExists") != NONE {
            return self.unsupported(node);
        }
        let reference = self.find(node, "SubqueryReference");
        let query = self.query(self.first(reference))?;
        Ok(self.push(Expr::Subquery { query }))
    }

    /// The value of a string literal, with the quotes gone and the escapes resolved.
    ///
    /// A literal can be several tokens. `'a' 'b'` on two lines is one literal that is `ab`, which is
    /// the SQL standard's rule and DuckDB's, so the node is decoded token by token rather than by
    /// taking its text and stripping the outside.
    fn string_value(&self, node: u32) -> Result<String> {
        let span = self.tree.node(node);
        let mut value = String::new();
        for token in &self.tokens[span.start as usize..span.end as usize] {
            if token.kind == Kind::String {
                value.push_str(&string_token(token.text(self.query))?);
            }
        }
        Ok(value)
    }

    /// The token that opens a string literal, which is the whole of it when it has a prefix.
    ///
    /// Only the first token is asked, because a prefixed literal is one token: `E'a' 'b'` is a
    /// syntax error upstream rather than a concatenation, so there is no second prefix to disagree
    /// with this one.
    fn first_string(&self, node: u32) -> &'a str {
        let span = self.tree.node(node);
        self.tokens[span.start as usize..span.end as usize]
            .iter()
            .find(|token| token.kind == Kind::String)
            .map_or("", |token| token.text(self.query))
    }

    /// A string literal as an expression, which is the value plus what the prefix makes of it.
    ///
    /// `N'abc'` is a cast of the string to VARCHAR upstream and not a plain string, and the column
    /// name is the proof: the pinned binary answers it in a column called `CAST('abc' AS VARCHAR)`.
    /// So it is written here as the cast it is, and then there is nothing left to keep in step.
    ///
    /// `x'4142'` is not a string at all, it is a BLOB, so it is the one prefix that becomes a
    /// different kind of literal rather than a string with something done to it.
    fn string_literal(&mut self, node: u32) -> Result<ExprRef> {
        let token = self.first_string(node);
        let prefix = match token.as_bytes() {
            [prefix, b'\'', ..] => *prefix,
            _ => 0,
        };
        if matches!(prefix, b'X' | b'x') {
            if let Some(body) = token.get(1..).and_then(quoted_body) {
                let text = blob_text(body.as_bytes())?;
                let text = self.intern(&text);
                return Ok(self.push(Expr::Literal { kind: LiteralKind::Blob, text }));
            }
        }
        let value = self.string_value(node)?;
        let text = self.intern(&value);
        let literal = self.push(Expr::Literal { kind: LiteralKind::String, text });
        if matches!(prefix, b'N' | b'n') {
            let ty = self.intern("VARCHAR");
            return Ok(self.push(Expr::Cast { operand: literal, ty, try_cast: false }));
        }
        Ok(literal)
    }
}

/// Each unit an interval literal can be written in, as the grammar rule that spells it, the
/// function it becomes, and the width the count is truncated to on the way there.
///
/// A width of `None` is the pair that keeps what is after the point. Those two stay a DOUBLE and
/// never see `trunc`, which is the whole of the difference between `INTERVAL 2.7 SECOND` being two
/// and seven tenths of a second and `INTERVAL 1.5 DAY` being one day. Every entry, both spellings
/// of every keyword and the width of each one was read off the pinned binary's column names.
const UNITS: &[(&str, &str, Option<&str>)] = &[
    ("YearKeyword", "to_years", Some("INTEGER")),
    ("MonthKeyword", "to_months", Some("INTEGER")),
    ("QuarterKeyword", "to_quarters", Some("INTEGER")),
    ("DecadeKeyword", "to_decades", Some("INTEGER")),
    ("CenturyKeyword", "to_centuries", Some("INTEGER")),
    ("MillenniumKeyword", "to_millennia", Some("INTEGER")),
    ("DayKeyword", "to_days", Some("INTEGER")),
    ("WeekKeyword", "to_weeks", Some("INTEGER")),
    ("HourKeyword", "to_hours", Some("BIGINT")),
    ("MinuteKeyword", "to_minutes", Some("BIGINT")),
    ("MicrosecondKeyword", "to_microseconds", Some("BIGINT")),
    ("SecondKeyword", "to_seconds", None),
    ("MillisecondKeyword", "to_milliseconds", None),
];

/// The one spelling a date part keyword is written back as, which is not always the singular.
///
/// Both spellings of each of the thirteen keywords land on one name, and the name is upper case and
/// is plural for the two smallest parts and singular for the rest. That is not a rule, it is a list,
/// and it was read off the pinned binary a keyword at a time: `EXTRACT(milliseconds FROM t)` and
/// `EXTRACT(millisecond FROM t)` are both `date_part('MILLISECONDS', t)` while `EXTRACT(seconds FROM
/// t)` is `date_part('SECOND', t)`.
///
/// A word that is not a keyword never reaches here, because the grammar tells the two apart, and it
/// keeps whatever case it was written in. `EXTRACT(epoch FROM t)` stays lower case, measured.
fn date_part(written: &str) -> String {
    const PARTS: &[(&str, &str)] = &[
        ("YEAR", "YEAR"),
        ("YEARS", "YEAR"),
        ("MONTH", "MONTH"),
        ("MONTHS", "MONTH"),
        ("DAY", "DAY"),
        ("DAYS", "DAY"),
        ("HOUR", "HOUR"),
        ("HOURS", "HOUR"),
        ("MINUTE", "MINUTE"),
        ("MINUTES", "MINUTE"),
        ("SECOND", "SECOND"),
        ("SECONDS", "SECOND"),
        ("MILLISECOND", "MILLISECONDS"),
        ("MILLISECONDS", "MILLISECONDS"),
        ("MICROSECOND", "MICROSECONDS"),
        ("MICROSECONDS", "MICROSECONDS"),
        ("WEEK", "WEEK"),
        ("WEEKS", "WEEK"),
        ("QUARTER", "QUARTER"),
        ("QUARTERS", "QUARTER"),
        ("DECADE", "DECADE"),
        ("DECADES", "DECADE"),
        ("CENTURY", "CENTURY"),
        ("CENTURIES", "CENTURY"),
        ("MILLENNIUM", "MILLENNIUM"),
        ("MILLENNIA", "MILLENNIUM"),
    ];
    PARTS
        .iter()
        .find(|(spelling, _)| spelling.eq_ignore_ascii_case(written))
        .map_or_else(|| written.to_string(), |(_, name)| (*name).to_string())
}

/// A grammar rule name like `DayToHour` as the words upstream puts in the message for it.
fn worded(rule: &str) -> String {
    let mut out = String::new();
    for character in rule.chars() {
        if character.is_ascii_uppercase() && !out.is_empty() {
            out.push(' ');
        }
        out.push(character.to_ascii_uppercase());
    }
    out
}

/// The value of one string token, with the quotes gone and whatever the prefix means resolved.
///
/// There is no fall through that keeps the source text. That arm is what answered `SELECT E'a'`
/// with the four characters `E'a'`, and a default that silently answers with the query is a default
/// that will do this again with the next spelling somebody adds, so a spelling this does not know
/// raises instead. Per #329.
fn string_token(text: &str) -> Result<String> {
    if let Some(body) = dollar_body(text) {
        return Ok(body.to_string());
    }
    if let Some(body) = quoted_body(text) {
        return Ok(body.replace("''", "'"));
    }
    let Some(body) = text.get(1..).and_then(quoted_body) else {
        return Ok(text.to_string());
    };
    match text.as_bytes()[0] {
        b'E' | b'e' => escaped(body),
        // `N'abc'` is the string and nothing else. The cast that makes the name is put on outside.
        b'N' | b'n' => Ok(body.replace("''", "'")),
        // Not a bit string, whatever the spelling suggests. Upstream answers `B'101'` with the four
        // characters `b101` as a VARCHAR, and `B''` with the one character `b`, which is measured
        // and not guessed. Nothing else is done with the body.
        b'B' | b'b' => Ok(format!("b{}", body.replace("''", "'"))),
        // `x'41'` is a BLOB and a BLOB is not a string, so the places that want a string out of a
        // literal, which are DESCRIBE and the part in EXTRACT, do not get one from this spelling.
        _ => Err(Error::not_implemented(format!("the string literal {text} is not supported yet"))),
    }
}

/// The text a blob literal's body means, which is the text a blob prints as.
///
/// `x'4142'` is two bytes and the pinned binary calls the column `'AB'::BLOB`, so what is kept here
/// is the printed form and not the source. The cast that reads it back gives the bytes again, which
/// is what makes one text enough for both the value and the name, and it is `Value` that prints it
/// so the two spellings of a blob cannot drift apart.
///
/// Upstream writes `\xHH` for every pair without looking at the digits and lets the cast refuse the
/// ones that are not hex, which is why `x'4'` is a parser error and `x'zz'` is a conversion error
/// one step later. Doing the same thing gives both messages in the same words. The pairs are bytes
/// and not characters: `x'éé'` is four bytes and so two pairs, which is how upstream counts them.
fn blob_text(body: &[u8]) -> Result<String> {
    if body.len() % 2 != 0 {
        return Err(Error::parser("Hex string literal must have an even number of hex digits"));
    }
    let digit = |byte: u8| (byte as char).to_digit(16).map(|digit| digit as u8);
    let bytes: Option<Vec<u8>> =
        body.chunks(2).map(|pair| Some(digit(pair[0])? * 16 + digit(pair[1])?)).collect();
    match bytes {
        Some(bytes) => Ok(Value::Blob(bytes).to_string()),
        None => {
            Ok(body.chunks(2).map(|pair| format!("\\x{}", String::from_utf8_lossy(pair))).collect())
        }
    }
}

/// The body of a single quoted string, for the tokens that are one.
///
/// An unterminated token has nothing to take off the end and keeps every byte it was given, which
/// is why the closing quote has to be a quote that is not also the opening one.
fn quoted_body(text: &str) -> Option<&str> {
    text.strip_prefix('\'').filter(|rest| !rest.is_empty()).and_then(|rest| rest.strip_suffix('\''))
}

/// The body of an `E'...'` literal, with the C style escapes resolved.
///
/// Every rule here was read off the pinned binary one at a time. The named escapes are `\n`, `\t`,
/// `\r`, `\b` and `\f`, and `\v` is not one of them. `\x` takes one or two hex digits and `\0`
/// through `\7` take one to three octal digits, both of which write a byte and not a character, so
/// `\xc3\xa9` is one `é` and `\377` is not a string at all. `\uHHHH` takes exactly four hex digits
/// and writes the character they name. Anything else, including a `\u` that is short or names a
/// surrogate half or a NUL, drops the backslash and keeps the character, so `\q` is `q` and `\u41`
/// is `u41`.
///
/// The result is bytes until the end because the escapes write bytes, and the two ways of writing
/// something that is not a string both raise the way upstream raises them.
fn escaped(body: &str) -> Result<String> {
    let bytes = body.as_bytes();
    let mut out = Vec::with_capacity(bytes.len());
    let mut at = 0;
    while at < bytes.len() {
        let byte = bytes[at];
        at += 1;
        if byte == b'\'' && bytes.get(at) == Some(&b'\'') {
            out.push(b'\'');
            at += 1;
            continue;
        }
        if byte != b'\\' || at == bytes.len() {
            out.push(byte);
            continue;
        }
        let escape = bytes[at];
        at += 1;
        match escape {
            b'n' => out.push(b'\n'),
            b't' => out.push(b'\t'),
            b'r' => out.push(b'\r'),
            b'b' => out.push(0x08),
            b'f' => out.push(0x0c),
            b'x' => match digits(bytes, &mut at, 16, 2) {
                Some(value) => out.push(value as u8),
                None => out.push(b'x'),
            },
            b'0'..=b'7' => {
                at -= 1;
                let value = digits(bytes, &mut at, 8, 3).unwrap_or(0);
                out.push(value as u8);
            }
            b'u' => match four_hex(bytes, at).and_then(char::from_u32).filter(|c| *c != '\0') {
                Some(c) => {
                    at += 4;
                    out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes());
                }
                None => out.push(b'u'),
            },
            other => out.push(other),
        }
    }
    if out.contains(&0) {
        return Err(Error::parser("Null character not permitted in escape string literal"));
    }
    String::from_utf8(out).map_err(|error| {
        Error::parser(format!(
            "Invalid UTF-8 in escape string literal at byte offset {}: byte mismatch",
            error.utf8_error().valid_up_to()
        ))
    })
}

/// Up to `most` digits in `radix` starting at `at`, moving `at` past the ones that were taken.
///
/// `None` means there were none at all, which is the case where the escape was not an escape:
/// `\x` on its own is the letter `x` upstream and not a zero byte.
fn digits(bytes: &[u8], at: &mut usize, radix: u32, most: usize) -> Option<u32> {
    let mut value = None;
    for _ in 0..most {
        let Some(digit) = bytes.get(*at).and_then(|byte| (*byte as char).to_digit(radix)) else {
            break;
        };
        value = Some(value.unwrap_or(0) * radix + digit);
        *at += 1;
    }
    value
}

/// The four hex digits of a `\uHHHH`, which has to be all four of them or it is not one.
///
/// Nothing is consumed here, because the digits are only digits if the whole escape works out. A
/// surrogate half is not a character and upstream does not pair it up either, so `😀` is
/// the ten characters it was written as, which is what the caller falls back to.
fn four_hex(bytes: &[u8], at: usize) -> Option<u32> {
    let digits = bytes.get(at..at + 4)?;
    if !digits.iter().all(u8::is_ascii_hexdigit) {
        return None;
    }
    u32::from_str_radix(std::str::from_utf8(digits).ok()?, 16).ok()
}

/// The body of a dollar quoted string, for the tokens that are one.
///
/// The tag is whatever sits between the opening pair of dollars and may be empty, so `$$a$$` and
/// `$tag$a$tag$` both arrive here, and nothing inside the body is escaped, which is the whole reason
/// the spelling exists. The tokenizer has already found the closing tag, which is the part that takes
/// work, so this says where the body starts and ends and no more. A token that is not dollar quoted
/// gives `None` and so does an unterminated one, which has no closing tag to take off and keeps every
/// byte it was given, the way the matcher already treats it. Per #276.
fn dollar_body(text: &str) -> Option<&str> {
    let rest = text.strip_prefix('$')?;
    let close = rest.find('$')?;
    let (tag, body) = (&rest[..close], &rest[close + 1..]);
    body.strip_suffix(&format!("${tag}$"))
}

/// Strip the quoting off an identifier.
///
/// DuckDB does not fold identifier case at any point, quoted or not, so this only removes the
/// quotes and resolves the doubled ones. Anything else would be the parser deciding what a name is.
///
/// Single quotes are stripped too, and the only way one gets here is the file name in `FROM
/// 'hits.parquet'`, because the matcher takes a string for a name in that position and in `COPY t TO
/// '...'` and nowhere else. Leaving them on would make that name different from the one `FROM
/// "hits.parquet"` writes, and DuckDB reads both of those as the same file.
fn unquote(text: &str) -> String {
    if let Some(body) = text.strip_prefix('"').and_then(|rest| rest.strip_suffix('"')) {
        return body.replace("\"\"", "\"");
    }
    match text.strip_prefix('\'').and_then(|rest| rest.strip_suffix('\'')) {
        Some(body) => body.replace("''", "'"),
        None => text.to_string(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::corpus::CORPUS;
    use crate::matcher::parse;

    /// The AST written back out as text, which is what the assertions below read.
    ///
    /// Not a SQL printer and not trying to be. It is deliberately not valid SQL: operators are
    /// spelled with the name of the variant and every binary node is parenthesised, so that a test
    /// asserting on this text is asserting on the shape of the tree and not on a formatting choice.
    /// `a - b - c` and `a - (b - c)` have to look different here or the test that tells them apart
    /// is not a test.
    fn show(ast: &Ast, expr: ExprRef) -> String {
        if expr == NONE {
            return "-".to_string();
        }
        let list = |slice: Slice| {
            ast.expr_list(slice).iter().map(|&item| show(ast, item)).collect::<Vec<_>>().join(", ")
        };
        match ast.expr(expr) {
            Expr::Star { qualifier, replacements } => {
                let star = if qualifier.is_empty() {
                    "*".to_string()
                } else {
                    format!("{}.*", ast.name_text(qualifier))
                };
                if replacements.is_empty() {
                    return star;
                }
                let entries: Vec<String> = ast
                    .target_list(replacements)
                    .iter()
                    .map(|target| {
                        format!("{} AS {}", show(ast, target.expr), ast.string(target.alias))
                    })
                    .collect();
                format!("{star} REPLACE ({})", entries.join(", "))
            }
            Expr::Column { name } => ast.name_text(name),
            Expr::Literal { kind, text } => match kind {
                LiteralKind::Number => ast.string(text).to_string(),
                LiteralKind::String => format!("'{}'", ast.string(text)),
                LiteralKind::Blob => format!("'{}'::BLOB", ast.string(text)),
                other => format!("{other:?}").to_uppercase(),
            },
            Expr::Unary { op, operand } => format!("({op:?} {})", show(ast, operand)),
            Expr::Binary { op, left, right } => {
                let op = match op {
                    BinaryOp::Named(name) => ast.string(name).to_string(),
                    other => format!("{other:?}"),
                };
                format!("({} {op} {})", show(ast, left), show(ast, right))
            }
            Expr::Function { name, args, distinct } => {
                let distinct = if distinct { "DISTINCT " } else { "" };
                format!("{}({distinct}{})", ast.name_text(name), list(args))
            }
            Expr::Cast { operand, ty, try_cast } => {
                let word = if try_cast { "TRY_CAST" } else { "CAST" };
                format!("{word}({} AS {})", show(ast, operand), ast.string(ty))
            }
            Expr::Case { operand, arms, otherwise } => {
                let arms = ast
                    .arm_list(arms)
                    .iter()
                    .map(|arm| format!("WHEN {} THEN {}", show(ast, arm.when), show(ast, arm.then)))
                    .collect::<Vec<_>>()
                    .join(" ");
                format!("CASE {} {arms} ELSE {} END", show(ast, operand), show(ast, otherwise))
            }
            Expr::Between { operand, low, high, negated } => {
                let not = if negated { "NOT " } else { "" };
                format!(
                    "({not}{} BETWEEN {} AND {})",
                    show(ast, operand),
                    show(ast, low),
                    show(ast, high)
                )
            }
            Expr::In { operand, list: items, negated } => {
                let not = if negated { "NOT " } else { "" };
                format!("({not}{} IN [{}])", show(ast, operand), list(items))
            }
            Expr::List { items } => format!("[{}]", list(items)),
            Expr::Parameter { name } => format!("${}", ast.string(name)),
            Expr::Row { items } => format!("ROW({})", list(items)),
            Expr::Subquery { query } => format!("({})", show_query(ast, query)),
        }
    }

    /// One from item written back out.
    fn show_source(ast: &Ast, source: SourceRef) -> String {
        let alias = |alias: StrRef| match alias {
            NONE => String::new(),
            other => format!(" AS {}", ast.string(other)),
        };
        match ast.source(source) {
            Source::Table { name, alias: name_alias, .. } => {
                format!("{}{}", ast.name_text(name), alias(name_alias))
            }
            Source::Function { name, args, alias: call_alias, .. } => {
                let args = ast
                    .target_list(args)
                    .iter()
                    .map(|item| match item.alias {
                        NONE => show(ast, item.expr),
                        named => format!("{} := {}", ast.string(named), show(ast, item.expr)),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                format!("{}({args}){}", ast.name_text(name), alias(call_alias))
            }
            Source::Subquery { query, alias: query_alias, .. } => {
                format!("({}){}", show_query(ast, query), alias(query_alias))
            }
            Source::Values { rows, alias: values_alias, .. } => {
                format!("{}{}", show_rows(ast, rows), alias(values_alias))
            }
            Source::Join { left, right, kind, natural, on, using } => {
                let natural = if natural { "NATURAL " } else { "" };
                let on = if on == NONE { String::new() } else { format!(" ON {}", show(ast, on)) };
                let using = if using.is_empty() {
                    String::new()
                } else {
                    format!(" USING ({})", ast.name_text(using))
                };
                format!(
                    "({} {natural}{kind:?} JOIN {}{on}{using})",
                    show_source(ast, left),
                    show_source(ast, right)
                )
            }
        }
    }

    /// The rows of a `VALUES` written back out.
    fn show_rows(ast: &Ast, rows: Slice) -> String {
        let rows = ast
            .rows(rows)
            .iter()
            .map(|&row| {
                let items = ast
                    .expr_list(row)
                    .iter()
                    .map(|&item| show(ast, item))
                    .collect::<Vec<_>>()
                    .join(", ");
                format!("({items})")
            })
            .collect::<Vec<_>>()
            .join(", ");
        format!("VALUES {rows}")
    }

    /// One query written back out.
    fn show_query(ast: &Ast, index: QueryRef) -> String {
        let query = ast.query(index);
        let list = |slice: Slice| {
            ast.expr_list(slice).iter().map(|&item| show(ast, item)).collect::<Vec<_>>().join(", ")
        };
        let mut out = match query.body {
            QueryBody::SetOp { op, quantifier, by_name, left, right } => {
                let by_name = if by_name { " BY NAME" } else { "" };
                format!(
                    "({} {op:?} {quantifier:?}{by_name} {})",
                    show_query(ast, left),
                    show_query(ast, right)
                )
            }
            QueryBody::Select(index) => {
                let select = ast.select(index);
                let distinct = match select.distinct {
                    Distinct::No => String::new(),
                    Distinct::Yes => " DISTINCT".to_string(),
                    Distinct::On(on) => format!(" DISTINCT ON ({})", list(on)),
                };
                let targets = ast
                    .target_list(select.targets)
                    .iter()
                    .map(|target| match target.alias {
                        NONE => show(ast, target.expr),
                        alias => format!("{} AS {}", show(ast, target.expr), ast.string(alias)),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                let mut out = format!("SELECT{distinct} {targets}");
                if !select.from.is_empty() {
                    let from = ast
                        .source_list(select.from)
                        .iter()
                        .map(|&source| show_source(ast, source))
                        .collect::<Vec<_>>()
                        .join(", ");
                    out += &format!(" FROM {from}");
                }
                if select.filter != NONE {
                    out += &format!(" WHERE {}", show(ast, select.filter));
                }
                if select.group_by_all {
                    out += " GROUP BY ALL";
                } else if !select.group_by.is_empty() {
                    out += &format!(" GROUP BY {}", list(select.group_by));
                }
                if select.having != NONE {
                    out += &format!(" HAVING {}", show(ast, select.having));
                }
                out
            }
            QueryBody::Values(rows) => show_rows(ast, rows),
            QueryBody::Describe(inner) => format!("DESCRIBE {}", show_query(ast, inner)),
            QueryBody::Show { name, .. } => format!("SHOW {}", ast.name_text(name)),
        };
        if query.order_by_all {
            out += " ORDER BY ALL";
        } else if !query.order_by.is_empty() {
            let items = ast
                .order_list(query.order_by)
                .iter()
                .map(|item| format!("{} {:?} {:?}", show(ast, item.expr), item.order, item.nulls))
                .collect::<Vec<_>>()
                .join(", ");
            out += &format!(" ORDER BY {items}");
        }
        if query.limit != NONE {
            let percent = if query.limit_percent { "%" } else { "" };
            out += &format!(" LIMIT {}{percent}", show(ast, query.limit));
        }
        if query.offset != NONE {
            out += &format!(" OFFSET {}", show(ast, query.offset));
        }
        out
    }

    /// One statement, transformed and written back out.
    fn round(query: &str) -> String {
        let ast = parse_ast(query).unwrap_or_else(|error| panic!("{query}: {error}"));
        assert_eq!(ast.statements.len(), 1, "{query} is one statement");
        let Statement::Query(index) = ast.statements[0] else {
            panic!("{query} is not a query");
        };
        show_query(&ast, index)
    }

    fn round_with_case(query: &str, case: IdentifierCase) -> String {
        let ast =
            parse_ast_with_case(query, case).unwrap_or_else(|error| panic!("{query}: {error}"));
        let Statement::Query(index) = ast.statements[0] else {
            panic!("{query} is not a query");
        };
        show_query(&ast, index)
    }

    /// One statement, transformed and written back out as the DDL and DML shape it is.
    fn round_statement(query: &str) -> String {
        let ast = parse_ast(query).unwrap_or_else(|error| panic!("{query}: {error}"));
        assert_eq!(ast.statements.len(), 1, "{query} is one statement");
        match ast.statements[0] {
            Statement::Query(index) => show_query(&ast, index),
            Statement::CreateTable(index) => {
                let create = ast.create_table(index);
                let mut out = "CREATE".to_string();
                if create.or_replace {
                    out += " OR REPLACE";
                }
                if create.temporary {
                    out += " TEMPORARY";
                }
                out += " TABLE";
                if create.if_not_exists {
                    out += " IF NOT EXISTS";
                }
                out += &format!(" {}", ast.name_text(create.name));
                let columns = ast
                    .column_defs(create.columns)
                    .iter()
                    .map(|def| {
                        let ty = match def.ty {
                            NONE => String::new(),
                            other => format!(" {}", ast.string(other)),
                        };
                        let null = if def.not_null { " NOT NULL" } else { "" };
                        format!("{}{ty}{null}", ast.string(def.name))
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                if !columns.is_empty() || create.query == NONE {
                    out += &format!(" ({columns})");
                }
                if create.query != NONE {
                    out += &format!(" AS {}", show_query(&ast, create.query));
                }
                out
            }
            Statement::CreateView(index) => {
                let create = ast.create_view(index);
                let mut out = "CREATE".to_string();
                if create.or_replace {
                    out += " OR REPLACE";
                }
                if create.temporary {
                    out += " TEMPORARY";
                }
                out += " VIEW";
                if create.if_not_exists {
                    out += " IF NOT EXISTS";
                }
                out += &format!(" {}", ast.name_text(create.name));
                if !create.columns.is_empty() {
                    let columns = ast.name(create.columns).collect::<Vec<_>>().join(", ");
                    out += &format!(" ({columns})");
                }
                out + &format!(" AS {}", show_query(&ast, create.query))
            }
            Statement::DropTable(index) => {
                let drop = ast.drop_table(index);
                let mut out = if drop.view { "DROP VIEW" } else { "DROP TABLE" }.to_string();
                if drop.if_exists {
                    out += " IF EXISTS";
                }
                let names = ast
                    .name_list(drop.names)
                    .iter()
                    .map(|&name| ast.name_text(name))
                    .collect::<Vec<_>>()
                    .join(", ");
                out + &format!(" {names}")
            }
            Statement::Insert(index) => {
                let insert = ast.insert(index);
                let mut out = format!("INSERT INTO {}", ast.name_text(insert.name));
                if !insert.columns.is_empty() {
                    let columns = ast.name(insert.columns).collect::<Vec<_>>().join(", ");
                    out += &format!(" ({columns})");
                }
                out + &format!(" {}", show_query(&ast, insert.source))
            }
            Statement::Set(index) => {
                let setting = ast.setting(index);
                let scope = match setting.scope.keyword() {
                    "" => String::new(),
                    word => format!(" {word}"),
                };
                format!("SET{scope} {} = {}", ast.string(setting.name), show(&ast, setting.value))
            }
            Statement::Reset(index) => {
                let setting = ast.setting(index);
                let scope = match setting.scope.keyword() {
                    "" => String::new(),
                    word => format!(" {word}"),
                };
                format!("RESET{scope} {}", ast.string(setting.name))
            }
            Statement::Checkpoint => "CHECKPOINT".to_string(),
            Statement::Explain { query, analyze } => {
                let analyze = if analyze { "ANALYZE " } else { "" };
                format!("EXPLAIN {analyze}{}", show_query(&ast, query))
            }
        }
    }

    #[test]
    fn an_explain_keeps_the_query_it_was_asked_about() {
        assert_eq!(
            round_statement("EXPLAIN SELECT a FROM t WHERE a > 1"),
            "EXPLAIN SELECT a FROM t WHERE (a Gt 1)"
        );
        assert_eq!(round_statement("explain select 1"), "EXPLAIN SELECT 1");
        assert_eq!(round_statement("explain analyze select 1"), "EXPLAIN ANALYZE SELECT 1");
    }

    #[test]
    fn the_parts_of_an_explain_that_are_not_the_query_are_refused_by_name() {
        // An option list that chooses a format is a promise about the output this does not keep,
        // and a statement that is not a query has no plan to show.
        for (query, named) in [
            ("EXPLAIN (FORMAT JSON) SELECT 1", "ExplainOptionList"),
            ("EXPLAIN INSERT INTO t VALUES (1)", "InsertStatement"),
            ("EXPLAIN CREATE TABLE u (a INTEGER)", "CreateStatement"),
        ] {
            let error = parse_ast(query).expect_err(query).to_string();
            assert!(error.contains(named), "{query}: {error}");
        }
    }

    #[test]
    fn a_set_keeps_its_name_its_scope_and_its_value() {
        assert_eq!(round_statement("SET memory_limit = '1GB'"), "SET memory_limit = '1GB'");
        assert_eq!(round_statement("set threads=4"), "SET threads = 4");
        assert_eq!(round_statement("SET GLOBAL threads = 4"), "SET GLOBAL threads = 4");
        assert_eq!(round_statement("SET SESSION threads = 4"), "SET SESSION threads = 4");
        assert_eq!(round_statement("SET LOCAL threads = 4"), "SET LOCAL threads = 4");
        assert_eq!(round_statement("RESET memory_limit"), "RESET memory_limit");
        assert_eq!(round_statement("RESET GLOBAL memory_limit"), "RESET GLOBAL memory_limit");
        assert_eq!(
            round_statement("SET TIME ZONE 'Asia/Kathmandu'"),
            "SET TimeZone = 'Asia/Kathmandu'"
        );
        assert_eq!(round_statement("SET TIME ZONE UTC"), "SET TimeZone = 'UTC'");
        assert_eq!(round_statement("SET TIME ZONE DEFAULT"), "RESET TimeZone");
        assert_eq!(round_statement("SET TIME ZONE LOCAL"), "RESET TimeZone");
    }

    #[test]
    fn the_two_other_things_the_word_set_starts_are_refused_rather_than_read_as_settings() {
        // `SET VARIABLE x = 1` declares a session variable and `SET SCHEMA` picks where an
        // unqualified name is looked up. Neither is a knob on the engine and reading either as one
        // would change an answer quietly.
        for statement in ["SET VARIABLE x = 1", "SET SCHEMA 'main'"] {
            let error = parse_ast(statement).expect_err(statement);
            assert_eq!(error.code().duckdb_name(), "Not implemented Error", "{statement}");
        }
    }

    #[test]
    fn a_setting_written_with_a_list_of_values_is_refused_rather_than_taking_the_first() {
        let error = parse_ast("SET search_path = a, b").expect_err("a list of two");
        assert_eq!(error.code().duckdb_name(), "Not implemented Error");
    }

    #[test]
    fn the_query_m0_has_to_run_transforms() {
        assert_eq!(round("SELECT * FROM t WHERE x > 5"), "SELECT * FROM t WHERE (x Gt 5)");
    }

    #[test]
    fn a_replace_list_rides_on_the_star_it_changes() {
        // The parentheses are optional around a single entry, which is how the clickbench load
        // recipe is not written but is how a lot of hand written sql is.
        assert_eq!(
            round("SELECT * REPLACE (a + 1 AS a) FROM t"),
            "SELECT * REPLACE ((a Add 1) AS a) FROM t"
        );
        assert_eq!(
            round("SELECT * REPLACE a + 1 AS a FROM t"),
            "SELECT * REPLACE ((a Add 1) AS a) FROM t"
        );
        assert_eq!(
            round("SELECT t.* REPLACE (make_date(a) AS a, b * 2 AS b) FROM t"),
            "SELECT t.* REPLACE (make_date(a) AS a, (b Multiply 2) AS b) FROM t"
        );
    }

    #[test]
    fn one_column_cannot_be_replaced_twice() {
        // Caught here rather than in the binder because it is a mistake in what was written and
        // not a mistake about what is in the table, and duckdb reports it the same way.
        let error = parse_ast("SELECT * REPLACE (a + 1 AS a, a + 2 AS A) FROM t").unwrap_err();
        assert_eq!(error.to_string(), "Parser Error: Duplicate entry \"A\" in REPLACE list");
    }

    #[test]
    fn a_table_function_argument_can_have_a_name_written_in_front_of_it() {
        // The grammar has `:=` and `=>`. It does not have `=`, which parses as a comparison and is
        // read back apart here, and that is the spelling the clickbench load recipe uses.
        for spelling in
            ["binary_as_string := True", "binary_as_string => True", "binary_as_string = True"]
        {
            assert_eq!(
                round(&format!("SELECT * FROM read_parquet('f.parquet', {spelling})")),
                "SELECT * FROM read_parquet('f.parquet', binary_as_string := TRUE)",
                "{spelling}"
            );
        }
    }

    #[test]
    fn an_equality_that_is_not_a_bare_name_stays_an_argument() {
        // A qualified name on the left is not a parameter name, and neither is anything that is
        // not a name at all, so both of those stay the comparison they were written as.
        assert_eq!(round("SELECT * FROM f(t.a = 1)"), "SELECT * FROM f((t.a Eq 1))");
        assert_eq!(round("SELECT * FROM f(1 = 1)"), "SELECT * FROM f((1 Eq 1))");
    }

    #[test]
    fn a_create_table_keeps_its_types_as_text() {
        assert_eq!(
            round_statement("CREATE TABLE t (a INTEGER, b VARCHAR NOT NULL)"),
            "CREATE TABLE t (a INTEGER, b VARCHAR NOT NULL)"
        );
        // The type is the text between the identifier and whatever follows it, parentheses and
        // all, because resolving `DECIMAL(18, 3)` into a width and a scale is the binder's job and
        // doing it here would mean two places that know the type table.
        assert_eq!(
            round_statement("CREATE TABLE t (a DECIMAL(18, 3), b STRUCT(x INT))"),
            "CREATE TABLE t (a DECIMAL(18, 3), b STRUCT(x INT))"
        );
    }

    #[test]
    fn the_modifiers_on_a_create_table_survive() {
        assert_eq!(
            round_statement("CREATE OR REPLACE TEMPORARY TABLE s.t (a INT)"),
            "CREATE OR REPLACE TEMPORARY TABLE s.t (a INT)"
        );
        assert_eq!(
            round_statement("CREATE TEMPORARY TABLE IF NOT EXISTS s.t (a INT)"),
            "CREATE TEMPORARY TABLE IF NOT EXISTS s.t (a INT)"
        );
    }

    #[test]
    fn or_replace_and_if_not_exists_in_one_statement_is_refused_here_and_not_later() {
        // The grammar has room for both and duckdb's has not, so its refusal is a parser error with
        // a caret under the `NOT` and this one is a parser error at the same stage. It is the same
        // sentence whatever is being created.
        for sql in [
            "CREATE OR REPLACE TABLE IF NOT EXISTS t (a INT)",
            "CREATE OR REPLACE VIEW IF NOT EXISTS v AS SELECT 1",
        ] {
            let error = parse_ast(sql).unwrap_err().to_string();
            assert_eq!(
                error,
                "Parser Error: Cannot specify both OR REPLACE and IF NOT EXISTS within single \
                 create statement"
            );
        }
    }

    #[test]
    fn a_create_table_as_carries_the_query_and_not_the_types() {
        assert_eq!(
            round_statement("CREATE TABLE t AS SELECT a FROM u"),
            "CREATE TABLE t AS SELECT a FROM u"
        );
        // The names are the syntax's to say and the types are the query's, so the column
        // definitions here have names and no types.
        assert_eq!(
            round_statement("CREATE TABLE t (x, y) AS SELECT a, b FROM u"),
            "CREATE TABLE t (x, y) AS SELECT a, b FROM u"
        );
    }

    #[test]
    fn a_create_view_carries_its_body_twice_over() {
        assert_eq!(
            round_statement("CREATE VIEW v AS SELECT a FROM u"),
            "CREATE VIEW v AS SELECT a FROM u"
        );
        assert_eq!(
            round_statement("CREATE OR REPLACE VIEW main.v (x, y) AS SELECT a, b FROM u"),
            "CREATE OR REPLACE VIEW main.v (x, y) AS SELECT a, b FROM u"
        );
        // The text the catalog keeps is the body and only the body, so that binding it again is
        // binding a query rather than a `CREATE` statement.
        let ast = parse_ast("CREATE VIEW v (x) AS SELECT a FROM u WHERE a > 1").expect("parses");
        let Statement::CreateView(index) = ast.statements[0] else {
            panic!("not a create view");
        };
        assert_eq!(ast.string(ast.create_view(index).sql), "SELECT a FROM u WHERE a > 1");
    }

    #[test]
    fn a_drop_view_is_not_a_drop_table() {
        assert_eq!(round_statement("DROP VIEW IF EXISTS a, b"), "DROP VIEW IF EXISTS a, b");
        assert_eq!(round_statement("DROP TABLE a"), "DROP TABLE a");
    }

    #[test]
    fn a_drop_table_is_a_list_of_qualified_names() {
        assert_eq!(round_statement("DROP TABLE t"), "DROP TABLE t");
        assert_eq!(round_statement("DROP TABLE IF EXISTS a, b.c"), "DROP TABLE IF EXISTS a, b.c");
    }

    #[test]
    fn dropping_something_that_is_neither_a_table_nor_a_view_is_refused() {
        // `TableOrView` covers `MATERIALIZED VIEW` as well, which is not a thing this database has,
        // and dropping one as if it were an ordinary view is a wrong answer rather than a missing
        // feature.
        let error = parse_ast("DROP MATERIALIZED VIEW v").unwrap_err().to_string();
        assert!(error.starts_with("Not implemented Error"), "{error}");
    }

    #[test]
    fn both_spellings_of_insert_arrive_at_a_query() {
        assert_eq!(
            round_statement("INSERT INTO t VALUES (1, 'a'), (2, 'b')"),
            "INSERT INTO t VALUES (1, 'a'), (2, 'b')"
        );
        assert_eq!(
            round_statement("INSERT INTO t (a, b) SELECT x, y FROM u"),
            "INSERT INTO t (a, b) SELECT x, y FROM u"
        );
    }

    #[test]
    fn an_insert_clause_that_changes_the_answer_is_refused() {
        for query in [
            "INSERT INTO t VALUES (1) RETURNING *",
            "INSERT OR REPLACE INTO t VALUES (1)",
            "INSERT INTO t BY NAME SELECT 1 AS a",
            "INSERT INTO t VALUES (1) ON CONFLICT DO NOTHING",
            "INSERT INTO t DEFAULT VALUES",
        ] {
            let error = parse_ast(query).unwrap_err().to_string();
            assert!(error.starts_with("Not implemented Error"), "{query} gave {error}");
        }
    }

    #[test]
    fn a_column_constraint_that_is_not_not_null_is_refused() {
        // Nothing enforces a constraint yet. Accepting one and not enforcing it is the wrong
        // answer, so `NOT NULL` is kept because the column already has a nullability and the rest
        // are refused until there is somewhere to put them.
        for query in [
            "CREATE TABLE t (a INT PRIMARY KEY)",
            "CREATE TABLE t (a INT UNIQUE)",
            "CREATE TABLE t (a INT CHECK (a > 0))",
            "CREATE TABLE t (a INT DEFAULT 1)",
            "CREATE TABLE t (a INT REFERENCES u (b))",
            "CREATE TABLE t (a INT, PRIMARY KEY (a))",
        ] {
            let error = parse_ast(query).unwrap_err().to_string();
            assert!(error.starts_with("Not implemented Error"), "{query} gave {error}");
        }
    }

    #[test]
    fn values_is_a_query_on_its_own_and_in_a_from() {
        assert_eq!(round("VALUES (1), (2)"), "VALUES (1), (2)");
        // Parenthesised it is a subquery whose body is the values, and bare it is a `ValuesRef`.
        // Two rules and one meaning, which is the grammar's doing and not something to flatten
        // here, because the parenthesised form can carry an order by and the bare one cannot.
        assert_eq!(
            round("SELECT * FROM (VALUES (1, 2), (3, 4)) t(a, b)"),
            "SELECT * FROM (VALUES (1, 2), (3, 4)) AS t"
        );
        assert_eq!(
            round("SELECT * FROM VALUES (1, 2), (3, 4) AS t(a, b)"),
            "SELECT * FROM VALUES (1, 2), (3, 4) AS t"
        );
        // Rows of different widths parse. Saying so wants the column count, which for an insert is
        // the table's, so the check belongs to the binder and not here.
        assert_eq!(round("VALUES (1), (2, 3)"), "VALUES (1), (2, 3)");
    }

    /// `DESCRIBE` is a query body, and the two spellings that name something become a star over it.
    ///
    /// Naming a table is not a shortcut for the query. On the reference binary `DESCRIBE t` and
    /// `DESCRIBE SELECT * FROM t` print the same six columns and the same rows, down to the `NO` on
    /// a column that refuses nulls, so rewriting one into the other costs nothing and leaves the
    /// binder with one case instead of three. A file name goes down the same path as a table name
    /// because a bare string in a `FROM` clause is already a name the replacement scan picks up.
    #[test]
    fn describe_rewrites_a_name_into_a_star_over_it() {
        assert_eq!(round("DESCRIBE SELECT 1 AS a"), "DESCRIBE SELECT 1 AS a");
        assert_eq!(round("DESCRIBE t"), "DESCRIBE SELECT * FROM t");
        assert_eq!(round("DESC t"), "DESCRIBE SELECT * FROM t");
        assert_eq!(round("DESCRIBE 'x.parquet'"), "DESCRIBE SELECT * FROM x.parquet");
        // A body and not a statement kind, so it nests both ways with no rule of its own.
        assert_eq!(
            round("SELECT column_name FROM (DESCRIBE SELECT 1 AS a)"),
            "SELECT column_name FROM (DESCRIBE SELECT 1 AS a)"
        );
        assert_eq!(round("DESCRIBE DESCRIBE SELECT 1 AS a"), "DESCRIBE DESCRIBE SELECT 1 AS a");
    }

    /// `SUMMARIZE` shares both of `DESCRIBE`'s grammar rules and is a different statement.
    ///
    /// It reads every row and returns one row per column carrying the min, the max, the count and
    /// the approximate distinct count, so none of it falls out of the `DESCRIBE` path. The word is
    /// the only thing in the tree that tells the two apart, which is why the transform looks at it
    /// rather than trusting the rule name it arrived under.
    #[test]
    fn summarize_is_refused_even_though_it_parses_as_a_describe() {
        for query in ["SUMMARIZE t", "SUMMARIZE SELECT 1"] {
            let error = parse_ast(query).expect_err("summarize is not implemented");
            let message = error.to_string();
            assert!(message.starts_with("Not implemented Error"), "{query} failed with {message}");
        }
    }

    #[test]
    fn every_statement_in_the_corpus_gets_a_defined_answer() {
        // The point of the test is the word defined. Half of these are statement kinds and
        // clauses this milestone does not cover, and the requirement is not that they work, it is
        // that they fail by saying so. A panic, a silently dropped clause or an internal error
        // would each be a different bug and all three would be invisible without this.
        let mut done = 0;
        for query in CORPUS {
            match parse_ast(query) {
                Ok(ast) => {
                    assert_eq!(ast.statements.len(), 1, "{query}");
                    done += 1;
                }
                Err(error) => {
                    let message = error.to_string();
                    assert!(
                        message.starts_with("Not implemented Error"),
                        "{query} failed with {message}, which is not a not-implemented error"
                    );
                }
            }
        }
        // Not an assertion about the right number. It is a ratchet: this only moves up, and the
        // day it moves down somebody has taken a construct out without meaning to.
        assert!(done >= 31, "only {done} of the corpus transforms, which is fewer than it was");
    }

    #[test]
    fn the_ast_is_far_smaller_than_the_parse_tree() {
        let query = CORPUS[4];
        let tree = parse(query).unwrap();
        let ast = parse_ast(query).unwrap();
        // The twenty precedence levels are the difference. Every one of them is a node in the
        // parse tree for every expression at every depth, and none of them survives into the AST.
        assert!(
            ast.node_count() * 20 < tree.arena_len(),
            "{} ast nodes against {} parse nodes",
            ast.node_count(),
            tree.arena_len()
        );
    }

    #[test]
    fn precedence_comes_out_of_the_chain_and_into_the_tree() {
        assert_eq!(round("SELECT 1 + 2 * 3"), "SELECT (1 Add (2 Multiply 3))");
        assert_eq!(round("SELECT (1 + 2) * 3"), "SELECT ((1 Add 2) Multiply 3)");
        assert_eq!(round("SELECT 1 + 2 + 3"), "SELECT ((1 Add 2) Add 3)");
        assert_eq!(round("SELECT 1 - 2 - 3"), "SELECT ((1 Subtract 2) Subtract 3)");
        assert_eq!(
            round("SELECT a OR b AND c"),
            "SELECT (a Or (b And c))",
            "and binds tighter than or"
        );
    }

    #[test]
    fn a_double_negation_is_two_nodes_and_not_none() {
        // Folding it would be an optimizer decision and this is not the optimizer. It also would
        // not be safe in general: `NOT NOT x` on a null is still null and on a non boolean it is
        // still an error, and both of those have to survive to the binder to be reported.
        assert_eq!(round("SELECT NOT NOT a"), "SELECT (Not (Not a))");
    }

    #[test]
    fn a_parenthesised_single_expression_is_not_a_row() {
        assert_eq!(round("SELECT (a)"), "SELECT a");
        assert_eq!(round("SELECT (a, b)"), "SELECT ROW(a, b)");
    }

    #[test]
    fn a_bracketed_list_is_a_list_of_however_many_items_were_written() {
        // One item is a list of one, which is where this parts company with the parenthesised form
        // above: `(a)` is `a` and `[a]` is a list, because the brackets are what say list.
        assert_eq!(round("SELECT [a]"), "SELECT [a]");
        assert_eq!(round("SELECT [1, 2, 3]"), "SELECT [1, 2, 3]");
        assert_eq!(round("SELECT []"), "SELECT []");
        assert_eq!(round("SELECT ['a.parquet', 'b.parquet']"), "SELECT ['a.parquet', 'b.parquet']");
    }

    #[test]
    fn a_parameter_carries_its_identifier_however_it_was_written() {
        assert_eq!(round("SELECT $1"), "SELECT $1");
        assert_eq!(round("SELECT ?1"), "SELECT $1");
        assert_eq!(round("SELECT $name"), "SELECT $name");
        // A bare question mark is numbered by where it is, and the counting is its own, so a later
        // `$2` does not push the first one along. This is duckdb v1.4.1, which prints `$1 + $2`.
        assert_eq!(round("SELECT ? + $2"), "SELECT ($1 Add $2)");
        assert_eq!(round("SELECT ?, ?, ?"), "SELECT $1, $2, $3");
    }

    #[test]
    fn the_parameters_of_a_statement_are_listed_once_each_in_written_order() {
        let ast = parse_ast("SELECT $b, $a, $b WHERE $a").expect("parses");
        assert_eq!(ast.parameters(), vec!["b", "a"]);
        assert!(parse_ast("SELECT 1").expect("parses").parameters().is_empty());
    }

    #[test]
    fn the_three_ways_to_write_an_alias_all_arrive() {
        assert_eq!(round("SELECT a AS b"), "SELECT a AS b");
        assert_eq!(round("SELECT a b"), "SELECT a AS b");
        assert_eq!(round("SELECT b: a"), "SELECT a AS b");
        assert_eq!(round("SELECT a"), "SELECT a", "and no alias when none was written");
    }

    #[test]
    fn a_from_with_no_select_selects_everything() {
        // DuckDB's own shorthand. Inventing the star here rather than in the binder means the
        // binder never has to know that the clause it is looking at was the one that was missing.
        assert_eq!(round("FROM t"), "SELECT * FROM t");
        assert_eq!(round("FROM t SELECT a"), "SELECT a FROM t");
    }

    #[test]
    fn joins_nest_to_the_left() {
        assert_eq!(
            round("SELECT * FROM a JOIN b ON a.i = b.i LEFT JOIN c USING (k)"),
            "SELECT * FROM ((a Inner JOIN b ON (a.i Eq b.i)) Left JOIN c USING (k))"
        );
        assert_eq!(
            round("SELECT * FROM a NATURAL JOIN b"),
            "SELECT * FROM (a NATURAL Inner JOIN b)"
        );
        assert_eq!(round("SELECT * FROM a CROSS JOIN b"), "SELECT * FROM (a Cross JOIN b)");
        assert_eq!(
            round("SELECT * FROM a POSITIONAL JOIN b"),
            "SELECT * FROM (a Positional JOIN b)"
        );
        assert_eq!(round("SELECT * FROM a, b"), "SELECT * FROM a, b", "a comma is not a join node");
    }

    #[test]
    fn a_qualified_name_keeps_its_parts_however_it_was_spelled() {
        // Five grammar rules can produce a column reference and they disagree about which
        // component is a schema and which is a table. None of that is decidable without the
        // catalog, so the AST holds the parts and the binder decides.
        assert_eq!(round("SELECT a"), "SELECT a");
        assert_eq!(round("SELECT t.a"), "SELECT t.a");
        assert_eq!(round("SELECT s.t.a"), "SELECT s.t.a");
        assert_eq!(round("SELECT c.s.t.a"), "SELECT c.s.t.a");
        assert_eq!(round("SELECT * FROM s.t"), "SELECT * FROM s.t");
    }

    #[test]
    fn a_star_can_be_qualified() {
        assert_eq!(round("SELECT *"), "SELECT *");
        assert_eq!(round("SELECT t.*"), "SELECT t.*");
        assert_eq!(round("SELECT s.t.*"), "SELECT s.t.*");
    }

    #[test]
    fn a_quoted_identifier_keeps_its_case_and_loses_its_quotes() {
        // DuckDB does not fold identifier case at any point, quoted or not, which the tokenizer
        // work established by reading the source. So the only thing to do here is take the quotes
        // off and resolve the doubled ones.
        let ast = parse_ast("SELECT \"Mixed Case\", \"a\"\"b\"").unwrap();
        assert_eq!(ast.strings[0], "Mixed Case");
        assert_eq!(ast.strings[1], "a\"b");
    }

    #[test]
    fn a_string_literal_is_decoded_and_adjacent_ones_are_joined() {
        assert_eq!(round("SELECT 'it''s'"), "SELECT 'it's'");
        assert_eq!(round("SELECT 'a'\n'b'"), "SELECT 'ab'", "the standard's adjacency rule");
    }

    /// Per #276, where the tag and the dollars were coming through as part of the value.
    #[test]
    fn a_dollar_quoted_string_loses_its_dollars_and_its_tag() {
        assert_eq!(round("SELECT $$dollar quoted$$"), "SELECT 'dollar quoted'");
        assert_eq!(round("SELECT $tag$body$tag$"), "SELECT 'body'");
        assert_eq!(round("SELECT $$$$"), "SELECT ''", "an empty tag and an empty body");
        // Nothing in the body is escaped, which is what the spelling is for, so a quote is a quote
        // and a dollar that is not the closing tag is a dollar.
        assert_eq!(round("SELECT $tag$it''s $other$ fine$tag$"), "SELECT 'it''s $other$ fine'");
        // An unterminated one has no closing tag to take off and keeps every byte it was given.
        assert_eq!(round("SELECT $$open"), "SELECT '$$open'");
    }

    /// Per #329, where every prefixed spelling came back as the source text it was written as.
    ///
    /// The escapes are the ones the pinned binary takes, read off it one at a time. The two that
    /// are easy to get wrong are `\v`, which is not an escape and is the letter, and `\u`, which
    /// wants all four digits and otherwise drops the backslash and keeps the letter.
    #[test]
    fn an_escape_string_resolves_its_backslashes() {
        assert_eq!(round("SELECT E'a\\nb'"), "SELECT 'a\nb'");
        assert_eq!(round("SELECT e'a\\tb'"), "SELECT 'a\tb'", "the prefix is a letter, not a name");
        assert_eq!(round("SELECT E'a\\rb'"), "SELECT 'a\rb'");
        assert_eq!(round("SELECT E'a\\bb'"), "SELECT 'a\u{8}b'");
        assert_eq!(round("SELECT E'a\\fb'"), "SELECT 'a\u{c}b'");
        assert_eq!(round("SELECT E'a\\\\b'"), "SELECT 'a\\b'");
        assert_eq!(round("SELECT E'a\\'b'"), "SELECT 'a'b'", "a quote, the same as ''");
        assert_eq!(round("SELECT E'a''b'"), "SELECT 'a'b'", "and '' still means a quote here");
        // A backslash in front of anything else is dropped and the character is kept, which is what
        // makes \v the letter v.
        assert_eq!(round("SELECT E'a\\vb'"), "SELECT 'avb'");
        assert_eq!(round("SELECT E'a\\qb'"), "SELECT 'aqb'");
    }

    /// The escapes that write a byte rather than a character, and the one that writes a character.
    #[test]
    fn a_numeric_escape_writes_the_byte_or_the_character_it_names() {
        assert_eq!(round("SELECT E'\\x41'"), "SELECT 'A'");
        assert_eq!(round("SELECT E'\\x4142'"), "SELECT 'A42'", "two digits at the most");
        assert_eq!(
            round("SELECT E'a\\x'"),
            "SELECT 'ax'",
            "and one at the least, or it is a letter"
        );
        assert_eq!(round("SELECT E'\\101'"), "SELECT 'A'");
        assert_eq!(round("SELECT E'\\1011'"), "SELECT 'A1'", "three digits at the most");
        assert_eq!(round("SELECT E'\\8'"), "SELECT '8'", "8 is not an octal digit");
        // Bytes and not characters, so two of them make one character and one of them makes none.
        assert_eq!(round("SELECT E'\\xc3\\xa9'"), "SELECT 'é'");
        assert_eq!(round("SELECT E'\\u00e9'"), "SELECT 'é'");
        assert_eq!(round("SELECT E'a\\u41'"), "SELECT 'au41'", "four digits or it is a letter");
        assert_eq!(round("SELECT E'a\\uZZZZ'"), "SELECT 'auZZZZ'");
        assert_eq!(
            round("SELECT E'\\ud83d\\ude00'"),
            "SELECT 'ud83dude00'",
            "surrogates are not it"
        );
    }

    /// The two ways an escape string is not a string at all, both with the message upstream gives.
    #[test]
    fn an_escape_string_that_is_not_a_string_raises() {
        let error = parse_ast("SELECT E'a\\x00'").unwrap_err().to_string();
        assert_eq!(error, "Parser Error: Null character not permitted in escape string literal");
        let error = parse_ast("SELECT E'a\\377'").unwrap_err().to_string();
        assert_eq!(
            error,
            "Parser Error: Invalid UTF-8 in escape string literal at byte offset 1: byte mismatch",
            "the offset is where the bytes stop being a string, not where the escape was written"
        );
    }

    /// The other prefixes, all of them measured against the pinned binary rather than assumed.
    #[test]
    fn the_other_string_prefixes_are_what_upstream_makes_of_them() {
        // N is the string and a cast of it to VARCHAR, which is where the column name comes from.
        assert_eq!(round("SELECT N'abc'"), "SELECT CAST('abc' AS VARCHAR)");
        assert_eq!(round("SELECT n'abc'"), "SELECT CAST('abc' AS VARCHAR)");
        // B is not a bit string. It is the letter b in front of the body, untouched.
        assert_eq!(round("SELECT B'101'"), "SELECT 'b101'");
        assert_eq!(round("SELECT b'abc'"), "SELECT 'babc'");
        assert_eq!(round("SELECT B''"), "SELECT 'b'", "an empty one is the letter on its own");
    }

    /// X is the prefix that is not a string at all, per #329.
    ///
    /// What is kept is the text the blob prints as, because that is the text the column is named
    /// after and the text the cast reads the bytes back from, and one text that does both is one
    /// text that cannot disagree with itself.
    #[test]
    fn a_hex_string_is_a_blob_and_not_a_string() {
        assert_eq!(round("SELECT x'4142'"), "SELECT 'AB'::BLOB");
        assert_eq!(round("SELECT X'4142'"), "SELECT 'AB'::BLOB");
        assert_eq!(round("SELECT x'ff41'"), "SELECT '\\xFFA'::BLOB", "a byte that does not print");
        assert_eq!(round("SELECT x''"), "SELECT ''::BLOB", "an empty one is an empty blob");
        // A quote and a backslash are bytes that do not print either, which is what keeps the text
        // something the cast can read back.
        assert_eq!(round("SELECT x'2741'"), "SELECT '\\x27A'::BLOB");
        assert_eq!(round("SELECT x'5c7834314141'"), "SELECT '\\x5Cx41AA'::BLOB");
        // An odd number of digits is a parser error and a digit that is not one is not, because
        // upstream writes the pairs out without looking at them and the cast is what looks.
        let error = parse_ast("SELECT x'4'").unwrap_err().to_string();
        assert_eq!(
            error,
            "Parser Error: Hex string literal must have an even number of hex digits"
        );
        assert_eq!(round("SELECT x'41zz'"), "SELECT '\\x41\\xzz'::BLOB");
    }

    #[test]
    fn the_null_and_boolean_tests_are_postfix_unary_operators() {
        assert_eq!(round("SELECT x IS NULL"), "SELECT (IsNull x)");
        assert_eq!(round("SELECT x IS NOT NULL"), "SELECT (IsNotNull x)");
        assert_eq!(round("SELECT x ISNULL"), "SELECT (IsNull x)");
        assert_eq!(round("SELECT x NOTNULL"), "SELECT (IsNotNull x)");
        assert_eq!(round("SELECT x IS TRUE"), "SELECT (IsTrue x)");
        assert_eq!(round("SELECT x IS NOT FALSE"), "SELECT (IsNotFalse x)");
        assert_eq!(round("SELECT x IS DISTINCT FROM y"), "SELECT (x IsDistinctFrom y)");
        assert_eq!(round("SELECT x IS NOT DISTINCT FROM y"), "SELECT (x IsNotDistinctFrom y)");
    }

    #[test]
    fn the_like_family_folds_its_negation_into_the_operator() {
        assert_eq!(round("SELECT x LIKE 'a'"), "SELECT (x Like 'a')");
        assert_eq!(round("SELECT x NOT LIKE 'a'"), "SELECT (x NotLike 'a')");
        assert_eq!(round("SELECT x ILIKE 'a'"), "SELECT (x ILike 'a')");
        assert_eq!(round("SELECT x ~~ 'a'"), "SELECT (x Like 'a')", "the operator spelling");
        assert_eq!(round("SELECT x !~~ 'a'"), "SELECT (x NotLike 'a')");
        assert_eq!(round("SELECT x SIMILAR TO 'a'"), "SELECT (x SimilarTo 'a')");
        // Glob has no negated operator to fold into, so the negation stays where it was written.
        assert_eq!(round("SELECT x NOT GLOB 'a'"), "SELECT (Not (x Glob 'a'))");
    }

    #[test]
    fn between_and_in_carry_their_negation_as_a_flag() {
        assert_eq!(round("SELECT x BETWEEN 1 AND 2"), "SELECT (x BETWEEN 1 AND 2)");
        assert_eq!(round("SELECT x NOT BETWEEN 1 AND 2"), "SELECT (NOT x BETWEEN 1 AND 2)");
        assert_eq!(round("SELECT x IN (1, 2)"), "SELECT (x IN [1, 2])");
        assert_eq!(round("SELECT x NOT IN (1, 2)"), "SELECT (NOT x IN [1, 2])");
    }

    #[test]
    fn both_spellings_of_a_cast_are_the_same_node() {
        assert_eq!(round("SELECT CAST(x AS BIGINT)"), "SELECT CAST(x AS BIGINT)");
        assert_eq!(round("SELECT x::BIGINT"), "SELECT CAST(x AS BIGINT)");
        assert_eq!(round("SELECT TRY_CAST(x AS BIGINT)"), "SELECT TRY_CAST(x AS BIGINT)");
        assert_eq!(
            round("SELECT x::DECIMAL(18, 3)"),
            "SELECT CAST(x AS DECIMAL(18, 3))",
            "the type is kept as text because parsing it is the type system's job"
        );
    }

    #[test]
    fn a_typed_literal_is_a_third_spelling_of_the_same_cast() {
        assert_eq!(round("SELECT DATE '1995-09-01'"), "SELECT CAST('1995-09-01' AS DATE)");
        assert_eq!(
            round("SELECT date '1995-09-01'"),
            "SELECT CAST('1995-09-01' AS date)",
            "the type is kept as written, the same as it is in the other two spellings"
        );
        assert_eq!(
            round("SELECT TIMESTAMP '2020-01-01 03:04:05'"),
            "SELECT CAST('2020-01-01 03:04:05' AS TIMESTAMP)"
        );
        assert_eq!(
            round("SELECT DECIMAL(5, 2) '1.5'"),
            "SELECT CAST('1.5' AS DECIMAL(5, 2))",
            "any type the cast takes is a typed literal, parameters and all"
        );
        assert_eq!(
            round("SELECT VARCHAR 'hi' FROM t"),
            "SELECT CAST('hi' AS VARCHAR) FROM t",
            "including the ones where the cast has nothing to do"
        );
    }

    #[test]
    fn a_case_keeps_its_arms_in_order() {
        assert_eq!(
            round("SELECT CASE WHEN a THEN 1 WHEN b THEN 2 ELSE 3 END"),
            "SELECT CASE - WHEN a THEN 1 WHEN b THEN 2 ELSE 3 END"
        );
        assert_eq!(
            round("SELECT CASE x WHEN 1 THEN 'a' END"),
            "SELECT CASE x WHEN 1 THEN 'a' ELSE - END",
            "a simple case keeps the operand and a missing else is not an implicit null yet"
        );
    }

    #[test]
    fn a_field_access_and_a_method_call_are_ordinary_function_calls() {
        // Which is what DuckDB makes of them too. Giving each its own AST node would mean the
        // binder needs a rule for something the function resolver already handles.
        assert_eq!(round("SELECT (f(x)).y"), "SELECT struct_extract(f(x), 'y')");
        assert_eq!(round("SELECT a[1]"), "SELECT array_extract(a, 1)");
    }

    /// The four ways of leaving a bound out, all of which upstream fills in the same way.
    #[test]
    fn a_range_gets_the_bounds_the_query_left_out() {
        assert_eq!(round("SELECT a[1:2]"), "SELECT array_slice(a, 1, 2)");
        assert_eq!(round("SELECT a[:2]"), "SELECT array_slice(a, 1, 2)");
        assert_eq!(round("SELECT a[2:]"), "SELECT array_slice(a, 2, -1)");
        assert_eq!(round("SELECT a[:]"), "SELECT array_slice(a, 1, -1)");
        // `EndSliceMinus`, which is a range with no end rather than a subtraction of nothing.
        assert_eq!(round("SELECT a[1:-]"), "SELECT array_slice(a, 1, -1)");
        assert_eq!(round("SELECT a[1:2:3]"), "SELECT array_slice(a, 1, 2, 3)");
        // A step that was written and left empty, which upstream fills with a list so that the call
        // fails to bind. Answering a row here would be answering where the reference refuses.
        assert_eq!(round("SELECT a[1:2:]"), "SELECT array_slice(a, 1, 2, [])");
    }

    /// `[]` is the one subscript the parser takes and the transformer refuses, in upstream's words.
    #[test]
    fn an_empty_subscript_is_not_a_subscript() {
        let error = parse_ast("SELECT a[]").expect_err("an empty subscript");
        assert_eq!(error.message(), "Empty subscript '[]' is not allowed");
    }

    /// A rule that wrote a keyword is not a rule that said nothing, however few children it has.
    /// Per #313.
    #[test]
    fn a_keyword_is_not_stepped_through_on_the_way_to_its_one_argument() {
        for (sql, rule) in [
            ("SELECT row(1)", "RowExpression"),
            ("SELECT try(1)", "TryExpression"),
            ("SELECT unpack([1])", "UnpackExpression"),
            ("SELECT columns('a')", "ColumnsExpression"),
        ] {
            let error = parse_ast(sql).expect_err(sql);
            assert!(error.message().ends_with(rule), "{sql}: {error}");
        }
        // Grouping brackets really do say nothing, and that is the one rule of this shape that is
        // stepped through rather than refused.
        assert_eq!(round("SELECT (1 + 2) * 3"), "SELECT ((1 Add 2) Multiply 3)");
        assert_eq!(round("SELECT -(7)"), "SELECT (Negate 7)");
    }

    /// The three spellings of a null check, two of which are their own grammar rule. Per #306.
    #[test]
    fn the_null_checks_are_calls_by_the_names_duckdb_prints() {
        // The keyword is the name, so the call is written with the canonical spelling of it whichever
        // case the query used. What the column is called is the binder's to decide.
        assert_eq!(round("SELECT COALESCE(a, b, 1)"), "SELECT coalesce(a, b, 1)");
        assert_eq!(round("SELECT coalesce(a)"), "SELECT coalesce(a)");
        assert_eq!(round("SELECT NULLIF(a, 1)"), "SELECT nullif(a, 1)");
        // `IFNULL` is a plain call that upstream's parser turns into the operator, qualifier and all.
        assert_eq!(round("SELECT ifnull(a, 1)"), "SELECT coalesce(a, 1)");
        assert_eq!(round("SELECT main.ifnull(a, 1)"), "SELECT coalesce(a, 1)");
        let error = parse_ast("SELECT ifnull(a)").expect_err("one argument to ifnull");
        assert_eq!(error.message(), "Wrong number of arguments to IFNULL.");
        let error = parse_ast("SELECT ifnull(a, b, c)").expect_err("three arguments to ifnull");
        assert_eq!(error.message(), "Wrong number of arguments to IFNULL.");
    }

    /// The four string functions with a grammar rule of their own, written back out as the calls
    /// DuckDB's parser writes them as. Per #314.
    #[test]
    fn the_string_keywords_are_the_calls_duckdb_prints() {
        assert_eq!(round("SELECT substring(s, 2, 3)"), "SELECT substring(s, 2, 3)");
        assert_eq!(round("SELECT SUBSTRING(s FROM 2 FOR 3)"), "SELECT substring(s, 2, 3)");
        assert_eq!(round("SELECT substring(s FROM 2)"), "SELECT substring(s, 2)");
        // The `FOR` on its own is three arguments and not two, with the start filled in.
        assert_eq!(round("SELECT substring(s FOR 3)"), "SELECT substring(s, 1, 3)");
        // The haystack comes first in the call and second in the query.
        assert_eq!(round("SELECT position('c' IN s)"), "SELECT position(s, 'c')");
        assert_eq!(round("SELECT trim(s)"), "SELECT trim(s)");
        assert_eq!(round("SELECT trim(BOTH 'x' FROM s)"), "SELECT trim(s, 'x')");
        assert_eq!(round("SELECT trim(BOTH FROM s)"), "SELECT trim(s)");
        assert_eq!(round("SELECT trim(s, 'xy')"), "SELECT trim(s, 'xy')");
        // A direction is a different function and not a different argument.
        assert_eq!(round("SELECT trim(LEADING FROM s)"), "SELECT ltrim(s)");
        assert_eq!(round("SELECT trim(TRAILING FROM s)"), "SELECT rtrim(s)");
        assert_eq!(round("SELECT trim(LEADING 'x' FROM s)"), "SELECT ltrim(s, 'x')");
        assert_eq!(round("SELECT trim(TRAILING 'x' FROM s)"), "SELECT rtrim(s, 'x')");
        assert_eq!(
            round("SELECT overlay(s PLACING 'X' FROM 2 FOR 1)"),
            "SELECT overlay(s, 'X', 2, 1)"
        );
        assert_eq!(round("SELECT overlay(s PLACING 'X' FROM 2)"), "SELECT overlay(s, 'X', 2)");
        assert_eq!(round("SELECT overlay(s, 'X', 2, 1)"), "SELECT overlay(s, 'X', 2, 1)");
    }

    #[test]
    fn an_aggregate_keeps_its_distinct() {
        assert_eq!(round("SELECT count(*)"), "SELECT count(*)");
        assert_eq!(round("SELECT count(DISTINCT x)"), "SELECT count(DISTINCT x)");
        assert_eq!(round("SELECT count(ALL x)"), "SELECT count(x)");
        assert_eq!(round("SELECT main.count(x)"), "SELECT main.count(x)");
    }

    #[test]
    fn the_modifiers_hang_off_the_query_and_not_off_the_select() {
        // `a UNION b ORDER BY x` sorts the union. Putting the order by on the select would have
        // made that unrepresentable, which is why the grammar puts it outside the chain and why
        // the AST follows.
        assert_eq!(
            round("SELECT 1 UNION ALL SELECT 2 ORDER BY 1"),
            "(SELECT 1 Union All SELECT 2) ORDER BY 1 Unstated Unstated"
        );
        assert_eq!(
            round("SELECT a FROM t UNION SELECT b FROM u EXCEPT SELECT c FROM v"),
            "((SELECT a FROM t Union Unstated SELECT b FROM u) Except Unstated SELECT c FROM v)",
            "set operators are left associative"
        );
        assert_eq!(
            round("SELECT 1 UNION SELECT 2 INTERSECT SELECT 3"),
            "(SELECT 1 Union Unstated (SELECT 2 Intersect Unstated SELECT 3))",
            "and intersect binds tighter than the other two"
        );
    }

    #[test]
    fn the_sort_and_limit_clauses_keep_what_was_written() {
        assert_eq!(
            round("SELECT a FROM t ORDER BY a"),
            "SELECT a FROM t ORDER BY a Unstated Unstated"
        );
        assert_eq!(
            round("SELECT a FROM t ORDER BY a DESC NULLS LAST"),
            "SELECT a FROM t ORDER BY a Descending Last"
        );
        assert_eq!(round("SELECT a FROM t ORDER BY ALL"), "SELECT a FROM t ORDER BY ALL");
        assert_eq!(round("SELECT a FROM t GROUP BY ALL"), "SELECT a FROM t GROUP BY ALL");
        assert_eq!(round("SELECT a FROM t LIMIT 10 OFFSET 5"), "SELECT a FROM t LIMIT 10 OFFSET 5");
        assert_eq!(round("SELECT a FROM t OFFSET 5 LIMIT 10"), "SELECT a FROM t LIMIT 10 OFFSET 5");
        assert_eq!(round("SELECT a FROM t LIMIT 10%"), "SELECT a FROM t LIMIT 10%");
        assert_eq!(round("SELECT a FROM t LIMIT ALL"), "SELECT a FROM t", "which is no limit");
    }

    #[test]
    fn a_subquery_appears_in_both_places_it_can() {
        assert_eq!(
            round("SELECT * FROM (SELECT x FROM t) AS s"),
            "SELECT * FROM (SELECT x FROM t) AS s"
        );
        assert_eq!(round("SELECT (SELECT 1)"), "SELECT (SELECT 1)");
    }

    #[test]
    fn distinct_on_keeps_its_expressions() {
        assert_eq!(round("SELECT DISTINCT a"), "SELECT DISTINCT a");
        assert_eq!(round("SELECT ALL a"), "SELECT a", "which is the default written out");
        assert_eq!(round("SELECT DISTINCT ON (a, b) a"), "SELECT DISTINCT ON (a, b) a");
    }

    #[test]
    fn an_operator_the_dialect_does_not_name_is_kept_by_name() {
        // The grammar text says `OperatorLiteral <- Identifier`, which reads as though any bare
        // word could be written infix. It cannot. That rule is one of the 24 the matcher overrides
        // and it is overridden to the bare operator matcher, so what it takes is a run of operator
        // characters. Believing the body here would have produced a transformer that accepted
        // `a foo b`, which DuckDB rejects.
        assert_eq!(round("SELECT a <=> b"), "SELECT (a <=> b)");
        assert!(parse_ast("SELECT a foo b").is_err(), "a bare word is not an operator");
    }

    #[test]
    fn a_script_is_a_list_of_statements() {
        let ast = parse_ast("SELECT 1; SELECT 2;").unwrap();
        assert_eq!(ast.statements.len(), 2);
        // A trailing semicolon makes an empty top level statement in the parse tree, because the
        // grammar's `Statement? (';'+ / EndOfInput)` is happy with nothing on both sides. It is
        // dropped here rather than pretended away in the matcher.
        let Statement::Query(second) = ast.statements[1] else {
            panic!("the second statement is a query");
        };
        assert_eq!(show_query(&ast, second), "SELECT 2");
    }

    #[test]
    fn an_unsupported_construct_names_itself_and_what_was_written() {
        let error = parse_ast("ALTER TABLE t ADD COLUMN a INTEGER").unwrap_err().to_string();
        assert!(error.starts_with("Not implemented Error"), "{error}");
        assert!(error.contains("ALTER TABLE t ADD COLUMN a INTEGER"), "{error}");
        assert!(error.contains("AlterStatement"), "{error}");
    }

    #[test]
    fn a_long_construct_is_cut_short_in_the_message() {
        let query = format!("ALTER TABLE t ADD COLUMN {} INTEGER", "a".repeat(80));
        let error = parse_ast(&query).unwrap_err().to_string();
        assert!(error.contains("..."), "{error}");
        assert!(error.len() < 200, "{error}");
    }

    #[test]
    fn the_transformer_never_panics_on_anything_the_matcher_accepts() {
        // The matcher accepts a good deal that means nothing, because the grammar does. Every one
        // of these parses and none of them is a statement this milestone covers, and the contract
        // is that the answer is an error either way.
        for query in [
            "SELECT",
            "FROM t SELECT",
            "SELECT * FROM t WHERE",
            "SELECT ()",
            "SELECT a FROM t GROUP BY ()",
        ] {
            let answer = parse_ast(query);
            if let Err(error) = answer {
                let message = error.to_string();
                assert!(
                    message.starts_with("Not implemented Error")
                        || message.starts_with("Parser Error"),
                    "{query} failed with {message}"
                );
            }
        }
    }

    #[test]
    fn a_file_name_in_a_from_clause_is_a_table_name_with_the_quotes_off() {
        // Both spellings have to arrive as the same name, because the binder decides whether it is
        // a file by looking at the name, and `'hits.parquet'` with the quotes still on it is not
        // a path that anything can open.
        assert_eq!(round("SELECT * FROM 'hits.parquet'"), "SELECT * FROM hits.parquet");
        assert_eq!(round("SELECT * FROM \"hits.parquet\""), "SELECT * FROM hits.parquet");
        assert_eq!(round("SELECT * FROM 'hits.parquet' AS h"), "SELECT * FROM hits.parquet AS h");
        assert_eq!(
            round_with_case("SELECT Mixed FROM 'NoSuch/Mixed/File.csv'", IdentifierCase::Lower),
            "SELECT mixed FROM NoSuch/Mixed/File.csv"
        );
        assert_eq!(
            round_with_case("SELECT Mixed FROM \"QuotedTable\"", IdentifierCase::Upper),
            "SELECT MIXED FROM QuotedTable"
        );
    }

    #[test]
    fn a_function_call_in_a_from_clause_is_a_source_and_not_an_expression() {
        assert_eq!(round("SELECT * FROM range(3)"), "SELECT * FROM range(3)");
        assert_eq!(round("SELECT * FROM range(1, 10, 2)"), "SELECT * FROM range(1, 10, 2)");
        assert_eq!(round("SELECT * FROM main.range(3)"), "SELECT * FROM main.range(3)");
        assert_eq!(round("SELECT * FROM range(3) AS t"), "SELECT * FROM range(3) AS t");
        // The grammar allows a call with no arguments here and the transformer keeps it, because
        // whether a particular function takes none is the binder's question and not this one's.
        assert_eq!(round("SELECT * FROM some_function()"), "SELECT * FROM some_function()");
    }

    #[test]
    fn the_forms_of_a_table_function_this_does_not_cover_are_turned_away_by_name() {
        for query in [
            "SELECT * FROM range(3) WITH ORDINALITY",
            "SELECT * FROM LATERAL range(3)",
            "SELECT * FROM t: range(3)",
        ] {
            let error = parse_ast(query).unwrap_err().to_string();
            assert!(error.contains("grammar rule"), "{query} failed with {error}");
        }
    }

    #[test]
    fn a_pragma_is_the_call_it_stands_for_by_the_time_it_leaves_here() {
        assert_eq!(round("PRAGMA version"), "SELECT * FROM pragma_version()");
        assert_eq!(round("PRAGMA database_size"), "SELECT * FROM pragma_database_size()");
        // The case the user wrote survives, because the name goes back out in the message about a
        // pragma that does not exist and the pin prints it back as it was typed.
        assert_eq!(round("PRAGMA VERSION"), "SELECT * FROM pragma_VERSION()");
        assert_eq!(round("PRAGMA table_info('t')"), "SELECT * FROM pragma_table_info('t')");
    }

    #[test]
    fn a_bare_name_in_a_pragmas_parentheses_is_a_name_and_not_a_column() {
        // There is no FROM clause here for a column to come out of, so both spellings have to
        // arrive as the same string, and a qualified one has to arrive as one string and not two.
        assert_eq!(round("PRAGMA table_info(t)"), "SELECT * FROM pragma_table_info('t')");
        assert_eq!(round("PRAGMA table_info(main.t)"), "SELECT * FROM pragma_table_info('main.t')");
        assert_eq!(round("PRAGMA table_info(\"T\")"), "SELECT * FROM pragma_table_info('T')");
        // Anything that is not a name is left alone, so the binder is the one that says there is
        // no overload taking an integer rather than a table called 1 being looked for.
        assert_eq!(round("PRAGMA table_info(1)"), "SELECT * FROM pragma_table_info(1)");
    }

    #[test]
    fn a_pragma_with_an_equals_sign_is_a_set_and_nothing_else() {
        assert_eq!(round_statement("PRAGMA memory_limit = '1GB'"), "SET memory_limit = '1GB'");
        assert_eq!(round_statement("PRAGMA threads = 4"), "SET threads = 4");
    }

    #[test]
    fn a_pragma_with_empty_parentheses_does_not_parse_on_either_engine() {
        // The rule is `PragmaParameters <- Parens(List(Expression))` and a list of no expressions
        // does not match, which is where the pin's parser error comes from as well.
        let error = parse_ast("PRAGMA version()").unwrap_err().to_string();
        assert!(error.contains("syntax error at or near \")\""), "{error}");
    }

    #[test]
    fn interning_means_a_name_written_twice_is_stored_once() {
        let ast = parse_ast("SELECT a, a, a FROM t WHERE a = a").unwrap();
        assert_eq!(ast.strings.iter().filter(|text| *text == "a").count(), 1);
    }
}