1use std::fmt::Write as _;
10
11use uqa_core::{TemporalValue, Value};
12
13use crate::ast::{
14 CteBody, CteMaterialization, Expr, FromClause, JoinKind, LockWait, NullsOrder,
15 OperatorJoinRelations, OrderBy, Projection, ReturningAliases, SelectStmt, SetOpKind, Statement,
16 TableFunction, WindowDefinition, CTE,
17};
18use crate::SQLError;
19
20mod commands;
21use commands::{delete_sql, insert_sql, merge_sql, update_sql};
22mod legacy_vector;
23pub use legacy_vector::legacy_vector_expression;
24mod window;
25pub use window::frame_clause_sql;
26mod expressions;
27use expressions::{render_expr, render_expr_in};
28pub(crate) mod function_syntax;
29
30pub(crate) fn pattern_sql<'a, T: 'a>(
31 operator: crate::ast::PatternOperator,
32 arguments: &'a [T],
33 mut render: impl FnMut(&'a T) -> Result<String, SQLError>,
34) -> Result<String, SQLError> {
35 let [left, pattern] = arguments else {
36 return Err(SQLError::Internal(
37 "invalid pattern operator operands".into(),
38 ));
39 };
40 Ok(format!(
41 "({} {} {})",
42 render(left)?,
43 operator.syntax(),
44 render(pattern)?
45 ))
46}
47
48pub fn statement_sql(statement: &Statement) -> Result<String, SQLError> {
50 match statement {
51 Statement::Select(select) => select_sql(select),
52 Statement::Insert(insert) => insert_sql(insert),
53 Statement::Update(update) => update_sql(update),
54 Statement::Delete(delete) => delete_sql(delete),
55 Statement::Merge(merge) => merge_sql(merge),
56 Statement::Notify { channel, payload } => {
57 let payload = if payload.is_empty() {
58 String::new()
59 } else {
60 format!(", {}", string_literal(payload))
61 };
62 Ok(format!("NOTIFY {}{payload}", ident(channel)))
63 }
64 _ => Err(SQLError::Internal(
65 "durable rewrite-rule action has an unsupported statement kind".into(),
66 )),
67 }
68}
69
70pub fn expression_sql(expression: &Expr) -> Result<String, SQLError> {
72 render_expr(expression)
73}
74
75fn select_sql(statement: &SelectStmt) -> Result<String, SQLError> {
76 let mut rendered = with_sql(&statement.with)?;
77 if let Some(set) = statement.set_op.as_deref() {
78 let left = set
79 .left
80 .as_deref()
81 .map_or_else(|| select_body_sql(statement), select_sql)?;
82 rendered.push('(');
83 rendered.push_str(&left);
84 rendered.push_str(") ");
85 rendered.push_str(match set.kind {
86 SetOpKind::Union => "UNION",
87 SetOpKind::Intersect => "INTERSECT",
88 SetOpKind::Except => "EXCEPT",
89 });
90 if set.all {
91 rendered.push_str(" ALL");
92 }
93 rendered.push_str(" (");
94 rendered.push_str(&select_sql(&set.right)?);
95 rendered.push(')');
96 render_order_limit_offset(
97 &mut rendered,
98 &set.combined_order_by,
99 set.combined_limit.as_ref(),
100 set.combined_with_ties,
101 set.combined_offset.as_ref(),
102 )?;
103 return Ok(rendered);
104 }
105 rendered.push_str(&select_body_sql(statement)?);
106 Ok(rendered)
107}
108
109fn select_body_sql(statement: &SelectStmt) -> Result<String, SQLError> {
110 let mut rendered = String::new();
111 if statement.values.is_empty() {
112 rendered.push_str("SELECT");
113 if !statement.distinct_on.is_empty() {
114 rendered.push_str(" DISTINCT ON (");
115 rendered.push_str(&expr_list_in(&statement.distinct_on, &statement.windows)?);
116 rendered.push(')');
117 } else if statement.distinct {
118 rendered.push_str(" DISTINCT");
119 }
120 rendered.push(' ');
121 rendered.push_str(&projections_sql_in(
122 &statement.projections,
123 &statement.windows,
124 )?);
125 if let Some(source) = &statement.from {
126 rendered.push_str(" FROM ");
127 rendered.push_str(&from_sql(source)?);
128 }
129 if let Some(predicate) = &statement.r#where {
130 rendered.push_str(" WHERE ");
131 rendered.push_str(&render_expr(predicate)?);
132 }
133 if !statement.grouping_sets.is_empty() {
134 rendered.push_str(" GROUP BY ");
135 if statement.group_distinct {
136 rendered.push_str("DISTINCT ");
137 }
138 rendered.push_str("GROUPING SETS (");
139 rendered.push_str(
140 &statement
141 .grouping_sets
142 .iter()
143 .map(|set| Ok(format!("({})", expr_list(set)?)))
144 .collect::<Result<Vec<_>, SQLError>>()?
145 .join(", "),
146 );
147 rendered.push(')');
148 } else if !statement.group_by.is_empty() {
149 rendered.push_str(" GROUP BY ");
150 if statement.group_distinct {
151 rendered.push_str("DISTINCT ");
152 }
153 rendered.push_str(&expr_list(&statement.group_by)?);
154 }
155 if let Some(predicate) = &statement.having {
156 rendered.push_str(" HAVING ");
157 rendered.push_str(&render_expr(predicate)?);
158 }
159 } else {
160 rendered.push_str("VALUES ");
161 rendered.push_str(&rows_sql(&statement.values)?);
162 }
163 rendered.push_str(&window::window_clause_sql(&statement.windows)?);
164 render_order_limit_offset_in(
165 &mut rendered,
166 &statement.order_by,
167 statement.limit.as_ref(),
168 statement.with_ties,
169 statement.offset.as_ref(),
170 &statement.windows,
171 )?;
172 for locking in &statement.locking {
173 rendered.push(' ');
174 rendered.push_str(locking.strength.sql_name());
175 if !locking.relations.is_empty() {
176 rendered.push_str(" OF ");
177 rendered.push_str(&ident_list(&locking.relations));
178 }
179 rendered.push_str(match locking.wait {
180 LockWait::Block => "",
181 LockWait::SkipLocked => " SKIP LOCKED",
182 LockWait::NoWait => " NOWAIT",
183 });
184 }
185 Ok(rendered)
186}
187
188#[expect(
189 clippy::too_many_lines,
190 reason = "exhaustive FROM rendering keeps each AST variant visibly complete"
191)]
192fn from_sql(source: &FromClause) -> Result<String, SQLError> {
193 Ok(match source {
194 crate::ast::FromClause::RetainedRows(_) => {
195 return Err(SQLError::Internal(
196 "retained row source has no persistent SQL representation".into(),
197 ))
198 }
199 FromClause::Table {
200 name,
201 alias,
202 column_aliases,
203 include_descendants,
204 ..
205 } => {
206 let mut rendered = only_relation(name, *include_descendants);
207 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
208 rendered
209 }
210 FromClause::Join {
211 left,
212 right,
213 kind,
214 on,
215 using,
216 natural,
217 alias,
218 column_aliases,
219 lateral,
220 } => {
221 let mut rendered = String::from("(");
222 rendered.push_str(&from_sql(left)?);
223 rendered.push(' ');
224 if *natural {
225 rendered.push_str("NATURAL ");
226 }
227 rendered.push_str(match kind {
228 JoinKind::Inner => "JOIN",
229 JoinKind::Left => "LEFT JOIN",
230 JoinKind::Right => "RIGHT JOIN",
231 JoinKind::Full => "FULL JOIN",
232 JoinKind::Cross => "CROSS JOIN",
233 });
234 rendered.push(' ');
235 if *lateral {
236 rendered.push_str("LATERAL ");
237 }
238 rendered.push_str(&from_sql(right)?);
239 if let Some(predicate) = on {
240 rendered.push_str(" ON ");
241 rendered.push_str(&render_expr(predicate)?);
242 } else if let Some(using) = using {
243 rendered.push_str(" USING (");
244 rendered.push_str(&ident_list(&using.columns));
245 rendered.push(')');
246 if let Some(alias) = &using.alias {
247 rendered.push_str(" AS ");
248 rendered.push_str(&ident(alias));
249 }
250 }
251 rendered.push(')');
252 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
253 rendered
254 }
255 FromClause::Values {
256 rows,
257 alias,
258 column_aliases,
259 ..
260 } => {
261 let mut rendered = format!("(VALUES {})", rows_sql(rows)?);
262 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
263 rendered
264 }
265 FromClause::Function {
266 name,
267 output_name: _,
268 relations,
269 args,
270 alias,
271 column_aliases,
272 ordinality,
273 column_types,
274 ..
275 } => {
276 let mut rendered = table_function_call_sql(name, relations.as_ref(), args)?;
277 if *ordinality {
278 rendered.push_str(" WITH ORDINALITY");
279 }
280 render_function_alias(
281 &mut rendered,
282 alias.as_deref(),
283 column_aliases,
284 column_types,
285 );
286 rendered
287 }
288 FromClause::FunctionGroup {
289 functions,
290 alias,
291 column_aliases,
292 ordinality,
293 } => {
294 let mut rendered = format!(
295 "ROWS FROM ({})",
296 functions
297 .iter()
298 .map(table_function_sql)
299 .collect::<Result<Vec<_>, _>>()?
300 .join(", ")
301 );
302 if *ordinality {
303 rendered.push_str(" WITH ORDINALITY");
304 }
305 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
306 rendered
307 }
308 FromClause::Subquery {
309 body,
310 alias,
311 column_aliases,
312 } => {
313 let mut rendered = format!("({})", select_sql(body)?);
314 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
315 rendered
316 }
317 })
318}
319
320fn table_function_sql(function: &TableFunction) -> Result<String, SQLError> {
321 let mut rendered =
322 table_function_call_sql(&function.name, function.relations.as_ref(), &function.args)?;
323 if !function.column_types.is_empty() {
324 rendered.push_str(" AS (");
325 rendered.push_str(
326 &function
327 .column_aliases
328 .iter()
329 .zip(&function.column_types)
330 .map(|(name, ty)| format!("{} {ty}", ident(name)))
331 .collect::<Vec<_>>()
332 .join(", "),
333 );
334 rendered.push(')');
335 }
336 Ok(rendered)
337}
338
339fn table_function_call_sql(
341 name: &str,
342 relations: Option<&OperatorJoinRelations>,
343 args: &[Expr],
344) -> Result<String, SQLError> {
345 let mut arguments = args
346 .iter()
347 .map(render_expr)
348 .collect::<Result<Vec<_>, _>>()?;
349 if let Some(relations) = relations {
350 if arguments.is_empty() {
351 return Err(SQLError::Internal(format!(
352 "operator join table function `{name}` has no left operand"
353 )));
354 }
355 arguments.insert(0, relations.left.clone());
356 arguments.insert(2, relations.right.clone());
357 }
358 Ok(format!("{name}({})", arguments.join(", ")))
359}
360
361fn with_sql(ctes: &[CTE]) -> Result<String, SQLError> {
362 if ctes.is_empty() {
363 return Ok(String::new());
364 }
365 let recursive = ctes.iter().any(|cte| cte.recursive);
366 Ok(format!(
367 "WITH {}{} ",
368 if recursive { "RECURSIVE " } else { "" },
369 ctes.iter()
370 .map(cte_sql)
371 .collect::<Result<Vec<_>, _>>()?
372 .join(", ")
373 ))
374}
375
376fn cte_sql(cte: &CTE) -> Result<String, SQLError> {
377 let mut rendered = ident(&cte.name);
378 if !cte.columns.is_empty() {
379 rendered.push_str(" (");
380 rendered.push_str(&ident_list(&cte.columns));
381 rendered.push(')');
382 }
383 rendered.push_str(" AS ");
384 rendered.push_str(match cte.materialization {
385 CteMaterialization::Default => "",
386 CteMaterialization::Materialized => "MATERIALIZED ",
387 CteMaterialization::NotMaterialized => "NOT MATERIALIZED ",
388 });
389 rendered.push('(');
390 rendered.push_str(&match &cte.body {
391 CteBody::Query(query) => select_sql(query),
392 CteBody::Insert(command) => insert_sql(command),
393 CteBody::Update(command) => update_sql(command),
394 CteBody::Delete(command) => delete_sql(command),
395 CteBody::Merge(command) => merge_sql(command),
396 }?);
397 rendered.push(')');
398 if let Some(search) = &cte.search {
399 write!(
400 &mut rendered,
401 " SEARCH {} FIRST BY {} SET {}",
402 if search.breadth_first {
403 "BREADTH"
404 } else {
405 "DEPTH"
406 },
407 ident_list(&search.columns),
408 ident(&search.sequence_column)
409 )
410 .expect("writing to a String cannot fail");
411 }
412 if let Some(cycle) = &cte.cycle {
413 write!(
414 &mut rendered,
415 " CYCLE {} SET {} TO {} DEFAULT {} USING {}",
416 ident_list(&cycle.columns),
417 ident(&cycle.mark_column),
418 render_expr(&cycle.mark_value)?,
419 render_expr(&cycle.mark_default)?,
420 ident(&cycle.path_column)
421 )
422 .expect("writing to a String cannot fail");
423 }
424 Ok(rendered)
425}
426
427fn render_order_limit_offset(
428 rendered: &mut String,
429 order_by: &[OrderBy],
430 limit: Option<&Expr>,
431 with_ties: bool,
432 offset: Option<&Expr>,
433) -> Result<(), SQLError> {
434 render_order_limit_offset_in(rendered, order_by, limit, with_ties, offset, &[])
435}
436
437fn render_order_limit_offset_in(
438 rendered: &mut String,
439 order_by: &[OrderBy],
440 limit: Option<&Expr>,
441 with_ties: bool,
442 offset: Option<&Expr>,
443 windows: &[WindowDefinition],
444) -> Result<(), SQLError> {
445 if !order_by.is_empty() {
446 rendered.push_str(" ORDER BY ");
447 rendered.push_str(&order_by_sql_in(order_by, windows)?);
448 }
449 if with_ties {
450 if let Some(offset) = offset {
451 rendered.push_str(" OFFSET ");
452 rendered.push_str(&render_expr_in(offset, windows)?);
453 }
454 if let Some(limit) = limit {
455 rendered.push_str(" FETCH FIRST ");
456 rendered.push_str(&render_expr_in(limit, windows)?);
457 rendered.push_str(" ROWS WITH TIES");
458 }
459 } else {
460 if let Some(limit) = limit {
461 rendered.push_str(" LIMIT ");
462 rendered.push_str(&render_expr_in(limit, windows)?);
463 }
464 if let Some(offset) = offset {
465 rendered.push_str(" OFFSET ");
466 rendered.push_str(&render_expr_in(offset, windows)?);
467 }
468 }
469 Ok(())
470}
471
472fn render_returning(
473 rendered: &mut String,
474 aliases: &ReturningAliases,
475 projections: &[Projection],
476) -> Result<(), SQLError> {
477 if projections.is_empty() {
478 return Ok(());
479 }
480 rendered.push_str(" RETURNING ");
481 if aliases.old_explicit || aliases.new_explicit {
482 rendered.push_str("WITH (");
483 let mut names = Vec::new();
484 if aliases.old_explicit {
485 names.push(format!("OLD AS {}", ident(&aliases.old)));
486 }
487 if aliases.new_explicit {
488 names.push(format!("NEW AS {}", ident(&aliases.new)));
489 }
490 rendered.push_str(&names.join(", "));
491 rendered.push_str(") ");
492 }
493 rendered.push_str(&projections_sql(projections)?);
494 Ok(())
495}
496
497fn render_target_alias(rendered: &mut String, relation: &str, qualifier: &str) {
498 if relation_local_name(relation) != qualifier {
499 rendered.push_str(" AS ");
500 rendered.push_str(&ident(qualifier));
501 }
502}
503
504fn render_relation_alias(rendered: &mut String, alias: Option<&str>, columns: &[String]) {
505 if let Some(alias) = alias {
506 rendered.push_str(" AS ");
507 rendered.push_str(&ident(alias));
508 if !columns.is_empty() {
509 rendered.push('(');
510 rendered.push_str(&ident_list(columns));
511 rendered.push(')');
512 }
513 }
514}
515
516fn render_function_alias(
517 rendered: &mut String,
518 alias: Option<&str>,
519 columns: &[String],
520 types: &[String],
521) {
522 if let Some(alias) = alias {
523 rendered.push_str(" AS ");
524 rendered.push_str(&ident(alias));
525 } else if !types.is_empty() {
526 rendered.push_str(" AS");
527 }
528 if !types.is_empty() {
529 rendered.push_str(" (");
530 rendered.push_str(
531 &columns
532 .iter()
533 .zip(types)
534 .map(|(name, ty)| format!("{} {ty}", ident(name)))
535 .collect::<Vec<_>>()
536 .join(", "),
537 );
538 rendered.push(')');
539 } else if !columns.is_empty() {
540 rendered.push('(');
541 rendered.push_str(&ident_list(columns));
542 rendered.push(')');
543 }
544}
545
546fn assignment_target_sql(target: &crate::ast::AssignmentTarget) -> Result<String, SQLError> {
547 use crate::ast::AssignmentStep;
548 let mut sql = ident(&target.column);
549 for step in &target.indirection {
550 match step {
551 AssignmentStep::Field(field) => {
552 sql.push('.');
553 sql.push_str(&ident(field));
554 }
555 AssignmentStep::Index(index) => {
556 sql.push('[');
557 sql.push_str(&render_expr(index)?);
558 sql.push(']');
559 }
560 AssignmentStep::Slice { lower, upper } => {
561 sql.push('[');
562 if let Some(lower) = lower {
563 sql.push_str(&render_expr(lower)?);
564 }
565 sql.push(':');
566 if let Some(upper) = upper {
567 sql.push_str(&render_expr(upper)?);
568 }
569 sql.push(']');
570 }
571 }
572 }
573 Ok(sql)
574}
575
576fn assignment_targets_sql(targets: &[crate::ast::AssignmentTarget]) -> Result<String, SQLError> {
577 Ok(targets
578 .iter()
579 .map(assignment_target_sql)
580 .collect::<Result<Vec<_>, _>>()?
581 .join(", "))
582}
583
584fn assignments_sql(
585 assignments: &[(crate::ast::AssignmentTargets, Expr)],
586) -> Result<String, SQLError> {
587 Ok(assignments
588 .iter()
589 .map(|(target, expression)| {
590 Ok(format!(
591 "{} = {}",
592 match target {
593 crate::ast::AssignmentTargets::Single(target) => assignment_target_sql(target)?,
594 crate::ast::AssignmentTargets::Multiple(targets) =>
595 format!("({})", assignment_targets_sql(&targets.targets)?),
596 },
597 render_expr(expression)?
598 ))
599 })
600 .collect::<Result<Vec<_>, SQLError>>()?
601 .join(", "))
602}
603
604fn projections_sql(projections: &[Projection]) -> Result<String, SQLError> {
605 projections_sql_in(projections, &[])
606}
607
608fn projections_sql_in(
609 projections: &[Projection],
610 windows: &[WindowDefinition],
611) -> Result<String, SQLError> {
612 Ok(projections
613 .iter()
614 .map(|projection| {
615 let mut rendered = render_expr_in(&projection.expr, windows)?;
616 if let Some(alias) = &projection.alias {
617 rendered.push_str(" AS ");
618 rendered.push_str(&ident(alias));
619 }
620 Ok(rendered)
621 })
622 .collect::<Result<Vec<_>, SQLError>>()?
623 .join(", "))
624}
625
626fn order_by_sql(order_by: &[OrderBy]) -> Result<String, SQLError> {
627 order_by_sql_in(order_by, &[])
628}
629
630fn order_by_sql_in(order_by: &[OrderBy], windows: &[WindowDefinition]) -> Result<String, SQLError> {
631 Ok(order_by
632 .iter()
633 .map(|order| {
634 let mut rendered = render_expr_in(&order.expr, windows)?;
635 if order.descending {
636 rendered.push_str(" DESC");
637 }
638 match order.nulls {
639 Some(NullsOrder::First) => rendered.push_str(" NULLS FIRST"),
640 Some(NullsOrder::Last) => rendered.push_str(" NULLS LAST"),
641 None => {}
642 }
643 Ok(rendered)
644 })
645 .collect::<Result<Vec<_>, SQLError>>()?
646 .join(", "))
647}
648
649fn rows_sql(rows: &[Vec<Expr>]) -> Result<String, SQLError> {
650 Ok(rows
651 .iter()
652 .map(|row| Ok(format!("({})", expr_list(row)?)))
653 .collect::<Result<Vec<_>, SQLError>>()?
654 .join(", "))
655}
656
657fn expr_list(expressions: &[Expr]) -> Result<String, SQLError> {
658 expr_list_in(expressions, &[])
659}
660
661fn expr_list_in(expressions: &[Expr], windows: &[WindowDefinition]) -> Result<String, SQLError> {
662 Ok(expressions
663 .iter()
664 .map(|expression| render_expr_in(expression, windows))
665 .collect::<Result<Vec<_>, _>>()?
666 .join(", "))
667}
668
669fn only_relation(name: &str, include_descendants: bool) -> String {
670 if include_descendants {
671 name.to_string()
672 } else {
673 format!("ONLY {name}")
674 }
675}
676
677fn ident_list(names: &[String]) -> String {
678 names
679 .iter()
680 .map(|name| ident(name))
681 .collect::<Vec<_>>()
682 .join(", ")
683}
684
685fn ident(name: &str) -> String {
686 crate::expr::quote_ident(name)
687}
688
689fn relation_local_name(name: &str) -> &str {
690 let mut quoted = false;
691 let mut last_dot = None;
692 let bytes = name.as_bytes();
693 let mut position = 0;
694 while position < bytes.len() {
695 match bytes[position] {
696 b'"' if quoted && bytes.get(position + 1) == Some(&b'"') => position += 2,
697 b'"' => {
698 quoted = !quoted;
699 position += 1;
700 }
701 b'.' if !quoted => {
702 last_dot = Some(position);
703 position += 1;
704 }
705 _ => position += 1,
706 }
707 }
708 let component = &name[last_dot.map_or(0, |dot| dot + 1)..];
709 component
710 .strip_prefix('"')
711 .and_then(|component| component.strip_suffix('"'))
712 .unwrap_or(component)
713}
714
715fn string_literal(value: &str) -> String {
716 format!("'{}'", value.replace('\'', "''"))
717}
718
719fn value_sql(value: &Value) -> Result<String, SQLError> {
720 Ok(match value {
721 Value::Datum(value) => return value_sql(&crate::expr::datums::read(value)?),
722 Value::Null => "NULL".into(),
723 Value::Void => "''::void".into(),
724 Value::Bool(value) => if *value { "true" } else { "false" }.into(),
725 Value::Int(value) => value.to_string(),
726 Value::Float(value) if value.is_finite() => value.to_string(),
727 Value::Float(value) => format!("{}::double precision", string_literal(&value.to_string())),
728 Value::Str(value) => string_literal(value),
729 Value::BitString(_) => {
730 format!("B{}", string_literal(&crate::expr::value_to_string(value)?))
731 }
732 Value::Enum(value) => return Err(crate::expr::catalog_output_required(value)),
733 Value::FixedChar(value) => format!("{}::character", string_literal(value)),
734 Value::Bytes(value) => {
735 let mut hex = String::new();
736 for byte in value {
737 write!(&mut hex, "{byte:02x}").expect("writing to a String cannot fail");
738 }
739 format!("{}::bytea", string_literal(&format!("\\x{hex}")))
740 }
741 Value::Temporal(value) => {
742 let ty = match value {
743 TemporalValue::Date { .. } => "date",
744 TemporalValue::Time { .. } => "time",
745 TemporalValue::TimeTz { .. } => "time with time zone",
746 TemporalValue::Timestamp { .. } => "timestamp",
747 TemporalValue::TimestampTz { .. } => "timestamp with time zone",
748 TemporalValue::Interval { .. } => "interval",
749 };
750 format!("{}::{ty}", string_literal(&value.to_sql_string()))
751 }
752 Value::Decimal(value) if value.is_nan() || value.is_infinite() => {
753 format!("{}::numeric", string_literal(&value.to_sql_string()))
754 }
755 Value::Decimal(value) => format!("{}::numeric", value.to_sql_string()),
756 Value::Json(value) => format!("{}::json", string_literal(value)),
757 Value::JsonB(value) => format!("{}::jsonb", string_literal(value)),
758 Value::LegacyVector(vector) => legacy_vector_expression(vector)?,
759 Value::Array(array) => format!(
760 "ARRAY[{}]",
761 array
762 .elements()
763 .iter()
764 .map(value_sql)
765 .collect::<Result<Vec<_>, _>>()?
766 .join(", ")
767 ),
768 Value::List(values) => format!(
769 "ARRAY[{}]",
770 values
771 .iter()
772 .map(value_sql)
773 .collect::<Result<Vec<_>, _>>()?
774 .join(", ")
775 ),
776 Value::Row(values) => format!(
777 "ROW({})",
778 values
779 .iter()
780 .map(value_sql)
781 .collect::<Result<Vec<_>, _>>()?
782 .join(", ")
783 ),
784 Value::Record(fields) => format!(
785 "ROW({})",
786 fields
787 .iter()
788 .map(|(_, value)| value_sql(value))
789 .collect::<Result<Vec<_>, _>>()?
790 .join(", ")
791 ),
792 Value::Map(value) => format!(
793 "{}::jsonb",
794 string_literal(&serde_json::to_string(value).map_err(|error| {
795 SQLError::Internal(format!("serialize map literal as jsonb: {error}"))
796 })?)
797 ),
798 })
799}
800
801#[cfg(test)]
802mod tests;