Upload 9 files

Dockerfile

@@ -0,0 +1,32 @@
+# Use an official Python runtime as a parent image
+FROM python:3.12
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY . /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Make port 7860 available to the world outside this container
+EXPOSE 7860
+
+# Create a script to run both FastAPI and Streamlit
+RUN echo '#!/bin/bash\n\
+uvicorn main:app --host 0.0.0.0 --port 8000 &\n\
+streamlit run streamlit_app.py --server.port 7860 --server.address 0.0.0.0\n\
+' > /app/run.sh
+
+RUN chmod +x /app/run.sh
+
+# Run the script when the container launches
+CMD ["/app/run.sh"]

main.py

@@ -0,0 +1,74 @@
+# main.py
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import psycopg2
+from psycopg2.extras import RealDictCursor
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+app = FastAPI()
+
+# Load environment variables and configure Genai
+load_dotenv()
+genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
+
+class Query(BaseModel):
+    question: str
+
+def get_gemini_response(question, prompt):
+    model = genai.GenerativeModel('gemini-1.5-pro')
+    response = model.generate_content([prompt, question])
+    return response.text.strip()  # Added strip() to remove any extra whitespace
+
+sql_prompt = """
+Convert the following English question to a PostgreSQL query for the Pagila DVD rental database.
+Only return the SQL query without any markdown formatting or explanations.
+The database has these main tables:
+- actor (actor_id, first_name, last_name)
+- film (film_id, title, description, release_year, rental_rate, length, rating)
+- category (category_id, name)
+- film_category (film_id, category_id)
+- inventory (inventory_id, film_id, store_id)
+- rental (rental_id, rental_date, inventory_id, customer_id, return_date, staff_id)
+- customer (customer_id, first_name, last_name, email)
+- payment (payment_id, customer_id, staff_id, rental_id, amount, payment_date)
+
+Example queries:
+Q: List all actors
+A: SELECT * FROM actor;
+
+Q: Show top 10 most rented movies
+A: SELECT f.title, COUNT(r.rental_id) as rental_count FROM film f JOIN inventory i ON f.film_id = i.film_id JOIN rental r ON i.inventory_id = r.inventory_id GROUP BY f.title ORDER BY rental_count DESC LIMIT 10;
+"""
+
+def execute_sql_query(query):
+    conn = None
+    try:
+        conn = psycopg2.connect(
+            dbname=os.getenv('DB_NAME'),
+            user=os.getenv('DB_USER'),
+            password=os.getenv('DB_PASSWORD'),
+            host=os.getenv('DB_HOST'),
+            port=os.getenv('DB_PORT', '5432')
+        )
+        with conn.cursor(cursor_factory=RealDictCursor) as cursor:
+            cursor.execute(query)
+            result = cursor.fetchall()
+            return result
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Database Error: {str(e)}")
+    finally:
+        if conn:
+            conn.close()
+
+@app.post("/query")
+async def process_query(query: Query):
+    try:
+        sql_query = get_gemini_response(query.question, sql_prompt)
+        # Remove any SQL code block markers if present
+        sql_query = sql_query.replace('```sql', '').replace('```', '').strip()
+        result = execute_sql_query(sql_query)
+        return {"query": sql_query, "result": result}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

pagila/1. pagila-schema.sql

