Class SQLServerCodeGenProvider

The SQL dialect instance for this provider.

Whether this platform needs explicit view refresh after schema changes. SQL Server: true (uses sp_refreshview) PostgreSQL: false (views resolve at query time)

Whether this platform needs a post-sync fix for virtual field nullability. SQL Server: false PostgreSQL: true (PG view columns always report attnotnull=false)

The database platform key (e.g., 'sqlserver', 'postgresql').

Returns the native timestamp-with-timezone type name for this platform. SQL Server: DATETIMEOFFSET PostgreSQL: TIMESTAMPTZ

Generates ALTER TABLE ... ADD COLUMN SQL. SQL Server: ALTER TABLE [schema].[table] ADD colName TYPE [NOT] NULL [DEFAULT expr] PostgreSQL: ALTER TABLE schema."table" ADD COLUMN "colName" TYPE [NOT] NULL [DEFAULT expr]

Generates SQL to add a default constraint/value to a column. SQL Server: ALTER TABLE ... ADD CONSTRAINT DF_name DEFAULT expr FOR [col] PostgreSQL: ALTER TABLE ... ALTER COLUMN "col" SET DEFAULT expr

Generates ALTER TABLE ... ALTER COLUMN to change type and nullability. SQL Server: ALTER TABLE ... ALTER COLUMN col TYPE NULL|NOT NULL PostgreSQL: ALTER TABLE ... ALTER COLUMN "col" TYPE type, ALTER COLUMN "col" SET|DROP NOT NULL

Builds the four SQL fragments needed to work with an entity's primary key columns in cursor-based cascade operations:

• varDeclarations: @{prefix}{PK} TYPE variable declarations for DECLARE.
• selectFields: Bracketed column names for the cursor SELECT.
• fetchInto: @{prefix}{PK} variable references for FETCH INTO.
• routineParams: Named parameter assignments (@PK = @{prefix}{PK}) for EXEC.

Supports composite primary keys by iterating all PK fields. The optional prefix defaults to 'Related' to avoid variable name collisions in nested cursor blocks.

Builds a SQL Server EXEC statement for invoking a stored procedure. When paramNames are provided, generates named parameter syntax (@ParamName=value); otherwise uses positional parameter values. Returns just EXEC [schema].[routine] if no params.

Compares two data type names, accounting for platform-specific aliases. For example, PostgreSQL reports timestamp with time zone in information_schema but DDL uses timestamptz.

Generates a conditional INSERT statement (insert only if not exists). SQL Server: IF NOT EXISTS (checkQuery) BEGIN insertSQL END PostgreSQL: DO $$ BEGIN IF NOT EXISTS (checkQuery) THEN insertSQL; END IF; END $$

Generates SQL to dynamically find and drop the default constraint on a column. Unlike PostgreSQL's simple ALTER COLUMN DROP DEFAULT, SQL Server requires looking up the constraint name from sys.default_constraints joined through sys.tables, sys.schemas, and sys.columns, then executing a dynamic ALTER TABLE DROP CONSTRAINT via EXEC(). The generated SQL is safe to run even if no default constraint exists (guarded by IF @constraintName IS NOT NULL).

Generates a DROP statement for a database object (view/procedure/function). SQL Server: IF OBJECT_ID('...', 'P') IS NOT NULL DROP PROCEDURE ... PostgreSQL: DROP FUNCTION IF EXISTS ... CASCADE

Note: This differs from generateDropGuard() which is used for CREATE OR REPLACE patterns. This method is used for cleanup operations.

Executes a SQL file against SQL Server using the sqlcmd command-line utility. Reads connection details (server, port, instance, user, password, database) from the shared sqlConfig object. On Windows, converts file paths containing spaces to 8.3 short format to avoid quoting issues with sqlcmd. Spawns the process with QUOTED_IDENTIFIER enabled (-I) and severity threshold 17 (-V 17). Optionally adds -C for trustServerCertificate. Returns true on successful execution, false on failure.

Formats a raw default value string for embedding in generated SQL. Recognizes common SQL Server functions (NEWID(), NEWSEQUENTIALID(), GETDATE(), GETUTCDATE(), SYSDATETIME(), SYSDATETIMEOFFSET(), CURRENT_TIMESTAMP, USER_NAME(), SUSER_NAME(), SYSTEM_USER) and strips wrapping parentheses from them. For literal values, strips surrounding single quotes and re-applies them only if needsQuotes is true. Returns 'NULL' for empty or whitespace-only inputs.

Generates a comment header for the combined all-entities SQL file.

