from os import sched_get_priority_max from tqdm import tqdm import numpy as np from prompting_utils import * from utils import * from sql_comparison import * import pickle def add_fk_tabcols(tables, schema_pk_fk): to_add = defaultdict(lambda: set()) for tab in tables: if tab in schema_pk_fk: tab_to_tab = schema_pk_fk[tab] for ftab in tables: if ftab in tab_to_tab: for pkfk in tab_to_tab[ftab]: # print(pkfk) to_add[pkfk[0][0]].add(pkfk[0][1]) to_add[pkfk[1][0]].add(pkfk[1][1]) return {k:v for k,v in to_add.items()} def score_prediction(gt: DataBase, pred: DataBase, all_relevant:bool=False, beta:float=1): pred_total = pred.get_column_count(include_derived_columns=all_relevant) if pred_total == 0: return 0,0,0 correct_count = gt.compare_column_overlap(other_db=pred, include_derived_columns=all_relevant) gt_total = gt.get_column_count(include_derived_columns=all_relevant) precision = correct_count / pred_total recall = correct_count / gt_total if precision+recall == 0: f1 = 0 else: if beta == 1: f1 = 2 * (precision * recall) / (precision + recall) else: f1 = (1+beta**2)*(precision*recall)/(((beta**2)*precision)+recall) return precision, recall, f1 def micro_counts(gt: DataBase, pred: DataBase, all_relevant:bool=False): pred_total = pred.get_column_count(include_derived_columns=all_relevant) if pred_total == 0: return 0,0,0 correct_count = gt.compare_column_overlap(other_db=pred, include_derived_columns=all_relevant) gt_total = gt.get_column_count(include_derived_columns=all_relevant) truepos = correct_count falsepos = pred_total - correct_count falseneg = gt_total - correct_count return truepos, falsepos, falseneg def get_executable_SQL_list(question_SQLs, gt_db: DataBase, pred_db: DataBase, base_schema: DataBase): schema_dict = base_schema.get_schema_for_sqlglot() all_real_cols = set() for t,table in base_schema.tables.items(): all_real_cols |= table.columns good = 0 total = 0 bad_content = [] req_tabcols = defaultdict(lambda: set()) executable_q_gt = [] for question, sql in question_SQLs.items(): clean_q1 = cleanup_query(sql, schema_dict) tab_cols = [] for column_expression in clean_q1.find_all(exp.Column): if str(column_expression.this).replace('"', '') not in all_real_cols: # print(column_expression, column_expression.name, type(column_expression)) continue try: if str(column_expression.args['table'].this).replace('"', '').startswith("_"): continue # a common pattern where sqlglot seems to fail to fully parse out some table aliases elif str(column_expression.args['table'].this).replace('"', '') in {"t", "t1"}: continue tab_cols.append((str(column_expression.args['table'].this).replace('"', ''), str(column_expression.this).replace('"', ''))) except KeyError: pass except AttributeError: pass tab_cols = set(tab_cols) pred_can_execute = True for (tab,col) in tab_cols: if not (tab in pred_db.tables and col in pred_db.tables[tab].columns): pred_can_execute = False req_tabcols[tab].add(col) if not (tab in gt_db.tables and col in gt_db.tables[tab].columns): bad_content.append((sql, (tab, col))) req_tabcols[tab].add(col) if pred_can_execute: executable_q_gt.append((question, sql)) return executable_q_gt def compare_derived_col_sims(gt_db: DataBase, pred_db: DataBase, base_schema: DataBase, cutoff_threshold: float = 0.0): sims = [] diffcounts = [] schema = base_schema.get_schema_for_sqlglot() sim_score_matrix = [] diff_score_matrix = [] gt_order_dict = {} pred_order_dict = {} for gt_ind, gt_derived in enumerate(gt_db.derived_columns): gt_sql = gt_derived.provenance_sql gt_order_dict[gt_ind] = gt_sql this_sims = [] this_diffs = [] for pred_ind, pred_derived in enumerate(pred_db.derived_columns): pred_sql = pred_derived.provenance_sql pred_order_dict[pred_ind] = pred_sql sim = sql_diff_sim(gt_sql, pred_sql, schema=schema) diff_count, total_count = get_nonalias_diff(gt_sql, pred_sql, schema=schema) if sim is None: this_sims.append(-1) this_diffs.append(999) else: this_diffs.append(diff_count) this_sims.append(sim) sim_score_matrix.append(this_sims) diff_score_matrix.append(this_diffs) gt_sim_maps = solve_optimal_mapping(sim_score_matrix) for from_ind, to_ind in gt_sim_maps.items(): sims.append(sim_score_matrix[from_ind][to_ind]) diffcounts.append(diff_score_matrix[from_ind][to_ind]) for gt_ind in gt_order_dict.keys(): if gt_ind not in gt_sim_maps: sims.append(0) diffcounts.append(999) return sims, diffcounts def calc_results(all_predictions, gt_data, schema_data, evaluate_derived_columns_soft_match:bool=False): schema_table_pk_fk = {} for db, tabcols in raw_schema_data.items(): schema_table_pk_fk[db] = defaultdict(lambda: defaultdict(lambda: list())) tables = [] for tab, cd in tabcols['tables'].items(): tables.append(Table(name=tab.lower(), columns=set(col['name'] for col in cd['columns']), column_types={col['name']: col['type'].upper() for col in cd['columns']})) for col in cd['columns']: if col['foreign_key']: assert len(col['foreign_key']) == 2 schema_table_pk_fk[db][tab.lower()][col['foreign_key'][0]].append( ((tab.lower(), col['name']), (col['foreign_key'][0], col['foreign_key'][1]))) schema_data[db] = DataBase(name=db, tables={t.name: t for t in tables}) assert not any("." in c for c in {col['name']: col['type'].upper() for col in cd['columns']}) assert not any("__" in c for c in {col['name']: col['type'].upper() for col in cd['columns']}) sizes = [] gt_sizes = [] precisions = [] recalls = [] f1s = [] micro_tp = 0 micro_fp = 0 micro_fn = 0 all_relevant_sizes = [] gt_all_relevant_sizes = [] all_relevant_precisions = [] all_relevant_recalls = [] all_relevant_f1s = [] macro_derived_sims = [] micro_derived_sims = [] macro_derived_diffs = [] micro_derived_diffs = [] derived_soft_prec = [] derived_soft_rec = [] derived_soft_f1 = [] is_hard = [] print("starting eval...") with open((BENCH_DIR / "v7_hard_dp_bench_with_topics.json").resolve(), 'r') as f: hard_subset = json.load(f) hard_subset = set(hard_subset.keys()) for database, pred_list in tqdm(all_predictions.items()): if not pred_list: continue base_schema = schema_data[database] for dpr_pred in pred_list: if database in hard_subset: is_hard.append(1) else: is_hard.append(0) gt_db = gt_to_db(dbname=database, raw_gt_data_product=gt_data[database]) gt_db = filter_real_table_columns(real_db=base_schema, filter_db=gt_db, debug=True) pred_tabcols = dpr_pred['PREDICTION'] if pred_tabcols is not None: for tab,cols in add_fk_tabcols(list(pred_tabcols.keys()), schema_table_pk_fk[database]).items(): pred_tabcols[tab] += list(cols) pred_tabcols[tab] = list(set(pred_tabcols[tab])) pred_db = viewgen_pred_to_db(pred_content=dpr_pred['PREDICTION'], dbname=database) pred_db = filter_real_table_columns(real_db=base_schema, filter_db=pred_db) all_relevant_result = score_prediction(gt=gt_db, pred=pred_db, all_relevant=True) non_derivation_result = score_prediction(gt=gt_db, pred=pred_db, all_relevant=False) micro_tpt, micro_fpt, micro_fnt = micro_counts(gt_db, pred_db, all_relevant=True) micro_tp += micro_tpt micro_fp += micro_fpt micro_fn += micro_fnt dpr_pred['all_relevant_res'] = all_relevant_result dpr_pred['nonderived_res'] = non_derivation_result precisions.append(non_derivation_result[0]) recalls.append(non_derivation_result[1]) f1s.append(non_derivation_result[2]) all_relevant_precisions.append(all_relevant_result[0]) all_relevant_recalls.append(all_relevant_result[1]) all_relevant_f1s.append(all_relevant_result[2]) sizes.append(pred_db.get_column_count(include_derived_columns=False) / base_schema.get_column_count( include_derived_columns=False)) gt_sizes.append(gt_db.get_column_count(include_derived_columns=False) / base_schema.get_column_count( include_derived_columns=False)) all_relevant_sizes.append( pred_db.get_column_count(include_derived_columns=True) / base_schema.get_column_count( include_derived_columns=True)) gt_all_relevant_sizes.append( gt_db.get_column_count(include_derived_columns=True) / base_schema.get_column_count( include_derived_columns=True)) if evaluate_derived_columns_soft_match: if len(gt_db.derived_columns) == 0: continue sim, diff = compare_derived_col_sims(gt_db, pred_db, base_schema) micro_derived_sims += sim micro_derived_diffs += diff macro_derived_sims.append(np.mean(sim)) macro_derived_diffs.append(np.mean(diff)) if len(pred_db.derived_columns) == 0: derived_soft_prec.append(0) derived_soft_rec.append(0) derived_soft_f1.append(0) else: derived_soft_prec.append(sprec:=(sum(sim) / len(pred_db.derived_columns))) derived_soft_rec.append(srec:=(sum(sim) / len(gt_db.derived_columns))) if sprec == 0 or srec == 0: derived_soft_f1.append(0) else: derived_soft_f1.append(2*(sprec*srec)/(sprec+srec)) print("XXXXXXXX") print("XXXXXXXX") print("Results") print("Non-derived columns only:") print(f"GT DP size: avg: {np.mean(gt_sizes):.3f}") print(f"Predicted DP size avg: {np.mean(sizes):.3f}") print("- P/R/F1-") print(f"Precision: {np.mean(precisions):.3f}") print(f"Recall: {np.mean(recalls):.3f}") print(f"F1: {np.mean(f1s):.3f}") print("-") print("Including derived columnss:") print(f"GT DP size: avg: {np.mean(gt_all_relevant_sizes):.3f}") print(f"Predicted DP size avg: {np.mean(all_relevant_sizes):.3f}") print("- P/R/F1-") print(f"Precision: {np.mean(all_relevant_precisions):.3f}") print(f"Recall: {np.mean(all_relevant_recalls):.3f}") print(f"F1: {np.mean(all_relevant_f1s):.3f}") print("-") # print(f"{np.mean(precisions):.3f} & {np.mean(recalls):.3f} & {np.mean(f1s):.3f} & {np.mean(all_relevant_precisions):.3f} & {np.mean(all_relevant_recalls):.3f} & {np.mean(all_relevant_f1s):.3f}") if evaluate_derived_columns_soft_match: print(f"Derived column stats") print(f"Average similarity: {np.mean(macro_derived_sims):.3f}, Median diff count between ASTs: {np.median(macro_derived_diffs):.3f}") print(f"Soft Precision: {np.mean(derived_soft_prec):.3f} Soft Recall: {np.mean(derived_soft_rec):.3f} Soft F1: {np.mean(derived_soft_f1):.3f}") print("XXXXXXXX") print(f"HARD TABLES ({np.sum(is_hard)/3} DBs)") print("XXXXXXXX") hard_gt_sizes = [v for ind, v in enumerate(gt_sizes) if is_hard[ind] == 1] print(f"GT DP size: avg: {np.mean(hard_gt_sizes):.3f}") print(f"Predicted DP size avg: {np.mean([v for ind, v in enumerate(sizes) if is_hard[ind] == 1]):.3f}") print("- P/R/F1-") print(f"Precision: {np.mean([v for ind, v in enumerate(precisions) if is_hard[ind] == 1]):.3f}") print(f"Recall: {np.mean([v for ind, v in enumerate(recalls) if is_hard[ind] == 1]):.3f}") print(f"F1: {np.mean([v for ind, v in enumerate(f1s) if is_hard[ind] == 1]):.3f}") print("-") print("Including derived columnss:") print(f"GT DP size: avg: {np.mean([v for ind, v in enumerate(gt_all_relevant_sizes) if is_hard[ind] == 1]):.3f}") print(f"Predicted DP size avg: {np.mean([v for ind, v in enumerate(all_relevant_sizes) if is_hard[ind] == 1]):.3f}") print("- P/R/F1-") print(f"Precision: {np.mean([v for ind, v in enumerate(all_relevant_precisions) if is_hard[ind] == 1]):.3f}") print(f"Recall: {np.mean([v for ind, v in enumerate(all_relevant_recalls) if is_hard[ind] == 1]):.3f}") print(f"F1: {np.mean([v for ind, v in enumerate(all_relevant_f1s) if is_hard[ind] == 1]):.3f}") print("-") # print(f"{np.mean([v for ind,v in enumerate(precisions) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(recalls) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(f1s) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_precisions) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_recalls) if is_hard[ind]==1]):.3f} & {np.mean([v for ind,v in enumerate(all_relevant_f1s) if is_hard[ind]==1]):.3f}") if evaluate_derived_columns_soft_match: print(f"Derived column stats") print( f"Average similarity: {np.mean([v for ind, v in enumerate(macro_derived_sims) if is_hard[ind] == 1]):.3f}, Median diff count between ASTs: {np.median([v for ind, v in enumerate(macro_derived_diffs) if is_hard[ind] == 1]):.3f}") print( f"Soft Precision: {np.mean([v for ind, v in enumerate(derived_soft_prec) if is_hard[ind] == 1]):.3f} Soft Recall: {np.mean([v for ind, v in enumerate(derived_soft_rec) if is_hard[ind] == 1]):.3f} Soft F1: {np.mean([v for ind, v in enumerate(derived_soft_f1) if is_hard[ind] == 1]):.3f}") return { 'pred_ratio': np.mean(sizes), 'precision': np.mean(precisions), 'recall': np.mean(recalls), 'f1': np.mean(f1s), 'include_derived_pred_ratio': np.mean(all_relevant_sizes), 'include_derived_precision': np.mean(all_relevant_precisions), 'include_derived_recall': np.mean(all_relevant_recalls), 'include_derived_f1': np.mean(all_relevant_f1s), } sql_exec_cache = {} def eval_text2sql(data): with open((BENCH_DIR / "v7_hard_dp_bench_with_topics.json").resolve(), 'r') as f: hard_subset = json.load(f) hard_subset = set(hard_subset.keys()) from benchmarks.dpbench_evaluation.sql_comparison import execute_sql correct_per_db = defaultdict(lambda: 0) total_per_db = defaultdict(lambda: 0) hard_correct_per_db = defaultdict(lambda: 0) hard_total_per_db = defaultdict(lambda: 0) for d in tqdm(data): gt = d['GT'] pred = d['pred'] db = d['database'] if gt in sql_exec_cache: gt_res = sql_exec_cache[gt] else: gt_res = execute_sql(gt, db) sql_exec_cache[gt] = gt_res pred_res = execute_sql(pred, db) if gt_res == pred_res: correct_per_db[db] += 1 total_per_db[db] += 1 if db in hard_subset: if gt_res == pred_res: hard_correct_per_db[db] += 1 hard_total_per_db[db] += 1 all_corr = sum(list(correct_per_db.values())) total_count = sum(list(total_per_db.values())) hard_all_corr = sum(list(hard_correct_per_db.values())) hard_total_count = sum(list(hard_total_per_db.values())) print(f"{all_corr} out of {total_count} correct ({all_corr / total_count:.3f})") print(f"HARD: {hard_total_count} potentially runnable, {hard_all_corr} correct ({100*(hard_all_corr / hard_total_count):.3f}%) (out of 900 total questions: {100*(hard_all_corr / 900):.3f}%)") if __name__ == "__main__": with open((BENCH_DIR / 'v7_dp_bench_with_topics.json').resolve(), 'r') as f: dpr_data = json.load(f) with open((SCHEMA_DIR / 'bird_train_tables.json').resolve(), 'r') as f: raw_schema_data = json.load(f) with open((SCHEMA_DIR / 'bird_dev_tables.json').resolve(), 'r') as f: raw_schema_data |= json.load(f) dp_result_file = 'v6_dpbench_baseline_gptoss_120b.pkl' with open((DATA_DIR / 'results' / dp_result_file).resolve(), 'rb') as f: experiment_res = pickle.load(f) print(f"Results for {dp_result_file}") calc_results(experiment_res, dpr_data, schema_data=raw_schema_data, evaluate_derived_columns_soft_match=False) text2sql_result_file = 'llama4_redo_gptoss_120v_text2sql.json' with open((DATA_DIR / 'results' / text2sql_result_file).resolve(), 'r') as f: text2sql_experiment_res = json.load(f) print(f"Results for {text2sql_result_file}") eval_text2sql(text2sql_experiment_res)