Skip to main content

uqa_sql/result/
completion.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Command completion owned by the plan that executed, including delegated EXECUTE.
8
9use crate::ast::{
10    AlterRoutineKind, AlterTableAction, AlterViewKind, DiscardTarget, DropKind, TransactionStmt,
11};
12use crate::plan::{CommandPlan, UnifiedPlan};
13use crate::SQLResult;
14
15pub fn set_command_completion(
16    plan: &UnifiedPlan,
17    result: &mut SQLResult,
18    transaction_failed: bool,
19) {
20    let command = match plan {
21        UnifiedPlan::Query(_) => {
22            result.command_tag = Some(format!("SELECT {}", result.rows.len()));
23            return;
24        }
25        UnifiedPlan::Command(command) => command.as_ref(),
26    };
27    if matches!(
28        command,
29        CommandPlan::Empty
30            | CommandPlan::Execute { .. }
31            | CommandPlan::CreateTableAs { .. }
32            | CommandPlan::CreateMaterializedView { .. }
33    ) {
34        // Delegated execution and optional population own their completion.
35        return;
36    }
37    result.command_tag = Some(command_completion(command, result, transaction_failed));
38}
39
40fn command_completion(
41    command: &CommandPlan,
42    result: &SQLResult,
43    transaction_failed: bool,
44) -> String {
45    match command {
46        CommandPlan::Insert(_) => format!("INSERT 0 {}", result.affected_rows),
47        CommandPlan::Update(_) => format!("UPDATE {}", result.affected_rows),
48        CommandPlan::Delete(_) => format!("DELETE {}", result.affected_rows),
49        CommandPlan::Merge(_) => format!("MERGE {}", result.affected_rows),
50        CommandPlan::FetchCursor(fetch) if fetch.move_only => {
51            format!("MOVE {}", result.affected_rows)
52        }
53        CommandPlan::FetchCursor(_) => format!("FETCH {}", result.rows.len()),
54        CommandPlan::CreateTableAs { .. } | CommandPlan::CreateMaterializedView { .. } => {
55            unreachable!("population execution owns completion")
56        }
57        CommandPlan::Execute { .. } => {
58            unreachable!("EXECUTE preserves delegated command completion")
59        }
60        CommandPlan::Transaction(statement) => {
61            transaction_completion(statement, transaction_failed).to_string()
62        }
63        command => command_tag_name(command).to_string(),
64    }
65}
66
67/// The tag of a command without its row count, as `CreateCommandName` names a command in diagnostics such as the read-only transaction error.
68#[expect(clippy::too_many_lines, reason = "exhaustive SQL command tag mapping")]
69pub fn command_tag_name(command: &CommandPlan) -> &'static str {
70    match command {
71        CommandPlan::Empty => "",
72        CommandPlan::Insert(_) => "INSERT",
73        CommandPlan::Update(_) => "UPDATE",
74        CommandPlan::Delete(_) => "DELETE",
75        CommandPlan::Merge(_) => "MERGE",
76        CommandPlan::FetchCursor(fetch) => {
77            if fetch.move_only {
78                "MOVE"
79            } else {
80                "FETCH"
81            }
82        }
83        CommandPlan::CreateTableAs {
84            select_into: true, ..
85        } => "SELECT INTO",
86        CommandPlan::CreateTableAs { .. } => "CREATE TABLE AS",
87        CommandPlan::CreateMaterializedView { .. } => "CREATE MATERIALIZED VIEW",
88        CommandPlan::Execute { .. } => "EXECUTE",
89        CommandPlan::Transaction(statement) => transaction_completion(statement, false),
90        CommandPlan::CreateTable(_) | CommandPlan::CreateTableIfNotExists(_) => "CREATE TABLE",
91        CommandPlan::CreateIndex(_) => "CREATE INDEX",
92        CommandPlan::RenameIndex(_) => "ALTER INDEX",
93        CommandPlan::Drop(statement) => match statement.kind {
94            DropKind::Table => "DROP TABLE",
95            DropKind::ForeignTable => "DROP FOREIGN TABLE",
96            DropKind::ForeignServer => "DROP SERVER",
97            DropKind::ForeignWrapper => "DROP FOREIGN DATA WRAPPER",
98            DropKind::Index => "DROP INDEX",
99            DropKind::View => "DROP VIEW",
100            DropKind::MaterializedView => "DROP MATERIALIZED VIEW",
101            DropKind::Schema => "DROP SCHEMA",
102            DropKind::Sequence => "DROP SEQUENCE",
103            DropKind::Domain => "DROP DOMAIN",
104            DropKind::Type => "DROP TYPE",
105        },
106        CommandPlan::AlterTable(statement) => match statement.actions.as_slice() {
107            [AlterTableAction::RenameTrigger { .. }] => "ALTER TRIGGER",
108            [AlterTableAction::RenameRule { .. }] => "ALTER RULE",
109            _ => "ALTER TABLE",
110        },
111        CommandPlan::AlterForeignTable(_) => "ALTER FOREIGN TABLE",
112        CommandPlan::AlterView(statement) => match statement.kind {
113            AlterViewKind::View => "ALTER VIEW",
114            AlterViewKind::MaterializedView => "ALTER MATERIALIZED VIEW",
115        },
116        CommandPlan::CreateView { .. } => "CREATE VIEW",
117        CommandPlan::RefreshMaterializedView { .. } => "REFRESH MATERIALIZED VIEW",
118        CommandPlan::CreateSchema { .. } => "CREATE SCHEMA",
119        CommandPlan::AlterSchemaOwner { .. } | CommandPlan::RenameSchema { .. } => "ALTER SCHEMA",
120        CommandPlan::Notify { .. } => "NOTIFY",
121        CommandPlan::Listen { .. } => "LISTEN",
122        CommandPlan::Unlisten { .. } => "UNLISTEN",
123        CommandPlan::SetVariable { .. } => "SET",
124        CommandPlan::ResetVariable { .. } | CommandPlan::ResetAllVariables => "RESET",
125        CommandPlan::SetConstraints { .. } => "SET CONSTRAINTS",
126        CommandPlan::ShowVariable { .. } => "SHOW",
127        CommandPlan::Discard { target } => match target {
128            DiscardTarget::All => "DISCARD ALL",
129            DiscardTarget::Plans => "DISCARD PLANS",
130            DiscardTarget::Sequences => "DISCARD SEQUENCES",
131            DiscardTarget::Temp => "DISCARD TEMP",
132        },
133        CommandPlan::Load { .. } => "LOAD",
134        CommandPlan::Explain { .. } => "EXPLAIN",
135        CommandPlan::Analyze { .. } => "ANALYZE",
136        CommandPlan::LockTable(_) => "LOCK TABLE",
137        CommandPlan::Vacuum(_) => "VACUUM",
138        CommandPlan::Truncate { .. } => "TRUNCATE TABLE",
139        CommandPlan::DeclareCursor { .. } => "DECLARE CURSOR",
140        CommandPlan::CloseCursor { name } => {
141            if name.is_some() {
142                "CLOSE CURSOR"
143            } else {
144                "CLOSE CURSOR ALL"
145            }
146        }
147        CommandPlan::CreateSequence(_) => "CREATE SEQUENCE",
148        CommandPlan::CreateDomain(_) => "CREATE DOMAIN",
149        CommandPlan::AlterDomain(_) => "ALTER DOMAIN",
150        CommandPlan::CommentType(_) => "COMMENT",
151        CommandPlan::CreateShellType(_)
152        | CommandPlan::CreateEnum(_)
153        | CommandPlan::CreateCompositeType(_) => "CREATE TYPE",
154        CommandPlan::AlterEnum(_) => "ALTER TYPE",
155        CommandPlan::AlterTypeObject(statement) => match statement.kind {
156            crate::ast::TypeObjectKind::Type => "ALTER TYPE",
157            crate::ast::TypeObjectKind::Domain => "ALTER DOMAIN",
158        },
159        CommandPlan::GrantType(statement) => grant_completion(statement.is_grant),
160        CommandPlan::AlterSequence(_) => "ALTER SEQUENCE",
161        CommandPlan::Prepare { .. } => "PREPARE",
162        CommandPlan::Deallocate { name } => {
163            if name.is_some() {
164                "DEALLOCATE"
165            } else {
166                "DEALLOCATE ALL"
167            }
168        }
169        CommandPlan::CreateForeignWrapper(_) => "CREATE FOREIGN DATA WRAPPER",
170        CommandPlan::CreateForeignServer(_) => "CREATE SERVER",
171        CommandPlan::CreateForeignTable(_) | CommandPlan::CreateForeignTableDefinition(_) => {
172            "CREATE FOREIGN TABLE"
173        }
174        CommandPlan::CreateFunction(statement) => {
175            if statement.is_procedure {
176                "CREATE PROCEDURE"
177            } else {
178                "CREATE FUNCTION"
179            }
180        }
181        CommandPlan::DropFunction(statement) => {
182            if statement.is_procedure {
183                "DROP PROCEDURE"
184            } else {
185                "DROP FUNCTION"
186            }
187        }
188        CommandPlan::AlterRoutine(statement) => alter_routine_completion(statement.kind),
189        CommandPlan::AlterRoutineOwner(statement) => alter_routine_completion(statement.kind),
190        CommandPlan::RenameRoutine(statement) => alter_routine_completion(statement.kind),
191        CommandPlan::GrantRoutine(statement) => grant_completion(statement.is_grant),
192        CommandPlan::GrantTable(statement) => grant_completion(statement.is_grant),
193        CommandPlan::GrantSequence(statement) => grant_completion(statement.is_grant),
194        CommandPlan::GrantDatabase(statement) => grant_completion(statement.is_grant),
195        CommandPlan::GrantSchema(statement) => grant_completion(statement.is_grant),
196        CommandPlan::GrantRole(statement) => {
197            if statement.is_grant {
198                "GRANT ROLE"
199            } else {
200                "REVOKE ROLE"
201            }
202        }
203        CommandPlan::CreateRole(_) => "CREATE ROLE",
204        CommandPlan::AlterRole(_) | CommandPlan::RenameRole(_) => "ALTER ROLE",
205        CommandPlan::DropRole(_) => "DROP ROLE",
206        CommandPlan::CreateTrigger(_) => "CREATE TRIGGER",
207        CommandPlan::DropTrigger(_) => "DROP TRIGGER",
208        CommandPlan::CreateRule(_) => "CREATE RULE",
209        CommandPlan::DropRule(_) => "DROP RULE",
210        CommandPlan::DoBlock { .. } => "DO",
211        CommandPlan::Call { .. } => "CALL",
212    }
213}
214
215pub const fn transaction_completion(statement: &TransactionStmt, failed: bool) -> &'static str {
216    match statement {
217        TransactionStmt::Begin | TransactionStmt::BeginWithCharacteristics(_) => "BEGIN",
218        TransactionStmt::Commit | TransactionStmt::CommitAndChain => {
219            if failed {
220                "ROLLBACK"
221            } else {
222                "COMMIT"
223            }
224        }
225        TransactionStmt::Rollback
226        | TransactionStmt::RollbackAndChain
227        | TransactionStmt::RollbackToSavepoint(_) => "ROLLBACK",
228        TransactionStmt::Savepoint(_) => "SAVEPOINT",
229        TransactionStmt::ReleaseSavepoint(_) => "RELEASE",
230        TransactionStmt::SetCharacteristics(_)
231        | TransactionStmt::SetSessionCharacteristics(_)
232        | TransactionStmt::SetSnapshot(_) => "SET",
233    }
234}
235
236const fn alter_routine_completion(kind: AlterRoutineKind) -> &'static str {
237    match kind {
238        AlterRoutineKind::Function => "ALTER FUNCTION",
239        AlterRoutineKind::Procedure => "ALTER PROCEDURE",
240        AlterRoutineKind::Routine => "ALTER ROUTINE",
241    }
242}
243
244const fn grant_completion(is_grant: bool) -> &'static str {
245    if is_grant {
246        "GRANT"
247    } else {
248        "REVOKE"
249    }
250}