Initial commit For SQL Practice Platform

Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+COPY app/ .
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/database.py

@@ -0,0 +1,13 @@
+import sqlite3
+
+def create_session_db():
+    conn = sqlite3.connect(":memory:", check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def get_session_db(session_id: str):
+    from main import sessions
+    return sessions.get(session_id, {}).get("conn")
+
+def close_session_db(conn):
+    conn.close()

app/main.py

@@ -0,0 +1,178 @@
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+import sqlite3
+import sqlparse
+import os
+import uuid
+import json  # Added for json.load()
+from typing import Dict, Any
+from app.database import create_session_db, close_session_db
+from app.schemas import RunQueryRequest, ValidateQueryRequest
+
+app = FastAPI()
+app.mount("/static", StaticFiles(directory=os.path.join(os.path.dirname(__file__), "static")), name="static")
+
+@app.exception_handler(Exception)
+async def custom_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(status_code=500, content={"detail": str(exc)})
+
+sessions: Dict[str, dict] = {}
+
+BASE_DIR = os.path.dirname(__file__)
+
+def load_questions(domain: str):
+    file_path = os.path.join(BASE_DIR, "questions", f"{domain}.json")
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Question file not found: {file_path}")
+    with open(file_path, "r") as f:
+        return json.load(f)  # Replaced eval with json.load()
+
+def load_schema_sql(domain: str):
+    file_path = os.path.join(BASE_DIR, "schemas", f"{domain}.sql")
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Schema file not found: {file_path}")
+    with open(file_path, "r") as f:
+        return f.read()
+
+def is_safe_query(sql: str) -> bool:
+    parsed = sqlparse.parse(sql.lower())[0]
+    return str(parsed).lower().strip().startswith("select") and all(kw not in str(parsed).lower() for kw in ["drop", "attach", "detach", "pragma", "insert", "update", "delete"])
+
+def extract_tables(sql: str) -> list:
+    tables = set()
+    tokens = sql.replace("\n", " ").lower().split()
+    in_subquery = in_openquery = in_values = False
+
+    for i, token in enumerate(tokens):
+        if token == "(" and not in_subquery and not in_values:
+            in_values = i > 0 and tokens[i - 1] == "values"
+            in_subquery = not in_values
+        if token == ")" and (in_subquery or in_values):
+            if in_values and i + 1 < len(tokens) and tokens[i + 1] == "as": in_values = False
+            elif in_subquery: in_subquery = False
+        if token == "openquery" and i + 1 < len(tokens) and tokens[i + 1] == "(": in_openquery = True
+        if token == ")" and in_openquery: in_openquery = False
+        if in_openquery: continue
+
+        if token in ["from", "join", "update", "delete", "insert", "into", "using", "apply", "pivot", "table"]:
+            next_token = tokens[i + 1].replace(",);", "") if i + 1 < len(tokens) else ""
+            if next_token and next_token not in ["select", "where", "on", "order", "group", "having", "as", "("]:
+                if i + 2 < len(tokens) and tokens[i + 2] == "as": next_token = next_token
+                elif next_token not in ["left", "right", "inner", "outer", "cross", "full"]: tables.add(next_token)
+            i += 1
+        elif token == "merge" and i + 1 < len(tokens) and tokens[i + 1] == "into":
+            next_token = tokens[i + 2].replace(",);", "") if i + 2 < len(tokens) else ""
+            if next_token and next_token not in ["using", "select", "where"]: tables.add(next_token)
+            i += 2
+            while i + 1 < len(tokens) and tokens[i + 1] != "using": i += 1
+            if i + 2 < len(tokens) and (next_token := tokens[i + 2].replace(",);", "")) and next_token not in ["select", "where"]: tables.add(next_token)
+        elif token == "select" and i + 1 < len(tokens) and tokens[i + 1] == "into":
+            next_token = tokens[i + 2].replace(",);", "") if i + 2 < len(tokens) else ""
+            if next_token and next_token not in ["from", "select"]: tables.add(next_token)
+            i += 2
+            while i + 1 < len(tokens) and tokens[i + 1] != "from": i += 1
+            if i + 2 < len(tokens) and (next_token := tokens[i + 2].replace(",);", "")) and next_token not in ["where", "join"]: tables.add(next_token)
+        elif token == "with":
+            while i + 1 < len(tokens) and tokens[i + 1] != "as": i += 1
+            if i + 2 < len(tokens) and tokens[i + 2] == "(":
+                bracket_count = 1
+                subquery_start = i + 2
+                i += 2
+                while i < len(tokens) and bracket_count > 0:
+                    if tokens[i] == "(": bracket_count += 1
+                    elif tokens[i] == ")": bracket_count -= 1
+                    i += 1
+                if bracket_count == 0 and i > subquery_start:
+                    subquery = " ".join(tokens[subquery_start:i - 1])
+                    tables.update(t for t in extract_tables(subquery) if t not in tables)
+        elif token == "values" and i + 1 < len(tokens) and tokens[i + 1] == "(":
+            while i + 1 < len(tokens) and tokens[i + 1] != "as": i += 1
+            if i + 2 < len(tokens) and (alias := tokens[i + 2].replace(",);", "")): tables.add(alias)
+        elif token in ["exists", "in"]:
+            subquery_start = i + 1
+            while i + 1 < len(tokens) and tokens[i + 1] != ")": i += 1
+            if i > subquery_start:
+                subquery = " ".join(tokens[subquery_start:i + 1])
+                tables.update(t for t in extract_tables(subquery) if t not in tables)
+    return list(tables)
+
+@app.post("/api/session")
+async def create_session():
+    session_id = str(uuid.uuid4())
+    sessions[session_id] = {"conn": create_session_db(), "domain": None}
+    return {"session_id": session_id}
+
+@app.get("/api/databases")
+async def get_databases():
+    questions_dir = os.path.join(BASE_DIR, "questions")
+    return {"databases": [f.replace(".json", "") for f in os.listdir(questions_dir) if f.endswith(".json")] if os.path.exists(questions_dir) else []}
+
+@app.post("/api/load-schema/{domain}")
+async def load_schema(domain: str, session_id: str = Header(...)):
+    if session_id not in sessions: raise HTTPException(status_code=401, detail="Invalid session")
+    sessions[session_id] = {"conn": create_session_db(), "domain": domain}
+    try:
+        sessions[session_id]["conn"].executescript(load_schema_sql(domain))
+        sessions[session_id]["conn"].commit()
+    except sqlite3.Error as e:
+        close_session_db(sessions[session_id]["conn"])  # Cleanup on error
+        del sessions[session_id]
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    return {"message": f"Database {domain} loaded"}
+
+@app.get("/api/schema/{domain}")
+async def get_schema(domain: str, session_id: str = Header(...)):
+    if session_id not in sessions or sessions[session_id]["domain"] != domain: raise HTTPException(status_code=401, detail="Invalid session or domain not loaded")
+    conn = sessions[session_id]["conn"]
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+    return {"schema": {table: [{"name": row["name"], "type": row["type"]} for row in conn.execute(f"PRAGMA table_info({table});")] for table in [row["name"] for row in cursor.fetchall()]}}
+
+@app.get("/api/sample-data/{domain}")
+async def get_sample_data(domain: str, session_id: str = Header(...)):
+    if session_id not in sessions or sessions[session_id]["domain"] != domain: raise HTTPException(status_code=401, detail="Invalid session or domain not loaded")
+    conn = sessions[session_id]["conn"]
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+    return {"sample_data": {table: {"columns": [desc[0] for desc in conn.execute(f"SELECT * FROM {table} LIMIT 5").description], "rows": [dict(row) for row in conn.execute(f"SELECT * FROM {table} LIMIT 5")]} for table in [row["name"] for row in cursor.fetchall()]}}
+
+@app.post("/api/run-query")
+async def run_query(request: RunQueryRequest, session_id: str = Header(...)):
+    if session_id not in sessions or not sessions[session_id]["domain"]: raise HTTPException(status_code=401, detail="Invalid session or no database loaded")
+    if not is_safe_query(request.query): raise HTTPException(status_code=400, detail="Only SELECT queries are allowed")
+    conn = sessions[session_id]["conn"]
+    cursor = conn.cursor()
+    cursor.execute(request.query)
+    if cursor.description:
+        columns = [desc[0] for desc in cursor.description]
+        return {"columns": columns, "rows": [dict(zip(columns, row)) for row in cursor.fetchall()]}
+    return {"message": "Query executed successfully (no results)"}
+
+@app.get("/api/questions/{domain}")
+async def get_questions(domain: str, difficulty: str = None):
+    questions = load_questions(domain)
+    if difficulty: questions = [q for q in questions if q["difficulty"].lower() == difficulty.lower()]
+    return [{"id": q["id"], "title": q["title"], "difficulty": q["difficulty"], "description": q["description"], "hint": q["hint"], "expected_sql": q["expected_sql"]} for q in questions]
+
+@app.post("/api/validate")
+async def validate_query(request: ValidateQueryRequest, session_id: str = Header(...)):
+    if session_id not in sessions or not sessions[session_id]["domain"]: raise HTTPException(status_code=401, detail="Invalid session or no database loaded")
+    conn = sessions[session_id]["conn"]
+    cursor = conn.cursor()
+    cursor.execute(request.user_query)
+    user_result = [tuple(str(x).lower() for x in row) for row in cursor.fetchall()] if cursor.description else []
+    cursor.execute(request.expected_query)
+    expected_result = [tuple(str(x).lower() for x in row) for row in cursor.fetchall()] if cursor.description else []
+    return {"valid": user_result == expected_result, "error": "Results do not match." if user_result != expected_result else ""}
+
+@app.on_event("shutdown")
+async def cleanup():
+    for session_id in list(sessions): close_session_db(sessions[session_id]["conn"]); del sessions[session_id]
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_frontend():
+    file_path = os.path.join(BASE_DIR, "static", "index.html")
+    if not os.path.exists(file_path): raise HTTPException(status_code=500, detail=f"Frontend file not found: {file_path}")
+    with open(file_path, "r") as f: return f.read()

app/questions/banking.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List all customers",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and emails of all customers.",
+    "hint": "Use SELECT on the customers table.",
+    "expected_sql": "SELECT name, email FROM customers;"
+  },
+  {
+    "id": "q2",
+    "title": "Show savings accounts",
+    "difficulty": "Beginner",
+    "description": "List all accounts of type 'Savings' with their balances.",
+    "hint": "Use WHERE clause to filter by account_type.",
+    "expected_sql": "SELECT account_id, balance FROM accounts WHERE account_type = 'Savings';"
+  },
+  {
+    "id": "q3",
+    "title": "Find customers in New York",
+    "difficulty": "Beginner",
+    "description": "Show the names and ages of customers living in New York.",
+    "hint": "Use WHERE clause to filter by city.",
+    "expected_sql": "SELECT name, age FROM customers WHERE city = 'New York';"
+  },
+  {
+    "id": "q4",
+    "title": "Count total accounts",
+    "difficulty": "Beginner",
+    "description": "Count the total number of accounts in the system.",
+    "hint": "Use COUNT() function on the accounts table.",
+    "expected_sql": "SELECT COUNT(*) AS total_accounts FROM accounts;"
+  },
+  {
+    "id": "q5",
+    "title": "List accounts opened in 2023",
+    "difficulty": "Beginner",
+    "description": "Retrieve all accounts opened in 2023.",
+    "hint": "Use WHERE clause with LIKE on opened_on.",
+    "expected_sql": "SELECT account_id, account_type, opened_on FROM accounts WHERE opened_on LIKE '2023%';"
+  },
+  {
+    "id": "q6",
+    "title": "List distinct account types",
+    "difficulty": "Beginner",
+    "description": "Get all unique account types from the accounts table.",
+    "hint": "Use DISTINCT to avoid duplicate account types.",
+    "expected_sql": "SELECT DISTINCT account_type FROM accounts;"
+  },
+  {
+    "id": "q7",
+    "title": "Find accounts for John Doe",
+    "difficulty": "Beginner",
+    "description": "List all accounts owned by John Doe.",
+    "hint": "Join accounts with customers and filter by name.",
+    "expected_sql": "SELECT a.account_id, a.account_type, a.balance FROM accounts a JOIN customers c ON a.customer_id = c.customer_id WHERE c.name = 'John Doe';"
+  },
+  {
+    "id": "q8",
+    "title": "Show customers under 30",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and cities of customers younger than 30 years old.",
+    "hint": "Use WHERE clause to filter by age.",
+    "expected_sql": "SELECT name, city FROM customers WHERE age < 30;"
+  },
+  {
+    "id": "q9",
+    "title": "List loan accounts",
+    "difficulty": "Beginner",
+    "description": "Show all accounts of type 'Loan' with their balances.",
+    "hint": "Use WHERE clause to filter by account_type.",
+    "expected_sql": "SELECT account_id, balance FROM accounts WHERE account_type = 'Loan';"
+  },
+  {
+    "id": "q10",
+    "title": "Find customer emails",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and email addresses of all customers.",
+    "hint": "Select name and email from customers table.",
+    "expected_sql": "SELECT name, email FROM customers;"
+  },
+  {
+    "id": "q11",
+    "title": "Count accounts per customer",
+    "difficulty": "Intermediate",
+    "description": "Show the number of accounts each customer owns.",
+    "hint": "Join customers and accounts, then GROUP BY customer name.",
+    "expected_sql": "SELECT c.name, COUNT(a.account_id) AS account_count FROM customers c LEFT JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name;"
+  },
+  {
+    "id": "q12",
+    "title": "Total balance per customer",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total balance across all accounts for each customer.",
+    "hint": "Join customers and accounts, then GROUP BY customer name and SUM balance.",
+    "expected_sql": "SELECT c.name, SUM(a.balance) AS total_balance FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name;"
+  },
+  {
+    "id": "q13",
+    "title": "Average balance by account type",
+    "difficulty": "Intermediate",
+    "description": "Find the average balance for each account type.",
+    "hint": "GROUP BY account_type and use AVG on balance.",
+    "expected_sql": "SELECT account_type, AVG(balance) AS avg_balance FROM accounts GROUP BY account_type;"
+  },
+  {
+    "id": "q14",
+    "title": "Customers with multiple accounts",
+    "difficulty": "Intermediate",
+    "description": "List customers who have more than one account.",
+    "hint": "Join customers and accounts, GROUP BY customer, and use HAVING clause.",
+    "expected_sql": "SELECT c.name, COUNT(a.account_id) AS account_count FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name HAVING COUNT(a.account_id) > 1;"
+  },
+  {
+    "id": "q15",
+    "title": "Accounts with negative balance",
+    "difficulty": "Intermediate",
+    "description": "Show all accounts with a negative balance, including customer names.",
+    "hint": "Join accounts with customers and filter by balance < 0.",
+    "expected_sql": "SELECT a.account_id, c.name, a.account_type, a.balance FROM accounts a JOIN customers c ON a.customer_id = c.customer_id WHERE a.balance < 0;"
+  },
+  {
+    "id": "q16",
+    "title": "Customers with no accounts",
+    "difficulty": "Intermediate",
+    "description": "List customers who do not have any accounts.",
+    "hint": "Use LEFT JOIN and check for NULL in accounts table.",
+    "expected_sql": "SELECT c.name FROM customers c LEFT JOIN accounts a ON c.customer_id = a.customer_id WHERE a.account_id IS NULL;"
+  },
+  {
+    "id": "q17",
+    "title": "Account details with customer info",
+    "difficulty": "Intermediate",
+    "description": "Show account details including customer name and city.",
+    "hint": "Join accounts and customers tables.",
+    "expected_sql": "SELECT a.account_id, a.account_type, a.balance, c.name, c.city FROM accounts a JOIN customers c ON a.customer_id = c.customer_id;"
+  },
+  {
+    "id": "q18",
+    "title": "Count accounts by city",
+    "difficulty": "Intermediate",
+    "description": "Count the number of accounts for customers in each city.",
+    "hint": "Join customers and accounts, GROUP BY city.",
+    "expected_sql": "SELECT c.city, COUNT(a.account_id) AS account_count FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.city;"
+  },
+  {
+    "id": "q19",
+    "title": "Accounts opened before 2023",
+    "difficulty": "Intermediate",
+    "description": "List all accounts opened before 2023, including customer names.",
+    "hint": "Join accounts with customers and filter by opened_on.",
+    "expected_sql": "SELECT a.account_id, a.account_type, c.name FROM accounts a JOIN customers c ON a.customer_id = c.customer_id WHERE a.opened_on < '2023-01-01';"
+  },
+  {
+    "id": "q20",
+    "title": "Total balance by account type",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total balance for each account type.",
+    "hint": "GROUP BY account_type and SUM balance.",
+    "expected_sql": "SELECT account_type, SUM(balance) AS total_balance FROM accounts GROUP BY account_type;"
+  },
+  {
+    "id": "q21",
+    "title": "Customers with highest total balance",
+    "difficulty": "Advanced",
+    "description": "Find the customer with the highest total balance across all their accounts.",
+    "hint": "Join tables, SUM balance, GROUP BY customer, and use LIMIT.",
+    "expected_sql": "SELECT c.name, SUM(a.balance) AS total_balance FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name ORDER BY total_balance DESC LIMIT 1;"
+  },
+  {
+    "id": "q22",
+    "title": "Youngest customer with loan account",
+    "difficulty": "Advanced",
+    "description": "Identify the youngest customer who has a Loan account.",
+    "hint": "Join tables, filter by account_type, and use MIN on age.",
+    "expected_sql": "SELECT c.name, c.age FROM customers c JOIN accounts a ON c.customer_id = a.customer_id WHERE a.account_type = 'Loan' ORDER BY c.age ASC LIMIT 1;"
+  },
+  {
+    "id": "q23",
+    "title": "Account age in years",
+    "difficulty": "Advanced",
+    "description": "Calculate the age of each account in years as of '2025-07-11'.",
+    "hint": "Use JULIANDAY to calculate date difference and divide by 365.25.",
+    "expected_sql": "SELECT account_id, account_type, ROUND((JULIANDAY('2025-07-11') - JULIANDAY(opened_on)) / 365.25, 1) AS account_age FROM accounts;"
+  },
+  {
+    "id": "q24",
+    "title": "Customers with diverse account types",
+    "difficulty": "Advanced",
+    "description": "List customers who have more than one type of account.",
+    "hint": "Join tables, count distinct account types, and use HAVING.",
+    "expected_sql": "SELECT c.name, COUNT(DISTINCT a.account_type) AS type_count FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name HAVING type_count > 1;"
+  },
+  {
+    "id": "q25",
+    "title": "Account openings by year",
+    "difficulty": "Advanced",
+    "description": "Show the number of accounts opened each year.",
+    "hint": "Use STRFTIME to extract year and GROUP BY.",
+    "expected_sql": "SELECT STRFTIME('%Y', opened_on) AS year, COUNT(account_id) AS account_count FROM accounts GROUP BY year;"
+  },
+  {
+    "id": "q26",
+    "title": "Customers with high negative balance",
+    "difficulty": "Advanced",
+    "description": "Find customers with a total balance less than -5000 across all accounts.",
+    "hint": "Join tables, SUM balance, and use HAVING clause.",
+    "expected_sql": "SELECT c.name, SUM(a.balance) AS total_balance FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name HAVING total_balance < -5000;"
+  },
+  {
+    "id": "q27",
+    "title": "Oldest account per customer",
+    "difficulty": "Advanced",
+    "description": "Show the earliest opened account for each customer.",
+    "hint": "Join tables, use MIN on opened_on, and GROUP BY customer.",
+    "expected_sql": "SELECT c.name, MIN(a.opened_on) AS earliest_opened FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.name;"
+  },
+  {
+    "id": "q28",
+    "title": "Cities with high average balance",
+    "difficulty": "Advanced",
+    "description": "List cities where the average account balance is greater than 1000.",
+    "hint": "Join tables, GROUP BY city, and use HAVING clause.",
+    "expected_sql": "SELECT c.city, AVG(a.balance) AS avg_balance FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.city HAVING avg_balance > 1000;"
+  },
+  {
+    "id": "q29",
+    "title": "Customers with no savings accounts",
+    "difficulty": "Advanced",
+    "description": "List customers who do not have a Savings account.",
+    "hint": "Use NOT IN or LEFT JOIN to exclude customers with Savings accounts.",
+    "expected_sql": "SELECT c.name FROM customers c WHERE c.customer_id NOT IN (SELECT a.customer_id FROM accounts a WHERE a.account_type = 'Savings');"
+  },
+  {
+    "id": "q30",
+    "title": "Most common account type per city",
+    "difficulty": "Advanced",
+    "description": "Find the most common account type in each city.",
+    "hint": "Join tables, group by city and account_type, use subquery or LIMIT.",
+    "expected_sql": "SELECT c.city, a.account_type, COUNT(a.account_id) AS account_count FROM customers c JOIN accounts a ON c.customer_id = a.customer_id GROUP BY c.city, a.account_type HAVING COUNT(a.account_id) = (SELECT MAX(account_count) FROM (SELECT COUNT(account_id) AS account_count FROM accounts a2 JOIN customers c2 ON a2.customer_id = c2.customer_id WHERE c2.city = c.city GROUP BY a2.account_type) AS counts);"
+  }
+]

