code/data_processing/planner.py

import sqlite3
import multiprocessing.pool
import functools
import pandas as pd
import re
import sqlparse
import requests
from sql_metadata import Parser
from data_processing.utils import get_table_columns_list, remove_table_alias, get_columns_in_select_clause, get_equation_function_in_select_clause, remove_table_alias
from openai import OpenAI
import os
from dotenv import load_dotenv
from func_timeout import func_set_timeout, FunctionTimedOut
from copy import deepcopy

pd.set_option('display.max_rows', 5)
pd.set_option('display.max_columns', 10)

# execute predicted sql with a time limitation
@func_set_timeout(30)
def execute_sql(cursor, sql):
    cursor.execute(sql)

    return cursor.fetchall()


def check_sql_executability(generated_sql, db):
    if not os.path.exists(db):
        raise Exception("Database file not found: %s" % db)
        
    connection = sqlite3.connect(db, check_same_thread = False)
    connection.text_factory = lambda b: b.decode(errors="ignore")
    cursor = connection.cursor()

    if generated_sql.strip() == "":
        return "Error: empty string"
    try:
        execute_sql(cursor, "EXPLAIN QUERY PLAN " + generated_sql)
        execution_error = None
    except FunctionTimedOut as fto:
        print("SQL execution time out error: {}.".format(fto))
        execution_error = "SQL execution times out."
    except Exception as e:
        # print("SQL execution runtime error: {}.".format(e))
        execution_error = str(e)

    cursor.close()
    connection.close()
    
    return execution_error

def timeout(max_timeout):
    """Timeout decorator, parameter in seconds."""
    def timeout_decorator(item):
        """Wrap the original function."""
        @functools.wraps(item)
        def func_wrapper(*args, **kwargs):
            """Closure for function."""
            pool = multiprocessing.pool.ThreadPool(processes=1)
            async_result = pool.apply_async(item, args, kwargs)
            # raises a TimeoutError if execution exceeds max_timeout
            return async_result.get(max_timeout)
        return func_wrapper
    return timeout_decorator

@timeout(30)
def _execute_sql_with_timeout(db_path, action):
    conn = sqlite3.connect(db_path)
    conn.text_factory = lambda b: b.decode(errors="ignore")
    actions = action.split(";")
    actions = [x for x in actions if len(x.strip()) > 0]
    if len(actions) == 0:
        return "no SQL query executed.", True
    cursor = conn.cursor()
    for action in actions:
        # action = action.lower()
        try:
            # cursor.execute(action)
            # response = cursor.fetchall()
            response = pd.read_sql_query(action, conn)
            has_error = False
        except Exception as error:
            # If the SQL query is invalid, return error message from sqlite
            response = str(error)
            has_error = True
            cursor.close()
            break
    cursor.close()
    conn.close()
    return response, has_error
    
def _execute_sql(db_path, sql_query):
    try:
        pred_result, has_error = _execute_sql_with_timeout(db_path, sql_query)
    except:
        pred_result = "The query takes too much time."
        has_error = True
    return pred_result, has_error

def _make_str_response(response, has_error):
    if has_error:
        return str(response)
    else:     
        # df = pd.DataFrame(response)
        # return str(df)
        return str(response).strip()

def is_execution_correct(true_response, pred_response):
    """
    Return True if both true_response and pred_response are pandas DataFrames
    and they have the same rows (ignoring row order), otherwise False.
    A string response is treated as an execution error, so it returns False.
    """
    
    # If either response is a string, treat it as an error => not correct.
    if isinstance(true_response, str) or isinstance(pred_response, str):
        return False
    
    # Fill missing values in both DataFrames to avoid NaN comparison issues.
    true_response = true_response.fillna("")
    pred_response = pred_response.fillna("")
    
    # Convert each row of the DataFrame into a tuple, then compare sets.
    # This makes ordering irrelevant (only set membership matters).
    true_set = set(map(tuple, true_response.values.tolist()))
    pred_set = set(map(tuple, pred_response.values.tolist()))
    
    return true_set == pred_set


