AbstractAbstractAllowsWhether the platform allows ORDER BY inside CTE definitions without TOP, OFFSET, or FOR XML. SQL Server: false (ORDER BY in CTEs is illegal without TOP/OFFSET/FOR XML) PostgreSQL: true (ORDER BY in CTEs is always legal)
AbstractBinarySQL type names this dialect uses for binary blob columns (image, bytea, varbinary).
AbstractBooleanSQL type names this dialect uses for boolean columns.
AbstractCurrencySQL type names this dialect uses for fixed-precision currency columns.
AbstractDateSQL type names this dialect uses for date / time / timestamp columns.
AbstractDefaultDefault ORDER BY expression for paging when no user-specified ORDER BY exists. SQL Server: '(SELECT NULL)', PostgreSQL: '1'
AbstractFixedSubset of StringTypeNames that represents fixed-width /
space-padded character types. SQL Server char/nchar and PostgreSQL
char/bpchar/character (without varying) all right-pad stored
values with spaces up to the declared length and return that padding
in result sets. Variable-width types (varchar, nvarchar, text,
etc.) do not.
Used by BaseEntity to rtrim padding on load so dirty-checks and
downstream consumers see the logical value, not the storage form.
AbstractFloatSQL type names this dialect uses for floating-point / decimal columns.
AbstractIntegerSQL type names this dialect uses for integer columns (int, bigint, smallint, …).
AbstractIntervalSQL type names this dialect uses for interval / duration columns.
AbstractJsonSQL type names this dialect uses for JSON / XML structured columns.
Hard maximum number of columns per table, or null when effectively unbounded for our purposes.
SQL Server: 1024. PostgreSQL: 1600. Default: null.
Maximum bytes that can be stored in-row for a single row, or null when the dialect has no
in-row size limit. SQL Server enforces a hard ~8060-byte in-row limit; PostgreSQL has none
(TOAST stores oversized variable-length values out-of-line). Consumed by schema materialization
to avoid emitting a table whose minimum in-row footprint can never satisfy an INSERT.
Default: null (no in-row size limit).
Maximum string length usable in an INDEX KEY column (PRIMARY KEY / UNIQUE constraint) on this dialect. A PK string column wider than this can't be indexed, so callers (e.g. the integration schema builder) cap PK string columns at this value. Default: no practical declare-time cap — a dialect overrides it where one exists. SQL Server's 900-byte index-key limit = 450 NVARCHAR chars; PostgreSQL enforces its (larger) btree limit on the stored value at write time, not the declared length, so it keeps the no-cap default.
AbstractNetworkSQL type names this dialect uses for network address columns (inet, cidr, …).
Returns the dialect's literal representation of NULL as it would
appear in generated SQL (e.g. as the result of a default-value
formatter). Both SQL Server and PostgreSQL use the bare keyword
NULL, but a future dialect could differ — codegen comparisons
should route through this rather than hard-coding the string.
AbstractParserReturns the dialect name used by node-sql-parser for AST parsing. SQL Server: 'TransactSQL', PostgreSQL: 'PostgresQL', etc.
AbstractPlatformThe platform key identifying this dialect.
AbstractStringSQL type names this dialect uses for variable-length character / text columns.
AbstractTypeReturns the data type mapping for this dialect.
AbstractUuidSQL type names this dialect uses for UUID / uniqueidentifier columns.
AbstractAddReturns the ADD COLUMN clause for ALTER TABLE. SQL Server: ADD [colName] type NULL DEFAULT ... PostgreSQL: ADD COLUMN "colName" type NULL DEFAULT ...
AbstractAlterReturns ALTER COLUMN clause(s) for type/nullability changes. SQL Server: ALTER TABLE t ALTER COLUMN [col] newType NULL/NOT NULL; PostgreSQL: ALTER TABLE t ALTER COLUMN "col" TYPE newType, ALTER COLUMN "col" SET/DROP NOT NULL;
AbstractAtomicWraps a list of statements in ONE all-or-nothing transaction batch for this platform, ready to
run as a single ExecuteSQL(script) call. Owns the platform-specific session/transaction setup
so callers don't sniff PlatformKey themselves:
SET QUOTED_IDENTIFIER ON / SET ANSI_NULLS ON (required for UPDATE/DELETE
against tables with filtered / computed-column indexes or indexed views — Msg 1934 otherwise)
SET XACT_ABORT ON (any failure rolls the whole batch back) + BEGIN/COMMIT TRANSACTION.BEGIN … COMMIT — no session pragmas (QUOTED_IDENTIFIER/ANSI_NULLS
are SQL-Server concepts) and PostgreSQL already aborts the whole transaction on any error.Returns an empty string for an empty statement list (nothing to run).
individual SQL statements (each WITHOUT a trailing ;)
AbstractAutoReturns the auto-increment PK expression for DDL. SQL Server: IDENTITY(1,1), PostgreSQL: GENERATED ALWAYS AS IDENTITY
AbstractBatchReturns the batch separator for the platform. SQL Server: "GO", PostgreSQL: "" (none needed)
AbstractBooleanReturns a boolean literal for the platform. SQL Server: "1"/"0", PostgreSQL: "true"/"false"
AbstractBooleanReturns the SQL type token for a boolean parameter in a stored-procedure /
function signature. Used by codegen when emitting tolerant-SP _Clear
companion parameters and other boolean-typed params.
SQL Server: bit (BIT type, 0/1)
PostgreSQL: boolean (BOOLEAN type, TRUE/FALSE)
Hardcoding bit everywhere worked on SQL Server but produced sprocs
that PG rejected as operator does not exist: boolean = integer when
the generated CASE compared a bit-declared parameter with = 1.
AbstractCanonicalCanonicalizes a SCHEMA name to the form the platform actually stores when
the name appears UNQUOTED in DDL. PostgreSQL folds unquoted identifiers to
lowercase, so __mj_BizAppsCommon physically becomes __mj_bizappscommon;
SQL Server is case-insensitive and stores the name as-given. Routing every
schema CREATE/DROP/USE through this keeps the engine's (quoted) operations
aligned with what unquoted migration DDL produces — so a mixed-case schema
name can't split into two physical schemas (one quoted-mixed, one folded-lowercase).
Cap a column type if it cannot be used in a UNIQUE/index constraint. SQL Server: NVARCHAR(MAX) → NVARCHAR(450) (MAX columns cannot be indexed). PostgreSQL: no-op (TEXT can be indexed). Override in platform-specific dialects.
Returns a CAST to a bounded-width string type. Used when the result
needs to be comparable against an indexed column (SQL Server cannot
compare/index NVARCHAR(MAX)) or against a fixed-width text column
such as MJ's RecordID (NVARCHAR(450) on SQL Server).
Implemented by composing ResolveAbstractType({ type: 'string', maxLength }),
which dialects already supply — SQL Server emits NVARCHAR(N) and
PostgreSQL emits VARCHAR(N). Defaults to MJ's standard 450-char
width to match the cap on indexable string columns in SQL Server.
AbstractCastReturns a CAST-to-text expression. SQL Server: CAST(expr AS NVARCHAR(MAX)), PostgreSQL: CAST(expr AS TEXT)
AbstractCastReturns a CAST-to-UUID expression. SQL Server: CAST(expr AS UNIQUEIDENTIFIER), PostgreSQL: CAST(expr AS UUID)
AbstractCoalesceReturns the platform's n-ary null-coalescing expression. SQL Server and
PostgreSQL both spell this COALESCE(...), but a future dialect could
use a different keyword — abstract on purpose so each dialect must
declare its own form rather than inheriting an opinionated default.
AbstractCommentReturns description metadata SQL for a column. SQL Server: EXEC sp_addextendedproperty with
CommentOnColumn that is safe to re-run. Default returns the standard statement (PostgreSQL COMMENT ON COLUMN already includes its terminator and is idempotent). SQL Server overrides to guard sp_addextendedproperty.
AbstractCommentReturns a COMMENT ON statement (PostgreSQL) or sp_addextendedproperty (SQL Server).
CommentOnObject that is safe to re-run (no error if the description already exists). Default returns the standard statement terminated with ';' — adequate where the comment statement is inherently idempotent (PostgreSQL COMMENT ON replaces in place). SQL Server overrides to guard sp_addextendedproperty with a fn_listextendedproperty check.
AbstractConcatReturns the string concatenation operator. SQL Server: "+", PostgreSQL: "||"
AbstractConditionalReturns a conditional IF/ELSE block in platform-appropriate procedural SQL. SQL Server: IF (condition) BEGIN thenSQL END ELSE BEGIN elseSQL END PostgreSQL: DO $$ BEGIN IF condition THEN thenSQL; ELSE elseSQL; END IF; END $$;
SQL boolean condition
SQL to execute when condition is true
OptionalelseSQL: stringOptional SQL to execute when condition is false
AbstractCreateWhether the platform supports CREATE OR REPLACE for a given object type. PostgreSQL supports it for FUNCTION, VIEW. SQL Server does not.
AbstractCreateReturns CREATE SCHEMA IF NOT EXISTS SQL. SQL Server: IF NOT EXISTS (...) EXEC('CREATE SCHEMA [name]'); GO PostgreSQL: CREATE SCHEMA IF NOT EXISTS "name";
A full CREATE TABLE that runs only if the table is absent, as a SINGLE statement.
Default (PostgreSQL et al.): CREATE TABLE IF NOT EXISTS <fullTable> (...);
SQL Server overrides with an IF OBJECT_ID(...) IS NULL guard (it has no native
CREATE TABLE IF NOT EXISTS).
Already-quoted schema.table identifier
The column/constraint lines that go between the parentheses
AbstractCreateReturns a full CREATE TABLE wrapped in a "create if not exists" guard. SQL Server: IF NOT EXISTS (sys.tables check) BEGIN CREATE TABLE ... END; PostgreSQL: CREATE TABLE IF NOT EXISTS ...;
Schema name
Table name
The column definitions (everything between the parentheses)
AbstractCurrentReturns the current UTC timestamp expression. SQL Server: GETUTCDATE(), PostgreSQL: NOW() AT TIME ZONE 'UTC'
AbstractDateReturns a date/time arithmetic expression. SQL Server: DATEADD(MINUTE, 30, GETUTCDATE()) PostgreSQL: (NOW() AT TIME ZONE 'UTC') + INTERVAL '30 minutes'
Time unit
Number of units to add (can be negative)
Base timestamp expression (e.g., from CurrentTimestampUTC())
Returns the empty-GUID sentinel literal
(00000000-0000-0000-0000-000000000000) formatted for use in a
CASE-comparison expression. The base class returns the literal as a
plain quoted string — SQL Server's implicit conversion accepts that
directly. Dialects with strict typing (PostgreSQL) override to add
the explicit cast their grammar requires.
AbstractEscapeSplits ${...} inside SQL string literals so Flyway doesn't treat
them as placeholders. Each ${name} becomes a concat-split that
round-trips back to ${name} at execution but contains no adjacent
${ in the file text. Form is platform-specific (concat operator,
truncation rules) — see each dialect's implementation.
Minimum in-row byte footprint of a column of the given raw SQL type. Off-row-capable variable-length / LOB types contribute only their in-row pointer; fixed-length types contribute their full size. Only meaningful for dialects that report a MaxInRowSizeBytes. Default: 24 (a conservative off-row-pointer floor).
AbstractExistenceReturns SQL to check if a database object exists.
"TABLE", "VIEW", "FUNCTION", "PROCEDURE", "TRIGGER"
Schema name
Object name
AbstractFallbackReturns the platform's fallback type for unknown/unmapped abstract types. SQL Server: NVARCHAR(MAX) PostgreSQL: TEXT
AbstractForeignReturns a ready-to-run (no bind parameters) query that enumerates the foreign-key graph of a single schema, for FK-cascade planning (e.g. Open-App metadata teardown).
Unlike SchemaIntrospectionQueries.listForeignKeys (a placeholder template), this
embeds the schema literal directly (via QuoteStringLiteral) so it can be executed
with ExecuteSQL(sql) on any provider without a dialect-specific bind convention. It also
returns two extra columns the cascade planner needs:
childNullable — whether the referencing (child) column allows NULL, which decides
UPDATE … SET NULL (nullable) vs. DELETE + recurse (NOT NULL).colCount — the number of columns in the FK constraint, so a caller can exclude
composite FKs (colCount > 1).Every row is one FK column. Column aliases are IDENTICAL across dialects:
parentTable, parentRefCol, childTable, childCol, childNullable, fkName, colCount
(both the referenced/parent and referencing/child tables are within schema).
the schema whose intra-schema FK edges to enumerate (e.g. __mj)
AbstractFullReturns DDL to create a full-text index. SQL Server: FULLTEXT CATALOG + FULLTEXT INDEX PostgreSQL: tsvector column + GIN index
Optionalcatalog: stringAbstractFullReturns a full-text search predicate expression. SQL Server: CONTAINS(column, searchTerm) PostgreSQL: column @@ plainto_tsquery('english', searchTerm)
AbstractGrantAbstractIIFReturns an IIF/CASE equivalent expression. SQL Server: IIF(condition, trueVal, falseVal) PostgreSQL: CASE WHEN condition THEN trueVal ELSE falseVal END
AbstractIndexAbstractIsReturns true if the given error represents an infrastructure-level connection failure (timeout, refused, pool closed, etc.) as opposed to a query-level error (bad SQL, constraint violation).
Each dialect implements this using its driver's structured error types:
error.name === 'ConnectionError'ErrorUsed by GenericDatabaseProvider to re-throw connection errors from
RunView/RunQuery instead of swallowing them into { Success: false }.
AbstractIsReturns the platform's two-argument null-coalescing expression.
SQL Server: ISNULL(expr, fallback), PostgreSQL: COALESCE(expr, fallback).
Abstract because each dialect must declare its own keyword — there is no
safe default. A future dialect that has neither ISNULL nor COALESCE
would silently emit invalid SQL if this fell through to a base
implementation.
Returns true if value is the dialect's representation of a NULL
literal in generated SQL. Comparison is case-insensitive after
trimming whitespace. Subclasses may override if a dialect uses a
non-keyword form (none currently do).
AbstractJsonReturns a JSON value extraction expression. SQL Server: JSON_VALUE(column, path) PostgreSQL: column->>'path' or jsonb_extract_path_text
AbstractLimitReturns pagination SQL fragments. SQL Server uses TOP (prefix) or OFFSET/FETCH (suffix). PostgreSQL uses LIMIT/OFFSET (suffix).
Optionaloffset: numberWraps an expression in the dialect's lowercase function — used for case-insensitive comparison when authoring filters that must work on both SS (default case-insensitive collation) and PG (case-sensitive).
Both SQL Server and PostgreSQL implement LOWER() per the ANSI SQL
standard, so the default returns LOWER(${expr}). A subclass would
override only for an exotic dialect (e.g. one that exposes lc() or
needs a CAST first).
Use this instead of hardcoding LOWER(...) in callers — keeps the
dialect-aware SQL surface in one place per the SQLDialect contract.
Convenience: maps a SQL Server type to this dialect's equivalent.
Optionallength: numberOptionalprecision: numberOptionalscale: numberAbstractNewReturns a new UUID generation expression. SQL Server: NEWID(), PostgreSQL: gen_random_uuid()
AbstractParameterReturns the default-value clause appended to a parameter declaration.
SQL Server: = NULL (or = 0, etc.), PostgreSQL: DEFAULT NULL.
value should be a SQL literal already formatted by the caller (e.g.
the dialect's NullLiteral, a quoted string, a numeric literal).
AbstractParameterReturns a parameter placeholder for the given index. SQL Server: @p0, @p1, ... PostgreSQL: $1, $2, ...
AbstractParameterReturns the parameter-reference syntax used by this dialect's
stored-procedure / function bodies.
SQL Server: @MyName, PostgreSQL functions: p_my_name.
Codegen should call this rather than hard-coding '@' + name.
AbstractProcedureReturns the SQL syntax for calling a stored procedure or function. SQL Server: EXEC [schema].[name] @p0,
PostgreSQL: SELECT * FROM schema.name($1, $2)
AbstractQuoteQuotes a column alias used in SELECT ... AS <alias>. SQL Server is
case-insensitive and accepts a bare identifier; PostgreSQL folds
unquoted identifiers to lowercase, so we must quote the alias when the
caller cares about preserving case (e.g. matching a TypeScript property
name in the result row).
AbstractQuoteQuotes a database identifier (table name, column name, etc.). SQL Server: [name], PostgreSQL: "name"
AbstractQuoteProduces a schema-qualified object reference. SQL Server: [schema].[object], PostgreSQL: schema."object"
Quotes a value as a SQL string literal. Both SQL Server and PostgreSQL
use single quotes with '' doubling to escape internal apostrophes —
this is concrete in the base class so callers don't reinvent the
value.replace(/'/g, "''") pattern. Subclasses may override if a
future dialect needs a different escape rule.
AbstractRaiseReturns a non-fatal signal/notice statement detectable in CLI output. Used for signaling conditions (e.g., "lock held") without aborting the script. SQL Server: RAISERROR('message', 16, 1) — appears in sqlcmd stdout PostgreSQL: RAISE NOTICE 'message' — appears in psql stderr
Note: For PostgreSQL, this must be used inside a ConditionalBlock (DO $$ context).
Signal message to emit (used for detection in CLI output)
AbstractRecursiveReturns the recursive CTE syntax keyword. SQL Server: "WITH", PostgreSQL: "WITH RECURSIVE"
AbstractResolveResolves an abstract schema field type to a concrete SQL type string. Used by SchemaEngine for DDL generation from platform-agnostic definitions. SQL Server: 'string' -> 'NVARCHAR(255)', 'boolean' -> 'BIT' PostgreSQL: 'string' -> 'VARCHAR(255)', 'boolean' -> 'BOOLEAN'
AbstractReturnReturns the clause used to get inserted values back. SQL Server: OUTPUT INSERTED.col1, INSERTED.col2 PostgreSQL: RETURNING col1, col2
Optionalcolumns: string[]AbstractRowReturns the row count variable/expression for the last statement. SQL Server: @@ROWCOUNT, PostgreSQL: (via GET DIAGNOSTICS or FOUND)
AbstractSchemaReturns platform-specific schema introspection queries.
AbstractScopeReturns the expression to get the last inserted identity value. SQL Server: SCOPE_IDENTITY(), PostgreSQL: lastval()
Splits an oversized SQL batch into individual statements on ;+EOL
boundaries so a caller (e.g. the RSU migration executor) can re-group
them into smaller chunks that each fit under a client request timeout.
Base implementation = the naive split(/;\s*\n/g) semantics: split on a
; followed by optional inline whitespace and a newline, trim each
fragment, drop empties, and ensure each returned statement ends with ;.
This is correct for SQL Server (no dollar-quoted blocks).
PostgreSQL overrides this with a dollar-quote-aware split that never
tears apart DO $$ … $$ / $tag$ … $tag$ blocks whose bodies
legitimately contain ;+newline.
AbstractStringReturns a STRING_SPLIT or equivalent expression. SQL Server: STRING_SPLIT(value, delimiter) PostgreSQL: string_to_array(value, delimiter) or regexp_split_to_table
AbstractTriggerAbstractUUIDPKReturns the default expression for a UUID primary key. SQL Server: NEWSEQUENTIALID(), PostgreSQL: gen_random_uuid()
Abstract base class for SQL dialect implementations.
Encapsulates ALL database-specific SQL syntax patterns into a single, testable abstraction. This is a pure string/logic layer with zero database driver dependencies.