Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Database Migration · microck | DecimalAI

microck/database-migration

SkillScore92Maintained

Execute database migrations across ORMs and platforms with zero-downtime strategies, data transformation, and rollback procedures. Use when migrating databases, changing schemas, performing data transformations, or implementing zero-downtime deployment strategies.

Databy microck

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/microck-database-migration/SKILL.md

decimalai skills pull microck-database-migration --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/microck-database-migration/SKILL.md https://app.decimal.ai/s/microck-database-migration/SKILL.md

Raw file: /s/microck-database-migration/SKILL.md ↗ · machine-readable summary at /s/microck-database-migration.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

24 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 8d ago

Yes — +17% lift · at higher cost+129% tokens0% turns92% of whole cases pass with skill (22/24)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-01	✗→✓	▲ Improved	135%	0%
case-02	✗→✓	▲ Improved	81%	0%
case-09	✗→✓	▲ Improved	81%	0%
case-14	✗→✓	▲ Improved	253%	0%
case-03	✓→✓	＝ Same ✓	128%	0%

Showing 5 of 24 cases

SkillSafety

✓ 3 of 3 passed

Code scan14 of 15 checks clean

0 critical · 0 warning · 1 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

No issues (informational notes only).

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

microck / ordinary-claude-skills

skills_all/database-migration/SKILL.md

View on GitHub ↗

License NOASSERTIONImported 8/3/2026Version v1

Skill contents

SKILL.md

Database Migration

Master database schema and data migrations across ORMs (Sequelize, TypeORM, Prisma), including rollback strategies and zero-downtime deployments.

When to Use This Skill

Migrating between different ORMs
Performing schema transformations
Moving data between databases
Implementing rollback procedures
Zero-downtime deployments
Database version upgrades
Data model refactoring

ORM Migrations

Sequelize Migrations

javascript
// migrations/20231201-create-users.js
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.createTable('users', {
      id: {
        type: Sequelize.INTEGER,
        primaryKey: true,
        autoIncrement: true
      },
      email: {
        type: Sequelize.STRING,
        unique: true,
        allowNull: false
      },
      createdAt: Sequelize.DATE,
      updatedAt: Sequelize.DATE
    });
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable('users');
  }
};

// Run: npx sequelize-cli db:migrate
// Rollback: npx sequelize-cli db:migrate:undo

TypeORM Migrations

typescript
// migrations/1701234567-CreateUsers.ts
import { MigrationInterface, QueryRunner, Table } from 'typeorm';

export class CreateUsers1701234567 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'users',
        columns: [
          {
            name: 'id',
            type: 'int',
            isPrimary: true,
            isGenerated: true,
            generationStrategy: 'increment'
          },
          {
            name: 'email',
            type: 'varchar',
            isUnique: true
          },
          {
            name: 'created_at',
            type: 'timestamp',
            default: 'CURRENT_TIMESTAMP'
          }
        ]
      })
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('users');
  }
}

// Run: npm run typeorm migration:run
// Rollback: npm run typeorm migration:revert

Prisma Migrations

prisma
// schema.prisma
model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  createdAt DateTime @default(now())
}

// Generate migration: npx prisma migrate dev --name create_users
// Apply: npx prisma migrate deploy

Schema Transformations

Adding Columns with Defaults

javascript
// Safe migration: add column with default
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.addColumn('users', 'status', {
      type: Sequelize.STRING,
      defaultValue: 'active',
      allowNull: false
    });
  },

  down: async (queryInterface) => {
    await queryInterface.removeColumn('users', 'status');
  }
};

Renaming Columns (Zero Downtime)

javascript
// Step 1: Add new column
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.addColumn('users', 'full_name', {
      type: Sequelize.STRING
    });

    // Copy data from old column
    await queryInterface.sequelize.query(
      'UPDATE users SET full_name = name'
    );
  },

  down: async (queryInterface) => {
    await queryInterface.removeColumn('users', 'full_name');
  }
};

// Step 2: Update application to use new column

// Step 3: Remove old column
module.exports = {
  up: async (queryInterface) => {
    await queryInterface.removeColumn('users', 'name');
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.addColumn('users', 'name', {
      type: Sequelize.STRING
    });
  }
};

Changing Column Types

javascript
module.exports = {
  up: async (queryInterface, Sequelize) => {
    // For large tables, use multi-step approach

    // 1. Add new column
    await queryInterface.addColumn('users', 'age_new', {
      type: Sequelize.INTEGER
    });

    // 2. Copy and transform data
    await queryInterface.sequelize.query(`
      UPDATE users
      SET age_new = CAST(age AS INTEGER)
      WHERE age IS NOT NULL
    `);

    // 3. Drop old column
    await queryInterface.removeColumn('users', 'age');

    // 4. Rename new column
    await queryInterface.renameColumn('users', 'age_new', 'age');
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.changeColumn('users', 'age', {
      type: Sequelize.STRING
    });
  }
};

