import { IAstPartialMapper, AstDefaultMapper } from './ast-mapper.ts';import { astVisitor, IAstVisitor, IAstFullVisitor } from './ast-visitor.ts';import { NotSupported, nil, ReplaceReturnType, NoExtraProperties } from './utils.ts';import { TableConstraint, JoinClause, ColumnConstraint, AlterSequenceStatement, CreateSequenceStatement, AlterSequenceSetOptions, CreateSequenceOptions, QName, SetGlobalValue, AlterColumnAddGenerated, QColumn, Name, OrderByStatement, QNameAliased } from './syntax/ast.ts';import { literal } from './pg-escape.ts';import { sqlKeywords } from './keywords.ts';
export type IAstToSql = { readonly [key in keyof IAstPartialMapper]-?: ReplaceReturnType<IAstPartialMapper[key], string> }
const kwSet = new Set(sqlKeywords.map(x => x.toLowerCase()));
let ret: string[] = [];
function name<T extends Name>(nm: NoExtraProperties<Name, T>) { return ident(nm.name);}
function ident(nm: string, forceDoubleQuote?: boolean) { if (!forceDoubleQuote) { const low = nm.toLowerCase(); if (low === nm && !kwSet.has(low) && /^[a-z][a-z0-9_]*$/.test(low)) { return nm; } } return '"' + nm + '"';}
function list<T>(elems: T[], act: (e: T) => any, addParen: boolean) { if (addParen) { ret.push('('); } let first = true; for (const e of elems) { if (!first) { ret.push(', '); } first = false; act(e); } if (addParen) { ret.push(')'); }}
function addConstraint(c: ColumnConstraint | TableConstraint, m: IAstVisitor) { switch (c.type) { case 'foreign key': ret.push(' foreign key (' , ...c.localColumns.map(name).join(', ') , ')'); case 'reference': ret.push(' REFERENCES '); m.tableRef(c.foreignTable); ret.push('(' , ...c.foreignColumns.map(name).join(', ') , ') '); if (c.match) { ret.push(' MATCH ', c.match.toUpperCase()); } if (c.onDelete) { ret.push(' ON DELETE ', c.onDelete); } if (c.onUpdate) { ret.push(' ON UPDATE ', c.onUpdate); } break; case 'primary key': case 'unique': ret.push(' ', c.type, ' '); if ('columns' in c) { ret.push('(' , ...c.columns.map(name).join(', ') , ') '); } break; case 'check': ret.push(' check '); m.expr(c.expr); break; case 'not null': case 'null': ret.push(' ', c.type, ' '); break; case 'default': ret.push(' default '); m.expr(c.default); break; case 'add generated': ret.push(' GENERATED '); visitGenerated(m, c); break; default: throw NotSupported.never(c) } ret.push(' ');}function visitQualifiedName(cs: QName, forceDoubleQuote?: boolean) { if (cs.schema) { ret.push(ident(cs.schema), '.'); } ret.push(ident(cs.name, forceDoubleQuote), ' ');}
function visitQualifiedNameAliased(cs: QNameAliased) { visitQualifiedName(cs); if (cs.alias) { ret.push(' AS ', ident(cs.alias), ' '); }}
function visitOrderBy(m: IAstVisitor, orderBy: OrderByStatement[]) { ret.push(' ORDER BY '); list(orderBy, e => { m.expr(e.by); if (e.order) { ret.push(' ', e.order, ' '); } if (e.nulls) { ret.push(' NULLS ', e.nulls, ' ') } }, false);}
function visitSetVal(set: SetGlobalValue) {
switch (set.type) { case 'default': ret.push('DEFAULT '); break; case 'identifier': ret.push(set.name); break; case 'list': let first = true; for (const v of set.values) { if (!first) { ret.push(', '); } first = false; visitSetVal(v); } break; case 'value': ret.push(typeof set.value === 'number' ? set.value.toString() : literal(set.value)); break; default: throw NotSupported.never(set); }}
function visitGenerated(m: IAstVisitor, alter: AlterColumnAddGenerated) { if (alter.always) { ret.push(alter.always.toUpperCase(), ' '); } ret.push('AS IDENTITY '); if (alter.sequence) { ret.push('('); if (alter.sequence.name) { ret.push('SEQUENCE NAME '); visitQualifiedName(alter.sequence.name); ret.push(' '); } visitSeqOpts(m, alter.sequence); ret.push(') '); }}function visitSeqOpts(m: IAstVisitor, cs: AlterSequenceSetOptions | CreateSequenceOptions) { if (cs.as) { ret.push('AS '); m.dataType(cs.as); ret.push(' '); } if (typeof cs.incrementBy === 'number') { ret.push('INCREMENT BY ', cs.incrementBy.toString(), ' '); } if (cs.minValue === 'no minvalue') { ret.push('NO MINVALUE '); } if (typeof cs.minValue === 'number') { ret.push('MINVALUE ', cs.minValue.toString(), ' '); } if (cs.maxValue === 'no maxvalue') { ret.push('NO MAXVALUE '); } if (typeof cs.maxValue === 'number') { ret.push('MAXVALUE ', cs.maxValue.toString(), ' '); } if (typeof cs.startWith === 'number') { ret.push('START WITH ', cs.startWith.toString(), ' '); } if (typeof cs.cache === 'number') { ret.push('CACHE ', cs.cache.toString(), ' '); } if (cs.cycle) { ret.push(cs.cycle, ' '); } if (cs.ownedBy === 'none') { ret.push('OWNED BY NONE '); } else if (cs.ownedBy) { ret.push('OWNED BY '); visitQColumn(cs.ownedBy); }
if ('restart' in cs) { if (cs.restart === true) { ret.push('RESTART ') } else if (cs.restart) { ret.push('RESTART WITH ', cs.restart.toString(), ' '); } }}
function visitQColumn(col: QColumn) { if (col.schema) { ret.push(ident(col.schema), '.'); } ret.push(ident(col.table), '.', ident(col.column), ' ');}
function join(m: IAstVisitor, j: JoinClause | nil, tbl: () => void) { if (!j) { tbl(); return; } ret.push(j.type, ' '); tbl(); if (j.on) { ret.push('ON ') m.expr(j.on); } if (j.using) { ret.push('USING ('); list(j.using, x => ret.push(name(x)), false); ret.push(') '); } ret.push(' ');}
function visitOp(v: { op: string; opSchema?: string; }) { if (v.opSchema) { ret.push(' operator(', ident(v.opSchema), '.', v.op, ') '); } else { ret.push(' ', v.op, ' '); }}
const visitor = astVisitor<IAstFullVisitor>(m => ({
addColumn: (...args) => { ret.push(' ADD COLUMN '); if (args[0].ifNotExists) { ret.push('IF NOT EXISTS '); } m.super().addColumn(...args); },
createExtension: e => { ret.push('CREATE EXTENSION '); if (e.ifNotExists) { ret.push(' IF NOT EXISTS '); } ret.push(name(e.extension)); if (!e.from && !e.version && !e.schema) { return; } ret.push(' WITH'); if (e.schema) { ret.push(' SCHEMA ', name(e.schema)); } if (e.version) { ret.push(' VERSION ', literal(e.version.value)); } if (e.from) { ret.push(' FROM ', literal(e.from.value)); } },
tablespace: t => { ret.push('TABLESPACE ', name(t.tablespace)); },
addConstraint: c => { ret.push(' ADD '); const cname = c.constraint.constraintName; if (cname) { ret.push(' CONSTRAINT ', name(cname), ' '); } addConstraint(c.constraint, m); },
alterColumn: (c, t) => { ret.push(' ALTER COLUMN ', name(c.column), ' '); m.super().alterColumn(c, t); },
setColumnDefault: (a, t, c) => { ret.push(' SET DEFAULT '); m.expr(a.default); if (a.updateExisting) { throw new Error('Not implemented: updateExisting on set column default'); } },
createEnum: t => { ret.push('CREATE TYPE '); visitQualifiedName(t.name); ret.push(' AS ENUM '); list(t.values, x => ret.push(literal(x.value)), true); ret.push(' '); },
createCompositeType: c => { ret.push('CREATE TYPE '); visitQualifiedName(c.name); ret.push(' AS '); list(c.attributes, x => { ret.push(name(x.name), ' '); m.dataType(x.dataType); if (x.collate) { ret.push('COLLATE '); visitQualifiedName(x.collate); } }, true); ret.push(' '); },
setTableOwner: o => { ret.push(' OWNER TO ', name(o.to)); },
alterColumnSimple: c => ret.push(c.type),
alterColumnAddGenerated: (alter) => { ret.push(' ADD GENERATED '); visitGenerated(m, alter) },
setColumnType: t => { ret.push(' SET DATA TYPE '); m.dataType(t.dataType); ret.push(' '); },
alterTable: t => { ret.push('ALTER TABLE '); if (t.ifExists) { ret.push(' IF EXISTS '); } if (t.only) { ret.push(' ONLY '); } visitQualifiedNameAliased(t.table); list(t.changes, change => m.tableAlteration(change, t.table), false); },
tableAlteration: (change, table) => { switch (change.type) { case 'add column': return m.addColumn(change, table); case 'add constraint': return m.addConstraint(change, table); case 'alter column': return m.alterColumn(change, table); case 'rename': return m.renameTable(change, table); case 'rename column': return m.renameColumn(change, table); case 'rename constraint': return m.renameConstraint(change, table); case 'drop column': return m.dropColumn(change, table); case 'drop constraint': return m.dropConstraint(change, table); case 'owner': return m.setTableOwner(change, table); default: throw NotSupported.never(change); } },
array: v => { ret.push(v.type === 'array' ? 'ARRAY[' : '('); list(v.expressions, e => m.expr(e), false); ret.push(v.type === 'array' ? ']' : ')'); },
arrayIndex: v => { m.expr(v.array); ret.push('['); m.expr(v.index); ret.push('] '); },
expr: e => { if (e.type === 'ref') { m.ref(e); return; } if (e.type === 'list') { m.super().expr(e); return; }
ret.push('('); m.super().expr(e); ret.push(')'); },
callOverlay: o => { ret.push('OVERLAY('); m.expr(o.value); ret.push(' PLACING '); m.expr(o.placing); ret.push(' FROM '); m.expr(o.from); if (o.for) { ret.push(' FOR '); m.expr(o.for); } ret.push(')'); },
callSubstring: s => { ret.push('SUBSTRING('); m.expr(s.value); if (s.from) { ret.push(' FROM '); m.expr(s.from); } if (s.for) { ret.push(' FOR '); m.expr(s.for); } ret.push(')'); },
binary: v => { m.expr(v.left); visitOp(v); m.expr(v.right); },
call: v => { visitQualifiedName(v.function); ret.push('('); if (v.distinct) { ret.push(v.distinct, ' '); } list(v.args, e => m.expr(e), false); if (v.orderBy) { visitOrderBy(m, v.orderBy); } ret.push(') '); if (v.filter) { ret.push('filter (where '); m.expr(v.filter); ret.push(') '); } if (v.over) { ret.push('over ('); if (v.over.partitionBy) { ret.push('PARTITION BY '); list(v.over.partitionBy, x => m.expr(x), false); ret.push(' '); } if (v.over.orderBy) { visitOrderBy(m, v.over.orderBy); ret.push(' '); } ret.push(') '); } },
case: c => { ret.push('CASE ') if (c.value) { m.expr(c.value); }
for (const e of c.whens) { ret.push(' WHEN '); m.expr(e.when); ret.push(' THEN ') m.expr(e.value); }
if (c.else) { ret.push(' ELSE '); m.expr(c.else); } ret.push(' END '); },
cast: c => { m.expr(c.operand); ret.push('::'); m.dataType(c.to); },
constant: c => { switch (c.type) { case 'boolean': ret.push(c.value ? 'true' : 'false'); break; case 'integer': ret.push(c.value.toString(10)); break; case 'numeric': ret.push(c.value.toString()); if (Number.isInteger(c.value)) { ret.push('.'); } break; case 'null': ret.push('null'); break; case 'constant': break; case 'string': ret.push(literal(c.value)); break; default: throw NotSupported.never(c); } },
valueKeyword: v => { ret.push(v.keyword, ' '); },
comment: c => { ret.push('COMMENT ON ', c.on.type.toUpperCase(), ' '); switch (c.on.type) { case 'column': visitQColumn(c.on.column); break; default: visitQualifiedName(c.on.name); break; } ret.push(' IS ', literal(c.comment), ' '); },
extract: v => { ret.push('EXTRACT (', v.field.name.toUpperCase(), ' FROM '); m.expr(v.from); ret.push(') '); },
createColumn: c => { ret.push(name(c.name), ' '); m.dataType(c.dataType); ret.push(' '); if (c.collate) { ret.push('COLLATE '); visitQualifiedName(c.collate); } for (const cst of c.constraints ?? []) { m.constraint(cst); } },
begin: beg => { ret.push('BEGIN '); if (beg.isolationLevel) { ret.push('ISOLATION LEVEL ', beg.isolationLevel.toUpperCase(), ' '); } if (beg.writeable) { ret.push(beg.writeable.toUpperCase(), ' '); } if (typeof beg.deferrable === 'boolean') { if (!beg.deferrable) { ret.push('NOT '); } ret.push('DEFERRABLE '); } },
alterSequence: cs => { ret.push('ALTER SEQUENCE '); if (cs.ifExists) { ret.push('IF EXISTS '); } visitQualifiedName(cs.name); switch (cs.change.type) { case 'set options': visitSeqOpts(m, cs.change); break; case 'rename': ret.push('RENAME TO ', name(cs.change.newName), ' '); break; case 'set schema': ret.push('SET SCHEMA ', name(cs.change.newSchema), ' '); break; case 'owner to': const own = cs.change.owner; ret.push('OWNER TO ', name(cs.change.owner), ' '); break; default: throw NotSupported.never(cs.change); } },
createSequence: cs => { ret.push('CREATE '); if (cs.temp) { ret.push('TEMPORARY '); } ret.push('SEQUENCE '); if (cs.ifNotExists) { ret.push('IF NOT EXISTS '); } visitQualifiedName(cs.name); visitSeqOpts(m, cs.options); },
drop: val => { ret.push(val.type.toUpperCase(), ' '); if (val.concurrently) { ret.push('CONCURRENTLY '); } if (val.ifExists) { ret.push('IF EXISTS '); } list(val.names, x => m.tableRef(x), false); if (val.cascade) { ret.push(val.cascade.toUpperCase(), ' '); } },
constraint: cst => { if (cst.constraintName) { ret.push(' CONSTRAINT ', name(cst.constraintName), ' '); } addConstraint(cst, m); },
do: d => { ret.push('DO'); if (d.language) { ret.push(' LANGUAGE ', d.language.name); } ret.push(' $$', d.code, '$$'); },
createFunction: c => { ret.push(c.orReplace ? 'CREATE OR REPLACE FUNCTION ' : 'CREATE FUNCTION ');
visitQualifiedName(c.name);
list(c.arguments, a => { if (a.mode) { ret.push(a.mode, ' '); } if (a.name) { ret.push(name(a.name), ' '); } m.dataType(a.type); if (a.default) { ret.push(" = "); m.expr(a.default); } }, true);
if (c.returns) { switch (c.returns.kind) { case 'table': ret.push(' RETURNS TABLE '); list(c.returns.columns, t => { ret.push(name(t.name), ' '); m.dataType(t.type); }, true); break; case undefined: case null: case 'array': ret.push(' RETURNS '); m.dataType(c.returns); break; default: throw NotSupported.never(c.returns); } }
ret.push(' AS $$', c.code ?? '', '$$');
if (c.language) { ret.push('LANGUAGE ', c.language.name, ' '); } if (c.purity) { ret.push(c.purity.toUpperCase(), ' '); } if (typeof c.leakproof === 'boolean') { ret.push(c.leakproof ? 'LEAKPROOF ' : 'NOT LEAKPROOF '); } switch (c.onNullInput) { case 'call': ret.push('CALLED ON NULL INPUT '); break; case 'null': ret.push('RETURNS NULL ON NULL INPUT '); break; case 'strict': ret.push('STRICT '); break; case null: case undefined: break; default: throw NotSupported.never(c.onNullInput); } },
dropFunction: d => { ret.push('DROP FUNCTION '); if (d.ifExists) { ret.push('IF EXISTS '); } visitQualifiedName(d.name);
if (d.arguments) { list(d.arguments, a => { if (a.name) { visitQualifiedName(a.name); ret.push(' '); } m.dataType(a.type); }, true); } ret.push(' '); },
with: w => { ret.push('WITH '); list(w.bind, b => { ret.push(name(b.alias), ' AS ('); m.statement(b.statement); ret.push(') '); }, false);
m.statement(w.in); },
withRecursive: val => { ret.push('WITH RECURSIVE ' , name(val.alias) , '(' , ...val.columnNames.map(name).join(', ') , ') AS ('); m.union(val.bind); ret.push(') '); m.statement(val.in); },
setGlobal: g => { ret.push('SET ', name(g.variable), ' = '); visitSetVal(g.set); },
setTimezone: g => { ret.push('SET TIME ZONE '); switch (g.to.type) { case 'default': case 'local': ret.push(g.to.type.toUpperCase(), ' '); break; case 'value': ret.push(typeof g.to.value === 'string' ? literal(g.to.value) : g.to.value.toString(10)); break; case 'interval': ret.push('INTERVAL ', literal(g.to.value), ' HOUR TO MINUTE'); break; default: throw NotSupported.never(g.to); } },
dataType: d => { if (d?.kind === 'array') { m.dataType(d.arrayOf!) ret.push('[]'); return; } if (!d?.name) { ret.push('unkown'); return; } let appendConfig = true; if (d.schema) { visitQualifiedName(d, d.doubleQuoted); } else { if (d.doubleQuoted) { visitQualifiedName(d, true); } else { switch (d.name) { case 'double precision': case 'character varying': case 'bit varying': ret.push(d.name, ' '); break; case 'time without time zone': case 'timestamp without time zone': case 'time with time zone': case 'timestamp with time zone': const parts = d.name.split(' ');
ret.push(parts.shift()!); if (d.config?.length) { list(d.config, v => ret.push(v.toString(10)), true); } ret.push(' ');
ret.push(parts.join(' '), ' '); appendConfig = false; break; default: visitQualifiedName(d); break; } } }
if (appendConfig && d.config?.length) { list(d.config, v => ret.push(v.toString(10)), true); } },
createIndex: c => { ret.push(c.unique ? 'CREATE UNIQUE INDEX ' : 'CREATE INDEX '); if (c.ifNotExists) { ret.push(' IF NOT EXISTS '); } if (c.indexName) { ret.push(name(c.indexName), ' '); } ret.push('ON '); m.tableRef(c.table); if (c.using) { ret.push('USING ', name(c.using), ' '); } list(c.expressions, e => { m.expr(e.expression); ret.push(' '); if (e.collate) { ret.push('COLLATE '); visitQualifiedName(e.collate); } if (e.opclass) { visitQualifiedName(e.opclass); } if (e.order) { ret.push(e.order, ' '); } if (e.nulls) { ret.push('nulls ', e.nulls, ' '); } }, true); if (c.with) { ret.push('WITH '); list(c.with, w => { ret.push(w.parameter, ' = ', literal(w.value)); }, true); } if (c.tablespace) { ret.push('TABLESPACE ', ident(c.tablespace)); } if (c.where) { ret.push(' WHERE '); m.expr(c.where); } ret.push(' '); },
createTable: t => { ret.push('CREATE '); if (t.locality) { ret.push(t.locality.toUpperCase(), ' '); } if (t.temporary) { ret.push('TEMPORARY '); } if (t.unlogged) { ret.push('UNLOGGED '); } ret.push(t.ifNotExists ? 'TABLE IF NOT EXISTS ' : 'TABLE '); m.tableRef(t.name); ret.push('('); list(t.columns, c => { switch (c.kind) { case 'column': return m.createColumn(c); case 'like table': return m.likeTable(c); default: throw NotSupported.never(c); } }, false); if (t.constraints) { ret.push(', '); list(t.constraints, c => { const cname = c.constraintName; if (cname) { ret.push('CONSTRAINT ', name(cname), ' '); } addConstraint(c, m); }, false) } ret.push(') '); if (t.inherits?.length) { ret.push(' INHERITS '); list(t.inherits, i => visitQualifiedName(i), true); } },
likeTable: l => { ret.push(' LIKE '); m.tableRef(l.like); ret.push(' '); for (const { verb, option } of l.options) { ret.push(verb.toUpperCase(), ' ', option.toUpperCase(), ' '); } },
createSchema: s => { ret.push(s.ifNotExists ? 'CREATE SCHEMA IF NOT EXISTS ' : 'CREATE SCHEMA '); ret.push(name(s.name)); },
truncateTable: t => { ret.push('TRUNCATE TABLE '); let first = true; for (const tbl of t.tables) { if (!first) { ret.push(', '); } first = false; m.tableRef(tbl); } if (t.identity) { switch (t.identity) { case 'restart': ret.push(' RESTART IDENTITY '); break; case 'continue': ret.push(' CONTINUE IDENTITY '); break; } } if (t.cascade) { ret.push(' ', t.cascade, ' '); } },
delete: t => { ret.push('DELETE FROM '); m.tableRef(t.from); if (t.where) { ret.push(' WHERE '); m.expr(t.where); }
if (t.returning) { ret.push(' RETURNING '); list(t.returning, r => m.selectionColumn(r), false); } ret.push(' '); },
dropColumn: t => { ret.push(' DROP COLUMN '); if (t.ifExists) { ret.push(' IF EXISTS '); } ret.push(name(t.column)); },
dropConstraint: t => { ret.push(' DROP CONSTRAINT '); if (t.ifExists) { ret.push(' IF EXISTS '); } ret.push(name(t.constraint)); if (t.behaviour) { ret.push(' ', t.behaviour.toUpperCase(), ' '); } },
from: t => m.super().from(t),
fromCall: s => {
join(m, s.join, () => { m.call(s); if (s.withOrdinality) { ret.push(' WITH ORDINALITY') } if (s.alias) { ret.push(' AS ', name<Name>(s.alias), ' '); const len = s.alias.columns?.length ?? 0; if (len > 0) { ret.push('(') for (let ix = 0; ix < len; ++ix) { if (ix !== 0) { ret.push(', ') } ret.push(name(s.alias.columns![ix])); } ret.push(')') } } });
ret.push(' '); },
fromStatement: s => {
join(m, s.join, () => { ret.push('('); m.select(s.statement); ret.push(') '); if (s.alias) { ret.push(' AS ', ident(s.alias)); if (s.columnNames) { list(s.columnNames, c => ret.push(name(c)), true); } ret.push(' '); } });
ret.push(' '); },
values: s => { ret.push('VALUES '); list(s.values, vlist => { list(vlist, e => { m.expr(e); }, true); }, false); },
fromTable: s => { join(m, s.join, () => { m.tableRef(s.name); if (s.name.columnNames) { if (!s.name.alias) { throw new Error('Cannot specify aliased column names without an alias'); } list(s.name.columnNames, c => ret.push(name(c)), true); } }); },
join: j => { throw new Error('Should not happen 💀'); },
insert: i => { ret.push('INSERT INTO '); m.tableRef(i.into);
if (i.columns) { ret.push( '(' , i.columns.map(name).join(', ') , ')' ); } ret.push(' '); if (i.overriding) { ret.push('OVERRIDING ', i.overriding.toUpperCase(), ' VALUE '); }
m.select(i.insert); ret.push(' ');
if (i.onConflict) { ret.push('ON CONFLICT '); if (i.onConflict.on) { list(i.onConflict.on, e => m.expr(e), true); } if (i.onConflict.do === 'do nothing') { ret.push(' DO NOTHING'); } else { ret.push(' DO UPDATE SET '); list(i.onConflict.do.sets, s => m.set(s), false); if (i.onConflict.where) { ret.push(' WHERE '); m.expr(i.onConflict.where); } } ret.push(' '); }
if (i.returning) { ret.push(' RETURNING '); list(i.returning, r => m.selectionColumn(r), false); } },
raise: r => { ret.push('RAISE '); if (r.level) { ret.push(r.level.toUpperCase(), ' '); } ret.push(literal(r.format), ' ');
if (r.formatExprs?.length) { ret.push(', '); list(r.formatExprs, e => m.expr(e), false); } if (r.using?.length) { ret.push(' USING '); list(r.using, ({ type, value }) => { ret.push(type.toUpperCase(), '='); m.expr(value); }, false); } ret.push(' '); },
default: () => { ret.push(' DEFAULT '); },
member: e => { m.expr(e.operand); ret.push(e.op); ret.push(typeof e.member === 'number' ? e.member.toString(10) : literal(e.member)); },
ref: r => { if (r.table) { visitQualifiedName(r.table); ret.push('.'); } ret.push(r.name === '*' ? '*' : ident(r.name)); },
parameter: p => { ret.push(p.name); },
renameColumn: r => { ret.push(' RENAME COLUMN ' , name(r.column) , ' TO ' , name(r.to)); },
renameConstraint: r => { ret.push(' RENAME CONSTRAINT ' , name(r.constraint) , ' TO ' , name(r.to)); },
renameTable: r => { ret.push(' RENAME TO ' , name(r.to)); },
createView: c => { ret.push('CREATE '); if (c.orReplace) { ret.push('OR REPLACE '); } if (c.temp) { ret.push('TEMP '); } if (c.recursive) { ret.push('RECURSIVE '); } ret.push('VIEW '); m.tableRef(c.name); if (c.columnNames) { list(c.columnNames, c => ret.push(name(c)), true); } const opts = c.parameters && Object.entries(c.parameters); if (opts?.length) { ret.push(' WITH '); list(opts, ([k, v]) => ret.push(k, '=', v), false); } ret.push(' AS '); m.select(c.query); if (c.checkOption) { ret.push(' WITH ', c.checkOption.toUpperCase(), ' CHECK OPTION'); } },
createMaterializedView: c => { ret.push('CREATE MATERIALIZED VIEW '); if (c.ifNotExists) { ret.push('IF NOT EXISTS '); } m.tableRef(c.name); if (c.columnNames) { list(c.columnNames, c => ret.push(name(c)), true); } const opts = c.parameters && Object.entries(c.parameters); if (opts?.length) { ret.push(' WITH '); list(opts, ([k, v]) => ret.push(k, '=', v), false); } if (c.tablespace) { ret.push(' TABLESPACE ', name(c.tablespace)); } ret.push(' AS '); m.select(c.query); if (typeof c.withData === 'boolean') { ret.push(c.withData ? ' WITH DATA' : ' WITH NO DATA'); } },
refreshMaterializedView: val => { ret.push('REFRESH MATERIALIZED VIEW '); if (val.concurrently) { ret.push('CONCURRENTLY '); } m.tableRef(val.name); if (typeof val.withData === 'boolean') { ret.push(val.withData ? ' WITH DATA' : ' WITH NO DATA'); } },
select: s => m.super().select(s),
selection: s => { ret.push('SELECT ');
if (s.distinct) { if (typeof s.distinct === 'string') { ret.push(s.distinct.toUpperCase()); } else { ret.push(' DISTINCT ON '); list(s.distinct, v => m.expr(v), true); } ret.push(' '); }
if (s.columns) { list(s.columns, c => m.selectionColumn(c), false); } ret.push(' '); if (s.from) { ret.push('FROM '); const tblCnt = s.from.length for (let i = 0; i < tblCnt; i++) { const f = s.from[i]; if (i > 0 && !f.join) { ret.push(',') } m.from(f); } ret.push(' '); }
if (s.where) { ret.push('WHERE '); m.expr(s.where); ret.push(' '); }
if (s.groupBy) { ret.push('GROUP BY '); list(s.groupBy, e => m.expr(e), false); ret.push(' '); }
if (s.orderBy) { visitOrderBy(m, s.orderBy); ret.push(' '); }
if (s.limit) { if (s.limit.offset) { ret.push(`OFFSET `); m.expr(s.limit.offset);
} if (s.limit.limit) { ret.push(`LIMIT `); m.expr(s.limit.limit); } }
if (s.for) { ret.push('FOR ', s.for.type.toUpperCase()); } },
show: s => { ret.push('SHOW ', name(s.variable)); },
prepare: s => { ret.push('PREPARE ', name(s.name)); if (s.args?.length) { list(s.args, a => m.dataType(a), true); } ret.push(' AS '); m.statement(s.statement); },
deallocate: s => { ret.push('DEALLOCATE '); if ('name' in s.target) { ret.push(s.target.name); return; } ret.push('ALL') },
arraySelect: s => { ret.push('array('); m.select(s.select); ret.push(')'); },
union: s => { ret.push('('); m.statement(s.left); ret.push(') ', s.type.toUpperCase(), ' '); if (s.right.type === 'union' || s.right.type === 'union all') { m.union(s.right); } else { ret.push('('); m.statement(s.right); ret.push(')'); } },
selectionColumn: c => { m.expr(c.expr); if (c.alias) { ret.push(' AS ', name(c.alias)); } ret.push(' '); },
set: s => { ret.push(name(s.column), ' = '); m.expr(s.value); ret.push(' '); },
statement: s => m.super().statement(s),
tableRef: r => { visitQualifiedName(r); if (r.alias) { ret.push(' AS ', ident(r.alias)); } ret.push(' '); },
ternary: t => { m.expr(t.value); ret.push(' ', t.op, ' '); m.expr(t.lo); ret.push(' AND '); m.expr(t.hi); ret.push(' '); },
transaction: t => { ret.push(t.type); },
unary: t => { switch (t.op) { case '+': case '-': visitOp(t); m.expr(t.operand); break; case 'NOT': ret.push(t.op); ret.push(' '); m.expr(t.operand); break; default: m.expr(t.operand); ret.push(' '); ret.push(t.op); } },
update: u => { ret.push('UPDATE '); m.tableRef(u.table); ret.push(' SET '); list(u.sets, s => m.set(s), false); ret.push(' '); if (u.from) { ret.push('FROM '); m.from(u.from); ret.push(' '); } if (u.where) { ret.push('WHERE '); m.expr(u.where); ret.push(' '); } if (u.returning) { ret.push(' RETURNING '); list(u.returning, r => m.selectionColumn(r), false); ret.push(' '); } },
}))
export const toSql = {} as IAstToSql;const proto = AstDefaultMapper.prototype as any;for (const k of Object.getOwnPropertyNames(proto)) { const orig = proto[k] as Function; if (k === 'constructor' || k === 'super' || typeof orig !== 'function') { continue; } (toSql as any)[k] = function (...args: []) { try { (visitor as any)[k].apply(visitor, args); return ret.join('').trim(); } finally { ret = []; } };}