app/questions/college.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List all students",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and emails of all students.",
+    "hint": "Use SELECT on the students table.",
+    "expected_sql": "SELECT name, email FROM students;"
+  },
+  {
+    "id": "q2",
+    "title": "List all courses",
+    "difficulty": "Beginner",
+    "description": "Show all courses with their names and credits.",
+    "hint": "Use SELECT on the courses table.",
+    "expected_sql": "SELECT name, credits FROM courses;"
+  },
+  {
+    "id": "q3",
+    "title": "Find Spring 2023 enrollments",
+    "difficulty": "Beginner",
+    "description": "Display student IDs and course IDs for enrollments in Spring 2023.",
+    "hint": "Use WHERE clause to filter by semester.",
+    "expected_sql": "SELECT student_id, course_id FROM enrollments WHERE semester = 'Spring 2023';"
+  },
+  {
+    "id": "q4",
+    "title": "Count total students",
+    "difficulty": "Beginner",
+    "description": "Count the total number of students in the system.",
+    "hint": "Use COUNT() on the students table.",
+    "expected_sql": "SELECT COUNT(*) AS total_students FROM students;"
+  },
+  {
+    "id": "q5",
+    "title": "List students in CSE department",
+    "difficulty": "Beginner",
+    "description": "Show names and emails of students in the CSE department.",
+    "hint": "Use WHERE clause to filter by department.",
+    "expected_sql": "SELECT name, email FROM students WHERE department = 'CSE';"
+  },
+  {
+    "id": "q6",
+    "title": "List distinct departments",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique departments from the students table.",
+    "hint": "Use DISTINCT to avoid duplicate departments.",
+    "expected_sql": "SELECT DISTINCT department FROM students;"
+  },
+  {
+    "id": "q7",
+    "title": "List courses in CSE department",
+    "difficulty": "Beginner",
+    "description": "Show all course names and instructors in the CSE department.",
+    "hint": "Use WHERE clause to filter by department.",
+    "expected_sql": "SELECT name, instructor FROM courses WHERE department = 'CSE';"
+  },
+  {
+    "id": "q8",
+    "title": "List second-year students",
+    "difficulty": "Beginner",
+    "description": "Retrieve names and emails of students in year 2.",
+    "hint": "Use WHERE clause to filter by year.",
+    "expected_sql": "SELECT name, email FROM students WHERE year = 2;"
+  },
+  {
+    "id": "q9",
+    "title": "Find instructor for Data Structures",
+    "difficulty": "Beginner",
+    "description": "Show the instructor for the 'Data Structures' course.",
+    "hint": "Use WHERE clause to filter by course name.",
+    "expected_sql": "SELECT instructor FROM courses WHERE name = 'Data Structures';"
+  },
+  {
+    "id": "q10",
+    "title": "List student IDs and names",
+    "difficulty": "Beginner",
+    "description": "Show all student IDs and their corresponding names.",
+    "hint": "Use SELECT on the students table.",
+    "expected_sql": "SELECT student_id, name FROM students;"
+  },
+  {
+    "id": "q11",
+    "title": "Students and their enrolled courses",
+    "difficulty": "Intermediate",
+    "description": "Display student names and the names of courses they are enrolled in.",
+    "hint": "Join students, enrollments, and courses tables.",
+    "expected_sql": "SELECT s.name AS student_name, c.name AS course_name FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id;"
+  },
+  {
+    "id": "q12",
+    "title": "Count students per course",
+    "difficulty": "Intermediate",
+    "description": "Show the number of students enrolled in each course.",
+    "hint": "Join enrollments with courses and GROUP BY course name.",
+    "expected_sql": "SELECT c.name, COUNT(e.student_id) AS student_count FROM enrollments e JOIN courses c ON e.course_id = c.course_id GROUP BY c.name;"
+  },
+  {
+    "id": "q13",
+    "title": "Students with A grades",
+    "difficulty": "Intermediate",
+    "description": "List names of students who received an 'A' grade in any course.",
+    "hint": "Join enrollments with students and filter by grade.",
+    "expected_sql": "SELECT DISTINCT s.name FROM enrollments e JOIN students s ON e.student_id = s.student_id WHERE e.grade = 'A';"
+  },
+  {
+    "id": "q14",
+    "title": "Courses with no enrollments",
+    "difficulty": "Intermediate",
+    "description": "Find courses that have no students enrolled.",
+    "hint": "Use LEFT JOIN and filter for NULL enrollment IDs.",
+    "expected_sql": "SELECT c.name FROM courses c LEFT JOIN enrollments e ON c.course_id = e.course_id WHERE e.enrollment_id IS NULL;"
+  },
+  {
+    "id": "q15",
+    "title": "Grades for Operating Systems",
+    "difficulty": "Intermediate",
+    "description": "Show student names and grades for the 'Operating Systems' course.",
+    "hint": "Join enrollments, students, and courses, filter by course name.",
+    "expected_sql": "SELECT s.name, e.grade FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id WHERE c.name = 'Operating Systems';"
+  },
+  {
+    "id": "q16",
+    "title": "Courses taught by Dr. Anil Kapoor",
+    "difficulty": "Intermediate",
+    "description": "List all courses taught by Dr. Anil Kapoor.",
+    "hint": "Use WHERE clause to filter by instructor.",
+    "expected_sql": "SELECT name FROM courses WHERE instructor = 'Dr. Anil Kapoor';"
+  },
+  {
+    "id": "q17",
+    "title": "Students with multiple enrollments",
+    "difficulty": "Intermediate",
+    "description": "Find students enrolled in more than one course.",
+    "hint": "Group by student name and use HAVING clause.",
+    "expected_sql": "SELECT s.name, COUNT(e.course_id) AS course_count FROM enrollments e JOIN students s ON e.student_id = s.student_id GROUP BY s.name HAVING COUNT(e.course_id) > 1;"
+  },
+  {
+    "id": "q18",
+    "title": "Total credits per student",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total credits each student is enrolled in.",
+    "hint": "Join enrollments with courses and SUM credits.",
+    "expected_sql": "SELECT s.name, SUM(c.credits) AS total_credits FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id GROUP BY s.name;"
+  },
+  {
+    "id": "q19",
+    "title": "Courses per department",
+    "difficulty": "Intermediate",
+    "description": "Count the number of courses offered by each department.",
+    "hint": "Group by department in the courses table.",
+    "expected_sql": "SELECT department, COUNT(course_id) AS course_count FROM courses GROUP BY department;"
+  },
+  {
+    "id": "q20",
+    "title": "Student enrollment semesters",
+    "difficulty": "Intermediate",
+    "description": "List student names and the semesters they are enrolled in.",
+    "hint": "Join enrollments with students.",
+    "expected_sql": "SELECT s.name, e.semester FROM enrollments e JOIN students s ON e.student_id = s.student_id;"
+  },
+  {
+    "id": "q21",
+    "title": "Average GPA per course",
+    "difficulty": "Advanced",
+    "description": "Calculate the average GPA per course, mapping grades to numeric values (A=4.0, A-=3.7, B+=3.3, B=3.0).",
+    "hint": "Use CASE to map grades and AVG for calculation.",
+    "expected_sql": "SELECT c.name, AVG(CASE e.grade WHEN 'A' THEN 4.0 WHEN 'A-' THEN 3.7 WHEN 'B+' THEN 3.3 WHEN 'B' THEN 3.0 ELSE 0 END) AS avg_gpa FROM enrollments e JOIN courses c ON e.course_id = c.course_id GROUP BY c.name;"
+  },
+  {
+    "id": "q22",
+    "title": "Top student per course",
+    "difficulty": "Advanced",
+    "description": "Find the student with the highest grade in each course.",
+    "hint": "Use a subquery to find the maximum grade per course.",
+    "expected_sql": "SELECT s.name, c.name AS course_name, e.grade FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id WHERE (e.course_id, e.grade) IN (SELECT course_id, MAX(grade) FROM enrollments GROUP BY course_id);"
+  },
+  {
+    "id": "q23",
+    "title": "Average credits per department",
+    "difficulty": "Advanced",
+    "description": "Calculate the average total credits per student in each department.",
+    "hint": "Group by student and department, then average credits.",
+    "expected_sql": "SELECT s.department, AVG(total_credits) AS avg_credits FROM (SELECT s.student_id, s.department, SUM(c.credits) AS total_credits FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id GROUP BY s.student_id, s.department) AS temp GROUP BY department;"
+  },
+  {
+    "id": "q24",
+    "title": "Students not enrolled",
+    "difficulty": "Advanced",
+    "description": "List students who are not enrolled in any course.",
+    "hint": "Use LEFT JOIN and filter for NULL enrollments.",
+    "expected_sql": "SELECT s.name FROM students s LEFT JOIN enrollments e ON s.student_id = e.student_id WHERE e.enrollment_id IS NULL;"
+  },
+  {
+    "id": "q25",
+    "title": "Course with highest average GPA",
+    "difficulty": "Advanced",
+    "description": "Find the course with the highest average GPA.",
+    "hint": "Map grades to GPA, group by course, and use LIMIT.",
+    "expected_sql": "SELECT c.name, AVG(CASE e.grade WHEN 'A' THEN 4.0 WHEN 'A-' THEN 3.7 WHEN 'B+' THEN 3.3 WHEN 'B' THEN 3.0 ELSE 0 END) AS avg_gpa FROM enrollments e JOIN courses c ON e.course_id = c.course_id GROUP BY c.name ORDER BY avg_gpa DESC LIMIT 1;"
+  },
+  {
+    "id": "q26",
+    "title": "Students enrolled in all CSE courses",
+    "difficulty": "Advanced",
+    "description": "List students who have enrolled in every CSE department course.",
+    "hint": "Compare count of CSE courses with enrolled courses using HAVING.",
+    "expected_sql": "SELECT s.name FROM enrollments e JOIN students s ON e.student_id = s.student_id JOIN courses c ON e.course_id = c.course_id WHERE c.department = 'CSE' GROUP BY s.name HAVING COUNT(DISTINCT c.course_id) = (SELECT COUNT(*) FROM courses WHERE department = 'CSE');"
+  },
+  {
+    "id": "q27",
+    "title": "Courses with multi-department students",
+    "difficulty": "Advanced",
+    "description": "Find courses with students from more than one department.",
+    "hint": "Group by course and count distinct departments.",
+    "expected_sql": "SELECT c.name FROM enrollments e JOIN courses c ON e.course_id = c.course_id JOIN students s ON e.student_id = s.student_id GROUP BY c.name HAVING COUNT(DISTINCT s.department) > 1;"
+  },
+  {
+    "id": "q28",
+    "title": "Instructor average GPA",
+    "difficulty": "Advanced",
+    "description": "Calculate the average GPA for students in courses taught by each instructor.",
+    "hint": "Join tables, map grades to GPA, and group by instructor.",
+    "expected_sql": "SELECT c.instructor, AVG(CASE e.grade WHEN 'A' THEN 4.0 WHEN 'A-' THEN 3.7 WHEN 'B+' THEN 3.3 WHEN 'B' THEN 3.0 ELSE 0 END) AS avg_gpa FROM enrollments e JOIN courses c ON e.course_id = c.course_id GROUP BY c.instructor;"
+  },
+  {
+    "id": "q29",
+    "title": "Students with consistent grades",
+    "difficulty": "Advanced",
+    "description": "List students who received the same grade in multiple courses.",
+    "hint": "Group by student and grade, filter for count > 1.",
+    "expected_sql": "SELECT s.name, e.grade FROM enrollments e JOIN students s ON e.student_id = s.student_id GROUP BY s.name, e.grade HAVING COUNT(*) > 1;"
+  },
+  {
+    "id": "q30",
+    "title": "Highest credit course per department",
+    "difficulty": "Advanced",
+    "description": "Find the course with the highest credits in each department.",
+    "hint": "Use a window function or subquery to rank courses by credits.",
+    "expected_sql": "SELECT department, name, credits FROM (SELECT department, name, credits, RANK() OVER (PARTITION BY department ORDER BY credits DESC) AS rnk FROM courses) AS ranked WHERE rnk = 1;"
+  }
+]

