Skip to main content

uqa_execution/
copy.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Execute COPY byte streams through the ordinary INSERT and SELECT statement paths.
8use std::io::{Read, Write};
9use uqa_core::Value;
10use uqa_sql::{
11    ast::{Expr, InsertStmt, ReturningAliases, Statement},
12    catalog::security::table::TableAclPrivilege,
13    copy::stream::CopyCatalog,
14    copy::{
15        compile_copy, decode_copy_input, encode_copy_result_with_engine, CopyDirection, CopyTarget,
16    },
17    expr::EngineHook,
18    SQLError, SQLParam, SQLResult,
19};
20pub trait CopyPrivileges {
21    fn ensure_any_column(&self, table: &str, privilege: TableAclPrivilege) -> Result<(), SQLError>;
22    fn ensure_column(
23        &self,
24        table: &str,
25        column: &str,
26        privilege: TableAclPrivilege,
27    ) -> Result<(), SQLError>;
28}
29pub trait CopyStatements {
30    fn execute_statement(
31        &self,
32        statement: Statement,
33        params: &[SQLParam],
34    ) -> Result<SQLResult, SQLError>;
35    fn execute_text(&self, text: &str, params: &[SQLParam]) -> Result<SQLResult, SQLError>;
36}
37pub struct CopyExecutionContext<'a> {
38    pub catalog: &'a dyn CopyCatalog,
39    pub privileges: &'a dyn CopyPrivileges,
40    pub statements: &'a dyn CopyStatements,
41    pub output: &'a dyn EngineHook,
42}
43pub fn copy_from(
44    context: &CopyExecutionContext<'_>,
45    statement: &str,
46    input: &mut impl Read,
47) -> Result<u64, SQLError> {
48    let copy = compile_copy(statement)?;
49    uqa_sql::copy::stream::validate_stream(&copy, CopyDirection::From)?;
50    let CopyTarget::Relation {
51        name: relation,
52        qualifier,
53        columns: requested_columns,
54    } = &copy.target
55    else {
56        return Err(SQLError::Routine {
57            sqlstate: "42601".into(),
58            message: "COPY FROM requires a relation target".into(),
59        });
60    };
61    let (canonical, columns) = uqa_sql::copy::stream::relation_columns(
62        context.catalog,
63        relation,
64        qualifier,
65        requested_columns,
66        false,
67    )?;
68    if columns.is_empty() {
69        context
70            .privileges
71            .ensure_any_column(&canonical, TableAclPrivilege::Insert)?;
72    } else {
73        for column in &columns {
74            context
75                .privileges
76                .ensure_column(&canonical, column, TableAclPrivilege::Insert)?;
77        }
78    }
79    let mut bytes = Vec::new();
80    input
81        .read_to_end(&mut bytes)
82        .map_err(|error| copy_io_error("read COPY FROM stream", error))?;
83    let rows = decode_copy_input(&bytes, &copy.options, &columns)?;
84    if rows.is_empty() {
85        return Ok(0);
86    }
87    if columns.is_empty() {
88        return Err(SQLError::Unsupported(
89            "COPY FROM for a zero-column relation is not implemented".into(),
90        ));
91    }
92    let mut params = Vec::with_capacity(rows.len().saturating_mul(columns.len()));
93    let mut parameter = 1usize;
94    let mut insert_rows = Vec::with_capacity(rows.len());
95    for row in rows {
96        let mut values = Vec::with_capacity(row.len());
97        for field in row {
98            values.push(Expr::Param(parameter));
99            parameter = parameter.checked_add(1).ok_or_else(|| SQLError::Routine {
100                sqlstate: "54000".into(),
101                message: "COPY input has too many fields".into(),
102            })?;
103            params.push(SQLParam::Scalar(match field {
104                Some(value) => Value::Str(value),
105                None => Value::Null,
106            }));
107        }
108        insert_rows.push(values);
109    }
110    let result = context.statements.execute_statement(
111        Statement::Insert(InsertStmt {
112            table: relation.clone(),
113            target_relation_bound: false,
114            target_qualifier: qualifier.clone(),
115            target_alias: None,
116            include_descendants: true,
117            columns: columns.into_iter().map(Into::into).collect(),
118            // COPY FROM writes the values its input supplies, also to a GENERATED ALWAYS identity column.
119            overriding: Some(uqa_sql::ast::OverridingKind::SystemValue),
120            with: Vec::new(),
121            rows: insert_rows,
122            select_source: None,
123            on_conflict: None,
124            returning: Vec::new(),
125            returning_aliases: ReturningAliases::default(),
126        }),
127        &params,
128    )?;
129    Ok(result.affected_rows)
130}
131
132pub fn copy_to(
133    context: &CopyExecutionContext<'_>,
134    statement: &str,
135    output: &mut impl Write,
136) -> Result<u64, SQLError> {
137    let copy = compile_copy(statement)?;
138    uqa_sql::copy::stream::validate_stream(&copy, CopyDirection::To)?;
139    let query = match &copy.target {
140        CopyTarget::Relation {
141            name: relation,
142            qualifier,
143            columns: requested_columns,
144        } => {
145            let (canonical, columns) = uqa_sql::copy::stream::relation_columns(
146                context.catalog,
147                relation,
148                qualifier,
149                requested_columns,
150                true,
151            )?;
152            if columns.is_empty() {
153                context
154                    .privileges
155                    .ensure_any_column(&canonical, TableAclPrivilege::Select)?;
156            } else {
157                for column in &columns {
158                    context.privileges.ensure_column(
159                        &canonical,
160                        column,
161                        TableAclPrivilege::Select,
162                    )?;
163                }
164            }
165            let projection = columns
166                .iter()
167                .map(|column| uqa_sql::expr::quote_ident(column))
168                .collect::<Vec<_>>()
169                .join(", ");
170            format!("SELECT {projection} FROM ONLY {relation}")
171        }
172        CopyTarget::Query(query) => query.clone(),
173    };
174    let result = context.statements.execute_text(&query, &[])?;
175    let row_count = u64::try_from(result.rows.len()).map_err(|_| SQLError::Routine {
176        sqlstate: "54000".into(),
177        message: "COPY output row count exceeds u64".into(),
178    })?;
179    let bytes = encode_copy_result_with_engine(&result, &copy.options, context.output)?;
180    output
181        .write_all(&bytes)
182        .map_err(|error| copy_io_error("write COPY TO stream", error))?;
183    Ok(row_count)
184}
185
186fn copy_io_error(action: &str, error: std::io::Error) -> SQLError {
187    SQLError::Routine {
188        sqlstate: "58030".into(),
189        message: format!("{action}: {error}"),
190    }
191}