Ready to supercharge your AI agents?

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

SQL Query Optimizer · a5c-ai | DecimalAI

a5c-ai/sql-query-optimizer

SkillScore86Maintained

Analyzes and optimizes SQL queries across different data warehouse platforms (Snowflake, BigQuery, Redshift, Databricks) with platform-specific recommendations.

Databy a5c-ai

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

Automatic

Data Engineer pack

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

pip install decimalai

2 · Get the skill — writes .claude/skills/a5c-ai-sql-query-optimizer/SKILL.md

decimalai skills pull a5c-ai-sql-query-optimizer --out .claude/skills/

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

curl -fsSL --create-dirs -o .claude/skills/a5c-ai-sql-query-optimizer/SKILL.md https://app.decimal.ai/s/a5c-ai-sql-query-optimizer/SKILL.md

Raw file: /s/a5c-ai-sql-query-optimizer/SKILL.md ↗ · machine-readable summary at /s/a5c-ai-sql-query-optimizer.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

Runs

—

no usage data yet

Used when offered

—

offered 22 · activation not measurable for prompt-injection usage

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

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

Yes — +73% lift · at higher cost+109% tokens0% turns86% of whole cases pass with skill (19/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-02	✗→✓	▲ Improved	113%	0%
case-17	✗→✓	▲ Improved	145%	0%
case-01	✗→✓	▲ Improved	108%	0%
case-03	✗→✓	▲ Improved	51%	0%
case-08	✗→✓	▲ Improved	42%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 7/31/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

a5c-ai / babysitter

library/specializations/data-engineering-analytics/skills/sql-query-optimizer/SKILL.md

View on GitHub ↗

License MITImported 7/31/2026Version v1

Skill contents

SKILL.md

SQL Query Optimizer

Analyzes and optimizes SQL queries across different data warehouse platforms with platform-specific recommendations.

Overview

This skill examines SQL queries to identify performance bottlenecks, suggest optimizations, and provide platform-specific recommendations for Snowflake, BigQuery, Redshift, and Databricks. It analyzes query execution plans, recommends indexes/clustering keys, and identifies anti-patterns.

Capabilities

Query execution plan analysis - Parse and analyze EXPLAIN outputs
Index recommendations - Suggest clustering keys, sort keys, partition keys
Join optimization - Identify inefficient join patterns and suggest improvements
Subquery elimination - Convert correlated subqueries to CTEs or joins
CTE optimization - Materialize vs reference optimization
Window function optimization - Frame and partition optimization
Predicate pushdown validation - Verify filter pushdown effectiveness
Clustering key recommendations - Platform-specific clustering strategies
Materialized view suggestions - Identify candidates for materialized views
Platform-specific optimizations - Snowflake, BigQuery, Redshift, Databricks

Input Schema

json
{
  "query": {
    "type": "string",
    "description": "The SQL query to analyze",
    "required": true
  },
  "platform": {
    "type": "string",
    "enum": ["snowflake", "bigquery", "redshift", "databricks", "postgres"],
    "required": true,
    "description": "Target data warehouse platform"
  },
  "tableStatistics": {
    "type": "object",
    "description": "Table statistics including row counts, column cardinality",
    "properties": {
      "tables": {
        "type": "array",
        "items": {
          "name": "string",
          "rowCount": "number",
          "sizeGB": "number",
          "columns": "array"
        }
      }
    }
  },
  "executionPlan": {
    "type": "object",
    "description": "Query execution plan (EXPLAIN output)"
  },
  "queryHistory": {
    "type": "object",
    "description": "Historical query performance metrics"
  },
  "optimizationGoals": {
    "type": "array",
    "items": {
      "type": "string",
      "enum": ["latency", "cost", "throughput", "scan_reduction"]
    },
    "default": ["latency", "cost"]
  }
}

Output Schema

json
{
  "optimizedQuery": {
    "type": "string",
    "description": "The optimized SQL query"
  },
  "improvements": {
    "type": "array",
    "items": {
      "type": {
        "type": "string",
        "enum": ["join", "predicate", "aggregation", "cte", "window", "scan", "index"]
      },
      "description": "string",
      "impact": "high|medium|low",
      "lineNumber": "number",
      "originalCode": "string",
      "optimizedCode": "string"
    }
  },
  "indexRecommendations": {
    "type": "array",
    "items": {
      "table": "string",
      "type": "clustering|sort|partition|index",
      "columns": "array",
      "rationale": "string",
      "ddl": "string"
    }
  },
  "estimatedImprovement": {
    "scanReduction": {
      "type": "number",
      "description": "Percentage reduction in data scanned"
    },
    "timeReduction": {
      "type": "number",
      "description": "Percentage reduction in execution time"
    },
    "costReduction": {
      "type": "number",
      "description": "Percentage reduction in query cost"
    }
  },
  "antiPatterns": {
    "type": "array",
    "items": {
      "pattern": "string",
      "severity": "high|medium|low",
      "location": "string",
      "suggestion": "string"
    }
  },
  "platformSpecificNotes": {
    "type": "array",
    "items": "string"
  }
}

Usage Examples

Basic Query Optimization

json
{
  "query": "SELECT * FROM orders o JOIN customers c ON o.customer_id = c.id WHERE o.created_at > '2024-01-01'",
  "platform": "snowflake"
}

With Execution Plan Analysis

json
{
  "query": "SELECT customer_id, SUM(amount) FROM orders GROUP BY customer_id",
  "platform": "bigquery",
  "executionPlan": {
    "stages": [...],
    "totalBytesProcessed": 1073741824
  },
  "optimizationGoals": ["cost", "scan_reduction"]
}

With Table Statistics

json
{
  "query": "SELECT ... complex query ...",
  "platform": "redshift",
  "tableStatistics": {
    "tables": [
      {
        "name": "orders",
        "rowCount": 10000000,
        "sizeGB": 50,
        "columns": [
          {"name": "order_id", "cardinality": 10000000},
          {"name": "customer_id", "cardinality": 500000}
        ]
      }
    ]
  }
}

Platform-Specific Optimizations

Snowflake

| Optimization | Description | |--------------|-------------| | Clustering keys | Recommend micro-partition clustering | | Result cache | Identify queries benefiting from caching | | Query acceleration | Suggest QUERY_ACCELERATION_MAX_SCALE_FACTOR | | Warehouse sizing | Right-size warehouse recommendations |

BigQuery

| Optimization | Description | |--------------|-------------| | Partitioning | DATE/TIMESTAMP partitioning recommendations | | Clustering | Up to 4 clustering columns | | BI Engine | Identify BI Engine-eligible queries | | Slots | Estimate slot usage optimization |

Redshift

| Optimization | Description | |--------------|-------------| | Sort keys | COMPOUND vs INTERLEAVED recommendations | | Distribution | KEY, EVEN, ALL distribution strategies | | Compression | Column encoding recommendations | | Vacuum | VACUUM and ANALYZE recommendations |

Databricks

| Optimization | Description | |--------------|-------------| | Z-ordering | Multi-column Z-order recommendations | | Delta cache | Caching strategy recommendations | | Photon | Photon-eligible query patterns | | Adaptive execution | AQE configuration suggestions |

Common Anti-Patterns Detected

Query Structure

| Anti-Pattern | Impact | Fix | |--------------|--------|-----| | SELECT | High | Specify columns explicitly | | Correlated subqueries | High | Convert to JOIN or CTE | | DISTINCT on large datasets | Medium | Use GROUP BY or window functions | | Non-SARGable predicates | High | Rewrite for index usage |

Join Issues

| Anti-Pattern | Impact | Fix | |--------------|--------|-----| | Cartesian products | Critical | Add join conditions | | Implicit joins | Medium | Use explicit JOIN syntax | | Wrong join order | High | Reorder by selectivity | | Missing indexes on join keys | High | Add clustering/sort keys |

Aggregation Issues

| Anti-Pattern | Impact | Fix | |--------------|--------|-----| | GROUP BY ordinal | Low | Use column names | | Aggregating before filter | High | Filter first, then aggregate | | Over-grouping | Medium | Reduce GROUP BY columns |

Integration Points

MCP Server Integration

Snowflake MCP - Real-time execution plan analysis
BigQuery MCP - Cost estimation and slot analysis
Redshift MCP - Query execution and statistics

Related Skills

Data Quality Profiler (SK-DEA-005) - Table statistics gathering
dbt Project Analyzer (SK-DEA-003) - Model query optimization

Applicable Processes

Query Optimization (query-optimization.js)
Data Warehouse Setup (data-warehouse-setup.js)
BI Dashboard Development (bi-dashboard.js)
OBT Creation (obt-creation.js)

References

Version History

1.0.0 - Initial release with multi-platform support

Illustrative Want to see what a5c-ai/sql-query-optimizer would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/2/2026, 20:04 UTC · 22 cases

Lift

+73%

86% vs 14%

Agent turns

1.0 vs 1.0

Tokens

+109%

4,251.27 vs 2,032.5

fail → pass · 16pass → pass · 3fail → fail · 3

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-02 Can you evaluate this BigQuery SQL query to reduce query cost and data scanned? `SELECT region, COUNT(DISTINCT user_id), SUM(amount) FROM logs GROUP BY 1`. Here are table stats: table 'logs' has 50,000,000 rows and 120GB size. Return your response matching the output structure with the optimized query string, array of improvements (including original and optimized code snippets), index or partition/clustering recommendations with DDL, metrics for estimated scan, time, and cost reductions, flagged anti-patterns, and platform specific notes for BigQuery.	fail→pass	13,237	15,237	+15%	1	1	0%	2,471	5,253	+113%	0	0	—
case-17 Analyze this BigQuery query: `SELECT DISTINCT customer_id FROM web_events WHERE event_type = 'checkout'`. Target platform bigquery. Return standard JSON output.	fail→pass	8,905	13,466	+51%	1	1	0%	1,672	4,103	+145%	0	0	—
case-01 I have a slow-running Snowflake SQL query that uses SELECT * and subqueries: `SELECT * FROM sales_data s WHERE YEAR(s.transaction_date) = 2024 AND s.customer_id IN (SELECT id FROM active_users)`. Please analyze this query for Snowflake and provide a structured JSON response containing the refactored query, detailed code improvements with impact levels and line numbers, clustering key recommendations with DDL, estimated percentage improvements for scan, time, and cost, identified anti-patterns with severity, and Snowflake-specific notes.	fail→pass	10,417	10,538	+1%	1	1	0%	2,199	4,570	+108%	0	0	—
case-03 Please optimize this Redshift query: `SELECT c.name, SUM(o.total) FROM customers c, orders o WHERE c.id = o.customer_id GROUP BY c.name`. The orders table has 10M rows (50GB). Provide a structured analysis output with the rewritten SQL, list of code improvements specifying category and severity impact, sort or distribution key recommendations with DDL, percentage reduction estimates for execution time and scanned data, identified query anti-patterns, and platform notes relevant to Redshift.	fail→pass	16,647	13,100	-21%	1	1	0%	3,083	4,654	+51%	0	0	—
case-04 Create a dbt model file `dim_customers.sql` that joins raw staging tables `stg_customers` and `stg_orders` using Jinja ref macros and materializes as a table.	pass→pass	6,153	5,858	-5%	1	1	0%	1,209	3,241	+168%	0	0	—
case-05 Design a PostgreSQL database schema for an e-commerce platform including `users`, `products`, and `orders` tables with primary keys, foreign keys, and check constraints.	pass→pass	12,744	16,115	+26%	1	1	0%	2,976	5,828	+96%	0	0	—
case-06 Write Great Expectations data quality validation rules for an analytics dataset to check for null values in `customer_id` and unique constraints on `order_id`.	pass→pass	8,863	7,503	-15%	1	1	0%	1,829	3,568	+95%	0	0	—
case-07 Analyze this Snowflake SQL query: `SELECT * FROM orders o WHERE o.amount > (SELECT AVG(amount) FROM orders WHERE customer_id = o.customer_id)`. Provide JSON optimization analysis.	fail→fail	10,622	9,700	-9%	1	1	0%	2,159	4,337	+101%	0	0	—
case-08 Optimize this Snowflake query filtering large table `events`: `SELECT event_id, user_id FROM events WHERE DATE_TRUNC('day', created_at) = '2024-03-01'`. Provide full analysis JSON.	fail→pass	10,664	6,607	-38%	1	1	0%	2,403	3,416	+42%	0	0	—
case-09 Evaluate this query on BigQuery table `pageviews` (500GB): `SELECT url, COUNT(*) FROM pageviews WHERE timestamp >= '2024-01-01' AND country = 'US' GROUP BY url`. Produce schema-compliant JSON analysis.	fail→pass	9,487	12,916	+36%	1	1	0%	1,921	4,788	+149%	0	0	—
case-10 Review this BigQuery SQL statement for cost efficiency: `SELECT * FROM transactional_logs WHERE event_date = CURRENT_DATE()`. Provide structured JSON feedback.	fail→pass	12,977	7,962	-39%	1	1	0%	2,402	3,621	+51%	0	0	—
case-11 Optimize a query joining two 100GB tables in Redshift: `SELECT l.line_id, o.order_date FROM line_items l JOIN orders o ON l.order_id = o.order_id WHERE o.order_date >= '2024-01-01'`. Table stats: `line_items` has 500M rows, `orders` has 100M rows. Produce JSON output.	fail→pass	9,594	13,376	+39%	1	1	0%	2,014	4,867	+142%	0	0	—
case-18 Evaluate this Redshift query: `SELECT e.name, d.department_name FROM employees e, departments d WHERE e.dept_id = d.id AND e.salary > 80000`. Return JSON analysis.	fail→pass	10,568	10,616	+0%	1	1	0%	2,037	4,286	+110%	0	0	—
case-12 Analyze this Redshift query for code quality: `SELECT customer_id, region, SUM(sales) FROM customer_sales WHERE status = 'active' GROUP BY 1, 2`. Output JSON analysis.	fail→pass	9,709	6,402	-34%	1	1	0%	1,523	3,349	+120%	0	0	—
case-13 Optimize this Databricks Spark SQL query on Delta Lake table `telemetry` (2TB): `SELECT device_id, date, AVG(reading) FROM telemetry WHERE date >= '2024-02-01' AND device_type = 'sensor_a' GROUP BY device_id, date`. Output JSON schema.	fail→fail	8,408	11,013	+31%	1	1	0%	1,631	4,237	+160%	0	0	—
case-14 Analyze this Databricks query: `SELECT a.id, b.status FROM events_a a, events_b b WHERE a.created_date > '2024-01-01'`. Provide structured JSON evaluation.	fail→fail	11,245	9,419	-16%	1	1	0%	2,208	3,948	+79%	0	0	—
case-15 Optimize this PostgreSQL query: `SELECT user_id, email FROM users WHERE LOWER(email) LIKE '%@gmail.com'`. Target platform postgres. Return JSON analysis structure.	fail→pass	9,246	12,888	+39%	1	1	0%	1,955	4,890	+150%	0	0	—
case-16 Optimize this Snowflake query with repeated CTE reference: `WITH customer_totals AS (SELECT customer_id, SUM(amount) AS total FROM orders GROUP BY customer_id) SELECT * FROM customer_totals WHERE total > 1000 UNION ALL SELECT * FROM customer_totals WHERE total < 50`. Return JSON output.	fail→pass	5,915	7,996	+35%	1	1	0%	1,205	3,814	+217%	0	0	—
case-19 Optimize this Databricks query: `SELECT user_id, transaction_date, SUM(amount) OVER (PARTITION BY user_id ORDER BY transaction_date) AS running_total FROM transactions`. Return standard JSON.	fail→pass	7,462	12,399	+66%	1	1	0%	1,583	4,643	+193%	0	0	—
case-20 Analyze execution stats for Snowflake query scanning 5TB data with warehouse overload: `SELECT DATE_TRUNC('month', sale_date), SUM(amount) FROM massive_sales GROUP BY 1`. Target platform snowflake. Return standard JSON.	fail→pass	10,139	8,775	-13%	1	1	0%	2,097	3,888	+85%	0	0	—
case-21 Optimize postgres query: `SELECT p.product_name, c.category_name FROM products p JOIN categories c ON p.category_id = c.id WHERE p.status = 'active'`. Target platform postgres. Return JSON analysis.	fail→pass	10,399	8,292	-20%	1	1	0%	2,151	3,729	+73%	0	0	—
case-22 Optimize BigQuery dashboard backend query: `SELECT region, SUM(revenue) FROM daily_sales WHERE sale_date = CURRENT_DATE() GROUP BY region`. Target platform bigquery. Return JSON analysis.	fail→pass	10,329	10,828	+5%	1	1	0%	1,987	4,498	+126%	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. 22 cases were attempted. The headline lift of +73 percentage points is the difference between those two pass rates over the 22 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 13.6%
Pass rate with the skill: 86.4%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 0
Skill version measured: v1
Run completed: 8/2/2026, 20:04 UTC

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

Prompt

Can you evaluate this BigQuery SQL query to reduce query cost and data scanned? `SELECT region, COUNT(DISTINCT user_id), SUM(amount) FROM logs GROUP BY 1`. Here are table stats: table 'logs' has 50,000,000 rows and 120GB size. Return your response matching the output structure with the optimized query string, array of improvements (including original and optimized code snippets), index or partition/clustering recommendations with DDL, metrics for estimated scan, time, and cost reductions, flagged anti-patterns, and platform specific notes for BigQuery.

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 run86

Live evalNeeds ≥10 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+110% 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 53 days ago

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