@@ -0,0 +1,1544 @@
+--
+-- PostgreSQL database dump
+--
+
+-- Dumped from database version 9.6.3
+-- Dumped by pg_dump version 10beta1
+
+SET statement_timeout = 0;
+SET lock_timeout = 0;
+SET idle_in_transaction_session_timeout = 0;
+SET client_encoding = 'UTF8';
+SET standard_conforming_strings = on;
+SET check_function_bodies = false;
+SET client_min_messages = warning;
+SET row_security = off;
+
+--
+-- Name: plpgsql; Type: EXTENSION; Schema: -; Owner: 
+--
+
+CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog;
+
+
+--
+-- Name: EXTENSION plpgsql; Type: COMMENT; Schema: -; Owner: 
+--
+
+COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';
+
+
+SET search_path = public, pg_catalog;
+
+--
+-- Name: mpaa_rating; Type: TYPE; Schema: public; Owner: postgres
+--
+
+CREATE TYPE mpaa_rating AS ENUM (
+    'G',
+    'PG',
+    'PG-13',
+    'R',
+    'NC-17'
+);
+
+
+ALTER TYPE mpaa_rating OWNER TO postgres;
+
+--
+-- Name: year; Type: DOMAIN; Schema: public; Owner: postgres
+--
+
+CREATE DOMAIN year AS integer
+	CONSTRAINT year_check CHECK (((VALUE >= 1901) AND (VALUE <= 2155)));
+
+
+ALTER DOMAIN year OWNER TO postgres;
+
+--
+-- Name: _group_concat(text, text); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION _group_concat(text, text) RETURNS text
+    LANGUAGE sql IMMUTABLE
+    AS $_$
+SELECT CASE
+  WHEN $2 IS NULL THEN $1
+  WHEN $1 IS NULL THEN $2
+  ELSE $1 || ', ' || $2
+END
+$_$;
+
+
+ALTER FUNCTION public._group_concat(text, text) OWNER TO postgres;
+
+--
+-- Name: film_in_stock(integer, integer); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION film_in_stock(p_film_id integer, p_store_id integer, OUT p_film_count integer) RETURNS SETOF integer
+    LANGUAGE sql
+    AS $_$
+     SELECT inventory_id
+     FROM inventory
+     WHERE film_id = $1
+     AND store_id = $2
+     AND inventory_in_stock(inventory_id);
+$_$;
+
+
+ALTER FUNCTION public.film_in_stock(p_film_id integer, p_store_id integer, OUT p_film_count integer) OWNER TO postgres;
+
+--
+-- Name: film_not_in_stock(integer, integer); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION film_not_in_stock(p_film_id integer, p_store_id integer, OUT p_film_count integer) RETURNS SETOF integer
+    LANGUAGE sql
+    AS $_$
+    SELECT inventory_id
+    FROM inventory
+    WHERE film_id = $1
+    AND store_id = $2
+    AND NOT inventory_in_stock(inventory_id);
+$_$;
+
+
+ALTER FUNCTION public.film_not_in_stock(p_film_id integer, p_store_id integer, OUT p_film_count integer) OWNER TO postgres;
+
+--
+-- Name: get_customer_balance(integer, timestamp with time zone); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION get_customer_balance(p_customer_id integer, p_effective_date timestamp with time zone) RETURNS numeric
+    LANGUAGE plpgsql
+    AS $$
+       --#OK, WE NEED TO CALCULATE THE CURRENT BALANCE GIVEN A CUSTOMER_ID AND A DATE
+       --#THAT WE WANT THE BALANCE TO BE EFFECTIVE FOR. THE BALANCE IS:
+       --#   1) RENTAL FEES FOR ALL PREVIOUS RENTALS
+       --#   2) ONE DOLLAR FOR EVERY DAY THE PREVIOUS RENTALS ARE OVERDUE
+       --#   3) IF A FILM IS MORE THAN RENTAL_DURATION * 2 OVERDUE, CHARGE THE REPLACEMENT_COST
+       --#   4) SUBTRACT ALL PAYMENTS MADE BEFORE THE DATE SPECIFIED
+DECLARE
+    v_rentfees DECIMAL(5,2); --#FEES PAID TO RENT THE VIDEOS INITIALLY
+    v_overfees INTEGER;      --#LATE FEES FOR PRIOR RENTALS
+    v_payments DECIMAL(5,2); --#SUM OF PAYMENTS MADE PREVIOUSLY
+BEGIN
+    SELECT COALESCE(SUM(film.rental_rate),0) INTO v_rentfees
+    FROM film, inventory, rental
+    WHERE film.film_id = inventory.film_id
+      AND inventory.inventory_id = rental.inventory_id
+      AND rental.rental_date <= p_effective_date
+      AND rental.customer_id = p_customer_id;
+
+    SELECT COALESCE(SUM(IF((rental.return_date - rental.rental_date) > (film.rental_duration * '1 day'::interval),
+        ((rental.return_date - rental.rental_date) - (film.rental_duration * '1 day'::interval)),0)),0) INTO v_overfees
+    FROM rental, inventory, film
+    WHERE film.film_id = inventory.film_id
+      AND inventory.inventory_id = rental.inventory_id
+      AND rental.rental_date <= p_effective_date
+      AND rental.customer_id = p_customer_id;
+
+    SELECT COALESCE(SUM(payment.amount),0) INTO v_payments
+    FROM payment
+    WHERE payment.payment_date <= p_effective_date
+    AND payment.customer_id = p_customer_id;
+
+    RETURN v_rentfees + v_overfees - v_payments;
+END
+$$;
+
+
+ALTER FUNCTION public.get_customer_balance(p_customer_id integer, p_effective_date timestamp with time zone) OWNER TO postgres;
+
+--
+-- Name: inventory_held_by_customer(integer); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION inventory_held_by_customer(p_inventory_id integer) RETURNS integer
+    LANGUAGE plpgsql
+    AS $$
+DECLARE
+    v_customer_id INTEGER;
+BEGIN
+
+  SELECT customer_id INTO v_customer_id
+  FROM rental
+  WHERE return_date IS NULL
+  AND inventory_id = p_inventory_id;
+
+  RETURN v_customer_id;
+END $$;
+
+
+ALTER FUNCTION public.inventory_held_by_customer(p_inventory_id integer) OWNER TO postgres;
+
+--
+-- Name: inventory_in_stock(integer); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION inventory_in_stock(p_inventory_id integer) RETURNS boolean
+    LANGUAGE plpgsql
+    AS $$
+DECLARE
+    v_rentals INTEGER;
+    v_out     INTEGER;
+BEGIN
+    -- AN ITEM IS IN-STOCK IF THERE ARE EITHER NO ROWS IN THE rental TABLE
+    -- FOR THE ITEM OR ALL ROWS HAVE return_date POPULATED
+
+    SELECT count(*) INTO v_rentals
+    FROM rental
+    WHERE inventory_id = p_inventory_id;
+
+    IF v_rentals = 0 THEN
+      RETURN TRUE;
+    END IF;
+
+    SELECT COUNT(rental_id) INTO v_out
+    FROM inventory LEFT JOIN rental USING(inventory_id)
+    WHERE inventory.inventory_id = p_inventory_id
+    AND rental.return_date IS NULL;
+
+    IF v_out > 0 THEN
+      RETURN FALSE;
+    ELSE
+      RETURN TRUE;
+    END IF;
+END $$;
+
+
+ALTER FUNCTION public.inventory_in_stock(p_inventory_id integer) OWNER TO postgres;
+
+--
+-- Name: last_day(timestamp with time zone); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION last_day(timestamp with time zone) RETURNS date
+    LANGUAGE sql IMMUTABLE STRICT
+    AS $_$
+  SELECT CASE
+    WHEN EXTRACT(MONTH FROM $1) = 12 THEN
+      (((EXTRACT(YEAR FROM $1) + 1) operator(pg_catalog.||) '-01-01')::date - INTERVAL '1 day')::date
+    ELSE
+      ((EXTRACT(YEAR FROM $1) operator(pg_catalog.||) '-' operator(pg_catalog.||) (EXTRACT(MONTH FROM $1) + 1) operator(pg_catalog.||) '-01')::date - INTERVAL '1 day')::date
+    END
+$_$;
+
+
+ALTER FUNCTION public.last_day(timestamp with time zone) OWNER TO postgres;
+
+--
+-- Name: last_updated(); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION last_updated() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+BEGIN
+    NEW.last_update = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END $$;
+
+
+ALTER FUNCTION public.last_updated() OWNER TO postgres;
+
+--
+-- Name: customer_customer_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE customer_customer_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE customer_customer_id_seq OWNER TO postgres;
+
+SET default_tablespace = '';
+
+SET default_with_oids = false;
+
+--
+-- Name: customer; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE customer (
+    customer_id SERIAL PRIMARY KEY,
+    store_id smallint NOT NULL,
+    first_name text NOT NULL,
+    last_name text NOT NULL,
+    email text,
+    address_id smallint NOT NULL,
+    activebool boolean DEFAULT true NOT NULL,
+    create_date date DEFAULT ('now'::text)::date NOT NULL,
+    last_update timestamp with time zone DEFAULT now(),
+    active integer
+);
+
+
+ALTER TABLE customer OWNER TO postgres;
+
+--
+-- Name: rewards_report(integer, numeric); Type: FUNCTION; Schema: public; Owner: postgres
+--
+
+CREATE FUNCTION rewards_report(min_monthly_purchases integer, min_dollar_amount_purchased numeric) RETURNS SETOF customer
+    LANGUAGE plpgsql SECURITY DEFINER
+    AS $_$
+DECLARE
+    last_month_start DATE;
+    last_month_end DATE;
+rr RECORD;
+tmpSQL TEXT;
+BEGIN
+
+    /* Some sanity checks... */
+    IF min_monthly_purchases = 0 THEN
+        RAISE EXCEPTION 'Minimum monthly purchases parameter must be > 0';
+    END IF;
+    IF min_dollar_amount_purchased = 0.00 THEN
+        RAISE EXCEPTION 'Minimum monthly dollar amount purchased parameter must be > $0.00';
+    END IF;
+
+    last_month_start := CURRENT_DATE - '3 month'::interval;
+    last_month_start := to_date((extract(YEAR FROM last_month_start) || '-' || extract(MONTH FROM last_month_start) || '-01'),'YYYY-MM-DD');
+    last_month_end := LAST_DAY(last_month_start);
+
+    /*
+    Create a temporary storage area for Customer IDs.
+    */
+    CREATE TEMPORARY TABLE tmpCustomer (customer_id INTEGER NOT NULL PRIMARY KEY);
+
+    /*
+    Find all customers meeting the monthly purchase requirements
+    */
+
+    tmpSQL := 'INSERT INTO tmpCustomer (customer_id)
+        SELECT p.customer_id
+        FROM payment AS p
+        WHERE DATE(p.payment_date) BETWEEN '||quote_literal(last_month_start) ||' AND '|| quote_literal(last_month_end) || '
+        GROUP BY customer_id
+        HAVING SUM(p.amount) > '|| min_dollar_amount_purchased || '
+        AND COUNT(customer_id) > ' ||min_monthly_purchases ;
+
+    EXECUTE tmpSQL;
+
+    /*
+    Output ALL customer information of matching rewardees.
+    Customize output as needed.
+    */
+    FOR rr IN EXECUTE 'SELECT c.* FROM tmpCustomer AS t INNER JOIN customer AS c ON t.customer_id = c.customer_id' LOOP
+        RETURN NEXT rr;
+    END LOOP;
+
+    /* Clean up */
+    tmpSQL := 'DROP TABLE tmpCustomer';
+    EXECUTE tmpSQL;
+
+RETURN;
+END
+$_$;
+
+
+ALTER FUNCTION public.rewards_report(min_monthly_purchases integer, min_dollar_amount_purchased numeric) OWNER TO postgres;
+
+--
+-- Name: group_concat(text); Type: AGGREGATE; Schema: public; Owner: postgres
+--
+
+CREATE AGGREGATE group_concat(text) (
+    SFUNC = _group_concat,
+    STYPE = text
+);
+
+
+ALTER AGGREGATE public.group_concat(text) OWNER TO postgres;
+
+--
+-- Name: actor_actor_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE actor_actor_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE actor_actor_id_seq OWNER TO postgres;
+
+--
+-- Name: actor; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE actor (
+    actor_id integer DEFAULT nextval('actor_actor_id_seq'::regclass) NOT NULL,
+    first_name text NOT NULL,
+    last_name text NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE actor OWNER TO postgres;
+
+--
+-- Name: category_category_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE category_category_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE category_category_id_seq OWNER TO postgres;
+
+--
+-- Name: category; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE category (
+    category_id integer DEFAULT nextval('category_category_id_seq'::regclass) NOT NULL,
+    name text NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE category OWNER TO postgres;
+
+--
+-- Name: film_film_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE film_film_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE film_film_id_seq OWNER TO postgres;
+
+--
+-- Name: film; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE film (
+    film_id integer DEFAULT nextval('film_film_id_seq'::regclass) NOT NULL,
+    title text NOT NULL,
+    description text,
+    release_year year,
+    language_id smallint NOT NULL,
+    original_language_id smallint,
+    rental_duration smallint DEFAULT 3 NOT NULL,
+    rental_rate numeric(4,2) DEFAULT 4.99 NOT NULL,
+    length smallint,
+    replacement_cost numeric(5,2) DEFAULT 19.99 NOT NULL,
+    rating mpaa_rating DEFAULT 'G'::mpaa_rating,
+    last_update timestamp with time zone DEFAULT now() NOT NULL,
+    special_features text[],
+    fulltext tsvector NOT NULL
+);
+
+
+ALTER TABLE film OWNER TO postgres;
+
+--
+-- Name: film_actor; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE film_actor (
+    actor_id smallint NOT NULL,
+    film_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE film_actor OWNER TO postgres;
+
+--
+-- Name: film_category; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE film_category (
+    film_id smallint NOT NULL,
+    category_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE film_category OWNER TO postgres;
+
+--
+-- Name: actor_info; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW actor_info AS
+ SELECT a.actor_id,
+    a.first_name,
+    a.last_name,
+    group_concat(DISTINCT (((c.name)::text || ': '::text) || ( SELECT group_concat((f.title)::text) AS group_concat
+           FROM ((film f
+             JOIN film_category fc_1 ON ((f.film_id = fc_1.film_id)))
+             JOIN film_actor fa_1 ON ((f.film_id = fa_1.film_id)))
+          WHERE ((fc_1.category_id = c.category_id) AND (fa_1.actor_id = a.actor_id))
+          GROUP BY fa_1.actor_id))) AS film_info
+   FROM (((actor a
+     LEFT JOIN film_actor fa ON ((a.actor_id = fa.actor_id)))
+     LEFT JOIN film_category fc ON ((fa.film_id = fc.film_id)))
+     LEFT JOIN category c ON ((fc.category_id = c.category_id)))
+  GROUP BY a.actor_id, a.first_name, a.last_name;
+
+
+ALTER TABLE actor_info OWNER TO postgres;
+
+--
+-- Name: address_address_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE address_address_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE address_address_id_seq OWNER TO postgres;
+
+--
+-- Name: address; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE address (
+    address_id integer DEFAULT nextval('address_address_id_seq'::regclass) NOT NULL,
+    address text NOT NULL,
+    address2 text,
+    district text NOT NULL,
+    city_id smallint NOT NULL,
+    postal_code text,
+    phone text NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE address OWNER TO postgres;
+
+--
+-- Name: city_city_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE city_city_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE city_city_id_seq OWNER TO postgres;
+
+--
+-- Name: city; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE city (
+    city_id integer DEFAULT nextval('city_city_id_seq'::regclass) NOT NULL,
+    city text NOT NULL,
+    country_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE city OWNER TO postgres;
+
+--
+-- Name: country_country_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE country_country_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE country_country_id_seq OWNER TO postgres;
+
+--
+-- Name: country; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE country (
+    country_id integer DEFAULT nextval('country_country_id_seq'::regclass) NOT NULL,
+    country text NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE country OWNER TO postgres;
+
+--
+-- Name: customer_list; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW customer_list AS
+ SELECT cu.customer_id AS id,
+    (((cu.first_name)::text || ' '::text) || (cu.last_name)::text) AS name,
+    a.address,
+    a.postal_code AS "zip code",
+    a.phone,
+    city.city,
+    country.country,
+        CASE
+            WHEN cu.activebool THEN 'active'::text
+            ELSE ''::text
+        END AS notes,
+    cu.store_id AS sid
+   FROM (((customer cu
+     JOIN address a ON ((cu.address_id = a.address_id)))
+     JOIN city ON ((a.city_id = city.city_id)))
+     JOIN country ON ((city.country_id = country.country_id)));
+
+
+ALTER TABLE customer_list OWNER TO postgres;
+
+--
+-- Name: film_list; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW film_list AS
+ SELECT film.film_id AS fid,
+    film.title,
+    film.description,
+    category.name AS category,
+    film.rental_rate AS price,
+    film.length,
+    film.rating,
+    group_concat((((actor.first_name)::text || ' '::text) || (actor.last_name)::text)) AS actors
+   FROM ((((category
+     LEFT JOIN film_category ON ((category.category_id = film_category.category_id)))
+     LEFT JOIN film ON ((film_category.film_id = film.film_id)))
+     JOIN film_actor ON ((film.film_id = film_actor.film_id)))
+     JOIN actor ON ((film_actor.actor_id = actor.actor_id)))
+  GROUP BY film.film_id, film.title, film.description, category.name, film.rental_rate, film.length, film.rating;
+
+
+ALTER TABLE film_list OWNER TO postgres;
+
+--
+-- Name: inventory_inventory_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE inventory_inventory_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE inventory_inventory_id_seq OWNER TO postgres;
+
+--
+-- Name: inventory; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE inventory (
+    inventory_id integer DEFAULT nextval('inventory_inventory_id_seq'::regclass) NOT NULL,
+    film_id smallint NOT NULL,
+    store_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE inventory OWNER TO postgres;
+
+--
+-- Name: language_language_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE language_language_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE language_language_id_seq OWNER TO postgres;
+
+--
+-- Name: language; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE language (
+    language_id integer DEFAULT nextval('language_language_id_seq'::regclass) NOT NULL,
+    name character(20) NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE language OWNER TO postgres;
+
+--
+-- Name: nicer_but_slower_film_list; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW nicer_but_slower_film_list AS
+ SELECT film.film_id AS fid,
+    film.title,
+    film.description,
+    category.name AS category,
+    film.rental_rate AS price,
+    film.length,
+    film.rating,
+    group_concat((((upper("substring"((actor.first_name)::text, 1, 1)) || lower("substring"((actor.first_name)::text, 2))) || upper("substring"((actor.last_name)::text, 1, 1))) || lower("substring"((actor.last_name)::text, 2)))) AS actors
+   FROM ((((category
+     LEFT JOIN film_category ON ((category.category_id = film_category.category_id)))
+     LEFT JOIN film ON ((film_category.film_id = film.film_id)))
+     JOIN film_actor ON ((film.film_id = film_actor.film_id)))
+     JOIN actor ON ((film_actor.actor_id = actor.actor_id)))
+  GROUP BY film.film_id, film.title, film.description, category.name, film.rental_rate, film.length, film.rating;
+
+
+ALTER TABLE nicer_but_slower_film_list OWNER TO postgres;
+
+--
+-- Name: payment_payment_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE payment_payment_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE payment_payment_id_seq OWNER TO postgres;
+
+--
+-- Name: payment; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment (
+    payment_id integer DEFAULT nextval('payment_payment_id_seq'::regclass) NOT NULL,
+    customer_id smallint NOT NULL,
+    staff_id smallint NOT NULL,
+    rental_id integer NOT NULL,
+    amount numeric(5,2) NOT NULL,
+    payment_date timestamp with time zone NOT NULL
+) PARTITION BY RANGE(payment_date);
+
+ALTER TABLE payment OWNER TO postgres;
+
+--
+-- Name: payment_p2017_01; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_01 PARTITION OF payment
+    FOR VALUES FROM ('2017-01-01 00:00:00+3:00') TO ('2017-02-01 00:00:00+3:00');
+
+ALTER TABLE payment_p2017_01 OWNER TO postgres;
+
+--
+-- Name: payment_p2017_02; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_02 PARTITION OF payment
+    FOR VALUES FROM ('2017-02-01 00:00:00+3:00') TO ('2017-03-01 00:00:00+3:00');
+
+ALTER TABLE payment_p2017_02 OWNER TO postgres;
+
+--
+-- Name: payment_p2017_03; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_03 PARTITION OF payment
+    FOR VALUES FROM ('2017-03-01 00:00:00+3:00') TO ('2017-04-01 00:00:00+3:00');
+
+
+ALTER TABLE payment_p2017_03 OWNER TO postgres;
+
+--
+-- Name: payment_p2017_04; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_04 PARTITION OF payment
+    FOR VALUES FROM ('2017-04-01 00:00:00+3:00') TO ('2017-05-01 00:00:00+3:00');
+
+ALTER TABLE payment_p2017_04 OWNER TO postgres;
+
+--
+-- Name: payment_p2017_05; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_05 PARTITION OF payment
+    FOR VALUES FROM ('2017-05-01 00:00:00+3:00') TO ('2017-06-01 00:00:00+3:00');
+
+ALTER TABLE payment_p2017_05 OWNER TO postgres;
+
+--
+-- Name: payment_p2017_06; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE payment_p2017_06 PARTITION OF payment
+    FOR VALUES FROM ('2017-06-01 00:00:00+3:00') TO ('2017-07-01 00:00:00+3:00');
+
+
+ALTER TABLE payment_p2017_06 OWNER TO postgres;
+
+--
+-- Name: rental_rental_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE rental_rental_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE rental_rental_id_seq OWNER TO postgres;
+
+--
+-- Name: rental; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE rental (
+    rental_id integer DEFAULT nextval('rental_rental_id_seq'::regclass) NOT NULL,
+    rental_date timestamp with time zone NOT NULL,
+    inventory_id integer NOT NULL,
+    customer_id smallint NOT NULL,
+    return_date timestamp with time zone,
+    staff_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE rental OWNER TO postgres;
+
+--
+-- Name: sales_by_film_category; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW sales_by_film_category AS
+ SELECT c.name AS category,
+    sum(p.amount) AS total_sales
+   FROM (((((payment p
+     JOIN rental r ON ((p.rental_id = r.rental_id)))
+     JOIN inventory i ON ((r.inventory_id = i.inventory_id)))
+     JOIN film f ON ((i.film_id = f.film_id)))
+     JOIN film_category fc ON ((f.film_id = fc.film_id)))
+     JOIN category c ON ((fc.category_id = c.category_id)))
+  GROUP BY c.name
+  ORDER BY (sum(p.amount)) DESC;
+
+
+ALTER TABLE sales_by_film_category OWNER TO postgres;
+
+--
+-- Name: staff_staff_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE staff_staff_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE staff_staff_id_seq OWNER TO postgres;
+
+--
+-- Name: staff; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE staff (
+    staff_id integer DEFAULT nextval('staff_staff_id_seq'::regclass) NOT NULL,
+    first_name text NOT NULL,
+    last_name text NOT NULL,
+    address_id smallint NOT NULL,
+    email text,
+    store_id smallint NOT NULL,
+    active boolean DEFAULT true NOT NULL,
+    username text NOT NULL,
+    password text,
+    last_update timestamp with time zone DEFAULT now() NOT NULL,
+    picture bytea
+);
+
+
+ALTER TABLE staff OWNER TO postgres;
+
+--
+-- Name: store_store_id_seq; Type: SEQUENCE; Schema: public; Owner: postgres
+--
+
+CREATE SEQUENCE store_store_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+ALTER TABLE store_store_id_seq OWNER TO postgres;
+
+--
+-- Name: store; Type: TABLE; Schema: public; Owner: postgres
+--
+
+CREATE TABLE store (
+    store_id integer DEFAULT nextval('store_store_id_seq'::regclass) NOT NULL,
+    manager_staff_id smallint NOT NULL,
+    address_id smallint NOT NULL,
+    last_update timestamp with time zone DEFAULT now() NOT NULL
+);
+
+
+ALTER TABLE store OWNER TO postgres;
+
+--
+-- Name: sales_by_store; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW sales_by_store AS
+ SELECT (((c.city)::text || ','::text) || (cy.country)::text) AS store,
+    (((m.first_name)::text || ' '::text) || (m.last_name)::text) AS manager,
+    sum(p.amount) AS total_sales
+   FROM (((((((payment p
+     JOIN rental r ON ((p.rental_id = r.rental_id)))
+     JOIN inventory i ON ((r.inventory_id = i.inventory_id)))
+     JOIN store s ON ((i.store_id = s.store_id)))
+     JOIN address a ON ((s.address_id = a.address_id)))
+     JOIN city c ON ((a.city_id = c.city_id)))
+     JOIN country cy ON ((c.country_id = cy.country_id)))
+     JOIN staff m ON ((s.manager_staff_id = m.staff_id)))
+  GROUP BY cy.country, c.city, s.store_id, m.first_name, m.last_name
+  ORDER BY cy.country, c.city;
+
+
+ALTER TABLE sales_by_store OWNER TO postgres;
+
+--
+-- Name: staff_list; Type: VIEW; Schema: public; Owner: postgres
+--
+
+CREATE VIEW staff_list AS
+ SELECT s.staff_id AS id,
+    (((s.first_name)::text || ' '::text) || (s.last_name)::text) AS name,
+    a.address,
+    a.postal_code AS "zip code",
+    a.phone,
+    city.city,
+    country.country,
+    s.store_id AS sid
+   FROM (((staff s
+     JOIN address a ON ((s.address_id = a.address_id)))
+     JOIN city ON ((a.city_id = city.city_id)))
+     JOIN country ON ((city.country_id = country.country_id)));
+
+
+ALTER TABLE staff_list OWNER TO postgres;
+
+--
+-- Name: actor actor_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY actor
+    ADD CONSTRAINT actor_pkey PRIMARY KEY (actor_id);
+
+
+--
+-- Name: address address_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY address
+    ADD CONSTRAINT address_pkey PRIMARY KEY (address_id);
+
+
+--
+-- Name: category category_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY category
+    ADD CONSTRAINT category_pkey PRIMARY KEY (category_id);
+
+
+--
+-- Name: city city_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY city
+    ADD CONSTRAINT city_pkey PRIMARY KEY (city_id);
+
+
+--
+-- Name: country country_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY country
+    ADD CONSTRAINT country_pkey PRIMARY KEY (country_id);
+
+
+
+--
+-- Name: film_actor film_actor_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_actor
+    ADD CONSTRAINT film_actor_pkey PRIMARY KEY (actor_id, film_id);
+
+
+--
+-- Name: film_category film_category_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_category
+    ADD CONSTRAINT film_category_pkey PRIMARY KEY (film_id, category_id);
+
+
+--
+-- Name: film film_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film
+    ADD CONSTRAINT film_pkey PRIMARY KEY (film_id);
+
+
+--
+-- Name: inventory inventory_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY inventory
+    ADD CONSTRAINT inventory_pkey PRIMARY KEY (inventory_id);
+
+
+--
+-- Name: language language_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY language
+    ADD CONSTRAINT language_pkey PRIMARY KEY (language_id);
+
+
+--
+-- Name: rental rental_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY rental
+    ADD CONSTRAINT rental_pkey PRIMARY KEY (rental_id);
+
+
+--
+-- Name: staff staff_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY staff
+    ADD CONSTRAINT staff_pkey PRIMARY KEY (staff_id);
+
+
+--
+-- Name: store store_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY store
+    ADD CONSTRAINT store_pkey PRIMARY KEY (store_id);
+
+
+--
+-- Name: film_fulltext_idx; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX film_fulltext_idx ON film USING gist (fulltext);
+
+
+--
+-- Name: idx_actor_last_name; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_actor_last_name ON actor USING btree (last_name);
+
+
+--
+-- Name: idx_fk_address_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_address_id ON customer USING btree (address_id);
+
+
+--
+-- Name: idx_fk_city_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_city_id ON address USING btree (city_id);
+
+
+--
+-- Name: idx_fk_country_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_country_id ON city USING btree (country_id);
+
+
+--
+-- Name: idx_fk_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_customer_id ON payment USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_film_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_film_id ON film_actor USING btree (film_id);
+
+
+--
+-- Name: idx_fk_inventory_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_inventory_id ON rental USING btree (inventory_id);
+
+
+--
+-- Name: idx_fk_language_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_language_id ON film USING btree (language_id);
+
+
+--
+-- Name: idx_fk_original_language_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_original_language_id ON film USING btree (original_language_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_01_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_01_customer_id ON payment_p2017_01 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_01_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_01_staff_id ON payment_p2017_01 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_02_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_02_customer_id ON payment_p2017_02 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_02_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_02_staff_id ON payment_p2017_02 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_03_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_03_customer_id ON payment_p2017_03 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_03_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_03_staff_id ON payment_p2017_03 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_04_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_04_customer_id ON payment_p2017_04 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_04_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_04_staff_id ON payment_p2017_04 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_05_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_05_customer_id ON payment_p2017_05 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_05_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_05_staff_id ON payment_p2017_05 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_06_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_06_customer_id ON payment_p2017_06 USING btree (customer_id);
+
+
+--
+-- Name: idx_fk_payment_p2017_06_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_payment_p2017_06_staff_id ON payment_p2017_06 USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_staff_id ON payment USING btree (staff_id);
+
+
+--
+-- Name: idx_fk_store_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_fk_store_id ON customer USING btree (store_id);
+
+
+--
+-- Name: idx_last_name; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_last_name ON customer USING btree (last_name);
+
+
+--
+-- Name: idx_store_id_film_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_store_id_film_id ON inventory USING btree (store_id, film_id);
+
+
+--
+-- Name: idx_title; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE INDEX idx_title ON film USING btree (title);
+
+
+--
+-- Name: idx_unq_manager_staff_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE UNIQUE INDEX idx_unq_manager_staff_id ON store USING btree (manager_staff_id);
+
+
+--
+-- Name: idx_unq_rental_rental_date_inventory_id_customer_id; Type: INDEX; Schema: public; Owner: postgres
+--
+
+CREATE UNIQUE INDEX idx_unq_rental_rental_date_inventory_id_customer_id ON rental USING btree (rental_date, inventory_id, customer_id);
+
+--
+-- Name: film film_fulltext_trigger; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER film_fulltext_trigger BEFORE INSERT OR UPDATE ON film FOR EACH ROW EXECUTE PROCEDURE tsvector_update_trigger('fulltext', 'pg_catalog.english', 'title', 'description');
+
+
+--
+-- Name: actor last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON actor FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: address last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON address FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: category last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON category FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: city last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON city FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: country last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON country FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: customer last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON customer FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: film last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON film FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: film_actor last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON film_actor FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: film_category last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON film_category FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: inventory last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON inventory FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: language last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON language FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: rental last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON rental FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: staff last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON staff FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: store last_updated; Type: TRIGGER; Schema: public; Owner: postgres
+--
+
+CREATE TRIGGER last_updated BEFORE UPDATE ON store FOR EACH ROW EXECUTE PROCEDURE last_updated();
+
+
+--
+-- Name: address address_city_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY address
+    ADD CONSTRAINT address_city_id_fkey FOREIGN KEY (city_id) REFERENCES city(city_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: city city_country_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY city
+    ADD CONSTRAINT city_country_id_fkey FOREIGN KEY (country_id) REFERENCES country(country_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: customer customer_address_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY customer
+    ADD CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) REFERENCES address(address_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: customer customer_store_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY customer
+    ADD CONSTRAINT customer_store_id_fkey FOREIGN KEY (store_id) REFERENCES store(store_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film_actor film_actor_actor_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_actor
+    ADD CONSTRAINT film_actor_actor_id_fkey FOREIGN KEY (actor_id) REFERENCES actor(actor_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film_actor film_actor_film_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_actor
+    ADD CONSTRAINT film_actor_film_id_fkey FOREIGN KEY (film_id) REFERENCES film(film_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film_category film_category_category_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_category
+    ADD CONSTRAINT film_category_category_id_fkey FOREIGN KEY (category_id) REFERENCES category(category_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film_category film_category_film_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film_category
+    ADD CONSTRAINT film_category_film_id_fkey FOREIGN KEY (film_id) REFERENCES film(film_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film film_language_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film
+    ADD CONSTRAINT film_language_id_fkey FOREIGN KEY (language_id) REFERENCES language(language_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: film film_original_language_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY film
+    ADD CONSTRAINT film_original_language_id_fkey FOREIGN KEY (original_language_id) REFERENCES language(language_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: inventory inventory_film_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY inventory
+    ADD CONSTRAINT inventory_film_id_fkey FOREIGN KEY (film_id) REFERENCES film(film_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: inventory inventory_store_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY inventory
+    ADD CONSTRAINT inventory_store_id_fkey FOREIGN KEY (store_id) REFERENCES store(store_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+--
+-- Name: rental rental_customer_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY rental
+    ADD CONSTRAINT rental_customer_id_fkey FOREIGN KEY (customer_id) REFERENCES customer(customer_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: rental rental_inventory_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY rental
+    ADD CONSTRAINT rental_inventory_id_fkey FOREIGN KEY (inventory_id) REFERENCES inventory(inventory_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: rental rental_staff_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY rental
+    ADD CONSTRAINT rental_staff_id_fkey FOREIGN KEY (staff_id) REFERENCES staff(staff_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: staff staff_address_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY staff
+    ADD CONSTRAINT staff_address_id_fkey FOREIGN KEY (address_id) REFERENCES address(address_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- Name: staff staff_store_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY staff
+    ADD CONSTRAINT staff_store_id_fkey FOREIGN KEY (store_id) REFERENCES store(store_id);
+
+
+--
+-- Name: store store_address_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: postgres
+--
+
+ALTER TABLE ONLY store
+    ADD CONSTRAINT store_address_id_fkey FOREIGN KEY (address_id) REFERENCES address(address_id) ON UPDATE CASCADE ON DELETE RESTRICT;
+
+
+--
+-- PostgreSQL database dump complete
+--
+
+
+ALTER TABLE payment_p2017_01
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);
+
+ALTER TABLE payment_p2017_02
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);
+
+ALTER TABLE payment_p2017_03
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);
+
+ALTER TABLE payment_p2017_04
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);
+
+ALTER TABLE payment_p2017_05
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);
+
+ALTER TABLE payment_p2017_06
+    ADD FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
+    ADD FOREIGN KEY(staff_id) REFERENCES staff(staff_id),
+    ADD FOREIGN KEY(rental_id) REFERENCES rental(rental_id);

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+streamlit
+pandas
+python-dotenv
+google-generativeai
+requests
+psycopg2-binary

streamlit_app.py

@@ -0,0 +1,59 @@
+# streamlit_app.py
+import streamlit as st
+import requests
+import pandas as pd
+
+st.set_page_config(page_title="QueryMate: Natural Language to SQL")
+
+st.markdown("# Text to SQL - PagilaDB🤖")
+st.markdown('''Your friendly assistant for converting natural language queries into SQL statements!
+               Ask questions about the Pagila DVD rental database.''')
+
+# Initialize chat history
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+
+# Predefined queries
+# Update the predefined_queries list
+predefined_queries = [
+    'List the top 10 most rented movies with their rental counts',
+    'Calculate total revenue for each movie category',
+    'Find customers who have spent more than $150 total',
+    'Show all movies in the Action category with their rental rates',
+]
+
+st.markdown("### Predefined Queries")
+for query in predefined_queries:
+    if st.button(query):
+        st.session_state.predefined_query = query
+
+st.markdown("### Enter Your Question")
+question = st.text_input("Input: ", key="input", value=st.session_state.get('predefined_query', ''))
+
+if st.button("Submit"):
+    response = requests.post("http://localhost:8000/query", 
+                           json={"question": question})
+    if response.status_code == 200:
+        data = response.json()
+        st.markdown("## Generated SQL Query")
+        st.code(data['query'], language='sql')
+        
+        st.markdown("## Query Results")
+        df = pd.DataFrame(data['result'])
+        st.dataframe(df)
+
+        # Update chat history
+        st.session_state.chat_history.append(f"👨‍💻: {question}")
+        st.session_state.chat_history.append(f"🤖: {data['query']}")
+    else:
+        st.error(f"Error: {response.text}")
+
+    st.session_state.pop('predefined_query', None)
+
+st.markdown("## Chat History")
+for message in st.session_state.chat_history:
+    st.text(message)
+
+if st.button("Clear History"):
+    st.session_state.chat_history = []
+    st.success("Chat history cleared!")

tests/Pagila Evals Dataset(Sheet1).csv

@@ -0,0 +1,41 @@
+Query Number,Natural Language Query,Difficulty
+1,List all actors' first and last names.,Easy
+2,Show the titles of all films in the database.,Easy
+3,Get the names of all cities.,Easy
+4,List all categories available for films.,Easy
+5,Show the first name and last name of all customers.,Easy
+6,Show all films released in 2006.,Easy
+7,"Find all actors with the last name ""Smith.""",Easy
+8,List all customers who are from the city of �New York.�,Easy
+9,Get all stores located in the country �India.�,Easy
+10,Show all films with a rental rate greater than $2.99.,Easy
+11,How many films are there in each category?,Medium
+12,What is the total number of actors?,Medium
+13,Get the total payment received in June 2022.,Medium
+14,Find the total number of rentals made last month.,Medium
+15,How many films have a rating of �PG-13�?,Medium
+16,List all films along with their category names.,Medium
+17,"Show all actors who appeared in the film ""Inception.""",Medium
+18,Get a list of all customers and the films they have rented.,Medium
+19,List all staff members along with the stores they work at.,Medium
+20,"Find all films rented by customer ""John Doe.""",Medium
+21,Show the top 5 films rented the most across all stores.,Medium
+22,List all customers who have rented films in both store 1 and store 2.,Medium
+23,Find all actors who have appeared in more than 10 films.,Medium
+24,Get a list of customers who have made more than 5 payments.,Medium
+25,"List all films that are in both the ""Action"" and ""Comedy"" categories.",Medium
+26,Show all rentals made in the last 7 days.,Medium
+27,Get all payments made in February 2022.,Medium
+28,List all films that have not been rented in the last 30 days.,Medium
+29,Find all customers who registered in the last 6 months.,Medium
+30,"Show all staff members hired before January 1, 2020.",Medium
+31,List the top 3 customers who have spent the most in each country.,Hard
+32,Find the films that have been rented more times than the average number of rentals per film.,Hard
+33,"For each actor, show their name and the percentage of films they've acted in compared to the total films.",Hard
+34,Show the average payment amount for each customer.,Hard
+35,List all actors who have appeared in at least one film in each category.,Hard
+36,Find customers who have rented more films this year than last year.,Hard
+37,List the top 5 films with the highest revenue.,Hard
+38,"For each customer, show the number of films rented in the last month compared to the previous month.",Hard
+39,Show the names of customers who have rented every film in the �Action� category.,Hard
+40,List customers who have rented the same film more than 3 times.,Hard

tests/results/query_results.json

@@ -0,0 +1,282 @@
+{
+  "1": {
+    "natural_language_query": "List all actors' first and last names.",
+    "sql_query": "SELECT first_name, last_name FROM actor;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "2": {
+    "natural_language_query": "Show the titles of all films in the database.",
+    "sql_query": "SELECT title FROM film;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "3": {
+    "natural_language_query": "Get the names of all cities.",
+    "sql_query": "SELECT city FROM city;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "4": {
+    "natural_language_query": "List all categories available for films.",
+    "sql_query": "SELECT name FROM category;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "5": {
+    "natural_language_query": "Show the first name and last name of all customers.",
+    "sql_query": "SELECT first_name, last_name FROM customer;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "6": {
+    "natural_language_query": "Show all films released in 2006.",
+    "sql_query": "SELECT * FROM film WHERE release_year = 2006;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "7": {
+    "natural_language_query": "Find all actors with the last name \"Smith.\"",
+    "sql_query": "SELECT * FROM actor WHERE last_name = 'Smith';",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "8": {
+    "natural_language_query": "List all customers who are from the city of “New York.”",
+    "sql_query": null,
+    "difficulty": "Easy",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "9": {
+    "natural_language_query": "Get all stores located in the country “India.”",
+    "sql_query": "SELECT store.store_id, address.address, city.city, country.country FROM store JOIN address ON store.address_id = address.address_id JOIN city ON address.city_id = city.city_id JOIN country ON city.country_id = country.country_id WHERE country.country = 'India';",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "10": {
+    "natural_language_query": "Show all films with a rental rate greater than $2.99.",
+    "sql_query": "SELECT * FROM film WHERE rental_rate > 2.99;",
+    "difficulty": "Easy",
+    "is_valid": true,
+    "error": null
+  },
+  "11": {
+    "natural_language_query": "How many films are there in each category?",
+    "sql_query": "SELECT c.name, COUNT(fc.film_id) FROM category c JOIN film_category fc ON c.category_id = fc.category_id GROUP BY c.name;",
+    "difficulty": "Medium",
+    "is_valid": true,
+    "error": null
+  },
+  "12": {
+    "natural_language_query": "What is the total number of actors?",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "13": {
+    "natural_language_query": "Get the total payment received in June 2022.",
+    "sql_query": "SELECT SUM(amount) FROM payment WHERE payment_date BETWEEN '2007-06-01' AND '2007-06-30';",
+    "difficulty": "Medium",
+    "is_valid": true,
+    "error": null
+  },
+  "14": {
+    "natural_language_query": "Find the total number of rentals made last month.",
+    "sql_query": "SELECT COUNT(*) FROM rental WHERE DATE_TRUNC('month', rental_date) = DATE_TRUNC('month', CURRENT_DATE - INTERVAL '1 month');",
+    "difficulty": "Medium",
+    "is_valid": true,
+    "error": null
+  },
+  "15": {
+    "natural_language_query": "How many films have a rating of “PG-13”?",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "16": {
+    "natural_language_query": "List all films along with their category names.",
+    "sql_query": "SELECT f.title, c.name FROM film f JOIN film_category fc ON f.film_id = fc.film_id JOIN category c ON fc.category_id = c.category_id;",
+    "difficulty": "Medium",
+    "is_valid": true,
+    "error": null
+  },
+  "17": {
+    "natural_language_query": "Show all actors who appeared in the film \"Inception.\"",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "18": {
+    "natural_language_query": "Get a list of all customers and the films they have rented.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "19": {
+    "natural_language_query": "List all staff members along with the stores they work at.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "20": {
+    "natural_language_query": "Find all films rented by customer \"John Doe.\"",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "21": {
+    "natural_language_query": "Show the top 5 films rented the most across all stores.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "22": {
+    "natural_language_query": "List all customers who have rented films in both store 1 and store 2.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "23": {
+    "natural_language_query": "Find all actors who have appeared in more than 10 films.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "24": {
+    "natural_language_query": "Get a list of customers who have made more than 5 payments.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "25": {
+    "natural_language_query": "List all films that are in both the \"Action\" and \"Comedy\" categories.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "26": {
+    "natural_language_query": "Show all rentals made in the last 7 days.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "27": {
+    "natural_language_query": "Get all payments made in February 2022.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "28": {
+    "natural_language_query": "List all films that have not been rented in the last 30 days.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "29": {
+    "natural_language_query": "Find all customers who registered in the last 6 months.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "30": {
+    "natural_language_query": "Show all staff members hired before January 1, 2020.",
+    "sql_query": null,
+    "difficulty": "Medium",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "31": {
+    "natural_language_query": "List the top 3 customers who have spent the most in each country.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "32": {
+    "natural_language_query": "Find the films that have been rented more times than the average number of rentals per film.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "33": {
+    "natural_language_query": "For each actor, show their name and the percentage of films they've acted in compared to the total films.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "34": {
+    "natural_language_query": "Show the average payment amount for each customer.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "35": {
+    "natural_language_query": "List all actors who have appeared in at least one film in each category.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "36": {
+    "natural_language_query": "Find customers who have rented more films this year than last year.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "37": {
+    "natural_language_query": "List the top 5 films with the highest revenue.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "38": {
+    "natural_language_query": "For each customer, show the number of films rented in the last month compared to the previous month.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "39": {
+    "natural_language_query": "Show the names of customers who have rented every film in the “Action” category.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  },
+  "40": {
+    "natural_language_query": "List customers who have rented the same film more than 3 times.",
+    "sql_query": null,
+    "difficulty": "Hard",
+    "is_valid": false,
+    "error": "API quota exceeded"
+  }
+}

tests/test_queries.py

@@ -0,0 +1,130 @@
+import sys
+import os
+import pandas as pd
+import json
+from pathlib import Path
+import psycopg2
+from dotenv import load_dotenv
+import time
+from tqdm import tqdm
+
+sys.path.append(str(Path(__file__).parent.parent))
+from main import get_gemini_response, sql_prompt
+
+def validate_sql_query(query, conn):
+    """Validate if the SQL query is syntactically correct"""
+    try:
+        with conn.cursor() as cursor:
+            # Reset any aborted transaction
+            conn.rollback()
+            
+            # Now try to validate the query
+            cursor.execute("EXPLAIN " + query)
+            conn.commit()  # Commit the successful EXPLAIN
+            return True, None
+    except psycopg2.Error as e:
+        # Rollback on error
+        conn.rollback()
+        return False, str(e)
+
+def handle_api_error(error):
+    """Handle different types of API errors"""
+    if "429" in str(error):
+        return "API quota exceeded", 30  # Wait 30 seconds
+    return str(error), 0
+
+def run_query_tests():
+    load_dotenv()
+    
+    # Database connection
+    conn = psycopg2.connect(
+        dbname=os.getenv('DB_NAME'),
+        user=os.getenv('DB_USER'),
+        password=os.getenv('DB_PASSWORD'),
+        host=os.getenv('DB_HOST'),
+        port=os.getenv('DB_PORT', '5432')
+    )
+    
+    # Read the test dataset with encoding specification
+    csv_path = Path(__file__).parent / 'Pagila Evals Dataset(Sheet1).csv'
+    try:
+        test_data = pd.read_csv(csv_path, encoding='cp1252')
+    except UnicodeDecodeError:
+        # Fallback to latin-1 if cp1252 fails
+        test_data = pd.read_csv(csv_path, encoding='latin-1')
+    
+    # Clean up any special quotes in the queries
+    test_data['Natural Language Query'] = test_data['Natural Language Query'].str.replace('"', '"').str.replace('"', '"')
+    
+    results_dir = Path(__file__).parent / 'results'
+    results_dir.mkdir(exist_ok=True)
+    
+    # Load existing results if any
+    output_file = results_dir / 'query_results.json'
+    if output_file.exists():
+        with open(output_file, 'r', encoding='utf-8') as f:
+            results = json.load(f)
+    else:
+        results = {}
+    
+    # Process queries with progress bar
+    for _, row in tqdm(test_data.iterrows(), total=len(test_data), desc="Processing queries"):
+        query_num = str(row['Query Number'])
+        
+        # Skip if already processed successfully
+        if query_num in results and results[query_num]['sql_query'] and results[query_num]['is_valid']:
+            continue
+            
+        nl_query = row['Natural Language Query']
+        difficulty = row['Difficulty']
+        
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                sql_query = get_gemini_response(nl_query, sql_prompt)
+                sql_query = sql_query.replace('```sql', '').replace('```', '').strip()
+                
+                is_valid, error_msg = validate_sql_query(sql_query, conn)
+                
+                results[query_num] = {
+                    'natural_language_query': nl_query,
+                    'sql_query': sql_query,
+                    'difficulty': difficulty,
+                    'is_valid': is_valid,
+                    'error': error_msg
+                }
+                
+                # Save progress after each successful query
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    json.dump(results, f, indent=2, ensure_ascii=False)
+                
+                break  # Success, exit retry loop
+                
+            except Exception as e:
+                error_msg, wait_time = handle_api_error(e)
+                retry_count += 1
+                
+                if wait_time > 0:
+                    print(f"\nAPI quota exceeded. Waiting {wait_time} seconds...")
+                    time.sleep(wait_time)
+                
+                if retry_count == max_retries:
+                    results[query_num] = {
+                        'natural_language_query': nl_query,
+                        'sql_query': None,
+                        'difficulty': difficulty,
+                        'is_valid': False,
+                        'error': error_msg
+                    }
+                    
+                    # Save progress even for failed queries
+                    with open(output_file, 'w', encoding='utf-8') as f:
+                        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    conn.close()
+    print(f"\nResults saved to {output_file}")
+
+if __name__ == "__main__":
+    run_query_tests()