discover-database

What this skill does

# Database Skills Discovery

Provides automatic access to comprehensive database design, optimization, and implementation skills.

## When This Skill Activates
This skill auto-activates when you're working with:
- SQL databases (PostgreSQL, MySQL)
- NoSQL databases (MongoDB, Redis)
- Database schema design and modeling
- Query optimization and performance tuning
- Database migrations and schema evolution
- Connection pooling configuration
- ORM usage and patterns
- Database selection and architecture decisions
- caching
- cache
- Redis
- CDN
- HTTP caching
- cache invalidation
- performance
- Service Workers

## Available Skills

### Quick Reference

The Database category contains 19 skills across 2 subcategories:

**Database (12 skills):**
1. **postgres-schema-design** - Schema design, relationships, data types, normalization
2. **postgres-query-optimization** - EXPLAIN plans, indexes, slow query debugging
3. **postgres-migrations** - Schema changes, zero-downtime, rollback strategies
4. **mongodb-document-design** - Document modeling, embedding vs referencing
5. **redis-data-structures** - Caching, sessions, rate limiting, leaderboards
6. **database-connection-pooling** - Pool configuration, debugging exhaustion
7. **orm-patterns** - ORM best practices, N+1 prevention, eager loading
8. **database-selection** - Choosing databases, SQL vs NoSQL decisions

Plus 4 more in `../database/INDEX.md`

**Caching (7 skills):** See `../caching/INDEX.md`

### Load Full Category Details
Read ../database/INDEX.md
Read ../caching/INDEX.md

## Common Workflows

### New Database Project
**Sequence**: Selection → Schema design → Connection pooling

Read ../database/database-selection.md         # Choose database
Read ../database/postgres-schema-design.md     # or mongodb-document-design.md
Read ../database/database-connection-pooling.md


### Query Performance Debugging
**Sequence**: Optimization → Connection pooling → ORM patterns

Read ../database/postgres-query-optimization.md  # Debug slow queries
Read ../database/database-connection-pooling.md  # Check pool settings
Read ../database/orm-patterns.md                 # Fix N+1 queries


### Schema Evolution
**Sequence**: Schema design → Migrations

Read ../database/postgres-schema-design.md    # Design changes
Read ../database/postgres-migrations.md       # Implement safely


### Caching Layer
**Sequence**: Redis structures → Cache patterns

Read ../database/redis-data-structures.md     # Redis patterns
Read ../caching/INDEX.md                      # Cache patterns

## Skill Selection Guide

**PostgreSQL skills** (relational, ACID, complex queries):
- `postgres-schema-design.md` - Design relational schemas
- `postgres-query-optimization.md` - Optimize complex queries
- `postgres-migrations.md` - Evolve schema over time

**MongoDB skills** (document-oriented, flexible schema):
- `mongodb-document-design.md` - Design document structures
- Choose when: Flexible schema, nested data, rapid iteration

**Redis skills** (in-memory, key-value, caching):
- `redis-data-structures.md` - Caching, sessions, rate limiting
- Choose when: Speed critical, caching layer, real-time features

**Cross-database skills**:
- `database-selection.md` - **Start here** for new projects
- `database-connection-pooling.md` - All databases need this
- `orm-patterns.md` - When using ORMs (SQLAlchemy, Prisma, Mongoose)

## Integration with Other Skills

Database skills commonly combine with:

**API skills** (`discover-api`):
- API endpoints → Database queries
- Connection pooling for API servers
- Query optimization for API performance
- Migrations alongside API versioning

**Backend language skills** (`discover-backend`):
- Python: SQLAlchemy, psycopg2, PyMongo
- Zig: PostgreSQL C bindings
- Rust: SQLx, Diesel
- Go: database/sql, GORM

**Testing skills** (`discover-testing`):
- Integration tests with test databases
- Migration testing
- Query performance testing
- Data fixture management

**Data pipeline skills** (`discover-data`):
- ETL from databases
- Database as data source
- Bulk data operations
- Streaming database changes (CDC)

**Observability skills** (`discover-observability`):
- Query metrics and slow query logs
- Connection pool metrics
- Database performance monitoring
- Alert configuration

## Progressive Loading

This gateway skill (~200 lines, ~2K tokens) enables progressive loading:
- **Level 1**: Gateway loads automatically (you're here now)
- **Level 2**: Load category INDEX.md (~3K tokens) for full overview
- **Level 3**: Load specific skills (~2-4K tokens each) as needed

Total context: 2K + 3K + skill(s) = 5-10K tokens vs 25K+ for entire index.

## Quick Start Examples

**"Design a PostgreSQL schema for an e-commerce app"**:
Read ../database/postgres-schema-design.md


**"Why is my query slow?"**:
Read ../database/postgres-query-optimization.md


**"How do I safely change my database schema?"**:
Read ../database/postgres-migrations.md


**"Should I use MongoDB or PostgreSQL?"**:
Read ../database/database-selection.md


**"Implement caching with Redis"**:
Read ../database/redis-data-structures.md


**"Fix N+1 queries in my ORM"**:
Read ../database/orm-patterns.md


## Database Type Decision Tree

```
Need ACID transactions? YES → PostgreSQL
Need complex queries/joins? YES → PostgreSQL
Need flexible schema? YES → MongoDB
Need real-time caching? YES → Redis
Need full-text search? YES → PostgreSQL (with extensions) or Elasticsearch
Need graph relationships? YES → Neo4j or PostgreSQL (with extensions)
Need analytics? YES → DuckDB or Redpanda + Iceberg
```

For detailed decision-making:
Read ../database/database-selection.md


## PostgreSQL Focus Areas

**Schema design** → `postgres-schema-design.md`:
- Tables, columns, data types
- Primary keys, foreign keys, constraints
- Normalization vs denormalization
- Indexing strategies

**Query optimization** → `postgres-query-optimization.md`:
- EXPLAIN and EXPLAIN ANALYZE
- Index selection and creation
- Query plan analysis
- Performance tuning

**Migrations** → `postgres-migrations.md`:
- Schema change strategies
- Zero-downtime deployments
- Rollback procedures
- Migration tools (Alembic, Flyway, migrate)

## NoSQL Focus Areas

**MongoDB** → `mongodb-document-design.md`:
- Document structure and embedding
- References vs embedding tradeoffs
- Schema versioning
- Index design for documents

**Redis** → `redis-data-structures.md`:
- Strings, hashes, lists, sets, sorted sets
- Caching patterns and TTLs
- Session storage
- Rate limiting implementations
- Leaderboards and counters

## ORM Considerations

Before using ORMs, load:
Read ../database/orm-patterns.md


**Common ORM pitfalls**:
- N+1 query problems
- Lazy vs eager loading confusion
- Transaction management
- Raw SQL when necessary
- Migration generation

**Supported ORMs**:
- SQLAlchemy (Python)
- Prisma (TypeScript/Node.js)
- Diesel (Rust)
- GORM (Go)
- ActiveRecord (Ruby)
- Entity Framework (C#)

## Usage Instructions

1. **Auto-activation**: This skill loads automatically when Claude Code detects database work
2. **Browse skills**: Run `Read ../database/INDEX.md` for full category overview
3. **Load specific skills**: Use bash commands above to load individual skills
4. **Follow workflows**: Use recommended sequences for common patterns
5. **Decision support**: Start with `database-selection.md` for new projects


**Next Steps**: Run `Read ../database/INDEX.md` to see full category details, or load specific skills using the bash commands above.