# def get_answer(messages):
#     response = client.completions.create(
#         model='meta-llama/Meta-Llama-3.1-8B-Instruct/',
#         prompt=messages[0]['content'],
#         max_tokens=256,
#         temperature=0.0,
#         use_beam_search=True,
#         n=4,
#         stop=['=========']
#         # eos_token_id=self.tokenizer.convert_tokens_to_ids(['<|end|>'])
#     )
#     response = response.choices[0].text
#     return response
    
def get_answer_vllm(messages):
    response = requests.post(
        # "http://localhost:8000/v1/completions",
        "http://192.168.1.117:8000/v1/completions",
            json={
                # "model": "meta-llama/Meta-Llama-3.1-8B-Instruct/",
                "model": "/hdd/datht/huggingface/qwen-1b-bird-planner/",
                "prompt": messages[0]['content'],
                "max_tokens": 768,
                "use_beam_search": True,
                "n": 4,
                "temperature": 0,
                "stop": ["========="]
                }).json()
    # select a choice that has text
    choices = [choice for choice in response["choices"] if choice["text"]]
    if len(choices) > 0:
        return choices[0]['text']
    else:
        return response["choices"][0]['text']


def get_answer_llamacpp(messages):
    response = requests.post("http://localhost:8000/v1/completions",
            json={
                "model": "meta-llama/Meta-Llama-3.1-8B-Instruct/",
                "prompt": messages[0]['content'],
                "n_predict": 768,
                "temperature": 0,
                "stop": ["========="]
                }).json()
    return response["content"]

def get_answer_openai(client, messages, model='gpt-4o-mini'):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        max_tokens=768,
        temperature=0.0,
    )
    response = response.choices[0].message.content.strip()
    return [response]
    

class Planner:
    def __init__(self, prompt_file, endpoint_type='llamacpp'):
        load_dotenv()

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm
        elif endpoint_type == 'openai':
            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
            self.get_answer = lambda x: get_answer_openai(client, x)

        self.prompt_template = open(prompt_file).read() + """
=========
{schema}

Question: {question}
External knowledge: {evidence}

"""

    def generate(self, sample):
        if 'prompt' not in sample:
            prompt = self.prompt_template.format(
                schema=sample['schema_sequence'], 
                question=sample['question'],
                evidence=sample['evidence']
            )
        else:
            prompt = sample['prompt']

        answers = self.get_answer([{"role": "user", "content": prompt}])
        return prompt, answers
    
class PlannerCombine(Planner):
    def __init__(self, endpoint_type='llamacpp'):
        super().__init__(prompt_file='./prompts/few_shot_prompt_planner_combine.txt', endpoint_type=endpoint_type)

class PlannerCombineWithTrueSQLRefiner(Planner):
    def __init__(self, endpoint_type='llamacpp'):
        super().__init__(prompt_file='./prompts/few_shot_prompt_planner_combine.txt', endpoint_type=endpoint_type)

#         self.prompt_template = open('./prompts/few_shot_prompt_planner_combine.txt').read() + """
# =========
# {schema}

# Matched contents are written in this format table.column (some values can be found in that column)
# {matched_content}

# Question: {question}

# Use this hidden True SQL query to write correct analysis that derives to the correct answer. The True SQL query cannot be used in the analysis.
# Hidden True SQL query: {true_sql_query} 

# Answer like example format:"""
        self.prompt_template = """{schema}

Matched contents are written in this format table.column (some values can be found in that column)
{matched_content}

Question: {question}

Use this hidden True SQL query to write correct analysis that derives to the correct answer. The True SQL query cannot be used in the analysis.
Hidden True SQL query: {true_sql_query} 

Answer like example format:"""

    def generate(self, sample):
        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'], 
            matched_content=sample['content_sequence'],
            question=sample['text'],
            true_sql_query=sample['sql']
        )
        answer = sample['planner_combine_with_true_sql']
        messages = [{"role": "user", "content": prompt}]
        messages.append({"role": "assistant", "content": answer})