Data Transformations

Complex Data Migration

javascript
module.exports = {
  up: async (queryInterface, Sequelize) => {
    // Get all records
    const [users] = await queryInterface.sequelize.query(
      'SELECT id, address_string FROM users'
    );

    // Transform each record
    for (const user of users) {
      const addressParts = user.address_string.split(',');

      await queryInterface.sequelize.query(
        `UPDATE users
         SET street = :street,
             city = :city,
             state = :state
         WHERE id = :id`,
        {
          replacements: {
            id: user.id,
            street: addressParts[0]?.trim(),
            city: addressParts[1]?.trim(),
            state: addressParts[2]?.trim()
          }
        }
      );
    }

    // Drop old column
    await queryInterface.removeColumn('users', 'address_string');
  },

  down: async (queryInterface, Sequelize) => {
    // Reconstruct original column
    await queryInterface.addColumn('users', 'address_string', {
      type: Sequelize.STRING
    });

    await queryInterface.sequelize.query(`
      UPDATE users
      SET address_string = CONCAT(street, ', ', city, ', ', state)
    `);

    await queryInterface.removeColumn('users', 'street');
    await queryInterface.removeColumn('users', 'city');
    await queryInterface.removeColumn('users', 'state');
  }
};

Rollback Strategies

Transaction-Based Migrations

javascript
module.exports = {
  up: async (queryInterface, Sequelize) => {
    const transaction = await queryInterface.sequelize.transaction();

    try {
      await queryInterface.addColumn(
        'users',
        'verified',
        { type: Sequelize.BOOLEAN, defaultValue: false },
        { transaction }
      );

      await queryInterface.sequelize.query(
        'UPDATE users SET verified = true WHERE email_verified_at IS NOT NULL',
        { transaction }
      );

      await transaction.commit();
    } catch (error) {
      await transaction.rollback();
      throw error;
    }
  },

  down: async (queryInterface) => {
    await queryInterface.removeColumn('users', 'verified');
  }
};

Checkpoint-Based Rollback

javascript
module.exports = {
  up: async (queryInterface, Sequelize) => {
    // Create backup table
    await queryInterface.sequelize.query(
      'CREATE TABLE users_backup AS SELECT * FROM users'
    );

    try {
      // Perform migration
      await queryInterface.addColumn('users', 'new_field', {
        type: Sequelize.STRING
      });

      // Verify migration
      const [result] = await queryInterface.sequelize.query(
        "SELECT COUNT(*) as count FROM users WHERE new_field IS NULL"
      );

      if (result[0].count > 0) {
        throw new Error('Migration verification failed');
      }

      // Drop backup
      await queryInterface.dropTable('users_backup');
    } catch (error) {
      // Restore from backup
      await queryInterface.sequelize.query('DROP TABLE users');
      await queryInterface.sequelize.query(
        'CREATE TABLE users AS SELECT * FROM users_backup'
      );
      await queryInterface.dropTable('users_backup');
      throw error;
    }
  }
};

Zero-Downtime Migrations

Blue-Green Deployment Strategy

javascript
// Phase 1: Make changes backward compatible
module.exports = {
  up: async (queryInterface, Sequelize) => {
    // Add new column (both old and new code can work)
    await queryInterface.addColumn('users', 'email_new', {
      type: Sequelize.STRING
    });
  }
};

// Phase 2: Deploy code that writes to both columns

// Phase 3: Backfill data
module.exports = {
  up: async (queryInterface) => {
    await queryInterface.sequelize.query(`
      UPDATE users
      SET email_new = email
      WHERE email_new IS NULL
    `);
  }
};

// Phase 4: Deploy code that reads from new column

// Phase 5: Remove old column
module.exports = {
  up: async (queryInterface) => {
    await queryInterface.removeColumn('users', 'email');
  }
};

Cross-Database Migrations

PostgreSQL to MySQL

javascript
// Handle differences
module.exports = {
  up: async (queryInterface, Sequelize) => {
    const dialectName = queryInterface.sequelize.getDialect();

    if (dialectName === 'mysql') {
      await queryInterface.createTable('users', {
        id: {
          type: Sequelize.INTEGER,
          primaryKey: true,
          autoIncrement: true
        },
        data: {
          type: Sequelize.JSON  // MySQL JSON type
        }
      });
    } else if (dialectName === 'postgres') {
      await queryInterface.createTable('users', {
        id: {
          type: Sequelize.INTEGER,
          primaryKey: true,
          autoIncrement: true
        },
        data: {
          type: Sequelize.JSONB  // PostgreSQL JSONB type
        }
      });
    }
  }
};