app/questions/e_commerce.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List electronics products",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and sale amounts of all products in the Electronics category.",
+    "hint": "Use WHERE clause to filter by category.",
+    "expected_sql": "SELECT product_name, sale_amount FROM sales WHERE category = 'Electronics';"
+  },
+  {
+    "id": "q2",
+    "title": "Find sales after specific date",
+    "difficulty": "Beginner",
+    "description": "Show all sales that occurred after January 5, 2023.",
+    "hint": "Use WHERE clause with date comparison.",
+    "expected_sql": "SELECT product_name, sale_date FROM sales WHERE sale_date > '2023-01-05';"
+  },
+  {
+    "id": "q3",
+    "title": "List orders by customer",
+    "difficulty": "Beginner",
+    "description": "Retrieve all orders placed by customer with ID 2001.",
+    "hint": "Use WHERE clause to filter by customer_id.",
+    "expected_sql": "SELECT order_id, product_id, order_date FROM orders WHERE customer_id = 2001;"
+  },
+  {
+    "id": "q4",
+    "title": "Find high-value sales",
+    "difficulty": "Beginner",
+    "description": "Show products with a sale amount greater than 1000.",
+    "hint": "Use WHERE clause to filter by sale_amount.",
+    "expected_sql": "SELECT product_name, sale_amount FROM sales WHERE sale_amount > 1000;"
+  },
+  {
+    "id": "q5",
+    "title": "List unique categories",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique product categories from the sales table.",
+    "hint": "Use DISTINCT to avoid duplicate categories.",
+    "expected_sql": "SELECT DISTINCT category FROM sales;"
+  },
+  {
+    "id": "q6",
+    "title": "Find orders with quantity greater than 1",
+    "difficulty": "Beginner",
+    "description": "Show order details where the quantity is greater than 1.",
+    "hint": "Use WHERE clause to filter by quantity.",
+    "expected_sql": "SELECT order_id, product_id, quantity FROM orders WHERE quantity > 1;"
+  },
+  {
+    "id": "q7",
+    "title": "List sales by date",
+    "difficulty": "Beginner",
+    "description": "Show all sales ordered by sale date.",
+    "hint": "Use ORDER BY clause on sale_date.",
+    "expected_sql": "SELECT product_name, sale_date FROM sales ORDER BY sale_date;"
+  },
+  {
+    "id": "q8",
+    "title": "Find accessories sales",
+    "difficulty": "Beginner",
+    "description": "Retrieve all sales from the Accessories category.",
+    "hint": "Use WHERE clause to filter by category.",
+    "expected_sql": "SELECT product_name, sale_amount FROM sales WHERE category = 'Accessories';"
+  },
+  {
+    "id": "q9",
+    "title": "List order quantities",
+    "difficulty": "Beginner",
+    "description": "Show the quantity for each order.",
+    "hint": "Select quantity from orders table.",
+    "expected_sql": "SELECT order_id, quantity FROM orders;"
+  },
+  {
+    "id": "q10",
+    "title": "Find sales with low amounts",
+    "difficulty": "Beginner",
+    "description": "Retrieve products with a sale amount less than 100.",
+    "hint": "Use WHERE clause to filter by sale_amount.",
+    "expected_sql": "SELECT product_name, sale_amount FROM sales WHERE sale_amount < 100;"
+  },
+  {
+    "id": "q11",
+    "title": "Total revenue by category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total sale amount for each product category.",
+    "hint": "Use GROUP BY on category and SUM on sale_amount.",
+    "expected_sql": "SELECT category, SUM(sale_amount) AS total_revenue FROM sales GROUP BY category;"
+  },
+  {
+    "id": "q12",
+    "title": "Count orders per product",
+    "difficulty": "Intermediate",
+    "description": "Show the number of orders for each product.",
+    "hint": "Join sales and orders, then GROUP BY product_name.",
+    "expected_sql": "SELECT s.product_name, COUNT(o.order_id) AS order_count FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.product_name;"
+  },
+  {
+    "id": "q13",
+    "title": "Average sale amount per product",
+    "difficulty": "Intermediate",
+    "description": "Find the average sale amount for each product name.",
+    "hint": "Use GROUP BY on product_name and AVG on sale_amount.",
+    "expected_sql": "SELECT product_name, AVG(sale_amount) AS avg_sale FROM sales GROUP BY product_name;"
+  },
+  {
+    "id": "q14",
+    "title": "Customer order count",
+    "difficulty": "Intermediate",
+    "description": "Show the number of orders placed by each customer.",
+    "hint": "Use GROUP BY on customer_id and COUNT.",
+    "expected_sql": "SELECT customer_id, COUNT(order_id) AS order_count FROM orders GROUP BY customer_id;"
+  },
+  {
+    "id": "q15",
+    "title": "High quantity orders",
+    "difficulty": "Intermediate",
+    "description": "List orders with a total quantity greater than 2.",
+    "hint": "Use GROUP BY on order_id and HAVING clause.",
+    "expected_sql": "SELECT order_id, SUM(quantity) AS total_quantity FROM orders GROUP BY order_id HAVING total_quantity > 2;"
+  },
+  {
+    "id": "q16",
+    "title": "Products not ordered",
+    "difficulty": "Intermediate",
+    "description": "List products that have not been ordered.",
+    "hint": "Use LEFT JOIN and check for NULL in orders table.",
+    "expected_sql": "SELECT s.product_name FROM sales s LEFT JOIN orders o ON s.id = o.product_id WHERE o.order_id IS NULL;"
+  },
+  {
+    "id": "q17",
+    "title": "Order details with products",
+    "difficulty": "Intermediate",
+    "description": "Show order details including product names and quantities.",
+    "hint": "Join sales and orders tables.",
+    "expected_sql": "SELECT o.order_id, s.product_name, o.quantity FROM orders o JOIN sales s ON o.product_id = s.id;"
+  },
+  {
+    "id": "q18",
+    "title": "Total quantity per customer",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total quantity of items ordered by each customer.",
+    "hint": "Use GROUP BY on customer_id and SUM on quantity.",
+    "expected_sql": "SELECT customer_id, SUM(quantity) AS total_quantity FROM orders GROUP BY customer_id;"
+  },
+  {
+    "id": "q19",
+    "title": "Orders by date range",
+    "difficulty": "Intermediate",
+    "description": "List all orders placed between January 1, 2023, and January 5, 2023.",
+    "hint": "Use BETWEEN clause for date range.",
+    "expected_sql": "SELECT order_id, customer_id, order_date FROM orders WHERE order_date BETWEEN '2023-01-01' AND '2023-01-05';"
+  },
+  {
+    "id": "q20",
+    "title": "Most ordered product category",
+    "difficulty": "Intermediate",
+    "description": "Find the category with the highest number of orders.",
+    "hint": "Join sales and orders, group by category, and use LIMIT.",
+    "expected_sql": "SELECT s.category, COUNT(o.order_id) AS order_count FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.category ORDER BY order_count DESC LIMIT 1;"
+  },
+  {
+    "id": "q21",
+    "title": "Total revenue per customer",
+    "difficulty": "Advanced",
+    "description": "Calculate the total revenue (sale_amount * quantity) generated by each customer.",
+    "hint": "Join sales and orders, multiply sale_amount by quantity, and group by customer_id.",
+    "expected_sql": "SELECT o.customer_id, SUM(s.sale_amount * o.quantity) AS total_revenue FROM orders o JOIN sales s ON o.product_id = s.id GROUP BY o.customer_id;"
+  },
+  {
+    "id": "q22",
+    "title": "Most expensive ordered product",
+    "difficulty": "Advanced",
+    "description": "Find the product with the highest sale amount that was ordered.",
+    "hint": "Join sales and orders, use ORDER BY and LIMIT.",
+    "expected_sql": "SELECT s.product_name, s.sale_amount FROM sales s JOIN orders o ON s.id = o.product_id ORDER BY s.sale_amount DESC LIMIT 1;"
+  },
+  {
+    "id": "q23",
+    "title": "Daily revenue trend",
+    "difficulty": "Advanced",
+    "description": "Show the total revenue (sale_amount * quantity) per day for all orders.",
+    "hint": "Join tables, group by order_date, and calculate revenue.",
+    "expected_sql": "SELECT o.order_date, SUM(s.sale_amount * o.quantity) AS daily_revenue FROM orders o JOIN sales s ON o.product_id = s.id GROUP BY o.order_date;"
+  },
+  {
+    "id": "q24",
+    "title": "Customers with high-value orders",
+    "difficulty": "Advanced",
+    "description": "Identify customers whose total order value exceeds 2000.",
+    "hint": "Join tables, calculate total value, and use HAVING clause.",
+    "expected_sql": "SELECT o.customer_id, SUM(s.sale_amount * o.quantity) AS total_value FROM orders o JOIN sales s ON o.product_id = s.id GROUP BY o.customer_id HAVING total_value > 2000;"
+  },
+  {
+    "id": "q25",
+    "title": "Products ordered by multiple customers",
+    "difficulty": "Advanced",
+    "description": "Find products that have been ordered by more than one distinct customer.",
+    "hint": "Join sales and orders, use COUNT and DISTINCT on customer_id, and group by product.",
+    "expected_sql": "SELECT s.product_name, COUNT(DISTINCT o.customer_id) AS customer_count FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.product_name HAVING customer_count > 1;"
+  },
+  {
+    "id": "q26",
+    "title": "Revenue contribution by category",
+    "difficulty": "Advanced",
+    "description": "Calculate the total revenue (sale_amount * quantity) for each product category.",
+    "hint": "Join tables, multiply sale_amount by quantity, and group by category.",
+    "expected_sql": "SELECT s.category, SUM(s.sale_amount * o.quantity) AS total_revenue FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.category;"
+  },
+  {
+    "id": "q27",
+    "title": "Earliest and latest order per customer",
+    "difficulty": "Advanced",
+    "description": "Show the earliest and latest order dates for each customer.",
+    "hint": "Use MIN and MAX on order_date, grouped by customer_id.",
+    "expected_sql": "SELECT customer_id, MIN(order_date) AS earliest_order, MAX(order_date) AS latest_order FROM orders GROUP BY customer_id;"
+  },
+  {
+    "id": "q28",
+    "title": "Products with high total quantity",
+    "difficulty": "Advanced",
+    "description": "Find products with a total ordered quantity greater than 2.",
+    "hint": "Join sales and orders, group by product, and use HAVING clause.",
+    "expected_sql": "SELECT s.product_name, SUM(o.quantity) AS total_quantity FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.product_name HAVING total_quantity > 2;"
+  },
+  {
+    "id": "q29",
+    "title": "Customers who ordered all electronics",
+    "difficulty": "Advanced",
+    "description": "List customers who have ordered every product in the Electronics category.",
+    "hint": "Count distinct Electronics products per customer and compare with total Electronics products.",
+    "expected_sql": "SELECT o.customer_id FROM orders o JOIN sales s ON o.product_id = s.id WHERE s.category = 'Electronics' GROUP BY o.customer_id HAVING COUNT(DISTINCT s.id) = (SELECT COUNT(*) FROM sales WHERE category = 'Electronics');"
+  },
+  {
+    "id": "q30",
+    "title": "Most frequent customer by product",
+    "difficulty": "Advanced",
+    "description": "Find the customer who ordered each product the most times.",
+    "hint": "Join tables, group by product and customer, use subquery to find max orders.",
+    "expected_sql": "SELECT s.product_name, o.customer_id, COUNT(o.order_id) AS order_count FROM sales s JOIN orders o ON s.id = o.product_id GROUP BY s.product_name, o.customer_id HAVING COUNT(o.order_id) = (SELECT MAX(order_count) FROM (SELECT COUNT(order_id) AS order_count FROM orders o2 WHERE o2.product_id = s.id GROUP BY o2.customer_id) AS counts);"
+  }
+]

app/questions/hospital.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List female patients",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and contact details of all female patients.",
+    "hint": "Use a WHERE clause to filter by gender.",
+    "expected_sql": "SELECT name, contact FROM patients WHERE gender = 'Female';"
+  },
+  {
+    "id": "q2",
+    "title": "Find appointments on specific date",
+    "difficulty": "Beginner",
+    "description": "Show all appointments scheduled on July 10, 2023.",
+    "hint": "Use a WHERE clause with date comparison.",
+    "expected_sql": "SELECT appointment_id, patient_id, doctor_id, appointment_date FROM appointments WHERE appointment_date = '2023-07-10';"
+  },
+  {
+    "id": "q3",
+    "title": "List cardiologists",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and contact details of all doctors with the Cardiologist specialty.",
+    "hint": "Use a WHERE clause to filter by specialty.",
+    "expected_sql": "SELECT name, contact FROM doctors WHERE specialty = 'Cardiologist';"
+  },
+  {
+    "id": "q4",
+    "title": "Patients born before 1995",
+    "difficulty": "Beginner",
+    "description": "Show the names and dates of birth of patients born before January 1, 1995.",
+    "hint": "Use a WHERE clause with date comparison on dob.",
+    "expected_sql": "SELECT name, dob FROM patients WHERE dob < '1995-01-01';"
+  },
+  {
+    "id": "q5",
+    "title": "List unique diagnoses",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique diagnoses from the appointments table.",
+    "hint": "Use DISTINCT to avoid duplicate diagnoses.",
+    "expected_sql": "SELECT DISTINCT diagnosis FROM appointments;"
+  },
+  {
+    "id": "q6",
+    "title": "Appointments for doctor ID 1",
+    "difficulty": "Beginner",
+    "description": "Show all appointments for the doctor with ID 1.",
+    "hint": "Use a WHERE clause to filter by doctor_id.",
+    "expected_sql": "SELECT appointment_id, patient_id, appointment_date FROM appointments WHERE doctor_id = 1;"
+  },
+  {
+    "id": "q7",
+    "title": "List patient names and genders",
+    "difficulty": "Beginner",
+    "description": "Show all patient names and their genders.",
+    "hint": "Select name and gender from the patients table.",
+    "expected_sql": "SELECT name, gender FROM patients;"
+  },
+  {
+    "id": "q8",
+    "title": "Appointments in August 2023",
+    "difficulty": "Beginner",
+    "description": "Retrieve all appointments scheduled in August 2023.",
+    "hint": "Use a WHERE clause with LIKE for appointment_date.",
+    "expected_sql": "SELECT appointment_id, patient_id, doctor_id, appointment_date FROM appointments WHERE appointment_date LIKE '2023-08%';"
+  },
+  {
+    "id": "q9",
+    "title": "List doctors and specialties",
+    "difficulty": "Beginner",
+    "description": "Show all doctor names and their specialties.",
+    "hint": "Select name and specialty from the doctors table.",
+    "expected_sql": "SELECT name, specialty FROM doctors;"
+  },
+  {
+    "id": "q10",
+    "title": "Patients with Routine Checkup",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names of patients with a diagnosis of 'Routine Checkup'.",
+    "hint": "Join patients and appointments, filter by diagnosis.",
+    "expected_sql": "SELECT p.name FROM patients p JOIN appointments a ON p.patient_id = a.patient_id WHERE a.diagnosis = 'Routine Checkup';"
+  },
+  {
+    "id": "q11",
+    "title": "Appointments per doctor",
+    "difficulty": "Intermediate",
+    "description": "Show the number of appointments for each doctor, including those with zero appointments.",
+    "hint": "Use a LEFT JOIN and GROUP BY doctor name.",
+    "expected_sql": "SELECT d.name, COUNT(a.appointment_id) AS appointment_count FROM doctors d LEFT JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.name;"
+  },
+  {
+    "id": "q12",
+    "title": "Patients with multiple appointments",
+    "difficulty": "Intermediate",
+    "description": "Find patients who have more than one appointment.",
+    "hint": "Join patients and appointments, use GROUP BY and HAVING clause.",
+    "expected_sql": "SELECT p.name, COUNT(a.appointment_id) AS appointment_count FROM patients p JOIN appointments a ON p.patient_id = a.patient_id GROUP BY p.name HAVING COUNT(a.appointment_id) > 1;"
+  },
+  {
+    "id": "q13",
+    "title": "Appointments by doctor specialty",
+    "difficulty": "Intermediate",
+    "description": "Count the number of appointments for each doctor specialty.",
+    "hint": "Join doctors and appointments, then GROUP BY specialty.",
+    "expected_sql": "SELECT d.specialty, COUNT(a.appointment_id) AS total_appointments FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.specialty;"
+  },
+  {
+    "id": "q14",
+    "title": "Patient and doctor appointment details",
+    "difficulty": "Intermediate",
+    "description": "Show patient names, doctor names, and appointment dates for all appointments.",
+    "hint": "Join patients, doctors, and appointments tables.",
+    "expected_sql": "SELECT p.name AS patient_name, d.name AS doctor_name, a.appointment_date FROM appointments a JOIN patients p ON a.patient_id = p.patient_id JOIN doctors d ON a.doctor_id = d.doctor_id;"
+  },
+  {
+    "id": "q15",
+    "title": "Diagnoses by patient gender",
+    "difficulty": "Intermediate",
+    "description": "Count the number of appointments for each diagnosis, grouped by patient gender.",
+    "hint": "Join patients and appointments, GROUP BY gender and diagnosis.",
+    "expected_sql": "SELECT p.gender, a.diagnosis, COUNT(a.appointment_id) AS appointment_count FROM patients p JOIN appointments a ON p.patient_id = a.patient_id GROUP BY p.gender, a.diagnosis;"
+  },
+  {
+    "id": "q16",
+    "title": "Doctors with no appointments",
+    "difficulty": "Intermediate",
+    "description": "List doctors who have not had any appointments.",
+    "hint": "Use a LEFT JOIN and check for NULL in the appointments table.",
+    "expected_sql": "SELECT d.name FROM doctors d LEFT JOIN appointments a ON d.doctor_id = a.doctor_id WHERE a.appointment_id IS NULL;"
+  },
+  {
+    "id": "q17",
+    "title": "Patients seen by multiple doctors",
+    "difficulty": "Intermediate",
+    "description": "Find patients who have appointments with more than one distinct doctor.",
+    "hint": "Join patients and appointments, group by patient, and use HAVING clause.",
+    "expected_sql": "SELECT p.name, COUNT(DISTINCT a.doctor_id) AS doctor_count FROM patients p JOIN appointments a ON p.patient_id = a.patient_id GROUP BY p.name HAVING COUNT(DISTINCT a.doctor_id) > 1;"
+  },
+  {
+    "id": "q18",
+    "title": "Appointments in July 2023",
+    "difficulty": "Intermediate",
+    "description": "List all appointments between July 1, 2023, and July 31, 2023.",
+    "hint": "Use a BETWEEN clause for the date range.",
+    "expected_sql": "SELECT appointment_id, patient_id, doctor_id, appointment_date FROM appointments WHERE appointment_date BETWEEN '2023-07-01' AND '2023-07-31';"
+  },
+  {
+    "id": "q19",
+    "title": "Most common diagnosis",
+    "difficulty": "Intermediate",
+    "description": "Find the diagnosis with the highest number of appointments.",
+    "hint": "Group by diagnosis, count appointments, and use LIMIT.",
+    "expected_sql": "SELECT diagnosis, COUNT(appointment_id) AS diagnosis_count FROM appointments GROUP BY diagnosis ORDER BY diagnosis_count DESC LIMIT 1;"
+  },
+  {
+    "id": "q20",
+    "title": "Unique patients by specialty",
+    "difficulty": "Intermediate",
+    "description": "Show the number of unique patients seen by each doctor specialty.",
+    "hint": "Join doctors and appointments, use COUNT and DISTINCT, group by specialty.",
+    "expected_sql": "SELECT d.specialty, COUNT(DISTINCT a.patient_id) AS unique_patients FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.specialty;"
+  },
+  {
+    "id": "q21",
+    "title": "Patient age at appointment",
+    "difficulty": "Advanced",
+    "description": "Calculate the age of each patient at the time of their appointment.",
+    "hint": "Join patients and appointments, use JULIANDAY for age calculation.",
+    "expected_sql": "SELECT p.name, a.appointment_date, ROUND((JULIANDAY(a.appointment_date) - JULIANDAY(p.dob)) / 365.25, 1) AS age FROM patients p JOIN appointments a ON p.patient_id = a.patient_id;"
+  },
+  {
+    "id": "q22",
+    "title": "Most active doctor",
+    "difficulty": "Advanced",
+    "description": "Find the doctor with the highest number of appointments.",
+    "hint": "Join doctors and appointments, group by doctor name, and use LIMIT.",
+    "expected_sql": "SELECT d.name, COUNT(a.appointment_id) AS appointment_count FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.name ORDER BY appointment_count DESC LIMIT 1;"
+  },
+  {
+    "id": "q23",
+    "title": "Patients seen by Cardiologist",
+    "difficulty": "Advanced",
+    "description": "List all patients who have seen a Cardiologist, including their diagnoses.",
+    "hint": "Join all tables and filter by doctor specialty.",
+    "expected_sql": "SELECT DISTINCT p.name, a.diagnosis FROM patients p JOIN appointments a ON p.patient_id = a.patient_id JOIN doctors d ON a.doctor_id = d.doctor_id WHERE d.specialty = 'Cardiologist';"
+  },
+  {
+    "id": "q24",
+    "title": "Diagnosis frequency by doctor",
+    "difficulty": "Advanced",
+    "description": "Show the number of times each diagnosis was made by each doctor.",
+    "hint": "Join doctors and appointments, group by doctor name and diagnosis.",
+    "expected_sql": "SELECT d.name, a.diagnosis, COUNT(a.appointment_id) AS diagnosis_count FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.name, a.diagnosis;"
+  },
+  {
+    "id": "q25",
+    "title": "Appointments per month",
+    "difficulty": "Advanced",
+    "description": "Show the number of appointments per month in 2023.",
+    "hint": "Use STRFTIME to extract the month and GROUP BY.",
+    "expected_sql": "SELECT STRFTIME('%Y-%m', appointment_date) AS month, COUNT(appointment_id) AS appointment_count FROM appointments GROUP BY month;"
+  },
+  {
+    "id": "q26",
+    "title": "Youngest patient per doctor",
+    "difficulty": "Advanced",
+    "description": "Find the youngest patient seen by each doctor.",
+    "hint": "Join tables, calculate age using JULIANDAY, and group by doctor.",
+    "expected_sql": "SELECT d.name, p.name AS patient_name, MIN(ROUND((JULIANDAY(a.appointment_date) - JULIANDAY(p.dob)) / 365.25, 1)) AS age FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id JOIN patients p ON a.patient_id = p.patient_id GROUP BY d.name;"
+  },
+  {
+    "id": "q27",
+    "title": "Patients with multiple specialties",
+    "difficulty": "Advanced",
+    "description": "List patients who have seen doctors from more than one specialty.",
+    "hint": "Join tables, count distinct specialties, and use HAVING clause.",
+    "expected_sql": "SELECT p.name, COUNT(DISTINCT d.specialty) AS specialty_count FROM patients p JOIN appointments a ON p.patient_id = a.patient_id JOIN doctors d ON a.doctor_id = d.doctor_id GROUP BY p.name HAVING COUNT(DISTINCT d.specialty) > 1;"
+  },
+  {
+    "id": "q28",
+    "title": "Unique diagnoses per doctor",
+    "difficulty": "Advanced",
+    "description": "Show the number of unique diagnoses made by each doctor.",
+    "hint": "Join doctors and appointments, use COUNT and DISTINCT, group by doctor name.",
+    "expected_sql": "SELECT d.name, COUNT(DISTINCT a.diagnosis) AS unique_diagnoses FROM doctors d JOIN appointments a ON d.doctor_id = a.doctor_id GROUP BY d.name;"
+  },
+  {
+    "id": "q29",
+    "title": "Patients not seen by Neurologist",
+    "difficulty": "Advanced",
+    "description": "List patients who have never been seen by a Neurologist.",
+    "hint": "Use NOT IN or LEFT JOIN to exclude patients with Neurologist appointments.",
+    "expected_sql": "SELECT p.name FROM patients p WHERE p.patient_id NOT IN (SELECT a.patient_id FROM appointments a JOIN doctors d ON a.doctor_id = d.doctor_id WHERE d.specialty = 'Neurologist');"
+  },
+  {
+    "id": "q30",
+    "title": "Earliest and latest appointment per patient",
+    "difficulty": "Advanced",
+    "description": "Show the earliest and latest appointment dates for each patient with appointments.",
+    "hint": "Join patients and appointments, use MIN and MAX on appointment_date.",
+    "expected_sql": "SELECT p.name, MIN(a.appointment_date) AS earliest_appointment, MAX(a.appointment_date) AS latest_appointment FROM patients p JOIN appointments a ON p.patient_id = a.patient_id GROUP BY p.name;"
+  }
+]

