bqsqlparse 0.1.0__py3-none-any.whl

bqsqlparse/unparse.py

@@ -0,0 +1,766 @@
+"""SQL generation (AST -> BigQuery SQL text)."""
+
+from __future__ import annotations
+
+from functools import singledispatch
+from typing import List
+
+from . import nodes as n
+from .lexer import RESERVED
+
+_SAFE_IDENT_CHARS = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")
+
+
+def _ident(name: str) -> str:
+    if (
+        name
+        and all(c in _SAFE_IDENT_CHARS for c in name)
+        and not name[0].isdigit()
+        and name.upper() not in RESERVED
+    ):
+        return name
+    return f"`{name}`"
+
+
+def _path(parts: List[str]) -> str:
+    return ".".join(_ident(p) for p in parts)
+
+
+def _str_lit(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace("'", "\\'").replace("\n", "\\n")
+    return f"'{escaped}'"
+
+
+def to_sql(node: "n.Node") -> str:
+    """Render an AST node back to BigQuery SQL."""
+    return _sql(node)
+
+
+@singledispatch
+def _sql(node) -> str:
+    raise TypeError(f"Cannot generate SQL for {type(node).__name__}")
+
+
+# ------------------------------------------------------------------- literals
+
+@_sql.register(n.Literal)
+def _(node: n.Literal) -> str:
+    if node.kind == "null":
+        return "NULL"
+    if node.kind == "default":
+        return "DEFAULT"
+    if node.kind == "bool":
+        return "TRUE" if node.value else "FALSE"
+    if node.kind == "number":
+        return str(node.value)
+    if node.kind == "bytes":
+        return "b" + _str_lit(str(node.value))
+    return _str_lit(str(node.value))
+
+
+@_sql.register(n.TypedLiteral)
+def _(node: n.TypedLiteral) -> str:
+    return f"{node.type_name} {_str_lit(node.value)}"
+
+
+@_sql.register(n.ColumnRef)
+def _(node: n.ColumnRef) -> str:
+    return _path(node.path)
+
+
+@_sql.register(n.Param)
+def _(node: n.Param) -> str:
+    return node.name
+
+
+@_sql.register(n.Star)
+def _(node: n.Star) -> str:
+    out = (_path(node.prefix) + "." if node.prefix else "") + "*"
+    if node.except_:
+        out += f" EXCEPT ({', '.join(_ident(c) for c in node.except_)})"
+    if node.replace:
+        items = ", ".join(f"{_sql(r.expr)} AS {_ident(r.name)}" for r in node.replace)
+        out += f" REPLACE ({items})"
+    return out
+
+
+# ---------------------------------------------------------------- expressions
+
+@_sql.register(n.BinaryOp)
+def _(node: n.BinaryOp) -> str:
+    return f"{_sql(node.left)} {node.op} {_sql(node.right)}"
+
+
+@_sql.register(n.UnaryOp)
+def _(node: n.UnaryOp) -> str:
+    if node.op == "NOT":
+        return f"NOT {_sql(node.operand)}"
+    return f"{node.op}{_sql(node.operand)}"
+
+
+@_sql.register(n.Between)
+def _(node: n.Between) -> str:
+    neg = "NOT " if node.negated else ""
+    return f"{_sql(node.expr)} {neg}BETWEEN {_sql(node.low)} AND {_sql(node.high)}"
+
+
+@_sql.register(n.InExpr)
+def _(node: n.InExpr) -> str:
+    neg = "NOT " if node.negated else ""
+    if node.unnest is not None:
+        return f"{_sql(node.expr)} {neg}IN UNNEST({_sql(node.unnest)})"
+    if node.query is not None:
+        return f"{_sql(node.expr)} {neg}IN ({_sql(node.query)})"
+    vals = ", ".join(_sql(v) for v in node.values or [])
+    return f"{_sql(node.expr)} {neg}IN ({vals})"
+
+
+@_sql.register(n.LikeExpr)
+def _(node: n.LikeExpr) -> str:
+    neg = "NOT " if node.negated else ""
+    if node.quantifier:
+        pats = ", ".join(_sql(p) for p in node.patterns)
+        return f"{_sql(node.expr)} {neg}LIKE {node.quantifier} ({pats})"
+    return f"{_sql(node.expr)} {neg}LIKE {_sql(node.patterns[0])}"
+
+
+@_sql.register(n.IsExpr)
+def _(node: n.IsExpr) -> str:
+    neg = "NOT " if node.negated else ""
+    return f"{_sql(node.expr)} IS {neg}{node.value}"
+
+
+@_sql.register(n.Case)
+def _(node: n.Case) -> str:
+    parts = ["CASE"]
+    if node.operand is not None:
+        parts.append(_sql(node.operand))
+    for w in node.whens:
+        parts.append(f"WHEN {_sql(w.condition)} THEN {_sql(w.result)}")
+    if node.else_ is not None:
+        parts.append(f"ELSE {_sql(node.else_)}")
+    parts.append("END")
+    return " ".join(parts)
+
+
+@_sql.register(n.Cast)
+def _(node: n.Cast) -> str:
+    fn = "SAFE_CAST" if node.safe else "CAST"
+    fmt = f" FORMAT {_sql(node.format)}" if node.format is not None else ""
+    return f"{fn}({_sql(node.expr)} AS {_sql(node.to_type)}{fmt})"
+
+
+@_sql.register(n.Extract)
+def _(node: n.Extract) -> str:
+    tz = f" AT TIME ZONE {_sql(node.at_time_zone)}" if node.at_time_zone is not None else ""
+    return f"EXTRACT({node.part} FROM {_sql(node.expr)}{tz})"
+
+
+@_sql.register(n.IntervalExpr)
+def _(node: n.IntervalExpr) -> str:
+    to = f" TO {node.to_unit}" if node.to_unit else ""
+    return f"INTERVAL {_sql(node.value)} {node.unit}{to}"
+
+
+@_sql.register(n.ArrayExpr)
+def _(node: n.ArrayExpr) -> str:
+    prefix = f"ARRAY<{_sql(node.elem_type)}>" if node.elem_type is not None else ""
+    return f"{prefix}[{', '.join(_sql(e) for e in node.elements)}]"
+
+
+@_sql.register(n.StructExpr)
+def _(node: n.StructExpr) -> str:
+    prefix = "STRUCT"
+    if node.type_fields is not None:
+        inner = ", ".join(
+            (f"{_ident(f.name)} " if f.name else "") + _sql(f.type)
+            for f in node.type_fields
+        )
+        prefix = f"STRUCT<{inner}>"
+    fields = ", ".join(
+        _sql(f.expr) + (f" AS {_ident(f.name)}" if f.name else "")
+        for f in node.fields_
+    )
+    if node.type_fields is None and prefix == "STRUCT":
+        return f"STRUCT({fields})"
+    return f"{prefix}({fields})"
+
+
+@_sql.register(n.Subscript)
+def _(node: n.Subscript) -> str:
+    if node.mode:
+        return f"{_sql(node.base)}[{node.mode}({_sql(node.index)})]"
+    return f"{_sql(node.base)}[{_sql(node.index)}]"
+
+
+@_sql.register(n.FieldAccess)
+def _(node: n.FieldAccess) -> str:
+    return f"{_sql(node.base)}.{_ident(node.field_name)}"
+
+
+@_sql.register(n.NamedArg)
+def _(node: n.NamedArg) -> str:
+    return f"{node.name} => {_sql(node.value)}"
+
+
+@_sql.register(n.FuncCall)
+def _(node: n.FuncCall) -> str:
+    name = ".".join(node.name)
+    if not node.args and not node.distinct and node.name_str in (
+        "CURRENT_DATE", "CURRENT_DATETIME", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+    ) and node.over is None:
+        return name
+    parts = []
+    if node.distinct:
+        parts.append("DISTINCT")
+    parts.append(", ".join(_sql(a) for a in node.args))
+    if node.nulls:
+        parts.append(f"{node.nulls} NULLS")
+    if node.having is not None:
+        parts.append(f"HAVING {node.having.kind} {_sql(node.having.expr)}")
+    if node.order_by:
+        parts.append("ORDER BY " + ", ".join(_sql(o) for o in node.order_by))
+    if node.limit is not None:
+        parts.append(f"LIMIT {_sql(node.limit)}")
+    body = " ".join(p for p in parts if p)
+    out = f"{name}({body})"
+    if node.over is not None:
+        if node.over.is_ref:
+            out += f" OVER {node.over.name}"
+        else:
+            out += f" OVER ({_window_body(node.over)})"
+    return out
+
+
+def _window_body(spec: "n.WindowSpec") -> str:
+    parts = []
+    if spec.name:
+        parts.append(spec.name)
+    if spec.partition_by:
+        parts.append("PARTITION BY " + ", ".join(_sql(e) for e in spec.partition_by))
+    if spec.order_by:
+        parts.append("ORDER BY " + ", ".join(_sql(o) for o in spec.order_by))
+    if spec.frame is not None:
+        f = spec.frame
+        if f.end is not None:
+            parts.append(f"{f.unit} BETWEEN {_bound(f.start)} AND {_bound(f.end)}")
+        else:
+            parts.append(f"{f.unit} {_bound(f.start)}")
+    return " ".join(parts)
+
+
+def _bound(b: "n.FrameBound") -> str:
+    if b.value is not None:
+        return f"{_sql(b.value)} {b.kind}"
+    return b.kind
+
+
+@_sql.register(n.OrderItem)
+def _(node: n.OrderItem) -> str:
+    out = _sql(node.expr)
+    if node.desc is True:
+        out += " DESC"
+    elif node.desc is False:
+        out += " ASC"
+    if node.nulls:
+        out += f" NULLS {node.nulls}"
+    return out
+
+
+@_sql.register(n.ScalarSubquery)
+def _(node: n.ScalarSubquery) -> str:
+    return f"({_sql(node.query)})"
+
+
+@_sql.register(n.ArraySubquery)
+def _(node: n.ArraySubquery) -> str:
+    return f"ARRAY({_sql(node.query)})"
+
+
+@_sql.register(n.ExistsSubquery)
+def _(node: n.ExistsSubquery) -> str:
+    return f"EXISTS ({_sql(node.query)})"
+
+
+# ---------------------------------------------------------------------- types
+
+@_sql.register(n.TypeNode)
+def _(node: n.TypeNode) -> str:
+    if node.name == "ARRAY" and node.element is not None:
+        return f"ARRAY<{_sql(node.element)}>"
+    if node.name == "RANGE" and node.element is not None:
+        return f"RANGE<{_sql(node.element)}>"
+    if node.name == "STRUCT":
+        if not node.fields_:
+            return "STRUCT"
+        inner = ", ".join(
+            (f"{_ident(f.name)} " if f.name else "") + _sql(f.type)
+            for f in node.fields_
+        )
+        return f"STRUCT<{inner}>"
+    if node.params:
+        return f"{node.name}({', '.join(node.params)})"
+    return node.name
+
+
+# ---------------------------------------------------------------- query parts
+
+@_sql.register(n.SelectItem)
+def _(node: n.SelectItem) -> str:
+    out = _sql(node.expr)
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    return out
+
+
+@_sql.register(n.Select)
+def _(node: n.Select) -> str:
+    parts = ["SELECT"]
+    if node.distinct:
+        parts.append("DISTINCT")
+    if node.as_mode:
+        parts.append(f"AS {node.as_mode}")
+    parts.append(", ".join(_sql(i) for i in node.items))
+    if node.from_ is not None:
+        parts.append(f"FROM {_sql(node.from_)}")
+    if node.where is not None:
+        parts.append(f"WHERE {_sql(node.where)}")
+    if node.group_by is not None:
+        parts.append(_sql(node.group_by))
+    if node.having is not None:
+        parts.append(f"HAVING {_sql(node.having)}")
+    if node.qualify is not None:
+        parts.append(f"QUALIFY {_sql(node.qualify)}")
+    if node.windows:
+        wins = ", ".join(f"{w.name} AS ({_window_body(w.spec)})" for w in node.windows)
+        parts.append(f"WINDOW {wins}")
+    return " ".join(parts)
+
+
+@_sql.register(n.GroupBy)
+def _(node: n.GroupBy) -> str:
+    if node.kind == "all":
+        return "GROUP BY ALL"
+    if node.kind == "rollup":
+        return f"GROUP BY ROLLUP({', '.join(_sql(e) for e in node.exprs)})"
+    if node.kind == "cube":
+        return f"GROUP BY CUBE({', '.join(_sql(e) for e in node.exprs)})"
+    if node.kind == "sets":
+        sets = ", ".join("(" + ", ".join(_sql(e) for e in s) + ")" for s in node.sets)
+        return f"GROUP BY GROUPING SETS ({sets})"
+    return "GROUP BY " + ", ".join(_sql(e) for e in node.exprs)
+
+
+@_sql.register(n.SetOp)
+def _(node: n.SetOp) -> str:
+    mode = "ALL" if node.all else "DISTINCT"
+    return f"{_sql(node.left)} {node.op} {mode} {_sql(node.right)}"
+
+
+@_sql.register(n.Query)
+def _(node: n.Query) -> str:
+    parts = []
+    if node.ctes:
+        rec = "RECURSIVE " if node.recursive else ""
+        ctes = ", ".join(f"{_ident(c.name)} AS ({_sql(c.query)})" for c in node.ctes)
+        parts.append(f"WITH {rec}{ctes}")
+    body = _sql(node.body)
+    if isinstance(node.body, n.Query):
+        body = f"({body})"
+    parts.append(body)
+    if node.order_by:
+        parts.append("ORDER BY " + ", ".join(_sql(o) for o in node.order_by))
+    if node.limit is not None:
+        parts.append(f"LIMIT {_sql(node.limit)}")
+    if node.offset is not None:
+        parts.append(f"OFFSET {_sql(node.offset)}")
+    return " ".join(parts)
+
+
+# ----------------------------------------------------------------- FROM items
+
+@_sql.register(n.TableRef)
+def _(node: n.TableRef) -> str:
+    out = _path(node.path)
+    if node.system_time is not None:
+        out += f" FOR SYSTEM_TIME AS OF {_sql(node.system_time)}"
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    if node.sample is not None:
+        out += f" TABLESAMPLE {node.sample.method} ({_sql(node.sample.value)} {node.sample.unit})"
+    return out
+
+
+@_sql.register(n.SubqueryRef)
+def _(node: n.SubqueryRef) -> str:
+    out = f"({_sql(node.query)})"
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    return out
+
+
+@_sql.register(n.UnnestRef)
+def _(node: n.UnnestRef) -> str:
+    out = f"UNNEST({_sql(node.expr)})"
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    if node.with_offset:
+        out += " WITH OFFSET"
+        if node.offset_alias:
+            out += f" AS {_ident(node.offset_alias)}"
+    return out
+
+
+@_sql.register(n.TableFuncRef)
+def _(node: n.TableFuncRef) -> str:
+    out = f"{'.'.join(node.name)}({', '.join(_sql(a) for a in node.args)})"
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    return out
+
+
+@_sql.register(n.Join)
+def _(node: n.Join) -> str:
+    if node.kind == "CROSS" and node.on is None and not node.using:
+        return f"{_sql(node.left)} CROSS JOIN {_sql(node.right)}"
+    kw = "JOIN" if node.kind == "INNER" else f"{node.kind} JOIN"
+    out = f"{_sql(node.left)} {kw} {_sql(node.right)}"
+    if node.on is not None:
+        out += f" ON {_sql(node.on)}"
+    elif node.using:
+        out += f" USING ({', '.join(_ident(c) for c in node.using)})"
+    return out
+
+
+@_sql.register(n.PivotRef)
+def _(node: n.PivotRef) -> str:
+    aggs = ", ".join(
+        _sql(a.func) + (f" AS {_ident(a.alias)}" if a.alias else "")
+        for a in node.aggregates
+    )
+    vals = ", ".join(
+        _sql(v.value) + (f" AS {_ident(v.alias)}" if v.alias else "")
+        for v in node.in_values
+    )
+    out = f"{_sql(node.input)} PIVOT({aggs} FOR {_sql(node.for_col)} IN ({vals}))"
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    return out
+
+
+@_sql.register(n.UnpivotRef)
+def _(node: n.UnpivotRef) -> str:
+    nulls = ""
+    if node.include_nulls is True:
+        nulls = " INCLUDE NULLS"
+    elif node.include_nulls is False:
+        nulls = " EXCLUDE NULLS"
+    multi = len(node.value_columns) > 1
+    vcols = "(" + ", ".join(node.value_columns) + ")" if multi else node.value_columns[0]
+    groups = []
+    for g in node.groups:
+        cols = ", ".join(_path(c) for c in g.columns)
+        if multi:
+            cols = f"({cols})"
+        if g.label is not None:
+            cols += f" AS {_sql(g.label)}"
+        groups.append(cols)
+    out = (f"{_sql(node.input)} UNPIVOT{nulls}({vcols} FOR {node.name_column} "
+           f"IN ({', '.join(groups)}))")
+    if node.alias:
+        out += f" AS {_ident(node.alias)}"
+    return out
+
+
+# ----------------------------------------------------------------- statements
+
+@_sql.register(n.CreateTableAsSelect)
+def _(node: n.CreateTableAsSelect) -> str:
+    parts = ["CREATE"]
+    if node.replace:
+        parts.append("OR REPLACE")
+    if node.temp:
+        parts.append("TEMP")
+    parts.append(node.kind)
+    if node.if_not_exists:
+        parts.append("IF NOT EXISTS")
+    parts.append(_path(node.name))
+    if node.columns:
+        cols = ", ".join(
+            _ident(c.name) + (f" {_sql(c.type)}" if c.type is not None else "")
+            for c in node.columns
+        )
+        parts.append(f"({cols})")
+    if node.partition_by is not None:
+        parts.append(f"PARTITION BY {_sql(node.partition_by)}")
+    if node.cluster_by:
+        parts.append("CLUSTER BY " + ", ".join(_sql(e) for e in node.cluster_by))
+    if node.options_sql:
+        parts.append(f"OPTIONS{node.options_sql}")
+    if node.query is not None:
+        parts.append(f"AS {_sql(node.query)}")
+    return " ".join(parts)
+
+
+@_sql.register(n.InsertStmt)
+def _(node: n.InsertStmt) -> str:
+    parts = [f"INSERT INTO {_path(node.table)}"]
+    if node.columns:
+        parts.append("(" + ", ".join(_ident(c) for c in node.columns) + ")")
+    if node.values:
+        rows = ", ".join("(" + ", ".join(_sql(v) for v in row) + ")" for row in node.values)
+        parts.append(f"VALUES {rows}")
+    elif node.query is not None:
+        parts.append(_sql(node.query))
+    return " ".join(parts)
+
+
+@_sql.register(n.UpdateStmt)
+def _(node: n.UpdateStmt) -> str:
+    parts = [f"UPDATE {_path(node.table)}"]
+    if node.alias:
+        parts.append(f"AS {_ident(node.alias)}")
+    sets = ", ".join(f"{_path(a.target)} = {_sql(a.value)}" for a in node.assignments)
+    parts.append(f"SET {sets}")
+    if node.from_ is not None:
+        parts.append(f"FROM {_sql(node.from_)}")
+    if node.where is not None:
+        parts.append(f"WHERE {_sql(node.where)}")
+    return " ".join(parts)
+
+
+@_sql.register(n.DeleteStmt)
+def _(node: n.DeleteStmt) -> str:
+    parts = [f"DELETE FROM {_path(node.table)}"]
+    if node.alias:
+        parts.append(f"AS {_ident(node.alias)}")
+    if node.where is not None:
+        parts.append(f"WHERE {_sql(node.where)}")
+    return " ".join(parts)
+
+
+@_sql.register(n.MergeStmt)
+def _(node: n.MergeStmt) -> str:
+    parts = [f"MERGE INTO {_path(node.target)}"]
+    if node.alias:
+        parts.append(f"AS {_ident(node.alias)}")
+    parts.append(f"USING {_sql(node.source)}")
+    parts.append(f"ON {_sql(node.on)}")
+    for w in node.whens:
+        kind = {
+            "MATCHED": "WHEN MATCHED",
+            "NOT_MATCHED": "WHEN NOT MATCHED",
+            "NOT_MATCHED_BY_SOURCE": "WHEN NOT MATCHED BY SOURCE",
+        }[w.match_kind]
+        if w.condition is not None:
+            kind += f" AND {_sql(w.condition)}"
+        kind += " THEN "
+        if w.action_kind == "UPDATE":
+            sets = ", ".join(f"{_path(a.target)} = {_sql(a.value)}" for a in w.assignments)
+            kind += f"UPDATE SET {sets}"
+        elif w.action_kind == "DELETE":
+            kind += "DELETE"
+        elif w.action_kind == "INSERT_ROW":
+            kind += "INSERT ROW"
+        else:
+            cols = ""
+            if w.columns:
+                cols = "(" + ", ".join(_ident(c) for c in w.columns) + ") "
+            kind += f"INSERT {cols}VALUES (" + ", ".join(_sql(v) for v in w.values) + ")"
+        parts.append(kind)
+    return " ".join(parts)
+
+
+# ------------------------------------------------------------------ scripting
+
+def _stmts(statements) -> str:
+    return " ".join(_sql(s) + ";" for s in statements)
+
+
+@_sql.register(n.DeclareStmt)
+def _(node: n.DeclareStmt) -> str:
+    out = "DECLARE " + ", ".join(_ident(x) for x in node.names)
+    if node.type is not None:
+        out += f" {_sql(node.type)}"
+    if node.default is not None:
+        out += f" DEFAULT {_sql(node.default)}"
+    return out
+
+
+@_sql.register(n.SetStmt)
+def _(node: n.SetStmt) -> str:
+    if len(node.targets) > 1:
+        tgt = "(" + ", ".join(node.targets) + ")"
+    else:
+        tgt = node.targets[0] if node.targets[0].startswith("@") else _ident(node.targets[0])
+    return f"SET {tgt} = {_sql(node.value)}"
+
+
+@_sql.register(n.ScriptBlock)
+def _(node: n.ScriptBlock) -> str:
+    label = f"{node.label}: " if node.label else ""
+    out = f"{label}BEGIN {_stmts(node.statements)}"
+    if node.has_exception_handler:
+        out += f" EXCEPTION WHEN ERROR THEN {_stmts(node.exception_statements)}"
+    return out.rstrip() + " END"
+
+
+@_sql.register(n.IfStmt)
+def _(node: n.IfStmt) -> str:
+    first = node.branches[0]
+    out = f"IF {_sql(first.condition)} THEN {_stmts(first.statements)}"
+    for b in node.branches[1:]:
+        out += f" ELSEIF {_sql(b.condition)} THEN {_stmts(b.statements)}"
+    if node.else_statements:
+        out += f" ELSE {_stmts(node.else_statements)}"
+    return out.rstrip() + " END IF"
+
+
+@_sql.register(n.LoopStmt)
+def _(node: n.LoopStmt) -> str:
+    label = f"{node.label}: " if node.label else ""
+    return f"{label}LOOP {_stmts(node.statements)}".rstrip() + " END LOOP"
+
+
+@_sql.register(n.WhileStmt)
+def _(node: n.WhileStmt) -> str:
+    label = f"{node.label}: " if node.label else ""
+    return (f"{label}WHILE {_sql(node.condition)} DO "
+            f"{_stmts(node.statements)}").rstrip() + " END WHILE"
+
+
+@_sql.register(n.RepeatStmt)
+def _(node: n.RepeatStmt) -> str:
+    label = f"{node.label}: " if node.label else ""
+    return (f"{label}REPEAT {_stmts(node.statements)} "
+            f"UNTIL {_sql(node.until)} END REPEAT")
+
+
+@_sql.register(n.ForInStmt)
+def _(node: n.ForInStmt) -> str:
+    label = f"{node.label}: " if node.label else ""
+    return (f"{label}FOR {_ident(node.var)} IN ({_sql(node.query)}) DO "
+            f"{_stmts(node.statements)}").rstrip() + " END FOR"
+
+
+@_sql.register(n.BreakContinueStmt)
+def _(node: n.BreakContinueStmt) -> str:
+    return f"{node.kind} {node.label}" if node.label else node.kind
+
+
+@_sql.register(n.CallStmt)
+def _(node: n.CallStmt) -> str:
+    return f"CALL {_path(node.name)}({', '.join(_sql(a) for a in node.args)})"
+
+
+@_sql.register(n.ReturnStmt)
+def _(node: n.ReturnStmt) -> str:
+    return "RETURN"
+
+
+@_sql.register(n.RaiseStmt)
+def _(node: n.RaiseStmt) -> str:
+    if node.message is not None:
+        return f"RAISE USING MESSAGE = {_sql(node.message)}"
+    return "RAISE"
+
+
+@_sql.register(n.ExecuteImmediate)
+def _(node: n.ExecuteImmediate) -> str:
+    out = f"EXECUTE IMMEDIATE {_sql(node.sql_expr)}"
+    if node.into:
+        out += " INTO " + ", ".join(_ident(v) for v in node.into)
+    if node.using:
+        args = ", ".join(
+            _sql(e) + (f" AS {_ident(a)}" if a else "") for e, a in node.using
+        )
+        out += f" USING {args}"
+    return out
+
+
+@_sql.register(n.AssertStmt)
+def _(node: n.AssertStmt) -> str:
+    out = f"ASSERT {_sql(node.condition)}"
+    if node.message is not None:
+        out += f" AS {_sql(node.message)}"
+    return out
+
+
+@_sql.register(n.TransactionStmt)
+def _(node: n.TransactionStmt) -> str:
+    return f"{node.kind} TRANSACTION"
+
+
+@_sql.register(n.TruncateStmt)
+def _(node: n.TruncateStmt) -> str:
+    return f"TRUNCATE TABLE {_path(node.table)}"
+
+
+@_sql.register(n.DropStmt)
+def _(node: n.DropStmt) -> str:
+    exists = "IF EXISTS " if node.if_exists else ""
+    return f"DROP {node.kind} {exists}{_path(node.name)}"
+
+
+@_sql.register(n.RoutineParam)
+def _(node: n.RoutineParam) -> str:
+    out = f"{node.mode} " if node.mode else ""
+    out += _ident(node.name)
+    if node.type is not None:
+        out += f" {_sql(node.type)}"
+    return out
+
+
+@_sql.register(n.CreateProcedure)
+def _(node: n.CreateProcedure) -> str:
+    parts = ["CREATE"]
+    if node.replace:
+        parts.append("OR REPLACE")
+    parts.append("PROCEDURE")
+    if node.if_not_exists:
+        parts.append("IF NOT EXISTS")
+    parts.append(f"{_path(node.name)}({', '.join(_sql(p) for p in node.params)})")
+    if node.options_sql:
+        parts.append(f"OPTIONS{node.options_sql}")
+    parts.append(_sql(node.body))
+    return " ".join(parts)
+
+
+@_sql.register(n.CreateFunction)
+def _(node: n.CreateFunction) -> str:
+    parts = ["CREATE"]
+    if node.replace:
+        parts.append("OR REPLACE")
+    if node.temp:
+        parts.append("TEMP")
+    if node.aggregate:
+        parts.append("AGGREGATE")
+    if node.table_function:
+        parts.append("TABLE")
+    parts.append("FUNCTION")
+    if node.if_not_exists:
+        parts.append("IF NOT EXISTS")
+    parts.append(f"{_path(node.name)}({', '.join(_sql(p) for p in node.params)})")
+    if node.returns_table:
+        inner = ", ".join(
+            (f"{_ident(f.name)} " if f.name else "") + _sql(f.type)
+            for f in node.returns_table
+        )
+        parts.append(f"RETURNS TABLE<{inner}>")
+    elif node.returns is not None:
+        parts.append(f"RETURNS {_sql(node.returns)}")
+    if node.deterministic is True:
+        parts.append("DETERMINISTIC")
+    elif node.deterministic is False:
+        parts.append("NOT DETERMINISTIC")
+    if node.language:
+        parts.append(f"LANGUAGE {node.language}")
+    if node.options_sql:
+        parts.append(f"OPTIONS{node.options_sql}")
+    if node.body_query is not None:
+        parts.append(f"AS ({_sql(node.body_query)})")
+    elif node.body_expr is not None:
+        parts.append(f"AS ({_sql(node.body_expr)})")
+    elif node.body_string is not None:
+        parts.append(f"AS {_str_lit(node.body_string)}")
+    return " ".join(parts)