home / skills / aidotnet / moyucode / database-designer

database-designer skill

/skills/community/database-designer

This skill designs and optimizes database schemas across PostgreSQL, MySQL, SQLite and MongoDB, generating ER models, normalization, and migration scripts.

npx playbooks add skill aidotnet/moyucode --skill database-designer

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.6 KB
---
name: database-designer
description: 设计和优化数据库模式,支持PostgreSQL、MySQL、SQLite和MongoDB。包括ER建模、规范化、索引优化和迁移脚本生成。
metadata:
  short-description: 设计数据库模式和迁移脚本
---

# Database Designer Skill

## Description
Design and optimize database schemas with Entity-Relationship modeling, normalization, and migration scripts.

## Trigger
- `/db-design` command
- User requests database schema design
- User needs migration scripts

## Prompt

You are a database architect that designs efficient, scalable database schemas.

### PostgreSQL Schema Example

```sql
-- Users table
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL UNIQUE,
    password_hash VARCHAR(255) NOT NULL,
    name VARCHAR(100) NOT NULL,
    avatar_url TEXT,
    email_verified BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Create index for email lookups
CREATE INDEX idx_users_email ON users(email);

-- Posts table with foreign key
CREATE TABLE posts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    title VARCHAR(255) NOT NULL,
    content TEXT,
    status VARCHAR(20) DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived')),
    published_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Composite index for user's posts
CREATE INDEX idx_posts_user_status ON posts(user_id, status);

-- Full-text search index
CREATE INDEX idx_posts_search ON posts USING GIN(to_tsvector('english', title || ' ' || content));

-- Updated_at trigger
CREATE OR REPLACE FUNCTION update_updated_at()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = NOW();
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER users_updated_at
    BEFORE UPDATE ON users
    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
```

### Entity Framework Core Migration

```csharp
public class CreateUsersTable : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "Users",
            columns: table => new
            {
                Id = table.Column<Guid>(nullable: false, defaultValueSql: "gen_random_uuid()"),
                Email = table.Column<string>(maxLength: 255, nullable: false),
                PasswordHash = table.Column<string>(maxLength: 255, nullable: false),
                Name = table.Column<string>(maxLength: 100, nullable: false),
                CreatedAt = table.Column<DateTime>(nullable: false, defaultValueSql: "NOW()")
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Users", x => x.Id);
            });

        migrationBuilder.CreateIndex(
            name: "IX_Users_Email",
            table: "Users",
            column: "Email",
            unique: true);
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(name: "Users");
    }
}
```

### Index Optimization Guidelines

```sql
-- Good: Selective index on frequently queried column
CREATE INDEX idx_orders_status ON orders(status) WHERE status = 'pending';

-- Good: Covering index for common query
CREATE INDEX idx_orders_user_date ON orders(user_id, created_at DESC) INCLUDE (total, status);

-- Avoid: Index on low-cardinality column
-- CREATE INDEX idx_users_active ON users(is_active); -- Only 2 values!
```

## Tags
`database`, `sql`, `schema`, `design`, `optimization`, `migration`

## Compatibility
- Codex: ✅
- Claude Code: ✅

Overview

This skill designs and optimizes database schemas for PostgreSQL, MySQL, SQLite, and MongoDB. It produces ER models, applies normalization, recommends and creates indexes, and generates migration scripts for common ORMs and SQL dialects. The focus is on scalable, maintainable schemas and practical migration artifacts.

How this skill works

You provide requirements, entities, relationships, and common queries; the skill returns a normalized ER diagram, table/collection definitions, recommended indexes, and sample migration code or SQL. It analyzes query patterns and cardinality to suggest selective and covering indexes, and emits triggers or timestamps for audit fields when appropriate. Output includes dialect-specific examples and migration snippets ready to adapt into your project.

When to use it

  • Starting a new application and defining persistent data models
  • Refactoring or normalizing an existing schema to reduce redundancy
  • Preparing production-ready indexes to improve query performance
  • Generating migration scripts for deployments or CI pipelines
  • Converting relational designs to document models for MongoDB

Best practices

  • Model entities and relationships first, then normalize to at least 3NF unless denormalization is justified
  • Design indexes around actual query patterns and cardinality; prefer partial and covering indexes for performance
  • Use UUIDs or surrogate keys consistently and add created_at/updated_at with automatic updates
  • Provide idempotent migrations and include down/rollback paths for safety
  • Document constraints, foreign keys, and cascade rules to prevent accidental data loss

Example use cases

  • Designing a multi-tenant users and posts schema for a social app with compound indexes for feed queries
  • Optimizing an orders table with partial indexes for pending payments and a covering index for reporting
  • Generating PostgreSQL migration SQL plus an Entity Framework Core migration class for a .NET backend
  • Converting a relational product-catalog to a MongoDB schema with embedded variants and reference constraints
  • Adding updated_at triggers and full-text search indexes for blog platform search features

FAQ

Which databases and dialects are supported?

PostgreSQL, MySQL, SQLite, and MongoDB are supported with dialect-specific schema and index suggestions.

Can this generate migrations for ORMs?

Yes. It can produce sample migration code or SQL for common ORMs such as Entity Framework Core and raw SQL migration scripts.