Improving Text-to-SQL with a Hybrid Decoding Method

In the present computing and fast growing world, information plays a key role in humans day to day life. Information can be stored in databases in an organized manner and SQL allows users to access process and manage data on database. But not all users are accustomed to writing SQL queries. This resulted in need for non-sophisticated users to access the database using natural language. A Natural Language Interface for Database (NLIDB) acts as an intelligent interface for database which allows users to access the database by typing requests in their natural language. The paper is going to discuss about a NLIDB system based on HMM. The system contains two modules: linguistic module and database module. Linguistic module makes uses of various Natural Language Processing (NLP) techniques which are used to identify tokens that correspond to the constraints and predicates required to build possible SELECT, WHERE and FROM clauses. The output of linguistic module is passed to database module. Identified tokens are then mapped to SQL query tokens using a query translation algorithm. A template is being used to generate corresponding SQL query. If the algorithm fails to identify sufficient details, a query prediction module based on HMM identifies the attributes and predicates list. The system used either a template based system that produce nearly 100% correct result to user query or prediction module that generate a highest probable result that matches to the user query. No situation exists in which the system fails to produce a result to the NL query.

Many SQL queries with aggregated subqueries exhibit redundancy (overlap in FROM and WHERE clauses). We propose a method, called the for-loop, to optimize such queries by ensuring that redundant computations are done only once. We specify a procedure to build a query plan implementing our method, give an example of its use and argue that it offers performance advantages over traditional approaches.

In recent years, as performance and capacity of main and external memory grow, performance of database management systems (DBMSes) on certain kinds of queries is more determined by raw CPU speed. Currently, PostgreSQL uses the interpreter to execute SQL queries. This yields an overhead caused by indirect calls to handler functions and runtime checks, which could be avoided if the query were compiled into native code "on-the-fly", i.e. just-in-time (JIT) compiled: at run time the specific table structure is known as well as data types and built-in functions used in the query as well as the query itself. This is especially important for complex queries, performance of which is CPU-bound. We’ve developed a PostgreSQL extension that implements SQL query JIT compilation using LLVM compiler infrastructure. In this paper we show how to implement JIT compilation to speed up sequential scan operator (SeqScan) as well as expressions in WHERE clauses. We describe some important optimizations that are possible only with dynamic compilation, such as precomputing tuple attributes offsets only for attributes used by the query. We also discuss the maintainability of our extension, i.e. the automation for translating PostgreSQL backend functions into LLVM IR, using the same source code both for our JIT compiler and the existing interpreter. Currently, with LLVM JIT we achieve up to 5x speedup on synthetic tests as compared to original PostgreSQL interpreter.

Mapping natural language (NL) statements into SQL queries allows users to interact with systems through everyday language. Semantic parsing has seen a growing interest over the past decades. In this paper, we extend single hidden layer feedforward network (SLFN) by adding the Kullback-Liebler (KL) divergence parameter to its objective function. We refer to this algorithm as Sparse SLFN (S-SLFN) which can learn whether an SQL query answers a particular NL question. With Bag of Words (BoW) representing the questions and the queries, the algorithm, by enforcing sparsity, is meant to retain robust features representing informative relationships and structure of the data. Experimental results show that S-SLFN outperforms SLFN and other algorithms for the GeoQueries dataset by a respectable margin.KeywordsSingle-hidden Layer Feedforward Network (SLFN)SparsitySemantic Parsing

Building natural language interfaces to relational databases is an important and challenging problem in natural language processing (NLP), it requires a system that is able to understand natural language questions and generate corresponding SQL queries. In this paper, we present our idea of using type information and database content to better understand rare entities and numbers in natural language questions, in order to improve the model SyntaxSQLNet as the state of the art in Text-to-SQL task. We also present the global architecture and techniques that can be used in the implementation of our Neural Network (NN) model Text2SQLNet, with the integration of our idea that consists of using type information to better understand rare entities and numbers in natural language questions. We can also use the database content to better understand the user query if it is not well-formed. The implementation of this idea can further improve performance in the Text-to-SQL task.

