@thierrynakoa/fire-flow 12.2.1 → 13.0.1

package/skills-library/_general/database-solutions/pg-to-mysql-schema-migration-methodology.md

@@ -0,0 +1,190 @@
+---
+name: pg-to-mysql-schema-migration-methodology
+category: database-solutions
+version: 1.0.0
+contributed: 2026-03-06
+contributor: ministry-lms
+last_updated: 2026-03-06
+contributors:
+  - ministry-lms
+tags: [postgresql, mysql, mariadb, migration, schema, uuid, returning, xampp]
+difficulty: medium
+usage_count: 0
+success_rate: 100
+---
+
+# PG to MySQL Schema Migration Methodology
+
+## Problem
+
+When porting a PostgreSQL application to MySQL, the runtime SQL translation layer (sql-compat.js) handles syntax differences. But tables and columns still need to exist in MySQL. PG migrations use PG-specific DDL (UUID, BOOLEAN, TEXT[], JSONB, TIMESTAMP WITH TIME ZONE, partial indexes) that MySQL doesn't support. The result: 500 errors at runtime when controllers reference tables or columns that were never created in MySQL.
+
+**Symptoms:**
+- 500 Internal Server Error on specific endpoints
+- `Table 'db.tablename' doesn't exist` in server logs
+- `Unknown column 'col' in 'field list'` errors
+- RETURNING * emulation returns empty/wrong rows (Strategy 3 returns 0 for UUID tables)
+
+## Solution Pattern
+
+Systematic 4-step process per feature area:
+
+### Step 1: Identify the 500
+
+Trace the error: endpoint URL -> route file -> controller -> model/query -> table name + columns.
+
+### Step 2: Check Table/Column Existence
+
+```javascript
+// Quick check script
+import sql from './config/sql.js';
+try {
+  const cols = await sql.unsafe('DESCRIBE tablename');
+  console.log(cols.map(c => c.Field));
+} catch(e) {
+  console.log('TABLE MISSING:', e.message);
+}
+```
+
+### Step 3: Create MySQL Migration Script
+
+Convert PG DDL to MySQL DDL with these type mappings:
+
+| PostgreSQL | MySQL |
+|------------|-------|
+| `UUID PRIMARY KEY DEFAULT gen_random_uuid()` | `CHAR(36) PRIMARY KEY DEFAULT (UUID())` |
+| `BOOLEAN DEFAULT true` | `TINYINT(1) DEFAULT 1` |
+| `TIMESTAMP WITH TIME ZONE` | `DATETIME` |
+| `TEXT[]` (array) | `JSON DEFAULT NULL` |
+| `JSONB` | `JSON` |
+| `INTEGER[]` | `JSON DEFAULT NULL` |
+| `SERIAL` | `INT AUTO_INCREMENT` |
+| `DECIMAL(10,2)` | `DECIMAL(10,2)` (same) |
+| `VARCHAR(255)` | `VARCHAR(255)` (same) |
+| `REFERENCES table(id) ON DELETE CASCADE` | Omit FK constraints (simpler with UUID tables) |
+| Partial index `WHERE condition` | Regular index (MySQL doesn't support partial) |
+| `CREATE TYPE ... AS ENUM` | `VARCHAR(50)` with application validation |
+| `NOW()` | `CURRENT_TIMESTAMP` (in DEFAULT) or `NOW()` (in queries) |
+
+### Step 4: Fix RETURNING * for UUID Tables
+
+When a table uses `CHAR(36) DEFAULT (UUID())` as primary key:
+- `LAST_INSERT_ID()` returns 0 (only works for AUTO_INCREMENT)
+- The RETURNING emulation Strategy 1 needs `id` in the INSERT column list
+- **Fix:** Generate UUID in JavaScript and include it explicitly
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+
+// Before (broken — RETURNING can't find the row)
+const result = await sql`
+  INSERT INTO courses (title, description)
+  VALUES (${title}, ${desc})
+  RETURNING *
+`;
+
+// After (works — Strategy 1 finds row by id)
+const id = uuidv4();
+const result = await sql`
+  INSERT INTO courses (id, title, description)
+  VALUES (${id}, ${title}, ${desc})
+  RETURNING *
+`;
+```
+
+## Migration Script Template
+
+Use idempotent JS migrations with existence checks:
+
+```javascript
+/**
+ * MySQL Migration: {description}
+ * Run with: node --env-file=.env.local migrations/{number}_{name}.js
+ */
+import sql from '../config/sql.js';
+
+async function addColumnIfMissing(table, column, definition) {
+  const cols = await sql.unsafe(`DESCRIBE ${table}`);
+  const colNames = cols.map(c => c.Field);
+  if (!colNames.includes(column)) {
+    await sql.unsafe(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    console.log(`  Added ${table}.${column}`);
+    return true;
+  }
+  console.log(`  ${table}.${column} already exists`);
+  return false;
+}
+
+async function migrate() {
+  try {
+    // CREATE TABLE IF NOT EXISTS for new tables
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS tablename (
+        id CHAR(36) PRIMARY KEY DEFAULT (UUID()),
+        -- columns here
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        INDEX idx_name (column)
+      )
+    `);
+
+    // ALTER TABLE for missing columns on existing tables
+    await addColumnIfMissing('existing_table', 'new_col', 'VARCHAR(255) DEFAULT NULL');
+
+    console.log('Migration complete!');
+  } catch (error) {
+    console.error('Migration error:', error.message);
+  } finally {
+    await sql.end();
+  }
+}
+
+migrate();
+```
+
+## Diagnostic Cheat Sheet
+
+| HTTP Status | Likely Cause | Check |
+|-------------|-------------|-------|
+| 500 on GET | Missing table or column | `DESCRIBE tablename` |
+| 500 on POST | Missing column in INSERT | Compare INSERT columns vs DESCRIBE |
+| 401 instead of 500 | Table exists, auth works | Fixed! |
+| Empty response on POST | RETURNING emulation failed | Check if `id` is in INSERT columns |
+| Wrong row returned | Strategy 4 race condition | Add explicit UUID to INSERT |
+
+## When to Use
+
+- Porting a PostgreSQL app to MySQL/MariaDB/XAMPP
+- When you see 500 errors on endpoints that work in PG
+- When the sql-compat runtime layer handles syntax but tables are missing
+- When RETURNING * returns empty or wrong rows on UUID tables
+- When multiple PG migrations need to be consolidated into MySQL equivalents
+
+## When NOT to Use
+
+- For SQL syntax translation at runtime (use postgresql-to-mysql-runtime-translation)
+- When the app uses an ORM that handles schema (Prisma, Sequelize)
+- For new applications (design for MySQL from the start)
+- When PG-specific features have no MySQL equivalent (PostGIS, row-level security)
+
+## Common Mistakes
+
+- Forgetting `ON UPDATE CURRENT_TIMESTAMP` for `updated_at` columns (PG uses triggers)
+- Using `LAST_INSERT_ID()` with UUID tables (returns 0)
+- Not making migrations idempotent (crashes on re-run if table/column exists)
+- Copying PG foreign key constraints (keep it simple — omit FKs for UUID tables)
+- Not restarting the server after migration (Node.js caches modules)
+- Using `BOOLEAN` in MySQL DDL without realizing it becomes `TINYINT(1)` (functional, but explicit is clearer)
+
+## Related Skills
+
+- [postgresql-to-mysql-runtime-translation](../database-solutions/postgresql-to-mysql-runtime-translation.md) - Runtime SQL translation layer
+- [reserved-word-context-aware-quoting](../database-solutions/reserved-word-context-aware-quoting.md) - Quoting reserved words
+- [regex-alternation-ordering-sql-types](../database-solutions/regex-alternation-ordering-sql-types.md) - Type cast regex ordering
+
+## References
+
+- MySQL 8.0 CREATE TABLE: https://dev.mysql.com/doc/refman/8.0/en/create-table.html
+- MySQL UUID(): https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid
+- Discovered during: MINISTRY-LMS migration (15+ tables ported in 3 sessions)
+- Contributed from: ministry-lms

package/skills-library/_general/database-solutions/sql-dialect-compatibility-matrix.md

@@ -0,0 +1,306 @@
+---
+name: sql-dialect-compatibility-matrix
+category: database-solutions
+version: 1.0.0
+contributed: 2026-03-10
+contributor: MINISTRY-LMS, research
+last_updated: 2026-03-10
+tags: [postgresql, mysql, sqlite, sql-server, mariadb, migration, dialect, translation]
+difficulty: hard
+---
+
+# SQL Dialect Compatibility Matrix
+
+## Problem
+
+When migrating between databases or building cross-database applications, developers hit dialect differences that cause silent data corruption, runtime errors, or lost functionality. No single reference covers the practical translation rules needed for AI-assisted migration.
+## Solution Pattern
+
+Use this matrix as a lookup table during migration planning and execution. Each section is organized by **task** ("what do you want to do?") rather than by database, following the Wikibooks SQL Dialects Reference structure.
+
+**Critical principle:** Always verify translations by running against the target database. Rules handle the deterministic 80%; the remaining 20% requires human judgment or LLM-assisted review with verification.
+
+## SQL Syntax Translation Rules
+
+### Auto-Increment / Sequential IDs
+
+| PostgreSQL | MySQL/MariaDB | SQLite | SQL Server |
+|---|---|---|---|
+| `SERIAL` | `INT AUTO_INCREMENT` | `INTEGER PRIMARY KEY` (implicit ROWID) | `INT IDENTITY(1,1)` |
+| `BIGSERIAL` | `BIGINT AUTO_INCREMENT` | same (64-bit ROWID) | `BIGINT IDENTITY(1,1)` |
+| `GENERATED ALWAYS AS IDENTITY` | N/A | N/A | `IDENTITY(start, increment)` |
+
+**Gotcha:** MySQL `LAST_INSERT_ID()` returns 0 for UUID primary key tables (`CHAR(36) DEFAULT (UUID())`). Generate UUID in application code and include `id` in INSERT.
+
+### Boolean
+
+| PostgreSQL | MySQL/MariaDB | SQLite | SQL Server |
+|---|---|---|---|
+| `BOOLEAN` (native) | `TINYINT(1)` / `BOOL` alias | `INTEGER` (0/1) | `BIT` |
+
+**Gotcha:** MySQL `BOOL` is literally `TINYINT(1)` — stores 0-127, not just 0/1. Validate value ranges when migrating to PG.
+
+### Text / String Types
+
+| PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|
+| `VARCHAR(n)` up to 10M | `VARCHAR(n)` up to 65K | `TEXT` (all strings) | `VARCHAR(n)` up to 8K; `VARCHAR(MAX)` |
+| `TEXT` (unlimited) | `TINYTEXT/TEXT/MEDIUMTEXT/LONGTEXT` | `TEXT` | `TEXT`/`NTEXT` |
+
+**Gotcha:** MySQL silently truncates in some SQL modes; PG raises error. pgloader maps all MySQL TEXT variants to PG `TEXT`.
+
+### Date / Time Types
+
+| PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|
+| `TIMESTAMP` | `DATETIME` | `TEXT` (ISO 8601) | `DATETIME2(p)` |
+| `TIMESTAMPTZ` | `TIMESTAMP` (auto UTC) | `TEXT` | `DATETIMEOFFSET(p)` |
+| `INTERVAL` | N/A | N/A | N/A |
+
+**Gotcha:** MySQL allows `0000-00-00` dates; PG rejects them. pgloader converts to NULL. **HIGH data loss risk** for timezone conversions.
+
+### UUID
+
+| PostgreSQL | MySQL/MariaDB | SQLite | SQL Server |
+|---|---|---|---|
+| `UUID` (native) | `CHAR(36)` / `VARCHAR(36)` | `TEXT` | `UNIQUEIDENTIFIER` |
+| `gen_random_uuid()` | `UUID()` | N/A (app-side) | `NEWID()` |
+
+### JSON
+
+| PostgreSQL | MySQL | SQLite | SQL Server | MariaDB |
+|---|---|---|---|---|
+| `JSONB` (binary, indexable) | `JSON` (validated) | `JSON` (3.45+ JSONB) | `NVARCHAR(MAX)` | `JSON` (alias for `LONGTEXT`) |
+| `col->>'key'` | `JSON_UNQUOTE(JSON_EXTRACT(col, '$.key'))` | `json_extract(col, '$.key')` | `JSON_VALUE(col, '$.key')` | same as MySQL |
+| `col->'key'` | `JSON_EXTRACT(col, '$.key')` | `json_extract(col, '$.key')` | `JSON_QUERY(col, '$.key')` | same as MySQL |
+| `col @> '{"k":"v"}'` | N/A | N/A | N/A | N/A |
+| GIN index on JSONB | Generated column + B-tree | N/A | Computed column + index | N/A |
+
+**Gotcha:** PG `->` uses plain key names; MySQL uses JSONPath (`$.key`). Completely different path syntax.
+
+### Arrays
+
+| PostgreSQL | MySQL | SQLite | SQL Server | MariaDB |
+|---|---|---|---|---|
+| `TEXT[]`, `INT[]` (native) | N/A (use JSON) | N/A | N/A | N/A |
+
+**PG-only.** Must denormalize to JSON array or junction table for other databases.
+
+### Enums
+
+| PostgreSQL | MySQL/MariaDB | SQLite | SQL Server |
+|---|---|---|---|
+| `CREATE TYPE status AS ENUM(...)` (type-level) | `ENUM(...)` (column-level inline) | N/A (use CHECK) | N/A (use CHECK) |
+
+**Gotcha:** pgloader creates separate `CREATE TYPE` for each MySQL inline ENUM.
+
+## SQL Syntax Differences
+
+### RETURNING Clause
+
+| Database | Support | Syntax |
+|---|---|---|
+| PostgreSQL | Full (INSERT/UPDATE/DELETE) | `INSERT ... RETURNING *` |
+| MySQL | **None** | Use `LAST_INSERT_ID()` or re-SELECT |
+| SQLite | Full (3.35+) | `INSERT ... RETURNING *` |
+| SQL Server | Full | `OUTPUT inserted.*` / `OUTPUT deleted.*` |
+| MariaDB | Partial (INSERT/DELETE only) | `INSERT ... RETURNING *` |
+
+**MINISTRY-LMS pattern:** 4-strategy fallback chain:
+1. UUID lookup (best for UUID PKs)
+2. Unique column lookup (for upserts)
+3. `LAST_INSERT_ID()` (auto-increment only — returns 0 for UUID!)
+4. Most recent row by `created_at` (race condition risk)
+
+### UPSERT / Merge
+
+| Database | Syntax |
+|---|---|
+| PostgreSQL | `INSERT ... ON CONFLICT (col) DO UPDATE SET ...` |
+| MySQL/MariaDB | `INSERT ... ON DUPLICATE KEY UPDATE ...` |
+| SQLite | `INSERT ... ON CONFLICT (col) DO UPDATE SET ...` (same as PG) |
+| SQL Server | `MERGE INTO ... USING ... WHEN MATCHED THEN UPDATE ...` |
+
+**Translation:** `ON CONFLICT ... DO UPDATE` → `ON DUPLICATE KEY UPDATE`, `EXCLUDED.col` → `VALUES(col)`, `DO NOTHING` → `INSERT IGNORE INTO`.
+
+### LIMIT / OFFSET
+
+| Database | Syntax |
+|---|---|
+| PostgreSQL | `LIMIT n OFFSET k` |
+| MySQL/MariaDB | `LIMIT n OFFSET k` or `LIMIT k, n` |
+| SQLite | `LIMIT n OFFSET k` |
+| SQL Server | `OFFSET k ROWS FETCH NEXT n ROWS ONLY` (requires ORDER BY) |
+
+**Gotcha:** MySQL rejects `LIMIT '20'` (string); PG silently casts. Always `parseInt()` LIMIT/OFFSET from Express `req.query`.
+
+### String Concatenation
+
+| Database | Syntax |
+|---|---|
+| PostgreSQL | `'a' \|\| 'b'` |
+| MySQL | `CONCAT('a', 'b')` (`\|\|` means OR by default) |
+| SQLite | `'a' \|\| 'b'` |
+| SQL Server | `'a' + 'b'` |
+
+### Identifier Quoting
+
+| Database | Quote Character |
+|---|---|
+| PostgreSQL | `"double quotes"` (case-preserving) |
+| MySQL/MariaDB | `` `backticks` `` |
+| SQLite | `"double quotes"` or `` `backticks` `` |
+| SQL Server | `[brackets]` or `"double quotes"` |
+
+### NULL Sort Order
+
+| Database | Default ASC | Default DESC |
+|---|---|---|
+| PostgreSQL | NULLs LAST | NULLs FIRST |
+| MySQL | NULLs FIRST | NULLs LAST |
+| SQLite | NULLs FIRST | NULLs LAST |
+| SQL Server | NULLs FIRST | NULLs LAST |
+
+**Translation:** PG `NULLS LAST` → MySQL `ORDER BY col IS NULL, col DESC`. PG `NULLS FIRST` → MySQL `ORDER BY col IS NOT NULL, col ASC`.
+
+### Type Casting
+
+| Database | Shorthand | Standard |
+|---|---|---|
+| PostgreSQL | `x::type` | `CAST(x AS type)` |
+| MySQL | N/A | `CAST(x AS type)` / `CONVERT(x, type)` |
+| SQLite | N/A | `CAST(x AS type)` |
+| SQL Server | N/A | `CAST(x AS type)` / `CONVERT(type, x)` |
+
+**Translation:** Strip all PG `::type` patterns for MySQL/SQLite. Use `CAST()` for portability.
+
+## Function Translation
+
+### Date Functions
+
+| Operation | PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|---|
+| Current time | `NOW()` | `NOW()` | `datetime('now')` | `GETDATE()` |
+| Extract part | `EXTRACT(YEAR FROM d)` | `YEAR(d)` | `strftime('%Y', d)` | `DATEPART(year, d)` |
+| Date add | `d + INTERVAL '1 day'` | `DATE_ADD(d, INTERVAL 1 DAY)` | `datetime(d, '+1 day')` | `DATEADD(day, 1, d)` |
+| Date diff | `d1 - d2` (interval) | `DATEDIFF(d1, d2)` (days) | `julianday(d1) - julianday(d2)` | `DATEDIFF(day, d1, d2)` |
+| Format | `TO_CHAR(d, 'YYYY-MM-DD')` | `DATE_FORMAT(d, '%Y-%m-%d')` | `strftime('%Y-%m-%d', d)` | `FORMAT(d, 'yyyy-MM-dd')` |
+| Truncate | `DATE_TRUNC('month', d)` | `DATE_FORMAT(d, '%Y-%m-01')` | `strftime('%Y-%m-01', d)` | `DATETRUNC(month, d)` |
+
+**Format token mapping (PG → MySQL):** `YYYY→%Y`, `MM→%m`, `DD→%d`, `HH24→%H`, `MI→%i`, `SS→%s`.
+
+### String Functions
+
+| Operation | PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|---|
+| Length | `LENGTH(s)` | `LENGTH(s)` | `LENGTH(s)` | `LEN(s)` |
+| Position | `POSITION(sub IN s)` | `LOCATE(sub, s)` | `INSTR(s, sub)` | `CHARINDEX(sub, s)` |
+| Regex match | `~ 'pattern'` | `REGEXP 'pattern'` | N/A | N/A |
+| Case-insensitive LIKE | `ILIKE` | `LIKE` (CI by default) | `LIKE` (CI for ASCII) | `LIKE` (collation) |
+| String split | `split_part(s, ',', 2)` | `SUBSTRING_INDEX(SUBSTRING_INDEX(s, ',', 2), ',', -1)` | N/A | N/A |
+
+### Aggregate Functions
+
+| Operation | PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|---|
+| String agg | `STRING_AGG(col, ',')` | `GROUP_CONCAT(col SEPARATOR ',')` | `GROUP_CONCAT(col, ',')` | `STRING_AGG(col, ',')` (2017+) |
+| JSON agg | `json_agg(col)` | `CONCAT('[', GROUP_CONCAT(col), ']')` | `json_group_array(col)` | N/A |
+| Filtered agg | `COUNT(*) FILTER (WHERE x)` | `SUM(CASE WHEN x THEN 1 ELSE 0 END)` | N/A | N/A |
+| JSON object | `jsonb_build_object('k', v)` | `JSON_OBJECT('k', v)` | `json_object('k', v)` | N/A |
+
+## Constraints & Indexing
+
+### Constraint Support
+
+| Feature | PostgreSQL | MySQL (InnoDB) | SQLite | SQL Server |
+|---|---|---|---|---|
+| CHECK constraints | Full | Enforced 8.0.16+ (ignored before!) | Full | Full |
+| Deferred constraints | `DEFERRABLE INITIALLY DEFERRED` | **Not supported** | Supported | **Not supported** |
+| EXCLUDE constraints | Full (GiST) | **Not supported** | **Not supported** | **Not supported** |
+| Multiple cascade paths | Allowed | Allowed | Allowed | **Not allowed** |
+
+**Gotcha:** MySQL CHECK constraints were silently ignored for years. Data may violate constraints after PG migration.
+
+### Index Types
+
+| Feature | PostgreSQL | MySQL | SQLite | SQL Server |
+|---|---|---|---|---|
+| Partial index | `WHERE condition` | **No** | Yes (3.8+) | Yes (filtered) |
+| Expression index | `ON (lower(col))` | **No** (use generated column) | Yes (3.9+) | Computed column |
+| GIN (inverted) | Yes | **No** | **No** | **No** |
+| Covering (INCLUDE) | Yes (11+) | **No** | **No** | Yes |
+| Concurrent creation | `CONCURRENTLY` | `ALGORITHM=INPLACE` | **No** | `ONLINE = ON` |
+
+## Automatable vs Human Judgment
+
+### Fully Automatable (lookup table)
+- Basic type mappings (INT, VARCHAR, TEXT, DATE)
+- Auto-increment syntax
+- LIMIT/OFFSET syntax
+- String concatenation
+- Identifier quoting
+- UPSERT templates
+- RETURNING clause templates
+- Type cast stripping (`::type`)
+- ILIKE → LIKE
+- Interval syntax (`INTERVAL '30 days'` → `INTERVAL 30 DAY`)
+
+### Partially Automatable (rules + validation)
+- Unsigned integer upsizing (MySQL UNSIGNED INT → PG BIGINT)
+- BOOLEAN conversion (validate TINYINT(1) value ranges)
+- Zero-date handling (`0000-00-00` → NULL)
+- ENUM extraction (inline → CREATE TYPE)
+- Text encoding conversion (detect charset first)
+
+### Requires Human Judgment
+- ARRAY type decomposition (JSON vs junction table — depends on access patterns)
+- Timezone semantics (TIMESTAMP vs TIMESTAMPTZ behavior)
+- DECIMAL precision alignment for financial data
+- Index strategy redesign (GIN/GiST have no equivalents)
+- Stored procedure rewriting (procedural syntax differs fundamentally)
+- Collation and case-sensitivity behavior
+- Constraint validation (lax MySQL CHECK → strict PG)
+
+## Tools Reference
+
+| Tool | Direction | Type | Best For |
+|------|-----------|------|----------|
+| **SQLGlot** | 31+ dialects | Deterministic (Python) | Automated SQL transpiling |
+| **pgloader** | MySQL/SQLite → PG | Declarative config | One-shot migration with type mapping |
+| **SQLines** | 10+ dialects | Rule-based | DDL + DML + stored procedures |
+| **AWS SCT** | Any → AWS DB | Assessment + conversion | Migration complexity scoring |
+| **sql-compat.js** (MINISTRY-LMS) | PG → MySQL | Runtime layer | Live bilingual applications |
+
+## When to Use
+
+- Planning a database migration (any direction)
+- Building cross-database applications
+- Writing the DATABASE phase of `/fire-resurrect`
+- Reviewing ORM migration portability
+- Auditing SQL for dialect-specific constructs before migration
+
+## When NOT to Use
+
+- Single-database projects with no migration plans
+- NoSQL databases (MongoDB, Redis, DynamoDB)
+- Data warehouse migrations (Snowflake, BigQuery — different paradigm)
+
+## Related Skills
+
+- [pg-to-mysql-schema-migration-methodology](pg-to-mysql-schema-migration-methodology.md)
+- [mysql-limit-offset-string-coercion](mysql-limit-offset-string-coercion.md)
+- [mysql-to-pg-migration](mysql-to-pg-migration.md)
+- [sqlite-to-pg-migration](sqlite-to-pg-migration.md)
+- [orm-schema-portability](orm-schema-portability.md)
+- [data-type-mapping-reference](data-type-mapping-reference.md)
+
+## References
+
+- PARROT Benchmark (NeurIPS 2025) — SQL translation accuracy evaluation
+- CrackSQL (SIGMOD 2025) — Hybrid rule+LLM dialect translation
+- RISE (arXiv 2601.05579, 2026) — Rule-driven SQL dialect translation
+- SQLGlot (github.com/tobymao/sqlglot) — Python SQL transpiler, 31+ dialects
+- pgloader (pgloader.readthedocs.io) — MySQL/SQLite to PostgreSQL migration
+- Troels Arvin — SQL implementation comparison (troels.arvin.dk/db/rdbms/)
+- Wikibooks SQL Dialects Reference
+- MINISTRY-LMS sql-compat.js — 27 production-proven translation rules