SQL Query Optimizer And Explainer

**Context**: 
SQL query optimization is crucial for improving the performance and efficiency of databases. A well-optimized query can significantly reduce execution time, minimize resource usage, and enhance overall system responsiveness. However, understanding and optimizing complex SQL queries can be challenging, even for experienced database administrators. An SQL query optimizer and explainer tool can analyze queries, identify bottlenecks, and provide recommendations for improvement.

**Detailed Instructions**: 
Design an SQL query optimizer and explainer that can take a SQL query as input, analyze its structure and execution plan, and provide a detailed report on optimization opportunities. The tool should be able to:

1. **Parse the SQL query**: Break down the query into its constituent parts, including SELECT, FROM, WHERE, JOIN, and ORDER BY clauses.
2. **Analyze the query execution plan**: Use the database's query optimizer to generate an execution plan, including information on index usage, join order, and subquery optimization.
3. **Identify optimization opportunities**: Apply heuristics and rules to identify potential bottlenecks, such as:
	* Inefficient join orders
	* Missing or suboptimal indexes
	* Unnecessary subqueries or correlated subqueries
	* Inadequate data typing or casting
4. **Provide optimization recommendations**: Offer suggestions for improving query performance, including:
	* Index creation or modification
	* Query rewriting or refactoring
	* Statistics collection and updating
	* Parameter tuning or configuration adjustments
5. **Explain the optimized query**: Generate a clear, step-by-step explanation of the optimized query, including:
	* The optimized query syntax
	* The expected execution plan
	* The rationale behind the optimization recommendations

**Output Format**: 
The output should be a JSON object containing the following elements:

* `original_query`: The original SQL query input
* `optimized_query`: The optimized SQL query
* `execution_plan`: The execution plan for the optimized query
* `optimization_recommendations`: A list of optimization suggestions, including the type of recommendation, the affected query component, and a brief description
* `explanation`: A step-by-step explanation of the optimized query, including the rationale behind the optimization recommendations

**Examples**: 
Input:
```sql
SELECT *
FROM customers
JOIN orders ON customers.customer_id = orders.customer_id
WHERE orders.order_date > '2022-01-01'
```
Output:
```json
{
  "original_query": "SELECT * FROM customers JOIN orders ON customers.customer_id = orders.customer_id WHERE orders.order_date > '2022-01-01'",
  "optimized_query": "SELECT * FROM customers JOIN orders ON customers.customer_id = orders.customer_id AND orders.order_date > '2022-01-01'",
  "execution_plan": [
    {
      "step": 1,
      "operation": "JOIN",
      "tables": ["customers", "orders"],
      "join_type": "INNER JOIN"
    },
    {
      "step": 2,
      "operation": "FILTER",
      "condition": "orders.order_date > '2022-01-01'"
    }
  ],
  "optimization_recommendations": [
    {
      "type": "INDEX",
      "component": "orders.order_date",
      "description": "Create an index on orders.order_date to improve filter performance"
    },
    {
      "type": "QUERY_REWRITE",
      "component": "JOIN",
      "description": "Rewrite the JOIN to use an INNER JOIN with a filter condition"
    }
  ],
  "explanation": [
    "Step 1: The original query joins customers and orders on customer_id.",
    "Step 2: The optimized query adds a filter condition to the JOIN to reduce the number of rows being joined.",
    "Step 3: The execution plan shows the optimized JOIN and FILTER operations."
  ]
}
```