Text-to-SQL parsing is the task of converting natural language questions into executable SQL queries, a significant branch of semantic parsing, which has gained increasing attention in recent years. This technology lowers the barrier for people to access databases, enhancing the convenience and availability of data. However, the primary challenge for text-to-SQL parsing lies in domain adaptation, which concerns whether the model can be applied to new databases and effectively align natural language questions with the corresponding tables or columns within the database. To address these issues, research has introduced SRSQL (Syntax and Relation-Augmented Query Generation), which incorporates syntax information and predefined relationships into the model, effectively utilizing syntactic dependencies and pattern linking to improve performance. Using a Transformer-based decoder, SRSQL generates SQL queries in the form of Abstract Syntax Trees (AST), significantly boosting prediction accuracy. Experimental results show that SRSQL outperforms comparative models, particularly on challenging benchmarks like Spider and Spider-SYN.

SPS-SQL: Enhancing Text-to-SQL generation on small-scale LLMs with pre-synthesized queries

Automatically mapping natural language semantics into programming languages has always been a major and interesting challenge in Computer Science. In this paper, we approach such problem by carrying out mapping at syntactic level and then applying machine learning algorithms to derive an automatic translator of natural language questions into their associated SQL queries. To build the required training and test sets, we designed an algorithm, which, given an initial corpus of questions and their answers, semi-automatically generates the set of possible incorrect and correct pairs. We encode such relational pairs in Support Vector Machines by means of kernel functions applied to the syntactic trees of questions and queries. The accurate results on automatic classification of the above pairs above, suggest that our approach captures the shared semantics between the two languages.

Declarative technologies have made great strides in expressivity between SQL and SBVR. SBVR models are more expressive that SQL schemas, but not as imminently executable yet. In this paper, we complete the architecture of a system that can execute SBVR models. We do this by describing how SBVR rules can be transformed into SQL DML so that they can be automatically checked against the database using a standard SQL query. In particular, we describe a formalization of the basic structure of an SQL query which includes aggregate functions, arithmetic operations, grouping, and grouping on condition. We do this while staying within a predicate calculus semantics which can be related to the standard SBVR-LF specification and equip it with a concrete semantics for expressing business rules formally. Our approach to transforming SBVR rules into standard SQL queries is thus generic, and the resulting queries can be readily executed on a relational schema generated from the SBVR model.

Relational databases are among the most widely used architectures to store massive amounts of data in the modern world. However, there is a barrier between these databases and the average user. The user often lacks the knowledge of a query language such as SQL required to interact with the database. The NL2SQL task aims at finding deep learning approaches to solve this problem by converting natural language questions into valid SQL queries. Given the sensitive nature of some databases and the growing need for data privacy, we have presented an approach with data privacy at its core. We have passed RoBERTa embeddings and data-agnostic knowledge vectors into LSTM based submodels to predict the final query. Although we have not achieved state of the art results, we have eliminated the need for the table data, right from the training of the model, and have achieved a test set execution accuracy of 76.7%. By eliminating the table data dependency while training we have created a model capable of zero shot learning based on the natural language question and table schema alone.

Due to the lack of labeled data, previous research on text-to-SQL parsing mainly focuses on English. Representative English datasets include ATIS, WikiSQL, Spider, etc. This paper presents DuSQL, a larges-scale and pragmatic Chinese dataset for the cross-domain text-to-SQL task, containing 200 databases, 813 tables, and 23,797 question/SQL pairs. Our new dataset has three major characteristics. First, by manually analyzing questions from several representative applications, we try to figure out the true distribution of SQL queries in real-life needs. Second, DuSQL contains a considerable proportion of SQL queries involving row or column calculations, motivated by our analysis on the SQL query distributions. Finally, we adopt an effective data construction framework via human-computer collaboration. The basic idea is automatically generating SQL queries based on the SQL grammar and constrained by the given database. This paper describes in detail the construction process and data statistics of DuSQL. Moreover, we present and compare performance of several open-source text-to-SQL parsers with minor modification to accommodate Chinese, including a simple yet effective extension to IRNet for handling calculation SQL queries.