app/questions/inventory.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List electronics products",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and prices of all products in the Electronics category.",
+    "hint": "Use a WHERE clause to filter by category.",
+    "expected_sql": "SELECT product_name, price FROM inventory WHERE category = 'Electronics';"
+  },
+  {
+    "id": "q2",
+    "title": "Find products with low stock",
+    "difficulty": "Beginner",
+    "description": "Show products with stock less than 10 units.",
+    "hint": "Use a WHERE clause to filter by stock.",
+    "expected_sql": "SELECT product_name, stock FROM inventory WHERE stock < 10;"
+  },
+  {
+    "id": "q3",
+    "title": "List restocks for product ID 1",
+    "difficulty": "Beginner",
+    "description": "Retrieve all restock details for the product with ID 1.",
+    "hint": "Use a WHERE clause to filter by product_id.",
+    "expected_sql": "SELECT restock_id, restock_date, quantity, supplier FROM restocks WHERE product_id = 1;"
+  },
+  {
+    "id": "q4",
+    "title": "Find products by price range",
+    "difficulty": "Beginner",
+    "description": "Show products with prices between 50 and 500, inclusive.",
+    "hint": "Use a BETWEEN clause for the price range.",
+    "expected_sql": "SELECT product_name, price FROM inventory WHERE price BETWEEN 50 AND 500;"
+  },
+  {
+    "id": "q5",
+    "title": "List unique suppliers",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique suppliers from the restocks table.",
+    "hint": "Use DISTINCT to avoid duplicate suppliers.",
+    "expected_sql": "SELECT DISTINCT supplier FROM restocks;"
+  },
+  {
+    "id": "q6",
+    "title": "Products with no restocks",
+    "difficulty": "Beginner",
+    "description": "List products that have never been restocked.",
+    "hint": "Use a LEFT JOIN and check for NULL in the restocks table.",
+    "expected_sql": "SELECT i.product_name FROM inventory i LEFT JOIN restocks r ON i.product_id = r.product_id WHERE r.restock_id IS NULL;"
+  },
+  {
+    "id": "q7",
+    "title": "Restocks in January 2023",
+    "difficulty": "Beginner",
+    "description": "Show all restocks that occurred in January 2023.",
+    "hint": "Use a WHERE clause with LIKE for restock_date.",
+    "expected_sql": "SELECT restock_id, product_id, restock_date, quantity FROM restocks WHERE restock_date LIKE '2023-01%';"
+  },
+  {
+    "id": "q8",
+    "title": "List products and categories",
+    "difficulty": "Beginner",
+    "description": "Show all product names and their categories.",
+    "hint": "Select product_name and category from the inventory table.",
+    "expected_sql": "SELECT product_name, category FROM inventory;"
+  },
+  {
+    "id": "q9",
+    "title": "Find high-priced products",
+    "difficulty": "Beginner",
+    "description": "Retrieve products with a price greater than 1000.",
+    "hint": "Use a WHERE clause to filter by price.",
+    "expected_sql": "SELECT product_name, price FROM inventory WHERE price > 1000;"
+  },
+  {
+    "id": "q10",
+    "title": "List restock quantities",
+    "difficulty": "Beginner",
+    "description": "Show the quantity restocked for each restock event.",
+    "hint": "Select restock_id and quantity from the restocks table.",
+    "expected_sql": "SELECT restock_id, quantity FROM restocks;"
+  },
+  {
+    "id": "q11",
+    "title": "Total stock per category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total stock for each product category.",
+    "hint": "Use GROUP BY on category and SUM on stock.",
+    "expected_sql": "SELECT category, SUM(stock) AS total_stock FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q12",
+    "title": "Average product price by category",
+    "difficulty": "Intermediate",
+    "description": "Find the average price of products in each category.",
+    "hint": "Use GROUP BY on category and AVG on price.",
+    "expected_sql": "SELECT category, AVG(price) AS avg_price FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q13",
+    "title": "Restocks by supplier",
+    "difficulty": "Intermediate",
+    "description": "Count the number of restock events for each supplier.",
+    "hint": "Use GROUP BY on supplier and COUNT.",
+    "expected_sql": "SELECT supplier, COUNT(restock_id) AS restock_count FROM restocks GROUP BY supplier;"
+  },
+  {
+    "id": "q14",
+    "title": "Total restock quantity per product",
+    "difficulty": "Intermediate",
+    "description": "Show the total quantity restocked for each product.",
+    "hint": "Join inventory and restocks, then GROUP BY product_name.",
+    "expected_sql": "SELECT i.product_name, SUM(r.quantity) AS total_restocked FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q15",
+    "title": "Products with multiple restocks",
+    "difficulty": "Intermediate",
+    "description": "List products that have been restocked more than once.",
+    "hint": "Use GROUP BY on product_name and HAVING clause.",
+    "expected_sql": "SELECT i.product_name, COUNT(r.restock_id) AS restock_count FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name HAVING COUNT(r.restock_id) > 1;"
+  },
+  {
+    "id": "q16",
+    "title": "Total inventory value by category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total value of inventory (price * stock) for each category.",
+    "hint": "Use GROUP BY on category and SUM on price * stock.",
+    "expected_sql": "SELECT category, SUM(price * stock) AS total_value FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q17",
+    "title": "Restock details with products",
+    "difficulty": "Intermediate",
+    "description": "Show restock details including product names, quantities, and suppliers.",
+    "hint": "Join inventory and restocks tables.",
+    "expected_sql": "SELECT r.restock_id, i.product_name, r.restock_date, r.quantity, r.supplier FROM inventory i JOIN restocks r ON i.product_id = r.product_id;"
+  },
+  {
+    "id": "q18",
+    "title": "Products with high stock",
+    "difficulty": "Intermediate",
+    "description": "List products with stock greater than 20, ordered by stock descending.",
+    "hint": "Use WHERE and ORDER BY clauses.",
+    "expected_sql": "SELECT product_name, stock FROM inventory WHERE stock > 20 ORDER BY stock DESC;"
+  },
+  {
+    "id": "q19",
+    "title": "Suppliers with large restocks",
+    "difficulty": "Intermediate",
+    "description": "Find suppliers who have restocked quantities greater than 10 in a single restock event.",
+    "hint": "Use WHERE clause on quantity and select DISTINCT supplier.",
+    "expected_sql": "SELECT DISTINCT supplier FROM restocks WHERE quantity > 10;"
+  },
+  {
+    "id": "q20",
+    "title": "Restock frequency by product",
+    "difficulty": "Intermediate",
+    "description": "Show the number of restock events for each product, including those with zero restocks.",
+    "hint": "Use a LEFT JOIN and GROUP BY product_name.",
+    "expected_sql": "SELECT i.product_name, COUNT(r.restock_id) AS restock_count FROM inventory i LEFT JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q21",
+    "title": "Most expensive restocked product",
+    "difficulty": "Advanced",
+    "description": "Find the product with the highest price that has been restocked.",
+    "hint": "Join inventory and restocks, use ORDER BY and LIMIT.",
+    "expected_sql": "SELECT i.product_name, i.price FROM inventory i JOIN restocks r ON i.product_id = r.product_id ORDER BY i.price DESC LIMIT 1;"
+  },
+  {
+    "id": "q22",
+    "title": "Total restock value per supplier",
+    "difficulty": "Advanced",
+    "description": "Calculate the total value of restocks (price * quantity) for each supplier.",
+    "hint": "Join tables, multiply price by quantity, and group by supplier.",
+    "expected_sql": "SELECT r.supplier, SUM(i.price * r.quantity) AS total_restock_value FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY r.supplier;"
+  },
+  {
+    "id": "q23",
+    "title": "Latest restock per product",
+    "difficulty": "Advanced",
+    "description": "Show the most recent restock date for each product that has been restocked.",
+    "hint": "Use GROUP BY on product_name and MAX on restock_date.",
+    "expected_sql": "SELECT i.product_name, MAX(r.restock_date) AS latest_restock FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q24",
+    "title": "Low stock high-value products",
+    "difficulty": "Advanced",
+    "description": "Identify products with stock less than 10 and price greater than 500.",
+    "hint": "Use multiple conditions in the WHERE clause.",
+    "expected_sql": "SELECT product_name, price, stock FROM inventory WHERE stock < 10 AND price > 500;"
+  },
+  {
+    "id": "q25",
+    "title": "Restock trend by month",
+    "difficulty": "Advanced",
+    "description": "Show the total quantity restocked per month in 2023.",
+    "hint": "Use STRFTIME to extract the month and GROUP BY.",
+    "expected_sql": "SELECT STRFTIME('%Y-%m', restock_date) AS month, SUM(quantity) AS total_quantity FROM restocks GROUP BY month;"
+  },
+  {
+    "id": "q26",
+    "title": "Products with high restock value",
+    "difficulty": "Advanced",
+    "description": "Find products where the total restock value (price * quantity) exceeds 5000.",
+    "hint": "Join tables, calculate value, and use HAVING clause.",
+    "expected_sql": "SELECT i.product_name, SUM(i.price * r.quantity) AS total_restock_value FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name HAVING SUM(i.price * r.quantity) > 5000;"
+  },
+  {
+    "id": "q27",
+    "title": "Supplier product diversity",
+    "difficulty": "Advanced",
+    "description": "Count the number of unique products each supplier has restocked.",
+    "hint": "Use COUNT and DISTINCT on product_id, grouped by supplier.",
+    "expected_sql": "SELECT r.supplier, COUNT(DISTINCT r.product_id) AS unique_products FROM restocks r GROUP BY r.supplier;"
+  },
+  {
+    "id": "q28",
+    "title": "Overstocked products",
+    "difficulty": "Advanced",
+    "description": "Identify products where the total restocked quantity exceeds the current stock by more than 10.",
+    "hint": "Join tables, compare SUM(quantity) with stock, and use HAVING.",
+    "expected_sql": "SELECT i.product_name, i.stock, SUM(r.quantity) AS total_restocked FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name, i.stock HAVING SUM(r.quantity) > i.stock + 10;"
+  },
+  {
+    "id": "q29",
+    "title": "Suppliers restocking all electronics",
+    "difficulty": "Advanced",
+    "description": "List suppliers who have restocked every product in the Electronics category.",
+    "hint": "Count distinct Electronics products per supplier and compare with total Electronics products.",
+    "expected_sql": "SELECT r.supplier FROM restocks r JOIN inventory i ON r.product_id = i.product_id WHERE i.category = 'Electronics' GROUP BY r.supplier HAVING COUNT(DISTINCT r.product_id) = (SELECT COUNT(*) FROM inventory WHERE category = 'Electronics');"
+  },
+  {
+    "id": "q30",
+    "title": "Earliest and latest restock per supplier",
+    "difficulty": "Advanced",
+    "description": "Show the earliest and latest restock dates for each supplier.",
+    "hint": "Use MIN and MAX on restock_date, grouped by supplier.",
+    "expected_sql": "SELECT supplier, MIN(restock_date) AS earliest_restock, MAX(restock_date) AS latest_restock FROM restocks GROUP BY supplier;"
+  }
+]

app/questions/library.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List all science fiction books",
+    "difficulty": "Beginner",
+    "description": "Retrieve the titles and authors of all books in the Science Fiction genre.",
+    "hint": "Use a WHERE clause to filter by genre.",
+    "expected_sql": "SELECT title, author FROM books WHERE genre = 'Science Fiction';"
+  },
+  {
+    "id": "q2",
+    "title": "Find books with low availability",
+    "difficulty": "Beginner",
+    "description": "Show books with fewer than 2 available copies.",
+    "hint": "Use a WHERE clause to filter by available_copies.",
+    "expected_sql": "SELECT title, available_copies FROM books WHERE available_copies < 2;"
+  },
+  {
+    "id": "q3",
+    "title": "List loans for user ID 101",
+    "difficulty": "Beginner",
+    "description": "Retrieve all loan details for the user with ID 101.",
+    "hint": "Use a WHERE clause to filter by user_id.",
+    "expected_sql": "SELECT loan_id, book_id, issue_date, due_date FROM loans WHERE user_id = 101;"
+  },
+  {
+    "id": "q4",
+    "title": "Find books published after 2000",
+    "difficulty": "Beginner",
+    "description": "Show titles and publication years of books published after 2000.",
+    "hint": "Use a WHERE clause with year comparison.",
+    "expected_sql": "SELECT title, year FROM books WHERE year > 2000;"
+  },
+  {
+    "id": "q5",
+    "title": "List unique genres",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique genres from the books table.",
+    "hint": "Use DISTINCT to avoid duplicate genres.",
+    "expected_sql": "SELECT DISTINCT genre FROM books;"
+  },
+  {
+    "id": "q6",
+    "title": "Find overdue loans",
+    "difficulty": "Beginner",
+    "description": "Show loans that are overdue as of '2023-03-01' (due_date before '2023-03-01' and not returned).",
+    "hint": "Use a WHERE clause to check due_date and NULL return_date.",
+    "expected_sql": "SELECT loan_id, book_id, due_date FROM loans WHERE due_date < '2023-03-01' AND return_date IS NULL;"
+  },
+  {
+    "id": "q7",
+    "title": "List users joined after 2020",
+    "difficulty": "Beginner",
+    "description": "Show names and emails of users who joined after December 31, 2020.",
+    "hint": "Use a WHERE clause with membership_date.",
+    "expected_sql": "SELECT name, email FROM users WHERE membership_date > '2020-12-31';"
+  },
+  {
+    "id": "q8",
+    "title": "Books by George Orwell",
+    "difficulty": "Beginner",
+    "description": "Retrieve all books written by George Orwell.",
+    "hint": "Use a WHERE clause to filter by author.",
+    "expected_sql": "SELECT title, genre FROM books WHERE author = 'George Orwell';"
+  },
+  {
+    "id": "q9",
+    "title": "List active loans",
+    "difficulty": "Beginner",
+    "description": "Show all loans that have not been returned.",
+    "hint": "Use a WHERE clause to check for NULL return_date.",
+    "expected_sql": "SELECT loan_id, book_id, user_id, issue_date FROM loans WHERE return_date IS NULL;"
+  },
+  {
+    "id": "q10",
+    "title": "List books by publication year",
+    "difficulty": "Beginner",
+    "description": "Show all book titles and their publication years, ordered by year ascending.",
+    "hint": "Use ORDER BY clause on year.",
+    "expected_sql": "SELECT title, year FROM books ORDER BY year ASC;"
+  },
+  {
+    "id": "q11",
+    "title": "Count loans per book",
+    "difficulty": "Intermediate",
+    "description": "Show the number of loans for each book, including books with zero loans.",
+    "hint": "Use a LEFT JOIN and GROUP BY book title.",
+    "expected_sql": "SELECT b.title, COUNT(l.loan_id) AS loan_count FROM books b LEFT JOIN loans l ON b.book_id = l.book_id GROUP BY b.title;"
+  },
+  {
+    "id": "q12",
+    "title": "Total loans per user",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total number of loans for each user, including users with zero loans.",
+    "hint": "Use a LEFT JOIN and GROUP BY user name.",
+    "expected_sql": "SELECT u.name, COUNT(l.loan_id) AS total_loans FROM users u LEFT JOIN loans l ON u.user_id = l.user_id GROUP BY u.name;"
+  },
+  {
+    "id": "q13",
+    "title": "Books by genre count",
+    "difficulty": "Intermediate",
+    "description": "Count the number of books in each genre.",
+    "hint": "Use GROUP BY on genre and COUNT.",
+    "expected_sql": "SELECT genre, COUNT(book_id) AS book_count FROM books GROUP BY genre;"
+  },
+  {
+    "id": "q14",
+    "title": "Active loans by genre",
+    "difficulty": "Intermediate",
+    "description": "Show the number of active loans (not returned) for each book genre.",
+    "hint": "Join books and loans, filter by NULL return_date, and GROUP BY genre.",
+    "expected_sql": "SELECT b.genre, COUNT(l.loan_id) AS active_loans FROM books b JOIN loans l ON b.book_id = l.book_id WHERE l.return_date IS NULL GROUP BY b.genre;"
+  },
+  {
+    "id": "q15",
+    "title": "Users with multiple loans",
+    "difficulty": "Intermediate",
+    "description": "Find users who have taken out more than one loan.",
+    "hint": "Use GROUP BY on user name and HAVING clause.",
+    "expected_sql": "SELECT u.name, COUNT(l.loan_id) AS loan_count FROM users u JOIN loans l ON u.user_id = l.user_id GROUP BY u.name HAVING COUNT(l.loan_id) > 1;"
+  },
+  {
+    "id": "q16",
+    "title": "Books never loaned",
+    "difficulty": "Intermediate",
+    "description": "List books that have never been loaned.",
+    "hint": "Use a LEFT JOIN and check for NULL in the loans table.",
+    "expected_sql": "SELECT b.title FROM books b LEFT JOIN loans l ON b.book_id = l.book_id WHERE l.loan_id IS NULL;"
+  },
+  {
+    "id": "q17",
+    "title": "Loan details with book and user",
+    "difficulty": "Intermediate",
+    "description": "Show loan details including book title, user name, and issue date for all loans.",
+    "hint": "Join books, users, and loans tables.",
+    "expected_sql": "SELECT l.loan_id, b.title, u.name, l.issue_date FROM loans l JOIN books b ON l.book_id = b.book_id JOIN users u ON l.user_id = u.user_id;"
+  },
+  {
+    "id": "q18",
+    "title": "Books loaned in 2022",
+    "difficulty": "Intermediate",
+    "description": "List all books that were loaned in 2022.",
+    "hint": "Use a WHERE clause with LIKE on issue_date and JOIN with books.",
+    "expected_sql": "SELECT DISTINCT b.title FROM books b JOIN loans l ON b.book_id = l.book_id WHERE l.issue_date LIKE '2022%';"
+  },
+  {
+    "id": "q19",
+    "title": "Average loan duration for returned books",
+    "difficulty": "Intermediate",
+    "description": "Calculate the average number of days for loans that have been returned.",
+    "hint": "Use JULIANDAY to calculate date difference and AVG.",
+    "expected_sql": "SELECT AVG(JULIANDAY(return_date) - JULIANDAY(issue_date)) AS avg_loan_days FROM loans WHERE return_date IS NOT NULL;"
+  },
+  {
+    "id": "q20",
+    "title": "Most popular author by loans",
+    "difficulty": "Intermediate",
+    "description": "Find the author with the most loans.",
+    "hint": "Join books and loans, GROUP BY author, and use LIMIT.",
+    "expected_sql": "SELECT b.author, COUNT(l.loan_id) AS loan_count FROM books b JOIN loans l ON b.book_id = l.book_id GROUP BY b.author ORDER BY loan_count DESC LIMIT 1;"
+  },
+  {
+    "id": "q21",
+    "title": "Overdue loans with user details",
+    "difficulty": "Advanced",
+    "description": "Show user names, book titles, and days overdue for loans not returned by '2023-03-01'.",
+    "hint": "Join tables, filter for overdue loans, and calculate days overdue.",
+    "expected_sql": "SELECT u.name, b.title, ROUND(JULIANDAY('2023-03-01') - JULIANDAY(l.due_date), 1) AS days_overdue FROM loans l JOIN books b ON l.book_id = b.book_id JOIN users u ON l.user_id = u.user_id WHERE l.due_date < '2023-03-01' AND l.return_date IS NULL;"
+  },
+  {
+    "id": "q22",
+    "title": "Most active user by loan duration",
+    "difficulty": "Advanced",
+    "description": "Find the user with the highest total loan duration for returned books.",
+    "hint": "Join users and loans, calculate duration, GROUP BY user, and use LIMIT.",
+    "expected_sql": "SELECT u.name, SUM(JULIANDAY(l.return_date) - JULIANDAY(l.issue_date)) AS total_loan_days FROM users u JOIN loans l ON u.user_id = l.user_id WHERE l.return_date IS NOT NULL GROUP BY u.name ORDER BY total_loan_days DESC LIMIT 1;"
+  },
+  {
+    "id": "q23",
+    "title": "Books with high demand",
+    "difficulty": "Advanced",
+    "description": "Identify books with more loans than their available copies.",
+    "hint": "Join books and loans, GROUP BY book, and use HAVING clause.",
+    "expected_sql": "SELECT b.title, COUNT(l.loan_id) AS loan_count, b.available_copies FROM books b JOIN loans l ON b.book_id = l.book_id GROUP BY b.title, b.available_copies HAVING COUNT(l.loan_id) > b.available_copies;"
+  },
+  {
+    "id": "q24",
+    "title": "Longest overdue loan",
+    "difficulty": "Advanced",
+    "description": "Find the loan with the longest overdue period as of '2023-03-01'.",
+    "hint": "Calculate days overdue, filter for overdue loans, and use LIMIT.",
+    "expected_sql": "SELECT l.loan_id, b.title, ROUND(JULIANDAY('2023-03-01') - JULIANDAY(l.due_date), 1) AS days_overdue FROM loans l JOIN books b ON l.book_id = b.book_id WHERE l.return_date IS NULL AND l.due_date < '2023-03-01' ORDER BY days_overdue DESC LIMIT 1;"
+  },
+  {
+    "id": "q25",
+    "title": "Loan activity by month",
+    "difficulty": "Advanced",
+    "description": "Show the number of loans issued per month in 2022 and 2023.",
+    "hint": "Use STRFTIME to extract the month and GROUP BY.",
+    "expected_sql": "SELECT STRFTIME('%Y-%m', issue_date) AS month, COUNT(loan_id) AS loan_count FROM loans GROUP BY month;"
+  },
+  {
+    "id": "q26",
+    "title": "Users with no returns",
+    "difficulty": "Advanced",
+    "description": "List users who have loans but no returned books.",
+    "hint": "Use JOIN and check for NULL return_date with HAVING clause.",
+    "expected_sql": "SELECT u.name FROM users u JOIN loans l ON u.user_id = l.user_id GROUP BY u.name HAVING COUNT(l.return_date) = 0;"
+  },
+  {
+    "id": "q27",
+    "title": "Books loaned by multiple users",
+    "difficulty": "Advanced",
+    "description": "Find books that have been loaned by more than one distinct user.",
+    "hint": "Use COUNT and DISTINCT on user_id, GROUP BY book title.",
+    "expected_sql": "SELECT b.title, COUNT(DISTINCT l.user_id) AS user_count FROM books b JOIN loans l ON b.book_id = l.book_id GROUP BY b.title HAVING COUNT(DISTINCT l.user_id) > 1;"
+  },
+  {
+    "id": "q28",
+    "title": "Average loan duration by genre",
+    "difficulty": "Advanced",
+    "description": "Calculate the average loan duration for returned books by genre.",
+    "hint": "Join books and loans, calculate duration, and GROUP BY genre.",
+    "expected_sql": "SELECT b.genre, AVG(JULIANDAY(l.return_date) - JULIANDAY(l.issue_date)) AS avg_loan_days FROM books b JOIN loans l ON b.book_id = l.book_id WHERE l.return_date IS NOT NULL GROUP BY b.genre;"
+  },
+  {
+    "id": "q29",
+    "title": "Users borrowing all science fiction books",
+    "difficulty": "Advanced",
+    "description": "List users who have borrowed every book in the Science Fiction genre.",
+    "hint": "Count distinct Science Fiction books per user and compare with total Science Fiction books.",
+    "expected_sql": "SELECT u.name FROM users u JOIN loans l ON u.user_id = l.user_id JOIN books b ON l.book_id = b.book_id WHERE b.genre = 'Science Fiction' GROUP BY u.name HAVING COUNT(DISTINCT b.book_id) = (SELECT COUNT(*) FROM books WHERE genre = 'Science Fiction');"
+  },
+  {
+    "id": "q30",
+    "title": "Earliest and latest loan per book",
+    "difficulty": "Advanced",
+    "description": "Show the earliest and latest issue dates for each book that has been loaned.",
+    "hint": "Use MIN and MAX on issue_date, GROUP BY book title.",
+    "expected_sql": "SELECT b.title, MIN(l.issue_date) AS earliest_loan, MAX(l.issue_date) AS latest_loan FROM books b JOIN loans l ON b.book_id = l.book_id GROUP BY b.title;"
+  }
+]

