TLDR: SQL-Exchange is a new framework that uses Large Language Models (LLMs) to transform SQL queries from one database schema to another while preserving the original query’s logical structure. It addresses challenges like structural drift and schema leakage through structured prompting, template-guided abstraction, and semantic constant substitution. Evaluations show high success in structural alignment, execution validity, and generating meaningful natural language questions. When used as in-context examples, SQL-Exchange’s mapped queries significantly improve the performance of text-to-SQL systems, making them more effective across diverse database domains.
In the evolving landscape of data management, the ability to seamlessly transfer knowledge and logic across different database systems is becoming increasingly vital. A new framework, SQL-Exchange, addresses this challenge by enabling the transformation of SQL queries from one database schema to another, all while preserving the original query’s underlying structure. This innovative approach holds significant promise for enhancing how we interact with and learn from diverse datasets.
The core idea behind SQL-Exchange, developed by Mohammadreza Daviran, Brian Lin, and Davood Rafiei from the University of Alberta, is to map SQL queries across different database domains. Imagine having a query designed for a database about Formula 1 racing, and needing to adapt it for a toxicology database. While the specific data and column names differ, the fundamental structure of the query—such as counting entries or joining tables—often remains the same. SQL-Exchange aims to automate this adaptation, making it easier to reuse query logic across vastly different data environments.
This capability is particularly valuable in several scenarios. For instance, in-context learning for text-to-SQL systems, which translate natural language questions into SQL queries, can be significantly improved by providing relevant examples. If you have a good example query from one domain, SQL-Exchange can adapt it to a new domain, providing a tailored example that boosts the system’s performance. It also has benefits in educational settings, allowing instructors to create varied assignments that maintain logical difficulty but use different data, thereby reducing plagiarism risks.
Previous efforts in data migration often focused on converting data or queries between different database *engines* (like SQL Server to SQLite) or translating between SQL and other query languages. However, SQL-Exchange tackles a more nuanced problem: adapting queries to databases with entirely different *schemas* (the structure of tables and columns) while keeping the query’s logical integrity intact. This is a complex task because queries can involve multiple joins, nested subqueries, and specific filtering conditions, all of which must be correctly translated to the new schema.
How SQL-Exchange Works
The framework leverages Large Language Models (LLMs) but goes beyond simple zero-shot translation, which often leads to issues like ‘structural drift’ (losing the original query’s logic) or ‘schema leakage’ (copying irrelevant names from the source). SQL-Exchange employs a structured approach:
- Structured Prompting with Chain-of-Thought Reasoning: The LLM is given a clear task description, a single illustrative example of a correct mapping, and the definitions of both the source and target schemas. It’s also prompted to generate a brief natural language explanation of its thought process, guiding it to maintain structural fidelity.
- Template-Guided Query Transfer: A key innovation is converting the source SQL query into a ‘schema-agnostic template.’ This means replacing all specific table names, column names, and values with generic placeholders (e.g., ‘table’, ‘column’, ‘value’). This template preserves the query’s structural backbone (joins, aggregations, filters) while removing domain-specific details. The LLM then ‘grounds’ this template by filling in appropriate elements from the target schema.
- Semantic Constant Substitution: Since constants (like ‘Dating’ in a genre query or a specific ID number) are highly domain-specific, SQL-Exchange provides the LLM with sample data from the target database. This allows the model to replace source constants with meaningful, existing values from the target schema, preventing invalid queries.
Evaluation and Impact
The researchers conducted extensive evaluations using two major text-to-SQL benchmarks, BIRD and SPIDER, and tested with models like Gemini-1.5-flash and GPT-4o-mini. The results were highly promising:
- High Generation Success: SQL-Exchange successfully produced mapped queries in nearly all cases (over 98%), with failures typically occurring only when the source logic was fundamentally incompatible with the target schema.
- Strong Structural Alignment: Between 66% and 87% of mapped queries accurately preserved the structural skeleton of the source SQL, demonstrating the effectiveness of the template-guided approach.
- High Execution Validity: The mapped queries were executable on the target schemas 68% to 93% of the time, indicating they were syntactically correct and semantically aligned.
- Meaningful Natural Language Questions: The generated natural language questions for the mapped queries were judged as meaningful in 80% to 96% of cases, ensuring the translated queries made sense in their new context.
Crucially, SQL-Exchange significantly outperformed zero-shot prompting, showing substantial gains in structural alignment, execution validity, and the meaningfulness of generated questions. It also dramatically reduced the undesirable reuse of source-specific elements like constants, tables, and columns.
Also Read:
- Streamlining Database Interaction: An End-to-End Text-to-SQL Framework with Automated Database Selection
- Decoding Data Flow: How AI is Improving Schema Understanding
Enhancing Text-to-SQL Systems
Beyond just mapping queries, the research demonstrated that these mapped queries are highly beneficial as in-context examples for downstream text-to-SQL tasks. When used in one-shot or few-shot prompting settings, SQL-Exchange’s schema-aligned examples consistently improved the execution accuracy of various LLMs (including LLaMA-3B, Qwen-3B, Qwen-7B, and GPT-4o-mini) compared to using unmapped examples or no examples at all. This highlights the practical utility of SQL-Exchange in making LLM-powered text-to-SQL systems more robust and accurate across diverse database environments.
The work presented in this paper, available for further details at the research paper link, marks a significant step forward in cross-domain query transformation. By balancing structural fidelity with semantic adaptability, SQL-Exchange opens new avenues for leveraging existing query knowledge and improving the performance of AI systems that interact with structured data.