Recent research in Text-to-SQL translation has primarily adopted in-context learning methods leveraging large language models (LLMs), achieving significant progress. However, these methods face challenges in adapting to natural language questions of varying difficulty and the relevance of the few-shot examples provided. In this paper, we propose an adaptive in-context learning approach with difficulty-aware instruction and retrieval-augmented generation to enhance the performance of Text-to-SQL translation (AID-SQL). First, we introduce adaptive instructions for LLMs, which employ precise difficulty classification to apply difficulty-adaptive generative guidelines and chain of thought (CoT) templates for varying difficulty levels. We automatically incorporate few-shot examples retrieved through the knowledge base into the CoT template to construct CoT-enhanced examples, which improves the capability of LLMs with retrieval-augmented generation (RAG). Furthermore, considering that current RAG methods struggle to effectively measure the contribution of retrieved examples in solving the specific task of Text-to-SQL translation, we train a ranking model that can better bridge the semantic and structural gap between NL questions and SQL queries. This approach can better understand semantic information and allows for retrieving examples that are more beneficial to the final problem-solving. We evaluate our method on five benchmarks. Our method achieves competitive performance compared with existing methods.

Modern enterprises increasingly leverage public cloud services to host application workloads with underlying cloud components, service tiers, and associated costs. These usage-based charging models introduce complexity. This necessitates the analysis of substantial data volumes to derive valuable insights. In this paper, we aim to address the challenge of enabling business and financial stakeholders to efficiently interpret cloud cost data and its trends without SQL expertise. We present an AI-powered system built on the DSPy framework that translates natural language questions into SQL queries using an enterprise-grade Large Language Model (LLM), delivering context-aware and desired responses. Existing dashboards and NLP approaches rely on rule-based parsing, requiring predefined data schemas and manual configuration. DSPy also uses these schemas but enhances flexibility by adapting them through structured pipelines and multi-step reasoning to improve accuracy. To train and evaluate our model, we augment a small dataset of question-SQL pairs through LLM-based generation and manual refinement. Additionally, we develop a custom recommendation engine using search-based techniques in Python to identify and disambiguate field names and values for both users and the LLM. Our system achieves 90% execution accuracy on our dataset, which indicates that the generated SQL queries return correct results when executed on the target database. These results demonstrate the effectiveness of prompt-tuned LLMs and in-context learning in providing a scalable, accessible solution for enterprise data analysis, ultimately enhancing decision-making in financial management.

Access to hospital data is commonly a difficult, costly and time-consuming process requiring extensive interaction with network administrators. This leads to possible delays in obtaining insights from data, such as diagnosis or other clinical outcomes. Healthcare administrators, medical practitioners, researchers and patients could benefit from a system that could extract relevant information from healthcare data in real-time. In this paper, we present a question answering system that allows health professionals to interact with a large-scale database by asking questions in natural language. This system is built upon the BERT and SQLOVA models, which translate a user's request into an SQL query, which is then passed to the data server to retrieve relevant information. We also propose a deep bilinear similarity model to improve the generated SQL queries by better matching terms in the user's query with the database schema and contents. This system was trained with only 75 real questions and 455 back-translated questions, and was evaluated over 75 additional real questions about a real health information database, achieving a retrieval accuracy of 78%.

The knowledge of courses can be represented by using ontology to create intelligent educational systems. This study proposes the Onto-Linking model as a knowledge framework that expresses the knowledge of the inputted schema to investigate the schema linking problem of the Text-to-SQL model. It combines the ontology with the structure of the schema. The proposed ontology is utilized to encapsulate the semantics of the intellectual elements of the schema, such as the table names, column names, foreignprimary key restrictions, and information about the probing schema connection. Therefore, the model makes it easier to accurately translate natural language questions into SQL queries. It improves query creation, helps with error handling, and supports query validation by helping the model better grasp the query's intent. The outcomes of the pedagogically oriented model aimed at guiding learners to comprehend the process of reasoning to attain the respective solution.