app/questions/restaurant.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List all main course items",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and prices of all menu items in the Main Course category.",
+    "hint": "Use a WHERE clause to filter by category.",
+    "expected_sql": "SELECT name, price FROM menu_items WHERE category = 'Main Course';"
+  },
+  {
+    "id": "q2",
+    "title": "Find orders by customer ID 1",
+    "difficulty": "Beginner",
+    "description": "Show all orders placed by the customer with ID 1.",
+    "hint": "Use a WHERE clause to filter by customer_id.",
+    "expected_sql": "SELECT order_id, order_date, total_amount FROM orders WHERE customer_id = 1;"
+  },
+  {
+    "id": "q3",
+    "title": "List all beverages",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and prices of all items in the Beverage category.",
+    "hint": "Use a WHERE clause to filter by category.",
+    "expected_sql": "SELECT name, price FROM menu_items WHERE category = 'Beverage';"
+  },
+  {
+    "id": "q4",
+    "title": "Find orders on June 11, 2023",
+    "difficulty": "Beginner",
+    "description": "Show all orders placed on June 11, 2023.",
+    "hint": "Use a WHERE clause with date comparison.",
+    "expected_sql": "SELECT order_id, customer_id, total_amount FROM orders WHERE order_date = '2023-06-11';"
+  },
+  {
+    "id": "q5",
+    "title": "List unique customer emails",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique customer email addresses.",
+    "hint": "Use DISTINCT to avoid duplicate emails.",
+    "expected_sql": "SELECT DISTINCT email FROM customers;"
+  },
+  {
+    "id": "q6",
+    "title": "Items in order ID 3",
+    "difficulty": "Beginner",
+    "description": "Show the menu items and quantities for order ID 3.",
+    "hint": "Join order_items with menu_items and filter by order_id.",
+    "expected_sql": "SELECT m.name, oi.quantity FROM order_items oi JOIN menu_items m ON oi.item_id = m.item_id WHERE oi.order_id = 3;"
+  },
+  {
+    "id": "q7",
+    "title": "List customer contact details",
+    "difficulty": "Beginner",
+    "description": "Show names and contact numbers of all customers.",
+    "hint": "Select name and contact from the customers table.",
+    "expected_sql": "SELECT name, contact FROM customers;"
+  },
+  {
+    "id": "q8",
+    "title": "Find high-priced items",
+    "difficulty": "Beginner",
+    "description": "Retrieve menu items with a price greater than 150.",
+    "hint": "Use a WHERE clause to filter by price.",
+    "expected_sql": "SELECT name, price FROM menu_items WHERE price > 150;"
+  },
+  {
+    "id": "q9",
+    "title": "List all order items",
+    "difficulty": "Beginner",
+    "description": "Show all order items with their quantities.",
+    "hint": "Select from the order_items table.",
+    "expected_sql": "SELECT order_item_id, order_id, item_id, quantity FROM order_items;"
+  },
+  {
+    "id": "q10",
+    "title": "Find orders above 300",
+    "difficulty": "Beginner",
+    "description": "Show orders with a total amount greater than 300.",
+    "hint": "Use a WHERE clause to filter by total_amount.",
+    "expected_sql": "SELECT order_id, customer_id, total_amount FROM orders WHERE total_amount > 300;"
+  },
+  {
+    "id": "q11",
+    "title": "Count orders per customer",
+    "difficulty": "Intermediate",
+    "description": "Show the number of orders placed by each customer, including those with zero orders.",
+    "hint": "Use a LEFT JOIN and GROUP BY customer name.",
+    "expected_sql": "SELECT c.name, COUNT(o.order_id) AS order_count FROM customers c LEFT JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.name;"
+  },
+  {
+    "id": "q12",
+    "title": "Total items ordered per category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total quantity of items ordered for each menu item category.",
+    "hint": "Join menu_items and order_items, then GROUP BY category.",
+    "expected_sql": "SELECT m.category, SUM(oi.quantity) AS total_quantity FROM menu_items m JOIN order_items oi ON m.item_id = oi.item_id GROUP BY m.category;"
+  },
+  {
+    "id": "q13",
+    "title": "Average order amount",
+    "difficulty": "Intermediate",
+    "description": "Calculate the average total amount of all orders.",
+    "hint": "Use AVG on total_amount in the orders table.",
+    "expected_sql": "SELECT AVG(total_amount) AS avg_order_amount FROM orders;"
+  },
+  {
+    "id": "q14",
+    "title": "Most ordered menu item",
+    "difficulty": "Intermediate",
+    "description": "Identify the menu item with the highest total quantity ordered.",
+    "hint": "Join order_items and menu_items, GROUP BY item name, and use LIMIT.",
+    "expected_sql": "SELECT m.name, SUM(oi.quantity) AS total_quantity FROM menu_items m JOIN order_items oi ON m.item_id = oi.item_id GROUP BY m.name ORDER BY total_quantity DESC LIMIT 1;"
+  },
+  {
+    "id": "q15",
+    "title": "Customers with multiple orders",
+    "difficulty": "Intermediate",
+    "description": "Find customers who have placed more than one order.",
+    "hint": "Use GROUP BY on customer name and HAVING clause.",
+    "expected_sql": "SELECT c.name, COUNT(o.order_id) AS order_count FROM customers c JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.name HAVING COUNT(o.order_id) > 1;"
+  },
+  {
+    "id": "q16",
+    "title": "Menu items never ordered",
+    "difficulty": "Intermediate",
+    "description": "List menu items that have never been ordered.",
+    "hint": "Use a LEFT JOIN and check for NULL in the order_items table.",
+    "expected_sql": "SELECT m.name FROM menu_items m LEFT JOIN order_items oi ON m.item_id = oi.item_id WHERE oi.order_item_id IS NULL;"
+  },
+  {
+    "id": "q17",
+    "title": "Order details with items",
+    "difficulty": "Intermediate",
+    "description": "Show order details including customer name and menu items for each order.",
+    "hint": "Join orders, customers, order_items, and menu_items tables.",
+    "expected_sql": "SELECT o.order_id, c.name AS customer_name, m.name AS item_name, oi.quantity FROM orders o JOIN customers c ON o.customer_id = c.customer_id JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id;"
+  },
+  {
+    "id": "q18",
+    "title": "Total revenue per customer",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total amount spent by each customer based on order totals.",
+    "hint": "Use GROUP BY on customer name and SUM on total_amount.",
+    "expected_sql": "SELECT c.name, SUM(o.total_amount) AS total_spent FROM customers c JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.name;"
+  },
+  {
+    "id": "q19",
+    "title": "Orders with multiple items",
+    "difficulty": "Intermediate",
+    "description": "List orders that include more than one type of menu item.",
+    "hint": "Use GROUP BY on order_id and HAVING clause on COUNT of item_id.",
+    "expected_sql": "SELECT o.order_id, COUNT(oi.item_id) AS item_count FROM orders o JOIN order_items oi ON o.order_id = oi.order_id GROUP BY o.order_id HAVING COUNT(oi.item_id) > 1;"
+  },
+  {
+    "id": "q20",
+    "title": "Items ordered with high quantity",
+    "difficulty": "Intermediate",
+    "description": "Show menu items with a total ordered quantity greater than 2.",
+    "hint": "Join order_items and menu_items, GROUP BY item name, and use HAVING.",
+    "expected_sql": "SELECT m.name, SUM(oi.quantity) AS total_quantity FROM menu_items m JOIN order_items oi ON m.item_id = oi.item_id GROUP BY m.name HAVING SUM(oi.quantity) > 2;"
+  },
+  {
+    "id": "q21",
+    "title": "Customer order value analysis",
+    "difficulty": "Advanced",
+    "description": "Calculate the total value of orders (sum of price * quantity) for each customer.",
+    "hint": "Join all tables, multiply price by quantity, and GROUP BY customer name.",
+    "expected_sql": "SELECT c.name, SUM(m.price * oi.quantity) AS total_order_value FROM customers c JOIN orders o ON c.customer_id = o.customer_id JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id GROUP BY c.name;"
+  },
+  {
+    "id": "q22",
+    "title": "Most expensive order",
+    "difficulty": "Advanced",
+    "description": "Identify the order with the highest calculated total based on item prices and quantities.",
+    "hint": "Join orders, order_items, and menu_items, calculate total, and use LIMIT.",
+    "expected_sql": "SELECT o.order_id, SUM(m.price * oi.quantity) AS calculated_total FROM orders o JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id GROUP BY o.order_id ORDER BY calculated_total DESC LIMIT 1;"
+  },
+  {
+    "id": "q23",
+    "title": "Customers ordering all main courses",
+    "difficulty": "Advanced",
+    "description": "Find customers who have ordered every item in the Main Course category.",
+    "hint": "Count distinct Main Course items per customer and compare with total Main Course items.",
+    "expected_sql": "SELECT c.name FROM customers c JOIN orders o ON c.customer_id = o.customer_id JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id WHERE m.category = 'Main Course' GROUP BY c.name HAVING COUNT(DISTINCT m.item_id) = (SELECT COUNT(*) FROM menu_items WHERE category = 'Main Course');"
+  },
+  {
+    "id": "q24",
+    "title": "Average item price per order",
+    "difficulty": "Advanced",
+    "description": "Calculate the average price of items in each order.",
+    "hint": "Join order_items and menu_items, GROUP BY order_id, and use AVG.",
+    "expected_sql": "SELECT o.order_id, AVG(m.price) AS avg_item_price FROM orders o JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id GROUP BY o.order_id;"
+  },
+  {
+    "id": "q25",
+    "title": "Order frequency by date",
+    "difficulty": "Advanced",
+    "description": "Show the number of orders placed on each date in June 2023.",
+    "hint": "Use GROUP BY on order_date and COUNT.",
+    "expected_sql": "SELECT order_date, COUNT(order_id) AS order_count FROM orders WHERE order_date LIKE '2023-06%' GROUP BY order_date;"
+  },
+  {
+    "id": "q26",
+    "title": "Customers who ordered Margherita Pizza",
+    "difficulty": "Advanced",
+    "description": "List customers who have ordered a Margherita Pizza.",
+    "hint": "Join all tables and filter by item name.",
+    "expected_sql": "SELECT DISTINCT c.name FROM customers c JOIN orders o ON c.customer_id = o.customer_id JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id WHERE m.name = 'Margherita Pizza';"
+  },
+  {
+    "id": "q27",
+    "title": "Category revenue contribution",
+    "difficulty": "Advanced",
+    "description": "Calculate the total revenue generated by each menu item category.",
+    "hint": "Join menu_items and order_items, multiply price by quantity, and GROUP BY category.",
+    "expected_sql": "SELECT m.category, SUM(m.price * oi.quantity) AS total_revenue FROM menu_items m JOIN order_items oi ON m.item_id = oi.item_id GROUP BY m.category;"
+  },
+  {
+    "id": "q28",
+    "title": "Orders with high item diversity",
+    "difficulty": "Advanced",
+    "description": "Find orders that include items from more than one category.",
+    "hint": "Join tables, GROUP BY order_id, and COUNT distinct categories.",
+    "expected_sql": "SELECT o.order_id, COUNT(DISTINCT m.category) AS category_count FROM orders o JOIN order_items oi ON o.order_id = oi.order_id JOIN menu_items m ON oi.item_id = m.item_id GROUP BY o.order_id HAVING COUNT(DISTINCT m.category) > 1;"
+  },
+  {
+    "id": "q29",
+    "title": "Customer spending rank",
+    "difficulty": "Advanced",
+    "description": "Rank customers by their total spending (sum of order totals).",
+    "hint": "Use GROUP BY on customer name, SUM, and ORDER BY.",
+    "expected_sql": "SELECT c.name, SUM(o.total_amount) AS total_spent FROM customers c JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.name ORDER BY total_spent DESC;"
+  },
+  {
+    "id": "q30",
+    "title": "Items with high revenue contribution",
+    "difficulty": "Advanced",
+    "description": "Identify menu items contributing more than 200 in total revenue (price * quantity).",
+    "hint": "Join menu_items and order_items, calculate revenue, and use HAVING.",
+    "expected_sql": "SELECT m.name, SUM(m.price * oi.quantity) AS total_revenue FROM menu_items m JOIN order_items oi ON m.item_id = oi.item_id GROUP BY m.name HAVING SUM(m.price * oi.quantity) > 200;"
+  }
+]