#         # add prompt to refine the answer
        messages.append({
            'role': 'user',
            'content': f"""The true SQL query returns this result:
{sample['true_result']}
The predicted SQL query returns this result:
{sample['pred_result']}

Please rewrite the plan to generate the correct answer. The answer format must the same as the example format above. The final SQL query must be the same as the hidden True SQL query.
Add additional thoughts after Tables to use and before Final SQL query if needed. Do not mention about the previous plan or previous SQL. The select goal must be the same as the True SQL query.
Answer in the example format:"""})

        answer = self.get_answer(messages)
        return answer

class PlannerCombineWithTrueSQL(Planner):
    def __init__(self, endpoint_type='llamacpp'):
        super().__init__(prompt_file='./data_processing/prompts/few_shot_prompt_planner_combine.txt', endpoint_type=endpoint_type)

        self.prompt_template = open('./data_processing/prompts/few_shot_prompt_planner_combine.txt').read() + """
=========
{schema}

Question: {question}
External knowledge: {evidence}

Use this hidden True SQL query to write correct analysis that derives to the correct answer. The True SQL query cannot be used in the analysis.
Hidden True SQL query: {true_sql_query} 

Always use external knowledge if it has been provided. Known that the database is SQLite.
Answer like example format:"""

    def generate(self, sample):
        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'], 
            # matched_content=sample['content_sequence'],
            question=sample['question'],
            evidence=sample.get('evidence', 'None'),
            true_sql_query=sample['sql']
        )
        answer = self.get_answer([{"role": "user", "content": prompt}])
        return answer

class ValidatorJOIN:
    def __init__(self, endpoint_type='llamacpp'):
        pd.set_option('display.max_rows', 5)
        pd.set_option('display.max_columns', 10)

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm

        self.prompt_template = open('./few_shot_prompt_join.txt').read() + """=========
{schema}

Matched contents are written in this format table.column (some values can be found in that column)
{matched_content}

Question: {question}

SQL query: {sql_query}

Execution response [written in pandas format]:
{execution_response}

Feedback:
JOIN.
- The SQL query uses tables {used_tables}, joining them on foreign keys {used_fks}."""

    def get_table_list(self, schema):
        tables = []
        for table_data in schema['schema_items']:
            table_name = table_data['table_name'].lower()
            tables.append(table_name)
        tables = list(set(tables))
        return tables
    
    def extract_join_clause(self, sql_query):
        # Define a regex pattern to match the SELECT clause up to the FROM keyword
        pattern = re.compile(r"FROM\s.*?\s(?=WHERE)", re.IGNORECASE | re.DOTALL)
        
        # Search for the pattern in the SQL query
        match = pattern.search(sql_query)
        
        if match:
            # Return the matched portion (SELECT clause)
            return match.group(0).strip()
        else:
            pattern  = re.compile(r"FROM.+", re.IGNORECASE | re.DOTALL)
            # Return None if no match is found
            # Search for the pattern in the SQL query
            match = pattern.search(sql_query)
            
            if match:
                # Return the matched portion (SELECT clause)
                return match.group(0).strip()
            else:
                return None

    def get_used_fks(self, sql_query):
        # use re, get all condition join after ON
        pattern = re.compile(r" ON\s.*?(?=\sWHERE|\sORDER BY|\sLIMIT|\sGROUP BY)", re.IGNORECASE | re.DOTALL)
        match = pattern.findall(sql_query)
        return match
 

    def get_tables_in_join_clause(self, sql_query, schema):
        table_list = self.get_table_list(schema)
        sql_query = remove_table_alias(sqlparse.format(sql_query, keyword_case = "upper", identifier_case = "lower"))
        join_clause = self.extract_join_clause(sql_query)

        used_tables = []
        for token in join_clause.split():
            if token in table_list:
                used_tables.append(token)

        used_fks = self.get_used_fks(sql_query)
        return used_tables, used_fks

    def validate(self, sample):
        execution_result = _execute_sql("../" + sample['db_path'], sample['predict_sql'])
        used_tables, used_fks = self.get_tables_in_join_clause(sample['predict_sql'], sample['schema'])

        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'], 
            matched_content=sample['content_sequence'],
            question=sample['text'],
            sql_query=sample['predict_sql'],
            execution_response=_make_str_response(*execution_result),
            used_tables=used_tables,
            used_fks=used_fks
        )
        answer = prompt.split("Feedback:")[-1] + self.get_answer([{"role": "user", "content": prompt}])
        return answer, execution_result
    
