Skip to main content

uqa_sql/
render.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Stable SQL rendering for compiler-owned statement trees.
8
9use 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
48/// Render one executable statement represented by UQA's durable SQL AST.
49pub 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
70/// Render one compiler-owned scalar expression without consulting runtime state.
71pub 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
363/// A table function call whose operator-join relations precede the operands bound to them.
364fn 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;