Evaluator_ChromaDB_Post_Trainining_synthetic_text_to_sql_gretelai.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "L4",
      "authorship_tag": "ABX9TyOYfVizvBSb4K8VL/3l3pLZ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "71c7e047b9994da691b7d67caafd2526": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_01d61c85a09144f9a7a0d0b19264f4de",
              "IPY_MODEL_eb223c3a40b44f16a501f3c9bc79ac96",
              "IPY_MODEL_e175c6e87af540ab8e48aaeba6057185"
            ],
            "layout": "IPY_MODEL_0fa0d71af2114eb1b518ba7d77ae15e5"
          }
        },
        "01d61c85a09144f9a7a0d0b19264f4de": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_70edf967d758491ba03dc2ea455df5a3",
            "placeholder": "​",
            "style": "IPY_MODEL_980b7be2998f4d24af7733e1ca820993",
            "value": "100%"
          }
        },
        "eb223c3a40b44f16a501f3c9bc79ac96": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_165d6dbd74b34fce9b56b78d6b5f9220",
            "max": 100,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_e245700deee44616b33d22688fab2311",
            "value": 100
          }
        },
        "e175c6e87af540ab8e48aaeba6057185": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_5778f2e2573644329a772ae131cfcf77",
            "placeholder": "​",
            "style": "IPY_MODEL_40f97705d548417d9ce86a49cc48cecf",
            "value": " 100/100 [49:39&lt;00:00, 26.33s/it]"
          }
        },
        "0fa0d71af2114eb1b518ba7d77ae15e5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "70edf967d758491ba03dc2ea455df5a3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "980b7be2998f4d24af7733e1ca820993": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "165d6dbd74b34fce9b56b78d6b5f9220": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e245700deee44616b33d22688fab2311": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "5778f2e2573644329a772ae131cfcf77": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "40f97705d548417d9ce86a49cc48cecf": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/frank-morales2020/MLxDL/blob/main/Evaluator_ChromaDB_Post_Trainining_synthetic_text_to_sql_gretelai.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q datasets\n",
        "!pip install -q chromadb\n",
        "!pip install -q faiss-gpu\n",
        "!pip install peft  -q\n",
        "\n",
        "!pip install bitsandbytes -q\n",
        "!pip pip install accelerate -q\n",
        "\n",
        "!pip install -U flash-attn --no-build-isolation --quiet\n",
        "\n",
        "!pip install colab-env --quiet\n",
        "\n",
        "!pip install mistral_inference -q\n",
        "\n",
        "!pip install -q evaluate sentence_transformers"
      ],
      "metadata": {
        "id": "zR4yytDbPyOa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5-cJWzOH4B81",
        "outputId": "c368e63f-0454-4d5f-c3ac-7ae92ec016ab"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sun Jul  7 17:54:26 2024       \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |\n",
            "|-----------------------------------------+----------------------+----------------------+\n",
            "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                                         |                      |               MIG M. |\n",
            "|=========================================+======================+======================|\n",
            "|   0  NVIDIA L4                      Off | 00000000:00:03.0 Off |                    0 |\n",
            "| N/A   37C    P8              16W /  72W |      1MiB / 23034MiB |      0%      Default |\n",
            "|                                         |                      |                  N/A |\n",
            "+-----------------------------------------+----------------------+----------------------+\n",
            "                                                                                         \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| Processes:                                                                            |\n",
            "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
            "|        ID   ID                                                             Usage      |\n",
            "|=======================================================================================|\n",
            "|  No running processes found                                                           |\n",
            "+---------------------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import colab_env\n",
        "import os\n",
        "import sys\n",
        "import json\n",
        "import IPython\n",
        "from datetime import datetime\n",
        "from datasets import load_dataset\n",
        "from peft import LoraConfig, PeftModel, prepare_model_for_kbit_training, get_peft_model\n",
        "from transformers import (\n",
        "    AutoModelForCausalLM,\n",
        "    AutoTokenizer,\n",
        "    BitsAndBytesConfig,\n",
        "    AutoTokenizer,\n",
        "    TrainingArguments,\n",
        ")"
      ],
      "metadata": {
        "id": "zAOOi0pfRZPt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Environment Settings"
      ],
      "metadata": {
        "id": "zi9nbbcSvbWS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "from tqdm.auto import tqdm\n",
        "from datasets import load_dataset\n",
        "from peft import AutoPeftModelForCausalLM\n",
        "from transformers import AutoTokenizer, pipeline\n",
        "import os\n",
        "\n",
        "\n",
        "from sentence_transformers import SentenceTransformer\n",
        "import chromadb\n",
        "\n",
        "# Logging Setup\n",
        "logging.basicConfig(level=logging.INFO)\n",
        "\n",
        "# 1. Configurable Parameters\n",
        "PEFT_MODEL_ID = \"frankmorales2020/Mistral-7B-text-to-sql-flash-attention-2-dataeval\"\n",
        "\n",
        "#b-mc2/sql-create-context\n",
        "#DATASET_FILE = \"/content/drive/MyDrive/datasets/test_dataset.json\"\n",
        "\n",
        "#gretelai/synthetic_text_to_sql\n",
        "DATASET_FILE = \"/content/drive/MyDrive/datasets/gretelai_test_dataset.json\"\n",
        "\n",
        "\n",
        "NUM_SAMPLES_TO_PROCESS = int(os.getenv(\"NUM_SAMPLES\", 100))\n",
        "GENERATION_PARAMS = {\n",
        "    \"max_new_tokens\": 256, \"do_sample\": True, \"temperature\": 0.7, \"top_k\": 50, \"top_p\": 0.95\n",
        "}\n",
        "SIMILARITY_THRESHOLD = 0.75\n",
        "\n",
        "# 2. Mount Google Drive (for Colab)\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# 3. Load Evaluation Dataset\n",
        "eval_dataset = load_dataset(\"json\", data_files=DATASET_FILE, split=\"train\")\n",
        "if NUM_SAMPLES_TO_PROCESS > 0:\n",
        "    eval_dataset = eval_dataset.select(range(NUM_SAMPLES_TO_PROCESS))\n",
        "logging.info(f\"Processing {len(eval_dataset)} samples from the dataset.\")\n",
        "\n",
        "\n",
        "# 4. Load Models and Tokenizer\n",
        "logging.info(f\"Loading fine-tuned PEFT model from: {PEFT_MODEL_ID}\")\n",
        "model = AutoPeftModelForCausalLM.from_pretrained(PEFT_MODEL_ID)\n",
        "tokenizer = AutoTokenizer.from_pretrained(PEFT_MODEL_ID)\n",
        "pipe = pipeline(\"text-generation\", model=model, tokenizer=tokenizer, **GENERATION_PARAMS)\n",
        "logging.info(\"Model and tokenizer loaded successfully!\")\n",
        "\n",
        "# 5. ChromaDB Setup\n",
        "client = chromadb.PersistentClient(path='db')  # Store embeddings on disk\n",
        "collection = client.get_or_create_collection(name=\"sql_queries_and_embeddings\")\n",
        "\n",
        "# Add Original SQL Queries to ChromaDB\n",
        "embedding_model = SentenceTransformer(\"all-mpnet-base-v2\")\n",
        "original_sql_queries = [\n",
        "    item['messages'][2]['content']\n",
        "    for item in eval_dataset if len(item['messages']) > 2 and item['messages'][2].get('content')\n",
        "]\n",
        "\n",
        "sql_embeddings = embedding_model.encode(original_sql_queries).tolist()\n",
        "collection.add(\n",
        "    embeddings=sql_embeddings,\n",
        "    metadatas=[{\"original_sql\": query} for query in original_sql_queries],\n",
        "    ids=[f\"original_{i}\" for i in range(len(original_sql_queries))]  # Unique IDs\n",
        ")\n"
      ],
      "metadata": {
        "id": "tOrvw1OpPw_r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Postgresql Setup"
      ],
      "metadata": {
        "id": "b_dQycoVu1yF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#ADDED By FM 01/06/2024\n",
        "!apt-get update -y\n",
        "!apt-get install postgresql-14 -y\n",
        "\n",
        "!service postgresql restart\n",
        "!sudo apt install postgresql-server-dev-all"
      ],
      "metadata": {
        "id": "fz3g0Q77QTBp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# PostGRES SQL Settings\n",
        "!sudo -u postgres psql -c \"CREATE USER postgres WITH SUPERUSER\"\n",
        "!sudo -u postgres psql -c \"ALTER USER postgres PASSWORD 'postgres'\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFbxBi-HQZT-",
        "outputId": "2f9ddbc4-ae85-4497-b4b7-dae4710fc9da"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ERROR:  role \"postgres\" already exists\n",
            "ALTER ROLE\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "QUERY_create='CREATE TABLE table_name_24 (score VARCHAR, date VARCHAR)'"
      ],
      "metadata": {
        "id": "l5ATm5VvQiAg"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "QUERY_select='SELECT 2009 FROM table_name_50 WHERE 2011 = \"a\"'"
      ],
      "metadata": {
        "id": "iJjf15-aQqco"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def table_creator(query):\n",
        "    import os\n",
        "    import psycopg2 as ps\n",
        "    import pandas as pd\n",
        "\n",
        "    DB_NAME = \"postgres\"\n",
        "    DB_USER = \"postgres\"\n",
        "    DB_PASS = \"postgres\"\n",
        "    DB_HOST = \"localhost\"\n",
        "    DB_PORT = \"5432\"\n",
        "\n",
        "    conn = ps.connect(database=DB_NAME,\n",
        "                  user=DB_USER,\n",
        "                  password=DB_PASS,\n",
        "                  host=DB_HOST,\n",
        "                  port=DB_PORT)\n",
        "\n",
        "    cur = conn.cursor() # creating a cursor\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    # Wrap the execute command in a try-except block to handle potential errors\n",
        "    try:\n",
        "        cur.execute(\"\"\"\n",
        "                            %s\n",
        "                            \"\"\"%query)\n",
        "        conn.commit()\n",
        "        print(\"Table Created successfully\")\n",
        "    except Exception as e:\n",
        "        conn.rollback() # Rollback the transaction in case of an error\n",
        "        print(\"Error creating table:\", e)\n",
        "\n",
        "    conn.close()"
      ],
      "metadata": {
        "id": "Q5qUFuunQvHU"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import psycopg2 as ps\n",
        "import pandas as pd\n",
        "\n",
        "DB_NAME = \"postgres\"\n",
        "DB_USER = \"postgres\"\n",
        "DB_PASS = \"postgres\"\n",
        "DB_HOST = \"localhost\"\n",
        "DB_PORT = \"5432\""
      ],
      "metadata": {
        "id": "BqlIz9IYQ3UT"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import psycopg2 as ps\n",
        "import pandas as pd\n",
        "\n",
        "def table_select(query):\n",
        "    conn = ps.connect(database=DB_NAME,\n",
        "                      user=DB_USER,\n",
        "                      password=DB_PASS,\n",
        "                      host=DB_HOST,\n",
        "                      port=DB_PORT)\n",
        "    print(\"Database connected successfully\")\n",
        "\n",
        "    #query = query.replace('\"', \"'\") # Replace double quotes with single quotes for potential date values\n",
        "\n",
        "    try:\n",
        "\n",
        "        #df = pd.read_sql_query(\"%s\"%query, con=conn)\n",
        "        #print('rec: %'%df) # Print the resulting DataFrame\n",
        "\n",
        "        cur = conn.cursor()\n",
        "        cur.execute(query)\n",
        "        rows = cur.fetchall()\n",
        "        conn.commit()\n",
        "        conn.close()\n",
        "        print('\\n')\n",
        "        print('Record(s): %s \\n'%len(rows))\n",
        "        for row in rows:\n",
        "            print(row)\n",
        "\n",
        "\n",
        "        eqc=1\n",
        "\n",
        "    except Exception as e:\n",
        "        eqc=0\n",
        "        #conn.rollback() # Rollback the transaction in case of an error\n",
        "        print(\"Error executing query:\", e)\n",
        "        #print('TABLE IS EMPTY')\n",
        "        conn.commit()\n",
        "        conn.close()\n",
        "\n",
        "    return eqc"
      ],
      "metadata": {
        "id": "ptNXNomUQ0Fy"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "table_creator(QUERY_create)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BsMREUeGQ9QQ",
        "outputId": "64822afb-fffa-4bbc-9063-164c9dd1b5b5"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Table Created successfully\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Model Evaluator"
      ],
      "metadata": {
        "id": "VszcBUuCvLAt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 6. Evaluation Function (Exact Match Only)\n",
        "def evaluate(sample):\n",
        "    eqc=0\n",
        "    prompt = pipe.tokenizer.apply_chat_template(sample[\"messages\"][:2], tokenize=False, add_generation_prompt=True)\n",
        "    outputs = pipe(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95, eos_token_id=pipe.tokenizer.eos_token_id, pad_token_id=pipe.tokenizer.pad_token_id)\n",
        "    predicted_answer = outputs[0]['generated_text'][len(prompt):].strip()\n",
        "\n",
        "    #print(\"\\n\\n\")\n",
        "    question = sample[\"messages\"][1][\"content\"]\n",
        "    original_answer = sample[\"messages\"][2][\"content\"]\n",
        "\n",
        "\n",
        "    schema=sample[\"messages\"][0]['content']\n",
        "    schema_query=schema[153:len(schema)]\n",
        "\n",
        "    print(f'Question: {question}')\n",
        "    print(f'SCHEMA: {schema_query}')\n",
        "    print(f'Original Answer: {original_answer}')\n",
        "    print(f'Generated Answer: {predicted_answer}')\n",
        "\n",
        "    if predicted_answer == original_answer:\n",
        "\n",
        "        print(\"\\n\")\n",
        "        print(f'SCHEMA QUERY: {schema_query}')\n",
        "        table_creator(schema_query)\n",
        "        print(\"\\n\")\n",
        "        print(f'Generated Answer: {predicted_answer}')\n",
        "        eqc=table_select(predicted_answer)\n",
        "        print(eqc)\n",
        "        print(\"\\n\")\n",
        "        if int(eqc)==1:\n",
        "           print('Good Query execution')\n",
        "        else:\n",
        "           print('Bad Query execution')\n",
        "\n",
        "        print(\"\\n\")\n",
        "        print('MATCH')\n",
        "        return 1, eqc\n",
        "\n",
        "    # If not an exact match, check semantic similarity using ChromaDB:\n",
        "    predicted_embedding = embedding_model.encode([predicted_answer]).tolist()[0]\n",
        "    results = collection.query(\n",
        "        query_embeddings=[predicted_embedding],\n",
        "        n_results=1,\n",
        "        include=[\"distances\", \"metadatas\"]\n",
        "    )\n",
        "    closest_distance = results['distances'][0][0]\n",
        "    most_similar_query = results['metadatas'][0][0]['original_sql']\n",
        "    print(f'Closest Distance: {closest_distance}')\n",
        "\n",
        "    similarity_threshold = SIMILARITY_THRESHOLD\n",
        "\n",
        "    if closest_distance < similarity_threshold:\n",
        "        print(\"\\n\")\n",
        "        print('MATCH (Semantically Similar)')\n",
        "        print(\"\\n\")\n",
        "        print(f'SCHEMA QUERY: {schema_query}')\n",
        "        table_creator(schema_query)\n",
        "        print(\"\\n\")\n",
        "        print('Similar Query:', most_similar_query)\n",
        "        eqc=table_select(most_similar_query)\n",
        "        print(\"\\n\")\n",
        "        if int(eqc)==1:\n",
        "           print('Good Query execution')\n",
        "        else:\n",
        "           print('Bad Query execution')\n",
        "        print(\"\\n\")\n",
        "        return 1, eqc\n",
        "\n",
        "    else:\n",
        "        print('NO MATCH')\n",
        "        return 0, eqc\n",
        "\n",
        "    print(\"\\n\\n\")\n",
        "\n",
        "# 7. Main Evaluation Loop\n",
        "success_rate = []\n",
        "success_rate_query = []\n",
        "\n",
        "for i, s in enumerate(tqdm(eval_dataset)):\n",
        "    print()\n",
        "    print(f\"Evaluating sample: {i}\")\n",
        "    try:\n",
        "        success_rate.append(evaluate(s))\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error evaluating sample {i}: {e}\")\n",
        "\n",
        "\n",
        "\n",
        "# 8. Compute and Print Accuracy\n",
        "if len(success_rate) > 0:\n",
        "    # Extract the first element (match success indicator) from each tuple\n",
        "    match_successes = [result[0] for result in success_rate]\n",
        "    accuracy = sum(match_successes) / len(success_rate)\n",
        "    print(f\"\\nMatch Accuracy: {accuracy:.2%}\\n\")\n",
        "\n",
        "    query_successes = [result[1] for result in success_rate]\n",
        "    accuracy = sum(query_successes) / len(query_successes)\n",
        "    print(f\"\\nQuery Successes: {accuracy:.2%}\\n\")\n",
        "\n",
        "else:\n",
        "    print(\"\\nNo samples were successfully evaluated. Check the dataset and evaluation logic.\\n\")\n",
        "\n",
        "\n",
        "# 8. Compute and Print Accuracy\n",
        "#if len(success_rate) > 0:\n",
        "#    accuracy = sum(success_rate) / len(success_rate)\n",
        "#    print(f\"\\nMatch Accuracy: {accuracy:.2%}\\n\")\n",
        "#else:\n",
        "#    print(\"\\nNo samples were successfully evaluated. Check the dataset and evaluation logic.\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "71c7e047b9994da691b7d67caafd2526",
            "01d61c85a09144f9a7a0d0b19264f4de",
            "eb223c3a40b44f16a501f3c9bc79ac96",
            "e175c6e87af540ab8e48aaeba6057185",
            "0fa0d71af2114eb1b518ba7d77ae15e5",
            "70edf967d758491ba03dc2ea455df5a3",
            "980b7be2998f4d24af7733e1ca820993",
            "165d6dbd74b34fce9b56b78d6b5f9220",
            "e245700deee44616b33d22688fab2311",
            "5778f2e2573644329a772ae131cfcf77",
            "40f97705d548417d9ce86a49cc48cecf"
          ]
        },
        "id": "pkl430CeQb8Z",
        "outputId": "05101fe9-03a9-4715-d64a-c1c74d0334bf"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/100 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "71c7e047b9994da691b7d67caafd2526"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Evaluating sample: 0\n",
            "Question: What is the percentage of successful open data initiatives in the education sector?\n",
            "SCHEMA: CREATE TABLE open_data_initiatives (id INT, sector VARCHAR(20), status VARCHAR(10)); INSERT INTO open_data_initiatives (id, sector, status) VALUES (1, 'justice', 'open'), (2, 'transportation', 'open'), (3, 'education', 'closed'), (4, 'education', 'open');\n",
            "Original Answer: SELECT 100.0 * COUNT(CASE WHEN status = 'open' THEN 1 END) / COUNT(*) FROM open_data_initiatives WHERE sector = 'education';\n",
            "Generated Answer: SELECT COUNT(*) FROM open_data_initiatives WHERE sector = 'education' AND status = 'open' / SELECT COUNT(*) FROM open_data_initiatives WHERE sector = 'education'\n",
            "Closest Distance: 0.3737031817436218\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE open_data_initiatives (id INT, sector VARCHAR(20), status VARCHAR(10)); INSERT INTO open_data_initiatives (id, sector, status) VALUES (1, 'justice', 'open'), (2, 'transportation', 'open'), (3, 'education', 'closed'), (4, 'education', 'open');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT 100.0 * COUNT(CASE WHEN status = 'open' THEN 1 END) / COUNT(*) FROM open_data_initiatives WHERE sector = 'education';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('50.0000000000000000'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 1\n",
            "Question: What is the average Shariah-compliant investment portfolio return for female investors in the Middle East, grouped by year?\n",
            "SCHEMA: CREATE TABLE Investments (Id INT, InvestorGender VARCHAR(10), Location VARCHAR(20), InvestmentType VARCHAR(20), Return DECIMAL(5,2), InvestmentYear INT); INSERT INTO Investments (Id, InvestorGender, Location, InvestmentType, Return, InvestmentYear) VALUES (1, 'Female', 'Middle East', 'Shariah Compliant', 8.56, 2020), (2, 'Female', 'Middle East', 'Shariah Compliant', 9.15, 2021);\n",
            "Original Answer: SELECT AVG(Return) AS Avg_Return, InvestmentYear FROM Investments WHERE InvestmentType = 'Shariah Compliant' AND InvestorGender = 'Female' GROUP BY InvestmentYear;\n",
            "Generated Answer: SELECT AVG(Return), InvestmentYear FROM Investments WHERE InvestorGender = 'Female' AND Location = 'Middle East' AND InvestmentType = 'Shariah Compliant' GROUP BY InvestmentYear\n",
            "Closest Distance: 0.09634736180305481\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Investments (Id INT, InvestorGender VARCHAR(10), Location VARCHAR(20), InvestmentType VARCHAR(20), Return DECIMAL(5,2), InvestmentYear INT); INSERT INTO Investments (Id, InvestorGender, Location, InvestmentType, Return, InvestmentYear) VALUES (1, 'Female', 'Middle East', 'Shariah Compliant', 8.56, 2020), (2, 'Female', 'Middle East', 'Shariah Compliant', 9.15, 2021);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(Return) AS Avg_Return, InvestmentYear FROM Investments WHERE InvestmentType = 'Shariah Compliant' AND InvestorGender = 'Female' GROUP BY InvestmentYear;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 2 \n",
            "\n",
            "(Decimal('8.5600000000000000'), 2020)\n",
            "(Decimal('9.1500000000000000'), 2021)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 2\n",
            "Question: Find the minimum founding year for startups founded by Indigenous or Native entrepreneurs\n",
            "SCHEMA: CREATE TABLE company (id INT, name TEXT, founding_year INT, founder_race TEXT); INSERT INTO company (id, name, founding_year, founder_race) VALUES (1, 'IndigenousTech', 2010, 'Indigenous or Native American'); INSERT INTO company (id, name, founding_year, founder_race) VALUES (2, 'Beta', 2015, 'White');\n",
            "Original Answer: SELECT MIN(founding_year) FROM company WHERE founder_race = 'Indigenous or Native American';\n",
            "Generated Answer: SELECT MIN(founding_year) FROM company WHERE founder_race = 'Indigenous or Native American'\n",
            "Closest Distance: 0.0234964732080698\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE company (id INT, name TEXT, founding_year INT, founder_race TEXT); INSERT INTO company (id, name, founding_year, founder_race) VALUES (1, 'IndigenousTech', 2010, 'Indigenous or Native American'); INSERT INTO company (id, name, founding_year, founder_race) VALUES (2, 'Beta', 2015, 'White');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MIN(founding_year) FROM company WHERE founder_race = 'Indigenous or Native American';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(2010,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 3\n",
            "Question: How many intelligence operations were conducted in 'Africa' in the 'IntelligenceOperations' table?\n",
            "SCHEMA: CREATE TABLE IntelligenceOperations (id INT PRIMARY KEY, operation_name VARCHAR(100), location VARCHAR(50), operation_type VARCHAR(50), start_date DATE, end_date DATE); INSERT INTO IntelligenceOperations (id, operation_name, location, operation_type, start_date, end_date) VALUES (1, 'Operation Red Anvil', 'Africa', 'Surveillance', '2021-01-01', '2021-03-31'); INSERT INTO IntelligenceOperations (id, operation_name, location, operation_type, start_date, end_date) VALUES (2, 'Operation Night Hawk', 'Europe', 'Counterintelligence', '2021-04-01', '2021-06-30');\n",
            "Original Answer: SELECT COUNT(*) FROM IntelligenceOperations WHERE location = 'Africa';\n",
            "Generated Answer: SELECT COUNT(*) FROM IntelligenceOperations WHERE location = \"Africa\" AND operation_type = \"Surveillance\" AND start_date <= 2021 AND end_date <= 2021\n",
            "Closest Distance: 0.34414035081863403\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE IntelligenceOperations (id INT PRIMARY KEY, operation_name VARCHAR(100), location VARCHAR(50), operation_type VARCHAR(50), start_date DATE, end_date DATE); INSERT INTO IntelligenceOperations (id, operation_name, location, operation_type, start_date, end_date) VALUES (1, 'Operation Red Anvil', 'Africa', 'Surveillance', '2021-01-01', '2021-03-31'); INSERT INTO IntelligenceOperations (id, operation_name, location, operation_type, start_date, end_date) VALUES (2, 'Operation Night Hawk', 'Europe', 'Counterintelligence', '2021-04-01', '2021-06-30');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM IntelligenceOperations WHERE location = 'Africa';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 4\n",
            "Question: What is the total number of space missions led by women?\n",
            "SCHEMA: CREATE TABLE space_missions (id INT, name VARCHAR(255), leader VARCHAR(255), year INT); INSERT INTO space_missions (id, name, leader, year) VALUES (1, 'Mars Rover', 'Dr. Jessica Watkins', 2022); INSERT INTO space_missions (id, name, leader, year) VALUES (2, 'ISS Expedition', 'Anousheh Ansari', 2023);\n",
            "Original Answer: SELECT COUNT(*) FROM space_missions WHERE leader IN (SELECT name FROM astronauts WHERE gender = 'Female');\n",
            "Generated Answer: SELECT COUNT(*) FROM space_missions WHERE leader = 'Anousheh Ansari' AND year > 2022\n",
            "Closest Distance: 0.5059126615524292\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE space_missions (id INT, name VARCHAR(255), leader VARCHAR(255), year INT); INSERT INTO space_missions (id, name, leader, year) VALUES (1, 'Mars Rover', 'Dr. Jessica Watkins', 2022); INSERT INTO space_missions (id, name, leader, year) VALUES (2, 'ISS Expedition', 'Anousheh Ansari', 2023);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM space_missions WHERE leader IN (SELECT name FROM astronauts WHERE gender = 'Female');\n",
            "Database connected successfully\n",
            "Error executing query: relation \"astronauts\" does not exist\n",
            "LINE 1: ... space_missions WHERE leader IN (SELECT name FROM astronauts...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 5\n",
            "Question: How many products are sold by each supplier?\n",
            "SCHEMA: CREATE TABLE Products (ProductID int, SupplierID int, QuantitySold int);\n",
            "Original Answer: SELECT SupplierID, SUM(QuantitySold) FROM Products GROUP BY SupplierID;\n",
            "Generated Answer: SELECT COUNT(*), SupplierID FROM Products GROUP BY SupplierID\n",
            "Closest Distance: 0.18182766437530518\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Products (ProductID int, SupplierID int, QuantitySold int);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT supplier_id, COUNT(DISTINCT id) FROM products GROUP BY supplier_id;\n",
            "Database connected successfully\n",
            "Error executing query: column \"supplier_id\" does not exist\n",
            "LINE 1: SELECT supplier_id, COUNT(DISTINCT id) FROM products GROUP B...\n",
            "               ^\n",
            "HINT:  Perhaps you meant to reference the column \"products.supplierid\".\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 6\n",
            "Question: What is the total waste generation in kg for the top 3 countries in 2020?\n",
            "SCHEMA: CREATE TABLE waste_generation (country VARCHAR(255), year INT, amount FLOAT); INSERT INTO waste_generation (country, year, amount) VALUES ('USA', 2020, 500.0), ('Canada', 2020, 350.0), ('Mexico', 2020, 400.0);\n",
            "Original Answer: SELECT wg.country, SUM(wg.amount) as total_waste FROM waste_generation wg WHERE wg.year = 2020 AND wg.country IN ('USA', 'Canada', 'Mexico') GROUP BY wg.country ORDER BY total_waste DESC LIMIT 3;\n",
            "Generated Answer: SELECT SUM(amount) FROM waste_generation WHERE country IN ('USA', 'Canada', 'Mexico') AND year = 2020\n",
            "Closest Distance: 0.2812768220901489\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE waste_generation (country VARCHAR(255), year INT, amount FLOAT); INSERT INTO waste_generation (country, year, amount) VALUES ('USA', 2020, 500.0), ('Canada', 2020, 350.0), ('Mexico', 2020, 400.0);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT wg.country, SUM(wg.amount) as total_waste FROM waste_generation wg WHERE wg.year = 2020 AND wg.country IN ('USA', 'Canada', 'Mexico') GROUP BY wg.country ORDER BY total_waste DESC LIMIT 3;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('USA', 500.0)\n",
            "('Mexico', 400.0)\n",
            "('Canada', 350.0)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 7\n",
            "Question: What is the average age of attendees at arts events in California and how many unique events have there been?\n",
            "SCHEMA: CREATE TABLE ca_events (id INT, num_attendees INT, avg_age FLOAT); CREATE TABLE ca_event_types (id INT, event_type VARCHAR(15)); INSERT INTO ca_events (id, num_attendees, avg_age) VALUES (1, 1200, 35.5), (2, 1800, 40.2); INSERT INTO ca_event_types (id, event_type) VALUES (1, 'Dance'), (2, 'Music');\n",
            "Original Answer: SELECT AVG(ce.avg_age), COUNT(DISTINCT cet.event_type) FROM ca_events ce INNER JOIN ca_event_types cet ON TRUE;\n",
            "Generated Answer: SELECT AVG(t2.avg_age) FROM ca_events AS t1 JOIN ca_event_types AS t2 ON t1.event_type = t2.id WHERE t2.event_type = \"Dance\" OR t2.event_type = \"Music\"\n",
            "Closest Distance: 0.4498296082019806\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE ca_events (id INT, num_attendees INT, avg_age FLOAT); CREATE TABLE ca_event_types (id INT, event_type VARCHAR(15)); INSERT INTO ca_events (id, num_attendees, avg_age) VALUES (1, 1200, 35.5), (2, 1800, 40.2); INSERT INTO ca_event_types (id, event_type) VALUES (1, 'Dance'), (2, 'Music');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(ce.avg_age), COUNT(DISTINCT cet.event_type) FROM ca_events ce INNER JOIN ca_event_types cet ON TRUE;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(37.85, 2)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 8\n",
            "Question: Find the average waste generation for chemicals with a carbon footprint above 800.\n",
            "SCHEMA: CREATE TABLE waste_generation (id INT PRIMARY KEY, chemical_id INT, waste_generation INT); INSERT INTO waste_generation (id, chemical_id, waste_generation) VALUES (1, 1, 900); CREATE TABLE environmental_impact (id INT PRIMARY KEY, chemical_id INT, carbon_footprint INT); INSERT INTO environmental_impact (id, chemical_id, carbon_footprint) VALUES (1, 1, 850);\n",
            "Original Answer: SELECT AVG(waste_generation) FROM waste_generation wg JOIN environmental_impact ei ON wg.chemical_id = ei.chemical_id WHERE ei.carbon_footprint > 800;\n",
            "Generated Answer: SELECT AVG(w.generation) FROM waste_generation AS w JOIN environmental_impact AS e ON w.chemical_id = e.chemical_id WHERE e.carbon_footprint > 800\n",
            "Closest Distance: 0.03243521973490715\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE waste_generation (id INT PRIMARY KEY, chemical_id INT, waste_generation INT); INSERT INTO waste_generation (id, chemical_id, waste_generation) VALUES (1, 1, 900); CREATE TABLE environmental_impact (id INT PRIMARY KEY, chemical_id INT, carbon_footprint INT); INSERT INTO environmental_impact (id, chemical_id, carbon_footprint) VALUES (1, 1, 850);\n",
            "Error creating table: relation \"waste_generation\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(waste_generation) FROM waste_generation wg JOIN environmental_impact ei ON wg.chemical_id = ei.chemical_id WHERE ei.carbon_footprint > 800;\n",
            "Database connected successfully\n",
            "Error executing query: relation \"environmental_impact\" does not exist\n",
            "LINE 1: ...G(waste_generation) FROM waste_generation wg JOIN environmen...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 9\n",
            "Question: How many TV shows have the word 'News' in their title?\n",
            "SCHEMA: CREATE TABLE shows (id INT, title TEXT, genre TEXT); INSERT INTO shows (id, title, genre) VALUES (1, 'News Show1', 'News'), (2, 'Entertainment Show2', 'Entertainment'), (3, 'Breaking News Show3', 'News');\n",
            "Original Answer: SELECT COUNT(*) FROM shows WHERE title LIKE '%News%';\n",
            "Generated Answer: SELECT COUNT(*) FROM shows WHERE genre = 'News'\n",
            "Closest Distance: 0.4847338795661926\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE shows (id INT, title TEXT, genre TEXT); INSERT INTO shows (id, title, genre) VALUES (1, 'News Show1', 'News'), (2, 'Entertainment Show2', 'Entertainment'), (3, 'Breaking News Show3', 'News');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM shows WHERE title LIKE '%News%';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(2,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 10\n",
            "Question: What was the total energy consumption (in MWh) for residential buildings in California in 2020?\n",
            "SCHEMA: CREATE TABLE residential_energy_consumption (state VARCHAR(20), year INT, sector VARCHAR(20), energy_consumption FLOAT);\n",
            "Original Answer: SELECT SUM(energy_consumption) FROM residential_energy_consumption WHERE state = 'California' AND year = 2020 AND sector = 'Residential';\n",
            "Generated Answer: SELECT SUM(energy_consumption) FROM residential_energy_consumption WHERE state = \"California\" AND sector = \"residential\" AND year = 2020\n",
            "Closest Distance: 0.0150598818436265\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE residential_energy_consumption (state VARCHAR(20), year INT, sector VARCHAR(20), energy_consumption FLOAT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(energy_consumption) FROM residential_energy_consumption WHERE state = 'California' AND year = 2020 AND sector = 'Residential';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(None,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 11\n",
            "Question: What is the number of news articles published per day in the United States and Canada, for the last 30 days?\n",
            "SCHEMA: CREATE TABLE news_articles (id INT, title VARCHAR(50), publication_date DATE, country VARCHAR(50)); INSERT INTO news_articles (id, title, publication_date, country) VALUES (1, 'Article1', '2022-01-01', 'United States'), (2, 'Article2', '2022-01-02', 'Canada'), (3, 'Article3', '2022-01-03', 'United States'), (4, 'Article4', '2022-01-04', 'Canada');\n",
            "Original Answer: SELECT DATE(publication_date) as date, COUNT(*) as num_articles FROM news_articles WHERE country IN ('United States', 'Canada') AND publication_date >= NOW() - INTERVAL 30 DAY GROUP BY date ORDER BY date DESC;\n",
            "Generated Answer: SELECT COUNT(*) FROM news_articles WHERE country = 'United States' OR country = 'Canada' AND publication_date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)\n",
            "Closest Distance: 0.2352416217327118\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE news_articles (id INT, title VARCHAR(50), publication_date DATE, country VARCHAR(50)); INSERT INTO news_articles (id, title, publication_date, country) VALUES (1, 'Article1', '2022-01-01', 'United States'), (2, 'Article2', '2022-01-02', 'Canada'), (3, 'Article3', '2022-01-03', 'United States'), (4, 'Article4', '2022-01-04', 'Canada');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT DATE(publication_date) as date, COUNT(*) as num_articles FROM news_articles WHERE country IN ('United States', 'Canada') AND publication_date >= NOW() - INTERVAL 30 DAY GROUP BY date ORDER BY date DESC;\n",
            "Database connected successfully\n",
            "Error executing query: syntax error at or near \"30\"\n",
            "LINE 1: ...Canada') AND publication_date >= NOW() - INTERVAL 30 DAY GRO...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 12\n",
            "Question: What is the number of travel advisories issued for each month for each country?\n",
            "SCHEMA: CREATE TABLE if not exists travel_advisory (advisory_id INT, country VARCHAR(50), issue_date DATE); INSERT INTO travel_advisory (advisory_id, country, issue_date) VALUES (1, 'France', '2022-02-01'), (2, 'Japan', '2022-03-01'), (3, 'Canada', '2022-01-01'), (4, 'Egypt', '2022-04-01'), (5, 'Australia', '2022-05-01');\n",
            "Original Answer: SELECT EXTRACT(MONTH FROM issue_date) as month, country, COUNT(*) as num_advisories FROM travel_advisory GROUP BY month, country;\n",
            "Generated Answer: SELECT COUNT(advisory_id), country FROM travel_advisory GROUP BY country, issue_date HAVING COUNT(*) = 1\n",
            "Closest Distance: 0.5168290138244629\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE if not exists travel_advisory (advisory_id INT, country VARCHAR(50), issue_date DATE); INSERT INTO travel_advisory (advisory_id, country, issue_date) VALUES (1, 'France', '2022-02-01'), (2, 'Japan', '2022-03-01'), (3, 'Canada', '2022-01-01'), (4, 'Egypt', '2022-04-01'), (5, 'Australia', '2022-05-01');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT EXTRACT(MONTH FROM issue_date) as month, country, COUNT(*) as num_advisories FROM travel_advisory GROUP BY month, country;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 5 \n",
            "\n",
            "(Decimal('2'), 'France', 1)\n",
            "(Decimal('3'), 'Japan', 1)\n",
            "(Decimal('4'), 'Egypt', 1)\n",
            "(Decimal('1'), 'Canada', 1)\n",
            "(Decimal('5'), 'Australia', 1)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 13\n",
            "Question: Delete the record with id 2 from the 'animals' table\n",
            "SCHEMA: CREATE TABLE animals (id INT PRIMARY KEY, name VARCHAR(50), species VARCHAR(50), population INT);\n",
            "Original Answer: DELETE FROM animals WHERE id = 2;\n",
            "Generated Answer: DELETE FROM animals WHERE id = 2\n",
            "Closest Distance: 0.04491596296429634\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE animals (id INT PRIMARY KEY, name VARCHAR(50), species VARCHAR(50), population INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: DELETE FROM animals WHERE id = 2;\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 14\n",
            "Question: How many donors from each country have donated to causes with a focus on climate change?\n",
            "SCHEMA: CREATE TABLE Donors (DonorID INT, DonorName VARCHAR(50), DonationAmount DECIMAL(10,2), CauseID INT, FirstDonationDate DATE, Country VARCHAR(50));CREATE TABLE Causes (CauseID INT, CauseName VARCHAR(50), Focus VARCHAR(50));\n",
            "Original Answer: SELECT D.Country, COUNT(DISTINCT D.DonorID) FROM Donors D JOIN Causes C ON D.CauseID = C.CauseID WHERE C.Focus = 'climate change' GROUP BY D.Country;\n",
            "Generated Answer: SELECT COUNT(*), DonorName, Country FROM Donors JOIN Causes ON Donors.CauseID = Causes.CauseID WHERE Causes.Focus = 'Climate change' GROUP BY DonorName, Country\n",
            "Closest Distance: 0.07848970592021942\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Donors (DonorID INT, DonorName VARCHAR(50), DonationAmount DECIMAL(10,2), CauseID INT, FirstDonationDate DATE, Country VARCHAR(50));CREATE TABLE Causes (CauseID INT, CauseName VARCHAR(50), Focus VARCHAR(50));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT D.Country, COUNT(DISTINCT D.DonorID) FROM Donors D JOIN Causes C ON D.CauseID = C.CauseID WHERE C.Focus = 'climate change' GROUP BY D.Country;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 15\n",
            "Question: Calculate the total cost of military equipment for Asian countries in the last 5 years\n",
            "SCHEMA: CREATE TABLE military_equipment (equipment_type VARCHAR(255), acquisition_cost INT, acquisition_year INT, country VARCHAR(255)); INSERT INTO military_equipment (equipment_type, acquisition_cost, acquisition_year, country) VALUES ('Fighter Jet', 50000000, 2017, 'China'), ('Submarine', 1000000000, 2019, 'Japan');\n",
            "Original Answer: SELECT country, SUM(acquisition_cost) FROM military_equipment WHERE country LIKE 'Asia%' AND acquisition_year BETWEEN (YEAR(CURRENT_DATE) - 5) AND YEAR(CURRENT_DATE) GROUP BY country;\n",
            "Generated Answer: SELECT SUM(acquisition_cost) FROM military_equipment WHERE country = 'Asia' AND acquisition_year > 2014\n",
            "Closest Distance: 0.2300858497619629\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE military_equipment (equipment_type VARCHAR(255), acquisition_cost INT, acquisition_year INT, country VARCHAR(255)); INSERT INTO military_equipment (equipment_type, acquisition_cost, acquisition_year, country) VALUES ('Fighter Jet', 50000000, 2017, 'China'), ('Submarine', 1000000000, 2019, 'Japan');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT country, SUM(acquisition_cost) FROM military_equipment WHERE country LIKE 'Asia%' AND acquisition_year BETWEEN (YEAR(CURRENT_DATE) - 5) AND YEAR(CURRENT_DATE) GROUP BY country;\n",
            "Database connected successfully\n",
            "Error executing query: function year(date) does not exist\n",
            "LINE 1: ...ountry LIKE 'Asia%' AND acquisition_year BETWEEN (YEAR(CURRE...\n",
            "                                                             ^\n",
            "HINT:  No function matches the given name and argument types. You might need to add explicit type casts.\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 16\n",
            "Question: What is the minimum fare collected for the 'Red Line' during any given month?\n",
            "SCHEMA: CREATE TABLE fare_by_month (route_name VARCHAR(50), month_year DATE, fare_amount DECIMAL(10,2)); INSERT INTO fare_by_month (route_name, month_year, fare_amount) VALUES ('Red Line', '2022-01-01', 100.00), ('Red Line', '2022-02-01', 110.00), ('Red Line', '2022-03-01', 95.00);\n",
            "Original Answer: SELECT MIN(fare_amount) FROM fare_by_month WHERE route_name = 'Red Line';\n",
            "Generated Answer: SELECT MIN(fare_amount) FROM fare_by_month WHERE route_name = 'Red Line' AND month_year > '2022-01-01'\n",
            "Closest Distance: 0.07992449402809143\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE fare_by_month (route_name VARCHAR(50), month_year DATE, fare_amount DECIMAL(10,2)); INSERT INTO fare_by_month (route_name, month_year, fare_amount) VALUES ('Red Line', '2022-01-01', 100.00), ('Red Line', '2022-02-01', 110.00), ('Red Line', '2022-03-01', 95.00);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MIN(fare_amount) FROM fare_by_month WHERE route_name = 'Red Line';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('95.00'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 17\n",
            "Question: What is the CO2 emission reduction of each production facility in the North America region from 2021 to 2022?\n",
            "SCHEMA: CREATE TABLE facility_emission_data (facility_id INT, facility_location VARCHAR(255), CO2_emission INT, year INT);\n",
            "Original Answer: SELECT facility_location, (a.CO2_emission - b.CO2_emission) AS CO2_emission_reduction FROM facility_emission_data a JOIN facility_emission_data b ON a.facility_location = b.facility_location AND a.year = b.year + 1 WHERE a.facility_location LIKE 'North America%' AND b.year = 2021;\n",
            "Generated Answer: SELECT CO2_emission FROM facility_emission_data WHERE facility_location = \"north america\" AND year > 2021 - 2022\n",
            "Closest Distance: 0.46491074562072754\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE facility_emission_data (facility_id INT, facility_location VARCHAR(255), CO2_emission INT, year INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT facility_location, (a.CO2_emission - b.CO2_emission) AS CO2_emission_reduction FROM facility_emission_data a JOIN facility_emission_data b ON a.facility_location = b.facility_location AND a.year = b.year + 1 WHERE a.facility_location LIKE 'North America%' AND b.year = 2021;\n",
            "Database connected successfully\n",
            "Error executing query: column reference \"facility_location\" is ambiguous\n",
            "LINE 1: SELECT facility_location, (a.CO2_emission - b.CO2_emission) ...\n",
            "               ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 18\n",
            "Question: What is the total number of transactions for each digital asset in the 'crypto_assets' table?\n",
            "SCHEMA: CREATE TABLE crypto_assets (asset_id INT, asset_name VARCHAR(50), total_transactions INT); INSERT INTO crypto_assets (asset_id, asset_name, total_transactions) VALUES (1, 'Bitcoin', 1000000); INSERT INTO crypto_assets (asset_id, asset_name, total_transactions) VALUES (2, 'Ethereum', 500000);\n",
            "Original Answer: SELECT asset_name, SUM(total_transactions) FROM crypto_assets GROUP BY asset_name;\n",
            "Generated Answer: SELECT COUNT(*) FROM crypto_assets GROUP BY asset_id, asset_name, total_transactions\n",
            "Closest Distance: 0.2868979275226593\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE crypto_assets (asset_id INT, asset_name VARCHAR(50), total_transactions INT); INSERT INTO crypto_assets (asset_id, asset_name, total_transactions) VALUES (1, 'Bitcoin', 1000000); INSERT INTO crypto_assets (asset_id, asset_name, total_transactions) VALUES (2, 'Ethereum', 500000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT asset_name, SUM(total_transactions) FROM crypto_assets GROUP BY asset_name;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 2 \n",
            "\n",
            "('Bitcoin', 1000000)\n",
            "('Ethereum', 500000)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 19\n",
            "Question: Update the arrival age of visitors from Japan to 30.\n",
            "SCHEMA: CREATE TABLE tourism_data (visitor_id INT, country VARCHAR(50), arrival_age INT); INSERT INTO tourism_data (visitor_id, country, arrival_age) VALUES (1, 'USA', 35), (2, 'USA', 42), (3, 'Japan', 28), (4, 'Australia', 31), (5, 'UK', 29), (6, 'UK', 34), (7, 'Canada', 22), (8, 'Canada', 25);\n",
            "Original Answer: UPDATE tourism_data SET arrival_age = 30 WHERE country = 'Japan';\n",
            "Generated Answer: UPDATE tourism_data SET arrival_age = 30 WHERE country = 'japan'\n",
            "Closest Distance: 0.03462090343236923\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE tourism_data (visitor_id INT, country VARCHAR(50), arrival_age INT); INSERT INTO tourism_data (visitor_id, country, arrival_age) VALUES (1, 'USA', 35), (2, 'USA', 42), (3, 'Japan', 28), (4, 'Australia', 31), (5, 'UK', 29), (6, 'UK', 34), (7, 'Canada', 22), (8, 'Canada', 25);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: UPDATE tourism_data SET arrival_age = 30 WHERE country = 'Japan';\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 20\n",
            "Question: How many mining operations are located in 'Canada'?\n",
            "SCHEMA: CREATE TABLE mining_operations (id INT PRIMARY KEY, operation_name VARCHAR(50), location VARCHAR(50), num_employees INT);\n",
            "Original Answer: SELECT COUNT(*) FROM mining_operations WHERE location = 'Canada';\n",
            "Generated Answer: SELECT COUNT(*) FROM mining_operations WHERE location = \"canada\"\n",
            "Closest Distance: 0.022677164524793625\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE mining_operations (id INT PRIMARY KEY, operation_name VARCHAR(50), location VARCHAR(50), num_employees INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM mining_operations WHERE location = 'Canada';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 21\n",
            "Question: What is the total cost of all space missions launched by SpaceX?\n",
            "SCHEMA: CREATE TABLE Missions (MissionID INT, Name VARCHAR(50), Agency VARCHAR(50), Cost INT); INSERT INTO Missions (MissionID, Name, Agency, Cost) VALUES (1, 'Falcon 9', 'SpaceX', 60000000), (2, 'Falcon Heavy', 'SpaceX', 90000000);\n",
            "Original Answer: SELECT SUM(Cost) FROM Missions WHERE Agency = 'SpaceX';\n",
            "Generated Answer: SELECT SUM(Cost) FROM Missions WHERE Agency = 'SpaceX'\n",
            "Closest Distance: 0.021514497697353363\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Missions (MissionID INT, Name VARCHAR(50), Agency VARCHAR(50), Cost INT); INSERT INTO Missions (MissionID, Name, Agency, Cost) VALUES (1, 'Falcon 9', 'SpaceX', 60000000), (2, 'Falcon Heavy', 'SpaceX', 90000000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(Cost) FROM Missions WHERE Agency = 'SpaceX';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(150000000,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 22\n",
            "Question: What is the average soil moisture level for each crop type in the past month?\n",
            "SCHEMA: CREATE TABLE SoilMoistureData (moisture FLOAT, time DATETIME, crop VARCHAR(255));\n",
            "Original Answer: SELECT crop, AVG(moisture) FROM SoilMoistureData WHERE time > DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 MONTH) GROUP BY crop;\n",
            "Generated Answer: SELECT AVG(moisture), time FROM SoilMoistureData WHERE time > DATEADD(MONTH, -1, GETDATE()) AND crop = \"corn\"\n",
            "Closest Distance: 0.25217875838279724\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE SoilMoistureData (moisture FLOAT, time DATETIME, crop VARCHAR(255));\n",
            "Error creating table: type \"datetime\" does not exist\n",
            "LINE 2: ...EATE TABLE SoilMoistureData (moisture FLOAT, time DATETIME, ...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT crop, AVG(moisture) FROM SoilMoistureData WHERE time > DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 MONTH) GROUP BY crop;\n",
            "Database connected successfully\n",
            "Error executing query: syntax error at or near \")\"\n",
            "LINE 1: ...stureData WHERE time > DATE_SUB(CURRENT_TIMESTAMP(), INTERVA...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 23\n",
            "Question: Insert a new record into the \"ocean_pollution\" table with the following data: \"Plastic\", \"Great Pacific Garbage Patch\", 2010\n",
            "SCHEMA: CREATE TABLE ocean_pollution (id INT PRIMARY KEY, pollutant_type VARCHAR(255), location VARCHAR(255), year INT);\n",
            "Original Answer: INSERT INTO ocean_pollution (pollutant_type, location, year) VALUES ('Plastic', 'Great Pacific Garbage Patch', 2010);\n",
            "Generated Answer: INSERT INTO ocean_pollution (pollutant_type, location, year) VALUES (\"Plastic\", \"Great Pacific Garbage Patch\", 2010)\n",
            "Closest Distance: 0.035345837473869324\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE ocean_pollution (id INT PRIMARY KEY, pollutant_type VARCHAR(255), location VARCHAR(255), year INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: INSERT INTO ocean_pollution (pollutant_type, location, year) VALUES ('Plastic', 'Great Pacific Garbage Patch', 2010);\n",
            "Database connected successfully\n",
            "Error executing query: null value in column \"id\" of relation \"ocean_pollution\" violates not-null constraint\n",
            "DETAIL:  Failing row contains (null, Plastic, Great Pacific Garbage Patch, 2010).\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 24\n",
            "Question: List the hotels that have consistently reduced their energy consumption.\n",
            "SCHEMA: CREATE TABLE hotels (hotel_id INT, hotel_name TEXT, city TEXT, country TEXT, energy_consumption FLOAT, year INT); INSERT INTO hotels (hotel_id, hotel_name, city, country, energy_consumption, year) VALUES (1, 'Hotel A', 'Rome', 'Italy', 12000.0, 2021), (1, 'Hotel A', 'Rome', 'Italy', 11000.0, 2022);\n",
            "Original Answer: SELECT hotel_name, energy_consumption FROM (SELECT hotel_name, energy_consumption, energy_consumption - LAG(energy_consumption) OVER (PARTITION BY hotel_name ORDER BY year) as diff FROM hotels) where diff < 0;\n",
            "Generated Answer: SELECT hotel_name FROM hotels GROUP BY hotel_id HAVING MIN(energy_consumption) < MAX(energy_consumption)\n",
            "Closest Distance: 0.5944753289222717\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE hotels (hotel_id INT, hotel_name TEXT, city TEXT, country TEXT, energy_consumption FLOAT, year INT); INSERT INTO hotels (hotel_id, hotel_name, city, country, energy_consumption, year) VALUES (1, 'Hotel A', 'Rome', 'Italy', 12000.0, 2021), (1, 'Hotel A', 'Rome', 'Italy', 11000.0, 2022);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT hotel_name, energy_consumption FROM (SELECT hotel_name, energy_consumption, energy_consumption - LAG(energy_consumption) OVER (PARTITION BY hotel_name ORDER BY year) as diff FROM hotels) where diff < 0;\n",
            "Database connected successfully\n",
            "Error executing query: subquery in FROM must have an alias\n",
            "LINE 1: SELECT hotel_name, energy_consumption FROM (SELECT hotel_nam...\n",
            "                                                   ^\n",
            "HINT:  For example, FROM (SELECT ...) [AS] foo.\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 25\n",
            "Question: What is the average age of females who have voted in the last 3 presidential elections in the state of California?\n",
            "SCHEMA: CREATE TABLE voters (voter_id INT, gender VARCHAR(10), age INT, state VARCHAR(20), election_year INT); INSERT INTO voters (voter_id, gender, age, state, election_year) VALUES (1, 'Female', 35, 'California', 2020), (2, 'Male', 45, 'Texas', 2016), (3, 'Female', 50, 'California', 2016), (4, 'Male', 25, 'California', 2020), (5, 'Female', 40, 'Texas', 2016), (6, 'Female', 30, 'California', 2012); CREATE TABLE elections (election_id INT, election_year INT, state VARCHAR(20)); INSERT INTO elections (election_id, election_year, state) VALUES (1, 2020, 'California'), (2, 2016, 'Texas'), (3, 2016, 'California'), (4, 2020, 'California'), (5, 2012, 'California');\n",
            "Original Answer: SELECT AVG(age) FROM voters JOIN elections ON voters.election_year = elections.election_year WHERE gender = 'Female' AND state = 'California' AND elections.election_year IN (2012, 2016, 2020);\n",
            "Generated Answer: SELECT AVG(t1.age) FROM voters AS t1 JOIN elections AS t2 ON t1.election_year = t2.election_year WHERE t1.gender = 'Female' AND t2.state = 'California' AND t2.election_year IN (2012, 2016, 2020)\n",
            "Closest Distance: 0.058995604515075684\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE voters (voter_id INT, gender VARCHAR(10), age INT, state VARCHAR(20), election_year INT); INSERT INTO voters (voter_id, gender, age, state, election_year) VALUES (1, 'Female', 35, 'California', 2020), (2, 'Male', 45, 'Texas', 2016), (3, 'Female', 50, 'California', 2016), (4, 'Male', 25, 'California', 2020), (5, 'Female', 40, 'Texas', 2016), (6, 'Female', 30, 'California', 2012); CREATE TABLE elections (election_id INT, election_year INT, state VARCHAR(20)); INSERT INTO elections (election_id, election_year, state) VALUES (1, 2020, 'California'), (2, 2016, 'Texas'), (3, 2016, 'California'), (4, 2020, 'California'), (5, 2012, 'California');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(age) FROM voters JOIN elections ON voters.election_year = elections.election_year WHERE gender = 'Female' AND state = 'California' AND elections.election_year IN (2012, 2016, 2020);\n",
            "Database connected successfully\n",
            "Error executing query: column reference \"state\" is ambiguous\n",
            "LINE 1: ...ections.election_year WHERE gender = 'Female' AND state = 'C...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 26\n",
            "Question: What is the number of job applications received from veterans in the HR department?\n",
            "SCHEMA: CREATE TABLE JobApplications (ApplicationID int, Name varchar(50), VeteranStatus varchar(50), Department varchar(50)); INSERT INTO JobApplications (ApplicationID, Name, VeteranStatus, Department) VALUES (1, 'John Doe', 'Yes', 'HR'); INSERT INTO JobApplications (ApplicationID, Name, VeteranStatus, Department) VALUES (2, 'Jane Smith', 'No', 'IT');\n",
            "Original Answer: SELECT COUNT(*) FROM JobApplications WHERE VeteranStatus = 'Yes' AND Department = 'HR';\n",
            "Generated Answer: SELECT COUNT(*) FROM JobApplications WHERE VeteranStatus = \"Yes\" AND Department = \"HR\"\n",
            "Closest Distance: 0.017593197524547577\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE JobApplications (ApplicationID int, Name varchar(50), VeteranStatus varchar(50), Department varchar(50)); INSERT INTO JobApplications (ApplicationID, Name, VeteranStatus, Department) VALUES (1, 'John Doe', 'Yes', 'HR'); INSERT INTO JobApplications (ApplicationID, Name, VeteranStatus, Department) VALUES (2, 'Jane Smith', 'No', 'IT');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM JobApplications WHERE VeteranStatus = 'Yes' AND Department = 'HR';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 27\n",
            "Question: Count the number of explainable AI models developed by each organization and return the TOP 3 organizations with the highest count?\n",
            "SCHEMA: CREATE TABLE ExplainableAI (id INT, model_name VARCHAR(50), organization VARCHAR(50)); INSERT INTO ExplainableAI (id, model_name, organization) VALUES (1, 'LIME', 'Google'), (2, 'SHAP', 'Microsoft'), (3, 'Anchors', 'Uber'), (4, 'TreeExplainer', 'Google'), (5, 'DeepLIFT', 'Microsoft');\n",
            "Original Answer: SELECT organization, COUNT(model_name) as model_count FROM ExplainableAI GROUP BY organization ORDER BY model_count DESC LIMIT 3;\n",
            "Generated Answer: SELECT COUNT(*), organization FROM ExplainableAI GROUP BY organization ORDER BY COUNT(*) DESC LIMIT 3\n",
            "Closest Distance: 0.19043458998203278\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE ExplainableAI (id INT, model_name VARCHAR(50), organization VARCHAR(50)); INSERT INTO ExplainableAI (id, model_name, organization) VALUES (1, 'LIME', 'Google'), (2, 'SHAP', 'Microsoft'), (3, 'Anchors', 'Uber'), (4, 'TreeExplainer', 'Google'), (5, 'DeepLIFT', 'Microsoft');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT organization, COUNT(model_name) as model_count FROM ExplainableAI GROUP BY organization ORDER BY model_count DESC LIMIT 3;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('Microsoft', 2)\n",
            "('Google', 2)\n",
            "('Uber', 1)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 28\n",
            "Question: Identify the well with the lowest production volume in the Gulf of Mexico\n",
            "SCHEMA: CREATE TABLE wells (well_id INT, well_name VARCHAR(50), production_volume FLOAT, location VARCHAR(50)); INSERT INTO wells VALUES (1, 'Well A', 1000, 'Gulf of Mexico'); INSERT INTO wells VALUES (2, 'Well B', 1500, 'Alaska North Slope'); INSERT INTO wells VALUES (3, 'Well C', 1200, 'Gulf of Mexico'); INSERT INTO wells VALUES (4, 'Well D', 800, 'Gulf of Mexico');\n",
            "Original Answer: SELECT well_name, production_volume FROM wells WHERE location = 'Gulf of Mexico' ORDER BY production_volume LIMIT 1;\n",
            "Generated Answer: SELECT well_id FROM wells WHERE production_volume = (SELECT MIN(production_volume) FROM wells WHERE location = 'Gulf of Mexico')\n",
            "Closest Distance: 0.41160473227500916\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE wells (well_id INT, well_name VARCHAR(50), production_volume FLOAT, location VARCHAR(50)); INSERT INTO wells VALUES (1, 'Well A', 1000, 'Gulf of Mexico'); INSERT INTO wells VALUES (2, 'Well B', 1500, 'Alaska North Slope'); INSERT INTO wells VALUES (3, 'Well C', 1200, 'Gulf of Mexico'); INSERT INTO wells VALUES (4, 'Well D', 800, 'Gulf of Mexico');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT well_name, production_volume FROM wells WHERE location = 'Gulf of Mexico' ORDER BY production_volume LIMIT 1;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Well D', 800.0)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 29\n",
            "Question: How many marine protected areas were added in 2020?\n",
            "SCHEMA: CREATE TABLE marine_protected_areas (name TEXT, added_year INTEGER); INSERT INTO marine_protected_areas (name, added_year) VALUES ('Tubbataha Reefs Natural Park', 1988), ('Palau National Marine Sanctuary', 2020), ('Malpelo Fauna and Flora Sanctuary', 1995);\n",
            "Original Answer: SELECT COUNT(*) FROM marine_protected_areas WHERE added_year = 2020;\n",
            "Generated Answer: SELECT COUNT(*) FROM marine_protected_areas WHERE added_year = 2020\n",
            "Closest Distance: 0.01627890206873417\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE marine_protected_areas (name TEXT, added_year INTEGER); INSERT INTO marine_protected_areas (name, added_year) VALUES ('Tubbataha Reefs Natural Park', 1988), ('Palau National Marine Sanctuary', 2020), ('Malpelo Fauna and Flora Sanctuary', 1995);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM marine_protected_areas WHERE added_year = 2020;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 30\n",
            "Question: Find the number of unique users who engaged with posts about 'data privacy' in the post_engagements table in the last month.\n",
            "SCHEMA: CREATE TABLE post_engagements (user_id INT, post_id INT, engagement_date DATE, post_topic VARCHAR(50));\n",
            "Original Answer: SELECT COUNT(DISTINCT user_id) as unique_users FROM post_engagements WHERE post_topic = 'data privacy' AND engagement_date >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH);\n",
            "Generated Answer: SELECT COUNT(DISTINCT user_id) FROM post_engagements WHERE engagement_date >= DATE(NOW) - INTERVAL 1 MONTH AND post_topic = 'data privacy'\n",
            "Closest Distance: 0.14528240263462067\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE post_engagements (user_id INT, post_id INT, engagement_date DATE, post_topic VARCHAR(50));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(DISTINCT user_id) as unique_users FROM post_engagements WHERE post_topic = 'data privacy' AND engagement_date >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH);\n",
            "Database connected successfully\n",
            "Error executing query: syntax error at or near \"1\"\n",
            "LINE 1: ...ND engagement_date >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH);\n",
            "                                                              ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 31\n",
            "Question: List the total number of accidents in each year?\n",
            "SCHEMA: CREATE TABLE AccidentYears (YearID int, Year int); CREATE TABLE AccidentReports (ReportID int, AccidentYearID int, AccidentDate date); INSERT INTO AccidentYears VALUES (1, 2010), (2, 2011), (3, 2012), (4, 2015), (5, 2019); INSERT INTO AccidentReports VALUES (1, 1, '2010-01-01'), (2, 1, '2011-05-15'), (3, 3, '2012-03-12'), (4, 4, '2015-06-18'), (5, 5, '2019-08-05');\n",
            "Original Answer: SELECT ay.Year, COUNT(ar.ReportID) as TotalAccidents FROM AccidentYears ay INNER JOIN AccidentReports ar ON ay.YearID = ar.AccidentYearID GROUP BY ay.Year;\n",
            "Generated Answer: SELECT COUNT(*), Year FROM AccidentYears JOIN AccidentReports ON AccidentReports.AccidentYearID = AccidentYears.YearID GROUP BY Year\n",
            "Closest Distance: 0.1418582648038864\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE AccidentYears (YearID int, Year int); CREATE TABLE AccidentReports (ReportID int, AccidentYearID int, AccidentDate date); INSERT INTO AccidentYears VALUES (1, 2010), (2, 2011), (3, 2012), (4, 2015), (5, 2019); INSERT INTO AccidentReports VALUES (1, 1, '2010-01-01'), (2, 1, '2011-05-15'), (3, 3, '2012-03-12'), (4, 4, '2015-06-18'), (5, 5, '2019-08-05');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT ay.Year, COUNT(ar.ReportID) as TotalAccidents FROM AccidentYears ay INNER JOIN AccidentReports ar ON ay.YearID = ar.AccidentYearID GROUP BY ay.Year;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 4 \n",
            "\n",
            "(2012, 1)\n",
            "(2015, 1)\n",
            "(2010, 2)\n",
            "(2019, 1)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 32\n",
            "Question: Which artists earned more than $50,000 in concert ticket sales?\n",
            "SCHEMA: CREATE TABLE Artists (ArtistID INT, Name VARCHAR(100), Genre VARCHAR(50));\n",
            "Original Answer: SELECT A.Name, SUM(T.Price) as TotalEarnings FROM Artists A INNER JOIN Concerts C ON A.ArtistID = C.ArtistID INNER JOIN Tickets T ON C.ConcertID = T.ConcertID GROUP BY A.Name HAVING TotalEarnings > 50000;\n",
            "Generated Answer: SELECT ArtistID, Name FROM Artists WHERE Genre = \"rock\" OR ConcertTicketSales > 50000\n",
            "Closest Distance: 0.4464685022830963\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Artists (ArtistID INT, Name VARCHAR(100), Genre VARCHAR(50));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT A.Name, SUM(T.Price) as TotalEarnings FROM Artists A INNER JOIN Concerts C ON A.ArtistID = C.ArtistID INNER JOIN Tickets T ON C.ConcertID = T.ConcertID GROUP BY A.Name HAVING TotalEarnings > 50000;\n",
            "Database connected successfully\n",
            "Error executing query: relation \"concerts\" does not exist\n",
            "LINE 1: ...Price) as TotalEarnings FROM Artists A INNER JOIN Concerts C...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 33\n",
            "Question: Find the maximum ticket price for pop concerts.\n",
            "SCHEMA: CREATE TABLE ConcertTickets (ticket_id INT, genre VARCHAR(20), price DECIMAL(5,2));\n",
            "Original Answer: SELECT MAX(price) FROM ConcertTickets WHERE genre = 'pop';\n",
            "Generated Answer: SELECT MAX(ticket_id), MAX(price) FROM ConcertTickets WHERE genre = \"pop\"\n",
            "Closest Distance: 0.09997956454753876\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE ConcertTickets (ticket_id INT, genre VARCHAR(20), price DECIMAL(5,2));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MAX(price) FROM ConcertTickets WHERE genre = 'pop';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(None,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 34\n",
            "Question: Show the total energy consumption and total energy savings for each renewable energy project type, for projects in California.\n",
            "SCHEMA: CREATE TABLE RenewableEnergyProjectTypes (TypeID INT, TypeName VARCHAR(50));CREATE TABLE RenewableEnergyProjects (ProjectID INT, TypeID INT, EnergyConsumption FLOAT, EnergySavings FLOAT, State VARCHAR(2));\n",
            "Original Answer: SELECT RenewableEnergyProjectTypes.TypeName, SUM(RenewableEnergyProjects.EnergyConsumption) AS TotalEnergyConsumption, SUM(RenewableEnergyProjects.EnergySavings) AS TotalEnergySavings FROM RenewableEnergyProjectTypes INNER JOIN RenewableEnergyProjects ON RenewableEnergyProjectTypes.TypeID = RenewableEnergyProjects.TypeID WHERE RenewableEnergyProjects.State = 'CA' GROUP BY RenewableEnergyProjectTypes.TypeName;\n",
            "Generated Answer: SELECT COUNT(SUM(T1.EnergyConsumption)), COUNT(SUM(T1.EnergySavings)) FROM RenewableEnergyProjectTypes AS T1 JOIN RenewableEnergyProjects AS T2 ON T1.TypeID = T2.TypeID JOIN State AS T3 ON T2.State = T3.State WHERE T3.State = \"California\"\n",
            "Closest Distance: 0.33024367690086365\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE RenewableEnergyProjectTypes (TypeID INT, TypeName VARCHAR(50));CREATE TABLE RenewableEnergyProjects (ProjectID INT, TypeID INT, EnergyConsumption FLOAT, EnergySavings FLOAT, State VARCHAR(2));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT RenewableEnergyProjectTypes.TypeName, SUM(RenewableEnergyProjects.EnergyConsumption) AS TotalEnergyConsumption, SUM(RenewableEnergyProjects.EnergySavings) AS TotalEnergySavings FROM RenewableEnergyProjectTypes INNER JOIN RenewableEnergyProjects ON RenewableEnergyProjectTypes.TypeID = RenewableEnergyProjects.TypeID WHERE RenewableEnergyProjects.State = 'CA' GROUP BY RenewableEnergyProjectTypes.TypeName;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 35\n",
            "Question: What is the average quantity of vegetarian dishes sold per order?\n",
            "SCHEMA: CREATE TABLE menu (menu_id INT, name VARCHAR(50), category VARCHAR(50), price DECIMAL(5,2)); INSERT INTO menu (menu_id, name, category, price) VALUES (1, 'Spaghetti Marinara', 'Pasta', 11.99), (2, 'Vegetable Stir Fry', 'Entree', 13.99), (3, 'Caesar Salad', 'Salad', 9.99); CREATE TABLE orders (order_id INT, order_date DATE, menu_id INT, quantity INT); INSERT INTO orders (order_id, order_date, menu_id, quantity) VALUES (1, '2022-01-03', 1, 3), (2, '2022-01-03', 2, 2), (3, '2022-01-05', 3, 1);\n",
            "Original Answer: SELECT AVG(orders.quantity) FROM orders JOIN menu ON orders.menu_id = menu.menu_id WHERE menu.category = 'Vegetarian';\n",
            "Generated Answer: SELECT AVG(quantity) FROM orders AS T1 JOIN menu AS T2 ON T1.menu_id = T2.menu_id WHERE T2.category = 'Vegetable'\n",
            "Closest Distance: 0.09367476403713226\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE menu (menu_id INT, name VARCHAR(50), category VARCHAR(50), price DECIMAL(5,2)); INSERT INTO menu (menu_id, name, category, price) VALUES (1, 'Spaghetti Marinara', 'Pasta', 11.99), (2, 'Vegetable Stir Fry', 'Entree', 13.99), (3, 'Caesar Salad', 'Salad', 9.99); CREATE TABLE orders (order_id INT, order_date DATE, menu_id INT, quantity INT); INSERT INTO orders (order_id, order_date, menu_id, quantity) VALUES (1, '2022-01-03', 1, 3), (2, '2022-01-03', 2, 2), (3, '2022-01-05', 3, 1);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(orders.quantity) FROM orders JOIN menu ON orders.menu_id = menu.menu_id WHERE menu.category = 'Vegetarian';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(None,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 36\n",
            "Question: What is the technology with the highest adoption rate in each city in Spain?\n",
            "SCHEMA: CREATE TABLE smart_cities (id INT, city VARCHAR(255), country VARCHAR(255), technology VARCHAR(255), adoption_rate DECIMAL(5,4)); INSERT INTO smart_cities (id, city, country, technology, adoption_rate) VALUES (1, 'Barcelona', 'Spain', 'Smart Lighting', 0.75);\n",
            "Original Answer: SELECT city, technology, MAX(adoption_rate) as max_adoption_rate FROM smart_cities WHERE country = 'Spain' GROUP BY city, technology;\n",
            "Generated Answer: SELECT technology FROM smart_cities WHERE country ='spain' ORDER BY adoption_rate DESC LIMIT 1\n",
            "Closest Distance: 0.3579321801662445\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE smart_cities (id INT, city VARCHAR(255), country VARCHAR(255), technology VARCHAR(255), adoption_rate DECIMAL(5,4)); INSERT INTO smart_cities (id, city, country, technology, adoption_rate) VALUES (1, 'Barcelona', 'Spain', 'Smart Lighting', 0.75);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT city, technology, MAX(adoption_rate) as max_adoption_rate FROM smart_cities WHERE country = 'Spain' GROUP BY city, technology;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Barcelona', 'Smart Lighting', Decimal('0.7500'))\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 37\n",
            "Question: Display the total number of properties and the total area in square meters for each city in the 'Cities' table.\n",
            "SCHEMA: CREATE TABLE cities (id INT, name VARCHAR(255), num_properties INT, total_area INT); INSERT INTO cities (id, name, num_properties, total_area) VALUES (1, 'San Francisco', 1000, 120000), (2, 'Oakland', 800, 90000), (3, 'Berkeley', 500, 75000);\n",
            "Original Answer: SELECT name, SUM(num_properties), SUM(total_area) FROM cities GROUP BY name;\n",
            "Generated Answer: SELECT COUNT(*), num_properties, TOTAL_AREA FROM cities GROUP BY name\n",
            "Closest Distance: 0.8428295850753784\n",
            "NO MATCH\n",
            "\n",
            "Evaluating sample: 38\n",
            "Question: Show the daily production volume of the 'Mining Operations' division, grouped by the mine's location.\n",
            "SCHEMA: CREATE TABLE daily_production (mine_id INT, division TEXT, location TEXT, production_volume INT); INSERT INTO daily_production (mine_id, division, location, production_volume) VALUES (1, 'Mining Operations', 'Wyoming, USA', 500), (2, 'Mining Operations', 'Montana, USA', 450), (3, 'Mining Operations', 'Idaho, USA', 400), (4, 'Mining Operations', 'Utah, USA', 350), (5, 'Mining Operations', 'Nevada, USA', 300);\n",
            "Original Answer: SELECT location, SUM(production_volume) as total_daily_production FROM daily_production WHERE division = 'Mining Operations' GROUP BY location;\n",
            "Generated Answer: SELECT location, SUM(production_volume) FROM daily_production WHERE division = 'Mining Operations' GROUP BY location\n",
            "Closest Distance: 0.06009873002767563\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE daily_production (mine_id INT, division TEXT, location TEXT, production_volume INT); INSERT INTO daily_production (mine_id, division, location, production_volume) VALUES (1, 'Mining Operations', 'Wyoming, USA', 500), (2, 'Mining Operations', 'Montana, USA', 450), (3, 'Mining Operations', 'Idaho, USA', 400), (4, 'Mining Operations', 'Utah, USA', 350), (5, 'Mining Operations', 'Nevada, USA', 300);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT location, SUM(production_volume) as total_daily_production FROM daily_production WHERE division = 'Mining Operations' GROUP BY location;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 5 \n",
            "\n",
            "('Idaho, USA', 400)\n",
            "('Montana, USA', 450)\n",
            "('Nevada, USA', 300)\n",
            "('Utah, USA', 350)\n",
            "('Wyoming, USA', 500)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 39\n",
            "Question: List the number of investments in startups founded by veterans in the biotech industry since 2015.\n",
            "SCHEMA: CREATE TABLE investment (id INT, company_id INT, investment_date DATE, investment_amount INT); INSERT INTO investment (id, company_id, investment_date, investment_amount) VALUES (1, 1, '2016-01-01', 500000);\n",
            "Original Answer: SELECT COUNT(*) FROM investment INNER JOIN company ON investment.company_id = company.id WHERE company.industry = 'Biotech' AND company.founder_gender = 'Veteran' AND investment_date >= '2015-01-01';\n",
            "Generated Answer: SELECT COUNT(*) FROM investment AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN company_type AS T3 ON T2.company_type_code = T3.company_type_code JOIN industry AS T4 ON T3.industry_code = T4.industry_code JOIN investment_type AS T5 ON T1.investment_type_code = T5.investment_type_code JOIN company_stage AS T6 ON T2.company_stage_code = T6.company_stage_code JOIN industry AS T7 ON T4.industry_id = T7.industry_id JOIN company_stage AS T8 ON T6.company_stage_code = T8.company_stage_code WHERE T4.industry_name = \"biotechnology\" AND T8.company_stage_name = \"startup\" AND T5.investment_type_name = \"equity\" AND T1.investment_date > 2015 AND T2.company_founded_by_veteran\n",
            "Closest Distance: 0.23995588719844818\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE investment (id INT, company_id INT, investment_date DATE, investment_amount INT); INSERT INTO investment (id, company_id, investment_date, investment_amount) VALUES (1, 1, '2016-01-01', 500000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM investment INNER JOIN company ON investment.company_id = company.id WHERE company.industry = 'Biotech' AND company.founder_gender = 'Veteran' AND investment_date >= '2015-01-01';\n",
            "Database connected successfully\n",
            "Error executing query: column company.industry does not exist\n",
            "LINE 1: ...mpany ON investment.company_id = company.id WHERE company.in...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 40\n",
            "Question: Which are the names of all museums that have hosted exhibitions with more than 50 pieces of art?\n",
            "SCHEMA: CREATE TABLE museums (museum_id INT, name VARCHAR(50), city VARCHAR(50), opening_year INT); INSERT INTO museums (museum_id, name, city, opening_year) VALUES (1, 'Metropolitan Museum of Art', 'New York', 1870); CREATE TABLE exhibitions (exhibition_id INT, title VARCHAR(50), year INT, museum_id INT, art_count INT); INSERT INTO exhibitions (exhibition_id, title, year, museum_id, art_count) VALUES (1, 'First Exhibition', 1871, 1, 100);\n",
            "Original Answer: SELECT m.name FROM museums m INNER JOIN exhibitions e ON m.museum_id = e.museum_id WHERE e.art_count > 50;\n",
            "Generated Answer: SELECT name FROM museums JOIN exhibitions ON museums.museum_id = exhibitions.museum_id WHERE art_count > 50\n",
            "Closest Distance: 0.09968919306993484\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE museums (museum_id INT, name VARCHAR(50), city VARCHAR(50), opening_year INT); INSERT INTO museums (museum_id, name, city, opening_year) VALUES (1, 'Metropolitan Museum of Art', 'New York', 1870); CREATE TABLE exhibitions (exhibition_id INT, title VARCHAR(50), year INT, museum_id INT, art_count INT); INSERT INTO exhibitions (exhibition_id, title, year, museum_id, art_count) VALUES (1, 'First Exhibition', 1871, 1, 100);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT m.name FROM museums m INNER JOIN exhibitions e ON m.museum_id = e.museum_id WHERE e.art_count > 50;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Metropolitan Museum of Art',)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 41\n",
            "Question: What is the maximum budget allocated for criminal justice reform initiatives in Michigan in a single year?\n",
            "SCHEMA: CREATE TABLE criminal_justice_reform_initiatives (initiative_id INT, year INT, budget INT, state VARCHAR(20)); INSERT INTO criminal_justice_reform_initiatives (initiative_id, year, budget, state) VALUES (1, 2022, 5000000, 'Michigan'), (2, 2021, 6000000, 'Michigan'), (3, 2020, 7000000, 'Michigan'), (4, 2019, 8000000, 'Michigan'), (5, 2018, 9000000, 'Michigan');\n",
            "Original Answer: SELECT MAX(budget) FROM criminal_justice_reform_initiatives WHERE year >= 2018 AND state = 'Michigan';\n",
            "Generated Answer: SELECT MAX(budget) FROM criminal_justice_reform_initiatives WHERE state = 'Michigan'\n",
            "Closest Distance: 0.10969177633523941\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE criminal_justice_reform_initiatives (initiative_id INT, year INT, budget INT, state VARCHAR(20)); INSERT INTO criminal_justice_reform_initiatives (initiative_id, year, budget, state) VALUES (1, 2022, 5000000, 'Michigan'), (2, 2021, 6000000, 'Michigan'), (3, 2020, 7000000, 'Michigan'), (4, 2019, 8000000, 'Michigan'), (5, 2018, 9000000, 'Michigan');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MAX(budget) FROM criminal_justice_reform_initiatives WHERE year >= 2018 AND state = 'Michigan';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(9000000,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 42\n",
            "Question: How many vessels are there in the container ship category?\n",
            "SCHEMA: CREATE TABLE vessels (id INT PRIMARY KEY, name VARCHAR(50), type VARCHAR(50), length FLOAT, year_built INT);\n",
            "Original Answer: SELECT COUNT(*) FROM vessels WHERE type = 'Container Ship';\n",
            "Generated Answer: SELECT COUNT(*) FROM vessels WHERE type = \"container ship\" AND length > 100 AND year_built > 1989\n",
            "Closest Distance: 0.20258454978466034\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE vessels (id INT PRIMARY KEY, name VARCHAR(50), type VARCHAR(50), length FLOAT, year_built INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM vessels WHERE type = 'Container Ship';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 43\n",
            "Question: Insert a new record for a threat intelligence metric with ID 3, name 'Cyber Attacks', and value 150\n",
            "SCHEMA: CREATE TABLE threat_intelligence (id INT, name VARCHAR(50), value INT);\n",
            "Original Answer: INSERT INTO threat_intelligence (id, name, value) VALUES (3, 'Cyber Attacks', 150);\n",
            "Generated Answer: INSERT INTO threat_intelligence (id, name, value) VALUES (3, \"Cyber Attacks\", 150)\n",
            "Closest Distance: 0.025179628282785416\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE threat_intelligence (id INT, name VARCHAR(50), value INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: INSERT INTO threat_intelligence (id, name, value) VALUES (3, 'Cyber Attacks', 150);\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 44\n",
            "Question: What is the total number of trips taken on public transportation in Paris, France?\n",
            "SCHEMA: CREATE TABLE public_transportation_trips (trip_id INT, transportation_id INT, city VARCHAR(50), date DATE);\n",
            "Original Answer: SELECT COUNT(*) FROM public_transportation_trips WHERE city = 'Paris';\n",
            "Generated Answer: SELECT COUNT(*) FROM public_transportation_trips WHERE city = \"Paris, France\" AND date > 2009\n",
            "Closest Distance: 0.16278481483459473\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE public_transportation_trips (trip_id INT, transportation_id INT, city VARCHAR(50), date DATE);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM public_transportation_trips WHERE city = 'Paris';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 45\n",
            "Question: What is the average biomass of humpback whales in all oceans?\n",
            "SCHEMA: CREATE TABLE whale_biomass (species TEXT, location TEXT, biomass INTEGER); INSERT INTO whale_biomass (species, location, biomass) VALUES ('Blue Whale', 'Atlantic', 300000), ('Humpback Whale', 'Atlantic', 80000), ('Blue Whale', 'Pacific', 250000), ('Humpback Whale', 'Pacific', 90000), ('Blue Whale', 'Indian', 200000), ('Humpback Whale', 'Indian', 70000);\n",
            "Original Answer: SELECT AVG(biomass) FROM whale_biomass WHERE species = 'Humpback Whale';\n",
            "Generated Answer: SELECT AVG(biomass) FROM whale_biomass WHERE species = 'Humpback Whale'\n",
            "Closest Distance: 0.0356934517621994\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE whale_biomass (species TEXT, location TEXT, biomass INTEGER); INSERT INTO whale_biomass (species, location, biomass) VALUES ('Blue Whale', 'Atlantic', 300000), ('Humpback Whale', 'Atlantic', 80000), ('Blue Whale', 'Pacific', 250000), ('Humpback Whale', 'Pacific', 90000), ('Blue Whale', 'Indian', 200000), ('Humpback Whale', 'Indian', 70000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(biomass) FROM whale_biomass WHERE species = 'Humpback Whale';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('80000.000000000000'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 46\n",
            "Question: What is the total revenue generated by each product category in the last month?\n",
            "SCHEMA: CREATE TABLE Sales (SaleID INT, ProductCategory VARCHAR(255), SaleDate DATE); CREATE TABLE Revenue (RevenueID INT, SaleID INT, Amount DECIMAL(10,2)); INSERT INTO Sales (SaleID, ProductCategory, SaleDate) VALUES (1, 'Flower', '2022-01-01'), (2, 'Concentrates', '2022-01-05'), (3, 'Edibles', '2022-01-10'); INSERT INTO Revenue (RevenueID, SaleID, Amount) VALUES (1, 1, 50.00), (2, 1, 75.00), (3, 2, 100.00), (4, 3, 200.00);\n",
            "Original Answer: SELECT ProductCategory, SUM(Amount) AS TotalRevenue FROM Sales JOIN Revenue ON Sales.SaleID = Revenue.SaleID WHERE SaleDate >= DATEADD(MONTH, -1, GETDATE()) GROUP BY ProductCategory;\n",
            "Generated Answer: SELECT SUM(R.Amount) FROM Revenue AS R JOIN Sales AS S ON R.SaleID = S.SaleID WHERE S.SaleDate = '2022-01-31' GROUP BY S.ProductCategory\n",
            "Closest Distance: 0.2712961435317993\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Sales (SaleID INT, ProductCategory VARCHAR(255), SaleDate DATE); CREATE TABLE Revenue (RevenueID INT, SaleID INT, Amount DECIMAL(10,2)); INSERT INTO Sales (SaleID, ProductCategory, SaleDate) VALUES (1, 'Flower', '2022-01-01'), (2, 'Concentrates', '2022-01-05'), (3, 'Edibles', '2022-01-10'); INSERT INTO Revenue (RevenueID, SaleID, Amount) VALUES (1, 1, 50.00), (2, 1, 75.00), (3, 2, 100.00), (4, 3, 200.00);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT ProductCategory, SUM(Amount) AS TotalRevenue FROM Sales JOIN Revenue ON Sales.SaleID = Revenue.SaleID WHERE SaleDate >= DATEADD(MONTH, -1, GETDATE()) GROUP BY ProductCategory;\n",
            "Database connected successfully\n",
            "Error executing query: column \"month\" does not exist\n",
            "LINE 1: ...SaleID = Revenue.SaleID WHERE SaleDate >= DATEADD(MONTH, -1,...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 47\n",
            "Question: What is the minimum property price per square meter for properties in the green_suburbs table?\n",
            "SCHEMA: CREATE TABLE green_suburbs (id INT, property_price FLOAT, size INT); INSERT INTO green_suburbs (id, property_price, size) VALUES (1, 400000, 100), (2, 500000, 120), (3, 600000, 150);\n",
            "Original Answer: SELECT MIN(property_price/size) FROM green_suburbs;\n",
            "Generated Answer: SELECT MIN(property_price) FROM green_suburbs / 100\n",
            "Closest Distance: 0.144636869430542\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE green_suburbs (id INT, property_price FLOAT, size INT); INSERT INTO green_suburbs (id, property_price, size) VALUES (1, 400000, 100), (2, 500000, 120), (3, 600000, 150);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MIN(property_price/size) FROM green_suburbs;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(4000.0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 48\n",
            "Question: Find the average warehouse management costs for the Chicago and New York warehouses in Q1 2023?\n",
            "SCHEMA: CREATE TABLE warehouse_costs (warehouse_id INT, warehouse_location VARCHAR(255), cost DECIMAL(10,2), quarter INT, year INT); INSERT INTO warehouse_costs (warehouse_id, warehouse_location, cost, quarter, year) VALUES (1, 'NYC Warehouse', 2800.00, 1, 2023), (2, 'LA Warehouse', 3200.00, 1, 2023), (3, 'CHI Warehouse', 2200.00, 1, 2023);\n",
            "Original Answer: SELECT warehouse_location, AVG(cost) as avg_cost FROM warehouse_costs WHERE warehouse_location IN ('NYC Warehouse', 'CHI Warehouse') AND quarter = 1 AND year = 2023 GROUP BY warehouse_location;\n",
            "Generated Answer: SELECT AVG(cost) FROM warehouse_costs WHERE warehouse_location = \"CHI Warehouse\" OR warehouse_location = \"NYC Warehouse\" AND quarter = 1 AND year = 2023\n",
            "Closest Distance: 0.26649749279022217\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE warehouse_costs (warehouse_id INT, warehouse_location VARCHAR(255), cost DECIMAL(10,2), quarter INT, year INT); INSERT INTO warehouse_costs (warehouse_id, warehouse_location, cost, quarter, year) VALUES (1, 'NYC Warehouse', 2800.00, 1, 2023), (2, 'LA Warehouse', 3200.00, 1, 2023), (3, 'CHI Warehouse', 2200.00, 1, 2023);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT warehouse_location, AVG(cost) as avg_cost FROM warehouse_costs WHERE warehouse_location IN ('NYC Warehouse', 'CHI Warehouse') AND quarter = 1 AND year = 2023 GROUP BY warehouse_location;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 2 \n",
            "\n",
            "('CHI Warehouse', Decimal('2200.0000000000000000'))\n",
            "('NYC Warehouse', Decimal('2800.0000000000000000'))\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 49\n",
            "Question: What is the average consumer preference score for products sourced from each country?\n",
            "SCHEMA: CREATE TABLE products_sourcing (id INT, product_name TEXT, consumer_preference FLOAT, sourcing_country TEXT); INSERT INTO products_sourcing (id, product_name, consumer_preference, sourcing_country) VALUES (1, 'Lotion', 4.3, 'USA'), (2, 'Shampoo', 4.1, 'Canada'), (3, 'Soap', 4.6, 'Germany');\n",
            "Original Answer: SELECT sourcing_country, AVG(consumer_preference) FROM products_sourcing GROUP BY sourcing_country;\n",
            "Generated Answer: SELECT AVG(consumer_preference), sourcing_country FROM products_sourcing GROUP BY sourcing_country\n",
            "Closest Distance: 0.07298785448074341\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE products_sourcing (id INT, product_name TEXT, consumer_preference FLOAT, sourcing_country TEXT); INSERT INTO products_sourcing (id, product_name, consumer_preference, sourcing_country) VALUES (1, 'Lotion', 4.3, 'USA'), (2, 'Shampoo', 4.1, 'Canada'), (3, 'Soap', 4.6, 'Germany');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT sourcing_country, AVG(consumer_preference) FROM products_sourcing GROUP BY sourcing_country;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('USA', 4.3)\n",
            "('Germany', 4.6)\n",
            "('Canada', 4.1)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 50\n",
            "Question: What is the minimum time between bus cleanings for each route?\n",
            "SCHEMA: CREATE TABLE buses (id INT, route_id INT, clean_date DATE); INSERT INTO buses (id, route_id, clean_date) VALUES (1, 101, '2022-01-01'), (2, 102, '2022-01-02'), (3, 103, '2022-01-03');\n",
            "Original Answer: SELECT route_id, MIN(DATEDIFF('day', LAG(clean_date) OVER (PARTITION BY route_id ORDER BY clean_date), clean_date)) FROM buses GROUP BY route_id;\n",
            "Generated Answer: SELECT MIN(t2.clean_date - t1.clean_date) FROM buses AS t1 JOIN buses AS t2 ON t1.route_id = t2.route_id\n",
            "Closest Distance: 0.33899736404418945\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE buses (id INT, route_id INT, clean_date DATE); INSERT INTO buses (id, route_id, clean_date) VALUES (1, 101, '2022-01-01'), (2, 102, '2022-01-02'), (3, 103, '2022-01-03');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT route_id, MIN(DATEDIFF('day', LAG(clean_date) OVER (PARTITION BY route_id ORDER BY clean_date), clean_date)) FROM buses GROUP BY route_id;\n",
            "Database connected successfully\n",
            "Error executing query: function datediff(unknown, date, date) does not exist\n",
            "LINE 1: SELECT route_id, MIN(DATEDIFF('day', LAG(clean_date) OVER (P...\n",
            "                             ^\n",
            "HINT:  No function matches the given name and argument types. You might need to add explicit type casts.\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 51\n",
            "Question: Percentage of citizens who have completed higher education in each European country.\n",
            "SCHEMA: CREATE TABLE education (id INT, country VARCHAR(50), citizens INT, higher_education BOOLEAN); INSERT INTO education (id, country, citizens, higher_education) VALUES (1, 'Norway', 5200000, true), (2, 'Switzerland', 8000000, true), (3, 'Luxembourg', 600000, true), (4, 'Ireland', 4800000, true), (5, 'Denmark', 5600000, true), (6, 'Finland', 5400000, true), (7, 'Sweden', 10000000, true);\n",
            "Original Answer: SELECT country, 100.0 * SUM(CASE WHEN higher_education = true THEN citizens ELSE 0 END) / SUM(citizens) AS percentage FROM education GROUP BY country;\n",
            "Generated Answer: SELECT country FROM education GROUP BY country ORDER BY citizens DESC LIMIT 7\n",
            "Closest Distance: 0.9238224029541016\n",
            "NO MATCH\n",
            "\n",
            "Evaluating sample: 52\n",
            "Question: What is the maximum salary of developers who work on machine learning projects?\n",
            "SCHEMA: CREATE TABLE developers (id INT, name VARCHAR(50), salary FLOAT, project VARCHAR(50));   INSERT INTO developers (id, name, salary, project) VALUES (1, 'Alice', 80000.0, 'Machine Learning');   INSERT INTO developers (id, name, salary, project) VALUES (2, 'Bob', 85000.0, 'Machine Learning');\n",
            "Original Answer: SELECT MAX(salary) FROM developers WHERE project = 'Machine Learning';\n",
            "Generated Answer: SELECT MAX(salary) FROM developers WHERE project = 'Machine Learning'\n",
            "Closest Distance: 0.03253801167011261\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE developers (id INT, name VARCHAR(50), salary FLOAT, project VARCHAR(50));   INSERT INTO developers (id, name, salary, project) VALUES (1, 'Alice', 80000.0, 'Machine Learning');   INSERT INTO developers (id, name, salary, project) VALUES (2, 'Bob', 85000.0, 'Machine Learning');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MAX(salary) FROM developers WHERE project = 'Machine Learning';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(85000.0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 53\n",
            "Question: Display union_name and position for employees in the 'employees' table who are members of unions with names starting with 'F'\n",
            "SCHEMA: CREATE TABLE labor_unions (id INT, union_name VARCHAR(50), members INT); CREATE TABLE employees (id INT, union_id INT, name VARCHAR(50), position VARCHAR(50));\n",
            "Original Answer: SELECT e.name, e.position, l.union_name FROM employees e JOIN labor_unions l ON e.union_id = l.id WHERE l.union_name LIKE 'F%';\n",
            "Generated Answer: SELECT T2.union_name, T1.position FROM employees AS T1 JOIN labor_unions AS T2 ON T1.union_id = T2.id WHERE T2.union_name LIKE 'F%'\n",
            "Closest Distance: 0.03952600061893463\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE labor_unions (id INT, union_name VARCHAR(50), members INT); CREATE TABLE employees (id INT, union_id INT, name VARCHAR(50), position VARCHAR(50));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT e.name, e.position, l.union_name FROM employees e JOIN labor_unions l ON e.union_id = l.id WHERE l.union_name LIKE 'F%';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 54\n",
            "Question: Which community development programs had the highest budget in 2020?\n",
            "SCHEMA: CREATE TABLE CommunityDevelopment (id INT, program VARCHAR(20), budget FLOAT, year INT); INSERT INTO CommunityDevelopment (id, program, budget, year) VALUES (1, 'Youth Empowerment', 120000, 2020), (2, 'Women Empowerment', 150000, 2019), (3, 'Elderly Care', 180000, 2018), (4, 'Rural Education', 200000, 2017), (5, 'Youth Empowerment', 250000, 2021);\n",
            "Original Answer: SELECT program, MAX(budget) FROM CommunityDevelopment WHERE year = 2020 GROUP BY program;\n",
            "Generated Answer: SELECT program FROM CommunityDevelopment WHERE budget = (SELECT MAX(budget) FROM CommunityDevelopment WHERE year = 2020)\n",
            "Closest Distance: 0.1953073889017105\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE CommunityDevelopment (id INT, program VARCHAR(20), budget FLOAT, year INT); INSERT INTO CommunityDevelopment (id, program, budget, year) VALUES (1, 'Youth Empowerment', 120000, 2020), (2, 'Women Empowerment', 150000, 2019), (3, 'Elderly Care', 180000, 2018), (4, 'Rural Education', 200000, 2017), (5, 'Youth Empowerment', 250000, 2021);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT program, MAX(budget) FROM CommunityDevelopment WHERE year = 2020 GROUP BY program;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Youth Empowerment', 120000.0)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 55\n",
            "Question: Show network infrastructure investments for the month of May 2022.\n",
            "SCHEMA: CREATE TABLE network_investments_2022 (investment_id INT, investment_date DATE, investment_amount FLOAT); INSERT INTO network_investments_2022 (investment_id, investment_date, investment_amount) VALUES (15, '2022-05-03', 80000); INSERT INTO network_investments_2022 (investment_id, investment_date, investment_amount) VALUES (16, '2022-05-18', 95000);\n",
            "Original Answer: SELECT * FROM network_investments_2022 WHERE investment_date BETWEEN '2022-05-01' AND '2022-05-31';\n",
            "Generated Answer: SELECT * FROM network_investments_2022 WHERE investment_date LIKE '2022-05-%'\n",
            "Closest Distance: 0.3371145725250244\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE network_investments_2022 (investment_id INT, investment_date DATE, investment_amount FLOAT); INSERT INTO network_investments_2022 (investment_id, investment_date, investment_amount) VALUES (15, '2022-05-03', 80000); INSERT INTO network_investments_2022 (investment_id, investment_date, investment_amount) VALUES (16, '2022-05-18', 95000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT * FROM network_investments_2022 WHERE investment_date BETWEEN '2022-05-01' AND '2022-05-31';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 2 \n",
            "\n",
            "(15, datetime.date(2022, 5, 3), 80000.0)\n",
            "(16, datetime.date(2022, 5, 18), 95000.0)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 56\n",
            "Question: How many containers were shipped from the Port of Oakland to Canada in the first quarter of 2022?\n",
            "SCHEMA: CREATE TABLE Port (port_id INT, port_name TEXT, country TEXT); INSERT INTO Port (port_id, port_name, country) VALUES (1, 'Port of Shanghai', 'China'); INSERT INTO Port (port_id, port_name, country) VALUES (2, 'Port of Singapore', 'Singapore'); INSERT INTO Port (port_id, port_name, country) VALUES (3, 'Port of Oakland', 'USA'); CREATE TABLE Shipment (shipment_id INT, container_id INT, port_id INT, shipping_date DATE); CREATE TABLE Container (container_id INT, weight FLOAT);\n",
            "Original Answer: SELECT COUNT(*) FROM Container c JOIN Shipment s ON c.container_id = s.container_id JOIN Port p ON s.port_id = p.port_id WHERE p.port_name = 'Port of Oakland' AND c.container_id IN (SELECT container_id FROM Shipment WHERE shipping_date >= '2022-01-01' AND shipping_date < '2022-04-01' AND port_id IN (SELECT port_id FROM Port WHERE country = 'Canada'));\n",
            "Generated Answer: SELECT COUNT(DISTINCT T2.container_id) FROM Container AS T1 JOIN Shipment AS T2 ON T1.container_id = T2.container_id JOIN Port AS T3 ON T2.port_id = T3.port_id WHERE T2.shipping_date BETWEEN '2022-01-01' AND '2022-03-31' AND T3.country = 'Canada'\n",
            "Closest Distance: 0.11889077723026276\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Port (port_id INT, port_name TEXT, country TEXT); INSERT INTO Port (port_id, port_name, country) VALUES (1, 'Port of Shanghai', 'China'); INSERT INTO Port (port_id, port_name, country) VALUES (2, 'Port of Singapore', 'Singapore'); INSERT INTO Port (port_id, port_name, country) VALUES (3, 'Port of Oakland', 'USA'); CREATE TABLE Shipment (shipment_id INT, container_id INT, port_id INT, shipping_date DATE); CREATE TABLE Container (container_id INT, weight FLOAT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM Container c JOIN Shipment s ON c.container_id = s.container_id JOIN Port p ON s.port_id = p.port_id WHERE p.port_name = 'Port of Oakland' AND c.container_id IN (SELECT container_id FROM Shipment WHERE shipping_date >= '2022-01-01' AND shipping_date < '2022-04-01' AND port_id IN (SELECT port_id FROM Port WHERE country = 'Canada'));\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(0,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 57\n",
            "Question: List the types of fish and their quantities farmed in each country using sustainable methods.\n",
            "SCHEMA: CREATE TABLE FarmD (species VARCHAR(20), country VARCHAR(20), quantity INT, farming_method VARCHAR(20)); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Salmon', 'Norway', 8000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Trout', 'Norway', 3000, 'Conventional'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Salmon', 'Scotland', 6000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Trout', 'Scotland', 2000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Cod', 'Canada', 4000, 'Conventional');\n",
            "Original Answer: SELECT country, species, SUM(quantity) FROM FarmD WHERE farming_method = 'Sustainable' GROUP BY country, species;\n",
            "Generated Answer: SELECT species, SUM(quantity) FROM FarmD WHERE farming_method = 'Sustainable' GROUP BY country\n",
            "Closest Distance: 0.05415366217494011\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE FarmD (species VARCHAR(20), country VARCHAR(20), quantity INT, farming_method VARCHAR(20)); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Salmon', 'Norway', 8000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Trout', 'Norway', 3000, 'Conventional'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Salmon', 'Scotland', 6000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Trout', 'Scotland', 2000, 'Sustainable'); INSERT INTO FarmD (species, country, quantity, farming_method) VALUES ('Cod', 'Canada', 4000, 'Conventional');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT country, species, SUM(quantity) FROM FarmD WHERE farming_method = 'Sustainable' GROUP BY country, species;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('Norway', 'Salmon', 8000)\n",
            "('Scotland', 'Salmon', 6000)\n",
            "('Scotland', 'Trout', 2000)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 58\n",
            "Question: How many pallets were returned to each warehouse in the reverse logistics process in January 2022?\n",
            "SCHEMA: CREATE TABLE Warehouses (WarehouseID int, WarehouseName varchar(50)); CREATE TABLE ReverseLogistics (ReturnID int, WarehouseID int, Pallets int, ReturnDate date); INSERT INTO Warehouses VALUES (1, 'WarehouseA'), (2, 'WarehouseB'), (3, 'WarehouseC'); INSERT INTO ReverseLogistics VALUES (100, 1, 5, '2022-01-01'), (200, 2, 10, '2022-01-05'), (300, 3, 8, '2022-01-10'), (400, 1, 3, '2022-01-15');\n",
            "Original Answer: SELECT Warehouses.WarehouseName, SUM(ReverseLogistics.Pallets) as TotalPallets FROM Warehouses INNER JOIN ReverseLogistics ON Warehouses.WarehouseID = ReverseLogistics.WarehouseID WHERE ReturnDate >= '2022-01-01' AND ReturnDate < '2022-02-01' GROUP BY Warehouses.WarehouseName;\n",
            "Generated Answer: SELECT COUNT(*), WarehouseID FROM ReverseLogistics GROUP BY WarehouseID\n",
            "Closest Distance: 0.6628749370574951\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Warehouses (WarehouseID int, WarehouseName varchar(50)); CREATE TABLE ReverseLogistics (ReturnID int, WarehouseID int, Pallets int, ReturnDate date); INSERT INTO Warehouses VALUES (1, 'WarehouseA'), (2, 'WarehouseB'), (3, 'WarehouseC'); INSERT INTO ReverseLogistics VALUES (100, 1, 5, '2022-01-01'), (200, 2, 10, '2022-01-05'), (300, 3, 8, '2022-01-10'), (400, 1, 3, '2022-01-15');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT Warehouses.WarehouseName, SUM(ReverseLogistics.Pallets) as TotalPallets FROM Warehouses INNER JOIN ReverseLogistics ON Warehouses.WarehouseID = ReverseLogistics.WarehouseID WHERE ReturnDate >= '2022-01-01' AND ReturnDate < '2022-02-01' GROUP BY Warehouses.WarehouseName;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('WarehouseC', 8)\n",
            "('WarehouseA', 8)\n",
            "('WarehouseB', 10)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 59\n",
            "Question: Delete all records of workers with a salary greater than 90000 and update the remaining salaries to increase by 5% if they work in the 'oil' industry.\n",
            "SCHEMA: CREATE TABLE Workers (Id INT, Name VARCHAR(50), Job VARCHAR(50), Salary FLOAT, Industry VARCHAR(50)); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (1, 'John Doe', 'Engineer', 80000.00, 'oil'); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (2, 'Jane Smith', 'Technician', 60000.00, 'oil'); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (3, 'Mike Johnson', 'Manager', 95000.00, 'oil');\n",
            "Original Answer: WITH cte AS (DELETE FROM Workers WHERE Salary > 90000 AND Industry = 'oil' RETURNING *) UPDATE Workers SET Salary = Salary * 1.05 WHERE Industry = 'oil';\n",
            "Generated Answer: DELETE FROM Workers WHERE Salary > 90000 AND Industry = 'oil'; UPDATE Workers SET Salary = Salary * 1.05 WHERE Industry = 'oil'\n",
            "Closest Distance: 0.14898890256881714\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Workers (Id INT, Name VARCHAR(50), Job VARCHAR(50), Salary FLOAT, Industry VARCHAR(50)); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (1, 'John Doe', 'Engineer', 80000.00, 'oil'); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (2, 'Jane Smith', 'Technician', 60000.00, 'oil'); INSERT INTO Workers (Id, Name, Job, Salary, Industry) VALUES (3, 'Mike Johnson', 'Manager', 95000.00, 'oil');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: WITH cte AS (DELETE FROM Workers WHERE Salary > 90000 AND Industry = 'oil' RETURNING *) UPDATE Workers SET Salary = Salary * 1.05 WHERE Industry = 'oil';\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 60\n",
            "Question: What is the total revenue generated by each cuisine, including dishes that have not been sold recently?\n",
            "SCHEMA: CREATE TABLE cuisine (cuisine_id INT, cuisine_name VARCHAR(255)); INSERT INTO cuisine VALUES (1, 'Italian'); INSERT INTO cuisine VALUES (2, 'Indian'); CREATE TABLE dishes (dish_id INT, dish_name VARCHAR(255), cuisine_id INT, price DECIMAL(5,2), last_sold DATE); INSERT INTO dishes VALUES (1, 'Pizza Margherita', 1, 12.99, '2022-04-15'); INSERT INTO dishes VALUES (2, 'Chole Bhature', 2, 9.99, '2022-04-20');\n",
            "Original Answer: SELECT cuisine_name, SUM(price) as total_revenue FROM cuisine JOIN dishes ON cuisine.cuisine_id = dishes.cuisine_id GROUP BY cuisine_name;\n",
            "Generated Answer: SELECT COUNT(dish_id), COUNT(price) FROM dishes GROUP BY cuisine_id\n",
            "Closest Distance: 0.4534068703651428\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE cuisine (cuisine_id INT, cuisine_name VARCHAR(255)); INSERT INTO cuisine VALUES (1, 'Italian'); INSERT INTO cuisine VALUES (2, 'Indian'); CREATE TABLE dishes (dish_id INT, dish_name VARCHAR(255), cuisine_id INT, price DECIMAL(5,2), last_sold DATE); INSERT INTO dishes VALUES (1, 'Pizza Margherita', 1, 12.99, '2022-04-15'); INSERT INTO dishes VALUES (2, 'Chole Bhature', 2, 9.99, '2022-04-20');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT cuisine_name, SUM(price) as total_revenue FROM cuisine JOIN dishes ON cuisine.cuisine_id = dishes.cuisine_id GROUP BY cuisine_name;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 2 \n",
            "\n",
            "('Indian', Decimal('9.99'))\n",
            "('Italian', Decimal('12.99'))\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 61\n",
            "Question: List all the suppliers and their contact information who have not supplied any raw materials in the last 6 months.\n",
            "SCHEMA: CREATE TABLE Suppliers (supplier_id INT, supplier_name VARCHAR(20), contact_name VARCHAR(20), contact_phone VARCHAR(15), last_supply DATE);\n",
            "Original Answer: SELECT Suppliers.* FROM Suppliers LEFT JOIN (SELECT supplier_id FROM Raw_Materials WHERE supply_date >= DATE_SUB(CURDATE(), INTERVAL 6 MONTH) GROUP BY supplier_id) AS RM ON Suppliers.supplier_id = RM.supplier_id WHERE RM.supplier_id IS NULL;\n",
            "Generated Answer: SELECT supplier_name, contact_name, contact_phone FROM Suppliers WHERE NOT last_supply >= (CURRENT_DATE - INTERVAL '6 MONTH'\n",
            "Closest Distance: 0.4245809316635132\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Suppliers (supplier_id INT, supplier_name VARCHAR(20), contact_name VARCHAR(20), contact_phone VARCHAR(15), last_supply DATE);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT Suppliers.* FROM Suppliers LEFT JOIN (SELECT supplier_id FROM Raw_Materials WHERE supply_date >= DATE_SUB(CURDATE(), INTERVAL 6 MONTH) GROUP BY supplier_id) AS RM ON Suppliers.supplier_id = RM.supplier_id WHERE RM.supplier_id IS NULL;\n",
            "Database connected successfully\n",
            "Error executing query: syntax error at or near \"6\"\n",
            "LINE 1: ...WHERE supply_date >= DATE_SUB(CURDATE(), INTERVAL 6 MONTH) G...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 62\n",
            "Question: Insert new records into 'OilRigs' table for the following data: (RigID, Location, Status, Type) - ('Rig02', 'Barents Sea', 'Inactive', 'Offshore'), ('Rig03', 'North Sea', 'Operational', 'Onshore')\n",
            "SCHEMA: CREATE TABLE OilRigs (RigID VARCHAR(10), Location VARCHAR(20), Status VARCHAR(20), Type VARCHAR(10));\n",
            "Original Answer: INSERT INTO OilRigs (RigID, Location, Status, Type) VALUES ('Rig02', 'Barents Sea', 'Inactive', 'Offshore'), ('Rig03', 'North Sea', 'Operational', 'Onshore');\n",
            "Generated Answer: INSERT INTO OilRigs (RigID, Location, Status, Type) VALUES ('Rig02', 'Barents Sea', 'Inactive', 'Offshore'), ('Rig03', 'North Sea', 'Operational', 'Onshore')\n",
            "Closest Distance: 0.03264840692281723\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE OilRigs (RigID VARCHAR(10), Location VARCHAR(20), Status VARCHAR(20), Type VARCHAR(10));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: INSERT INTO OilRigs (RigID, Location, Status, Type) VALUES ('Rig02', 'Barents Sea', 'Inactive', 'Offshore'), ('Rig03', 'North Sea', 'Operational', 'Onshore');\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 63\n",
            "Question: List defense projects that started in 2019 and their associated risks, if any.\n",
            "SCHEMA: CREATE TABLE DefenseProjects (id INT, project_name VARCHAR(50), start_date DATE, risk_level INT); INSERT INTO DefenseProjects (id, project_name, start_date, risk_level) VALUES (1, 'Project G', '2019-01-01', 3), (2, 'Project H', '2018-06-15', 5), (3, 'Project I', '2019-12-31', NULL);\n",
            "Original Answer: SELECT project_name, risk_level FROM DefenseProjects WHERE start_date >= '2019-01-01' AND start_date <= '2019-12-31' AND risk_level IS NOT NULL;\n",
            "Generated Answer: SELECT T1.project_name, T1.start_date, T2.risk_level FROM DefenseProjects AS T1 JOIN DefenseProjects AS T2 ON T1.id = T2.id WHERE T1.start_date = '2019-01-01' AND T2.risk_level IS NOT NULL\n",
            "Closest Distance: 0.17775973677635193\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE DefenseProjects (id INT, project_name VARCHAR(50), start_date DATE, risk_level INT); INSERT INTO DefenseProjects (id, project_name, start_date, risk_level) VALUES (1, 'Project G', '2019-01-01', 3), (2, 'Project H', '2018-06-15', 5), (3, 'Project I', '2019-12-31', NULL);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT project_name, risk_level FROM DefenseProjects WHERE start_date >= '2019-01-01' AND start_date <= '2019-12-31' AND risk_level IS NOT NULL;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Project G', 3)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 64\n",
            "Question: Update the completion date of the community development initiative with ID 4 to '2022-04-15' in the Cambodia table.\n",
            "SCHEMA: CREATE TABLE community_development (id INT, country VARCHAR(20), initiative_name VARCHAR(50), completion_date DATE); INSERT INTO community_development (id, country, initiative_name, completion_date) VALUES (1, 'Cambodia', 'Health Center', '2021-01-05'), (2, 'Cambodia', 'Waste Management', '2022-03-01');\n",
            "Original Answer: UPDATE community_development SET completion_date = '2022-04-15' WHERE id = 4 AND country = 'Cambodia';\n",
            "Generated Answer: UPDATE community_development SET completion_date = \"2022-04-15\" WHERE id = 4 AND country = \"cambodia\"\n",
            "Closest Distance: 0.014767073094844818\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE community_development (id INT, country VARCHAR(20), initiative_name VARCHAR(50), completion_date DATE); INSERT INTO community_development (id, country, initiative_name, completion_date) VALUES (1, 'Cambodia', 'Health Center', '2021-01-05'), (2, 'Cambodia', 'Waste Management', '2022-03-01');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: UPDATE community_development SET completion_date = '2022-04-15' WHERE id = 4 AND country = 'Cambodia';\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 65\n",
            "Question: How many community development initiatives have been completed in each state of 'India'?\n",
            "SCHEMA: CREATE TABLE community_development(id INT, state TEXT, initiative_name TEXT, completion_status TEXT); INSERT INTO community_development (id, state, initiative_name, completion_status) VALUES (1, 'Uttar Pradesh', 'Community Health Center', 'completed'); INSERT INTO community_development (id, state, initiative_name, completion_status) VALUES (2, 'Maharashtra', 'Women Empowerment Program', 'in progress');\n",
            "Original Answer: SELECT state, COUNT(*) FROM community_development WHERE completion_status = 'completed' AND state IN ('Uttar Pradesh', 'Maharashtra', 'West Bengal', 'Andhra Pradesh', 'Tamil Nadu', 'Karnataka', 'Gujarat', 'Rajasthan', 'Bihar', 'Madhya Pradesh') GROUP BY state;\n",
            "Generated Answer: SELECT COUNT(completion_status) FROM community_development WHERE state = 'India'\n",
            "Closest Distance: 0.2739105820655823\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE community_development(id INT, state TEXT, initiative_name TEXT, completion_status TEXT); INSERT INTO community_development (id, state, initiative_name, completion_status) VALUES (1, 'Uttar Pradesh', 'Community Health Center', 'completed'); INSERT INTO community_development (id, state, initiative_name, completion_status) VALUES (2, 'Maharashtra', 'Women Empowerment Program', 'in progress');\n",
            "Error creating table: relation \"community_development\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT state, COUNT(*) FROM community_development WHERE completion_status = 'completed' AND state IN ('Uttar Pradesh', 'Maharashtra', 'West Bengal', 'Andhra Pradesh', 'Tamil Nadu', 'Karnataka', 'Gujarat', 'Rajasthan', 'Bihar', 'Madhya Pradesh') GROUP BY state;\n",
            "Database connected successfully\n",
            "Error executing query: column \"state\" does not exist\n",
            "LINE 1: SELECT state, COUNT(*) FROM community_development WHERE comp...\n",
            "               ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 66\n",
            "Question: Count the number of sensors in each region\n",
            "SCHEMA: CREATE TABLE sensor (id INT, region VARCHAR(255), type VARCHAR(255)); INSERT INTO sensor (id, region, type) VALUES (1, 'North', 'temperature'), (2, 'South', 'humidity'), (3, 'East', 'moisture'), (4, 'North', 'moisture');\n",
            "Original Answer: SELECT region, COUNT(*) FROM sensor GROUP BY region;\n",
            "Generated Answer: SELECT COUNT(*), region FROM sensor GROUP BY region\n",
            "Closest Distance: 0.10639293491840363\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE sensor (id INT, region VARCHAR(255), type VARCHAR(255)); INSERT INTO sensor (id, region, type) VALUES (1, 'North', 'temperature'), (2, 'South', 'humidity'), (3, 'East', 'moisture'), (4, 'North', 'moisture');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT region, COUNT(*) FROM sensor GROUP BY region;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('North', 2)\n",
            "('East', 1)\n",
            "('South', 1)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 67\n",
            "Question: What is the total energy production (in MWh) of hydroelectric power plants in 'SouthAmerica' that were built before '2010'?\n",
            "SCHEMA: CREATE TABLE hydro_plants (id INT, name VARCHAR(50), region VARCHAR(50), built_year INT, production INT); INSERT INTO hydro_plants (id, name, region, built_year, production) VALUES (1, 'HydroPlant1', 'SouthAmerica', 2005, 1500), (2, 'HydroPlant2', 'SouthAmerica', 2015, 2000);\n",
            "Original Answer: SELECT SUM(production) FROM hydro_plants WHERE region = 'SouthAmerica' AND built_year < 2010;\n",
            "Generated Answer: SELECT SUM(production) FROM hydro_plants WHERE region ='southamerica' AND built_year < 2010\n",
            "Closest Distance: 0.01524895429611206\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE hydro_plants (id INT, name VARCHAR(50), region VARCHAR(50), built_year INT, production INT); INSERT INTO hydro_plants (id, name, region, built_year, production) VALUES (1, 'HydroPlant1', 'SouthAmerica', 2005, 1500), (2, 'HydroPlant2', 'SouthAmerica', 2015, 2000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(production) FROM hydro_plants WHERE region = 'SouthAmerica' AND built_year < 2010;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1500,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 68\n",
            "Question: Determine the average spending in the 'gift_shop' category for the month of July 2022.\n",
            "SCHEMA: CREATE TABLE transactions (id INT, category VARCHAR(50), amount DECIMAL(10, 2), transaction_date DATE); INSERT INTO transactions (id, category, amount, transaction_date) VALUES (1, 'fine_dining', 150.50, '2022-06-01'), (2, 'gift_shop', 25.95, '2022-07-02'), (3, 'coffee_shop', 8.95, '2022-06-02');\n",
            "Original Answer: SELECT AVG(amount) as avg_spending FROM transactions WHERE category = 'gift_shop' AND transaction_date BETWEEN '2022-07-01' AND '2022-07-31';\n",
            "Generated Answer: SELECT AVG(amount) FROM transactions WHERE category = 'gift_shop' AND transaction_date = '2022-07-02'\n",
            "Closest Distance: 0.13656626641750336\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE transactions (id INT, category VARCHAR(50), amount DECIMAL(10, 2), transaction_date DATE); INSERT INTO transactions (id, category, amount, transaction_date) VALUES (1, 'fine_dining', 150.50, '2022-06-01'), (2, 'gift_shop', 25.95, '2022-07-02'), (3, 'coffee_shop', 8.95, '2022-06-02');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(amount) as avg_spending FROM transactions WHERE category = 'gift_shop' AND transaction_date BETWEEN '2022-07-01' AND '2022-07-31';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('25.9500000000000000'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 69\n",
            "Question: What is the total sales revenue of organic skincare products in the European market?\n",
            "SCHEMA: CREATE TABLE SkincareSales (productID INT, productName VARCHAR(50), region VARCHAR(50), revenue DECIMAL(10,2)); INSERT INTO SkincareSales (productID, productName, region, revenue) VALUES (1, 'Nourishing Cream', 'Europe', 5000.00), (2, 'Soothing Lotion', 'Europe', 7000.00), (3, 'Regenerating Serum', 'Europe', 8000.00); CREATE TABLE ProductIngredients (productID INT, ingredient VARCHAR(50), organic BOOLEAN); INSERT INTO ProductIngredients (productID, ingredient, organic) VALUES (1, 'Aloe Vera', true), (2, 'Chamomile', true), (3, 'Retinol', false);\n",
            "Original Answer: SELECT SUM(revenue) FROM SkincareSales INNER JOIN ProductIngredients ON SkincareSales.productID = ProductIngredients.productID WHERE organic = true AND region = 'Europe';\n",
            "Generated Answer: SELECT SUM(t1.revenue) FROM SkincareSales AS t1 JOIN ProductIngredients AS t2 ON t1.productID = t2.productID WHERE t2.organic = true AND t1.region = 'Europe'\n",
            "Closest Distance: 0.08842703700065613\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE SkincareSales (productID INT, productName VARCHAR(50), region VARCHAR(50), revenue DECIMAL(10,2)); INSERT INTO SkincareSales (productID, productName, region, revenue) VALUES (1, 'Nourishing Cream', 'Europe', 5000.00), (2, 'Soothing Lotion', 'Europe', 7000.00), (3, 'Regenerating Serum', 'Europe', 8000.00); CREATE TABLE ProductIngredients (productID INT, ingredient VARCHAR(50), organic BOOLEAN); INSERT INTO ProductIngredients (productID, ingredient, organic) VALUES (1, 'Aloe Vera', true), (2, 'Chamomile', true), (3, 'Retinol', false);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(revenue) FROM SkincareSales INNER JOIN ProductIngredients ON SkincareSales.productID = ProductIngredients.productID WHERE organic = true AND region = 'Europe';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('12000.00'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 70\n",
            "Question: What is the total amount of donations received by 'organization X' in the year 2021?\n",
            "SCHEMA: CREATE TABLE organization (organization_id INT, name VARCHAR(50)); INSERT INTO organization (organization_id, name) VALUES (1, 'Organization X'), (2, 'Organization Y'); CREATE TABLE year (year_id INT, year INT); INSERT INTO year (year_id, year) VALUES (1, 2021), (2, 2020); CREATE TABLE donations (donation_id INT, amount INT, organization_id INT, year_id INT); INSERT INTO donations (donation_id, amount, organization_id, year_id) VALUES (1, 500, 1, 1), (2, 700, 1, 1), (3, 300, 2, 1);\n",
            "Original Answer: SELECT SUM(amount) FROM donations WHERE organization_id = 1 AND year_id = 1;\n",
            "Generated Answer: SELECT SUM(amount) FROM donations AS T1 JOIN organization AS T2 ON T1.organization_id = T2.organization_id JOIN year AS T3 ON T1.year_id = T3.year_id WHERE T3.year = 2021 AND T2.name = 'organization X'\n",
            "Closest Distance: 0.2417825609445572\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE organization (organization_id INT, name VARCHAR(50)); INSERT INTO organization (organization_id, name) VALUES (1, 'Organization X'), (2, 'Organization Y'); CREATE TABLE year (year_id INT, year INT); INSERT INTO year (year_id, year) VALUES (1, 2021), (2, 2020); CREATE TABLE donations (donation_id INT, amount INT, organization_id INT, year_id INT); INSERT INTO donations (donation_id, amount, organization_id, year_id) VALUES (1, 500, 1, 1), (2, 700, 1, 1), (3, 300, 2, 1);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(amount) FROM donations WHERE organization_id = 1 AND year_id = 1;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1200,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 71\n",
            "Question: Find the number of unique products that are supplied by each supplier.\n",
            "SCHEMA: CREATE TABLE products (id INT, name VARCHAR(255), price DECIMAL(10,2), supplier_id INT);\n",
            "Original Answer: SELECT supplier_id, COUNT(DISTINCT id) FROM products GROUP BY supplier_id;\n",
            "Generated Answer: SELECT COUNT(*), supplier_id FROM products GROUP BY supplier_id\n",
            "Closest Distance: 0.13587060570716858\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE products (id INT, name VARCHAR(255), price DECIMAL(10,2), supplier_id INT);\n",
            "Error creating table: relation \"products\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT supplier_id, COUNT(DISTINCT id) FROM products GROUP BY supplier_id;\n",
            "Database connected successfully\n",
            "Error executing query: column \"supplier_id\" does not exist\n",
            "LINE 1: SELECT supplier_id, COUNT(DISTINCT id) FROM products GROUP B...\n",
            "               ^\n",
            "HINT:  Perhaps you meant to reference the column \"products.supplierid\".\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 72\n",
            "Question: How many artworks were created by artists from Japan who have won awards?\n",
            "SCHEMA: CREATE TABLE Artists (ArtistID INT, Name TEXT, Nationality TEXT, Award INT);   CREATE TABLE Artworks (ArtworkID INT, ArtistID INT, CreationYear INT);   INSERT INTO Artists (ArtistID, Name, Nationality, Award) VALUES (1, 'Yayoi Kusama', 'Japanese', 1);   INSERT INTO Artworks (ArtworkID, ArtistID, CreationYear) VALUES (1, 1, 1990);\n",
            "Original Answer: SELECT COUNT(*) FROM Artworks A JOIN Artists B ON A.ArtistID = B.ArtistID WHERE B.Nationality = 'Japanese' AND B.Award = 1;\n",
            "Generated Answer: SELECT COUNT(*) FROM Artworks AS T1 JOIN Artists AS T2 ON T1.ArtistID = T2.ArtistID WHERE T2.Nationality = 'Japanese' AND T2.Award = 1\n",
            "Closest Distance: 0.037197936326265335\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Artists (ArtistID INT, Name TEXT, Nationality TEXT, Award INT);   CREATE TABLE Artworks (ArtworkID INT, ArtistID INT, CreationYear INT);   INSERT INTO Artists (ArtistID, Name, Nationality, Award) VALUES (1, 'Yayoi Kusama', 'Japanese', 1);   INSERT INTO Artworks (ArtworkID, ArtistID, CreationYear) VALUES (1, 1, 1990);\n",
            "Error creating table: relation \"artists\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM Artworks A JOIN Artists B ON A.ArtistID = B.ArtistID WHERE B.Nationality = 'Japanese' AND B.Award = 1;\n",
            "Database connected successfully\n",
            "Error executing query: relation \"artworks\" does not exist\n",
            "LINE 1: SELECT COUNT(*) FROM Artworks A JOIN Artists B ON A.ArtistID...\n",
            "                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 73\n",
            "Question: What is the total installed capacity (GW) of renewable energy sources in 'China'?\n",
            "SCHEMA: CREATE TABLE renewable_energy (energy_id INT, country VARCHAR(50), capacity FLOAT); INSERT INTO renewable_energy (energy_id, country, capacity) VALUES (1, 'China', 1200.5), (2, 'USA', 800.7);\n",
            "Original Answer: SELECT SUM(capacity) FROM renewable_energy WHERE country = 'China';\n",
            "Generated Answer: SELECT SUM(capacity) FROM renewable_energy WHERE country = 'china'\n",
            "Closest Distance: 0.026269014924764633\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE renewable_energy (energy_id INT, country VARCHAR(50), capacity FLOAT); INSERT INTO renewable_energy (energy_id, country, capacity) VALUES (1, 'China', 1200.5), (2, 'USA', 800.7);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(capacity) FROM renewable_energy WHERE country = 'China';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1200.5,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 74\n",
            "Question: Which product has the most sustainable packaging material?\n",
            "SCHEMA: CREATE TABLE packaging (package_id INT, product_id INT, material VARCHAR(20), recyclable BOOLEAN); INSERT INTO packaging (package_id, product_id, material, recyclable) VALUES (1, 1, 'plastic', false), (2, 2, 'glass', true), (3, 3, 'paper', true);\n",
            "Original Answer: SELECT product_id, material FROM packaging WHERE recyclable = true ORDER BY LENGTH(material) DESC LIMIT 1;\n",
            "Generated Answer: SELECT product_id FROM packaging GROUP BY product_id ORDER BY COUNT(recyclable) DESC LIMIT 1\n",
            "Closest Distance: 0.2640998065471649\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE packaging (package_id INT, product_id INT, material VARCHAR(20), recyclable BOOLEAN); INSERT INTO packaging (package_id, product_id, material, recyclable) VALUES (1, 1, 'plastic', false), (2, 2, 'glass', true), (3, 3, 'paper', true);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT product_id, material FROM packaging WHERE recyclable = true ORDER BY LENGTH(material) DESC LIMIT 1;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(2, 'glass')\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 75\n",
            "Question: What is the consumer preference for organic beauty products in the South American region?\n",
            "SCHEMA: CREATE TABLE sales_data (sale_id INT, product_id INT, country VARCHAR(50), is_organic BOOLEAN, sale_date DATE, revenue DECIMAL(10,2));\n",
            "Original Answer: SELECT country, YEAR(sale_date) as year, MONTH(sale_date) as month, 100.0 * SUM(CASE WHEN is_organic THEN revenue ELSE 0 END) / SUM(revenue) as organic_preference FROM sales_data WHERE sale_date >= '2018-01-01' AND country LIKE 'South America%' GROUP BY country, year, month;\n",
            "Generated Answer: SELECT is_organic, COUNT(*) FROM sales_data WHERE country = \"south america\" AND sale_date > 2010 AND revenue > 1000000000\n",
            "Closest Distance: 0.8728170394897461\n",
            "NO MATCH\n",
            "\n",
            "Evaluating sample: 76\n",
            "Question: Calculate the percentage of artworks by each artist in Rome that have a guest rating of 4.5 or higher, and rank them in descending order of percentage.\n",
            "SCHEMA: CREATE TABLE Artists (id INT, name VARCHAR(30)); CREATE TABLE Works (id INT, artist_id INT, title VARCHAR(50)); CREATE TABLE Exhibitions (id INT, work_id INT, city VARCHAR(20), guest_rating FLOAT, revenue FLOAT); INSERT INTO Exhibitions (id, work_id, city, guest_rating, revenue) VALUES (1, 1, 'Rome', 4.6, 5000), (2, 2, 'Rome', 4.3, 6000), (3, 3, 'Rome', 4.5, 7000);\n",
            "Original Answer: SELECT a.name, COUNT(e.work_id) as total_works, COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) as high_rating_works, 100.0 * COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) / COUNT(e.work_id) as percentage, RANK() OVER (PARTITION BY a.name ORDER BY 100.0 * COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) / COUNT(e.work_id) DESC) as rank FROM Artists a JOIN Works w ON a.id = w.artist_id JOIN Exhibitions e ON w.id = e.work_id WHERE e.city = 'Rome' GROUP BY a.name, rank ORDER BY percentage DESC;\n",
            "Generated Answer: SELECT T2.name, COUNT(*) FROM Artists AS T1 JOIN Works AS T2 ON T1.id = T2.artist_id JOIN Exhibitions AS T3 ON T2.id = T3.work_id WHERE T3.city = \"Rome\" AND T3.guest_rating > 4.5 GROUP BY T2.name ORDER BY COUNT(*) DESC\n",
            "Closest Distance: 0.43445587158203125\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Artists (id INT, name VARCHAR(30)); CREATE TABLE Works (id INT, artist_id INT, title VARCHAR(50)); CREATE TABLE Exhibitions (id INT, work_id INT, city VARCHAR(20), guest_rating FLOAT, revenue FLOAT); INSERT INTO Exhibitions (id, work_id, city, guest_rating, revenue) VALUES (1, 1, 'Rome', 4.6, 5000), (2, 2, 'Rome', 4.3, 6000), (3, 3, 'Rome', 4.5, 7000);\n",
            "Error creating table: relation \"artists\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT a.name, COUNT(e.work_id) as total_works, COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) as high_rating_works, 100.0 * COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) / COUNT(e.work_id) as percentage, RANK() OVER (PARTITION BY a.name ORDER BY 100.0 * COUNT(CASE WHEN e.guest_rating >= 4.5 THEN e.work_id END) / COUNT(e.work_id) DESC) as rank FROM Artists a JOIN Works w ON a.id = w.artist_id JOIN Exhibitions e ON w.id = e.work_id WHERE e.city = 'Rome' GROUP BY a.name, rank ORDER BY percentage DESC;\n",
            "Database connected successfully\n",
            "Error executing query: relation \"works\" does not exist\n",
            "LINE 1: ...OUNT(e.work_id) DESC) as rank FROM Artists a JOIN Works w ON...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 77\n",
            "Question: What is the minimum listing price for co-op properties in Boston?\n",
            "SCHEMA: CREATE TABLE boston_properties (type VARCHAR(10), price INT); INSERT INTO boston_properties (type, price) VALUES ('Co-op', 450000); INSERT INTO boston_properties (type, price) VALUES ('Condo', 600000);\n",
            "Original Answer: SELECT MIN(price) FROM boston_properties WHERE type = 'Co-op';\n",
            "Generated Answer: SELECT MIN(price) FROM boston_properties WHERE type = 'Co-op'\n",
            "Closest Distance: 0.015126347541809082\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE boston_properties (type VARCHAR(10), price INT); INSERT INTO boston_properties (type, price) VALUES ('Co-op', 450000); INSERT INTO boston_properties (type, price) VALUES ('Condo', 600000);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT MIN(price) FROM boston_properties WHERE type = 'Co-op';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(450000,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 78\n",
            "Question: What is the total revenue of lipsticks sold in the USA in Q1 2022?\n",
            "SCHEMA: CREATE TABLE cosmetics_sales (product VARCHAR(255), country VARCHAR(255), revenue DECIMAL(10,2)); CREATE VIEW q1_sales AS SELECT * FROM cosmetics_sales WHERE sale_date BETWEEN '2022-01-01' AND '2022-03-31'; CREATE TABLE countries (country VARCHAR(255), continent VARCHAR(255)); INSERT INTO countries (country, continent) VALUES ('USA', 'North America');\n",
            "Original Answer: SELECT SUM(revenue) FROM q1_sales JOIN cosmetics ON q1_sales.product = cosmetics.product JOIN countries ON q1_sales.country = countries.country WHERE cosmetics.product_category = 'Lipsticks' AND countries.country = 'USA';\n",
            "Generated Answer: SELECT SUM(revenue) FROM q1_sales AS T1 JOIN cosmetics_sales AS T2 ON T1.product = T2.product JOIN countries AS T3 ON T2.country = T3.country WHERE T3.continent = 'North America'\n",
            "Closest Distance: 0.11314328014850616\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE cosmetics_sales (product VARCHAR(255), country VARCHAR(255), revenue DECIMAL(10,2)); CREATE VIEW q1_sales AS SELECT * FROM cosmetics_sales WHERE sale_date BETWEEN '2022-01-01' AND '2022-03-31'; CREATE TABLE countries (country VARCHAR(255), continent VARCHAR(255)); INSERT INTO countries (country, continent) VALUES ('USA', 'North America');\n",
            "Error creating table: column \"sale_date\" does not exist\n",
            "LINE 2: ...W q1_sales AS SELECT * FROM cosmetics_sales WHERE sale_date ...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT SUM(revenue) FROM q1_sales JOIN cosmetics ON q1_sales.product = cosmetics.product JOIN countries ON q1_sales.country = countries.country WHERE cosmetics.product_category = 'Lipsticks' AND countries.country = 'USA';\n",
            "Database connected successfully\n",
            "Error executing query: relation \"q1_sales\" does not exist\n",
            "LINE 1: SELECT SUM(revenue) FROM q1_sales JOIN cosmetics ON q1_sales...\n",
            "                                 ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 79\n",
            "Question: What is the highest scoring game in the history of the NBA?\n",
            "SCHEMA: CREATE TABLE games (game_id INT, home_team INT, away_team INT, home_points INT, away_points INT);\n",
            "Original Answer: SELECT home_team, away_team, home_points, away_points FROM games WHERE (home_points + away_points) = (SELECT MAX(home_points + away_points) FROM games);\n",
            "Generated Answer: SELECT MAX(home_points) + MAX(away_points) FROM games;\n",
            "Closest Distance: 0.18206225335597992\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE games (game_id INT, home_team INT, away_team INT, home_points INT, away_points INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT home_team, away_team, home_points, away_points FROM games WHERE (home_points + away_points) = (SELECT MAX(home_points + away_points) FROM games);\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 80\n",
            "Question: How many labor violations were reported in the 'labour_productivity' table for mines located in 'Asia'?\n",
            "SCHEMA: CREATE TABLE labour_productivity (mine_location VARCHAR(255), violation_count INT); INSERT INTO labour_productivity (mine_location, violation_count) VALUES ('North America', 15), ('South America', 22), ('Asia', 30), ('Europe', 10);\n",
            "Original Answer: SELECT COUNT(*) FROM labour_productivity WHERE mine_location = 'Asia';\n",
            "Generated Answer: SELECT COUNT(*) FROM labour_productivity WHERE mine_location = 'Asia'\n",
            "Closest Distance: 0.022716384381055832\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE labour_productivity (mine_location VARCHAR(255), violation_count INT); INSERT INTO labour_productivity (mine_location, violation_count) VALUES ('North America', 15), ('South America', 22), ('Asia', 30), ('Europe', 10);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM labour_productivity WHERE mine_location = 'Asia';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(1,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 81\n",
            "Question: What's the average ESG score of companies in the technology sector?\n",
            "SCHEMA: CREATE TABLE companies (id INT, sector VARCHAR(20), ESG_score FLOAT); INSERT INTO companies (id, sector, ESG_score) VALUES (1, 'Technology', 72.5), (2, 'Healthcare', 80.3), (3, 'Technology', 76.2);\n",
            "Original Answer: SELECT AVG(ESG_score) FROM companies WHERE sector = 'Technology';\n",
            "Generated Answer: SELECT AVG(ESG_score) FROM companies WHERE sector = 'Technology'\n",
            "Closest Distance: 0.03466857969760895\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE companies (id INT, sector VARCHAR(20), ESG_score FLOAT); INSERT INTO companies (id, sector, ESG_score) VALUES (1, 'Technology', 72.5), (2, 'Healthcare', 80.3), (3, 'Technology', 76.2);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(ESG_score) FROM companies WHERE sector = 'Technology';\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(74.35,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 82\n",
            "Question: List the names of underrepresented communities with the highest community engagement metrics in 2019.\n",
            "SCHEMA: CREATE TABLE Community_Engagement (id INT, community_name VARCHAR(100), year INT, engagement_score INT);\n",
            "Original Answer: SELECT community_name FROM Community_Engagement WHERE year = 2019 AND engagement_score IN (SELECT MAX(engagement_score) FROM Community_Engagement WHERE year = 2019) AND community_name IN ('African American', 'Hispanic', 'Indigenous', 'Asian', 'LGBTQ+');\n",
            "Generated Answer: SELECT community_name FROM Community_Engagement WHERE year = 2019 ORDER BY engagement_score DESC LIMIT 1\n",
            "Closest Distance: 0.6495604515075684\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Community_Engagement (id INT, community_name VARCHAR(100), year INT, engagement_score INT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT community_name FROM Community_Engagement WHERE year = 2019 AND engagement_score IN (SELECT MAX(engagement_score) FROM Community_Engagement WHERE year = 2019) AND community_name IN ('African American', 'Hispanic', 'Indigenous', 'Asian', 'LGBTQ+');\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 83\n",
            "Question: List all the clean energy policy trends in the Asia-Pacific region from 2015 to 2020.\n",
            "SCHEMA: CREATE TABLE policies (policy_name VARCHAR(255), region VARCHAR(255), start_year INT, end_year INT); INSERT INTO policies (policy_name, region, start_year, end_year) VALUES ('Renewable Portfolio Standard', 'Asia-Pacific', 2015, 2020), ('Feed-in Tariff Program', 'Asia-Pacific', 2016, 2020), ('Energy Storage Target', 'Asia-Pacific', 2017, 2020), ('Carbon Pricing', 'Asia-Pacific', 2018, 2020), ('Green Building Codes', 'Asia-Pacific', 2019, 2020);\n",
            "Original Answer: SELECT policy_name FROM policies WHERE region = 'Asia-Pacific' AND start_year BETWEEN 2015 AND 2020;\n",
            "Generated Answer: SELECT policy_name FROM policies WHERE region = 'Asia-Pacific' AND start_year < 2020 AND end_year > 2015\n",
            "Closest Distance: 0.040437862277030945\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE policies (policy_name VARCHAR(255), region VARCHAR(255), start_year INT, end_year INT); INSERT INTO policies (policy_name, region, start_year, end_year) VALUES ('Renewable Portfolio Standard', 'Asia-Pacific', 2015, 2020), ('Feed-in Tariff Program', 'Asia-Pacific', 2016, 2020), ('Energy Storage Target', 'Asia-Pacific', 2017, 2020), ('Carbon Pricing', 'Asia-Pacific', 2018, 2020), ('Green Building Codes', 'Asia-Pacific', 2019, 2020);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT policy_name FROM policies WHERE region = 'Asia-Pacific' AND start_year BETWEEN 2015 AND 2020;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 5 \n",
            "\n",
            "('Renewable Portfolio Standard',)\n",
            "('Feed-in Tariff Program',)\n",
            "('Energy Storage Target',)\n",
            "('Carbon Pricing',)\n",
            "('Green Building Codes',)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 84\n",
            "Question: What is the average transaction value for 'SmartContractC'?\n",
            "SCHEMA: CREATE TABLE Transactions (tx_id INT, contract_name VARCHAR(255), tx_value DECIMAL(10,2)); INSERT INTO Transactions (tx_id, contract_name, tx_value) VALUES (1, 'SmartContractC', 100.50); INSERT INTO Transactions (tx_id, contract_name, tx_value) VALUES (2, 'SmartContractC', 200.75);\n",
            "Original Answer: SELECT AVG(tx_value) FROM Transactions WHERE contract_name = 'SmartContractC';\n",
            "Generated Answer: SELECT AVG(tx_value) FROM Transactions WHERE contract_name = 'SmartContractC'\n",
            "Closest Distance: 0.02133331075310707\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Transactions (tx_id INT, contract_name VARCHAR(255), tx_value DECIMAL(10,2)); INSERT INTO Transactions (tx_id, contract_name, tx_value) VALUES (1, 'SmartContractC', 100.50); INSERT INTO Transactions (tx_id, contract_name, tx_value) VALUES (2, 'SmartContractC', 200.75);\n",
            "Error creating table: relation \"transactions\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT AVG(tx_value) FROM Transactions WHERE contract_name = 'SmartContractC';\n",
            "Database connected successfully\n",
            "Error executing query: column \"tx_value\" does not exist\n",
            "LINE 1: SELECT AVG(tx_value) FROM Transactions WHERE contract_name =...\n",
            "                   ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 85\n",
            "Question: List all volunteers who have contributed 20 or more hours in 'Q1 2023'.\n",
            "SCHEMA: CREATE TABLE volunteers (volunteer_id INT, volunteer_name TEXT, volunteer_hours INT, volunteer_quarter INT, volunteer_year INT); INSERT INTO volunteers (volunteer_id, volunteer_name, volunteer_hours, volunteer_quarter, volunteer_year) VALUES (1, 'Bob Brown', 25, 1, 2023), (2, 'Charlie Davis', 15, 1, 2023);\n",
            "Original Answer: SELECT volunteer_name FROM volunteers WHERE volunteer_quarter = 1 AND volunteer_year = 2023 AND volunteer_hours >= 20;\n",
            "Generated Answer: SELECT volunteer_id, volunteer_name FROM volunteers WHERE volunteer_hours >= 20 AND volunteer_quarter = 1 AND volunteer_year = 2023\n",
            "Closest Distance: 0.061816684901714325\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE volunteers (volunteer_id INT, volunteer_name TEXT, volunteer_hours INT, volunteer_quarter INT, volunteer_year INT); INSERT INTO volunteers (volunteer_id, volunteer_name, volunteer_hours, volunteer_quarter, volunteer_year) VALUES (1, 'Bob Brown', 25, 1, 2023), (2, 'Charlie Davis', 15, 1, 2023);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT volunteer_name FROM volunteers WHERE volunteer_quarter = 1 AND volunteer_year = 2023 AND volunteer_hours >= 20;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Bob Brown',)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 86\n",
            "Question: What is the average age of community health workers by cultural competency level?\n",
            "SCHEMA: CREATE TABLE CommunityHealthWorkers (Id INT, Age INT, CulturalCompetencyLevel VARCHAR(20)); INSERT INTO CommunityHealthWorkers (Id, Age, CulturalCompetencyLevel) VALUES (1, 45, 'High'), (2, 35, 'Medium'), (3, 50, 'Low');\n",
            "Original Answer: SELECT CulturalCompetencyLevel, AVG(Age) as AvgAge FROM CommunityHealthWorkers GROUP BY CulturalCompetencyLevel;\n",
            "Generated Answer: SELECT AVG(Age), CulturalCompetencyLevel FROM CommunityHealthWorkers GROUP BY CulturalCompetencyLevel\n",
            "Closest Distance: 0.07721497118473053\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE CommunityHealthWorkers (Id INT, Age INT, CulturalCompetencyLevel VARCHAR(20)); INSERT INTO CommunityHealthWorkers (Id, Age, CulturalCompetencyLevel) VALUES (1, 45, 'High'), (2, 35, 'Medium'), (3, 50, 'Low');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT CulturalCompetencyLevel, AVG(Age) as AvgAge FROM CommunityHealthWorkers GROUP BY CulturalCompetencyLevel;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('Medium', Decimal('35.0000000000000000'))\n",
            "('High', Decimal('45.0000000000000000'))\n",
            "('Low', Decimal('50.0000000000000000'))\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 87\n",
            "Question: Insert a new record for a military technology developed by Russia.\n",
            "SCHEMA: CREATE TABLE military_tech (id INT, name VARCHAR(255), country VARCHAR(255), status VARCHAR(255));\n",
            "Original Answer: INSERT INTO military_tech (id, name, country, status) VALUES (4, 'T-14 Armata', 'Russia', 'active');\n",
            "Generated Answer: INSERT INTO military_tech (name, country, status) VALUES ('avtomat', 'russia', 'operational')\n",
            "Closest Distance: 0.13324449956417084\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE military_tech (id INT, name VARCHAR(255), country VARCHAR(255), status VARCHAR(255));\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: INSERT INTO military_tech (id, name, country, status) VALUES (4, 'T-14 Armata', 'Russia', 'active');\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 88\n",
            "Question: Which country has launched the most satellites in the year 2010?\n",
            "SCHEMA: CREATE TABLE satellites (id INT, country VARCHAR(255), launch_date DATE);\n",
            "Original Answer: SELECT country, COUNT(*) AS launched_satellites FROM satellites WHERE EXTRACT(YEAR FROM launch_date) = 2010 GROUP BY country ORDER BY launched_satellites DESC LIMIT 1;\n",
            "Generated Answer: SELECT country FROM satellites WHERE launch_date = 2010 GROUP BY country ORDER BY COUNT(*) DESC LIMIT 1\n",
            "Closest Distance: 0.1737743616104126\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE satellites (id INT, country VARCHAR(255), launch_date DATE);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT country, COUNT(*) AS launched_satellites FROM satellites WHERE EXTRACT(YEAR FROM launch_date) = 2010 GROUP BY country ORDER BY launched_satellites DESC LIMIT 1;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 89\n",
            "Question: Who are the top 3 construction companies with the most completed projects in California?\n",
            "SCHEMA: CREATE TABLE Companies (CompanyID int, CompanyName varchar(255), State varchar(255)); CREATE TABLE Projects (ProjectID int, CompanyID int, StartDate date, EndDate date);\n",
            "Original Answer: SELECT CompanyName, COUNT(ProjectID) as CompletedProjects FROM Companies JOIN Projects ON Companies.CompanyID = Projects.CompanyID WHERE State = 'California' GROUP BY CompanyName ORDER BY CompletedProjects DESC LIMIT 3;\n",
            "Generated Answer: SELECT T2.CompanyName, COUNT(*) FROM Companies AS T1 JOIN Projects AS T2 ON T1.CompanyID = T2.CompanyID WHERE T2.EndDate > CURRENT_DATE AND T1.State = \"California\" GROUP BY T2.CompanyName ORDER BY COUNT(*) DESC LIMIT 3\n",
            "Closest Distance: 0.1802496612071991\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Companies (CompanyID int, CompanyName varchar(255), State varchar(255)); CREATE TABLE Projects (ProjectID int, CompanyID int, StartDate date, EndDate date);\n",
            "Error creating table: relation \"companies\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT CompanyName, COUNT(ProjectID) as CompletedProjects FROM Companies JOIN Projects ON Companies.CompanyID = Projects.CompanyID WHERE State = 'California' GROUP BY CompanyName ORDER BY CompletedProjects DESC LIMIT 3;\n",
            "Database connected successfully\n",
            "Error executing query: relation \"projects\" does not exist\n",
            "LINE 1: ...ojectID) as CompletedProjects FROM Companies JOIN Projects O...\n",
            "                                                             ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 90\n",
            "Question: How many local events in India and Mexico support environmental conservation and women's rights?\n",
            "SCHEMA: CREATE TABLE local_events (event_id INT, event_name TEXT, location TEXT, cause TEXT); INSERT INTO local_events (event_id, event_name, location, cause) VALUES (1, 'Festival of Diversity', 'India', 'Women''s Rights'), (2, 'Sustainable Fashion Show', 'Mexico', 'Environmental Conservation');\n",
            "Original Answer: SELECT COUNT(*) FROM local_events WHERE location IN ('India', 'Mexico') AND cause IN ('Environmental Conservation', 'Women''s Rights');\n",
            "Generated Answer: SELECT COUNT(*) FROM local_events WHERE location = \"India\" AND cause = \"Women's Rights\" UNION SELECT COUNT(*) FROM local_events WHERE location = \"Mexico\" AND cause = \"Environmental Conservation\"\n",
            "Closest Distance: 0.44650959968566895\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE local_events (event_id INT, event_name TEXT, location TEXT, cause TEXT); INSERT INTO local_events (event_id, event_name, location, cause) VALUES (1, 'Festival of Diversity', 'India', 'Women''s Rights'), (2, 'Sustainable Fashion Show', 'Mexico', 'Environmental Conservation');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM local_events WHERE location IN ('India', 'Mexico') AND cause IN ('Environmental Conservation', 'Women''s Rights');\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(2,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 91\n",
            "Question: Who are the developers of the top 3 decentralized applications by transaction volume in South America?\n",
            "SCHEMA: CREATE TABLE decentralized_applications (id INT, name VARCHAR(255), developer VARCHAR(255), transaction_volume DECIMAL(10, 2), country VARCHAR(255)); INSERT INTO decentralized_applications (id, name, developer, transaction_volume, country) VALUES (1, 'App 1', 'Dev 1', 5000.00, 'Brazil'), (2, 'App 2', 'Dev 2', 7000.00, 'Argentina'), (3, 'App 3', 'Dev 3', 3000.50, 'Colombia'), (4, 'App 4', 'Dev 4', 6000.00, 'Chile'), (5, 'App 5', 'Dev 5', 4000.50, 'Peru');\n",
            "Original Answer: SELECT developer, SUM(transaction_volume) FROM decentralized_applications WHERE country IN ('Brazil', 'Argentina', 'Colombia', 'Chile', 'Peru') GROUP BY developer ORDER BY SUM(transaction_volume) DESC LIMIT 3;\n",
            "Generated Answer: SELECT developer FROM decentralized_applications WHERE country = 'South America' ORDER BY transaction_volume DESC LIMIT 3\n",
            "Closest Distance: 0.2910562753677368\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE decentralized_applications (id INT, name VARCHAR(255), developer VARCHAR(255), transaction_volume DECIMAL(10, 2), country VARCHAR(255)); INSERT INTO decentralized_applications (id, name, developer, transaction_volume, country) VALUES (1, 'App 1', 'Dev 1', 5000.00, 'Brazil'), (2, 'App 2', 'Dev 2', 7000.00, 'Argentina'), (3, 'App 3', 'Dev 3', 3000.50, 'Colombia'), (4, 'App 4', 'Dev 4', 6000.00, 'Chile'), (5, 'App 5', 'Dev 5', 4000.50, 'Peru');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT developer, SUM(transaction_volume) FROM decentralized_applications WHERE country IN ('Brazil', 'Argentina', 'Colombia', 'Chile', 'Peru') GROUP BY developer ORDER BY SUM(transaction_volume) DESC LIMIT 3;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 3 \n",
            "\n",
            "('Dev 2', Decimal('7000.00'))\n",
            "('Dev 4', Decimal('6000.00'))\n",
            "('Dev 1', Decimal('5000.00'))\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 92\n",
            "Question: What is the standard deviation of CO2 emissions for garments made from recycled nylon?\n",
            "SCHEMA: CREATE TABLE RecycledNylonGarments (id INT, co2_emission DECIMAL); INSERT INTO RecycledNylonGarments (id, co2_emission) VALUES (1, 7.2), (2, 7.8), (3, 7.6), (4, 8.1), (5, 7.4);\n",
            "Original Answer: SELECT STDDEV(co2_emission) FROM RecycledNylonGarments;\n",
            "Generated Answer: SELECT STDDEV(co2_emission) FROM RecycledNylonGarments\n",
            "Closest Distance: 0.0983736664056778\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE RecycledNylonGarments (id INT, co2_emission DECIMAL); INSERT INTO RecycledNylonGarments (id, co2_emission) VALUES (1, 7.2), (2, 7.8), (3, 7.6), (4, 8.1), (5, 7.4);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT STDDEV(co2_emission) FROM RecycledNylonGarments;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(Decimal('0.34928498393145961293'),)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 93\n",
            "Question: Increase the 'funding' for a specific project by 10% in the 'Funding_Allocation' table.\n",
            "SCHEMA: CREATE TABLE Funding_Allocation (id INT, project VARCHAR(30), funding FLOAT);\n",
            "Original Answer: UPDATE Funding_Allocation SET funding = funding * 1.10 WHERE project = 'Arctic Biodiversity Monitoring';\n",
            "Generated Answer: UPDATE Funding_Allocation SET funding = funding * 1.10 WHERE project ='specific project'\n",
            "Closest Distance: 0.19640782475471497\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Funding_Allocation (id INT, project VARCHAR(30), funding FLOAT);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: UPDATE Funding_Allocation SET funding = funding * 1.10 WHERE project = 'Arctic Biodiversity Monitoring';\n",
            "Database connected successfully\n",
            "Error executing query: no results to fetch\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 94\n",
            "Question: List the names and number of open cases for each government agency in the city of Chicago for the year 2019\n",
            "SCHEMA: CREATE TABLE government_agencies (agency_id INT, agency_name VARCHAR(50), city VARCHAR(20), year INT, cases_open INT); INSERT INTO government_agencies (agency_id, agency_name, city, year, cases_open) VALUES (1, 'Chicago Parks Department', 'Chicago', 2019, 200);\n",
            "Original Answer: SELECT agency_name, cases_open FROM government_agencies WHERE city = 'Chicago' AND year = 2019;\n",
            "Generated Answer: SELECT agency_name, COUNT(cases_open) FROM government_agencies WHERE city = 'Chicago' AND year = 2019 GROUP BY agency_name\n",
            "Closest Distance: 0.3165452778339386\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE government_agencies (agency_id INT, agency_name VARCHAR(50), city VARCHAR(20), year INT, cases_open INT); INSERT INTO government_agencies (agency_id, agency_name, city, year, cases_open) VALUES (1, 'Chicago Parks Department', 'Chicago', 2019, 200);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT agency_name, cases_open FROM government_agencies WHERE city = 'Chicago' AND year = 2019;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "('Chicago Parks Department', 200)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 95\n",
            "Question: How many total attendees identified as part of the Hispanic community attended events in Texas in 2021?\n",
            "SCHEMA: CREATE TABLE Attendees (attendee_id INT, event_id INT, state VARCHAR(50), community_identity VARCHAR(50), attendance_year INT); INSERT INTO Attendees (attendee_id, event_id, state, community_identity, attendance_year) VALUES (15, 60, 'Texas', 'Hispanic', 2021), (16, 61, 'Texas', 'African American', 2021), (17, 62, 'Texas', 'Hispanic', 2021);\n",
            "Original Answer: SELECT COUNT(*) FROM Attendees WHERE state = 'Texas' AND attendance_year = 2021 AND community_identity IN ('Hispanic', 'Mexican', 'Puerto Rican', 'Cuban', 'Spanish');\n",
            "Generated Answer: SELECT COUNT(*) FROM Attendees WHERE state = 'Texas' AND community_identity = 'Hispanic' AND attendance_year = 2021\n",
            "Closest Distance: 0.14693787693977356\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Attendees (attendee_id INT, event_id INT, state VARCHAR(50), community_identity VARCHAR(50), attendance_year INT); INSERT INTO Attendees (attendee_id, event_id, state, community_identity, attendance_year) VALUES (15, 60, 'Texas', 'Hispanic', 2021), (16, 61, 'Texas', 'African American', 2021), (17, 62, 'Texas', 'Hispanic', 2021);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT COUNT(*) FROM Attendees WHERE state = 'Texas' AND attendance_year = 2021 AND community_identity IN ('Hispanic', 'Mexican', 'Puerto Rican', 'Cuban', 'Spanish');\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 1 \n",
            "\n",
            "(2,)\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 96\n",
            "Question: Show all records from the top_ethics_training view\n",
            "SCHEMA: CREATE TABLE workforce_training (id INT PRIMARY KEY, employee_name VARCHAR(255), training_topic VARCHAR(255), training_hours INT, training_completion_date DATE); CREATE VIEW top_ethics_training AS WITH cte AS (SELECT * FROM workforce_training WHERE training_topic = 'ethics') SELECT * FROM cte WHERE training_hours > 5;\n",
            "Original Answer: SELECT * FROM top_ethics_training;\n",
            "Generated Answer: SELECT * FROM top_ethics_training\n",
            "Closest Distance: 0.07149428129196167\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE workforce_training (id INT PRIMARY KEY, employee_name VARCHAR(255), training_topic VARCHAR(255), training_hours INT, training_completion_date DATE); CREATE VIEW top_ethics_training AS WITH cte AS (SELECT * FROM workforce_training WHERE training_topic = 'ethics') SELECT * FROM cte WHERE training_hours > 5;\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT * FROM top_ethics_training;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 97\n",
            "Question: List all cultivation licenses issued in California in 2021, in chronological order.\n",
            "SCHEMA: CREATE TABLE Licenses (License_ID INT, License_Type TEXT, License_Number TEXT, Issue_Date DATE); INSERT INTO Licenses (License_ID, License_Type, License_Number, Issue_Date) VALUES (1, 'Cultivation', 'CA-001-CUL', '2021-01-01');\n",
            "Original Answer: SELECT License_Number, Issue_Date FROM Licenses WHERE License_Type = 'Cultivation' AND YEAR(Issue_Date) = 2021 ORDER BY Issue_Date;\n",
            "Generated Answer: SELECT License_ID, License_Number FROM Licenses WHERE License_Type = 'Cultivation' AND Issue_Date = '2021-01-01' ORDER BY Issue_Date\n",
            "Closest Distance: 0.06873967498540878\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Licenses (License_ID INT, License_Type TEXT, License_Number TEXT, Issue_Date DATE); INSERT INTO Licenses (License_ID, License_Type, License_Number, Issue_Date) VALUES (1, 'Cultivation', 'CA-001-CUL', '2021-01-01');\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT License_Number, Issue_Date FROM Licenses WHERE License_Type = 'Cultivation' AND YEAR(Issue_Date) = 2021 ORDER BY Issue_Date;\n",
            "Database connected successfully\n",
            "Error executing query: function year(date) does not exist\n",
            "LINE 1: ...M Licenses WHERE License_Type = 'Cultivation' AND YEAR(Issue...\n",
            "                                                             ^\n",
            "HINT:  No function matches the given name and argument types. You might need to add explicit type casts.\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 98\n",
            "Question: What is the total amount donated by each program in the last quarter?\n",
            "SCHEMA: CREATE TABLE ProgramDonations (ProgramID INT, DonationDate DATE, DonationAmount DECIMAL(10,2)); INSERT INTO ProgramDonations (ProgramID, DonationDate, DonationAmount) VALUES (1, '2022-01-05', 500.00), (1, '2022-02-10', 750.00), (2, '2022-03-20', 300.00);\n",
            "Original Answer: SELECT ProgramID, SUM(DonationAmount) as TotalDonated FROM (SELECT ProgramID, DonationAmount FROM ProgramDonations WHERE DonationDate >= DATE_TRUNC('quarter', CURRENT_DATE - INTERVAL '3 months') AND DonationDate < DATE_TRUNC('quarter', CURRENT_DATE) + INTERVAL '1 day' ) t GROUP BY ProgramID;\n",
            "Generated Answer: SELECT ProgramID, SUM(DonationAmount) FROM ProgramDonations WHERE DonationDate LIKE \"2022-03-%\" GROUP BY ProgramID\n",
            "Closest Distance: 0.28456825017929077\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE ProgramDonations (ProgramID INT, DonationDate DATE, DonationAmount DECIMAL(10,2)); INSERT INTO ProgramDonations (ProgramID, DonationDate, DonationAmount) VALUES (1, '2022-01-05', 500.00), (1, '2022-02-10', 750.00), (2, '2022-03-20', 300.00);\n",
            "Table Created successfully\n",
            "\n",
            "\n",
            "Similar Query: SELECT ProgramID, SUM(DonationAmount) as TotalDonated FROM (SELECT ProgramID, DonationAmount FROM ProgramDonations WHERE DonationDate >= DATE_TRUNC('quarter', CURRENT_DATE - INTERVAL '3 months') AND DonationDate < DATE_TRUNC('quarter', CURRENT_DATE) + INTERVAL '1 day' ) t GROUP BY ProgramID;\n",
            "Database connected successfully\n",
            "\n",
            "\n",
            "Record(s): 0 \n",
            "\n",
            "\n",
            "\n",
            "Good Query execution\n",
            "\n",
            "\n",
            "\n",
            "Evaluating sample: 99\n",
            "Question: Which programs had more than 25 volunteers in any month of 2022?\n",
            "SCHEMA: CREATE TABLE Volunteers (id INT, program VARCHAR(50), volunteer_count INT, engagement_date DATE); INSERT INTO Volunteers (id, program, volunteer_count, engagement_date) VALUES (1, 'Education', 15, '2022-01-05'), (2, 'Health', 20, '2022-01-12'), (3, 'Education', 25, '2022-03-20'), (4, 'Health', 18, '2022-03-27'), (5, 'Environment', 30, '2022-04-01'), (6, 'Education', 35, '2022-05-15');\n",
            "Original Answer: SELECT program, DATE_FORMAT(engagement_date, '%Y-%m') as engagement_month, SUM(volunteer_count) as total_volunteers FROM Volunteers WHERE engagement_date BETWEEN '2022-01-01' AND '2022-12-31' GROUP BY program, engagement_month HAVING total_volunteers > 25;\n",
            "Generated Answer: SELECT program FROM Volunteers WHERE volunteer_count > 25 AND engagement_date LIKE '2022%'\n",
            "Closest Distance: 0.4901929795742035\n",
            "\n",
            "\n",
            "MATCH (Semantically Similar)\n",
            "\n",
            "\n",
            "SCHEMA QUERY: CREATE TABLE Volunteers (id INT, program VARCHAR(50), volunteer_count INT, engagement_date DATE); INSERT INTO Volunteers (id, program, volunteer_count, engagement_date) VALUES (1, 'Education', 15, '2022-01-05'), (2, 'Health', 20, '2022-01-12'), (3, 'Education', 25, '2022-03-20'), (4, 'Health', 18, '2022-03-27'), (5, 'Environment', 30, '2022-04-01'), (6, 'Education', 35, '2022-05-15');\n",
            "Error creating table: relation \"volunteers\" already exists\n",
            "\n",
            "\n",
            "\n",
            "Similar Query: SELECT program, DATE_FORMAT(engagement_date, '%Y-%m') as engagement_month, SUM(volunteer_count) as total_volunteers FROM Volunteers WHERE engagement_date BETWEEN '2022-01-01' AND '2022-12-31' GROUP BY program, engagement_month HAVING total_volunteers > 25;\n",
            "Database connected successfully\n",
            "Error executing query: column \"program\" does not exist\n",
            "LINE 1: SELECT program, DATE_FORMAT(engagement_date, '%Y-%m') as eng...\n",
            "               ^\n",
            "\n",
            "\n",
            "\n",
            "Bad Query execution\n",
            "\n",
            "\n",
            "\n",
            "Match Accuracy: 97.00%\n",
            "\n",
            "\n",
            "Query Successes: 64.00%\n",
            "\n"
          ]
        }
      ]
    }
  ]
}