class ValidatorOrder:
    def __init__(self, endpoint_type='llamacpp'):
        pd.set_option('display.max_rows', 5)
        pd.set_option('display.max_columns', 10)

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm

        self.prompt_no_none = open('./few_shot_prompt_order.txt').read().replace("{", "{{").replace("}", "}}") + """
=========
{schema}

Matched contents are written in this format table.column (some values can be found in that column)
{matched_content}

Question: {question}

SQL query: {sql_query}

Execution response [written in pandas format]:
{execution_response}

Feedback:
ORDER BY.
- The SQL query uses ```{order_by_clause}```.
- Based on the question, the query should use"""

        self.prompt_has_none = open('./few_shot_prompt_order.txt').read().replace("{", "{{").replace("}", "}}") + """
=========
{schema}

Matched contents are written in this format table.column (some values can be found in that column)
{matched_content}

Question: {question}

SQL query: {sql_query}

Execution response [written in pandas format]:
{execution_response}

Feedback:
ORDER BY.
- The SQL query uses ```{order_by_clause}```.
- However, the column ```{order_by_column}```` has None values, so the SQL query need to add condition ```{order_by_column} IS NOT NULL``` to filter out None values.
- Conclude: incorrect."""

    def get_table_list(self, schema):
        tables = []
        for table_data in schema['schema_items']:
            table_name = table_data['table_name'].lower()
            tables.append(table_name)
        tables = list(set(tables))
        return tables
    
    def extract_order_clause(self, sql_tokens):
        # extract order by clause given sql_tokens is a list, find start index of order by token
        order_by_index = -1
        for i in range(len(sql_tokens)):
            if sql_tokens[i] == "order by":
                order_by_index = i
                break
        # return order clause
        if order_by_index == -1:
            return []
        else:
            return sql_tokens[order_by_index:]

    def extract_order_by_clause_using_regex(self, sql_query):
        # use regex on sql_query to extract order by clause
        order_by_clause = re.search(r'(?i)ORDER BY\s+(.*)', sql_query)
        if order_by_clause is None:
            return None
        else:
            return order_by_clause.group(1)

    def get_columns_in_order_clause(self, sql_query, schema):
        column_list = get_table_columns_list(schema)

        try:
            sql_tokens = [token.value for token in Parser(sql_query.lower()).tokens]
        except Exception as e:
            sql_tokens = sql_query.lower().split()
    
        order_clause_tokens = self.extract_order_clause(sql_tokens)

        equation_functions = []
        for token in order_clause_tokens:
            if token in ["min", "max", "avg", "sum", "count", "divide", "+", "/", "case", "when"]:
                equation_functions.append(token)

        # use regex on sql_query to extract order by clause
        order_by_clause = self.extract_order_by_clause_using_regex(sql_query)

        if len(equation_functions) > 0:
            return None, order_by_clause # not supported yet
        else:
            columns = []
            for token in order_clause_tokens:
                if token in column_list:
                    columns.append(token)

            # norm columns list, add table.column if '.' not present. table can extract using regex on sql query SELECT x FROM table
            norm_columns = []
            for column in columns:
                if "." not in column:
                    # regex find table name right after the word 'FROM', table name can be wrapped inside ``
                    table = re.search(r'(?i)FROM\s+`?(\w+)`?', sql_query).group(1)
                    norm_columns.append(f"{table}.{column}")
                else:
                    norm_columns.append(column)

            return norm_columns, order_by_clause
        
    def get_column_type(self, column, schema):
        # column is a string in form 'table.column' or 'column'
        if "." in column:
            table, column = column.split(".")
            for table_data in schema['schema_items']:
                if table_data['table_name'] == table:
                    for column_name, column_type in zip(table_data['column_names'], table_data['column_types']):
                        if column_name == column:
                            return column_type
        else:
            for table_data in schema['schema_items']:
                for column_name, column_type in zip(table_data['column_names'], table_data['column_types']):
                    if column_name == column:
                        return column_type
    
    def check_order_by_column_has_none_values(self, column, db_path):
        # use sql query to check if column has none values
        conn = sqlite3.connect(db_path)
        c = conn.cursor()
        table_name = column.split(".")[0]
        column_name = column.split(".")[1]
        query = f"SELECT COUNT(*) FROM `{table_name}` WHERE `{column_name}` IS NULL"
        try:
            c.execute(query)
            result = c.fetchall()
        except Exception as err:
            result = str(err)
        conn.close()

        if type(result) == list and result[0][0] > 0:
            return True
        else:
            return False
        
    def validate(self, sample):
        execution_result = _execute_sql("../" + sample['db_path'], sample['predict_sql'])

        order_columns, order_by_clause = self.get_columns_in_order_clause(sample['predict_sql'], sample['schema'])
        if order_columns is not None and len(order_columns) > 0:
            column = order_columns[0]
            if self.check_order_by_column_has_none_values(column, "../" + sample['db_path']) == True:
                prompt = self.prompt_has_none.format(
                    schema=sample['schema_sequence'], 
                    matched_content=sample['content_sequence'],
                    question=sample['text'],
                    sql_query=sample['predict_sql'],
                    execution_response=_make_str_response(*execution_result),
                    order_by_clause=order_by_clause,
                    order_by_column=column
                )
                answer = prompt.split("Feedback:")[-1]
                return answer, execution_result
            else: # False or error string
                prompt = self.prompt_no_none.format(
                    schema=sample['schema_sequence'], 
                    matched_content=sample['content_sequence'],
                    question=sample['text'],
                    sql_query=sample['predict_sql'],
                    execution_response=_make_str_response(*execution_result),
                    order_by_clause=order_by_clause)
                answer = prompt.split("Feedback:")[-1] + self.get_answer([{"role": "user", "content": prompt}])
        else:
            answer = None
            
        return answer, execution_result



