In database theory, a conjunctive query is a restricted form of first-order queries using the logical conjunction operator. Many first-order queries can be written as conjunctive queries. In particular, a large part of queries issued on relational databases can be expressed in this way. Conjunctive queries also have a number of desirable theoretical properties that larger classes of queries (e.g., the relational algebra queries) do not share.
The conjunctive queries are the fragment of (domain independent) first-order logic given by the set offormulae that can be constructed from atomic formulae using conjunction ∧ andexistential quantification ∃, but not using disjunction ∨, negation ¬,or universal quantification ∀.Each such formula can be rewritten (efficiently) into an equivalent formula in prenex normal form, thus this form is usually simply assumed.
Thus conjunctive queries are of the following general form:
(x1,\ldots,xk).\existsxk+1,\ldotsxm.A1\wedge\ldots\wedgeAr
x1,\ldots,xk
xk+1,\ldots,xm
A1,\ldots,Ar
As an example of why the restriction to domain independent first-order logic is important, consider
x1.\existsx2.R(x2)
Conjunctive queries can express a large proportion of queries that are frequently issued on relational databases. To give an example, imagine a relational database for storing information about students, their address, the courses they take and their gender. Finding all male students and their addresses who attend a course that is also attended by a female student is expressed by the following conjunctive query:
(student, address) . ∃ (student2, course) . attends(student, course) ∧ gender(student, 'male') ∧ attends(student2, course) ∧ gender(student2, 'female') ∧ lives(student, address)
Note that since the only entity of interest is the male student and his address, these are the only distinguished variables, while the variables course, student2 are only existentially quantified, i.e. undistinguished.
Conjunctive queries without distinguished variables are called boolean conjunctive queries. Conjunctive queries where all variables are distinguished (and no variables are bound) are called equi-join queries,[1] because they are the equivalent, in the relational calculus, of the equi-join queries in the relational algebra (when selecting all columns of the result).
Conjunctive queries also correspond to select-project-join queries in relational algebra (i.e.,relational algebra queries that do not use the operations union or difference) and to select-from-where queries in SQL in which the where-condition uses exclusively conjunctions of atomic equality conditions, i.e. conditions constructed from column names and constants using no comparison operators other than "=", combined using "and". Notably, this excludes the use of aggregation and subqueries. For example, the above query can be written as an SQL query of the conjunctive query fragment as
Besides their logical notation, conjunctive queries can also be written as Datalog rules. Many authors in fact prefer the following Datalog notation for the query above:
While any conjunctive query can be written as a Datalog rule, not every Datalog program can be written as a conjunctive query. In fact, only single rules over extensional predicate symbols can be easily rewritten as an equivalent conjunctive query. The problem of deciding whether for a given Datalog program there is an equivalent nonrecursive program (corresponding to a positive relational algebra query, or, equivalently, a formula of positive existential first-order logic, or, as a special case, a conjunctive query) is known as the Datalog boundedness problem and is undecidable.[2]
Extensions of conjunctive queries capturing more expressive power include:
The formal study of all of these extensions is justified by their application in relational databases and is in the realm of database theory.
See main article: Query evaluation. For the study of the computational complexity of evaluating conjunctive queries, two problems have to be distinguished. The first is the problem of evaluating a conjunctive query on a relational database where both the query and the database are considered part of the input. The complexity of this problem is usually referred to as combined complexity, while the complexity of the problem of evaluating a query on a relational database, where the query is assumed fixed, iscalled data complexity.
Conjunctive queries are NP-complete with respect to combined complexity,[3] while the data complexity of conjunctive queries is very low, in the parallel complexity class AC0, which is contained in LOGSPACE and thus in polynomial time. The NP-hardness of conjunctive queries may appear surprising, since relational algebra and SQL strictly subsume the conjunctive queries and are thus at least as hard (in fact, relational algebra is PSPACE-complete with respect to combined complexity and is therefore even harder under widely held complexity-theoretic assumptions). However, in the usual application scenario, databases are large, while queries are very small, and the data complexity model may be appropriate for studying and describing their difficulty.
The problem of listing all answers to a non-Boolean conjunctive query has been studied in the context of enumeration algorithms, with a characterization (under some computational hardness assumptions) of the queries for which enumeration can be performed with linear time preprocessing and constant delay between each solution. Specifically, these are the acyclic conjunctive queries which also satisfy a free-connex condition.[4]
Conjunctive queries are one of the great success stories of database theory in that many interesting problems that are computationally hard or undecidable for larger classes of queries are feasible for conjunctive queries.[5] For example, consider the query containment problem. We write
R\subseteqS
R,S
R
S
Q
I
Q(I)
Q1
Q2
I
Q1(I)\subseteqQ2(I)
The query containment problem is undecidable for relational algebra and SQL but is decidable and NP-complete for conjunctive queries. In fact, it turns out that the query containment problem for conjunctive queries is exactly the same problem as the query evaluation problem.[5] Since queries tend to be small, NP-completeness here is usually considered acceptable. The query containment problem for conjunctive queries is also equivalent to the constraint satisfaction problem.
An important class of conjunctive queries that have polynomial-time combined complexity are the acyclic conjunctive queries.[6] The query evaluation, and thus query containment, is LOGCFL-complete and thus in polynomial time.[7] Acyclicity of conjunctive queries is a structural property of queries that is defined with respect to the query's hypergraph:[5] a conjunctive query is acyclic if and only if it has hypertree-width 1. For the special case of conjunctive queries in which all relations used are binary, this notion corresponds to the treewidth of the dependency graph of the variables in the query (i.e., the graph having the variables of the query as nodes and an undirected edge
\{x,y\}
R(x,y)
R(y,x)
An important generalization of acyclicity is the notion of bounded hypertree-width, which is a measure of how close to acyclic a hypergraph is, analogous to bounded treewidth in graphs. Conjunctive queries of bounded tree-width have LOGCFL combined complexity.[8]
Unrestricted conjunctive queries over tree data (i.e., a relational database consisting of a binary child relation of a tree as well as unary relations for labeling the tree nodes) have polynomial time combined complexity.[9]