app/questions/retail.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "q1",
+    "title": "List electronics products",
+    "difficulty": "Beginner",
+    "description": "Retrieve the names and prices of all products in the Electronics category.",
+    "hint": "Use a WHERE clause to filter by category.",
+    "expected_sql": "SELECT product_name, price FROM inventory WHERE category = 'Electronics';"
+  },
+  {
+    "id": "q2",
+    "title": "Find low stock products",
+    "difficulty": "Beginner",
+    "description": "Show products with stock below their reorder level.",
+    "hint": "Use a WHERE clause to compare stock and reorder_level.",
+    "expected_sql": "SELECT product_name, stock, reorder_level FROM inventory WHERE stock < reorder_level;"
+  },
+  {
+    "id": "q3",
+    "title": "List restocks for product ID 1",
+    "difficulty": "Beginner",
+    "description": "Retrieve all restock details for the product with ID 1.",
+    "hint": "Use a WHERE clause to filter by product_id in the restocks table.",
+    "expected_sql": "SELECT restock_id, restock_date, quantity, supplier FROM restocks WHERE product_id = 1;"
+  },
+  {
+    "id": "q4",
+    "title": "Find products by price range",
+    "difficulty": "Beginner",
+    "description": "Show products with prices between 100 and 500, inclusive.",
+    "hint": "Use a BETWEEN clause for the price range.",
+    "expected_sql": "SELECT product_name, price FROM inventory WHERE price BETWEEN 100 AND 500;"
+  },
+  {
+    "id": "q5",
+    "title": "List unique suppliers",
+    "difficulty": "Beginner",
+    "description": "Retrieve all unique suppliers from the restocks table.",
+    "hint": "Use DISTINCT to avoid duplicate suppliers.",
+    "expected_sql": "SELECT DISTINCT supplier FROM restocks;"
+  },
+  {
+    "id": "q6",
+    "title": "Find restocks in 2023",
+    "difficulty": "Beginner",
+    "description": "Show all restocks that occurred in 2023.",
+    "hint": "Use a WHERE clause with LIKE for restock_date.",
+    "expected_sql": "SELECT restock_id, product_id, restock_date, quantity FROM restocks WHERE restock_date LIKE '2023%';"
+  },
+  {
+    "id": "q7",
+    "title": "List accessories products",
+    "difficulty": "Beginner",
+    "description": "Retrieve product names and stock for all items in the Accessories category.",
+    "hint": "Use a WHERE clause to filter by category.",
+    "expected_sql": "SELECT product_name, stock FROM inventory WHERE category = 'Accessories';"
+  },
+  {
+    "id": "q8",
+    "title": "Find high stock products",
+    "difficulty": "Beginner",
+    "description": "Show products with stock greater than 20.",
+    "hint": "Use a WHERE clause to filter by stock.",
+    "expected_sql": "SELECT product_name, stock FROM inventory WHERE stock > 20;"
+  },
+  {
+    "id": "q9",
+    "title": "List restock quantities",
+    "difficulty": "Beginner",
+    "description": "Show the quantity restocked for each restock event.",
+    "hint": "Select restock_id and quantity from the restocks table.",
+    "expected_sql": "SELECT restock_id, quantity FROM restocks;"
+  },
+  {
+    "id": "q10",
+    "title": "Find products with high reorder level",
+    "difficulty": "Beginner",
+    "description": "Retrieve products with a reorder level greater than 5.",
+    "hint": "Use a WHERE clause to filter by reorder_level.",
+    "expected_sql": "SELECT product_name, reorder_level FROM inventory WHERE reorder_level > 5;"
+  },
+  {
+    "id": "q11",
+    "title": "Total stock per category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total stock for each product category.",
+    "hint": "Use GROUP BY on category and SUM on stock.",
+    "expected_sql": "SELECT category, SUM(stock) AS total_stock FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q12",
+    "title": "Average price per category",
+    "difficulty": "Intermediate",
+    "description": "Calculate the average price of products in each category.",
+    "hint": "Use GROUP BY on category and AVG on price.",
+    "expected_sql": "SELECT category, AVG(price) AS avg_price FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q13",
+    "title": "Count restocks per supplier",
+    "difficulty": "Intermediate",
+    "description": "Show the number of restock events for each supplier.",
+    "hint": "Use GROUP BY on supplier and COUNT.",
+    "expected_sql": "SELECT supplier, COUNT(restock_id) AS restock_count FROM restocks GROUP BY supplier;"
+  },
+  {
+    "id": "q14",
+    "title": "Total restock quantity per product",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total quantity restocked for each product.",
+    "hint": "Join inventory and restocks, then GROUP BY product_name.",
+    "expected_sql": "SELECT i.product_name, SUM(r.quantity) AS total_restocked FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q15",
+    "title": "Products with multiple restocks",
+    "difficulty": "Intermediate",
+    "description": "List products that have been restocked more than once.",
+    "hint": "Use GROUP BY on product_name and HAVING clause.",
+    "expected_sql": "SELECT i.product_name, COUNT(r.restock_id) AS restock_count FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name HAVING COUNT(r.restock_id) > 1;"
+  },
+  {
+    "id": "q16",
+    "title": "Total inventory value",
+    "difficulty": "Intermediate",
+    "description": "Calculate the total value of inventory (price * stock) for each category.",
+    "hint": "Use GROUP BY on category and SUM on price * stock.",
+    "expected_sql": "SELECT category, SUM(price * stock) AS total_value FROM inventory GROUP BY category;"
+  },
+  {
+    "id": "q17",
+    "title": "Restock details with product names",
+    "difficulty": "Intermediate",
+    "description": "Show restock details including product names, quantities, and suppliers.",
+    "hint": "Join inventory and restocks tables.",
+    "expected_sql": "SELECT r.restock_id, i.product_name, r.restock_date, r.quantity, r.supplier FROM inventory i JOIN restocks r ON i.product_id = r.product_id;"
+  },
+  {
+    "id": "q18",
+    "title": "Products needing restock",
+    "difficulty": "Intermediate",
+    "description": "List products with stock at or below their reorder level, ordered by stock ascending.",
+    "hint": "Use WHERE and ORDER BY clauses.",
+    "expected_sql": "SELECT product_name, stock, reorder_level FROM inventory WHERE stock <= reorder_level ORDER BY stock ASC;"
+  },
+  {
+    "id": "q19",
+    "title": "Suppliers with large restocks",
+    "difficulty": "Intermediate",
+    "description": "Find suppliers who have restocked quantities greater than 20 in a single restock event.",
+    "hint": "Use WHERE clause on quantity and select DISTINCT supplier.",
+    "expected_sql": "SELECT DISTINCT supplier FROM restocks WHERE quantity > 20;"
+  },
+  {
+    "id": "q20",
+    "title": "Restock frequency by product",
+    "difficulty": "Intermediate",
+    "description": "Show the number of restock events for each product, including those with zero restocks.",
+    "hint": "Use a LEFT JOIN and GROUP BY product_name.",
+    "expected_sql": "SELECT i.product_name, COUNT(r.restock_id) AS restock_count FROM inventory i LEFT JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q21",
+    "title": "Most expensive restocked product",
+    "difficulty": "Advanced",
+    "description": "Find the product with the highest price that has been restocked.",
+    "hint": "Join inventory and restocks, use ORDER BY and LIMIT.",
+    "expected_sql": "SELECT i.product_name, i.price FROM inventory i JOIN restocks r ON i.product_id = r.product_id ORDER BY i.price DESC LIMIT 1;"
+  },
+  {
+    "id": "q22",
+    "title": "Total restock value per supplier",
+    "difficulty": "Advanced",
+    "description": "Calculate the total value of restocks (price * quantity) for each supplier.",
+    "hint": "Join tables, multiply price by quantity, and GROUP BY supplier.",
+    "expected_sql": "SELECT r.supplier, SUM(i.price * r.quantity) AS total_restock_value FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY r.supplier;"
+  },
+  {
+    "id": "q23",
+    "title": "Latest restock per product",
+    "difficulty": "Advanced",
+    "description": "Show the most recent restock date for each product that has been restocked.",
+    "hint": "Use GROUP BY on product_name and MAX on restock_date.",
+    "expected_sql": "SELECT i.product_name, MAX(r.restock_date) AS latest_restock FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name;"
+  },
+  {
+    "id": "q24",
+    "title": "Suppliers restocking all electronics",
+    "difficulty": "Advanced",
+    "description": "List suppliers who have restocked every product in the Electronics category.",
+    "hint": "Count distinct Electronics products per supplier and compare with total Electronics products.",
+    "expected_sql": "SELECT r.supplier FROM restocks r JOIN inventory i ON r.product_id = i.product_id WHERE i.category = 'Electronics' GROUP BY r.supplier HAVING COUNT(DISTINCT r.product_id) = (SELECT COUNT(*) FROM inventory WHERE category = 'Electronics');"
+  },
+  {
+    "id": "q25",
+    "title": "Restock trend by month",
+    "difficulty": "Advanced",
+    "description": "Show the total quantity restocked per month in 2023.",
+    "hint": "Use STRFTIME to extract the month and GROUP BY.",
+    "expected_sql": "SELECT STRFTIME('%Y-%m', restock_date) AS month, SUM(quantity) AS total_quantity FROM restocks WHERE restock_date LIKE '2023%' GROUP BY month;"
+  },
+  {
+    "id": "q26",
+    "title": "Products with high restock value",
+    "difficulty": "Advanced",
+    "description": "Find products where the total restock value (price * quantity) exceeds 5000.",
+    "hint": "Join tables, calculate value, and use HAVING clause.",
+    "expected_sql": "SELECT i.product_name, SUM(i.price * r.quantity) AS total_restock_value FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name HAVING SUM(i.price * r.quantity) > 5000;"
+  },
+  {
+    "id": "q27",
+    "title": "Supplier product diversity",
+    "difficulty": "Advanced",
+    "description": "Count the number of unique products each supplier has restocked.",
+    "hint": "Use COUNT and DISTINCT on product_id, GROUP BY supplier.",
+    "expected_sql": "SELECT r.supplier, COUNT(DISTINCT r.product_id) AS unique_products FROM restocks r GROUP BY r.supplier;"
+  },
+  {
+    "id": "q28",
+    "title": "Overstocked products",
+    "difficulty": "Advanced",
+    "description": "Identify products where the total restocked quantity exceeds the current stock by more than 20.",
+    "hint": "Join tables, compare SUM(quantity) with stock, and use HAVING.",
+    "expected_sql": "SELECT i.product_name, i.stock, SUM(r.quantity) AS total_restocked FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.product_name, i.stock HAVING SUM(r.quantity) > i.stock + 20;"
+  },
+  {
+    "id": "q29",
+    "title": "Restock value by category",
+    "difficulty": "Advanced",
+    "description": "Calculate the total restock value (price * quantity) for each product category.",
+    "hint": "Join tables, multiply price by quantity, and GROUP BY category.",
+    "expected_sql": "SELECT i.category, SUM(i.price * r.quantity) AS total_restock_value FROM inventory i JOIN restocks r ON i.product_id = r.product_id GROUP BY i.category;"
+  },
+  {
+    "id": "q30",
+    "title": "Earliest and latest restock per supplier",
+    "difficulty": "Advanced",
+    "description": "Show the earliest and latest restock dates for each supplier.",
+    "hint": "Use MIN and MAX on restock_date, GROUP BY supplier.",
+    "expected_sql": "SELECT supplier, MIN(restock_date) AS earliest_restock, MAX(restock_date) AS latest_restock FROM restocks GROUP BY supplier;"
+  }
+]

app/schemas.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+class RunQueryRequest(BaseModel):
+    query: str
+
+class ValidateQueryRequest(BaseModel):
+    user_query: str
+    expected_query: str

app/schemas/banking.sql

@@ -0,0 +1,34 @@
+-- Customers table
+CREATE TABLE customers (
+    customer_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    age INTEGER,
+    city TEXT,
+    email TEXT
+);
+
+-- Accounts table
+CREATE TABLE accounts (
+    account_id INTEGER PRIMARY KEY,
+    customer_id INTEGER,
+    account_type TEXT CHECK(account_type IN ('Savings', 'Current', 'Loan')),
+    balance REAL,
+    opened_on DATE,
+    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
+);
+
+-- Sample data: customers
+INSERT INTO customers (customer_id, name, age, city, email) VALUES (1, 'John Doe', 30, 'New York', 'john.doe@example.com');
+INSERT INTO customers (customer_id, name, age, city, email) VALUES (2, 'Jane Smith', 25, 'Los Angeles', 'jane.smith@example.com');
+INSERT INTO customers (customer_id, name, age, city, email) VALUES (3, 'Michael Johnson', 45, 'Chicago', 'michael.j@example.com');
+INSERT INTO customers (customer_id, name, age, city, email) VALUES (4, 'Emily Davis', 28, 'Houston', 'emily.davis@example.com');
+INSERT INTO customers (customer_id, name, age, city, email) VALUES (5, 'David Wilson', 35, 'Phoenix', 'david.w@example.com');
+
+-- Sample data: accounts
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (1, 1, 'Savings', 1000.50, '2023-01-15');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (2, 2, 'Savings', 500.75, '2022-11-20');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (3, 3, 'Current', 2500.00, '2023-03-10');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (4, 4, 'Loan', -10000.00, '2021-06-01');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (5, 5, 'Savings', 350.00, '2024-04-25');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (6, 1, 'Loan', -5000.00, '2022-05-10');
+INSERT INTO accounts (account_id, customer_id, account_type, balance, opened_on) VALUES (7, 2, 'Current', 700.00, '2023-08-12');

app/schemas/college.sql