class FixAgent():
    def __init__(self, prompt_template=None, endpoint_type='llamacpp'):

        if endpoint_type in ['openai', 'vllm']:
            self.prompt_template = """You are a SQL tutor that helps fixing the SQL query generated by a student. Given a database schema and a question with external knowledge. Generate Fixed SQL query based on the feedback. Write the SQL query directly, do not add more thoughts.

{schema}

Question: {question}
External knowledge: {evidence}

Generated SQL query from student with the execution response.
SQL query: {sql_query}

Execution response [written in pandas format]:
{execution_response}

The feedback for the SQL query:
{feedback_select}

{feedback_condition}

{feedback_join}

FIXED SQL:"""
        else:
            self.prompt_template = prompt_template

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            # self.get_answer = get_answer_vllm
            client = OpenAI(
                base_url="http://localhost:8003/v1",
                api_key="no-key",
            )
            self.get_answer = lambda x: get_answer_openai(client, x, model='vllm')

        elif endpoint_type == 'openai':
            from dotenv import load_dotenv
            load_dotenv()
            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
            self.get_answer = lambda x: get_answer_openai(client, x)

    def generate(self, sample, feedback_select, feedback_condition, feedback_join, feedback_order):
        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'], 
            question=sample['question'],
            evidence=sample['evidence'],
            sql_query=sample['predict_sql'],
            execution_response=sample['pred_result'],
            feedback_select=feedback_select,
            feedback_condition=feedback_condition,
            feedback_join=feedback_join,
        )
        answers = self.get_answer([{"role": "user", "content": prompt}])
        return prompt, answers

    def get_final_sql(self, predict_sql, fixed_sql, db_path):
        sqls_priority = [fixed_sql, predict_sql]
        sqls_priority = [sql for sql in sqls_priority if sql is not None]
        for sql in sqls_priority:
            # check if the sql is executable
            execution_error = check_sql_executability(sql, db_path)
            if execution_error is None:
                return sql
        return predict_sql
    