Generates a SQL Server CREATE VIEW statement for an entity's base view. The view selects all columns from the base table plus any related, parent, and root ID fields supplied by the orchestrator context. For entities with soft-delete enabled, appends a WHERE ... IS NULL clause filtering out soft-deleted rows. Includes the conditional DROP guard and a descriptive comment header.

Generates the spCreate stored procedure for a SQL Server entity. Handles three primary key strategies:

1. Auto-increment: Uses SCOPE_IDENTITY() to retrieve the generated key.
2. UNIQUEIDENTIFIER with default (e.g., NEWSEQUENTIALID()): Uses an OUTPUT clause into a table variable with a two-branch IF @PK IS NOT NULL pattern so callers can optionally supply their own GUID or let the database default apply.
3. UNIQUEIDENTIFIER without default: Falls back to ISNULL(@PK, NEWID()).
4. Composite / other PKs: Constructs a multi-column WHERE clause for retrieval.

The procedure always returns the newly created record via the entity's base view. Includes GRANT EXECUTE permissions for authorized roles.

Generates the spDelete stored procedure for a SQL Server entity. Supports both hard delete (DELETE FROM) and soft delete (UPDATE ... SET __mj_DeletedAt = GETUTCDATE() with a guard against re-deleting already soft-deleted rows). Prepends any cascade delete/update SQL for related entities. Uses @@ROWCOUNT to determine success: returns the PK values on success or NULL PK values if no row was affected.

Generates GRANT EXECUTE SQL for a CRUD stored procedure, granting permission only to roles whose EntityPermission record allows the specified CRUD operation type. Produces a single comma-separated GRANT EXECUTE ON ... TO [role1], [role2] statement.

Generates the spUpdate stored procedure for a SQL Server entity. Performs a standard UPDATE ... SET ... WHERE PK = @PK and uses @@ROWCOUNT to detect whether the row was found: if no rows were updated (e.g., stale PK or concurrent delete), returns an empty result set with the base view's column structure (SELECT TOP 0 ... WHERE 1=0); otherwise returns the updated record from the base view. Also generates the __mj_UpdatedAt timestamp trigger if the entity has that column.

Generates SQL Server-style conditional DROP guards using the IF OBJECT_ID(...) IS NOT NULL pattern. Maps each object type to its SQL Server type code: 'V' for views, 'P' for procedures, 'IF' for inline table-valued functions, and 'TR' for triggers. Each guard is terminated with a GO batch separator.

Generates SQL Server full-text search infrastructure for an entity, conditionally producing up to three components based on entity metadata flags:

1. Full-text catalog (FullTextCatalogGenerated): CREATE FULLTEXT CATALOG if one doesn't already exist, defaulting to MJ_FullTextCatalog.
2. Full-text index (FullTextIndexGenerated): Drops any existing FT index on the table, then creates a new one covering the specified search fields with English language.
3. Search function (FullTextSearchFunctionGenerated): An inline table-valued function that wraps CONTAINS() to return matching primary key values.

Generates GRANT EXECUTE permission for a full-text search function.

Generates a SQL Server OUTER APPLY clause to join the root ID inline table-valued function into the entity's base view. The function is invoked with the record's primary key and the self-referencing FK value as arguments.

Generates the SELECT expression for a root ID field in a base view. SQL Server: rootFn.RootID AS [FieldRoot...] PostgreSQL: root_fn.root_id AS "FieldRoot..."

Generates a SQL Server inline table-valued function that resolves the root ancestor ID for a self-referencing foreign key hierarchy. Uses a recursive CTE starting from the given record (or its parent if provided), walking up the parent chain until it finds a record with a NULL parent pointer. Enforces a maximum recursion depth of 100 to prevent infinite loops from circular references. The function is named fn{BaseTable}{FieldName}_GetRootID and returns a single-column result (RootID), designed to be consumed via OUTER APPLY in the entity's base view.

Generates the cascade delete/update SQL for a single related entity. Called by the orchestrator for each FK relationship when CascadeDeletes is true.

Generates a comment header for a generated SQL file.

Generates a SQL Server AFTER UPDATE trigger that automatically sets the __mj_UpdatedAt column to GETUTCDATE() on every update. The trigger joins the base table to the INSERTED pseudo-table on all primary key columns to target only the affected rows. Returns an empty string if the entity does not have an __mj_UpdatedAt field.

Generates GRANT SELECT permission for a base view.

Generates SQL to refresh/recompile a view. SQL Server: EXEC sp_refreshview 'schema.viewName'; PostgreSQL: returns empty string (no-op).