Resources

references/orm-switching.md: ORM migration guides
references/schema-migration.md: Schema transformation patterns
references/data-transformation.md: Data migration scripts
references/rollback-strategies.md: Rollback procedures
assets/schema-migration-template.sql: SQL migration templates
assets/data-migration-script.py: Data migration utilities
scripts/test-migration.sh: Migration testing script

Best Practices

Always Provide Rollback: Every up() needs a down()
Test Migrations: Test on staging first
Use Transactions: Atomic migrations when possible
Backup First: Always backup before migration
Small Changes: Break into small, incremental steps
Monitor: Watch for errors during deployment
Document: Explain why and how
Idempotent: Migrations should be rerunnable

Common Pitfalls

Not testing rollback procedures
Making breaking changes without downtime strategy
Forgetting to handle NULL values
Not considering index performance
Ignoring foreign key constraints
Migrating too much data at once

Want to see if microck/database-migration would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/21/2026, 00:16 UTC · 24 cases

Lift

+17%

92% vs 75%

Agent turns

1.0 vs 1.0

Tokens

+129%

4,752.17 vs 2,075.96

fail → pass · 4pass → pass · 18fail → fail · 2

Per-case results (24)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 I need to refactor a single text field called `location_info` into separate `city_name`, `state_name`, and `country_name` fields in our database. Can you supply a complete JavaScript migration file that performs this data transformation inside a database transaction, including full rollback functionality if anything fails during execution?	fail→pass	35,458	12,147	-66%	1	1	0%	2,162	5,078	+135%	0	0	—
case-02 Our backend application needs to support both PostgreSQL and MySQL database instances. I need a migration script for creating a `user_logs` table containing a flexible metadata payload column. Please generate the migration structure with `up` and `down` methods that properly adapts column data types according to the target database engine.	fail→pass	14,349	11,207	-22%	1	1	0%	2,770	5,004	+81%	0	0	—
case-03 We need to rename a column in a production SQL database without taking down the application or causing runtime errors for running API instances during deployment. Most developers just run ALTER TABLE RENAME COLUMN, but that breaks running app nodes. How should this schema change be structured across migration scripts?	pass→pass	14,092	16,596	+18%	1	1	0%	2,408	5,493	+128%	0	0	—
case-04 We need to change an existing `age` column from VARCHAR to INTEGER in a high-traffic SQL database table. Direct column type alteration locks tables and breaks existing code. What sequence of operations safely performs this type conversion?	pass→pass	15,447	17,288	+12%	1	1	0%	2,661	5,730	+115%	0	0	—
case-05 We have a risky data migration where a simple SQL transaction is not sufficient because DDL operations auto-commit in MySQL. What migration strategy creates a temporary snapshot table to verify data integrity post-migration and restores from it on error?	fail→fail	13,310	10,593	-20%	1	1	0%	2,200	4,601	+109%	0	0	—
case-06 Developers using schema-first ORMs often manually apply raw SQL files to staging and production. What CLI commands generate a named schema migration file in development and deploy pending migrations to production?	pass→pass	9,614	10,587	+10%	1	1	0%	1,733	4,602	+166%	0	0	—
case-07 We are building a TypeScript backend that manages database schema evolution using class files with up and down methods. Developers often default to writing raw SQL strings inside queryRunner.query(). Show the object-oriented approach for table creation.	pass→pass	14,427	12,961	-10%	1	1	0%	2,847	5,551	+95%	0	0	—
case-08 We want to add a mandatory non-nullable `status` column to an existing `users` database table containing millions of rows. Running ALTER TABLE ADD COLUMN status VARCHAR NOT NULL without default values causes execution errors. Provide the JS migration code for adding this column safely.	pass→pass	15,516	13,260	-15%	1	1	0%	2,667	5,132	+92%	0	0	—
case-09 We have a legacy database table with an `address_string` column containing comma-separated street, city, and state values. Write a JS database migration that parses this string, updates separate `street`, `city`, and `state` fields, and handles rollback by reconstructing the original string.	fail→pass	14,363	11,637	-19%	1	1	0%	2,814	5,101	+81%	0	0	—
case-10 Our DevOps team is planning a zero-downtime database deployment for changing an `email` column structure in a blue-green deployment setup. Outline the multi-phase deployment workflow that avoids breaking running blue or green nodes.	pass→pass	16,785	18,399	+10%	1	1	0%	2,983	6,008	+101%	0	0	—
case-11 When automated deployment pipelines retry failed migration steps, non-idempotent scripts crash or corrupt data. What core rule should every migration script follow to ensure safe re-execution across deployment environments?	pass→pass	9,860	8,077	-18%	1	1	0%	1,629	4,156	+155%	0	0	—
case-12 We are running a multi-statement database schema migration in JS. Many developers forget error handling, leaving the database in a partially modified state if the second query fails. Show the standard pattern for atomic execution using explicit database transaction objects.	pass→pass	10,695	12,901	+21%	1	1	0%	1,867	5,217	+179%	0	0	—
case-13 We are writing a cross-database schema definition layer in JavaScript for multi-tenant deployments. PostgreSQL and MySQL store structured JSON differently. How should column type definition adapt between PostgreSQL and MySQL?	fail→fail	17,130	17,888	+4%	1	1	0%	2,860	6,251	+119%	0	0	—
case-14 A newly deployed migration in our TypeScript backend caused unexpected query errors. Developers often write manual DROP TABLE scripts to fix this. What CLI command reverts the last applied migration?	fail→pass	5,833	5,761	-1%	1	1	0%	1,045	3,686	+253%	0	0	—
case-15 Our team manages JavaScript database schema updates via terminal tools. Developers frequently manually execute raw SQL files to undo schema changes. What CLI commands execute pending migrations and revert the most recent migration?	pass→pass	9,027	8,962	-1%	1	1	0%	1,704	4,395	+158%	0	0	—
case-16 During code review, a teammate wrote an `up` function that drops a column, but left the `down` function empty with a comment saying "cannot undo". What rule from database schema migration standards does this violate?	pass→pass	7,510	5,710	-24%	1	1	0%	1,243	3,634	+192%	0	0	—
case-17 A developer submitted a single massive migration script that creates 15 tables, transforms 20 columns, and updates 50,000 rows in one run. What best practice for database migration maintenance should be applied here?	pass→pass	10,141	9,103	-10%	1	1	0%	1,667	4,187	+151%	0	0	—
case-18 When dropping tables or deleting columns in relational database migrations, queries often fail with execution errors due to linked relational rules. What common migration pitfall causes this issue?	pass→pass	9,345	8,028	-14%	1	1	0%	1,441	4,065	+182%	0	0	—
case-24 We want to configure connection pooling parameters like pool size, connection timeout, and idle timeout in our Node.js database client configuration file to prevent database connection exhaustion. How should we set up the connection pool object?	pass→pass	13,822	12,399	-10%	1	1	0%	2,560	5,076	+98%	0	0	—
case-19 Before executing a database migration script directly against a production database, what operational verification step should always be performed to catch unexpected SQL syntax or locking issues?	pass→pass	10,612	9,055	-15%	1	1	0%	1,545	4,041	+162%	0	0	—
case-20 When converting an existing optional column into a NOT NULL column across millions of rows, database migrations often fail during execution. What common oversight regarding existing dataset records causes this migration error?	pass→pass	9,233	8,890	-4%	1	1	0%	1,448	4,263	+194%	0	0	—
case-21 Before running destructive database schema migrations or complex data updates on production tables, what operational safety measure must always be taken to prevent permanent data loss?	pass→pass	7,149	6,290	-12%	1	1	0%	1,119	3,635	+225%	0	0	—
case-22 We need to write a complex SQL SELECT query using INNER JOIN, GROUP BY, and HAVING clauses to calculate monthly user retention metrics in PostgreSQL. Can you write this analytical reporting query?	pass→pass	14,192	12,692	-11%	1	1	0%	2,582	5,267	+104%	0	0	—
case-23 We need to perform a full physical database backup of a PostgreSQL instance using command-line utility tools before an infrastructure maintenance window. What pg_dump CLI command options should be used to output a custom-format compressed backup file?	pass→pass	11,115	8,728	-21%	1	1	0%	1,954	4,205	+115%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 24 cases were attempted, and 23 counted toward the lift figure. The other 1 produced results that are not comparable between the two arms, so they are excluded from the headline rather than averaged into it. The headline lift of +17 percentage points is the difference between those two pass rates over the 23 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 75%
Pass rate with the skill: 91.7%
Cases attempted: 24
Cases counted toward lift: 23
Cases that regressed: 0
Skill version measured: v1
Run completed: 8/21/2026, 00:16 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-02

Prompt

Our backend application needs to support both PostgreSQL and MySQL database instances. I need a migration script for creating a `user_logs` table containing a flexible metadata payload column. Please generate the migration structure with `up` and `down` methods that properly adapts column data types according to the target database engine.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run92

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+135% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 8 days ago

Other measured skills in the registry, with their headline benchmark lift.