class SelectionAgent:
    def __init__(self, endpoint_type='llamacpp'):
        load_dotenv()

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm
        elif endpoint_type == 'openai':
            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
            self.get_answer = lambda x: get_answer_openai(client, x)

        self.prompt_template = """<|start_header_id|>user<|end_header_id|>
Given the question and following SQL queries, and execution results, please select the best SQL query that can answer the question. Answer the index of the SQL query you choose.

Question: {question}
Hint: {evidence}
"""
        self.choice_prompt = """
{index}. {sql}
Execution result: {result}
-------------------------
"""   

    def build_prompt(self, sample):
        prompt = self.prompt_template.format(question=sample['question'], evidence=sample['evidence'])
        index = 1
        for i in range(len(sample['candidate_sqls'])):
            choice_prompt = self.choice_prompt.format(index=index, sql=sample['candidate_sqls'][i].strip(), result=sample['candidate_pred_results'][i])
            index += 1

            prompt += choice_prompt
        
        prompt += """<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""   
        return prompt

    def generate(self, sample):
        prompt = self.build_prompt(sample)
        answers = self.get_answer([{"role": "user", "content": prompt}])
        return prompt, answers

    def is_duplicated_execution_result(self, result, seen_results):
        # use is_execution_correct to check if the result is correct
        is_corrects = [is_execution_correct(result, x) for x in seen_results]
        return any(is_corrects)

    def get_best_sql(self, sample, max_candidates=2):
        """
        Iteratively compare predict_sqls in groups of 'max_candidates'.
        In each round, we chunk the remaining candidates into groups of size 'max_candidates'.
        For each group, we ask 'selection_agent' to pick the best SQL among them
        (1-based index) or return -1/0 to reject them all.
        
        We continue until only one candidate remains or none. Return final SQL or None.
        """

        # Extract the lists from the sample
        predict_sqls = []
        pred_results = []
        seen_results = []
        for predict_sql, pred_result in zip(sample['candidate_sqls'], sample['candidate_pred_results']):
            if 'Execution failed' not in str(pred_result) and 'too much time' not in str(pred_result) and not self.is_duplicated_execution_result(pred_result, seen_results):
                seen_results.append(pred_result)
                predict_sqls.append(re.sub(r'\s+', ' ', predict_sql).strip())
                pred_results.append(pred_result)

        compare_list = []

        while len(predict_sqls) > 1:
            new_predict_sqls = []
            new_pred_results = []

            # Split the current set of candidates into chunks of size 'max_candidates'
            for i in range(0, len(predict_sqls), max_candidates):
                chunk_sqls = predict_sqls[i : i + max_candidates]
                chunk_results = pred_results[i : i + max_candidates]

                # Build a temporary sample for just this chunk
                chunk_sample = deepcopy(sample)
                chunk_sample['candidate_sqls'] = chunk_sqls
                chunk_sample['candidate_pred_results'] = chunk_results

                # Ask the selection agent to pick the best SQL from 1..max_candidates
                # or return -1/0 to reject all
                prompt, answer_list = self.generate(chunk_sample)
                # print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
                # print(prompt + answer_list[0])

                if not answer_list:
                    # If no answer from the agent, reject entire chunk
                    continue

                try:
                    # Convert the agent's first answer to int
                    answer = int(answer_list[0])
                except:
                    # If parsing fails, reject entire chunk
                    answer = -1

                # add to compare list, if answer = 1, add pred_results[0] > pred_results[1]
                if len(chunk_results) == 2 and answer in [1, 2]:
                    if answer == 1:
                        # compare_list.append((chunk_results[0], chunk_results[1]))
                        compare_list.append((str(chunk_results[0]), str(chunk_results[1])))
                    elif answer == 2:
                        # compare_list.append((chunk_results[1], chunk_results[0]))
                        compare_list.append((str(chunk_results[1]), str(chunk_results[0])))

                # If agent picks 1..len(chunk_sqls), keep that candidate
                if 1 <= answer <= len(chunk_sqls):
                    chosen_idx = answer - 1
                    new_predict_sqls.append(chunk_sqls[chosen_idx])
                    new_pred_results.append(chunk_results[chosen_idx])
                else:
                    # If agent picks -1 or 0 or out-of-range -> reject entire chunk
                    pass

            # Update lists with the "winners" of each chunk
            predict_sqls = new_predict_sqls
            pred_results = new_pred_results

            # If in this round we fail to keep anything, no final single solution
            if not predict_sqls:
                # get greedy answer = first predict_sqls
                # print('Greedy answer')
                return sample['candidate_sqls'][0]

        # At the end, if there's exactly one candidate, return it; otherwise None
        if len(predict_sqls) == 1:
            return predict_sqls[0]
    
        # print('greedy answer')
        return sample['candidate_sqls'][0]



class SelectionAgentWithSchema:
    def __init__(self, endpoint_type='llamacpp'):
        load_dotenv()

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm
        elif endpoint_type == 'openai':
            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
            self.get_answer = lambda x: get_answer_openai(client, x)

        self.prompt_template = """<|start_header_id|>user<|end_header_id|>
