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 comma,
212 left,
213 right,
214 kind,
215 on,
216 using,
217 natural,
218 alias,
219 column_aliases,
220 lateral,
221 } => {
222 if *comma {
223 let permission = if *lateral && !right.is_explicitly_lateral() {
224 "LATERAL "
225 } else {
226 ""
227 };
228 return Ok(format!(
229 "{}, {permission}{}",
230 from_sql(left)?,
231 from_sql(right)?
232 ));
233 }
234 let mut rendered = String::from("(");
235 rendered.push_str(&from_sql(left)?);
236 rendered.push(' ');
237 if *natural {
238 rendered.push_str("NATURAL ");
239 }
240 rendered.push_str(match kind {
241 JoinKind::Inner if on.is_none() && using.is_none() && !*natural => "CROSS JOIN",
242 JoinKind::Inner => "JOIN",
243 JoinKind::Left => "LEFT JOIN",
244 JoinKind::Right => "RIGHT JOIN",
245 JoinKind::Full => "FULL JOIN",
246 JoinKind::Cross => "CROSS JOIN",
247 });
248 rendered.push(' ');
249 if *lateral && !right.is_explicitly_lateral() {
250 rendered.push_str("LATERAL ");
251 }
252 rendered.push_str(&from_sql(right)?);
253 if let Some(predicate) = on {
254 rendered.push_str(" ON ");
255 rendered.push_str(&render_expr(predicate)?);
256 } else if let Some(using) = using {
257 rendered.push_str(" USING (");
258 rendered.push_str(&ident_list(&using.columns));
259 rendered.push(')');
260 if let Some(alias) = &using.alias {
261 rendered.push_str(" AS ");
262 rendered.push_str(&ident(alias));
263 }
264 }
265 rendered.push(')');
266 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
267 rendered
268 }
269 FromClause::Values {
270 lateral,
271 rows,
272 alias,
273 column_aliases,
274 ..
275 } => {
276 let mut rendered = format!(
277 "{}(VALUES {})",
278 if *lateral { "LATERAL " } else { "" },
279 rows_sql(rows)?
280 );
281 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
282 rendered
283 }
284 FromClause::Function {
285 name,
286 output_name: _,
287 relations,
288 args,
289 alias,
290 column_aliases,
291 ordinality,
292 column_types,
293 ..
294 } => {
295 let mut rendered = table_function_call_sql(name, relations.as_ref(), args)?;
296 if *ordinality {
297 rendered.push_str(" WITH ORDINALITY");
298 }
299 render_function_alias(
300 &mut rendered,
301 alias.as_deref(),
302 column_aliases,
303 column_types,
304 );
305 rendered
306 }
307 FromClause::FunctionGroup {
308 functions,
309 alias,
310 column_aliases,
311 ordinality,
312 } => {
313 let mut rendered = format!(
314 "ROWS FROM ({})",
315 functions
316 .iter()
317 .map(table_function_sql)
318 .collect::<Result<Vec<_>, _>>()?
319 .join(", ")
320 );
321 if *ordinality {
322 rendered.push_str(" WITH ORDINALITY");
323 }
324 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
325 rendered
326 }
327 FromClause::Subquery {
328 lateral,
329 body,
330 alias,
331 column_aliases,
332 } => {
333 let mut rendered = format!(
334 "{}({})",
335 if *lateral { "LATERAL " } else { "" },
336 select_sql(body)?
337 );
338 render_relation_alias(&mut rendered, alias.as_deref(), column_aliases);
339 rendered
340 }
341 })
342}
343
344fn table_function_sql(function: &TableFunction) -> Result<String, SQLError> {
345 let mut rendered =
346 table_function_call_sql(&function.name, function.relations.as_ref(), &function.args)?;
347 if !function.column_types.is_empty() {
348 rendered.push_str(" AS (");
349 rendered.push_str(
350 &function
351 .column_aliases
352 .iter()
353 .zip(&function.column_types)
354 .map(|(name, ty)| format!("{} {ty}", ident(name)))
355 .collect::<Vec<_>>()
356 .join(", "),
357 );
358 rendered.push(')');
359 }
360 Ok(rendered)
361}
362
363fn table_function_call_sql(
365 name: &str,
366 relations: Option<&OperatorJoinRelations>,
367 args: &[Expr],
368) -> Result<String, SQLError> {
369 let mut arguments = args
370 .iter()
371 .map(render_expr)
372 .collect::<Result<Vec<_>, _>>()?;
373 if let Some(relations) = relations {
374 if arguments.is_empty() {
375 return Err(SQLError::Internal(format!(
376 "operator join table function `{name}` has no left operand"
377 )));
378 }
379 arguments.insert(0, relations.left.clone());
380 arguments.insert(2, relations.right.clone());
381 }
382 Ok(format!("{name}({})", arguments.join(", ")))
383}
384
385fn with_sql(ctes: &[CTE]) -> Result<String, SQLError> {
386 if ctes.is_empty() {
387 return Ok(String::new());
388 }
389 let recursive = ctes.iter().any(|cte| cte.recursive);
390 Ok(format!(
391 "WITH {}{} ",
392 if recursive { "RECURSIVE " } else { "" },
393 ctes.iter()
394 .map(cte_sql)
395 .collect::<Result<Vec<_>, _>>()?
396 .join(", ")
397 ))
398}
399
400fn cte_sql(cte: &CTE) -> Result<String, SQLError> {
401 let mut rendered = ident(&cte.name);
402 if !cte.columns.is_empty() {
403 rendered.push_str(" (");
404 rendered.push_str(&ident_list(&cte.columns));
405 rendered.push(')');
406 }
407 rendered.push_str(" AS ");
408 rendered.push_str(match cte.materialization {
409 CteMaterialization::Default => "",
410 CteMaterialization::Materialized => "MATERIALIZED ",
411 CteMaterialization::NotMaterialized => "NOT MATERIALIZED ",
412 });
413 rendered.push('(');
414 rendered.push_str(&match &cte.body {
415 CteBody::Query(query) => select_sql(query),
416 CteBody::Insert(command) => insert_sql(command),
417 CteBody::Update(command) => update_sql(command),
418 CteBody::Delete(command) => delete_sql(command),
419 CteBody::Merge(command) => merge_sql(command),
420 }?);
421 rendered.push(')');
422 if let Some(search) = &cte.search {
423 write!(
424 &mut rendered,
425 " SEARCH {} FIRST BY {} SET {}",
426 if search.breadth_first {
427 "BREADTH"
428 } else {
429 "DEPTH"
430 },
431 ident_list(&search.columns),
432 ident(&search.sequence_column)
433 )
434 .expect("writing to a String cannot fail");
435 }
436 if let Some(cycle) = &cte.cycle {
437 write!(
438 &mut rendered,
439 " CYCLE {} SET {} TO {} DEFAULT {} USING {}",
440 ident_list(&cycle.columns),
441 ident(&cycle.mark_column),
442 render_expr(&cycle.mark_value)?,
443 render_expr(&cycle.mark_default)?,
444 ident(&cycle.path_column)
445 )
446 .expect("writing to a String cannot fail");
447 }
448 Ok(rendered)
449}
450
451fn render_order_limit_offset(
452 rendered: &mut String,
453 order_by: &[OrderBy],
454 limit: Option<&Expr>,
455 with_ties: bool,
456 offset: Option<&Expr>,
457) -> Result<(), SQLError> {
458 render_order_limit_offset_in(rendered, order_by, limit, with_ties, offset, &[])
459}
460
461fn render_order_limit_offset_in(
462 rendered: &mut String,
463 order_by: &[OrderBy],
464 limit: Option<&Expr>,
465 with_ties: bool,
466 offset: Option<&Expr>,
467 windows: &[WindowDefinition],
468) -> Result<(), SQLError> {
469 if !order_by.is_empty() {
470 rendered.push_str(" ORDER BY ");
471 rendered.push_str(&order_by_sql_in(order_by, windows)?);
472 }
473 if with_ties {
474 if let Some(offset) = offset {
475 rendered.push_str(" OFFSET ");
476 rendered.push_str(&render_expr_in(offset, windows)?);
477 }
478 if let Some(limit) = limit {
479 rendered.push_str(" FETCH FIRST ");
480 rendered.push_str(&render_expr_in(limit, windows)?);
481 rendered.push_str(" ROWS WITH TIES");
482 }
483 } else {
484 if let Some(limit) = limit {
485 rendered.push_str(" LIMIT ");
486 rendered.push_str(&render_expr_in(limit, windows)?);
487 }
488 if let Some(offset) = offset {
489 rendered.push_str(" OFFSET ");
490 rendered.push_str(&render_expr_in(offset, windows)?);
491 }
492 }
493 Ok(())
494}
495
496fn render_returning(
497 rendered: &mut String,
498 aliases: &ReturningAliases,
499 projections: &[Projection],
500) -> Result<(), SQLError> {
501 if projections.is_empty() {
502 return Ok(());
503 }
504 rendered.push_str(" RETURNING ");
505 if aliases.old_explicit || aliases.new_explicit {
506 rendered.push_str("WITH (");
507 let mut names = Vec::new();
508 if aliases.old_explicit {
509 names.push(format!("OLD AS {}", ident(&aliases.old)));
510 }
511 if aliases.new_explicit {
512 names.push(format!("NEW AS {}", ident(&aliases.new)));
513 }
514 rendered.push_str(&names.join(", "));
515 rendered.push_str(") ");
516 }
517 rendered.push_str(&projections_sql(projections)?);
518 Ok(())
519}
520
521fn render_target_alias(rendered: &mut String, relation: &str, qualifier: &str) {
522 if relation_local_name(relation) != qualifier {
523 rendered.push_str(" AS ");
524 rendered.push_str(&ident(qualifier));
525 }
526}
527
528fn render_relation_alias(rendered: &mut String, alias: Option<&str>, columns: &[String]) {
529 if let Some(alias) = alias {
530 rendered.push_str(" AS ");
531 rendered.push_str(&ident(alias));
532 if !columns.is_empty() {
533 rendered.push('(');
534 rendered.push_str(&ident_list(columns));
535 rendered.push(')');
536 }
537 }
538}
539
540fn render_function_alias(
541 rendered: &mut String,
542 alias: Option<&str>,
543 columns: &[String],
544 types: &[String],
545) {
546 if let Some(alias) = alias {
547 rendered.push_str(" AS ");
548 rendered.push_str(&ident(alias));
549 } else if !types.is_empty() {
550 rendered.push_str(" AS");
551 }
552 if !types.is_empty() {
553 rendered.push_str(" (");
554 rendered.push_str(
555 &columns
556 .iter()
557 .zip(types)
558 .map(|(name, ty)| format!("{} {ty}", ident(name)))
559 .collect::<Vec<_>>()
560 .join(", "),
561 );
562 rendered.push(')');
563 } else if !columns.is_empty() {
564 rendered.push('(');
565 rendered.push_str(&ident_list(columns));
566 rendered.push(')');
567 }
568}
569
570fn assignment_target_sql(target: &crate::ast::AssignmentTarget) -> Result<String, SQLError> {
571 use crate::ast::AssignmentStep;
572 let mut sql = ident(&target.column);
573 for step in &target.indirection {
574 match step {
575 AssignmentStep::Field(field) => {
576 sql.push('.');
577 sql.push_str(&ident(field));
578 }
579 AssignmentStep::Index(index) => {
580 sql.push('[');
581 sql.push_str(&render_expr(index)?);
582 sql.push(']');
583 }
584 AssignmentStep::Slice { lower, upper } => {
585 sql.push('[');
586 if let Some(lower) = lower {
587 sql.push_str(&render_expr(lower)?);
588 }
589 sql.push(':');
590 if let Some(upper) = upper {
591 sql.push_str(&render_expr(upper)?);
592 }
593 sql.push(']');
594 }
595 }
596 }
597 Ok(sql)
598}
599
600fn assignment_targets_sql(targets: &[crate::ast::AssignmentTarget]) -> Result<String, SQLError> {
601 Ok(targets
602 .iter()
603 .map(assignment_target_sql)
604 .collect::<Result<Vec<_>, _>>()?
605 .join(", "))
606}
607
608fn assignments_sql(
609 assignments: &[(crate::ast::AssignmentTargets, Expr)],
610) -> Result<String, SQLError> {
611 Ok(assignments
612 .iter()
613 .map(|(target, expression)| {
614 Ok(format!(
615 "{} = {}",
616 match target {
617 crate::ast::AssignmentTargets::Single(target) => assignment_target_sql(target)?,
618 crate::ast::AssignmentTargets::Multiple(targets) =>
619 format!("({})", assignment_targets_sql(&targets.targets)?),
620 },
621 render_expr(expression)?
622 ))
623 })
624 .collect::<Result<Vec<_>, SQLError>>()?
625 .join(", "))
626}
627
628fn projections_sql(projections: &[Projection]) -> Result<String, SQLError> {
629 projections_sql_in(projections, &[])
630}
631
632fn projections_sql_in(
633 projections: &[Projection],
634 windows: &[WindowDefinition],
635) -> Result<String, SQLError> {
636 Ok(projections
637 .iter()
638 .map(|projection| {
639 let mut rendered = render_expr_in(&projection.expr, windows)?;
640 if let Some(alias) = &projection.alias {
641 rendered.push_str(" AS ");
642 rendered.push_str(&ident(alias));
643 }
644 Ok(rendered)
645 })
646 .collect::<Result<Vec<_>, SQLError>>()?
647 .join(", "))
648}
649
650fn order_by_sql(order_by: &[OrderBy]) -> Result<String, SQLError> {
651 order_by_sql_in(order_by, &[])
652}
653
654fn order_by_sql_in(order_by: &[OrderBy], windows: &[WindowDefinition]) -> Result<String, SQLError> {
655 Ok(order_by
656 .iter()
657 .map(|order| {
658 let mut rendered = render_expr_in(&order.expr, windows)?;
659 if order.descending {
660 rendered.push_str(" DESC");
661 }
662 match order.nulls {
663 Some(NullsOrder::First) => rendered.push_str(" NULLS FIRST"),
664 Some(NullsOrder::Last) => rendered.push_str(" NULLS LAST"),
665 None => {}
666 }
667 Ok(rendered)
668 })
669 .collect::<Result<Vec<_>, SQLError>>()?
670 .join(", "))
671}
672
673fn rows_sql(rows: &[Vec<Expr>]) -> Result<String, SQLError> {
674 Ok(rows
675 .iter()
676 .map(|row| Ok(format!("({})", expr_list(row)?)))
677 .collect::<Result<Vec<_>, SQLError>>()?
678 .join(", "))
679}
680
681fn expr_list(expressions: &[Expr]) -> Result<String, SQLError> {
682 expr_list_in(expressions, &[])
683}
684
685fn expr_list_in(expressions: &[Expr], windows: &[WindowDefinition]) -> Result<String, SQLError> {
686 Ok(expressions
687 .iter()
688 .map(|expression| render_expr_in(expression, windows))
689 .collect::<Result<Vec<_>, _>>()?
690 .join(", "))
691}
692
693fn only_relation(name: &str, include_descendants: bool) -> String {
694 if include_descendants {
695 name.to_string()
696 } else {
697 format!("ONLY {name}")
698 }
699}
700
701fn ident_list(names: &[String]) -> String {
702 names
703 .iter()
704 .map(|name| ident(name))
705 .collect::<Vec<_>>()
706 .join(", ")
707}
708
709fn ident(name: &str) -> String {
710 crate::expr::quote_ident(name)
711}
712
713fn relation_local_name(name: &str) -> &str {
714 let mut quoted = false;
715 let mut last_dot = None;
716 let bytes = name.as_bytes();
717 let mut position = 0;
718 while position < bytes.len() {
719 match bytes[position] {
720 b'"' if quoted && bytes.get(position + 1) == Some(&b'"') => position += 2,
721 b'"' => {
722 quoted = !quoted;
723 position += 1;
724 }
725 b'.' if !quoted => {
726 last_dot = Some(position);
727 position += 1;
728 }
729 _ => position += 1,
730 }
731 }
732 let component = &name[last_dot.map_or(0, |dot| dot + 1)..];
733 component
734 .strip_prefix('"')
735 .and_then(|component| component.strip_suffix('"'))
736 .unwrap_or(component)
737}
738
739fn string_literal(value: &str) -> String {
740 format!("'{}'", value.replace('\'', "''"))
741}
742
743fn value_sql(value: &Value) -> Result<String, SQLError> {
744 Ok(match value {
745 Value::Datum(value) => return value_sql(&crate::expr::datums::read(value)?),
746 Value::Null => "NULL".into(),
747 Value::Void => "''::void".into(),
748 Value::Bool(value) => if *value { "true" } else { "false" }.into(),
749 Value::Int(value) => value.to_string(),
750 Value::Float(value) if value.is_finite() => value.to_string(),
751 Value::Float(value) => format!("{}::double precision", string_literal(&value.to_string())),
752 Value::Str(value) => string_literal(value),
753 Value::BitString(_) => {
754 format!("B{}", string_literal(&crate::expr::value_to_string(value)?))
755 }
756 Value::Enum(value) => return Err(crate::expr::catalog_output_required(value)),
757 Value::FixedChar(value) => format!("{}::character", string_literal(value)),
758 Value::Bytes(value) => {
759 let mut hex = String::new();
760 for byte in value {
761 write!(&mut hex, "{byte:02x}").expect("writing to a String cannot fail");
762 }
763 format!("{}::bytea", string_literal(&format!("\\x{hex}")))
764 }
765 Value::Temporal(value) => {
766 let ty = match value {
767 TemporalValue::Date { .. } => "date",
768 TemporalValue::Time { .. } => "time",
769 TemporalValue::TimeTz { .. } => "time with time zone",
770 TemporalValue::Timestamp { .. } => "timestamp",
771 TemporalValue::TimestampTz { .. } => "timestamp with time zone",
772 TemporalValue::Interval { .. } => "interval",
773 };
774 format!("{}::{ty}", string_literal(&value.to_sql_string()))
775 }
776 Value::Decimal(value) if value.is_nan() || value.is_infinite() => {
777 format!("{}::numeric", string_literal(&value.to_sql_string()))
778 }
779 Value::Decimal(value) => format!("{}::numeric", value.to_sql_string()),
780 Value::Json(value) => format!("{}::json", string_literal(value)),
781 Value::JsonB(value) => format!("{}::jsonb", string_literal(value)),
782 Value::LegacyVector(vector) => legacy_vector_expression(vector)?,
783 Value::Array(array) => format!(
784 "ARRAY[{}]",
785 array
786 .elements()
787 .iter()
788 .map(value_sql)
789 .collect::<Result<Vec<_>, _>>()?
790 .join(", ")
791 ),
792 Value::List(values) => format!(
793 "ARRAY[{}]",
794 values
795 .iter()
796 .map(value_sql)
797 .collect::<Result<Vec<_>, _>>()?
798 .join(", ")
799 ),
800 Value::Row(values) => format!(
801 "ROW({})",
802 values
803 .iter()
804 .map(value_sql)
805 .collect::<Result<Vec<_>, _>>()?
806 .join(", ")
807 ),
808 Value::Record(fields) => format!(
809 "ROW({})",
810 fields
811 .iter()
812 .map(|(_, value)| value_sql(value))
813 .collect::<Result<Vec<_>, _>>()?
814 .join(", ")
815 ),
816 Value::Map(value) => format!(
817 "{}::jsonb",
818 string_literal(&serde_json::to_string(value).map_err(|error| {
819 SQLError::Internal(format!("serialize map literal as jsonb: {error}"))
820 })?)
821 ),
822 })
823}
824
825#[cfg(test)]
826mod tests;