1use 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(©, CopyDirection::From)?;
50 let CopyTarget::Relation {
51 name: relation,
52 qualifier,
53 columns: requested_columns,
54 } = ©.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, ©.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 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 ¶ms,
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(©, CopyDirection::To)?;
139 let query = match ©.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, ©.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}