@memberjunction/codegen-lib 5.4.1 → 5.6.0

package/dist/Database/manage-metadata.js

@@ -1,11 +1,12 @@
-import sql from 'mssql';
-import { configInfo, currentWorkingDirectory, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
-import { CodeNameFromString, EntityInfo, ExtractActualDefaultValue, LogError, LogStatus, Metadata, SeverityType } from "@memberjunction/core";
+import { CodeGenDatabaseProvider } from './codeGenDatabaseProvider.js';
+import { SQLServerCodeGenProvider } from './providers/sqlserver/SQLServerCodeGenProvider.js';
+import { configInfo, currentWorkingDirectory, dbType, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
+import { EntityInfo, ExtractActualDefaultValue, LogError, LogStatus, Metadata, SeverityType } from "@memberjunction/core";
 import { logError, logMessage, logStatus } from "../Misc/status_logging.js";
 import { SQLUtilityBase } from "./sql.js";
 import { AdvancedGeneration } from "../Misc/advanced_generation.js";
 import { SQLParser } from "@memberjunction/core-entities-server";
-import { convertCamelCaseToHaveSpaces, generatePluralName, MJGlobal, stripTrailingChars } from "@memberjunction/global";
+import { convertCamelCaseToHaveSpaces, generatePluralName, MJGlobal, stripTrailingChars, UUIDsEqual } from "@memberjunction/global";
 import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs';
 import path from 'path';
@@ -31,8 +32,138 @@ export class ValidatorResult {
 }
 export class ManageMetadataBase {
     constructor() {
+        // ─── Database Provider Infrastructure ─────────────────────────────
+        // All platform-specific SQL generation is delegated to the CodeGenDatabaseProvider.
+        // The provider is lazily initialized from the dbType() config on first access.
+        this._dbProvider = null;
+        // ─── End Dialect Infrastructure ───────────────────────────────────
         this._sqlUtilityObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
     }
+    /**
+     * Returns the CodeGenDatabaseProvider for the current database platform.
+     * Lazily initialized from dbType() configuration.
+     */
+    get dbProvider() {
+        if (!this._dbProvider) {
+            const platform = dbType();
+            if (platform === 'postgresql') {
+                const pgProvider = MJGlobal.Instance.ClassFactory.CreateInstance(CodeGenDatabaseProvider, 'PostgreSQLCodeGenProvider');
+                if (pgProvider) {
+                    this._dbProvider = pgProvider;
+                }
+                else {
+                    throw new Error('PostgreSQL CodeGen provider not found. Ensure @memberjunction/postgresql-dataprovider ' +
+                        'is installed and its CodeGen provider is registered before running CodeGen.');
+                }
+            }
+            else {
+                this._dbProvider = new SQLServerCodeGenProvider();
+            }
+        }
+        return this._dbProvider;
+    }
+    /**
+     * Returns the SQLDialect for the current database platform, derived from the provider.
+     */
+    get dialect() {
+        return this.dbProvider.Dialect;
+    }
+    /**
+     * Quotes a database identifier (column, table, etc.).
+     * SQL Server: [name], PostgreSQL: "name"
+     */
+    qi(name) {
+        return this.dialect.QuoteIdentifier(name);
+    }
+    /**
+     * Produces a schema-qualified object reference.
+     * SQL Server: [schema].[object], PostgreSQL: schema."object"
+     */
+    qs(schema, object) {
+        return this.dialect.QuoteSchema(schema, object);
+    }
+    /**
+     * Returns the current UTC timestamp expression.
+     * SQL Server: GETUTCDATE(), PostgreSQL: NOW() AT TIME ZONE 'UTC'
+     */
+    utcNow() {
+        return this.dialect.CurrentTimestampUTC();
+    }
+    /**
+     * Returns a boolean literal for the platform.
+     * SQL Server: 1/0, PostgreSQL: true/false
+     */
+    boolLit(value) {
+        return this.dialect.BooleanLiteral(value);
+    }
+    /**
+     * Quotes mixed-case identifiers in a SQL string for the current platform.
+     * Delegates to the database provider's quoteSQLForExecution method.
+     */
+    qsql(sql) {
+        return this.dbProvider.quoteSQLForExecution(sql);
+    }
+    /**
+     * Executes a SQL query with automatic identifier quoting for the current platform.
+     */
+    async runQuery(pool, sql) {
+        return pool.query(this.qsql(sql));
+    }
+    /**
+     * Executes a parameterized SQL query with automatic identifier quoting for the current platform.
+     */
+    async runQueryWithParams(pool, sql, params) {
+        return pool.queryWithParams(this.qsql(sql), params);
+    }
+    /**
+     * Wraps a SELECT query with a row limit.
+     * SQL Server: SELECT TOP N ... , PostgreSQL: SELECT ... LIMIT N
+     */
+    selectTop(n, selectBody, fromAndWhere, orderBy) {
+        const limit = this.dialect.LimitClause(n);
+        const orderClause = orderBy ? ` ORDER BY ${orderBy}` : '';
+        if (limit.prefix) {
+            // SQL Server: SELECT TOP N columns FROM ...
+            return `SELECT ${limit.prefix} ${selectBody} ${fromAndWhere}${orderClause}`;
+        }
+        // PostgreSQL: SELECT columns FROM ... LIMIT N
+        return `SELECT ${selectBody} ${fromAndWhere}${orderClause} ${limit.suffix}`;
+    }
+    /**
+     * Returns ISNULL/COALESCE expression.
+     * Both platforms support COALESCE, but SQL Server also has ISNULL.
+     */
+    coalesce(expr, fallback) {
+        return this.dialect.IsNull(expr, fallback);
+    }
+    /**
+     * Returns an IIF/CASE expression.
+     * SQL Server: IIF(cond, t, f), PostgreSQL: CASE WHEN cond THEN t ELSE f END
+     */
+    iif(condition, trueVal, falseVal) {
+        return this.dialect.IIF(condition, trueVal, falseVal);
+    }
+    /**
+     * Returns the timestamp column type name for this platform.
+     * Delegates to the database provider.
+     */
+    get timestampType() {
+        return this.dbProvider.TimestampType;
+    }
+    /**
+     * Generates a conditional existence check + DROP statement.
+     * Delegates to the database provider.
+     */
+    dropIfExists(objectType, schema, name) {
+        return this.dbProvider.dropObjectSQL(objectType, schema, name);
+    }
+    /**
+     * Generates SQL for conditional INSERT (IF NOT EXISTS pattern).
+     * Delegates to the database provider.
+     */
+    conditionalInsert(checkQuery, insertSQL) {
+        return this.dbProvider.conditionalInsertSQL(checkQuery, insertSQL);
+    }
     get SQLUtilityObject() {
         return this._sqlUtilityObject;
     }
@@ -200,16 +331,11 @@ export class ManageMetadataBase {
         for (const rel of relationships) {
             try {
                 // Look up the parent entity — try by Name first, then by BaseTable within the given schema
-                const parentResult = await pool.request()
-                    .input('ParentName', rel.ParentEntity)
-                    .input('SchemaName', rel.SchemaName || null)
-                    .query(`
-                  SELECT TOP 1 ID, Name
-                  FROM [${schema}].vwEntities
+                const parentResult = await this.runQueryWithParams(pool, `
+                  ${this.selectTop(1, 'ID, Name', `FROM ${this.qs(schema, 'vwEntities')}
                   WHERE Name = @ParentName
-                     OR (BaseTable = @ParentName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))
-                  ORDER BY CASE WHEN Name = @ParentName THEN 0 ELSE 1 END
-               `);
+                     OR (BaseTable = @ParentName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))`, 'CASE WHEN Name = @ParentName THEN 0 ELSE 1 END')}
+               `, { 'ParentName': rel.ParentEntity, 'SchemaName': rel.SchemaName || null });
                 if (parentResult.recordset.length === 0) {
                     logError(`    > IS-A config: parent entity "${rel.ParentEntity}" not found — skipping`);
                     continue;
@@ -217,16 +343,11 @@ export class ManageMetadataBase {
                 const parentId = parentResult.recordset[0].ID;
                 const parentName = parentResult.recordset[0].Name;
                 // Look up the child entity — same strategy
-                const childResult = await pool.request()
-                    .input('ChildName', rel.ChildEntity)
-                    .input('SchemaName', rel.SchemaName || null)
-                    .query(`
-                  SELECT TOP 1 ID, Name, ParentID
-                  FROM [${schema}].vwEntities
+                const childResult = await this.runQueryWithParams(pool, `
+                  ${this.selectTop(1, 'ID, Name, ParentID', `FROM ${this.qs(schema, 'vwEntities')}
                   WHERE Name = @ChildName
-                     OR (BaseTable = @ChildName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))
-                  ORDER BY CASE WHEN Name = @ChildName THEN 0 ELSE 1 END
-               `);
+                     OR (BaseTable = @ChildName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))`, 'CASE WHEN Name = @ChildName THEN 0 ELSE 1 END')}
+               `, { 'ChildName': rel.ChildEntity, 'SchemaName': rel.SchemaName || null });
                 if (childResult.recordset.length === 0) {
                     logError(`    > IS-A config: child entity "${rel.ChildEntity}" not found — skipping`);
                     continue;
@@ -235,15 +356,12 @@ export class ManageMetadataBase {
                 const childName = childResult.recordset[0].Name;
                 const existingParentId = childResult.recordset[0].ParentID;
                 // Skip if already set correctly
-                if (existingParentId === parentId) {
+                if (UUIDsEqual(existingParentId, parentId)) {
                     logStatus(`    > IS-A: "${childName}" already has ParentID set to "${parentName}", skipping`);
                 }
                 else {
                     // Set ParentID on the child entity
-                    await pool.request()
-                        .input('ParentID', parentId)
-                        .input('ChildID', childId)
-                        .query(`UPDATE [${schema}].Entity SET ParentID = @ParentID WHERE ID = @ChildID`);
+                    await this.runQueryWithParams(pool, `UPDATE ${this.qs(schema, 'Entity')} SET ParentID = @ParentID WHERE ID = @ChildID`, { 'ParentID': parentId, 'ChildID': childId });
                     if (existingParentId) {
                         logStatus(`    > IS-A: Updated "${childName}" ParentID from previous value to "${parentName}"`);
                     }
@@ -286,14 +404,10 @@ export class ManageMetadataBase {
                     continue;
                 }
                 // Look up the entity by BaseTable + SchemaName
-                const entityResult = await pool.request()
-                    .input('BaseTable', ec.BaseTable)
-                    .input('SchemaName', ec.SchemaName)
-                    .query(`
-                  SELECT TOP 1 ID, Name
-                  FROM [${schema}].vwEntities
-                  WHERE BaseTable = @BaseTable AND SchemaName = @SchemaName
-               `);
+                const entityResult = await this.runQueryWithParams(pool, `
+                  ${this.selectTop(1, 'ID, Name', `FROM ${this.qs(schema, 'vwEntities')}
+                  WHERE BaseTable = @BaseTable AND SchemaName = @SchemaName`)}
+               `, { 'BaseTable': ec.BaseTable, 'SchemaName': ec.SchemaName });
                 if (entityResult.recordset.length === 0) {
                     logError(`    > Entities config: entity for "${ec.SchemaName}.${ec.BaseTable}" not found — skipping`);
                     continue;
@@ -301,16 +415,16 @@ export class ManageMetadataBase {
                 const entityId = entityResult.recordset[0].ID;
                 const entityName = entityResult.recordset[0].Name;
                 // Build a parameterized UPDATE with one SET clause per attribute
-                const request = pool.request().input('EntityID', entityId);
+                const queryParams = { 'EntityID': entityId };
                 const setClauses = [];
                 for (const [key, value] of attrs) {
                     const paramName = `attr_${key}`;
                     // Convert boolean values to SQL BIT (1/0)
                     const sqlValue = typeof value === 'boolean' ? (value ? 1 : 0) : value;
-                    request.input(paramName, sqlValue);
-                    setClauses.push(`[${key}] = @${paramName}`);
+                    queryParams[paramName] = sqlValue;
+                    setClauses.push(`${this.qi(key)} = @${paramName}`);
                 }
-                await request.query(`UPDATE [${schema}].Entity SET ${setClauses.join(', ')} WHERE ID = @EntityID`);
+                await this.runQueryWithParams(pool, `UPDATE ${this.qs(schema, 'Entity')} SET ${setClauses.join(', ')} WHERE ID = @EntityID`, queryParams);
                 const attrSummary = attrs.map(([k, v]) => `${k}=${v}`).join(', ');
                 logStatus(`    > Entities config: Set ${attrSummary} on "${entityName}"`);
                 updatedCount++;
@@ -343,32 +457,20 @@ export class ManageMetadataBase {
             const entityName = ve.EntityName || this.deriveEntityNameFromView(viewName);
             const pkField = ve.PrimaryKey?.[0] || 'ID';
             // Check if entity already exists for this view
-            const existsResult = await pool.request()
-                .input('ViewName', viewName)
-                .input('SchemaName', viewSchema)
-                .query(`SELECT ID FROM [${schema}].vwEntities WHERE BaseView = @ViewName AND SchemaName = @SchemaName`);
+            const existsResult = await this.runQueryWithParams(pool, `SELECT ID FROM ${this.qs(schema, 'vwEntities')} WHERE BaseView = @ViewName AND SchemaName = @SchemaName`, { 'ViewName': viewName, 'SchemaName': viewSchema });
             if (existsResult.recordset.length > 0) {
                 logStatus(`    > Virtual entity "${entityName}" already exists for view [${viewSchema}].[${viewName}], skipping creation`);
                 continue;
             }
             // Verify the view actually exists in the database
-            const viewExistsResult = await pool.request()
-                .input('ViewName', viewName)
-                .input('SchemaName', viewSchema)
-                .query(`SELECT 1 FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = @ViewName AND TABLE_SCHEMA = @SchemaName`);
+            const viewExistsResult = await this.runQueryWithParams(pool, this.dbProvider.getViewExistsSQL(), { 'ViewName': viewName, 'SchemaName': viewSchema });
             if (viewExistsResult.recordset.length === 0) {
                 logError(`    > View [${viewSchema}].[${viewName}] does not exist — skipping virtual entity creation for "${entityName}"`);
                 continue;
             }
             // Create the virtual entity via the stored procedure
             try {
-                const createResult = await pool.request()
-                    .input('Name', entityName)
-                    .input('BaseView', viewName)
-                    .input('SchemaName', viewSchema)
-                    .input('PrimaryKeyFieldName', pkField)
-                    .input('Description', ve.Description || null)
-                    .execute(`[${schema}].spCreateVirtualEntity`);
+                const createResult = await pool.executeStoredProcedure(`${this.qs(schema, 'spCreateVirtualEntity')}`, { 'Name': entityName, 'BaseView': viewName, 'SchemaName': viewSchema, 'PrimaryKeyFieldName': pkField, 'Description': ve.Description || null });
                 const newEntityId = createResult.recordset?.[0]?.['']
                     || createResult.recordset?.[0]?.ID
                     || createResult.recordset?.[0]?.Column0;
@@ -410,9 +512,24 @@ export class ManageMetadataBase {
      */
     async manageMetadata(pool, currentUser) {
         const md = new Metadata();
-        const excludeSchemas = configInfo.excludeSchemas ? configInfo.excludeSchemas : [];
+        // Auto-exclude platform-specific system schemas.
+        // We mutate configInfo.excludeSchemas directly so that all downstream code
+        // (including createExcludeTablesAndSchemasFilter) picks up the exclusions.
+        const systemSchemas = this.dbProvider.getSystemSchemasToExclude();
+        if (systemSchemas.length > 0) {
+            if (!configInfo.excludeSchemas) {
+                configInfo.excludeSchemas = [];
+            }
+            for (const s of systemSchemas) {
+                if (!configInfo.excludeSchemas.includes(s)) {
+                    configInfo.excludeSchemas.push(s);
+                }
+            }
+        }
+        const excludeSchemas = configInfo.excludeSchemas ? [...configInfo.excludeSchemas] : [];
         let bSuccess = true;
         let start = new Date();
+        // Very early FK check - before any operations
         // Load SchemaInfo records early so that EntityNamePrefix/Suffix rules from the
         // database are available when createNewEntities() names new entities.
         logStatus('   Loading SchemaInfo records for entity name rules...');
@@ -519,8 +636,8 @@ export class ManageMetadataBase {
         // virtual entities are records defined in the entity metadata and do NOT define a distinct base table
         // but they do specify a base view. We DO NOT generate a base view for a virtual entity, we simply use it to figure
         // out the fields that should be in the entity definition and add/update/delete the entity definition to match what's in the view when this runs
-        const sql = `SELECT * FROM [${mj_core_schema()}].vwEntities WHERE VirtualEntity = 1`;
-        const virtualEntitiesResult = await pool.request().query(sql);
+        const sql = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntities')} WHERE VirtualEntity = 1`;
+        const virtualEntitiesResult = await this.runQuery(pool, sql);
         const virtualEntities = virtualEntitiesResult.recordset;
         let anyUpdates = false;
         if (virtualEntities && virtualEntities.length > 0) {
@@ -542,20 +659,8 @@ export class ManageMetadataBase {
         try {
             // for a given virtual entity, we need to loop through the fields that exist in the current SQL definition for the view
             // and add/update/delete the entity fields to match what's in the view
-            const sql = `  SELECT
-                           c.name AS FieldName, t.name AS Type, c.max_length AS Length, c.precision Precision, c.scale Scale, c.is_nullable AllowsNull
-                        FROM
-                           sys.columns c
-                        INNER JOIN
-                           sys.types t ON c.user_type_id = t.user_type_id
-                        INNER JOIN
-                           sys.views v ON c.object_id = v.object_id
-                        WHERE
-                           v.name = '${virtualEntity.BaseView}' AND
-                           SCHEMA_NAME(v.schema_id) = '${virtualEntity.SchemaName}'
-                        ORDER BY
-                           c.column_id`;
-            const veFieldsResult = await pool.request().query(sql);
+            const sql = this.dbProvider.getViewColumnsSQL(virtualEntity.SchemaName, virtualEntity.BaseView);
+            const veFieldsResult = await this.runQuery(pool, sql);
             const veFields = veFieldsResult.recordset;
             if (veFields && veFields.length > 0) {
                 // we have 1+ fields, now loop through them and process each one
@@ -569,7 +674,7 @@ export class ManageMetadataBase {
                         removeList.push(f.ID);
                     }
                     if (removeList.length > 0) {
-                        const sqlRemove = `DELETE FROM [${mj_core_schema()}].EntityField WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
+                        const sqlRemove = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
                         // this removes the fields that shouldn't be there anymore
                         await this.LogSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from entity ${virtualEntity.Name}`);
                         bUpdated = true;
@@ -591,7 +696,7 @@ export class ManageMetadataBase {
             }
             if (bUpdated) {
                 // finally make sure we update the UpdatedAt field for the entity if we made changes to its fields
-                const sqlUpdate = `UPDATE [${mj_core_schema()}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${virtualEntity.ID}'`;
+                const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${virtualEntity.ID}'`;
                 await this.LogSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity updated date for ${virtualEntity.Name}`);
             }
             return { success: bSuccess, updatedEntity: bUpdated };
@@ -622,7 +727,7 @@ export class ManageMetadataBase {
                     field.Sequence !== fieldSequence) {
                     // the field needs to be updated, so update it
                     const sqlUpdate = `UPDATE
-                                    [${mj_core_schema()}].EntityField
+                                    ${this.qs(mj_core_schema(), 'EntityField')}
                                   SET
                                     Sequence=${fieldSequence},
                                     Type='${veField.Type}',
@@ -640,13 +745,16 @@ export class ManageMetadataBase {
             else {
                 // this means that we do NOT have a match so the field does not exist in the entity definition, so we need to add it
                 newEntityFieldUUID = this.createNewUUID();
-                const sqlAdd = `INSERT INTO [${mj_core_schema()}].EntityField (
-                                      ID, EntityID, Name, Type, AllowsNull,
-                                      Length, Precision, Scale,
-                                      Sequence, IsPrimaryKey, IsUnique )
+                const q = (n) => this.qi(n);
+                const sqlAdd = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
+                                      ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
+                                      ${q('Length')}, ${q('Precision')}, ${q('Scale')},
+                                      ${q('Sequence')}, ${q('IsPrimaryKey')}, ${q('IsUnique')},
+                                      ${q('__mj_CreatedAt')}, ${q('__mj_UpdatedAt')} )
                             VALUES (  '${newEntityFieldUUID}', '${entity.ID}', '${veField.FieldName}', '${veField.Type}', ${veField.AllowsNull ? 1 : 0},
                                        ${veField.Length}, ${veField.Precision}, ${veField.Scale},
-                                       ${fieldSequence}, ${makePrimaryKey ? 1 : 0}, ${makePrimaryKey ? 1 : 0}
+                                       ${fieldSequence}, ${makePrimaryKey ? 1 : 0}, ${makePrimaryKey ? 1 : 0},
+                                       ${this.utcNow()}, ${this.utcNow()}
                                     )`;
                 await this.LogSQLAndExecute(pool, sqlAdd, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                 didUpdate = true;
@@ -717,9 +825,9 @@ export class ManageMetadataBase {
                 return { decorated: false, skipped: true };
             }
             // Get view definition from SQL Server
-            const viewDefSQL = `SELECT OBJECT_DEFINITION(OBJECT_ID('[${entity.SchemaName}].[${entity.BaseView}]')) AS ViewDef`;
-            const viewDefResult = await pool.request().query(viewDefSQL);
-            const viewDefinition = viewDefResult.recordset[0]?.ViewDef;
+            const viewDefSQL = this.dbProvider.getViewDefinitionSQL(entity.SchemaName, entity.BaseView);
+            const viewDefResult = await this.runQuery(pool, viewDefSQL);
+            const viewDefinition = viewDefResult.recordset[0]?.ViewDefinition;
             if (!viewDefinition) {
                 logStatus(`         Could not get view definition for ${entity.SchemaName}.${entity.BaseView} — skipping LLM decoration`);
                 return { decorated: false, skipped: false };
@@ -752,7 +860,7 @@ export class ManageMetadataBase {
             // Apply categories using the shared methods (same stability rules as regular entities)
             anyUpdated = await this.applyVEFieldCategories(pool, entity, result) || anyUpdated;
             if (anyUpdated) {
-                const sqlUpdate = `UPDATE [${schema}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${entity.ID}'`;
+                const sqlUpdate = `UPDATE ${this.qs(schema, 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${entity.ID}'`;
                 await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${entity.Name} after LLM decoration`);
             }
             return { decorated: anyUpdated, skipped: false };
@@ -810,10 +918,10 @@ export class ManageMetadataBase {
         const schema = mj_core_schema();
         const fieldsSQL = `
          SELECT ID, Name, Category, AutoUpdateCategory, AutoUpdateDisplayName, GeneratedFormSection, DisplayName, ExtendedType, CodeType
-         FROM [${schema}].EntityField
+         FROM ${this.qs(schema, 'EntityField')}
          WHERE EntityID = '${entity.ID}'
       `;
-        const fieldsResult = await pool.request().query(fieldsSQL);
+        const fieldsResult = await this.runQuery(pool, fieldsSQL);
         const dbFields = fieldsResult.recordset;
         if (dbFields.length === 0)
             return false;
@@ -860,12 +968,12 @@ export class ManageMetadataBase {
         // Build batched SQL: clear default PK + set all LLM-identified PKs
         const sqlStatements = [];
         // Clear existing default PK (field #1 fallback) before applying LLM-identified PKs
-        sqlStatements.push(`UPDATE [${schema}].[EntityField]
+        sqlStatements.push(`UPDATE ${this.qs(schema, 'EntityField')}
                         SET IsPrimaryKey=0, IsUnique=0
                         WHERE EntityID='${entity.ID}' AND IsPrimaryKey=1 AND IsSoftPrimaryKey=0`);
         // Set LLM-identified PKs
         for (const pk of validPKs) {
-            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+            sqlStatements.push(`UPDATE ${this.qs(schema, 'EntityField')}
                          SET IsPrimaryKey=1, IsUnique=1, IsSoftPrimaryKey=1
                          WHERE EntityID='${entity.ID}' AND Name='${pk}'`);
             logStatus(`         ✓ Set PK for ${entity.Name}.${pk} (LLM-identified)`);
@@ -905,7 +1013,7 @@ export class ManageMetadataBase {
                 logStatus(`         ⚠️  LLM FK: related entity '${fk.relatedEntityName}' not found for ${entity.Name}.${fk.fieldName}`);
                 continue;
             }
-            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+            sqlStatements.push(`UPDATE ${this.qs(schema, 'EntityField')}
                          SET RelatedEntityID='${relatedEntity.ID}',
                              RelatedEntityFieldName='${fk.relatedFieldName}',
                              IsSoftForeignKey=1
@@ -945,7 +1053,7 @@ export class ManageMetadataBase {
                     setClauses += `, ExtendedType='${validExtendedType}'`;
                 }
             }
-            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+            sqlStatements.push(`UPDATE ${this.qs(schema, 'EntityField')}
                          SET ${setClauses}
                          WHERE EntityID='${entity.ID}' AND Name='${field.Name}'`);
         }
@@ -1051,12 +1159,9 @@ export class ManageMetadataBase {
             }
             // Check the DATABASE for existing field record — in-memory metadata may be stale
             // (e.g. createNewEntityFieldsFromSchema may have already added this field from the view)
-            const existsResult = await pool.request()
-                .input('EntityID', childEntity.ID)
-                .input('FieldName', parentField.Name)
-                .query(`SELECT ID, IsVirtual, Type, Length, Precision, Scale, AllowsNull, AllowUpdateAPI
-                    FROM [${mj_core_schema()}].EntityField
-                    WHERE EntityID = @EntityID AND Name = @FieldName`);
+            const existsResult = await this.runQueryWithParams(pool, `SELECT ID, IsVirtual, Type, Length, Precision, Scale, AllowsNull, AllowUpdateAPI
+                    FROM ${this.qs(mj_core_schema(), 'EntityField')}
+                    WHERE EntityID = @EntityID AND Name = @FieldName`, { 'EntityID': childEntity.ID, 'FieldName': parentField.Name });
             if (existsResult.recordset.length > 0) {
                 // Field already exists — update it to ensure it's marked as a virtual IS-A field
                 const existingRow = existsResult.recordset[0];
@@ -1068,7 +1173,7 @@ export class ManageMetadataBase {
                     existingRow.AllowsNull !== parentField.AllowsNull ||
                     !existingRow.AllowUpdateAPI;
                 if (needsUpdate) {
-                    const sqlUpdate = `UPDATE [${mj_core_schema()}].EntityField
+                    const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
                   SET IsVirtual=1,
                       Type='${parentField.Type}',
                       Length=${parentField.Length},
@@ -1086,16 +1191,19 @@ export class ManageMetadataBase {
                 const newFieldID = this.createNewUUID();
                 // Use high sequence — will be reordered by updateExistingEntityFieldsFromSchema
                 const sequence = 100000 + parentFields.indexOf(parentField);
-                const sqlInsert = `INSERT INTO [${mj_core_schema()}].EntityField (
-                  ID, EntityID, Name, Type, AllowsNull,
-                  Length, Precision, Scale,
-                  Sequence, IsVirtual, AllowUpdateAPI,
-                  IsPrimaryKey, IsUnique)
+                const q = (n) => this.qi(n);
+                const sqlInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
+                  ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
+                  ${q('Length')}, ${q('Precision')}, ${q('Scale')},
+                  ${q('Sequence')}, ${q('IsVirtual')}, ${q('AllowUpdateAPI')},
+                  ${q('IsPrimaryKey')}, ${q('IsUnique')},
+                  ${q('__mj_CreatedAt')}, ${q('__mj_UpdatedAt')})
                VALUES (
                   '${newFieldID}', '${childEntity.ID}', '${parentField.Name}',
                   '${parentField.Type}', ${parentField.AllowsNull ? 1 : 0},
                   ${parentField.Length}, ${parentField.Precision}, ${parentField.Scale},
-                  ${sequence}, 1, 1, 0, 0)`;
+                  ${sequence}, 1, 1, 0, 0,
+                  ${this.utcNow()}, ${this.utcNow()})`;
                 await this.LogSQLAndExecute(pool, sqlInsert, `Create IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
                 bUpdated = true;
             }
@@ -1107,12 +1215,12 @@ export class ManageMetadataBase {
             !f.IsPrimaryKey && !f.Name.startsWith('__mj_') &&
             !currentParentFieldNames.has(f.Name.toLowerCase()));
         for (const staleField of staleFields) {
-            const sqlDelete = `DELETE FROM [${mj_core_schema()}].EntityField WHERE ID='${staleField.ID}'`;
+            const sqlDelete = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID='${staleField.ID}'`;
             await this.LogSQLAndExecute(pool, sqlDelete, `Remove stale IS-A parent field ${staleField.Name} from ${childEntity.Name}`);
             bUpdated = true;
         }
         if (bUpdated) {
-            const sqlUpdate = `UPDATE [${mj_core_schema()}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${childEntity.ID}'`;
+            const sqlUpdate = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET ${this.qi(EntityInfo.UpdatedAtFieldName)}=${this.utcNow()} WHERE ID='${childEntity.ID}'`;
             await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${childEntity.Name} after IS-A field sync`);
         }
         return { success: true, updated: bUpdated };
@@ -1164,55 +1272,40 @@ export class ManageMetadataBase {
         try {
             // STEP 1 - search for all foreign keys in the vwEntityFields view, we use the RelatedEntityID field to determine our FKs
             const sSQL = `SELECT *
-                       FROM ${mj_core_schema()}.vwEntityFields
+                       FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
                        WHERE
                              RelatedEntityID IS NOT NULL AND
                              IsVirtual = 0 AND
-                             EntityID NOT IN (SELECT ID FROM ${mj_core_schema()}.Entity WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
+                             EntityID NOT IN (SELECT ID FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
                        ORDER BY RelatedEntityID`;
-            const entityFieldsResult = await pool.request().query(sSQL);
+            const entityFieldsResult = await this.runQuery(pool, sSQL);
             const entityFields = entityFieldsResult.recordset;
             // Get the relationship counts for each entity
-            const sSQLRelationshipCount = `SELECT EntityID, COUNT(*) AS Count FROM ${mj_core_schema()}.EntityRelationship GROUP BY EntityID`;
-            const relationshipCountsResult = await pool.request().query(sSQLRelationshipCount);
+            const sSQLRelationshipCount = `SELECT ${this.qi('EntityID')}, COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} GROUP BY ${this.qi('EntityID')}`;
+            const relationshipCountsResult = await this.runQuery(pool, sSQLRelationshipCount);
             const relationshipCounts = relationshipCountsResult.recordset;
             const relationshipCountMap = new Map();
             for (const rc of relationshipCounts) {
-                relationshipCountMap.set(rc.EntityID, rc.Count);
+                // Use Number() because PG returns COUNT(*) as bigint, which the pg driver delivers as a string
+                relationshipCountMap.set(rc.EntityID, Number(rc.Count));
             }
             // get all relationships in one query for performance improvement
-            const sSQLRelationship = `SELECT * FROM ${mj_core_schema()}.EntityRelationship`;
-            const allRelationshipsResult = await pool.request().query(sSQLRelationship);
+            const sSQLRelationship = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityRelationship')}`;
+            const allRelationshipsResult = await this.runQuery(pool, sSQLRelationship);
             const allRelationships = allRelationshipsResult.recordset;
             // Function to process a batch of entity fields
             const processBatch = async (batch) => {
                 let batchSQL = '';
                 batch.forEach((f) => {
                     // for each field determine if an existing relationship exists, if not, create it
-                    const relationships = allRelationships.filter((r) => r.EntityID === f.RelatedEntityID && r.RelatedEntityID === f.EntityID);
+                    const relationships = allRelationships.filter((r) => UUIDsEqual(r.EntityID, f.RelatedEntityID) && UUIDsEqual(r.RelatedEntityID, f.EntityID));
                     if (relationships && relationships.length === 0) {
                         // no relationship exists, so create it
-                        const e = md.Entities.find(e => e.ID === f.EntityID);
-                        const parentEntity = md.Entities.find(e => e.ID === f.RelatedEntityID);
-                        const parentEntityName = parentEntity ? parentEntity.Name : f.RelatedEntityID;
-                        // calculate the sequence by getting the count of existing relationships for the entity and adding 1 and then increment the count for future inserts in this loop
-                        const relCount = relationshipCountMap.get(f.EntityID) || 0;
-                        const sequence = relCount + 1;
-                        const newEntityRelationshipUUID = this.createNewUUID();
-                        batchSQL += `
-/* Create Entity Relationship: ${parentEntityName} -> ${e.Name} (One To Many via ${f.Name}) */
-   IF NOT EXISTS (
-      SELECT 1
-      FROM [${mj_core_schema()}].EntityRelationship
-      WHERE ID = '${newEntityRelationshipUUID}'
-   )
-   BEGIN
-      INSERT INTO ${mj_core_schema()}.EntityRelationship (ID, EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence)
-                              VALUES ('${newEntityRelationshipUUID}', '${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', 1, 1, '${e.Name}', ${sequence});
-   END
-                              `;
-                        // now update the map for the relationship count
-                        relationshipCountMap.set(f.EntityID, sequence);
+                        batchSQL += this.buildInsertRelationshipSQL(f, md, relationshipCountMap);
+                    }
+                    else {
+                        // relationship(s) exist - check if any need their join field updated
+                        batchSQL += this.buildUpdateRelationshipJoinFieldSQL(relationships, f);
                     }
                 });
                 if (batchSQL.length > 0) {
@@ -1224,6 +1317,11 @@ export class ManageMetadataBase {
                 const batch = entityFields.slice(i, i + batchItems);
                 await processBatch(batch);
             }
+            // NOTE: Stale relationship cleanup is intentionally NOT done here because this
+            // method runs BEFORE deleteUnneededEntityFields(). Stale EntityField records
+            // (for dropped columns) still exist at this point and would prevent detection
+            // of stale relationships. The cleanup is handled by cleanupStaleEntityRelationships()
+            // which is called from sql_codegen.ts AFTER entity fields are fully synced.
             return true;
         }
         catch (e) {
@@ -1231,6 +1329,103 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /**
+     * Builds SQL to INSERT a new EntityRelationship record for a discovered FK field.
+     */
+    buildInsertRelationshipSQL(f, md, relationshipCountMap) {
+        const e = md.Entities.find(e => UUIDsEqual(e.ID, f.EntityID));
+        const parentEntity = md.Entities.find(e => UUIDsEqual(e.ID, f.RelatedEntityID));
+        const parentEntityName = parentEntity ? parentEntity.Name : String(f.RelatedEntityID);
+        const relCount = relationshipCountMap.get(f.EntityID) || 0;
+        const sequence = relCount + 1;
+        const newEntityRelationshipUUID = this.createNewUUID();
+        const checkQuery = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${newEntityRelationshipUUID}'`;
+        const insertSQL = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityRelationship')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('RelatedEntityID')}, ${this.qi('RelatedEntityJoinField')}, ${this.qi('Type')}, ${this.qi('BundleInAPI')}, ${this.qi('DisplayInForm')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')})
+                    VALUES ('${newEntityRelationshipUUID}', '${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', ${this.boolLit(true)}, ${this.boolLit(true)}, ${sequence}, ${this.utcNow()}, ${this.utcNow()})`;
+        relationshipCountMap.set(f.EntityID, sequence);
+        return `
+/* Create Entity Relationship: ${parentEntityName} -> ${e.Name} (One To Many via ${f.Name}) */
+   ${this.dbProvider.conditionalInsertSQL(checkQuery, insertSQL)};
+                    `;
+    }
+    /**
+     * Builds SQL to UPDATE an existing EntityRelationship's RelatedEntityJoinField if it no longer
+     * matches the current FK field name. Only updates relationships where AutoUpdateFromSchema = true.
+     */
+    buildUpdateRelationshipJoinFieldSQL(relationships, f) {
+        let sql = '';
+        for (const r of relationships) {
+            if (r.AutoUpdateFromSchema && String(r.RelatedEntityJoinField).trim() !== String(f.Name).trim()) {
+                logStatus(`      > Updating EntityRelationship join field: ${r.RelatedEntityJoinField} -> ${f.Name} (ID: ${r.ID})`);
+                sql += `
+/* Update EntityRelationship join field from '${r.RelatedEntityJoinField}' to '${f.Name}' */
+   UPDATE ${this.qs(mj_core_schema(), 'EntityRelationship')}
+      SET ${this.qi('RelatedEntityJoinField')} = '${f.Name}',
+          ${this.qi('__mj_UpdatedAt')} = ${this.utcNow()}
+      WHERE ${this.qi('ID')} = '${r.ID}';
+`;
+            }
+        }
+        return sql;
+    }
+    /**
+     * Public entry point for cleaning up stale EntityRelationship records. This must be called
+     * AFTER deleteUnneededEntityFields() has run, so that stale EntityField records (for dropped
+     * columns) are removed before we check which relationships are still valid.
+     * Called from sql_codegen.ts after the second manageEntityFields() pass.
+     * @param pool - database connection
+     * @param excludeSchemas - schemas to exclude from FK field lookup
+     */
+    async cleanupStaleEntityRelationships(pool, excludeSchemas) {
+        try {
+            const sSQL = `SELECT *
+                       FROM ${this.qs(mj_core_schema(), 'vwEntityFields')}
+                       WHERE
+                             RelatedEntityID IS NOT NULL AND
+                             IsVirtual = 0 AND
+                             EntityID NOT IN (SELECT ID FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
+                       ORDER BY RelatedEntityID`;
+            const entityFieldsResult = await this.runQuery(pool, sSQL);
+            const entityFields = entityFieldsResult.recordset;
+            const sSQLRelationship = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityRelationship')}`;
+            const allRelationshipsResult = await this.runQuery(pool, sSQLRelationship);
+            const allRelationships = allRelationshipsResult.recordset;
+            await this.removeStaleOneToManyRelationships(pool, allRelationships, entityFields);
+            return true;
+        }
+        catch (e) {
+            logError(e);
+            return false;
+        }
+    }
+    /**
+     * Removes stale One-To-Many EntityRelationship records whose RelatedEntityJoinField no longer
+     * corresponds to a valid FK field in the database. Only removes relationships where
+     * AutoUpdateFromSchema = true and Type = 'One To Many'.
+     */
+    async removeStaleOneToManyRelationships(pool, allRelationships, entityFields) {
+        // Build a set of valid (ParentEntityID, ChildEntityID, JoinFieldName) tuples from current FK fields.
+        // In EntityRelationship terms: EntityID = ParentEntityID (the "one" side), RelatedEntityID = ChildEntityID (the "many" side)
+        // In entityFields: f.RelatedEntityID = ParentEntityID, f.EntityID = ChildEntityID, f.Name = FK field name
+        const validRelationshipKeys = new Set();
+        for (const f of entityFields) {
+            validRelationshipKeys.add(`${f.RelatedEntityID}|${f.EntityID}|${f.Name}`);
+        }
+        const staleRelationships = allRelationships.filter(r => String(r.Type).trim() === 'One To Many' &&
+            r.AutoUpdateFromSchema === true &&
+            !validRelationshipKeys.has(`${r.EntityID}|${r.RelatedEntityID}|${r.RelatedEntityJoinField}`));
+        if (staleRelationships.length > 0) {
+            let deleteSQL = '';
+            for (const r of staleRelationships) {
+                logStatus(`      > Removing stale EntityRelationship: ${r.Entity} -> ${r.RelatedEntity} via '${r.RelatedEntityJoinField}' (ID: ${r.ID})`);
+                deleteSQL += `
+/* Remove stale EntityRelationship: ${r.Entity} -> ${r.RelatedEntity} (FK field '${r.RelatedEntityJoinField}' no longer exists) */
+   DELETE FROM ${this.qs(mj_core_schema(), 'EntityRelationship')} WHERE ${this.qi('ID')} = '${r.ID}';
+`;
+            }
+            await this.LogSQLAndExecute(pool, deleteSQL, 'Remove stale One-To-Many EntityRelationships');
+        }
+    }
     /**
      * This method will look for situations where entity metadata exist in the entities metadata table but the underlying table has been deleted. In this case, the metadata for the entity
      * should be removed. This method is called as part of the manageMetadata method and is not intended to be called directly.
@@ -1239,8 +1434,8 @@ export class ManageMetadataBase {
      */
     async checkAndRemoveMetadataForDeletedTables(pool, excludeSchemas) {
         try {
-            const sql = `SELECT * FROM ${mj_core_schema()}.vwEntitiesWithMissingBaseTables WHERE VirtualEntity=0`;
-            const entitiesResult = await pool.request().query(sql);
+            const sql = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntitiesWithMissingBaseTables')}${this.dbProvider.getEntitiesWithMissingBaseTablesFilter()}`;
+            const entitiesResult = await this.runQuery(pool, sql);
             const entities = entitiesResult.recordset;
             if (entities && entities.length > 0) {
                 for (const e of entities) {
@@ -1248,7 +1443,7 @@ export class ManageMetadataBase {
                     // the below could fail if there are non-core dependencies on the entity, but that's ok, we will flag that in the console
                     // for the admin to handle manually
                     try {
-                        const sqlDelete = `__mj.spDeleteEntityWithCoreDependencies @EntityID='${e.ID}'`;
+                        const sqlDelete = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spDeleteEntityWithCoreDependencies', [`'${e.ID}'`], ['EntityID']);
                         await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove entity ${e.Name}`);
                         logStatus(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
                         // next up we need to remove the spCreate, spDelete, spUpdate, BaseView, and FullTextSearchFunction, if provided.
@@ -1279,9 +1474,8 @@ export class ManageMetadataBase {
             if (proceed && schemaName && name && schemaName.trim().length > 0 && name.trim().length > 0) {
                 // Use IF OBJECT_ID pattern for Flyway compatibility
                 // Object type codes: P = Stored Procedure, V = View, FN = Scalar Function, IF/TF = Table-Valued Function
-                const objectTypeCode = type === 'procedure' ? 'P' : type === 'view' ? 'V' : 'FN';
                 const upperType = type.toUpperCase();
-                const sqlDelete = `IF OBJECT_ID('[${schemaName}].[${name}]', '${objectTypeCode}') IS NOT NULL\n    DROP ${upperType} [${schemaName}].[${name}]`;
+                const sqlDelete = this.dbProvider.dropObjectSQL(upperType, schemaName, name);
                 await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove ${type} ${schemaName}.${name}`);
                 // next up, we need to clean up the cache of saved DB objects that may exist for this entity in the appropriate sub-directory.
                 const sqlOutputDir = outputDir('SQL', true);
@@ -1350,6 +1544,16 @@ export class ManageMetadataBase {
             bSuccess = false;
         }
         logStatus(`      Created new entity fields from schema in ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+        // PostgreSQL view columns always report attnotnull=false, so virtual fields
+        // (FK join columns like "Location", "Class") incorrectly get AllowsNull=true.
+        // Fix: derive virtual field AllowsNull from the FK column that drives the JOIN.
+        // The virtual field name = FK field name minus trailing "ID" (e.g. ClassID → Class).
+        if (this.dbProvider.NeedsVirtualFieldNullabilityFix) {
+            const fixSQL = this.dbProvider.getFixVirtualFieldNullabilitySQL(mj_core_schema());
+            if (fixSQL) {
+                await this.LogSQLAndExecute(pool, fixSQL, 'SQL to fix virtual field nullability');
+            }
+        }
         // AN: 14-June-2025 - we are now running this AFTER we create new entity fields from schema
         // which results in the same pattern of behavior as migrations where we first create new fields
         // with VERY HIGH sequence numbers (e.g. 100,000 above what they will be approx) and then
@@ -1425,23 +1629,26 @@ export class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 [${mj_core_schema()}].vwEntities
+                                 ${this.qs(mj_core_schema(), 'vwEntities')}
                               WHERE
                                  VirtualEntity=0 AND
                                  DeleteType='Soft' AND
                                  SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
-            const entitiesResult = await pool.request().query(sqlEntities);
+            const entitiesResult = await this.runQuery(pool, sqlEntities);
             const entities = entitiesResult.recordset;
             let overallResult = true;
             if (entities.length > 0) {
                 // we have 1+ entities that need the special fields, so loop through them and ensure the fields exist
                 // validate that each entity has the __mj_DeletedAt field, and it is a DATETIMEOFFSET fields, NOT NULL and both are fields that have a DEFAULT value of GETUTCDATE().
-                const sql = `SELECT *
+                const sql = `SELECT
+                            TABLE_SCHEMA AS "TABLE_SCHEMA", TABLE_NAME AS "TABLE_NAME",
+                            COLUMN_NAME AS "COLUMN_NAME", DATA_TYPE AS "DATA_TYPE",
+                            IS_NULLABLE AS "IS_NULLABLE", COLUMN_DEFAULT AS "COLUMN_DEFAULT"
                          FROM INFORMATION_SCHEMA.COLUMNS
                          WHERE
-                         ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
+                         (${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')})
                          AND COLUMN_NAME='${EntityInfo.DeletedAtFieldName}'`;
-                const resultResult = await pool.request().query(sql);
+                const resultResult = await this.runQuery(pool, sql);
                 const result = resultResult.recordset;
                 for (const e of entities) {
                     const eResult = result.filter((r) => r.TABLE_NAME === e.BaseTable && r.TABLE_SCHEMA === e.SchemaName); // get just the fields for this entity
@@ -1490,8 +1697,8 @@ export class ManageMetadataBase {
                 const tableSchema = table.SchemaName;
                 const tableName = table.TableName;
                 // Look up entity ID (SELECT query - no need to log to migration file)
-                const entityLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${tableSchema}' AND BaseTable = '${tableName}'`;
-                const entityResult = await pool.request().query(entityLookupSQL);
+                const entityLookupSQL = `SELECT ID FROM ${this.qs(schema, 'Entity')} WHERE SchemaName = '${tableSchema}' AND BaseTable = '${tableName}'`;
+                const entityResult = await this.runQuery(pool, entityLookupSQL);
                 if (entityResult.recordset.length === 0) {
                     logStatus(`         ⚠️  Entity not found for ${tableSchema}.${tableName} - skipping`);
                     continue;
@@ -1502,11 +1709,11 @@ export class ManageMetadataBase {
                 const primaryKeys = table.PrimaryKey || [];
                 if (primaryKeys.length > 0) {
                     for (const pk of primaryKeys) {
-                        const sSQL = `UPDATE [${schema}].[EntityField]
-                                SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
-                                    [IsPrimaryKey] = 1,
-                                    [IsSoftPrimaryKey] = 1
-                                WHERE [EntityID] = '${entityId}' AND [Name] = '${pk.FieldName}'`;
+                        const sSQL = `UPDATE ${this.qs(schema, 'EntityField')}
+                                SET ${EntityInfo.UpdatedAtFieldName}=${this.utcNow()},
+                                    ${this.qi('IsPrimaryKey')} = 1,
+                                    ${this.qi('IsSoftPrimaryKey')} = 1
+                                WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = '${pk.FieldName}'`;
                         const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft PK for ${tableSchema}.${tableName}.${pk.FieldName}`);
                         if (result !== null) {
                             logStatus(`         ✓ Set IsPrimaryKey=1, IsSoftPrimaryKey=1 for ${tableName}.${pk.FieldName}`);
@@ -1520,19 +1727,19 @@ export class ManageMetadataBase {
                     for (const fk of foreignKeys) {
                         const fkSchema = fk.SchemaName || tableSchema;
                         // Look up related entity ID (SELECT query - no need to log to migration file)
-                        const relatedLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${fkSchema}' AND BaseTable = '${fk.RelatedTable}'`;
-                        const relatedEntityResult = await pool.request().query(relatedLookupSQL);
+                        const relatedLookupSQL = `SELECT ID FROM ${this.qs(schema, 'Entity')} WHERE SchemaName = '${fkSchema}' AND BaseTable = '${fk.RelatedTable}'`;
+                        const relatedEntityResult = await this.runQuery(pool, relatedLookupSQL);
                         if (relatedEntityResult.recordset.length === 0) {
                             logStatus(`         ⚠️  Related entity not found for ${fkSchema}.${fk.RelatedTable} - skipping FK ${fk.FieldName}`);
                             continue;
                         }
                         const relatedEntityId = relatedEntityResult.recordset[0].ID;
-                        const sSQL = `UPDATE [${schema}].[EntityField]
-                                SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
-                                    [RelatedEntityID] = '${relatedEntityId}',
-                                    [RelatedEntityFieldName] = '${fk.RelatedField}',
-                                    [IsSoftForeignKey] = 1
-                                WHERE [EntityID] = '${entityId}' AND [Name] = '${fk.FieldName}'`;
+                        const sSQL = `UPDATE ${this.qs(schema, 'EntityField')}
+                                SET ${EntityInfo.UpdatedAtFieldName}=${this.utcNow()},
+                                    ${this.qi('RelatedEntityID')} = '${relatedEntityId}',
+                                    ${this.qi('RelatedEntityFieldName')} = '${fk.RelatedField}',
+                                    ${this.qi('IsSoftForeignKey')} = 1
+                                WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = '${fk.FieldName}'`;
                         const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft FK for ${tableSchema}.${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
                         if (result !== null) {
                             logStatus(`         ✓ Set soft FK for ${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
@@ -1560,24 +1767,27 @@ export class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 [${mj_core_schema()}].vwEntities
+                                 ${this.qs(mj_core_schema(), 'vwEntities')}
                               WHERE
                                  VirtualEntity = 0 AND
                                  TrackRecordChanges = 1 AND
                                  SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
-            const entitiesResult = await pool.request().query(sqlEntities);
+            const entitiesResult = await this.runQuery(pool, sqlEntities);
             const entities = entitiesResult.recordset;
             let overallResult = true;
             if (entities.length > 0) {
                 // we have 1+ entities that need the special fields, so loop through them and ensure the fields exist
                 // validate that each entity has two specific fields, the first one is __mj_CreatedAt and the second one is __mj_UpdatedAt
                 // both are DATETIME fields, NOT NULL and both are fields that have a DEFAULT value of GETUTCDATE().
-                const sqlCreatedUpdated = `SELECT *
+                const sqlCreatedUpdated = `SELECT
+                                          TABLE_SCHEMA AS "TABLE_SCHEMA", TABLE_NAME AS "TABLE_NAME",
+                                          COLUMN_NAME AS "COLUMN_NAME", DATA_TYPE AS "DATA_TYPE",
+                                          IS_NULLABLE AS "IS_NULLABLE", COLUMN_DEFAULT AS "COLUMN_DEFAULT"
                                        FROM INFORMATION_SCHEMA.COLUMNS
                                        WHERE
-                                          ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
+                                          (${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')})
                                        AND COLUMN_NAME IN ('${EntityInfo.CreatedAtFieldName}','${EntityInfo.UpdatedAtFieldName}')`;
-                const resultResult = await pool.request().query(sqlCreatedUpdated);
+                const resultResult = await this.runQuery(pool, sqlCreatedUpdated);
                 const result = resultResult.recordset;
                 for (const e of entities) {
                     // result has both created at and updated at fields, so filter on the result for each and do what we need to based on that
@@ -1608,18 +1818,19 @@ export class ManageMetadataBase {
         try {
             if (!currentFieldData) {
                 // field doesn't exist, let's create it
-                const sql = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD ${fieldName} DATETIMEOFFSET ${allowNull ? 'NULL' : 'NOT NULL DEFAULT GETUTCDATE()'}`;
+                const sql = this.dbProvider.addColumnSQL(entity.SchemaName, entity.BaseTable, fieldName, this.timestampType, allowNull, allowNull ? undefined : this.utcNow());
                 await this.LogSQLAndExecute(pool, sql, `SQL text to add special date field ${fieldName} to entity ${entity.SchemaName}.${entity.BaseTable}`);
             }
             else {
                 // field does exist, let's first check the data type/nullability
-                if (currentFieldData.DATA_TYPE.trim().toLowerCase() !== 'datetimeoffset' ||
+                const dataTypeMatches = this.dbProvider.compareDataTypes(currentFieldData.DATA_TYPE.trim().toLowerCase(), this.timestampType.toLowerCase());
+                if (!dataTypeMatches ||
                     (currentFieldData.IS_NULLABLE.trim().toLowerCase() !== 'no' && !allowNull) ||
                     (currentFieldData.IS_NULLABLE.trim().toLowerCase() === 'no' && allowNull)) {
                     // the column is the wrong type, or has wrong nullability attribute, so let's update it, first removing the default constraint, then
                     // modifying the column, and finally adding the default constraint back in.
                     await this.dropExistingDefaultConstraint(pool, entity, fieldName);
-                    const sql = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ALTER COLUMN ${fieldName} DATETIMEOFFSET ${allowNull ? 'NULL' : 'NOT NULL'}`;
+                    const sql = this.dbProvider.alterColumnTypeAndNullabilitySQL(entity.SchemaName, entity.BaseTable, fieldName, this.timestampType, allowNull);
                     await this.LogSQLAndExecute(pool, sql, `SQL text to update special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
                     if (!allowNull)
                         await this.createDefaultConstraintForSpecialDateField(pool, entity, fieldName);
@@ -1630,7 +1841,7 @@ export class ManageMetadataBase {
                     if (!allowNull) {
                         const defaultValue = currentFieldData.COLUMN_DEFAULT;
                         const realDefaultValue = ExtractActualDefaultValue(defaultValue);
-                        if (!realDefaultValue || realDefaultValue.trim().toLowerCase() !== 'getutcdate()') {
+                        if (!realDefaultValue || realDefaultValue.trim().toLowerCase() !== this.utcNow().toLowerCase()) {
                             await this.dropAndCreateDefaultConstraintForSpecialDateField(pool, entity, fieldName);
                         }
                     }
@@ -1649,7 +1860,7 @@ export class ManageMetadataBase {
      */
     async createDefaultConstraintForSpecialDateField(pool, entity, fieldName) {
         try {
-            const sqlAddDefaultConstraint = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD CONSTRAINT DF_${entity.SchemaName}_${CodeNameFromString(entity.BaseTable)}_${fieldName} DEFAULT GETUTCDATE() FOR [${fieldName}]`;
+            const sqlAddDefaultConstraint = this.dbProvider.addDefaultConstraintSQL(entity.SchemaName, entity.BaseTable, fieldName, this.utcNow());
             await this.LogSQLAndExecute(pool, sqlAddDefaultConstraint, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
@@ -1675,25 +1886,7 @@ export class ManageMetadataBase {
      */
     async dropExistingDefaultConstraint(pool, entity, fieldName) {
         try {
-            const sqlDropDefaultConstraint = `
-         DECLARE @constraintName NVARCHAR(255);
-
-         -- Get the default constraint name
-         SELECT @constraintName = d.name
-         FROM sys.tables t
-         JOIN sys.schemas s ON t.schema_id = s.schema_id
-         JOIN sys.columns c ON t.object_id = c.object_id
-         JOIN sys.default_constraints d ON c.default_object_id = d.object_id
-         WHERE s.name = '${entity.SchemaName}'
-         AND t.name = '${entity.BaseTable}'
-         AND c.name = '${fieldName}';
-
-         -- Drop the default constraint if it exists
-         IF @constraintName IS NOT NULL
-         BEGIN
-            EXEC('ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] DROP CONSTRAINT ' + @constraintName);
-         END
-         `;
+            const sqlDropDefaultConstraint = this.dbProvider.dropDefaultConstraintSQL(entity.SchemaName, entity.BaseTable, fieldName);
             await this.LogSQLAndExecute(pool, sqlDropDefaultConstraint, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
@@ -1713,14 +1906,14 @@ export class ManageMetadataBase {
         if (ag.featureEnabled('EntityDescriptions')) {
             // we have the feature enabled, so let's loop through the new entities and generate descriptions for them
             for (let e of ManageMetadataBase.newEntityList) {
-                const dataResult = await pool.request().query(`SELECT * FROM [${mj_core_schema()}].vwEntities WHERE Name = '${e}'`);
+                const dataResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntities')} WHERE Name = '${e}'`);
                 const data = dataResult.recordset;
-                const fieldsResult = await pool.request().query(`SELECT * FROM [${mj_core_schema()}].vwEntityFields WHERE EntityID='${data[0].ID}'`);
+                const fieldsResult = await this.runQuery(pool, `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFields')} WHERE EntityID='${data[0].ID}'`);
                 const fields = fieldsResult.recordset;
                 // Use new API to generate entity description
                 const result = await ag.generateEntityDescription(e, data[0].BaseTable, fields.map((f) => ({ Name: f.Name, Type: f.Type, IsNullable: f.AllowsNull, Description: f.Description })), currentUser);
                 if (result?.entityDescription && result.entityDescription.length > 0) {
-                    const sSQL = `UPDATE [${mj_core_schema()}].Entity SET Description = '${result.entityDescription}' WHERE Name = '${e}'`;
+                    const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'Entity')} SET Description = '${result.entityDescription}' WHERE Name = '${e}'`;
                     await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity description for entity ${e}`);
                 }
                 else {
@@ -1742,9 +1935,9 @@ export class ManageMetadataBase {
             const sql = `SELECT
                         ef.ID, ef.Name
                       FROM
-                        [${mj_core_schema()}].vwEntityFields ef
+                        ${this.qs(mj_core_schema(), 'vwEntityFields')} ef
                       INNER JOIN
-                        [${mj_core_schema()}].vwEntities e
+                        ${this.qs(mj_core_schema(), 'vwEntities')} e
                       ON
                         ef.EntityID = e.ID
                       WHERE
@@ -1752,13 +1945,13 @@ export class ManageMetadataBase {
                         ef.Name <> \'ID\' AND
                         e.SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})
                         `;
-            const fieldsResult = await pool.request().query(sql);
+            const fieldsResult = await this.runQuery(pool, sql);
             const fields = fieldsResult.recordset;
             if (fields && fields.length > 0)
                 for (const field of fields) {
                     const sDisplayName = stripTrailingChars(convertCamelCaseToHaveSpaces(field.Name), 'ID', true).trim();
                     if (sDisplayName.length > 0 && sDisplayName.toLowerCase().trim() !== field.Name.toLowerCase().trim()) {
-                        const sSQL = `UPDATE [${mj_core_schema()}].EntityField SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(), DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
+                        const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')} SET ${EntityInfo.UpdatedAtFieldName}=${this.utcNow()}, DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
                         await this.LogSQLAndExecute(pool, sSQL, `SQL text to update display name for field ${field.Name}`);
                     }
                 }
@@ -1779,7 +1972,7 @@ export class ManageMetadataBase {
      */
     async setDefaultColumnWidthWhereNeeded(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC ${mj_core_schema()}.spSetDefaultColumnWidthWhereNeeded @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spSetDefaultColumnWidthWhereNeeded', [`'${excludeSchemas.join(',')}'`], ['ExcludedSchemaNames']);
             await this.LogSQLAndExecute(pool, sSQL, `SQL text to set default column width where needed`, true);
             return true;
         }
@@ -1801,120 +1994,7 @@ export class ManageMetadataBase {
      */
     getPendingEntityFieldsSELECTSQL() {
         const schema = mj_core_schema();
-        const sSQL = `
--- Materialize system DMV views into temp tables so SQL Server gets real statistics
--- instead of expanding nested view-on-view joins with bad cardinality estimates
--- Drop first in case a prior run on this connection left them behind
-IF OBJECT_ID('tempdb..#__mj__CodeGen__vwForeignKeys') IS NOT NULL DROP TABLE #__mj__CodeGen__vwForeignKeys;
-IF OBJECT_ID('tempdb..#__mj__CodeGen__vwTablePrimaryKeys') IS NOT NULL DROP TABLE #__mj__CodeGen__vwTablePrimaryKeys;
-IF OBJECT_ID('tempdb..#__mj__CodeGen__vwTableUniqueKeys') IS NOT NULL DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
-
-SELECT [column], [table], [schema_name], referenced_table, referenced_column, [referenced_schema]
-INTO #__mj__CodeGen__vwForeignKeys
-FROM [${schema}].vwForeignKeys;
-
-SELECT TableName, ColumnName, SchemaName
-INTO #__mj__CodeGen__vwTablePrimaryKeys
-FROM [${schema}].vwTablePrimaryKeys;
-
-SELECT TableName, ColumnName, SchemaName
-INTO #__mj__CodeGen__vwTableUniqueKeys
-FROM [${schema}].vwTableUniqueKeys;
-
-WITH MaxSequences AS (
-   -- Calculate the maximum existing sequence for each entity to avoid collisions
-   SELECT
-      EntityID,
-      ISNULL(MAX(Sequence), 0) AS MaxSequence
-   FROM
-      [${schema}].EntityField
-   GROUP BY
-      EntityID
-),
-NumberedRows AS (
-   SELECT
-      sf.EntityID,
-      -- Use dynamic offset based on max existing sequence for this entity to prevent collisions
-      -- Add 100000 to ensure we're well above any existing sequences, then add the column sequence
-      ISNULL(ms.MaxSequence, 0) + 100000 + sf.Sequence AS Sequence,
-      sf.FieldName,
-      sf.Description,
-      sf.Type,
-      sf.Length,
-      sf.Precision,
-      sf.Scale,
-      sf.AllowsNull,
-      sf.DefaultValue,
-      sf.AutoIncrement,
-      IIF(sf.IsVirtual = 1, 0, IIF(sf.FieldName = '${EntityInfo.CreatedAtFieldName}' OR
-                                   sf.FieldName = '${EntityInfo.UpdatedAtFieldName}' OR
-                                   sf.FieldName = '${EntityInfo.DeletedAtFieldName}' OR
-                                   pk.ColumnName IS NOT NULL, 0, 1)) AllowUpdateAPI,
-      sf.IsVirtual,
-      e.RelationshipDefaultDisplayType,
-      e.Name EntityName,
-      re.ID RelatedEntityID,
-      fk.referenced_column RelatedEntityFieldName,
-      IIF(sf.FieldName = 'Name', 1, 0) IsNameField,
-      IsPrimaryKey =	CASE
-            WHEN pk.ColumnName IS NOT NULL THEN 1
-            ELSE 0
-         END,
-      IsUnique =		CASE
-            WHEN pk.ColumnName IS NOT NULL THEN 1
-            ELSE
-               CASE
-                  WHEN uk.ColumnName IS NOT NULL THEN 1
-                  ELSE 0
-               END
-         END,
-      ROW_NUMBER() OVER (PARTITION BY sf.EntityID, sf.FieldName ORDER BY (SELECT NULL)) AS rn
-   FROM
-      [${schema}].vwSQLColumnsAndEntityFields sf
-   LEFT OUTER JOIN
-      MaxSequences ms
-   ON
-      sf.EntityID = ms.EntityID
-   LEFT OUTER JOIN
-      [${schema}].Entity e
-   ON
-      sf.EntityID = e.ID
-   LEFT OUTER JOIN
-      #__mj__CodeGen__vwForeignKeys fk
-   ON
-      sf.FieldName = fk.[column] AND
-      e.BaseTable = fk.[table] AND
-      e.SchemaName = fk.[schema_name]
-   LEFT OUTER JOIN
-      [${schema}].Entity re -- Related Entity
-   ON
-      re.BaseTable = fk.referenced_table AND
-      re.SchemaName = fk.[referenced_schema]
-   LEFT OUTER JOIN
-      #__mj__CodeGen__vwTablePrimaryKeys pk
-   ON
-      e.BaseTable = pk.TableName AND
-      sf.FieldName = pk.ColumnName AND
-      e.SchemaName = pk.SchemaName
-   LEFT OUTER JOIN
-      #__mj__CodeGen__vwTableUniqueKeys uk
-   ON
-      e.BaseTable = uk.TableName AND
-      sf.FieldName = uk.ColumnName AND
-      e.SchemaName = uk.SchemaName
-   WHERE
-      EntityFieldID IS NULL -- only where we have NOT YET CREATED EntityField records\n${this.createExcludeTablesAndSchemasFilter('sf.')}
-   )
-   SELECT *
-   FROM NumberedRows
-   WHERE rn = 1
-   ORDER BY EntityID, Sequence;
-
-DROP TABLE #__mj__CodeGen__vwForeignKeys;
-DROP TABLE #__mj__CodeGen__vwTablePrimaryKeys;
-DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
-`;
-        return sSQL;
+        return this.dbProvider.getPendingEntityFieldsSQL(schema);
     }
     /**
      * This method builds a SQL Statement that will insert a row into the EntityField table with information about a new field.
@@ -1946,43 +2026,44 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                 break;
         }
         const parsedDefaultValue = this.parseDefaultValue(n.DefaultValue);
-        const quotedDefaultValue = parsedDefaultValue?.trim().length === 0 ? 'NULL' :
-            (parsedDefaultValue?.trim().toLowerCase() === 'null' ? 'NULL' : `'${parsedDefaultValue}'`);
-        // in the above we are setting quotedDefaultValue to NULL if the parsed default value is an empty string or the string 'NULL' (case insensitive)
+        // Escape single quotes inside the default value so they don't break the SQL string literal
+        const escapedParsedDefault = parsedDefaultValue?.replace(/'/g, "''");
+        // quotedDefaultValue is NULL when parsedDefaultValue is null/undefined, empty, or the literal string 'NULL' (case insensitive)
+        const quotedDefaultValue = (parsedDefaultValue == null || parsedDefaultValue.trim().length === 0)
+            ? 'NULL'
+            : (parsedDefaultValue.trim().toLowerCase() === 'null' ? 'NULL' : `'${escapedParsedDefault}'`);
+        const conflictCheck = `SELECT 1 FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID = '${newEntityFieldUUID}' OR (EntityID = '${n.EntityID}' AND Name = '${n.FieldName}')`;
+        const guard = this.dbProvider.wrapInsertWithConflictGuard(conflictCheck);
         return `
-      IF NOT EXISTS (
-         SELECT 1 FROM [${mj_core_schema()}].EntityField 
-         WHERE ID = '${newEntityFieldUUID}'  OR 
-               (EntityID = '${n.EntityID}' AND Name = '${n.FieldName}')
-         -- check to make sure we're not inserting a duplicate entity field metadata record
-      )
-      BEGIN
-         INSERT INTO [${mj_core_schema()}].EntityField
+      ${guard.prefix}
+         INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')}
          (
-            ID,
-            EntityID,
-            Sequence,
-            Name,
-            DisplayName,
-            Description,
-            Type,
-            Length,
-            Precision,
-            Scale,
-            AllowsNull,
-            DefaultValue,
-            AutoIncrement,
-            AllowUpdateAPI,
-            IsVirtual,
-            RelatedEntityID,
-            RelatedEntityFieldName,
-            IsNameField,
-            IncludeInUserSearchAPI,
-            IncludeRelatedEntityNameFieldInBaseView,
-            DefaultInView,
-            IsPrimaryKey,
-            IsUnique,
-            RelatedEntityDisplayType
+            ${this.qi('ID')},
+            ${this.qi('EntityID')},
+            ${this.qi('Sequence')},
+            ${this.qi('Name')},
+            ${this.qi('DisplayName')},
+            ${this.qi('Description')},
+            ${this.qi('Type')},
+            ${this.qi('Length')},
+            ${this.qi('Precision')},
+            ${this.qi('Scale')},
+            ${this.qi('AllowsNull')},
+            ${this.qi('DefaultValue')},
+            ${this.qi('AutoIncrement')},
+            ${this.qi('AllowUpdateAPI')},
+            ${this.qi('IsVirtual')},
+            ${this.qi('RelatedEntityID')},
+            ${this.qi('RelatedEntityFieldName')},
+            ${this.qi('IsNameField')},
+            ${this.qi('IncludeInUserSearchAPI')},
+            ${this.qi('IncludeRelatedEntityNameFieldInBaseView')},
+            ${this.qi('DefaultInView')},
+            ${this.qi('IsPrimaryKey')},
+            ${this.qi('IsUnique')},
+            ${this.qi('RelatedEntityDisplayType')},
+            ${this.qi('__mj_CreatedAt')},
+            ${this.qi('__mj_UpdatedAt')}
          )
          VALUES
          (
@@ -2009,9 +2090,11 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             ${bDefaultInView ? 1 : 0},
             ${n.IsPrimaryKey},
             ${n.IsUnique},
-            '${n.RelationshipDefaultDisplayType}'
+            '${n.RelationshipDefaultDisplayType}',
+            ${this.utcNow()},
+            ${this.utcNow()}
          )
-      END`;
+      ${guard.suffix}`;
     }
     /**
      * This method takes the stored DEFAULT CONSTRAINT value from the database and parses it to retrieve the actual default value. This is necessary because the default value is
@@ -2023,27 +2106,18 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
      * @returns
      */
     parseDefaultValue(sqlDefaultValue) {
-        let sResult = null;
-        if (sqlDefaultValue !== null && sqlDefaultValue !== undefined) {
-            if (sqlDefaultValue.startsWith('(') && sqlDefaultValue.endsWith(')'))
-                sResult = sqlDefaultValue.substring(1, sqlDefaultValue.length - 1);
-            else
-                sResult = sqlDefaultValue;
-            if (sResult.toUpperCase().startsWith('N\'') && sResult.endsWith('\''))
-                sResult = sResult.substring(2, sResult.length - 1);
-            if (sResult.startsWith('\'') && sResult.endsWith('\''))
-                sResult = sResult.substring(1, sResult.length - 1);
-        }
-        return sResult;
+        if (sqlDefaultValue === null || sqlDefaultValue === undefined) {
+            return null;
+        }
+        return this.dbProvider.parseColumnDefaultValue(sqlDefaultValue) ?? null;
     }
     async createNewEntityFieldsFromSchema(pool) {
         try {
             const sSQL = this.getPendingEntityFieldsSELECTSQL();
-            const newEntityFieldsResult = await pool.request().query(sSQL);
+            const newEntityFieldsResult = await this.runQuery(pool, sSQL);
             const newEntityFields = newEntityFieldsResult.recordset;
             if (newEntityFields.length > 0) {
-                const transaction = new sql.Transaction(pool);
-                await transaction.begin();
+                const transaction = await pool.beginTransaction();
                 try {
                     // wrap in a transaction so we get all of it or none of it
                     for (let i = 0; i < newEntityFields.length; ++i) {
@@ -2091,9 +2165,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
      */
     async updateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap) {
         try {
-            const sSQL = `EXEC [${mj_core_schema()}].spUpdateEntityFieldRelatedEntityNameFieldMap
-         @EntityFieldID='${entityFieldID}',
-         @RelatedEntityNameFieldMap='${relatedEntityNameFieldMap}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateEntityFieldRelatedEntityNameFieldMap', [`'${entityFieldID}'`, `'${relatedEntityNameFieldMap}'`], ['EntityFieldID', 'RelatedEntityNameFieldMap']);
             await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
             return true;
         }
@@ -2104,7 +2176,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     async updateExistingEntitiesFromSchema(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${mj_core_schema()}].spUpdateExistingEntitiesFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateExistingEntitiesFromSchema', [`'${excludeSchemas.join(',')}'`], ['ExcludedSchemaNames']);
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to update existing entities from schema`, true);
             // result contains the updated entities, and there is a property of each row called Name which has the entity name that was modified
             // add these to the modified entity list if they're not already in there
@@ -2129,7 +2201,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     async updateExistingEntityFieldsFromSchema(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${mj_core_schema()}].spUpdateExistingEntityFieldsFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateExistingEntityFieldsFromSchema', [`'${excludeSchemas.join(',')}'`], ['ExcludedSchemaNames']);
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to update existing entity fields from schema`, true);
             // result contains the updated entity fields
             // there is a field in there called EntityName. Get a distinct list of entity names from this and add them
@@ -2154,7 +2226,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
      */
     async updateSchemaInfoFromDatabase(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${mj_core_schema()}].spUpdateSchemaInfoFromDatabase @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spUpdateSchemaInfoFromDatabase', [`'${excludeSchemas.join(',')}'`], ['ExcludedSchemaNames']);
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to sync schema info from database schemas`, true);
             if (result && result.length > 0) {
                 logStatus(`   > Updated/created ${result.length} SchemaInfo records`);
@@ -2185,8 +2257,8 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
      */
     async loadSchemaInfoRecords(pool) {
         try {
-            const sSQL = `SELECT * FROM [${mj_core_schema()}].SchemaInfo`;
-            const result = await pool.request().query(sSQL);
+            const sSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'SchemaInfo')}`;
+            const result = await this.runQuery(pool, sSQL);
             if (result?.recordset?.length > 0) {
                 this.cacheSchemaInfoRecords(result.recordset);
             }
@@ -2199,7 +2271,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     async deleteUnneededEntityFields(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${mj_core_schema()}].spDeleteUnneededEntityFields @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = this.dbProvider.callRoutineSQL(mj_core_schema(), 'spDeleteUnneededEntityFields', [`'${excludeSchemas.join(',')}'`], ['ExcludedSchemaNames']);
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to delete unneeded entity fields`, true);
             // result contains the DELETED entity fields
             // there is a field in there called Entity. Get a distinct list of entity names from this and add them
@@ -2220,15 +2292,15 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             // evaluate it to see if it is a simple series of OR statements or not, if it is a simple series of OR statements, we can parse the possible values
             // for the field and sync that up with the EntityFieldValue table. If it is not a simple series of OR statements, we will not be able to parse it and we'll
             // just ignore it.
-            const filter = excludeSchemas && excludeSchemas.length > 0 ? ` WHERE SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})` : '';
-            const sSQL = `SELECT * FROM [${mj_core_schema()}].vwEntityFieldsWithCheckConstraints${filter}`;
-            const resultResult = await pool.request().query(sSQL);
+            const filter = this.dbProvider.getCheckConstraintsSchemaFilter(excludeSchemas);
+            const sSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFieldsWithCheckConstraints')}${filter}`;
+            const resultResult = await this.runQuery(pool, sSQL);
             const result = resultResult.recordset;
-            const efvSQL = `SELECT * FROM [${mj_core_schema()}].EntityFieldValue`;
-            const allEntityFieldValuesResult = await pool.request().query(efvSQL);
+            const efvSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')}`;
+            const allEntityFieldValuesResult = await this.runQuery(pool, efvSQL);
             const allEntityFieldValues = allEntityFieldValuesResult.recordset;
-            const efSQL = `SELECT * FROM [${mj_core_schema()}].vwEntityFields ORDER BY EntityID, Sequence`;
-            const allEntityFieldsResult = await pool.request().query(efSQL);
+            const efSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwEntityFields')} ORDER BY EntityID, Sequence`;
+            const allEntityFieldsResult = await this.runQuery(pool, efSQL);
             const allEntityFields = allEntityFieldsResult.recordset;
             const generationPromises = [];
             const columnLevelResults = result.filter((r) => r.EntityFieldID); // get the column level constraints
@@ -2249,11 +2321,11 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                             await this.syncEntityFieldValues(pool, r.EntityFieldID, parsedValues, allEntityFieldValues);
                             // finally, make sure the ValueListType column within the EntityField table is set to "List" because for check constraints we only allow the values specified in the list.
                             // check to see if the ValueListType is already set to "List", if not, update it
-                            const sSQLCheck = `SELECT ValueListType FROM [${mj_core_schema()}].EntityField WHERE ID='${r.EntityFieldID}'`;
-                            const checkResultResult = await pool.request().query(sSQLCheck);
+                            const sSQLCheck = `SELECT ValueListType FROM ${this.qs(mj_core_schema(), 'EntityField')} WHERE ID='${r.EntityFieldID}'`;
+                            const checkResultResult = await this.runQuery(pool, sSQLCheck);
                             const checkResult = checkResultResult.recordset;
                             if (checkResult && checkResult.length > 0 && checkResult[0].ValueListType.trim().toLowerCase() !== 'list') {
-                                const sSQL = `UPDATE [${mj_core_schema()}].EntityField SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
+                                const sSQL = `UPDATE ${this.qs(mj_core_schema(), 'EntityField')} SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
                                 await this.LogSQLAndExecute(pool, sSQL, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
                             }
                         }
@@ -2381,13 +2453,12 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             // now, loop through the possible values and add any that are not already in the database
             // Step 1: for any existing value that is NOT in the list of possible Values, delete it
             let numRemoved = 0;
-            const transaction = new sql.Transaction(ds);
-            await transaction.begin();
+            const transaction = await ds.beginTransaction();
             try {
                 for (const ev of existingValues) {
                     if (!possibleValues.find(v => v === ev.Value)) {
                         // delete the value from the database
-                        const sSQLDelete = `DELETE FROM [${mj_core_schema()}].EntityFieldValue WHERE ID='${ev.ID}'`;
+                        const sSQLDelete = `DELETE FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')} WHERE ID='${ev.ID}'`;
                         await this.LogSQLAndExecute(ds, sSQLDelete, `SQL text to delete entity field value ID ${ev.ID}`);
                         numRemoved++;
                     }
@@ -2399,10 +2470,10 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                         // Generate a UUID for this new EntityFieldValue record
                         const newId = uuidv4();
                         // add the value to the database with explicit ID
-                        const sSQLInsert = `INSERT INTO [${mj_core_schema()}].EntityFieldValue
-                                       (ID, EntityFieldID, Sequence, Value, Code)
+                        const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityFieldValue')}
+                                       (${this.qi('ID')}, ${this.qi('EntityFieldID')}, ${this.qi('Sequence')}, ${this.qi('Value')}, ${this.qi('Code')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')})
                                     VALUES
-                                       ('${newId}', '${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}')`;
+                                       ('${newId}', '${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}', ${this.utcNow()}, ${this.utcNow()})`;
                         await this.LogSQLAndExecute(ds, sSQLInsert, `SQL text to insert entity field value with ID ${newId}`);
                         numAdded++;
                     }
@@ -2413,7 +2484,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                     const ev = existingValues.find((ev) => ev.Value === v);
                     if (ev && ev.Sequence !== 1 + possibleValues.indexOf(v)) {
                         // update the sequence to match the order in the possible values list, if it doesn't already match
-                        const sSQLUpdate = `UPDATE [${mj_core_schema()}].EntityFieldValue SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
+                        const sSQLUpdate = `UPDATE ${this.qs(mj_core_schema(), 'EntityFieldValue')} SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
                         await this.LogSQLAndExecute(ds, sSQLUpdate, `SQL text to update entity field value sequence`);
                         numUpdated++;
                     }
@@ -2433,17 +2504,25 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     parseCheckConstraintValues(constraintDefinition, fieldName, entityName) {
         // This regex checks for the overall structure including field name and 'OR' sequences
-        // an example of a valid constraint definition would be: ([FieldName]='Value1' OR [FieldName]='Value2' OR [FieldName]='Value3')
-        // like: ([AutoRunIntervalUnits]='Years' OR [AutoRunIntervalUnits]='Months' OR [AutoRunIntervalUnits]='Weeks' OR [AutoRunIntervalUnits]='Days' OR [AutoRunIntervalUnits]='Hours' OR [AutoRunIntervalUnits]='Minutes')
-        // Also handles constraints with optional NULL: ([FieldName]='Value1' OR [FieldName]='Value2' OR [FieldName] IS NULL)
-        // Also handles nested NULL pattern: ([FieldName] IS NULL OR ([FieldName]='Value1' OR [FieldName]='Value2'))
+        // SQL Server uses [FieldName]='Value' quoting, PostgreSQL uses "FieldName" or unquoted FieldName
+        // We handle both: [FieldName], "FieldName", or bare FieldName
         // Note: Assuming fieldName does not contain regex special characters; otherwise, it needs to be escaped as well.
         const processedConstraint = constraintDefinition.replace(/(^|[=(\s])N'([^']*)'/g, "$1'$2'");
-        // Check for nested pattern: ([Field] IS NULL OR ([Field]='Value1' OR ...))
-        const nestedNullRegex = new RegExp(`^\\(\\[${fieldName}\\] IS NULL OR \\(\\[${fieldName}\\]='[^']+'(?: OR \\[${fieldName}\\]='[^']+?')+\\)\\)$`);
+        // PostgreSQL ANY (ARRAY[...]) pattern:
+        // CHECK ((("FieldName")::text = ANY ((ARRAY['Val1'::character varying, 'Val2'::character varying])::text[])))
+        // Also handles simpler forms: ("FieldName" = ANY (ARRAY['Val1', 'Val2']))
+        const pgArrayValues = this.parsePgArrayConstraint(processedConstraint);
+        if (pgArrayValues) {
+            return pgArrayValues;
+        }
+        // Build a regex fragment that matches the field name in any quoting style:
+        // [FieldName] (SQL Server) or "FieldName" (PostgreSQL) or bare FieldName
+        const quotedField = `(?:\\[${fieldName}\\]|"${fieldName}"|${fieldName})`;
+        // Check for nested pattern: (Field IS NULL OR (Field='Value1' OR ...))
+        const nestedNullRegex = new RegExp(`^\\(${quotedField} IS NULL OR \\(${quotedField}='[^']+'(?: OR ${quotedField}='[^']+?')+\\)\\)$`);
         if (nestedNullRegex.test(processedConstraint)) {
             // Extract values from nested pattern - same extraction logic works
-            const valueRegex = new RegExp(`\\[${fieldName}\\]='([^']+)\'`, 'g');
+            const valueRegex = new RegExp(`${quotedField}='([^']+)\'`, 'g');
             let match;
             const possibleValues = [];
             while ((match = valueRegex.exec(processedConstraint)) !== null) {
@@ -2457,16 +2536,13 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             return possibleValues.length > 0 ? possibleValues : null;
         }
         // Check for standard pattern with optional trailing IS NULL
-        const structureRegex = new RegExp(`^\\(\\[${fieldName}\\]='[^']+'(?: OR \\[${fieldName}\\]='[^']+?')+(?: OR \\[${fieldName}\\] IS NULL)?\\)$`);
+        const structureRegex = new RegExp(`^\\(${quotedField}='[^']+'(?: OR ${quotedField}='[^']+?')+(?: OR ${quotedField} IS NULL)?\\)$`);
         if (!structureRegex.test(processedConstraint)) {
-            // decided to NOT log these warnings anymore becuase they make it appear to the user that there is a problem but there is NOT, this is normal behvario for all othe types of
-            // check constraints that are not simple OR conditions
-            //logWarning(`         Can't extract value list from [${entityName}].[${fieldName}]. The check constraint does not match the simple OR condition pattern or field name does not match:   ${constraintDefinition}`);
             return null;
         }
         else {
             // Regular expression to match the values within the single quotes specifically for the field
-            const valueRegex = new RegExp(`\\[${fieldName}\\]='([^']+)\'`, 'g');
+            const valueRegex = new RegExp(`${quotedField}='([^']+)\'`, 'g');
             let match;
             const possibleValues = [];
             // Use regex to find matches and extract the values
@@ -2483,24 +2559,51 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             return possibleValues;
         }
     }
+    /**
+     * Parses PostgreSQL ANY (ARRAY[...]) CHECK constraint syntax.
+     * PG's pg_get_constraintdef() returns constraints like:
+     *   CHECK ((("Status")::text = ANY ((ARRAY['Confirmed'::character varying, 'Cancelled'::character varying])::text[])))
+     * This method extracts the string values from the ARRAY literal.
+     */
+    parsePgArrayConstraint(constraintDefinition) {
+        // Match the ARRAY[...] portion, handling optional type casts
+        const arrayMatch = constraintDefinition.match(/\bARRAY\s*\[([^\]]+)\]/i);
+        if (!arrayMatch) {
+            return null;
+        }
+        // Extract individual values from the array content
+        // Each element looks like: 'Value'::character varying  or just  'Value'
+        const arrayContent = arrayMatch[1];
+        const valueRegex = /'([^']+)'(?:::[^,\]]*)?/g;
+        const possibleValues = [];
+        let match;
+        while ((match = valueRegex.exec(arrayContent)) !== null) {
+            if (match[1]) {
+                possibleValues.push(match[1]);
+            }
+        }
+        return possibleValues.length > 0 ? possibleValues : null;
+    }
     createExcludeTablesAndSchemasFilter(fieldPrefix) {
         let sExcludeTables = '';
         let sExcludeSchemas = '';
+        const schemaCol = `${fieldPrefix}${this.qi('SchemaName')}`;
+        const tableCol = `${fieldPrefix}${this.qi('TableName')}`;
         if (configInfo.excludeTables) {
             for (let i = 0; i < configInfo.excludeTables.length; ++i) {
                 const t = configInfo.excludeTables[i];
                 sExcludeTables += (sExcludeTables.length > 0 ? ' AND ' : '') +
-                    (t.schema.indexOf('%') > -1 ? ` NOT ( ${fieldPrefix}SchemaName LIKE '${t.schema}'` :
-                        ` NOT ( ${fieldPrefix}SchemaName = '${t.schema}'`);
-                sExcludeTables += (t.table.indexOf('%') > -1 ? ` AND ${fieldPrefix}TableName LIKE '${t.table}') ` :
-                    ` AND ${fieldPrefix}TableName = '${t.table}') `);
+                    (t.schema.indexOf('%') > -1 ? ` NOT ( ${schemaCol} LIKE '${t.schema}'` :
+                        ` NOT ( ${schemaCol} = '${t.schema}'`);
+                sExcludeTables += (t.table.indexOf('%') > -1 ? ` AND ${tableCol} LIKE '${t.table}') ` :
+                    ` AND ${tableCol} = '${t.table}') `);
             }
         }
         if (configInfo.excludeSchemas) {
             for (let i = 0; i < configInfo.excludeSchemas.length; ++i) {
                 const s = configInfo.excludeSchemas[i];
                 sExcludeSchemas += (sExcludeSchemas.length > 0 ? ' AND ' : '') +
-                    (s.indexOf('%') > -1 ? `${fieldPrefix}SchemaName NOT LIKE '${s}'` : `${fieldPrefix}SchemaName <> '${s}'`);
+                    (s.indexOf('%') > -1 ? `${schemaCol} NOT LIKE '${s}'` : `${schemaCol} <> '${s}'`);
             }
         }
         const sWhere = (sExcludeTables.length > 0 || sExcludeSchemas.length > 0 ? ` AND ` : '') +
@@ -2510,13 +2613,12 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     async createNewEntities(pool, currentUser) {
         try {
-            const sSQL = `SELECT * FROM [${mj_core_schema()}].vwSQLTablesAndEntities WHERE EntityID IS NULL ` + this.createExcludeTablesAndSchemasFilter('');
-            const newEntitiesResult = await pool.request().query(sSQL);
+            const sSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'vwSQLTablesAndEntities')} WHERE ${this.qi('EntityID')} IS NULL ` + this.createExcludeTablesAndSchemasFilter('');
+            const newEntitiesResult = await this.runQuery(pool, sSQL);
             const newEntities = newEntitiesResult.recordset;
             if (newEntities && newEntities.length > 0) {
                 const md = new Metadata();
-                const transaction = new sql.Transaction(pool);
-                await transaction.begin();
+                const transaction = await pool.beginTransaction();
                 try {
                     // wrap in a transaction so we get all of it or none of it
                     for (let i = 0; i < newEntities.length; ++i) {
@@ -2547,9 +2649,9 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
         // criteria:
         // 1) entity has a field that is a primary key
         // validate all of these factors by getting the sql from SQL Server and check the result, if failure, shouldCreate=false and generate validation message, otherwise return empty validation message and true for shouldCreate.
-        const query = `EXEC ${Metadata.Provider.ConfigData.MJCoreSchemaName}.spGetPrimaryKeyForTable @TableName='${newEntity.TableName}', @SchemaName='${newEntity.SchemaName}'`;
+        const query = this.dbProvider.callRoutineSQL(Metadata.Provider.ConfigData.MJCoreSchemaName, 'spGetPrimaryKeyForTable', [`'${newEntity.TableName}'`, `'${newEntity.SchemaName}'`], ['TableName', 'SchemaName']);
         try {
-            const resultResult = await ds.request().query(query);
+            const resultResult = await ds.query(query);
             const result = resultResult.recordset;
             if (result.length === 0) {
                 // No database PK constraint found - check if there's a soft PK defined in config
@@ -2784,9 +2886,9 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                     if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
                         // only do this if the configuration setting is set to add new entities to applications for schema names
                         for (const appUUID of apps) {
-                            const sSQLInsertApplicationEntity = `INSERT INTO ${mj_core_schema()}.ApplicationEntity
-                                       (ApplicationID, EntityID, Sequence) VALUES
-                                       ('${appUUID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${mj_core_schema()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
+                            const sSQLInsertApplicationEntity = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+                                       (${this.qi('ApplicationID')}, ${this.qi('EntityID')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
+                                       ('${appUUID}', '${newEntityID}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(mj_core_schema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
                             await this.LogSQLAndExecute(pool, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
                         }
                     }
@@ -2805,9 +2907,9 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                     for (const p of permissions) {
                         const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
                         if (RoleID) {
-                            const sSQLInsertPermission = `INSERT INTO ${mj_core_schema()}.EntityPermission
-                                                   (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES
-                                                   ('${newEntityID}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0})`;
+                            const sSQLInsertPermission = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityPermission')}
+                                                   (${this.qi('EntityID')}, ${this.qi('RoleID')}, ${this.qi('CanRead')}, ${this.qi('CanCreate')}, ${this.qi('CanUpdate')}, ${this.qi('CanDelete')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
+                                                   ('${newEntityID}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0}, ${this.utcNow()}, ${this.utcNow()})`;
                             await this.LogSQLAndExecute(pool, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
                         }
                         else
@@ -2832,10 +2934,12 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     async isSchemaNew(pool, schemaName) {
         // check to see if there are any entities in the db with this schema name
-        const sSQL = `SELECT COUNT(*) AS Count FROM [${mj_core_schema()}].Entity WHERE SchemaName = '${schemaName}'`;
-        const resultResult = await pool.request().query(sSQL);
+        // Quote the alias so PostgreSQL preserves PascalCase (unquoted aliases are lowercased in PG)
+        const sSQL = `SELECT COUNT(*) AS ${this.qi('Count')} FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE ${this.qi('SchemaName')} = '${schemaName}'`;
+        const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
-        return result && result.length > 0 ? result[0].Count === 0 : true;
+        // Use Number() because PG returns COUNT(*) as bigint, which the pg driver delivers as a string
+        return result && result.length > 0 ? Number(result[0].Count) === 0 : true;
     }
     /**
      * Creates a new application using direct SQL INSERT to ensure it's captured in SQL logging.
@@ -2860,7 +2964,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                 .replace(/[^a-z0-9-]/g, '') // remove special chars
                 .replace(/-+/g, '-') // collapse multiple hyphens
                 .replace(/^-|-$/g, ''); // trim hyphens from start/end
-            const sSQL = `INSERT INTO [${mj_core_schema()}].Application (ID, Name, Description, SchemaAutoAddNewEntities, Path, AutoUpdatePath)
+            const sSQL = `INSERT INTO ${this.qs(mj_core_schema(), 'Application')} (ID, Name, Description, SchemaAutoAddNewEntities, Path, AutoUpdatePath)
                        VALUES ('${appID}', '${appName}', 'Generated for schema', '${schemaName}', '${path}', 1)`;
             await this.LogSQLAndExecute(pool, sSQL, `SQL generated to create new application ${appName}`);
             LogStatus(`Created new application ${appName} with Path: ${path}`);
@@ -2872,15 +2976,15 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
         }
     }
     async applicationExists(pool, applicationName) {
-        const sSQL = `SELECT ID FROM [${mj_core_schema()}].Application WHERE Name = '${applicationName}'`;
-        const resultResult = await pool.request().query(sSQL);
+        const sSQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'Application')} WHERE Name = '${applicationName}'`;
+        const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
         return result && result.length > 0 ? result[0].ID.length > 0 : false;
     }
     async getApplicationIDForSchema(pool, schemaName) {
         // get all the apps each time from DB as we might be adding, don't use Metadata here for that reason
-        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM [${mj_core_schema()}].vwApplications`;
-        const resultResult = await pool.request().query(sSQL);
+        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM ${this.qs(mj_core_schema(), 'vwApplications')}`;
+        const resultResult = await this.runQuery(pool, sSQL);
         const result = resultResult.recordset;
         if (!result || result.length === 0) {
             // no applications found, return null
@@ -2921,9 +3025,9 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
         if (apps && apps.length > 0) {
             if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
                 for (const appUUID of apps) {
-                    const sSQLInsert = `INSERT INTO ${mj_core_schema()}.ApplicationEntity
-                                    (ApplicationID, EntityID, Sequence) VALUES
-                                    ('${appUUID}', '${entityId}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${mj_core_schema()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
+                    const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+                                    (${this.qi('ApplicationID')}, ${this.qi('EntityID')}, ${this.qi('Sequence')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
+                                    ('${appUUID}', '${entityId}', (SELECT COALESCE(MAX(${this.qi('Sequence')}),0)+1 FROM ${this.qs(mj_core_schema(), 'ApplicationEntity')} WHERE ${this.qi('ApplicationID')} = '${appUUID}'), ${this.utcNow()}, ${this.utcNow()})`;
                     await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add entity ${entityName} to application ID: '${appUUID}'`);
                 }
             }
@@ -2945,9 +3049,9 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
         for (const p of permissions) {
             const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
             if (RoleID) {
-                const sSQLInsert = `INSERT INTO ${mj_core_schema()}.EntityPermission
-                                 (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES
-                                 ('${entityId}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0})`;
+                const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityPermission')}
+                                 (${this.qi('EntityID')}, ${this.qi('RoleID')}, ${this.qi('CanRead')}, ${this.qi('CanCreate')}, ${this.qi('CanUpdate')}, ${this.qi('CanDelete')}, ${this.qi('__mj_CreatedAt')}, ${this.qi('__mj_UpdatedAt')}) VALUES
+                                 ('${entityId}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0}, ${this.utcNow()}, ${this.utcNow()})`;
                 await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add permission for entity ${entityName} for role ${p.RoleName}`);
             }
             else {
@@ -2957,27 +3061,30 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     }
     createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix, newEntityDisplayName) {
         const newEntityDefaults = configInfo.newEntityDefaults;
-        const newEntityDescriptionEscaped = newEntity.Description ? `'${newEntity.Description.replace(/'/g, "''")}` : null;
+        const newEntityDescriptionEscaped = newEntity.EntityDescription ? `'${newEntity.EntityDescription.replace(/'/g, "''")}'` : null;
+        const q = (name) => this.qi(name);
         const sSQLInsert = `
-      INSERT INTO [${mj_core_schema()}].Entity (
-         ID,
-         Name,
-         DisplayName,
-         Description,
-         NameSuffix,
-         BaseTable,
-         BaseView,
-         SchemaName,
-         IncludeInAPI,
-         AllowUserSearchAPI
-         ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', TrackRecordChanges'}
-         ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', AuditRecordAccess'}
-         ${newEntityDefaults.AuditViewRuns === undefined ? '' : ', AuditViewRuns'}
-         ${newEntityDefaults.AllowAllRowsAPI === undefined ? '' : ', AllowAllRowsAPI'}
-         ${newEntityDefaults.AllowCreateAPI === undefined ? '' : ', AllowCreateAPI'}
-         ${newEntityDefaults.AllowUpdateAPI === undefined ? '' : ', AllowUpdateAPI'}
-         ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', AllowDeleteAPI'}
-         ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', UserViewMaxRows'}
+      INSERT INTO ${this.qs(mj_core_schema(), 'Entity')} (
+         ${q('ID')},
+         ${q('Name')},
+         ${q('DisplayName')},
+         ${q('Description')},
+         ${q('NameSuffix')},
+         ${q('BaseTable')},
+         ${q('BaseView')},
+         ${q('SchemaName')},
+         ${q('IncludeInAPI')},
+         ${q('AllowUserSearchAPI')}
+         ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', ' + q('TrackRecordChanges')}
+         ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', ' + q('AuditRecordAccess')}
+         ${newEntityDefaults.AuditViewRuns === undefined ? '' : ', ' + q('AuditViewRuns')}
+         ${newEntityDefaults.AllowAllRowsAPI === undefined ? '' : ', ' + q('AllowAllRowsAPI')}
+         ${newEntityDefaults.AllowCreateAPI === undefined ? '' : ', ' + q('AllowCreateAPI')}
+         ${newEntityDefaults.AllowUpdateAPI === undefined ? '' : ', ' + q('AllowUpdateAPI')}
+         ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', ' + q('AllowDeleteAPI')}
+         ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', ' + q('UserViewMaxRows')}
+         , ${q('__mj_CreatedAt')}
+         , ${q('__mj_UpdatedAt')}
       )
       VALUES (
          '${newEntityUUID}',
@@ -2998,6 +3105,8 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
          ${newEntityDefaults.AllowUpdateAPI === undefined ? '' : ', ' + (newEntityDefaults.AllowUpdateAPI ? '1' : '0')}
          ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', ' + (newEntityDefaults.AllowDeleteAPI ? '1' : '0')}
          ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', ' + (newEntityDefaults.UserViewMaxRows)}
+         , ${this.utcNow()}
+         , ${this.utcNow()}
       )
    `;
         return sSQLInsert;
@@ -3051,13 +3160,13 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                e.BaseTable,
                e.ParentID
             FROM
-               [${mj_core_schema()}].vwEntities e
+               ${this.qs(mj_core_schema(), 'vwEntities')} e
             WHERE
                ${whereClause}
             ORDER BY
                e.Name
          `;
-            const entitiesResult = await pool.request().query(entitiesSQL);
+            const entitiesResult = await this.runQuery(pool, entitiesSQL);
             const entities = entitiesResult.recordset;
             if (entities.length === 0) {
                 return true;
@@ -3089,14 +3198,14 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                ef.DefaultInView,
                ef.IncludeInUserSearchAPI
             FROM
-               [${mj_core_schema()}].vwEntityFields ef
+               ${this.qs(mj_core_schema(), 'vwEntityFields')} ef
             WHERE
                ef.EntityID IN (${entityIds})
             ORDER BY
                ef.EntityID,
                ef.Sequence
          `;
-            const fieldsResult = await pool.request().query(fieldsSQL);
+            const fieldsResult = await this.runQuery(pool, fieldsSQL);
             const allFields = fieldsResult.recordset;
             // Get EntitySettings for all entities (for existing category icons/info)
             const settingsSQL = `
@@ -3105,12 +3214,12 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                es.Name,
                es.Value
             FROM
-               [${mj_core_schema()}].EntitySetting es
+               ${this.qs(mj_core_schema(), 'EntitySetting')} es
             WHERE
                es.EntityID IN (${entityIds})
                AND es.Name = 'FieldCategoryInfo'
          `;
-            const settingsResult = await pool.request().query(settingsSQL);
+            const settingsResult = await this.runQuery(pool, settingsSQL);
             const allSettings = settingsResult.recordset;
             // Group settings by entity
             const settingsByEntity = {};
@@ -3175,7 +3284,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
     async processEntityAdvancedGeneration(pool, entity, allFields, ag, currentUser) {
         try {
             // Filter fields for this entity (client-side filtering)
-            const fields = allFields.filter((f) => f.EntityID === entity.ID);
+            const fields = allFields.filter((f) => UUIDsEqual(f.EntityID, entity.ID));
             // Determine if this is a new entity (for DefaultForNewUser decision)
             const isNewEntity = ManageMetadataBase.newEntityList.includes(entity.Name);
             // Smart Field Identification
@@ -3236,7 +3345,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             if (visited.has(currentParentID))
                 break; // circular reference guard
             visited.add(currentParentID);
-            const parentEntity = allEntities.find(e => e.ID === currentParentID);
+            const parentEntity = allEntities.find(e => UUIDsEqual(e.ID, currentParentID));
             if (!parentEntity)
                 break;
             parentChain.push({ entityID: parentEntity.ID, entityName: parentEntity.Name });
@@ -3264,7 +3373,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
      */
     findFieldSourceParent(fieldName, parentChain, allEntities) {
         for (const parent of parentChain) {
-            const parentEntity = allEntities.find(e => e.ID === parent.entityID);
+            const parentEntity = allEntities.find(e => UUIDsEqual(e.ID, parent.entityID));
             if (!parentEntity)
                 continue;
             // Check if this parent has a non-virtual field with this name
@@ -3284,7 +3393,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
         const nameField = fields.find(f => f.Name === result.nameField);
         if (nameField && nameField.AutoUpdateIsNameField && nameField.ID && !nameField.IsNameField /*don't waste SQL to set the value if IsNameField already set */) {
             sqlStatements.push(`
-            UPDATE [${mj_core_schema()}].EntityField
+            UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
             SET IsNameField = 1
             WHERE ID = '${nameField.ID}'
             AND AutoUpdateIsNameField = 1
@@ -3305,7 +3414,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
             if (!field.DefaultInView) {
                 // only set these when DefaultInView not already on, otherwise wasteful
                 sqlStatements.push(`
-               UPDATE [${mj_core_schema()}].EntityField
+               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
                SET DefaultInView = 1
                WHERE ID = '${field.ID}'
                AND AutoUpdateDefaultInView = 1
@@ -3325,7 +3434,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                 if (!field.IncludeInUserSearchAPI) {
                     // only set this if IncludeInUserSearchAPI isn't already set
                     sqlStatements.push(`
-                  UPDATE [${mj_core_schema()}].EntityField
+                  UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
                   SET IncludeInUserSearchAPI = 1
                   WHERE ID = '${field.ID}'
                   AND AutoUpdateIncludeInUserSearchAPI = 1
@@ -3429,7 +3538,7 @@ DROP TABLE #__mj__CodeGen__vwTableUniqueKeys;
                 }
                 if (setClauses.length > 0) {
                     // only generate an UPDATE if we have 1+ set clause
-                    sqlStatements.push(`\n-- UPDATE Entity Field Category Info ${entity.Name}.${field.Name} \nUPDATE [${mj_core_schema()}].EntityField
+                    sqlStatements.push(`\n-- UPDATE Entity Field Category Info ${entity.Name}.${field.Name} \nUPDATE ${this.qs(mj_core_schema(), 'EntityField')}
 SET 
    ${setClauses.join(',\n   ')}
 WHERE 
@@ -3455,15 +3564,15 @@ WHERE
     async applyEntityIcon(pool, entityId, entityIcon) {
         if (!entityIcon || entityIcon.trim().length === 0)
             return;
-        const checkSQL = `SELECT Icon FROM [${mj_core_schema()}].Entity WHERE ID = '${entityId}'`;
-        const entityCheck = await pool.request().query(checkSQL);
+        const checkSQL = `SELECT Icon FROM ${this.qs(mj_core_schema(), 'Entity')} WHERE ID = '${entityId}'`;
+        const entityCheck = await this.runQuery(pool, checkSQL);
         if (entityCheck.recordset.length > 0) {
             const currentIcon = entityCheck.recordset[0].Icon;
             if (!currentIcon || currentIcon.trim().length === 0) {
                 const escapedIcon = entityIcon.replace(/'/g, "''");
                 const updateSQL = `
-               UPDATE [${mj_core_schema()}].Entity
-               SET Icon = '${escapedIcon}', __mj_UpdatedAt = GETUTCDATE()
+               UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+               SET Icon = '${escapedIcon}', __mj_UpdatedAt = ${this.utcNow()}
                WHERE ID = '${entityId}'
             `;
                 try {
@@ -3484,13 +3593,13 @@ WHERE
             return;
         const infoJSON = JSON.stringify(categoryInfo).replace(/'/g, "''");
         // Upsert FieldCategoryInfo (new format)
-        const checkNewSQL = `SELECT ID FROM [${mj_core_schema()}].EntitySetting WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'`;
-        const existingNew = await pool.request().query(checkNewSQL);
+        const checkNewSQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'`;
+        const existingNew = await this.runQuery(pool, checkNewSQL);
         if (existingNew.recordset.length > 0) {
             try {
                 await this.LogSQLAndExecute(pool, `
-               UPDATE [${mj_core_schema()}].EntitySetting
-               SET Value = '${infoJSON}', __mj_UpdatedAt = GETUTCDATE()
+               UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
+               SET Value = '${infoJSON}', __mj_UpdatedAt = ${this.utcNow()}
                WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
             `, `Update FieldCategoryInfo setting for entity`, false);
             }
@@ -3502,8 +3611,8 @@ WHERE
             const newId = uuidv4();
             try {
                 await this.LogSQLAndExecute(pool, `
-               INSERT INTO [${mj_core_schema()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
-               VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', GETUTCDATE(), GETUTCDATE())
+               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', ${this.utcNow()}, ${this.utcNow()})
             `, `Insert FieldCategoryInfo setting for entity`, false);
             }
             catch (ex) {
@@ -3518,13 +3627,13 @@ WHERE
             }
         }
         const iconsJSON = JSON.stringify(iconsOnly).replace(/'/g, "''");
-        const checkLegacySQL = `SELECT ID FROM [${mj_core_schema()}].EntitySetting WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'`;
-        const existingLegacy = await pool.request().query(checkLegacySQL);
+        const checkLegacySQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'`;
+        const existingLegacy = await this.runQuery(pool, checkLegacySQL);
         if (existingLegacy.recordset.length > 0) {
             try {
                 await this.LogSQLAndExecute(pool, `
-               UPDATE [${mj_core_schema()}].EntitySetting
-               SET Value = '${iconsJSON}', __mj_UpdatedAt = GETUTCDATE()
+               UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
+               SET Value = '${iconsJSON}', __mj_UpdatedAt = ${this.utcNow()}
                WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'
             `, `Update FieldCategoryIcons setting (legacy)`, false);
             }
@@ -3536,8 +3645,8 @@ WHERE
             const newId = uuidv4();
             try {
                 await this.LogSQLAndExecute(pool, `
-               INSERT INTO [${mj_core_schema()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
-               VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', GETUTCDATE(), GETUTCDATE())
+               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', ${this.utcNow()}, ${this.utcNow()})
             `, `Insert FieldCategoryIcons setting (legacy)`, false);
             }
             catch (ex) {
@@ -3552,8 +3661,8 @@ WHERE
     async applyEntityImportance(pool, entityId, importance) {
         const defaultForNewUser = importance.defaultForNewUser ? 1 : 0;
         const updateSQL = `
-         UPDATE [${mj_core_schema()}].ApplicationEntity
-         SET DefaultForNewUser = ${defaultForNewUser}, __mj_UpdatedAt = GETUTCDATE()
+         UPDATE ${this.qs(mj_core_schema(), 'ApplicationEntity')}
+         SET DefaultForNewUser = ${defaultForNewUser}, __mj_UpdatedAt = ${this.utcNow()}
          WHERE EntityID = '${entityId}'
       `;
         try {
@@ -3576,7 +3685,7 @@ WHERE
      * @returns - The result of the query execution.
      */
     async LogSQLAndExecute(pool, query, description, isRecurringScript = false) {
-        return await SQLLogging.LogSQLAndExecute(pool, query, description, isRecurringScript);
+        return await SQLLogging.LogSQLAndExecute(pool, this.qsql(query), description, isRecurringScript);
     }
 }
 //# sourceMappingURL=manage-metadata.js.map