Given the question and following SQL queries, and execution results, please select the best SQL query that can answer the question. Answer the index of the SQL query you choose.
{schema}

Question: {question}
Hint: {evidence}
"""
        self.choice_prompt = """
{index}. {sql}
Execution result: {result}
-------------------------
"""   

    def build_prompt(self, sample):
        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'],
            question=sample['question'], 
            evidence=sample['evidence'])
        index = 1
        for i in range(len(sample['candidate_sqls'])):
            choice_prompt = self.choice_prompt.format(index=index, sql=sample['candidate_sqls'][i].strip(), result=sample['candidate_pred_results'][i])
            index += 1

            prompt += choice_prompt
        
        prompt += """<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""   
        return prompt

    def generate(self, sample):
        prompt = self.build_prompt(sample)
        answers = self.get_answer([{"role": "user", "content": prompt}])
        return prompt, answers

    def is_duplicated_execution_result(self, result, seen_results):
        # use is_execution_correct to check if the result is correct
        is_corrects = [is_execution_correct(result, x) for x in seen_results]
        return any(is_corrects)
    
    def extract_answer_index(self, answer):
        try:
            # Convert the agent's first answer to int
            # extract answer inside <answer> </answer>
            answer = re.search(r'<answer>(.*)</answer>', answer).group(1)
            answer = int(answer)
        except:
            # If parsing fails, reject entire chunk
            answer = -1
        return answer

    def get_best_sql(self, sample, max_candidates=2):
        """
        Iteratively compare predict_sqls in groups of 'max_candidates'.
        In each round, we chunk the remaining candidates into groups of size 'max_candidates'.
        For each group, we ask 'selection_agent' to pick the best SQL among them
        (1-based index) or return -1/0 to reject them all.
        
        We continue until only one candidate remains or none. Return final SQL or None.
        """

        # Extract the lists from the sample
        predict_sqls = []
        pred_results = []
        seen_results = []
        for predict_sql, pred_result in zip(sample['candidate_sqls'], sample['candidate_pred_results']):
            if 'Execution failed' not in str(pred_result) and 'too much time' not in str(pred_result) and not self.is_duplicated_execution_result(pred_result, seen_results):
                seen_results.append(pred_result)
                predict_sqls.append(re.sub(r'\s+', ' ', predict_sql).strip())
                pred_results.append(pred_result)

        while len(predict_sqls) > 1:
            new_predict_sqls = []
            new_pred_results = []

            # Split the current set of candidates into chunks of size 'max_candidates'
            for i in range(0, len(predict_sqls), max_candidates):
                chunk_sqls = predict_sqls[i : i + max_candidates]
                chunk_results = pred_results[i : i + max_candidates]

                if len(chunk_sqls) == 1:
                    new_predict_sqls.append(chunk_sqls[0])
                    new_pred_results.append(chunk_results[0])
                    continue

                # Build a temporary sample for just this chunk
                chunk_sample = deepcopy(sample)
                chunk_sample['candidate_sqls'] = chunk_sqls
                chunk_sample['candidate_pred_results'] = chunk_results

                # Ask the selection agent to pick the best SQL from 1..max_candidates
                # or return -1/0 to reject all
                prompt, answer_list = self.generate(chunk_sample)
                print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
                print(prompt + answer_list[0])

                if not answer_list:
                    # If no answer from the agent, reject entire chunk
                    continue

                answer = self.extract_answer_index(answer_list[0])

                # If agent picks 1..len(chunk_sqls), keep that candidate
                if 1 <= answer <= len(chunk_sqls):
                    chosen_idx = answer - 1
                    new_predict_sqls.append(chunk_sqls[chosen_idx])
                    new_pred_results.append(chunk_results[chosen_idx])
                else:
                    # If agent picks -1 or 0 or out-of-range -> reject entire chunk
                    pass

            # Update lists with the "winners" of each chunk
            predict_sqls = new_predict_sqls
            pred_results = new_pred_results

            # If in this round we fail to keep anything, no final single solution
            if not predict_sqls:
                # get greedy answer = first predict_sqls
                # print('Greedy answer')
                return sample['candidate_sqls'][0]

        # At the end, if there's exactly one candidate, return it; otherwise None
        if len(predict_sqls) == 1:
            return predict_sqls[0]
    
        # print('greedy answer')
        return sample['candidate_sqls'][0]