@@ -0,0 +1,52 @@
+-- Students table
+CREATE TABLE students (
+    student_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    department TEXT,
+    year INTEGER,
+    email TEXT
+);
+
+-- Courses table
+CREATE TABLE courses (
+    course_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    department TEXT,
+    credits INTEGER,
+    instructor TEXT
+);
+
+-- Enrollments table
+CREATE TABLE enrollments (
+    enrollment_id INTEGER PRIMARY KEY,
+    student_id INTEGER,
+    course_id INTEGER,
+    semester TEXT,
+    grade TEXT,
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+
+
+INSERT INTO students (student_id, name, department, year, email) VALUES
+(1, 'Rahul Sharma', 'CSE', 2, 'rahul.s@univ.edu'),
+(2, 'Anjali Mehta', 'ECE', 3, 'anjali.m@univ.edu'),
+(3, 'Soham Verma', 'ME', 2, 'soham.v@univ.edu'),
+(4, 'Pooja Singh', 'CSE', 1, 'pooja.s@univ.edu'),
+(5, 'Karan Patel', 'EEE', 4, 'karan.p@univ.edu');
+
+INSERT INTO courses (course_id, name, department, credits, instructor) VALUES
+(101, 'Data Structures', 'CSE', 4, 'Dr. Anil Kapoor'),
+(102, 'Digital Electronics', 'ECE', 3, 'Dr. Priya Nair'),
+(103, 'Thermodynamics', 'ME', 4, 'Dr. Ramesh Rao'),
+(104, 'Operating Systems', 'CSE', 4, 'Dr. Neha Malhotra'),
+(105, 'Power Systems', 'EEE', 3, 'Dr. Amit Kumar');
+
+INSERT INTO enrollments (enrollment_id, student_id, course_id, semester, grade) VALUES
+(1, 1, 101, 'Spring 2023', 'A'),
+(2, 1, 104, 'Spring 2023', 'B+'),
+(3, 2, 102, 'Spring 2023', 'A-'),
+(4, 3, 103, 'Spring 2023', 'B'),
+(5, 4, 101, 'Spring 2023', 'A'),
+(6, 4, 104, 'Spring 2023', 'A-'),
+(7, 5, 105, 'Spring 2023', 'B+');

app/schemas/e_commerce.sql

@@ -0,0 +1,44 @@
+-- Sales Table
+CREATE TABLE sales (
+    id INTEGER PRIMARY KEY,
+    product_name TEXT NOT NULL,
+    category TEXT,
+    sale_amount REAL NOT NULL,
+    sale_date DATE
+);
+
+-- Orders Table
+CREATE TABLE orders (
+    order_id INTEGER PRIMARY KEY,
+    customer_id INTEGER,
+    product_id INTEGER,
+    quantity INTEGER DEFAULT 1,
+    order_date DATE,
+    FOREIGN KEY (product_id) REFERENCES sales(id)
+);
+
+
+INSERT INTO sales (id, product_name, category, sale_amount, sale_date) VALUES
+(1, 'Laptop', 'Electronics', 1200.0, '2023-01-01'),
+(2, 'Phone', 'Electronics', 800.0, '2023-01-02'),
+(3, 'Laptop', 'Electronics', 1500.0, '2023-01-03'),
+(4, 'Tablet', 'Electronics', 600.0, '2023-01-04'),
+(5, 'Phone', 'Electronics', 900.0, '2023-01-05'),
+(6, 'Monitor', 'Accessories', 400.0, '2023-01-06'),
+(7, 'Keyboard', 'Accessories', 100.0, '2023-01-07'),
+(8, 'Mouse', 'Accessories', 50.0, '2023-01-08'),
+(9, 'Charger', 'Accessories', 70.0, '2023-01-09'),
+(10, 'Headphones', 'Accessories', 200.0, '2023-01-10');
+
+
+INSERT INTO orders (order_id, customer_id, product_id, quantity, order_date) VALUES
+(1, 2001, 1, 1, '2023-01-01'),
+(2, 2002, 2, 2, '2023-01-02'),
+(3, 2001, 3, 1, '2023-01-03'),
+(4, 2003, 4, 1, '2023-01-04'),
+(5, 2001, 5, 1, '2023-01-05'),
+(6, 2004, 6, 1, '2023-01-06'),
+(7, 2002, 7, 3, '2023-01-07'),
+(8, 2003, 8, 2, '2023-01-08'),
+(9, 2005, 9, 1, '2023-01-09'),
+(10, 2004, 10, 1, '2023-01-10');

app/schemas/hospital.sql

@@ -0,0 +1,50 @@
+-- Patients Table
+CREATE TABLE patients (
+    patient_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    gender TEXT CHECK (gender IN ('Male', 'Female', 'Other')),
+    dob DATE,
+    contact TEXT
+);
+
+-- Doctors Table
+CREATE TABLE doctors (
+    doctor_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    specialty TEXT,
+    contact TEXT
+);
+
+-- Appointments Table
+CREATE TABLE appointments (
+    appointment_id INTEGER PRIMARY KEY,
+    patient_id INTEGER,
+    doctor_id INTEGER,
+    appointment_date DATE,
+    diagnosis TEXT,
+    FOREIGN KEY (patient_id) REFERENCES patients(patient_id),
+    FOREIGN KEY (doctor_id) REFERENCES doctors(doctor_id)
+);
+
+
+INSERT INTO patients VALUES 
+(1, 'Aarushi Verma', 'Female', '1995-08-20', '9999888877'),
+(2, 'Rohan Mehra', 'Male', '1990-03-15', '9999123456'),
+(3, 'Simran Kaur', 'Female', '1985-11-05', '8888445566'),
+(4, 'Arjun Kapoor', 'Male', '2000-01-25', '7777333222'),
+(5, 'Priya Das', 'Female', '1998-07-14', '9999000011');
+
+INSERT INTO doctors VALUES 
+(1, 'Dr. Rakesh Sharma', 'Cardiologist', '8888777766'),
+(2, 'Dr. Meena Iyer', 'Dermatologist', '8888123456'),
+(3, 'Dr. Alok Mishra', 'Neurologist', '7777888899'),
+(4, 'Dr. Nandini Rao', 'Pediatrician', '9999333311');
+
+INSERT INTO appointments VALUES 
+(1, 1, 1, '2023-06-20', 'Routine Checkup'),
+(2, 2, 2, '2023-06-25', 'Skin Rash'),
+(3, 3, 1, '2023-07-02', 'Chest Pain'),
+(4, 4, 3, '2023-07-10', 'Headache & Dizziness'),
+(5, 5, 4, '2023-07-15', 'Child Vaccination'),
+(6, 1, 3, '2023-08-01', 'Memory Loss'),
+(7, 2, 1, '2023-08-05', 'High Blood Pressure');

app/schemas/inventory.sql

@@ -0,0 +1,46 @@
+-- Inventory Table
+CREATE TABLE inventory (
+    product_id INTEGER PRIMARY KEY,
+    product_name TEXT NOT NULL,
+    category TEXT NOT NULL,
+    price REAL NOT NULL,
+    stock INTEGER NOT NULL CHECK (stock >= 0)
+);
+
+-- Restocks Table
+CREATE TABLE restocks (
+    restock_id INTEGER PRIMARY KEY,
+    product_id INTEGER,
+    restock_date DATE NOT NULL,
+    quantity INTEGER NOT NULL CHECK (quantity > 0),
+    supplier TEXT,
+    FOREIGN KEY (product_id) REFERENCES inventory(product_id)
+);
+
+
+INSERT INTO inventory (product_id, product_name, category, price, stock) VALUES
+(1, 'Laptop', 'Electronics', 1200.00, 10),
+(2, 'Smartphone', 'Electronics', 800.00, 15),
+(3, 'Printer', 'Peripherals', 300.00, 5),
+(4, 'Desk Chair', 'Furniture', 150.00, 20),
+(5, 'Monitor', 'Peripherals', 400.00, 8),
+(6, 'Mouse', 'Accessories', 40.00, 50),
+(7, 'Keyboard', 'Accessories', 60.00, 30),
+(8, 'Router', 'Networking', 90.00, 12),
+(9, 'External HDD', 'Storage', 110.00, 7),
+(10, 'USB-C Hub', 'Accessories', 25.00, 40);
+
+INSERT INTO restocks (restock_id, product_id, restock_date, quantity, supplier) VALUES
+(1, 1, '2023-01-01', 5, 'TechSupplier Inc.'),
+(2, 2, '2023-01-05', 10, 'MobileMart Ltd.'),
+(3, 3, '2023-01-10', 3, 'PrintPerfect'),
+(4, 4, '2023-01-12', 15, 'OfficeFurnish Co.'),
+(5, 5, '2023-01-15', 6, 'PeripheralWorks'),
+(6, 6, '2023-01-17', 25, 'AccsGlobal'),
+(7, 7, '2023-01-18', 10, 'AccsGlobal'),
+(8, 8, '2023-01-20', 8, 'NetConnect'),
+(9, 9, '2023-01-21', 5, 'StorageHouse'),
+(10, 10, '2023-01-22', 20, 'TechSupplier Inc.'),
+(11, 1, '2023-02-01', 3, 'TechSupplier Inc.'),
+(12, 2, '2023-02-03', 7, 'MobileMart Ltd.');
+

app/schemas/library.sql

@@ -0,0 +1,55 @@
+-- Books table
+CREATE TABLE books (
+    book_id INTEGER PRIMARY KEY,
+    title TEXT NOT NULL,
+    author TEXT NOT NULL,
+    genre TEXT,
+    year INTEGER,
+    available_copies INTEGER DEFAULT 1
+);
+
+-- Users table (added for more realistic modeling)
+CREATE TABLE users (
+    user_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    email TEXT,
+    membership_date DATE
+);
+
+-- Loans table
+CREATE TABLE loans (
+    loan_id INTEGER PRIMARY KEY,
+    book_id INTEGER,
+    user_id INTEGER,
+    issue_date DATE,
+    due_date DATE,
+    return_date DATE,
+    FOREIGN KEY (book_id) REFERENCES books(book_id),
+    FOREIGN KEY (user_id) REFERENCES users(user_id)
+);
+
+INSERT INTO books (book_id, title, author, genre, year, available_copies) VALUES
+(1, 'The Great Gatsby', 'F. Scott Fitzgerald', 'Fiction', 1925, 2),
+(2, '1984', 'George Orwell', 'Dystopian', 1949, 3),
+(3, 'Dune', 'Frank Herbert', 'Science Fiction', 1965, 4),
+(4, 'Project Hail Mary', 'Andy Weir', 'Science Fiction', 2021, 1),
+(5, 'Klara and the Sun', 'Kazuo Ishiguro', 'Science Fiction', 2021, 2),
+(6, 'The Martian', 'Andy Weir', 'Science Fiction', 2011, 2),
+(7, 'Animal Farm', 'George Orwell', 'Political Satire', 1945, 3);
+
+
+INSERT INTO users (user_id, name, email, membership_date) VALUES
+(101, 'Alice Johnson', 'alice.j@example.com', '2020-06-15'),
+(102, 'Bob Smith', 'bob.smith@example.com', '2019-08-22'),
+(103, 'Charlie Rose', 'charlie.r@example.com', '2021-01-10'),
+(104, 'Diana Prince', 'diana.p@example.com', '2022-05-04'),
+(105, 'Ethan Hunt', 'ethan.h@example.com', '2023-02-01');
+
+
+INSERT INTO loans (loan_id, book_id, user_id, issue_date, due_date, return_date) VALUES
+(1, 1, 101, '2022-11-30', '2022-12-15', '2022-12-12'),
+(2, 2, 102, '2022-12-20', '2023-01-10', NULL),
+(3, 3, 103, '2022-11-01', '2022-11-30', '2022-11-28'),
+(4, 4, 104, '2023-01-10', '2023-02-01', NULL),
+(5, 5, 105, '2023-02-10', '2023-03-01', NULL),
+(6, 2, 101, '2023-01-15', '2023-02-05', '2023-02-04');

app/schemas/restaurant.sql

@@ -0,0 +1,65 @@
+-- Menu Items Table
+CREATE TABLE menu_items (
+    item_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    category TEXT,
+    price REAL NOT NULL
+);
+
+-- Customers Table
+CREATE TABLE customers (
+    customer_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    contact TEXT,
+    email TEXT
+);
+
+-- Orders Table
+CREATE TABLE orders (
+    order_id INTEGER PRIMARY KEY,
+    customer_id INTEGER,
+    order_date DATE,
+    total_amount REAL,
+    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
+);
+
+-- Order Items Table
+CREATE TABLE order_items (
+    order_item_id INTEGER PRIMARY KEY,
+    order_id INTEGER,
+    item_id INTEGER,
+    quantity INTEGER,
+    FOREIGN KEY (order_id) REFERENCES orders(order_id),
+    FOREIGN KEY (item_id) REFERENCES menu_items(item_id)
+);
+
+
+INSERT INTO menu_items VALUES 
+(1, 'Margherita Pizza', 'Main Course', 250.0),
+(2, 'Paneer Tikka', 'Appetizer', 180.0),
+(3, 'Chocolate Brownie', 'Dessert', 120.0),
+(4, 'Cold Coffee', 'Beverage', 90.0),
+(5, 'Veg Burger', 'Main Course', 150.0),
+(6, 'French Fries', 'Appetizer', 100.0),
+(7, 'Lemonade', 'Beverage', 60.0);
+
+INSERT INTO customers VALUES 
+(1, 'Aman Gupta', '9876543210', 'aman.g@example.com'),
+(2, 'Neha Sharma', '9876501234', 'neha.s@example.com'),
+(3, 'Rohit Mehra', '9876567890', 'rohit.m@example.com');
+
+INSERT INTO orders VALUES 
+(1, 1, '2023-06-10', 500.0),
+(2, 2, '2023-06-11', 360.0),
+(3, 1, '2023-06-15', 420.0),
+(4, 3, '2023-06-17', 270.0);
+
+INSERT INTO order_items VALUES 
+(1, 1, 1, 2),   -- 2 Margherita Pizzas
+(2, 2, 2, 1),   -- 1 Paneer Tikka
+(3, 2, 4, 2),   -- 2 Cold Coffees
+(4, 3, 5, 1),   -- 1 Veg Burger
+(5, 3, 3, 2),   -- 2 Brownies
+(6, 3, 4, 1),   -- 1 Cold Coffee
+(7, 4, 6, 2),   -- 2 French Fries
+(8, 4, 7, 1);   -- 1 Lemonade

app/schemas/retail.sql

@@ -0,0 +1,42 @@
+-- Product inventory table
+CREATE TABLE inventory (
+    product_id INTEGER PRIMARY KEY,
+    product_name TEXT NOT NULL,
+    category TEXT,
+    price REAL NOT NULL,
+    stock INTEGER NOT NULL,
+    reorder_level INTEGER DEFAULT 5
+);
+
+-- Restocks table
+CREATE TABLE restocks (
+    restock_id INTEGER PRIMARY KEY,
+    product_id INTEGER,
+    restock_date DATE,
+    quantity INTEGER NOT NULL,
+    supplier TEXT,
+    FOREIGN KEY (product_id) REFERENCES inventory(product_id)
+);
+
+INSERT INTO inventory (product_id, product_name, category, price, stock, reorder_level) VALUES
+(1, 'Laptop', 'Electronics', 1200.0, 5, 3),
+(2, 'Phone', 'Electronics', 800.0, 20, 10),
+(3, 'Tablet', 'Electronics', 600.0, 8, 5),
+(4, 'Monitor', 'Accessories', 300.0, 15, 7),
+(5, 'Keyboard', 'Accessories', 100.0, 30, 10),
+(6, 'Mouse', 'Accessories', 50.0, 50, 20),
+(7, 'Headphones', 'Accessories', 150.0, 25, 10),
+(8, 'Webcam', 'Accessories', 250.0, 4, 5),
+(9, 'Charger', 'Electronics', 60.0, 12, 8);
+
+INSERT INTO restocks (restock_id, product_id, restock_date, quantity, supplier) VALUES
+(1, 1, '2023-01-01', 10, 'TechWorld Supplies'),
+(2, 2, '2023-01-02', 20, 'GadgetMart Inc.'),
+(3, 3, '2022-12-15', 15, 'ElectroParts Ltd.'),
+(4, 4, '2023-01-03', 30, 'DisplayX Pvt. Ltd.'),
+(5, 5, '2023-01-10', 40, 'KeyTech Solutions'),
+(6, 6, '2023-01-20', 50, 'Mousey Traders'),
+(7, 7, '2023-02-01', 25, 'AudioGear Distributors'),
+(8, 1, '2023-03-01', 5, 'TechWorld Supplies'),
+(9, 8, '2023-03-15', 10, 'VisionTech Systems'),
+(10, 9, '2023-04-01', 12, 'ElectroParts Ltd.');

app/static/index.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SQL Practice Platform</title>
+    <link rel="icon" href="/static/favicon.png" type="image/x-icon" />
+    <script src="https://cdn.tailwindcss.com/3.3.3"></script>
+    <script
+      src="/static/ace.js"
+      id="ace-script"
+      onerror="this.nextElementSibling.src='https://cdnjs.cloudflare.com/ajax/libs/ace-builds/1.35.0/ace.js';"
+    ></script>
+    <script src="" id="ace-fallback"></script>
+    <link href="/static/style.css" rel="stylesheet" />
+    <style>
+      #schemaInfo {
+        max-height: calc(100vh - 200px);
+        overflow-y: auto;
+      }
+    </style>
+  </head>
+  <body class="bg-gray-100 min-h-screen">
+    <div class="max-w-full mx-auto p-4">
+      <h1 class="text-3xl font-bold mb-6 text-center text-blue-600">
+        SQL Practice Platform
+      </h1>
+      <div class="grid grid-cols-1 md:grid-cols-3 gap-4 h-[calc(100vh-100px)]">
+        <div class="bg-white p-4 rounded-lg shadow-md">
+          <h2 class="text-xl font-semibold mb-4 text-green-600">Database</h2>
+          <select
+            id="domainSelect"
+            class="w-full p-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 mb-4"
+          >
+            <option value="">Select Database</option>
+          </select>
+          <button
+            id="loadSchemaBtn"
+            class="w-full bg-blue-600 text-white p-2 rounded-md hover:bg-blue-700 disabled:bg-gray-400 mb-4"
+            disabled
+          >
+            Loading...
+          </button>
+          <button
+            id="showSchemaBtn"
+            class="w-full bg-gray-500 text-white p-2 rounded-md hover:bg-gray-600 mb-4 hidden"
+          >
+            Show Schema
+          </button>
+          <button
+            id="showTableBtn"
+            class="w-full bg-gray-500 text-white p-2 rounded-md hover:bg-gray-600 mb-4 hidden"
+          >
+            Show Table
+          </button>
+          <div
+            id="schemaInfo"
+            class="text-sm overflow-auto max-h-60 hidden"
+          ></div>
+        </div>
+        <div class="bg-white p-4 rounded-lg shadow-md flex flex-col">
+          <h2 class="text-xl font-semibold mb-4 text-purple-600">SQL Editor</h2>
+          <div id="sqlEditor" class="w-full h-48 border rounded-md mb-4"></div>
+          <div class="flex space-x-4 mb-4">
+            <button
+              id="runQueryBtn"
+              class="bg-green-600 text-white p-2 rounded-md hover:bg-green-700 disabled:bg-gray-400"
+            >
+              Run
+            </button>
+          </div>
+          <h2 class="text-xl font-semibold mb-4 text-purple-600">Results</h2>
+          <div id="results" class="text-sm overflow-auto flex-grow"></div>
+          <div id="errorMessage" class="text-red-500 mt-2"></div>
+        </div>
+        <div class="bg-white p-4 rounded-lg shadow-md flex flex-col">
+          <h2 class="text-xl font-semibold mb-4 text-yellow-600">
+            Practice Question
+          </h2>
+          <select
+            id="difficultySelect"
+            class="w-full p-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 mb-4"
+            disabled
+          >
+            <option value="">Select Difficulty</option>
+            <option value="Beginner">Beginner</option>
+            <option value="Intermediate">Intermediate</option>
+            <option value="Advanced">Advanced</option>
+          </select>
+          <div id="questionDetails" class="text-sm mb-4"></div>
+          <div
+            class="flex justify-between mb-4"
+            style="display: none"
+            id="navButtons"
+          >
+            <button
+              id="prevBtn"
+              class="bg-gray-500 text-white p-2 rounded-md hover:bg-gray-600"
+            >
+              <<
+            </button>
+            <button
+              id="nextBtn"
+              class="bg-gray-500 text-white p-2 rounded-md hover:bg-gray-600"
+            >
+              >>
+            </button>
+          </div>
+          <button
+            id="hintBtn"
+            class="w-full bg-gray-500 text-white p-2 rounded-md hover:bg-gray-600 mb-4"
+            style="display: none"
+          >
+            Show Hint
+          </button>
+          <button
+            id="solutionBtn"
+            class="w-full bg-gray-400 text-white p-2 rounded-md hover:bg-gray-500 mb-4"
+            style="display: none"
+          >
+            Show Solution
+          </button>
+        </div>
+      </div>
+    </div>
+    <script src="/static/script.js"></script>
+  </body>
+</html>

app/static/script.js

