Query-by-Example (QBE) is a classical method for formulating database queries by filling out relation templates with example values, which avoids the need for formal query languages. Extensions such as Fuzzy QBE have introduced variants, where users label example tuples as relevant or irrelevant to guide the construction of a query condition. In this paper, we examine how such label-driven query induction can be applied to quantum logic-based query languages, focusing on the Commuting Quantum Query Language (CQQL). We assume the problem to be a form of classification and approach it using Quantum Logic Decision Trees. The resulting conditions are expressed as CQQL formulas and compiled into executable queries using Quantum SQL. We provide illustrative examples and discuss practical considerations.
Germany CEUR Workshop ISSN1613-0073
QBE was introduced in the 1970s as a user-friendly interface for relational databases, aimed at users
unfamiliar with formal query languages like SQL [
A more recent line of work proposes generating queries directly from natural language with
techniques from natural language processing, particularly using large language models (LLMs). Examples of
this approach can be found in studies such as [
To overcome the limitations of classical QBE in handling vague or graded relevance, Moreau et al.
proposed Fuzzy Query-by-Example (FQBE) [
However, a closer examination of FQBE reveals that the problem it addresses is structurally equivalent
to that of a classification task. The user, by labeling tuples as relevant or irrelevant, efectively provides
a training set, and the system learns a selection condition that distinguishes the relevant examples from
the rest. This is much like how a classifier learns a decision boundary. In this light, QBE can be viewed
as an instance of logic-based supervised learning, where the goal is to infer an interpretable predicate
that approximates user intent. This places the problem in the domain of query learning, where queries
are induced from labeled examples [
The approach of viewing query construction as a classification problem based on labeled examples has been adopted in other works as well. For example, [9] propose Libra, a system that synthesizes relational selection queries by learning decision trees from input-output tuple examples. Even though it operates strictly in the classical Boolean context, its methodology is very similar to that of Fuzzy QBE. Both treat the user’s labeling as a form of supervision, and both induce a condition that distinguishes relevant from irrelevant tuples. Notably, Libra does not reference earlier fuzzy QBE approaches, but can be seen as continuing the same fundamental idea of query learning. The works of these authors show that classification can be used as a tool to learn queries that represent user wishes, which motivates our approach. This perspective motivates our approach: in the following chapters, we explore how classification models can be used to learn such queries directly from labeled examples.
(User-provided)
As an initial step towards our logic-based formulation and to motivate the next steps, we first consider a
simplified version using classical decision trees (DT) and Boolean logic, with a methodology similarly to
the approaches in [
A DT is a classification model that partitions the input space by recursively applying conditions on attribute values, resulting in a tree structure where each internal node represents a decision based on an attribute, and each leaf corresponds to a classification outcome. It is a classical and widely used model, particularly valued for its interpretability, as each decision path from root to leaf can be translated into a Boolean expression that explains why a particular classification was made [ 10]. For binary classification, a decision tree can be represented by a single Boolean formula that captures the conditions under which an input is assigned the positive class. Aside from XAI aspects, this property is also useful in database contexts, as the resulting Boolean expression can be directly embedded into an SQL query, which would efectively transform a learned classifier into a selection predicate.
In practice, the process proceeds as follows. We begin by collecting labels from the user, who marks a selection of randomly chosen tuples from the input relation as either relevant or not relevant. Each labeled tuple is treated as a feature vector for training, where the relevance label serves as the class, and each column in the relation corresponds to an attribute. A classification algorithm, such as CART [ 11], is then applied to learn a DT. The resulting tree is transformed into a Boolean expression that represents the selection condition for the relevant class. This expression can be inserted into the WHERE clause of a prepared SQL query. The process of this approach is illustrated in Figure 1. While we focus here on single-table selections for simplicity, this method can be extended to support JOIN and more complex queries.
For a simple example, consider the toy dataset in Table 1, which describes colored balls of difering size. The column “Label” refers to the user-provided relevance evaluation and encodes “irrelevant” as 0 and “relevant” as 1. Training a DT classifier on this dataset could result in a simple DT such as depicted in Figure 2.
This DT can be expressed as a Boolean expression, which expresses the truth value of the statement: “The record is relevant”. Such an expression would be: ( = ’Red’) ∧ ( = ’Large’) Incorporating the expression into an SQL statement, would yield the query in the following Listing 1:
True
Size = Large? True 1
False
0 Color = Red?
False 0
WHERE C o l o r = ’ Red ’ AND S i z e = ’ L a r g e ’ ;
This example demonstrates how a classification model, in this case a DT, can be used to derive a logical query predicate from user-labeled data. The resulting condition is interpretable, executable, and mirrors the user’s intent. In the following sections, we extend this approach beyond Boolean logic by explaining and applying a quantum logic-based classifier instead of the DT, which adds support for graded relevance.
A QLDT [12] is a classification model for tabular data that uses quantum-inspired logic at its core. Note that the usage of quantum logic does not, by itself, imply any connection to quantum computing. Although quantum logic borrows mathematical ideas from quantum mechanics, it operates on classical computers and does not involve concepts such as superposition, entanglement, or quantum circuits.
A QLDT consists of a CQQL condition on normalized attribute values and a threshold. CQQL refers
to Commuting Quantum Query Language [
For brevity, we do not describe the full formalism of CQQL here and instead refer to [13] for a
simplified explanation based on probability theory. In this interpretation, the evaluation of a condition
against a feature vector , which is notated as [] , works as follows. Atomic conditions denote the
event that a given attribute of an object “is high” and their evaluation [] returns the corresponding
attribute value of normalized to [
[ ] = 1 − [] ,
mirroring the complement of a probability value. This evaluation scheme remains valid even if the terms
of the logical expression are themselves non-atomic, as long as they remain statistically independent.
This is typically the case when the overall expression is in disjunctive normal form (DNF), where each
conjunction can be treated as an independent unit. It should be noted that full distributivity does not
hold in general quantum logic. To address this, CQQL expressions are always evaluated in DNF.
evaluation of CQQL conditions generates a score [] ∈ [
With the methodology from Section 3 established, we now adapt it to the quantum logic setting by integrating the Quantum Logic Decision Tree (QLDT) introduced in Section 4. As before, the goal is to induce a query condition from labeled tuples by extracting a logical expression that best separates relevant from irrelevant examples. In this case, however, we aim to learn a CQQL condition instead. This condition can then be used to construct a query, just as in the Boolean case.
A key diference is that standard SQL does not support quantum logic operators, similarity-based predicates, or graded relevance evaluation. To address this, we propose using the Quantum SQL (QSQL) dialect [14], which is specifically designed to support such semantics. Since QSQL is not widely supported in commercial systems, we optionally translate the resulting QSQL query into standard SQL-99. This is possible, as long as the required similarity functions are defined in the database system for the relevant attributes, for example using user-defined functions in a procedural SQL dialect like PL/SQL.
To illustrate this concept, we provide a second example relation and apply the method on this data. value for safety and emission level, where a possible consumer would prefer a high safety and a low emission level. Furthermore, the table shows the the label that was provided by a user and a score that we will discuss below.
Training a QLDT classifier on this data yields the decision tree shown in Figure 3. In this figure, the safety attribute is abbreviated as and the emission attribute as , purely for compactness of presentation. (This difers from the rest of the paper, where denotes a condition!)
[] = [safety] ⋅ (1 − [emission] ).
Keep in mind that for the evaluation of an atomic attribute (e.g. emission), the attribute value is taken from the feature vector of the evaluated object . Incorporating this condition into QSQL could result in the query in Listing 2:
Listing 2: QSQL query expressing the CQQL condition
FROM a u t o m o b i l e s WHERE ( s a f e t y ~ 1 )
AND NOT ( e m i s s i o n ~ 1 )
In QSQL, the operator ∼ denotes similarity to a reference value, here 1, evaluated according to CQQL semantics. This is equivalent to the condition that the value “is high” since 1 is the upper limit of its domain. Conjunction and negation are evaluated as described in Section 4.
As discussed earlier, this QSQL code can be converted into normal SQL. For the actual mechanisms of parsing from QSQL to SQL, we refer to [14]. The SQL version of the previous query can be found in Listing 3 below:
Listing 3: SQL translation of the QSQL query
LAND (
SAFE_TO_SCORE ( s a f e t y , 1 ) , LNOT ( EM_TO_SCORE ( e m i s s i o n , 1 ) ) ) AS s c o r e v a l FROM a u t o m o b i l e s
This, of course, requires the used functions to be defined in the system beforehand. A short list with descriptions of the functions in this example is provided in Table 3. It should be emphasized that in this SQL version, the condition is not placed in the WHERE clause but computed in the SELECT clause. This is because its gradual fulfillment is expressed as the attribute scoreval, which must be part of the result relation. Thresholding can be added in WHERE by referencing scoreval, but the intended query includes all tuples and orders them by their degree of fulfillment.
This demonstrates how a QLDT can be used to derive interpretable, graded query conditions in the form of CQQL expressions, which can then be translated into executable QSQL and SQL statements.
This work contributes a conceptual step toward bringing example-based query formulation into the setting of quantum logic. Our main outcome is to show that query learning, when framed as a classification problem, can be extended beyond Boolean logic by employing Quantum Logic Decision Trees (QLDT). This allows queries to be induced from labeled tuples in a way that produces interpretable conditions, which can then be executed as Commuting Quantum Query Language (CQQL) expressions and compiled into Quantum SQL (QSQL) or SQL.
Our method generates clean, Boolean algebra-compliant logic expressions, supports fuzzy decision boundaries and gradual relevance without being confined to classical Boolean logic, and inherits the classification performance of QLDTs, which have been shown to perform well in prior studies. As for the limitations of the method, it relies on suficient and representative labeled data, which may be challenging to obtain from the user.
The generated CQQL conditions require evaluation in QSQL, for which no current implementation exists, or must be mapped manually to SQL-99 with user-defined similarity functions. Additionally, QLDT currently supports only simple similarity cases (conditions like “is high” or “is low”) and lacks more flexible or attribute-specific similarity semantics. This could be partially mitigated by replacing the QLDT with a BBQ-Tree, a variant that includes more types of possible splits [15].
This paper is primarily conceptual and does not include an empirical evaluation of user efectiveness. Nonetheless, the underlying components (QBE, DT and QLDT) have been validated individually in prior research. Future work could investigate the practical usability of this method through user studies, system implementation, and comparative benchmarks. Furthermore, strategies such as Active Learning or weak supervision could be explored to reduce the labeling efort required from users.
In summary, we have shown that query induction from labeled examples is feasible even in the context of quantum logic. This contributes a small but necessary step toward supporting example-based query formulation in systems that rely on quantum logic.
During the preparation of this work, the author used ChatGPT-4 in order to: Grammar and spelling check and preparation of TikZ code for figures. After using this service, the author reviewed and edited the content as needed and takes full responsibility for the publication’s content. by examples: An experiment using relevance feedback, id3, genetic algorithms, and simulated annealing, Journal of the American Society for Information Science 49 (1998) 693–705. [9] A. Naik, A. Thakkar, A. Stein, R. Alur, M. Naik, Relational query synthesis ⋈ decision tree learning, Proc. VLDB Endow. 17 (2023) 250–263. URL: https://doi.org/10.14778/3626292.3626306. doi:10.14778/3626292.3626306. [10] S. Russell, P. Norvig, Artificial Intelligence: A Modern Approach, Global Edition, Pearson Education,
London, 2021. [11] L. Breiman, J. H. Friedman, R. A. Olshen, C. J. Stone, Classification and Regression Trees, CRC
Press, New York, 1984. doi:10.1201/9781315139470. [12] I. Schmitt, QLDT: A decision tree based on quantum logic, in: S. Chiusano, T. Cerquitelli, R. Wrembel, K. Nørvåg, B. Catania, G. Vargas-Solar, E. Zumpano (Eds.), New Trends in Database and Information Systems, Springer International Publishing, Cham, 2022, pp. 299–308. [13] I. Schmitt, Logic interpretations of ann partition cells, 2024. URL: https://arxiv.org/abs/2408.14314.
arXiv:2408.14314. [14] S. Lehrack, I. Schmitt, QSQL: Incorporating logic-based retrieval conditions into SQL, in: H. Kitagawa, Y. Ishikawa, Q. Li, C. Watanabe (Eds.), Database Systems for Advanced Applications, Springer Berlin Heidelberg, Berlin, Heidelberg, 2010, pp. 429–443. [15] A. Stahl, I. Schmitt, BBQ-Tree – a decision tree with boolean and quantum logic decisions, in: Lecture Notes in Computer Science, volume 14918, 2024.