Sql Query Optimizer
Analyze and rewrite SQL queries for peak database performance
What You Can Do
You can submit any SQL query and receive a thoroughly optimized version with specific performance improvements. The skill analyzes query structure, recommends missing indexes with creation syntax for your database dialect, rewrites inefficient patterns, and provides estimated performance gains. It maintains semantic equivalence while transforming your queries into production-ready code.
Features
transforms slow patterns into optimized equivalents while preserving logic
identifies missing indexes with dialect-specific creation syntax
converts dependent subqueries into efficient JOINs or window functions
restructures multi-table operations for minimal data scanning
improves readability and performance using Common Table Expressions
optimizes for PostgreSQL, MySQL, and SQLite with dialect-specific syntax
provides estimated improvement percentages and explains each optimization
analyzes execution plans to identify bottlenecks and sequential scans
Example Output
Input Query:
SELECT u.id, u.name, (SELECT COUNT(*) FROM orders WHERE orders.user_id = u.id) as order_count
FROM users u
WHERE u.created_at > '2024-01-01';
Optimized Output:
WITH user_orders AS (
SELECT user_id, COUNT(*) as order_count
FROM orders
GROUP BY user_id
)
SELECT u.id, u.name, COALESCE(uo.order_count, 0) as order_count
FROM users u
LEFT JOIN user_orders uo ON u.id = uo.user_id
WHERE u.created_at > '2024-01-01';
Index Recommendation:
CREATE INDEX idx_users_created_at ON users(created_at);
CREATE INDEX idx_orders_user_id ON orders(user_id);
Performance Impact: ~65% faster execution time by eliminating correlated subquery (N+1 problem).
What's Included
- SKILL.md: Complete optimization framework with dialect-specific syntax rules
- Query optimization checklist: 15-point performance review template
- Index recommendation template: Structured format for proposing database indexes
- EXPLAIN plan decoder: Guide to interpreting execution plans across PostgreSQL, MySQL, and SQLite
- Common anti-patterns guide: Quick reference for slow query patterns and their optimized alternatives
Who It's For
- Database Administrators — optimizing production queries and capacity planning
- Backend Engineers — improving application performance and reducing database load
- Data Engineers — tuning ETL and data pipeline queries for efficiency
- DevOps Engineers — troubleshooting slow database performance in CI/CD pipelines
- Performance Specialists — analyzing and benchmarking query optimization efforts
Best For
- Slow query analysis and rewriting for production systems
- Index design and recommendation for large datasets
- Converting legacy SQL patterns to modern, efficient syntax
- Troubleshooting N+1 query problems and correlated subqueries
- Preparing queries for high-traffic environments with strict latency requirements
You might also like
You get Claude to analyze your API specifications and automatically generate bulletproof parameter validation logic. Claude creates security-hardened middleware, enforces type constraints, detects malicious input patterns, and generates comprehensive error handling — all tailored to your framework and existing codebase. The result is production-ready validation code with zero unvalidated inputs reaching your business logic.
This skill enables you to automatically audit your websites against compliance standards and detect deviations from expected baselines. You can track regulatory requirements, identify policy violations, and generate compliance reports with actionable remediation steps. Monitor multiple sites simultaneously and maintain detailed audit trails for compliance documentation.
Transform schema and data changes into production-ready migration packages that protect data integrity and minimize downtime. You can handle column additions, renames, type conversions, and backfills using proven patterns like expand-contract and shadow tables. The skill generates explicit rollback scripts, validation checklists, and phased execution plans that keep applications stable throughout the migration.
You'll transform high-level feature requirements into a complete development plan covering API design, frontend implementation, testing strategy, and documentation. The skill helps you identify dependencies, parallelize work across frontend and backend teams, and establish quality gates that ensure features ship bug-free with proper error handling and logging.
You can conduct comprehensive toxicology safety assessments, generate regulatory-compliant safety documentation, and produce detailed hazard analyses for pharmaceutical and chemical submissions. This skill structures toxicological data into standardized safety reports, maps findings to regulatory guidelines (FDA, EMA, ICH), and identifies risk characterization strategies to support regulatory submissions and approval timelines.
You can submit your Solidity smart contracts for comprehensive security analysis, vulnerability detection, and gas optimization recommendations. Claude reviews your code against known attack vectors, design patterns, and best practices—identifying reentrancy risks, overflow/underflow issues, access control flaws, and inefficient operations. You receive actionable fix recommendations with explanations of the security implications and gas savings potential.
You can design end-to-end NGS pipelines tailored to your experiment type (WGS, WES, RNA-seq, targeted), troubleshoot pipeline failures by analyzing QC metrics and logs, and optimize performance by fine-tuning parameters and identifying bottlenecks. This skill handles the full workflow from raw sequencing data quality assessment through variant interpretation and annotation.
You can accelerate your entire antenna design workflow—from initial concept to optimized specifications—by leveraging Claude's knowledge of electromagnetic theory, antenna types, and design trade-offs. Claude helps you parameterize designs, identify optimal configurations for your frequency band and application, and prepare detailed briefs for simulation and manufacturing. You'll generate design reviews, impedance-matching solutions, and validation checklists without context-switching to multiple tools.