class RankingAgent:
    def __init__(self, endpoint_type='llamacpp'):
        load_dotenv()

        if endpoint_type == 'llamacpp':
            self.get_answer = get_answer_llamacpp
        elif endpoint_type == 'vllm':
            self.get_answer = get_answer_vllm
        elif endpoint_type == 'openai':
            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
            self.get_answer = lambda x: get_answer_openai(client, x)

        self.prompt_template = """<|start_header_id|>user<|end_header_id|>
Given the question and following SQL queries, and execution results, please select the best SQL query that can answer the question. Answer the index of the SQL query you choose.

Question: {question}
Hint: {evidence}
"""
        self.choice_prompt = (
    "We have two candidate SQL queries:\n"
    "1) SQL:\n{sql1}\nResult:\n{res1}\n\n"
    "2) SQL:\n{sql2}\nResult:\n{res2}\n\n"
    "Which query is better for the question. Answer 1 or 2.\n"
)

    def build_prompt(self, sample):
        prompt = self.prompt_template.format(question=sample['question'], evidence=sample['evidence'])

        predict_sqls = sample['predict_sqls']
        pred_results = sample['pred_results']
        sql1 = predict_sqls[0]
        res1 = pred_results[0]
        if len(predict_sqls) > 1:
            sql2 = predict_sqls[1]
            res2 = pred_results[1]
        else:
            sql2 = ""
            res2 = ""

        choice_prompt = self.choice_prompt.format(
            sql1=sql1,
            res1=res1,
            sql2=sql2,
            res2=res2
        )

        # Combine with the base prompt
        prompt = prompt + choice_prompt
        prompt += """<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""   
        return prompt

    def generate(self, sample):
        prompt = self.build_prompt(sample)
        answers = self.get_answer([{"role": "user", "content": prompt}])
        return prompt, answers



class ValidatorFixer():
    def __init__(self, endpoint_type='llamacpp'):
        self.prompt_template = """{schema}

Question: {question}
External knowledge: {evidence}

Generated SQL query: {sql_query}

Execution response:
{execution_response}

Feedback for the SQL query:
"""

    def parse_fixed_sql(self, answer: str):
        match = re.search(r'FIXED SQL: (.*)', answer, re.DOTALL)
        if match:
            fixed_sql = match.group(1).strip()
            return fixed_sql if fixed_sql.lower() != "none" else None
        return None
    
    def get_final_sql(self, predict_sql, fixed_sql, db_path):
        sqls_priority = [fixed_sql, predict_sql]
        sqls_priority = [sql for sql in sqls_priority if sql is not None]
        for sql in sqls_priority:
            # check if the sql is executable
            execution_error = check_sql_executability(sql, db_path)
            if execution_error is None:
                return sql
        return predict_sql

    def generate(self, sample, execution_result=None):
        if execution_result is None:
            execution_result = _execute_sql("./" + sample['db_path'], sample['predict_sql'])
            execution_result = _make_str_response(*execution_result)

        prompt = self.prompt_template.format(
            schema=sample['schema_sequence'], 
            question=sample['question'],
            evidence=sample['evidence'],
            sql_query=sample['predict_sql'],
            execution_response=execution_result,
        )

        answers = self.get_answer([{"role": "user", "content": prompt}])
        # print(answers[0])
        fixed_sqls = [self.parse_fixed_sql(answer) for answer in answers]
        return prompt, answers, fixed_sqls, execution_result