@@ -0,0 +1,603 @@
+let sessionId,
+  editor,
+  currentQuestions = [],
+  currentQuestionIndex = 0,
+  isSchemaVisible,
+  isTableVisible,
+  isHintVisible,
+  isSolutionVisible;
+
+async function init() {
+  await new Promise((r) =>
+    document.readyState === "complete"
+      ? r()
+      : window.addEventListener("load", r)
+  );
+  const sqlEditor = document.getElementById("sqlEditor");
+  if (!sqlEditor) throw new Error("SQL Editor element not found");
+  await new Promise((r) => setTimeout(r, 100));
+  if (typeof ace === "undefined")
+    throw new Error("Ace Editor library not loaded");
+  editor = ace.edit("sqlEditor");
+  editor.setTheme("ace/theme/monokai");
+  editor.session.setMode("ace/mode/sql");
+  editor.setOptions({ enableBasicAutocompletion: true, fontSize: "12px" });
+  editor.setValue("SELECT * FROM customers;");
+  const response = await fetch("/api/session", { method: "POST" });
+  if (!response.ok) throw new Error("Failed to create session");
+  sessionId = (await response.json()).session_id;
+  const domainResponse = await fetch("/api/databases");
+  if (!domainResponse.ok) throw new Error("Failed to fetch databases");
+  const domains = (await domainResponse.json()).databases;
+  const domainSelect = document.getElementById("domainSelect");
+  domainSelect.innerHTML = '<option value="">Select Database</option>';
+  domains.forEach((domain) => {
+    const option = document.createElement("option");
+    option.value = domain;
+    option.textContent = domain.charAt(0).toUpperCase() + domain.slice(1);
+    domainSelect.appendChild(option);
+  });
+  document
+    .getElementById("loadSchemaBtn")
+    .addEventListener("click", loadDomain);
+  document
+    .getElementById("showSchemaBtn")
+    .addEventListener("click", showSchema);
+  document.getElementById("showTableBtn").addEventListener("click", showTable);
+  document
+    .getElementById("difficultySelect")
+    .addEventListener("change", loadQuestions);
+  document.getElementById("hintBtn").addEventListener("click", toggleHint);
+  document
+    .getElementById("solutionBtn")
+    .addEventListener("click", toggleSolution);
+  document.getElementById("prevBtn").addEventListener("click", prevQuestion);
+  document.getElementById("nextBtn").addEventListener("click", nextQuestion);
+  document.getElementById("runQueryBtn").addEventListener("click", runQuery);
+}
+
+async function loadDomain() {
+  const domain = document.getElementById("domainSelect").value;
+  if (!domain) {
+    showError("Please select a database.");
+    return;
+  }
+  const loadBtn = document.getElementById("loadSchemaBtn");
+  loadBtn.disabled = true;
+  loadBtn.textContent = "Loading...";
+  try {
+    const response = await fetch(`/api/load-schema/${domain}`, {
+      method: "POST",
+      headers: { "session-id": sessionId },
+    });
+    if (!response.ok)
+      throw new Error(
+        (await response.json()).detail || "Failed to load database"
+      );
+    await response.json();
+    document.getElementById("difficultySelect").disabled = false;
+    document.getElementById("showSchemaBtn").classList.remove("hidden");
+    document.getElementById("showTableBtn").classList.remove("hidden");
+    document.getElementById("schemaInfo").classList.add("hidden");
+    document.getElementById("questionDetails").innerHTML = "";
+    document.getElementById("hintBtn").style.display = "block";
+    document.getElementById("solutionBtn").style.display = "block";
+    currentQuestions = [];
+    currentQuestionIndex = 0;
+  } catch (e) {
+    showError(`Failed to load database: ${e.message}.`);
+  } finally {
+    loadBtn.disabled = false;
+    loadBtn.textContent = "Load Database";
+  }
+}
+
+async function showSchema() {
+  const domain = document.getElementById("domainSelect").value;
+  if (!domain) return;
+  const schemaInfo = document.getElementById("schemaInfo");
+  if (isTableVisible) {
+    isTableVisible = false;
+    schemaInfo.classList.add("hidden");
+  }
+  schemaInfo.classList.toggle("hidden");
+  isSchemaVisible = !schemaInfo.classList.contains("hidden");
+  if (isSchemaVisible) {
+    const schemaResponse = await fetch(`/api/schema/${domain}`, {
+      headers: { "session-id": sessionId },
+    });
+    if (!schemaResponse.ok)
+      throw new Error(
+        (await schemaResponse.json()).detail || "Failed to load schema"
+      );
+    const schema = (await schemaResponse.json()).schema;
+    let schemaHtml = '<div class="grid grid-cols-1 md:grid-cols-2 gap-4">';
+    for (const [table, columns] of Object.entries(schema)) {
+      schemaHtml += `<div class="bg-gray-100 p-2 rounded"><h3 class="font-semibold">${table}</h3><ul class="list-disc ml-4">`;
+      columns.forEach(
+        (col) => (schemaHtml += `<li>${col.name} (${col.type})</li>`)
+      );
+      schemaHtml += "</ul></div>";
+    }
+    schemaInfo.innerHTML = schemaHtml;
+  }
+}
+
+async function showTable() {
+  const domain = document.getElementById("domainSelect").value;
+  if (!domain) return;
+  const schemaInfo = document.getElementById("schemaInfo");
+  if (isSchemaVisible) {
+    isSchemaVisible = false;
+    schemaInfo.classList.add("hidden");
+  }
+  schemaInfo.classList.toggle("hidden");
+  isTableVisible = !schemaInfo.classList.contains("hidden");
+  if (isTableVisible) {
+    const sampleResponse = await fetch(`/api/sample-data/${domain}`, {
+      headers: { "session-id": sessionId },
+    });
+    if (!sampleResponse.ok)
+      throw new Error(
+        (await sampleResponse.json()).detail || "Failed to load sample data"
+      );
+    const sampleData = (await sampleResponse.json()).sample_data;
+    let tableHtml = '<div class="grid grid-cols-1 gap-4">';
+    for (const [table, data] of Object.entries(sampleData)) {
+      tableHtml += `<div class="bg-gray-50 p-2 rounded"><h4 class="font-semibold">${table}</h4>`;
+      tableHtml += '<table class="w-full mt-2"><tr>';
+      data.columns.forEach(
+        (col) => (tableHtml += `<th class="border p-1">${col}</th>`)
+      );
+      tableHtml += "</tr>";
+      data.rows.forEach((row) => {
+        tableHtml += "<tr>";
+        data.columns.forEach(
+          (col) =>
+            (tableHtml += `<td class="border p-1">${row[col] || "NULL"}</td>`)
+        );
+        tableHtml += "</tr>";
+      });
+      tableHtml += "</table></div>";
+    }
+    schemaInfo.innerHTML = tableHtml;
+  }
+}
+
+async function loadQuestions() {
+  const domain = document.getElementById("domainSelect").value;
+  const difficulty = document.getElementById("difficultySelect").value;
+  if (!domain) {
+    document.getElementById("difficultySelect").value = "";
+    alert("Please select and load a database first");
+    return;
+  }
+  if (!difficulty) {
+    document.getElementById("questionDetails").innerHTML = "";
+    document.getElementById("hintBtn").style.display = "none";
+    document.getElementById("solutionBtn").style.display = "none";
+    document.getElementById("navButtons").style.display = "none";
+    currentQuestions = [];
+    currentQuestionIndex = 0;
+    return;
+  }
+  const questionResponse = await fetch(
+    `/api/questions/${domain}?difficulty=${difficulty}`
+  );
+  if (!questionResponse.ok)
+    throw new Error(
+      (await questionResponse.json()).detail || "Failed to load questions"
+    );
+  currentQuestions = await questionResponse.json();
+  if (currentQuestions.length > 0) {
+    currentQuestionIndex = 0;
+    updateQuestionDisplay();
+    document.getElementById("hintBtn").style.display = "block";
+    document.getElementById("solutionBtn").style.display = "block";
+    document.getElementById("navButtons").style.display = "flex";
+  } else {
+    document.getElementById("questionDetails").innerHTML =
+      "<p>No questions available for this difficulty.</p>";
+    document.getElementById("hintBtn").style.display = "none";
+    document.getElementById("solutionBtn").style.display = "none";
+    document.getElementById("navButtons").style.display = "none";
+    currentQuestions = [];
+    currentQuestionIndex = 0;
+  }
+}
+
+function updateQuestionDisplay() {
+  const questionDetails = document.getElementById("questionDetails");
+  if (
+    currentQuestions.length &&
+    currentQuestionIndex >= 0 &&
+    currentQuestionIndex < currentQuestions.length
+  ) {
+    const question = currentQuestions[currentQuestionIndex];
+    questionDetails.innerHTML = `<p id="questionText"><strong>Practice Question:</strong> ${
+      question.description || "No question available."
+    }</p>`;
+  } else {
+    questionDetails.innerHTML =
+      '<p id="questionText">No questions available.</p>';
+  }
+}
+
+function prevQuestion() {
+  if (currentQuestions.length && currentQuestionIndex > 0) {
+    currentQuestionIndex--;
+    updateQuestionDisplay();
+    updateHintSolutionDisplay();
+  }
+}
+function nextQuestion() {
+  if (
+    currentQuestions.length &&
+    currentQuestionIndex < currentQuestions.length - 1
+  ) {
+    currentQuestionIndex++;
+    updateQuestionDisplay();
+    updateHintSolutionDisplay();
+  }
+}
+
+function updateHintSolutionDisplay() {
+  if (isHintVisible) toggleHint();
+  if (isSolutionVisible) toggleSolution();
+}
+
+function toggleHint() {
+  const question = currentQuestions[currentQuestionIndex];
+  const hintBtn = document.getElementById("hintBtn");
+  const questionDetails = document.getElementById("questionDetails");
+  if (isSolutionVisible) toggleSolution();
+  if (question && question.hint) {
+    if (hintBtn.textContent === "Show Hint") {
+      questionDetails.innerHTML += `<p><strong>Hint:</strong> ${question.hint}</p>`;
+      hintBtn.textContent = "Hide Hint";
+      isHintVisible = true;
+    } else {
+      questionDetails.innerHTML = questionDetails.innerHTML.replace(
+        `<p><strong>Hint:</strong> ${question.hint}</p>`,
+        ""
+      );
+      hintBtn.textContent = "Show Hint";
+      isHintVisible = false;
+    }
+  } else {
+    if (hintBtn.textContent === "Show Hint") {
+      questionDetails.innerHTML +=
+        '<p class="text-black">No hint available.</p>';
+      hintBtn.textContent = "Hide Hint";
+      isHintVisible = true;
+    } else {
+      questionDetails.innerHTML = questionDetails.innerHTML.replace(
+        '<p class="text-black">No hint available.</p>',
+        ""
+      );
+      hintBtn.textContent = "Show Hint";
+      isHintVisible = false;
+    }
+  }
+}
+
+function toggleSolution() {
+  const question = currentQuestions[currentQuestionIndex];
+  const solutionBtn = document.getElementById("solutionBtn");
+  const questionDetails = document.getElementById("questionDetails");
+  if (isHintVisible) toggleHint();
+  if (question && question.expected_sql) {
+    if (solutionBtn.textContent === "Show Solution") {
+      questionDetails.innerHTML += `<p><strong>Solution:</strong> <code>${question.expected_sql}</code></p>`;
+      solutionBtn.textContent = "Hide Solution";
+      isSolutionVisible = true;
+    } else {
+      questionDetails.innerHTML = questionDetails.innerHTML.replace(
+        `<p><strong>Solution:</strong> <code>${question.expected_sql}</code></p>`,
+        ""
+      );
+      solutionBtn.textContent = "Show Solution";
+      isSolutionVisible = false;
+    }
+  } else {
+    if (solutionBtn.textContent === "Show Solution") {
+      questionDetails.innerHTML +=
+        '<p class="text-black">No solution available.</p>';
+      solutionBtn.textContent = "Hide Solution";
+      isSolutionVisible = true;
+    } else {
+      questionDetails.innerHTML = questionDetails.innerHTML.replace(
+        '<p class="text-black">No solution available.</p>',
+        ""
+      );
+      solutionBtn.textContent = "Show Solution";
+      isSolutionVisible = false;
+    }
+  }
+}
+
+async function runQuery() {
+  const runBtn = document.getElementById("runQueryBtn");
+  const resultsDiv = document.getElementById("results");
+  let resultMessage =
+    document.getElementById("resultMessage") || document.createElement("span");
+  if (!resultMessage.id) {
+    resultMessage.id = "resultMessage";
+    runBtn.parentNode.appendChild(resultMessage);
+  }
+  runBtn.disabled = true;
+  runBtn.textContent = "Running...";
+  resultMessage.textContent = "";
+  try {
+    if (!editor) throw new Error("Editor not initialized. Refresh the page.");
+    let query = editor.getValue().trim().toLowerCase();
+    if (!query) throw new Error("Please enter a query.");
+    const domain = document.getElementById("domainSelect").value;
+    if (!domain) throw new Error("Please load a database first.");
+    const schemaResponse = await fetch(`/api/schema/${domain}`, {
+      headers: { "session-id": sessionId },
+    });
+    if (!schemaResponse.ok)
+      throw new Error("Failed to load schema for table validation");
+    const schema = (await schemaResponse.json()).schema;
+    const validTables = Object.keys(schema).map((t) => t.toLowerCase());
+    const tableNames = extractTableNames(query);
+    if (tableNames.some((table) => !validTables.includes(table)))
+      throw new Error(
+        `Invalid table name. Use only: ${validTables.join(", ")}`
+      );
+    const response = await fetch("/api/run-query", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "session-id": sessionId },
+      body: JSON.stringify({ query }),
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(errorText || "Server error occurred.");
+    }
+    const result = await response.json();
+    if (result.columns) {
+      let html = `<table class="w-full border-collapse"><tr>${result.columns
+        .map((col) => `<th class="border p-2">${col}</th>`)
+        .join("")}</tr>`;
+      html += result.rows
+        .map(
+          (row) =>
+            `<tr>${result.columns
+              .map((col) => `<td class="border p-2">${row[col] || "NULL"}</td>`)
+              .join("")}</tr>`
+        )
+        .join("");
+      html += "</table>";
+      resultsDiv.innerHTML = html;
+    } else {
+      resultsDiv.innerHTML = "<p>No results</p>";
+    }
+    if (
+      currentQuestions.length &&
+      currentQuestionIndex >= 0 &&
+      currentQuestionIndex < currentQuestions.length
+    )
+      await validateQuery(query, result, resultsDiv);
+    else {
+      resultMessage.textContent = "Select a question first";
+      resultMessage.className = "text-red-500 ml-4";
+    }
+  } catch (e) {
+    resultsDiv.innerHTML = "";
+    resultMessage.textContent = e.message.includes("Internal Server Error")
+      ? "Server error: Please check the query or try again later."
+      : e.message;
+    resultMessage.className = "text-red-500 ml-4";
+  } finally {
+    runBtn.disabled = false;
+    runBtn.textContent = "Run";
+  }
+}
+
+function extractTableNames(query) {
+  const tables = new Set();
+  const tokens = query.replace(/(\s+)/g, " ").split(" ");
+  let inSubquery = false,
+    inOpenQuery = false,
+    inValues = false;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i].toLowerCase();
+    if (token === "(" && !inSubquery && !inValues) {
+      if (i > 0 && tokens[i - 1].toLowerCase() === "values") inValues = true;
+      else inSubquery = true;
+    }
+    if (token === ")" && (inSubquery || inValues)) {
+      if (
+        inValues &&
+        i + 1 < tokens.length &&
+        tokens[i + 1].toLowerCase() === "as"
+      )
+        inValues = false;
+      else if (inSubquery) inSubquery = false;
+    }
+    if (token === "openquery" && i + 1 < tokens.length && tokens[i + 1] === "(")
+      inOpenQuery = true;
+    if (token === ")" && inOpenQuery) inOpenQuery = false;
+    if (inOpenQuery) continue;
+
+    if (
+      [
+        "from",
+        "join",
+        "update",
+        "delete",
+        "insert",
+        "into",
+        "using",
+        "apply",
+        "pivot",
+        "table",
+      ].includes(token)
+    ) {
+      let nextToken = tokens[i + 1]
+        ? tokens[i + 1].replace(/[,;)]/g, "").toLowerCase()
+        : "";
+      if (
+        nextToken &&
+        ![
+          "select",
+          "where",
+          "on",
+          "order",
+          "group",
+          "having",
+          "as",
+          "(",
+        ].includes(nextToken)
+      ) {
+        if (i + 2 < tokens.length && tokens[i + 2].toLowerCase() === "as")
+          nextToken = nextToken;
+        else if (
+          !["left", "right", "inner", "outer", "cross", "full"].includes(
+            nextToken
+          )
+        )
+          tables.add(nextToken);
+      }
+      i++;
+    } else if (
+      token === "merge" &&
+      i + 1 < tokens.length &&
+      tokens[i + 1].toLowerCase() === "into"
+    ) {
+      let nextToken = tokens[i + 2]
+        ? tokens[i + 2].replace(/[,;)]/g, "").toLowerCase()
+        : "";
+      if (nextToken && !["using", "select", "where"].includes(nextToken))
+        tables.add(nextToken);
+      i += 2;
+      while (i + 1 < tokens.length && tokens[i + 1].toLowerCase() !== "using")
+        i++;
+      if (i + 2 < tokens.length) {
+        nextToken = tokens[i + 2].replace(/[,;)]/g, "").toLowerCase();
+        if (nextToken && !["select", "where"].includes(nextToken))
+          tables.add(nextToken);
+      }
+    } else if (
+      token === "select" &&
+      i + 1 < tokens.length &&
+      tokens[i + 1].toLowerCase() === "into"
+    ) {
+      let nextToken = tokens[i + 2]
+        ? tokens[i + 2].replace(/[,;)]/g, "").toLowerCase()
+        : "";
+      if (nextToken && !["from", "select"].includes(nextToken))
+        tables.add(nextToken);
+      i += 2;
+      while (i + 1 < tokens.length && tokens[i + 1].toLowerCase() !== "from")
+        i++;
+      if (i + 2 < tokens.length) {
+        nextToken = tokens[i + 2].replace(/[,;)]/g, "").toLowerCase();
+        if (nextToken && !["where", "join"].includes(nextToken))
+          tables.add(nextToken);
+      }
+    } else if (token === "with") {
+      let cteStart = i + 1;
+      while (i + 1 < tokens.length && tokens[i + 1].toLowerCase() !== "as") i++;
+      if (i + 2 < tokens.length && tokens[i + 2] === "(") {
+        let bracketCount = 1,
+          subqueryStart = i + 2;
+        while (i + 1 < tokens.length && bracketCount > 0) {
+          i++;
+          if (tokens[i] === "(") bracketCount++;
+          if (tokens[i] === ")") bracketCount--;
+        }
+        const subquery = tokens.slice(subqueryStart, i).join(" ");
+        tables.add(
+          ...extractTableNames(subquery).filter((t) => !tables.has(t))
+        );
+      }
+    } else if (
+      token === "values" &&
+      i + 1 < tokens.length &&
+      tokens[i + 1] === "("
+    ) {
+      let aliasStart = i + 1;
+      while (i + 1 < tokens.length && tokens[i + 1] !== "as") i++;
+      if (i + 2 < tokens.length) {
+        let alias = tokens[i + 2].replace(/[,;)]/g, "").toLowerCase();
+        if (alias) tables.add(alias);
+      }
+    } else if (["exists", "in"].includes(token)) {
+      let subqueryStart = i + 1;
+      while (i + 1 < tokens.length && tokens[i + 1] !== ")") i++;
+      if (i > subqueryStart) {
+        const subquery = tokens.slice(subqueryStart, i + 1).join(" ");
+        tables.add(
+          ...extractTableNames(subquery).filter((t) => !tables.has(t))
+        );
+      }
+    }
+  }
+  return Array.from(tables);
+}
+
+async function validateQuery(query, runResult, resultsDiv) {
+  const question = currentQuestions[currentQuestionIndex];
+  if (!question || !question.expected_sql) {
+    showError("No question or expected SQL available for validation.");
+    return;
+  }
+  const response = await fetch("/api/validate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "session-id": sessionId },
+    body: JSON.stringify({
+      user_query: query,
+      expected_query: question.expected_sql,
+    }),
+  });
+  if (!response.ok)
+    throw new Error((await response.json()).detail || "Failed to validate");
+  const result = await response.json();
+  const questionText = document.getElementById("questionText");
+  const resultMessage = document.getElementById("resultMessage");
+  if (result.valid) {
+    questionText.classList.remove("text-red-500");
+    questionText.classList.add("text-green-500");
+    resultMessage.textContent = "Correct answer!";
+    resultMessage.className = "text-green-500 ml-4";
+    if (runResult.columns) {
+      let html = `<table class="w-full border-collapse"><tr>${runResult.columns
+        .map((col) => `<th class="border p-2">${col}</th>`)
+        .join("")}</tr>`;
+      html += runResult.rows
+        .map(
+          (row) =>
+            `<tr>${runResult.columns
+              .map((col) => `<td class="border p-2">${row[col] || "NULL"}</td>`)
+              .join("")}</tr>`
+        )
+        .join("");
+      html += "</table>";
+      resultsDiv.innerHTML = html;
+    } else {
+      resultsDiv.innerHTML = "<p>No results</p>";
+    }
+  } else {
+    questionText.classList.remove("text-green-500");
+    questionText.classList.add("text-red-500");
+    resultMessage.textContent = "Incorrect answer!";
+    resultMessage.className = "text-red-500 ml-4";
+    resultsDiv.innerHTML = "";
+  }
+}
+
+function showError(message) {
+  let errorMessage =
+    document.getElementById("errorMessage") || document.createElement("span");
+  if (!errorMessage.id) {
+    errorMessage.id = "errorMessage";
+    document.getElementById("runQueryBtn").parentNode.appendChild(errorMessage);
+  }
+  errorMessage.textContent = message;
+  errorMessage.className = "text-red-500 mt-2";
+}
+
+window.onload = init;

app/static/style.css

@@ -0,0 +1,16 @@
+body {
+  font-family: Arial, sans-serif;
+}
+#results table {
+  border-collapse: collapse;
+  width: 100%;
+}
+#results th,
+#results td {
+  border: 1px solid #ddd;
+  padding: 8px;
+  text-align: left;
+}
+#results th {
+  background-color: #f2f2f2;
+}

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.110.0
+uvicorn
+pydantic
+sqlparse