Generates a simple test query to validate a view is functional. SQL Server: SELECT TOP 1 * FROM [schema].[viewName] PostgreSQL: SELECT * FROM "schema"."viewName" LIMIT 1

Returns an additional WHERE clause fragment for the check-constraints query. SQL Server: WHERE SchemaName NOT IN (...) when excludeSchemas is provided. PostgreSQL: empty string (the PG view already handles schema filtering).

Returns a SQL query that checks whether a column participates in a composite (multi-column) unique constraint. Queries sys.indexes, sys.index_columns, and sys.columns to find non-primary-key unique indexes that include the specified column AND have more than one column. Returns rows if the column is part of such a constraint; the orchestrator checks recordset.length > 0.

Returns the name of the CRUD routine for an entity. SQL Server: spCreateEntityName PostgreSQL: fn_create_entity_name

Returns an additional WHERE clause fragment for the missing-base-tables query. SQL Server: WHERE VirtualEntity=0 PostgreSQL: empty string (PG query doesn't need this filter).

Generates SQL to fix virtual field nullability after metadata sync. PostgreSQL: Updates AllowsNull for virtual fields based on the FK column's nullability. SQL Server: returns empty string (no fix needed).

Returns a SQL query string to check if a foreign key index already exists. Used by the orchestrator to conditionally create FK indexes. SQL Server: queries sys.indexes with OBJECT_ID PostgreSQL: queries pg_indexes

The result set should return rows if the index exists (length > 0 means exists).

Generates the full SQL query to retrieve entity fields that exist in the database schema but are not yet registered in MJ metadata. The query is assembled from three parts:

1. Temp table materialization: Copies vwForeignKeys, vwTablePrimaryKeys, and vwTableUniqueKeys into temp tables so SQL Server can build real statistics instead of expanding nested view-on-view joins with bad cardinality estimates.
2. Main CTE query: Uses MaxSequences CTE to calculate proper field ordering and NumberedRows CTE to deduplicate results, joining against the temp tables for FK, PK, and unique key detection.
3. Cleanup: Drops the temp tables.

Returns a SQL query that retrieves the primary key index name for a table by joining sys.indexes, sys.objects, and sys.key_constraints and filtering on constraint type 'PK'. The result column is named IndexName as expected by the orchestrator.

Returns an array of system schema names that should be excluded from metadata synchronization. Empty array if the platform has no system schemas that need excluding. SQL Server: [] (no system schemas need excluding) PostgreSQL: ['information_schema', 'pg_catalog', 'pg_toast', ...]

Returns a SQL query that retrieves column metadata for a view by joining sys.columns, sys.types, sys.views, and sys.schemas. Returns columns named FieldName, Type, Length, Precision, Scale, and AllowsNull, ordered by column_id to preserve the original column definition order.

Returns a SQL query string to retrieve the current view definition from the database. SQL Server: SELECT OBJECT_DEFINITION(OBJECT_ID('[schema].[viewName]')) AS ViewDefinition PostgreSQL: SELECT pg_get_viewdef('"schema"."viewName"'::regclass, true) AS "ViewDefinition"

The result set must include a column named ViewDefinition.

Returns SQL to check if a view exists. The query uses @ViewName and @SchemaName as named parameters. Returns 1 row if the view exists.

Parses a raw SQL Server column default value from the system catalog into a clean form. SQL Server wraps defaults in parentheses (e.g., (getdate()), ((1)), (N'foo')), so this method applies three successive stripping passes:

1. Strips one layer of wrapping parentheses.
2. Strips the N'...' Unicode string prefix.
3. Strips surrounding single quotes from plain string literals.

Returns null if the input is null or undefined.

Quotes mixed-case identifiers in a raw SQL string for execution. SQL Server: returns the SQL unchanged (case-insensitive identifiers). PostgreSQL: double-quotes PascalCase identifiers to preserve case.

SQL Server implementation of CodeGenDatabaseProvider.SetupDataSource.

Opens (or reuses) the module-cached mssql pool via MSSQLConnection(), wires up the SQL Server metadata provider, builds the dialect-aware connection, and resolves the audit user via UserCache.Refresh() — the canonical pattern that has lived in runCodeGen.setupSQLServerDataSource() since the multi-provider work started. It now sits behind the CodeGenDatabaseProvider factory so adding a third platform doesn't mean touching the orchestrator.

Wraps an INSERT statement with a conditional existence check at the statement level. SQL Server: Adds IF NOT EXISTS (...) BEGIN prefix and END suffix. PostgreSQL: Adds ON CONFLICT DO NOTHING suffix (no prefix needed).