Answering Conjunctive Queries under Updates

TL;DR

This paper introduces q-hierarchical conjunctive queries and demonstrates their efficient maintenance and enumeration in dynamic databases, establishing dichotomies based on query structure and leveraging fine-grained complexity conjectures.

Contribution

It defines q-hierarchical queries and proves they can be maintained with constant delay and update time, providing a clear classification for query enumeration and counting complexity.

Findings

Q-hierarchical queries allow efficient enumeration and maintenance.

Non-q-hierarchical queries cannot achieve sublinear delay and update time.

Complete dichotomies are established for Boolean and counting conjunctive queries.

Abstract

We consider the task of enumerating and counting answers to $k$-ary conjunctive queries against relational databases that may be updated by inserting or deleting tuples. We exhibit a new notion of q-hierarchical conjunctive queries and show that these can be maintained efficiently in the following sense. During a linear time preprocessing phase, we can build a data structure that enables constant delay enumeration of the query results; and when the database is updated, we can update the data structure and restart the enumeration phase within constant time. For the special case of self-join free conjunctive queries we obtain a dichotomy: if a query is not q-hierarchical, then query enumeration with sublinear$^\ast$ delay and sublinear update time (and arbitrary preprocessing time) is impossible. For answering Boolean conjunctive queries and for the more general problem of counting the number of solutions of k-ary queries we obtain complete dichotomies: if the query's homomorphic core is q-hierarchical, then size of the the query result can be computed in linear time and maintained with constant update time. Otherwise, the size of the query result cannot be maintained with sublinear update time. All our lower bounds rely on the OMv-conjecture, a conjecture on the hardness of online matrix-vector multiplication that has recently emerged in the field of fine-grained complexity to characterise the hardness of dynamic problems. The lower bound for the counting problem additionally relies on the orthogonal vectors conjecture, which in turn is implied by the strong exponential time hypothesis. $^\ast)$ By sublinear we mean $O(n^{1-\varepsilon})$ for some $\varepsilon>0$, where $n$ is the size of the active domain of the current database.

Tables

Table 1. Table 1: Enumeration of φ ​ ( D 0 ) 𝜑 subscript 𝐷 0 \varphi({D_{0}}) using data structure 𝙳 0 subscript 𝙳 0 \mathtt{D}_{0} depicted in Figure  3(a) .

$x$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$a$	$b$	$b$	$b$	$b$	$b$	$b$	$b$	$b$	$b$
$y$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$e$	$f$	$f$	$g$	$g$	$g$	$g$	$g$	$g$	$g$	$g$	$g$
$z$	$a$	$a$	$a$	$a$	$a$	$a$	$b$	$b$	$b$	$b$	$b$	$b$	$c$	$c$	$b$	$b$	$b$	$b$	$b$	$b$	$b$	$b$	$b$
$z^{\prime }$	$a$	$a$	$b$	$b$	$c$	$c$	$a$	$a$	$b$	$b$	$c$	$c$	$c$	$c$	$a$	$a$	$a$	$b$	$b$	$b$	$c$	$c$	$c$
$y^{\prime }$	$e$	$f$	$e$	$f$	$e$	$f$	$e$	$f$	$e$	$f$	$e$	$f$	$e$	$f$	$d$	$g$	$h$	$d$	$g$	$h$	$d$	$g$	$h$

Equations

$$\exists y_{1}\,\cdots\,\exists y_{\ell}\;\big{(}\,\psi_{1}\,\wedge\,\cdots\,\wedge\,\psi_{d}\,\big{)}$$

$$\varphi_{S\text{-}E\text{-}T}\quad:=\quad\big{(}\,Sx\,\wedge\,Exy\,\wedge\,Ty\,\big{)}$$

$$\varphi^{\prime}_{S\text{-}E\text{-}T}\quad:=\quad\exists x\,\exists y\;\big{(}\,Sx\,\wedge\,Exy\,\wedge\,Ty\,\big{)}$$

$$\varphi_{E\text{-}T}\quad:=\quad\exists y\;\big{(}\,Exy\,\wedge\,Ty\,\big{)}.$$

$$\displaystyle\varphi\$$

$$\displaystyle\varphi^{\prime}\$$

$$\big{\{}(a_{1},\ldots,a_{k})\in\varphi(D)\ :\ \text{there is a permutation ${\pi}\colon[k]\to[k]$ with $a_{i}\in X_{x_{{\pi}(i)}}$ for all $i\in[k]$}\big{\}}\,.$$

$$\big{|}\varphi(D)\cap\bigl{(}X_{x_{1}}\times\cdots\times X_{x_{k}}\bigr{)}\big{|}\,\cdot\,\big{|}\Pi\big{|}\ \ =\ \ |{\mathcal{R}}(D)|\,.$$

$${\mathcal{R}}_{I,j}\ \ :=\ \ \{\,(a_{1},\ldots,a_{k})\in\varphi(D)\ :\ \big{|}\{a_{1},\ldots,a_{k}\}\cap\bigl{(}\textstyle\bigcup_{i\in I}X_{x_{i}}\bigr{)}\big{|}=j\,\}.$$

$$\mathcal{R}(D)={\mathcal{R}}_{[k],k}\setminus \bigcup _{i\in [k]}{\mathcal{R}}_{[k]\setminus \{i\},k}.$$

$$|\mathcal{R}(D)|$$

$$\displaystyle\ \ =\ \ \sum_{I\subseteq[k]}(-1)^{|I|}\cdot\Bigl{|}{\mathcal{R}}_{[k]\setminus I,k}\Bigr{|}.$$

$$R^{D_{I,\ell}}:=\big{\{}\bigl{(}\langle a_{1}\rangle^{s_{1}},\ldots,\langle a_{r}\rangle^{s_{r}}\bigr{)}\colon(a_{1},\ldots,a_{r})\in R^{D},s_{i}=1\text{ for }i\notin I,\text{ and }s_{i}\in[\ell]\text{ for }i\in I\big{\}}.$$

$$\big{|}\varphi(D_{I,\ell})\big{|}\quad=\quad\sum_{j=0}^{k}\ \ell^{j}\cdot\big{|}{\mathcal{R}}_{I,j}\big{|}.$$

$$\varphi(D)\ \cap\ \bigl{(}X_{x}\times X_{z_{1}}\times\cdots\times X_{z_{{\ell^{\prime}}}}\bigr{)}\ \ =\ \ \big{\{}\,(a_{i},c_{1},\ldots,c_{{\ell^{\prime}}})\ :\ i\in[n],\ (\vec{u}^{\,i})^{\,\mkern-1.5mu\mathsf{T}}\vec{v}\neq 0\,\big{\}}$$

$$\varphi\quad=\quad\exists x_{k+1}\cdots\exists x_{m}\,\big{(}\psi_{1}\wedge\cdots\wedge\psi_{\ell}\big{)}\,.$$

$${\mathcal{E}}^i$$

$$C^i$$

$$C_u^i$$

$$\big{(}\;Rxyz\,\wedge\,Rxyz^{\prime}\,\wedge\,Exy\,\wedge\,Exy^{\prime}\,\wedge\,Sxyz\;\big{)}$$

$${\tilde{\mathcal{E}}}^i:=\{{\beta }_{|\text{free}(\phi )}:\beta \in {\mathcal{E}}^i\}$$

$${\beta }_{\mathcal{I}}=\bigcup _{v\in V^{\prime }}{\beta }^{i_v}\subseteq \bigcup _{v\in V^{\prime }}{\gamma }_v={\gamma }_{v_{\text{textsl}root}}.$$

$$C^i={\prod }_{\psi \in \text{rep}(v)}{C}_{\psi }^i\cdot {\prod }_{u\in N(v)}{C}_u^i.$$

$${\tilde{C}}^i$$

$${\tilde{C}}_u^i$$

$${\tilde{C}}_{\text{start}}$$

$${\tilde{C}}^i=\{\begin{array}{ll}0& \text{if }{C}^i=0\\ {\prod }_{u\in N(v)\cap \text{free}(\phi )}{\tilde{C}}_u^i& \text{otherwise.}\end{array}$$

$${\phi }_1(x,y)$$

$${\phi }_2(x,y,z_1,z_2)$$

Full text

We exhibit a new notion of q-hierarchical conjunctive queries and show that these can be maintained efficiently in the following sense. During a linear time preprocessing phase, we can build a data structure that enables constant delay enumeration of the query results; and when the database is updated, we can update the data structure and restart the enumeration phase within constant time. For the special case of self-join free conjunctive queries we obtain a dichotomy: if a query is not q-hierarchical, then query enumeration with sublinear∗ delay and sublinear update time (and arbitrary preprocessing time) is impossible.

For answering Boolean conjunctive queries and for the more general problem of counting the number of solutions of $k$-ary queries we obtain complete dichotomies: if the query’s homomorphic core is q-hierarchical, then size of the the query result can be computed in linear time and maintained with constant update time. Otherwise, the size of the query result cannot be maintained with sublinear update time.

All our lower bounds rely on the OMv-conjecture, a conjecture on the hardness of online matrix-vector multiplication that has recently emerged in the field of fine-grained complexity to characterise the hardness of dynamic problems. The lower bound for the counting problem additionally relies on the orthogonal vectors conjecture, which in turn is implied by the strong exponential time hypothesis.

${}^{\ast})$ By sublinear we mean $O(n^{1-\varepsilon})$ for some $\varepsilon>0$, where $n$ is the size of the active domain of the current database.

1 Introduction

We study the algorithmic problem of answering a conjunctive query $\varphi$ against a dynamically changing relational database $D$. Depending on the problem setting, we want to answer a Boolean query, count the number of output tuples of a non-Boolean query, or enumerate the query result with constant delay. We consider finite relational databases over a possibly infinite domain in the fully dynamic setting where new tuples can be inserted or deleted.

At the beginning, a dynamic query evaluation algorithm gets a query $\varphi$ together with an initial database ${D_{0}}$. It starts with a preprocessing phase where a suitable data structure is built to represent the result of evaluating $\varphi$ against ${D_{0}}$. Afterwards, when the database is updated by inserting or deleting a tuple, the data structure is updated, too, and the result of evaluating $\varphi$ on the updated database is reported.

The update time is the time needed to compute the representation of the new query result. In order to be efficient, we require that the update time is way smaller than the time needed to recompute the entire query result. In particular, we consider constant update time that only depends on the query but not on the database, as feasible. One can even argue that update time that scales polylogarithmically ($\log^{O(1)}|\!|D|\!|$) with the size $|\!|D|\!|$ of the database is feasible. On the other hand, we regard update time that scales polynomially ($|\!|D|\!|^{\Omega(1)}$) with the database as infeasible.

This paper’s aim is to classify those conjunctive queries (CQs, for short) that can be efficiently maintained under updates, and to distinguish them from queries that are hard in this sense.

1.1 Our Contribution

We identify a subclass of conjunctive queries that can be efficiently maintained by a dynamic evaluation algorithm. We call these queries q-hierarchical, and this notion is strongly related to the hierarchical property that was introduced by Dalvi and Suciu in [13] and has already played a central role for efficient query evaluation in various contexts (see Section 3 for a definition and discussion of related concepts). We show that after a linear time preprocessing phase the result of any q-hierarchical conjunctive query can be maintained with constant update time. This means that after every update we can answer a Boolean q-hierarchical query and compute the number of result tuples of a non-Boolean query in constant time. Moreover, we can enumerate the query result with constant delay.

We are also able to prove matching lower bounds. These bounds are conditioned on the OMv-conjecture, a conjecture on the hardness of online matrix-vector multiplication that was introduced by Henzinger, Krinninger, Nanongkai, and Saranurak in [23] to characterise the hardness of many dynamic problems. The lower bound for the counting problem additionally relies on the OV-conjecture, a conjecture on the hardness of the orthogonal vectors problem which in turn is implied by the well-known strong exponential time hypothesis [38]. We obtain the following dichotomies, which are stated from the perspective of data complexity (i.e., the query is regarded to be fixed) and hold for any fixed $\varepsilon>0$. By $n$ we always denote the size of the active domain of the current database $D$. For the enumeration problem we restrict our attention to self-join free CQs, where every relation symbol occurs only once in the query.

Theorem 1.1**.**

*Let $\varphi$ be a self-join free CQ.

If $\varphi$ is q-hierarchical, then after a linear time preprocessing phase the query result $\varphi(D)$ can be enumerated with constant delay and constant update time.

Otherwise, unless the OMv-conjecture fails, there is no dynamic algorithm that enumerates $\varphi$ with arbitrary preprocessing time, and $O(n^{1-\varepsilon})$ delay and update time.*

Theorem 1.2**.**

*Let $\varphi$ be a Boolean CQ.

If the homomorphic core of $\varphi$ is q-hierarchical, then the query can be answered with linear preprocessing time and constant update time.

Otherwise, unless the OMv-conjecture fails, there is no algorithm that answers $\varphi$ with arbitrary preprocessing time and $O(n^{1-\varepsilon})$ update time.*

Theorem 1.3**.**

*Let $\varphi$ be a CQ.

If $\varphi$ is q-hierarchical, then the number $|\varphi(D)|$ of tuples in the query result can be computed with linear preprocessing time and constant update time.

Otherwise, assuming the OMv-conjecture and the OV-conjecture, there is no algorithm that computes $|\varphi(D)|$ with arbitrary preprocessing time and $O(n^{1-\varepsilon})$ update time.*

For the databases we construct in our lower bound proofs it holds that $n\approx\sqrt{|\!|D|\!|}$. Therefore all our lower bounds of the form $n^{1-\varepsilon}$ translate to $|\!|D|\!|^{\frac{1}{2}-\varepsilon}$ in terms of the size of the database.

1.2 Related Work

In more practically motivated papers the task of answering a fixed query against a dynamic database has been studied under the name incremental view maintenance (see e. g. [22]). Given the huge amount of theoretical results on the complexity of query evaluation in the static setting, surprisingly little is known about the computational complexity of query evaluation under updates.

The dynamic descriptive complexity framework introduced by Patnaik and Immerman [32] focuses on the expressive power of (fragments or extensions of) first-order logic on dynamic databases and has led to a rich body of literature (see [33] for a survey). This approach, however, is quite different from the algorithmic setting considered in the present paper, as in every update step the internal data structure is updated by evaluating a first-order query. As this may take polynomial time even for the special case of conjunctive queries (as considered e. g. by Zeume and Schwentick in [40]), this is too expensive in the area of dynamic algorithms.

We are aware of only a few papers dealing with the computational complexity of query evaluation under updates, namely the study of XPath evaluation of Björklund, Gelade, and Martens [8] and the studies of MSO queries on trees by Balmin, Papakonstantinou, and Vianu [5] and by Losemann and Martens [26], the latter of which is to the best of our knowledge the only work that deals with efficient query enumeration under updates.111Let us mention that in a follow-up of the present paper, we characterise the dynamic complexity of counting and enumerating the results of first-order queries (and their extensions by modulo-counting quantifiers) on bounded degree databases [7].

In the static setting, a lot of research has been devoted to classify those conjunctive queries that can be answered efficiently. Below we give an overview of known results.

Complexity of Boolean Queries. The complexity of answering Boolean conjunctive queries on a static database is fairly well understood. For every fixed database schema $\sigma$, extending a result of [21], Grohe [20] gave a tight characterisation of the tractable CQs under the complexity theoretic assumption FPT $\neq$ W[1]: If we are given a Boolean CQ $\varphi$ of size $|\!|\varphi|\!|$ and a $\sigma$-database $D$ of size $m$, then $\varphi$ can be answered against $D$ in time $f(|\!|\varphi|\!|)\cdot m^{O(1)}$ for some computable function $f$ if, and only if, the homomorphic core of $\varphi$ has bounded treewidth. Marx [27] extended this classification to the case where the schema is part of the input.

Counting Complexity. For computing the number of output tuples of a given join query (i.e., a quantifier-free CQ) over a fixed schema $\sigma$, a characterisation was proven by Dalmau and Jonsson [12]: Assuming FPT $\neq$ #W[1], the output size \big{|}\varphi(D)\big{|} of a join query $\varphi$ evaluated on a $\sigma$-database $D$ of size $m$ can be computed in time $f(|\!|\varphi|\!|)\cdot m^{O(1)}$ if, and only if, $\varphi$ has bounded treewidth. The result has recently been extended to all conjunctive queries over a fixed schema by Chen and Mengel [11]. Structural properties that make the counting problem for CQs tractable in the case where the schema is part of the input have been identified in [16, 18].

Join Evaluation. When the entire result of a non-Boolean query has to be computed, the evaluation problem cannot be modelled as a decision or counting problem and one has to come up with different measures to characterise the hardness of query evaluation. One approach that has been fruitfully applied to join evaluation is to study the worst-case output size as a measure of the hardness of a query. Atserias, Grohe, and Marx [3] identified the fractional edge cover number of the join query as a crucial measure for lower bounding its worst-case output size. This bound was also shown to be optimal and is matched by so called “worst-case optimal” join evaluation algorithms, see [30, 37, 29, 24].

Query Enumeration. Another way of studying non-Boolean queries that is independent of the actual or worst-case output size is query enumeration. A query enumeration algorithm evaluates a non-Boolean query by reporting, one by one without repetition, the tuples in the query result. The crucial measure to characterise queries that are tractable w.r.t. enumeration is the delay between two output tuples. In the context of constraint satisfaction, the combined complexity, where the query as well as the database are given as input, has been considered. As the size of the query result might be exponential in the input size in this setting, queries that can be enumerated with polynomial delay and polynomial preprocessing are regarded as “tractable.” Classes of conjunctive queries that can be enumerated with polynomial delay have been identified in [10, 19]. However, a complete characterisation of conjunctive queries that are tractable in this sense is not in sight.

More relevant to the database setting, where one evaluates a small query against a large database, is the notion of constant delay enumeration introduced by Durand and Grandjean in [15]. The preprocessing time is supposed to be much smaller than the time needed to evaluate the query (usually, linear in the size of the database), and the delay between two output tuples may depend on the query, but not on the database. A lot of research has been devoted to this subject, where one usually tries to understand which structural restrictions on the query or on the database allow constant delay enumeration. For an introduction to this topic and an overview of the state-of-the-art we refer the reader to the surveys [35, 34, 36].

Bagan, Durand, and Grandjean [4] showed that acyclic conjunctive queries that are free-connex can be enumerated with constant delay after a linear time preprocessing phase (cf. [9] for a simplified proof of their result). They also showed that for self-join free acyclic conjunctive queries the free-connex property is essential by proving the following lower bound. Assume that multiplying two $n\times n$ matrices cannot be done in time $O(n^{2})$. Then the result of a self-join free acyclic conjunctive query that is not free-connex cannot be enumerated with constant delay after a linear time preprocessing phase.

It turns out that our notion of q-hierarchical conjunctive queries is a proper subclass of the free-connex conjunctive queries. Thus, there are queries that can be efficiently enumerated in the static setting but are hard to maintain under database updates.

Organisation. The remainder of the paper is structured as follows. In Section 2 we fix the basic notation along with the concept of dynamic algorithms for query evaluation. Section 3 introduces q-hierarchical queries and formally states our main theorems. We then present an alternative characterisation of q-hierarchical queries in Section 4 and prove our lower and upper bound theorems in Sections 5 and 6, respectively. We conclude in Section 7.

Acknowledgement. We acknowledge the financial support by the German Research Foundation DFG under grant SCHW 837/5-1. The first author wants to thank Thatchaphol Saranurak and Ryan Williams for helpful discussions on algorithmic conjectures.

2 Preliminaries

We write $\mathbb{N}$ for the set of non-negative integers and let $\mathbb{N}_{\scriptscriptstyle\geqslant 1}:=\mathbb{N}\setminus\{0\}$ and $[n]:=\{1,\ldots,n\}$ for all $n\in\mathbb{N}_{\scriptscriptstyle\geqslant 1}$. By $2^{M}$ we denote the power set of a set $M$.

Databases. We fix a countably infinite set dom, the domain of potential database entries. Elements in dom are called constants. A schema is a finite set $\sigma$ of relation symbols, where each $R\in\sigma$ is equipped with a fixed arity $\operatorname{ar}(R)\in\mathbb{N}_{\scriptscriptstyle\geqslant 1}$. Let us fix a schema $\sigma=\{R_{1},\ldots,R_{s}\}$, and let $r_{i}:=\operatorname{ar}(R_{i})$ for $i\in[s]$. A database $D$ of schema $\sigma$ ($\sigma$-db, for short), is of the form $D=(R_{1}^{D},\ldots,R_{s}^{D})$, where $R_{i}^{D}$ is a finite subset of $\textbf{dom}^{r_{i}}$. The active domain $\textrm{adom}(D)$ of $D$ is the smallest subset $A$ of dom such that $R_{i}^{D}\subseteq A^{r_{i}}$ for all $i\in[s]$.

Updates. We allow to update a given database of schema $\sigma$ by inserting or deleting tuples as follows. An insertion command is of the form insert $R(a_{1},\ldots,a_{r})$ for $R\in\sigma$, $r=\operatorname{ar}(R)$, and $a_{1},\ldots,a_{r}\in\textbf{dom}$. When applied to a $\sigma$-db $D$, it results in the updated $\sigma$-db $D^{\prime}$ with $R^{D^{\prime}}:=R^{D}\cup\{(a_{1},\ldots,a_{r})\}$ and $S^{D^{\prime}}:=S^{D}$ for all $S\in\sigma\setminus\{R\}$. A deletion command is of the form delete $R(a_{1},\ldots,a_{r})$ for $R\in\sigma$, $r=\operatorname{ar}(R)$, and $a_{1},\ldots,a_{r}\in\textbf{dom}$. When applied to a $\sigma$-db $D$, it results in the updated $\sigma$-db $D^{\prime}$ with $R^{D^{\prime}}:=R^{D}\setminus\{(a_{1},\ldots,a_{r})\}$ and $S^{D^{\prime}}:=S^{D}$ for all $S\in\sigma\setminus\{R\}$. Note that both types of commands may change the database’s active domain.

Queries. We fix a countably infinite set var of variables. An atomic query (for short: atom) $\psi$ of schema $\sigma$ is of the form $Ru_{1}\cdots u_{r}$ with $R\in\sigma$, $r=\operatorname{ar}(R)$, and $u_{1},\ldots,u_{r}\in\textbf{var}$. The set of variables occurring in $\psi$ is denoted by $\textrm{vars}(\psi):=\{u_{1},\ldots,u_{r}\}$. A conjunctive query (CQ, for short) of schema $\sigma$ is of the form

[TABLE]

where $\ell\in\mathbb{N}$, $d\in\mathbb{N}_{\scriptscriptstyle\geqslant 1}$, $\psi_{j}$ is an atomic query of schema $\sigma$ for every $j\in[d]$, and $y_{1},\ldots,y_{\ell}$ are pairwise distinct elements in var. Join queries are quantifier-free CQs, i.e., CQs of the form \big{(}\psi_{1}\wedge\cdots\wedge\psi_{d}\big{)}. A CQ is called self-join free (or non-repeating or simple) if no relation symbol occurs more than once in the query. For a CQ $\varphi$ of the form (1) we let $\textrm{vars}(\varphi)$ be the set of all variables occurring in $\varphi$, and we let $\textrm{free}(\varphi):=\textrm{vars}(\varphi)\setminus\{y_{1},\ldots,y_{\ell}\}$ be the set of free variables.

For $k\in\mathbb{N}$, a $k$-ary conjunctive query ($k$-ary CQ, for short) is of the form $\varphi(x_{1},\ldots,x_{k})$, where $\varphi$ is a CQ of schema $\sigma$, $k=|\textrm{free}(\varphi)|$, and $x_{1},\ldots,x_{k}$ is a list of the free variables of $\varphi$. We will often assume that the tuple $(x_{1},\ldots,x_{k})$ is clear from the context and simply write $\varphi$ instead of $\varphi(x_{1},\ldots,x_{k})$. The semantics of CQs are defined as usual:  A valuation is a mapping $\beta:\textbf{var}\to\textbf{dom}$. For a $\sigma$-db $D$ and an atomic query $\psi=Ru_{1}\cdots u_{r}$ we write $(D,\beta)\models\psi$ to indicate that \big{(}\beta(u_{1}),\ldots,\beta(u_{r})\big{)}\in R^{D}. For a $k$-ary CQ $\varphi(x_{1},\ldots,x_{k})$ where $\varphi$ is of the form (1), and for a tuple $\overline{a}=(a_{1},\ldots,a_{k})\in\textbf{dom}^{k}$, a valuation $\beta$ is said to be compatible with $\overline{a}$ iff $\beta(x_{i})=a_{i}$ for all $i\in[k]$. We write $D\models\varphi[\overline{a}]$ to indicate that there is a valuation $\beta$ that is compatible with $\overline{a}$ such that $(D,\beta)\models\psi_{j}$ for all $j\in[d]$. The query result $\varphi(D)$ is defined as the set of all tuples $\overline{a}\in\textbf{dom}^{k}$ with $D\models\varphi[\overline{a}]$. Clearly, $\varphi(D)\subseteq\textrm{adom}(D)^{k}$.

A Boolean CQ is a CQ $\varphi$ with $\textrm{free}(\varphi)=\emptyset$. As usual, for Boolean CQs $\varphi$ we will write $\varphi(D)=\texttt{yes}$ instead of $\varphi(D)\neq\emptyset$, and $\varphi(D)=\texttt{no}$ instead of $\varphi(D)=\emptyset$.

Sizes and Cardinalities. The size $|\!|\varphi|\!|$ of a CQ $\varphi$ is defined as the length of $\varphi$ when viewed as a word over the alphabet $\sigma\cup\textbf{var}\cup\{\exists,\wedge,(,)\}$. For a $k$-ary CQ $\varphi(x_{1},\ldots,x_{k})$ and a $\sigma$-DB $D$, the cardinality of the query result is the number $|\varphi(D)|$ of tuples in $\varphi(D)$.

The cardinality $|D|$ of a $\sigma$-db $D$ is defined as the number of tuples stored in $D$, i.e., $|D|:=\sum_{R\in\sigma}|R^{D}|$. The size $|\!|D|\!|$ of $D$ is defined as $|\sigma|+|\textrm{adom}(D)|+\sum_{R\in\sigma}\operatorname{ar}(R){\cdot}|R^{D}|$ and corresponds to the size of a reasonable encoding of $D$. We will often write $n$ to denote the cardinality $|\textrm{adom}(D)|$ of $D$’s active domain.

Dynamic Algorithms for Query Evaluation. We use Random Access Machines (RAMs) with $O(\log n)$ word-size and a uniform cost measure as a model of computation. In particular, adding and multiplying integers that are polynomial in the input size can be done in constant time. For our purposes it will be convenient to assume that $\textbf{dom}=\mathbb{N}_{\scriptscriptstyle\geqslant 1}$. We will assume that the RAM’s memory is initialised to [math]. In particular, if an algorithm uses an array, we will assume that all array entries are initialised to [math], and this initialisation comes at no cost (in real-world computers this can be achieved by using the lazy array initialisation technique, cf. e.g. the textbook [28]). A further assumption that is unproblematic within the RAM-model, but unrealistic for real-world computers, is that for every fixed dimension $d\in\mathbb{N}_{\scriptscriptstyle\geqslant 1}$ we have available an unbounded number of $d$-ary arrays A such that for given $(n_{1},\ldots,n_{d})\in\mathbb{N}^{d}$ the entry $\texttt{A}[n_{1},\ldots,n_{d}]$ at position $(n_{1},\ldots,n_{d})$ can be accessed in constant time.222While this can be accomplished easily in the RAM-model, for an implementation on real-world computers one would probably have to resort to replacing our use of arrays by using suitably designed hash functions.

Our algorithms will take as input a $k$-ary CQ $\varphi(x_{1},\ldots,x_{k})$ and a $\sigma$-db ${D_{0}}$. For all query evaluation problems considered in this paper, we aim at routines preprocess and update which achieve the following:

1. $\bullet$

upon input of $\varphi(x_{1},\ldots,x_{k})$ and ${D_{0}}$, preprocess builds a data structure $\mathtt{D}$ which represents ${D_{0}}$ (and which is designed in such a way that it supports efficient evaluation of $\varphi$ on ${D_{0}}$) 2. $\bullet$

upon input of a command $\textsf{update}\ R(a_{1},\ldots,a_{r})$ (with $\textsf{update}\in\{\textsf{insert},\textsf{delete}\}$), calling update modifies the data structure $\mathtt{D}$ such that it represents the updated database $D$.

The preprocessing time $t_{p}$ is the time used for performing preprocess; the update time $t_{u}$ is the time used for performing an update.

In the following, $D$ will always denote the database that is currently represented by the data structure $\mathtt{D}$. To solve the enumeration problem under updates, apart from the routines preprocess and update we aim at a routine enumerate such that calling enumerate invokes an enumeration of all tuples (without repetition) that belong to the query result $\varphi(D)$. The delay $t_{d}$ is the maximum time used during a call of enumerate

1. $\bullet$

until the output of the first tuple (or the end-of-enumeration message EOE, if $\varphi(D)=\emptyset$), 2. $\bullet$

between the output of two consecutive tuples, and 3. $\bullet$

between the output of the last tuple and the end-of-enumeration message EOE.

To solve the counting problem under updates, instead of enumerate we aim at a routine count which outputs the cardinality $|\varphi(D)|$ of the query result. The counting time $t_{c}$ is the time used for performing a count. To answer a Boolean conjunctive query under updates, instead of enumerate or count we aim at a routine answer that produces the answer yes or no of $\varphi$ on $D$. The answer time $t_{a}$ is the time used for performing answer. Whenever speaking of a dynamic algorithm, we mean an algorithm that has routines preprocess and update and, depending on the problem at hand, at least one of the routines enumerate, count, and answer.

Throughout the paper, we often adopt the view of data complexity and use the $O$-notation to suppress factors that may depend on the query but not on the database. For example, “linear preprocessing time” means $t_{p}=f(\varphi)\cdot|\!|{D_{0}}|\!|$ and “constant update time” means $t_{u}=f(\varphi)$, for a function $f$ with codomain $\mathbb{N}$. When writing $\operatorname{\textit{poly}}(\varphi)$ we mean $|\!|\varphi|\!|^{O(1)}$.

3 Main Results

Our notion of q-hierarchical conjunctive queries is related to the hierarchical property that has already played a central role for efficient query evaluation in various contexts. It has been introduced by Dalvi and Suciu in [13] to characterise the Boolean CQs that can be answered in polynomial time on probabilistic databases. They obtained a dichotomy stating for self-join free queries that the complexity of query evaluation on probabilistic databases is in PTIME for hierarchical queries and #P-complete for non-hierarchical queries. Fink and Olteanu [17] generalised the notion and the dichotomy result to non-Boolean queries and to queries using negation. In the different context of query evaluation on massively parallel architectures, Koutris and Suciu [25] considered hierarchical join queries and singled out a subclass of so-called tall-flat queries as exactly those queries that can be computed with only one broadcast step in their Massively Parallel model of query evaluation. For further information on the various uses of the hierarchical property we refer the reader to [17].

The definition of hierarchical queries relies on the following notion. Consider a CQ $\varphi$ of the form (1). For every variable $x\in\textrm{vars}(\varphi)$ we let $\textrm{atoms}(x)$ be the set of all atoms $\psi_{j}$ of $\varphi$ such that $x\in\textrm{vars}(\psi_{j})$. Dalvi and Suciu [13] call a Boolean CQ $\varphi$ hierarchical iff the condition

• $(*)$:

$\textrm{atoms}(x)\subseteq\textrm{atoms}(y)$  or  $\textrm{atoms}(x)\supseteq\textrm{atoms}(y)$  or  $\textrm{atoms}(x)\cap\textrm{atoms}(y)=\emptyset$

is satisfied by all variables $x,y\in\textrm{vars}(\varphi)$. An example for a hierarchical Boolean CQ is  \exists x\exists y\exists z\exists y^{\prime}\exists z^{\prime}\,\big{(}Rxyz\,\wedge\,Rxyz^{\prime}\,\wedge\,Exy\,\wedge\,Exy^{\prime}\big{)}.

In [25], Koutris and Suciu transferred the notion to join queries $\varphi$, which they call hierarchical iff condition $(*)$ is satisfied by all variables $x,y\in\textrm{vars}(\varphi)$. In [17], Fink and Olteanu introduced a slightly different notion for a more general class of queries. Translated into the setting of CQs, their notion (only) requires that condition $(*)$ is satisfied by all quantified variables, i.e., variables $x,y\in\textrm{vars}(\varphi)\setminus\textrm{free}(\varphi)$. Obviously, both notions coincide on Boolean CQs, but on join queries Koutris and Suciu’s notion is more restrictive than Fink and Olteanu’s notion (according to which all quantifier-free CQs are hierarchical). For example, the join query

[TABLE]

is hierarchical w.r.t. Fink and Olteanu’s notion, and non-hierarchical w.r.t. Koutris and Suciu’s notion.

In the context of answering queries under updates, our lower bound results show that the join query $\varphi_{S\text{-}E\text{-}T}$, as well as its Boolean version

[TABLE]

are intractable. A further query that is hierarchical, but intractable in our setting is

[TABLE]

To ensure tractability of a conjunctive query in our setting, we will require that its quantifier-free part is hierarchical in Koutris and Suciu’s notion and, additionally, the quantifiers respect the query’s hierarchical form. We call such queries q-hierarchical.

Definition 3.1**.**

A CQ $\varphi$ is q-hierarchical if for any two variables $x,y\in\textrm{vars}(\varphi)$ the following is satisfied:

1. (i)

$\textrm{atoms}(x)\subseteq\textrm{atoms}(y)$  or  $\textrm{atoms}(x)\supseteq\textrm{atoms}(y)$  or  $\textrm{atoms}(x)\cap\textrm{atoms}(y)=\emptyset$ ,   and 2. (ii)

if $\textrm{atoms}(x)\subsetneq\textrm{atoms}(y)$ and $x\in\textrm{free}(\varphi)$, then $y\in\textrm{free}(\varphi)$.

Note that a Boolean CQ is q-hierarchical iff it is hierarchical, and a join query is q-hierarchical iff it is hierarchical w.r.t. Koutris and Suciu’s notion. The queries $\varphi_{S\text{-}E\text{-}T}$ and $\varphi_{E\text{-}T}$ are minimal examples for queries that are not q-hierarchical because they do not satisfy condition (i) and (ii), respectively. Regarding the query $\varphi_{E\text{-}T}$, note that all other versions such as the query \exists x\,\big{(}Exy\,\wedge\,Ty\big{)}, the join query \big{(}Exy\,\wedge\,Ty\big{)}, and the Boolean query \exists x\exists y\,\big{(}Exy\,\wedge\,Ty\big{)}, are q-hierarchical.

It is not hard to see that we can decide in polynomial time whether a given CQ is q-hierarchical (see Lemma 4.2). Our first main result shows that all q-hierarchical CQs can be efficiently maintained under database updates:

Theorem 3.2**.**

There is a dynamic algorithm that receives a q-hierarchical conjunctive query $\varphi$ and a $\sigma$-db ${D_{0}}$, and computes within $t_{p}=\operatorname{\textit{poly}}(\varphi){\cdot}O(|\!|{D_{0}}|\!|)$ preprocessing time a data structure that can be updated in time $t_{u}=\operatorname{\textit{poly}}(\varphi)$ and allows to

1. (a)

enumerate $\varphi(D)$ with delay $t_{d}=\operatorname{\textit{poly}}(\varphi)$,  and 2. (b)

compute the cardinality $|\varphi(D)|$ in time $t_{c}=O(1)$,

where $D$ is the current database.

Note that this implies that q-hierarchical Boolean conjunctive queries can be answered in constant time. Our algorithm crucially relies on the tree-like structure of hierarchical queries, which has already been used for efficient query evaluation in [14, 13, 25, 17, 31]. In Section 4 we present the notion of a q-tree and show that it precisely characterises the q-hierarchical conjunctive queries. These q-trees serve as a basis for the data structure used in our dynamic algorithm for query answering. Details on this algorithm along with a proof of Theorem 3.2 can be found in Section 6. Let us mention that every q-tree is an f-tree in the sense of [31], but there exist f-trees that are no q-trees. The dynamic data structure that is computed by our algorithm can be viewed as an f-representation of the query result [31], but not every f-representation can be efficiently maintained under database updates.

We now discuss our further main results, which show that the q-hierarchical property is necessary for designing efficient dynamic algorithms, and that the results from Theorem 3.2 cannot be extended to queries that are not q-hierarchical. As discussed in the introduction, our lower bounds rely on the OMv-conjecture and the OV-conjecture. For more details on these conjectures, as well as proofs of our lower bound theorems, we refer the reader to Section 5. In the following, ${D_{0}}$ denotes the initial database that serves as input for the preprocess routine, and $n=|\textrm{adom}(D)|$ denotes the size of the active domain of a dynamically changing database $D$. Our first lower bound theorem states that non-q-hierarchical self-join free conjunctive queries cannot be enumerated efficiently under updates.

Theorem 3.3**.**

Fix a number $\varepsilon>0$ and a self-join free conjunctive query $\varphi$. If $\varphi$ is not q-hierarchical, then there is no algorithm with arbitrary preprocessing time and $O(n^{1-\varepsilon})$ update time that enumerates $\varphi(D)$ with $O(n^{1-\varepsilon})$ delay, unless the OMv-conjecture fails.

For Boolean CQs we obtain a lower bound for all queries, i.e., also for queries that are not self-join free. To state the result, we need the standard notion of a homomorphic core. A homomorphism from a conjunctive query $\varphi(x_{1},\ldots,x_{k})$ to a conjunctive query $\varphi^{\prime}(y_{1},\ldots,y_{k})$ is a mapping $h$ from $\textrm{vars}(\varphi)$ to $\textrm{vars}(\varphi^{\prime})$ such that $h(x_{i})=y_{i}$ for all $i\in\{1,\ldots,k\}$, and if $Ru_{1}\cdots u_{r}$ is an atom of $\varphi$, then $R\,h(u_{1})\cdots h(u_{r})$ is an atom of $\varphi^{\prime}$. The homomorphic core (for short, core) of a conjunctive query $\varphi$ is a minimal subquery $\varphi^{\prime}$ of $\varphi$ such that there is a homomorphism from $\varphi$ to $\varphi^{\prime}$, but no homomorphism from $\varphi^{\prime}$ to a proper subquery of $\varphi^{\prime}$. By Chandra and Merlin’s homomorphism theorem, every CQ $\varphi$ has a unique (up to isomorphism) core $\varphi^{\prime}$, and $\varphi^{\prime}(D)=\varphi(D)$ for all databases $D$ (cf., e. g., [2]). While self-join free queries are their own cores, the situation is different for general CQs. Consider, for example, the queries

[TABLE]

Here, $\varphi^{\prime}$ is a core of $\varphi$ and thus $\varphi(D)=\varphi^{\prime}(D)$ for every database $D$. However, $\varphi^{\prime}$ is q-hierarchical, whereas $\varphi$ is not. The next lower bound theorem states that the result of a Boolean conjunctive query cannot be maintained efficiently if the query’s core is not q-hierarchical.

Theorem 3.4**.**

Fix a number $\varepsilon>0$ and a Boolean conjunctive query $\varphi$. If the homomorphic core of $\varphi$ is not q-hierarchical, then there is no algorithm with arbitrary preprocessing time and $t_{u}=O(n^{1-\varepsilon})$ update time that answers $\varphi(D)$ in time $t_{a}=O(n^{2-\varepsilon})$, unless the OMv-conjecture fails.

Let us now turn to the problem of computing the cardinality $|\varphi(D)|$ of the result of a query $\varphi(x_{1},\ldots,x_{k})$. From the Theorems 3.2 and 3.4 we know that we can efficiently decide whether $|\varphi(D)|>0$ if, and only if, the homomorphic core of $\exists x_{1}\cdots\exists x_{k}\,\varphi$ is q-hierarchical. The complexity of actually counting the number of tuples in $\varphi(D)$, however, depends on whether the core of the query $\varphi(x_{1},\ldots,x_{k})$ itself (rather than the core of its Boolean version $\exists x_{1}\cdots\exists x_{k}\,\varphi$) is q-hierarchical. As in the Boolean case, the next theorem (together with Theorem 3.2) implies a dichotomy for all conjunctive queries. One difference is that we have to additionally rely on the OV-conjecture.

Theorem 3.5**.**

Fix a number $\varepsilon>0$ and a conjunctive query $\varphi$. If the homomorphic core of $\varphi$ is not q-hierarchical, then there is no algorithm with arbitrary preprocessing time and $t_{u}=O(n^{1-\varepsilon})$ update time that computes $|\varphi(D)|$ in time $t_{c}=O(n^{1-\varepsilon})$, assuming the OMv-conjecture and the OV-conjecture.

Combining Theorem 3.2 with the Theorems 3.3, 3.4, and 3.5 immediately leads to the dichotomies (Theorems 1.1, 1.2, and 1.3) stated in the introduction.

4 The tree-like structure of q-hierarchical queries

We now give an alternative characterisation of q-hierarchical queries that sheds more light on their “tree-like” structure and will be useful for designing efficient query evaluation algorithms. We say that a CQ $\varphi$ is connected if for any two variables $x,y\in\textrm{vars}(\varphi)$ there is a path $x=z_{0},\ldots,z_{\ell}=y$ such that for each $j<\ell$ there is an atom $\psi$ of $\varphi$ such that $\{z_{j},z_{j+1}\}\subseteq\textrm{vars}(\psi)$. Note that every conjunctive query can be written as a conjunction $\bigwedge_{i}\varphi_{i}$ of connected conjunctive queries $\varphi_{i}$ over pairwise disjoint variable sets. We call these $\varphi_{i}$ the connected components of the query. Note that a query is q-hierarchical if, and only if, all its connected components are q-hierarchical. Next, we define the notion of a q-tree for a connected query $\varphi$ and show that $\varphi$ is q-hierarchical iff it has a q-tree.

Definition 4.1**.**

Let $\varphi$ be a connected CQ. A q-tree for $\varphi$ is a rooted directed tree $T_{\varphi}=(V,E)$ with $V=\textrm{vars}(\varphi)$ where

1. (1)

for all atoms $\psi$ in $\varphi$ the set $\textrm{vars}(\psi)$ forms a directed path in $T_{\varphi}$ that starts from the root, and 2. (2)

if $\textrm{free}(\varphi)\neq\emptyset$, then $\textrm{free}(\varphi)$ is a connected subset in $T_{\varphi}$ that contains the root.

See Figure 1 for examples of q-trees. The following lemma gives a characterisation of the q-hierarchical conjunctive queries via q-trees.

Lemma 4.2**.**

A CQ $\varphi$ is q-hierarchical if, and only if, every connected component of $\varphi$ has a q-tree. Moreover, there is a polynomial time algorithm which decides whether an input CQ $\varphi$ is q-hierarchical, and if so, outputs a q-tree for each connected component of $\varphi$.

To prove the lemma we inductively apply the following claim.

Claim 4.3**.**

For every connected q-hierarchical CQ $\varphi$ there is a variable $x\in\textrm{vars}(\varphi)$ that is contained in every atom of $\varphi$. Moreover, if $\textrm{free}(\varphi)\neq\emptyset$, then $x\in\textrm{free}(\varphi)$.

Proof.

For simplicity, we associate with every conjunctive query $\varphi$ the hypergraph $\mathcal{H}_{\varphi}$ with vertex set $\textrm{vars}(\varphi)$ and hyperedges $e_{\psi}:=\textrm{vars}(\psi)$ for every atom $\psi$ in $\varphi$. For a variable $x$ we let $\operatorname{E}(x):=\{e_{\psi}\ :\ x\in\textrm{vars}(\psi)\}$ be the set of hyperedges that contain $x$. Let us recall some basic notation concerning hypergraphs. A path of length $\ell$ in $\mathcal{H}_{\varphi}$ is a sequence of variables $x_{0},\ldots,x_{\ell}$ such that for every $i<\ell$ there is a hyperedge containing $x_{i}$ and $x_{i+1}$. Two variables have distance $\ell$ if they are connected by a path of length $\ell$, but not by a path of length $\ell-1$. We first show that (*) every pair of hyperedges in $\mathcal{H}_{\varphi}$ has a non-empty intersection. Suppose for contradiction that there are two hyperedges $e_{1}$ and $e_{2}$ with $e_{1}\cap e_{2}=\emptyset$, let $x_{0}\in e_{1}$ and $x_{\ell}\in e_{2}$ be two variables of distance $\ell\geqslant 2$, and $x_{0},\ldots,x_{\ell}$ be a shortest path connecting both variables. Hence, for every $i<\ell$ there is a hyperedge containing $x_{i}$ and $x_{i+1}$ but no other variable from the path. Therefore it holds that $\operatorname{E}(x_{0})\cap\operatorname{E}(x_{1})\neq\emptyset$. Furthermore, we have $e_{1}\notin\operatorname{E}(x_{1})$ and hence $\operatorname{E}(x_{0})\not\subseteq\operatorname{E}(x_{1})$. On the other hand, the hyperedge containing $x_{1}$ and $x_{2}$ does not contain $x_{0}$ and therefore $\operatorname{E}(x_{1})\not\subseteq\operatorname{E}(x_{0})$, which contradicts the assumption that $\varphi$ is q-hierarchical.

We now prove that there is a variable that is contained in every hyperedge (and hence in every atom of $\varphi$). We consider two cases. First suppose that for every pair of hyperedges $e_{i}$, $e_{j}$ it holds that either $e_{i}\subseteq e_{j}$ or $e_{j}\subseteq e_{i}$. Then there is a minimal hyperedge $e$ that is contained in every other hyperedge, and thus all of the variables in this hyperedge are contained in all other hyperedges as well.

Now suppose that there are two hyperedges $e_{i}$, $e_{j}$ such that $e_{i}\not\subseteq e_{j}$ and $e_{j}\not\subseteq e_{i}$. By (*), both hyperedges have a non-empty intersection. Thus, we can choose some $x\in e_{i}\cap e_{j}$. We want to argue that $x$ is contained in every hyperedge of $\mathcal{H}_{\varphi}$ and assume for contradiction that there is a hyperedge $e_{k}$ that does not contain $x$. By (*) we can choose some $y\neq x$ that is contained in the non-empty intersection of $e_{j}$ and $e_{k}$. But now we have $e_{j}\in\operatorname{E}(x)\cap\operatorname{E}(y)$, $e_{i}\in\operatorname{E}(x)\setminus\operatorname{E}(y)$, and $e_{k}\in\operatorname{E}(y)\setminus\operatorname{E}(x)$, contradicting that $\varphi$ is q-hierarchical.

Let $S$ be the set of all variables that are contained in every hyperedge. We have already shown that $S\neq\emptyset$. To ensure that there is a free variable in $S$, note that (by the definition of q-hierarchical CQs) if $x\in\textrm{free}(\varphi)$ and $x\notin S$, then $S\subset\textrm{free}(\varphi)$. Hence, $\textrm{free}(\varphi)\neq\emptyset$ implies that we can choose a variable from $\textrm{free}(\varphi)\cap S$ that satisfies the conditions of the claim. ∎

Proof of Lemma 4.2.

The proof of the “if” direction is easy, as every connected component that has a q-tree $T$ must be q-hierarchical, because if $y$ is a descendant of $x$ in $T$, then $\textrm{atoms}(y)\subseteq\textrm{atoms}(x)$.

For proving the “only if” direction of Lemma 4.2 we inductively apply Claim 4.3 to construct a q-tree $T_{\varphi}$ for all connected conjunctive queries $\varphi$ with at most $\ell$ variables. The induction start for empty queries is trivial. For the induction step, assume that there is a q-tree for every connected q-hierarchical query with at most $\ell$ variables, and let $\varphi$ be a connected q-hierarchical query with $\ell+1$ variables. By Claim 4.3 there is at least one variable that is contained in every atom, and if $\textrm{free}(\varphi)\neq\emptyset$ there is a free variable with this property. We choose such a variable $x$ (preferring free over quantified variables) and let $x$ be the root of $T_{\varphi}$.

Now we consider the query $\varphi^{\prime}$ that is obtained from $\varphi$ by “removing” $x$ from every atom. As this query is still q-hierarchical, we can find by induction a tree $T_{i}$ for every connected component $\varphi^{\prime}_{i}$ of $\varphi^{\prime}$. We let $T_{\varphi}$ be the disjoint union of the $T_{i}$ together with the root $x$ and conclude the construction by adding an edge from $x$ to the root of each $T_{i}$. It is easy to see that this construction can be computed in polynomial time. ∎

5 Lower Bounds

5.1 The OMv-conjecture

We write $\vec{w}_{i}$ to denote the $i$-th component of an $n$-dimensional vector $\vec{w}$, and we write $M_{i,j}$ for the entry in row $i$ and column $j$ of an $n\times n$ matrix $M$.

We consider matrices and vectors over $\{0,1\}$. All the arithmetic is done over the Boolean semiring, where multiplication means conjunction and addition means disjunction. For example, for $n$-dimensional vectors $\vec{u}$ and $\vec{v}$ we have $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}\vec{v}=1$ if and only if there is an $i\in[n]$ such the $\vec{u}_{i}=\vec{v}_{i}=1$. Let $M$ be an $n\times n$ matrix and let $\vec{v}^{\,1},\ldots,\vec{v}^{\,n}$ be a sequence of $n$ vectors, each of which has dimension $n$. The online matrix-vector multiplication problem is the following algorithmic task. At first, the algorithm gets an $n\times n$ matrix $M$ and is allowed to do some preprocessing. Afterwards, the algorithm receives the vectors $\vec{v}^{\,1},\ldots,\vec{v}^{\,n}$ one by one and has to output $M{\vec{v}^{\,t}}$ before it has access to $\vec{v}^{\,t+1}$ (for each $t<n$). The running time is the overall time the algorithm needs to produce the output $M\vec{v}^{\,1},\ldots,M\vec{v}^{\,n}$.

It is easy to see that this problem can be solved in $O(n^{3})$ time; the best known algorithm runs in time $O(n^{3}/\log^{2}n)$ [39]. The OMv-conjecture was introduced by Henzinger, Krinninger, Nanongkai, and Saranurak in [23] and states that the online matrix-vector multiplication problem cannot be solved in “truly subcubic” time $O(n^{3-\varepsilon})$ for any $\varepsilon>0$. Note that the hardness of online matrix-vector multiplication crucially depends on the requirement that the algorithm does not receive all vectors $\vec{v}^{\,1},\ldots,\vec{v}^{\,n}$ at once. In fact, without this requirement the output could be computed in time $O(n^{3-\varepsilon})$ by using any fast matrix multiplication algorithm. The OMv-conjecture has been used to prove conditional lower bounds for various dynamic problems and is a common barrier for improving these algorithms, see [23]. Contrary to classical complexity theoretic assumptions such as $P\neq NP$, this conjecture shares with other recently proposed algorithmic conjectures the less desirable fact that it can hardly be called “well-established”. However, at least we know that improving dynamic query evaluation algorithms for queries that are hard under the OMv-conjecture is a very difficult task and (even if not completely inconceivable) would lead to major breakthroughs in algorithms for e.g. matrix multiplication (see [23] for a discussion).

A variant of OMv that is useful as an intermediate step in our reductions is the following OuMv problem. Again, we are given an $n\times n$ matrix $M$ and are allowed to do some preprocessing. Afterwards, a sequence of pairs of vectors $\vec{u}^{\,t},\vec{v}^{\,t}$ arrives for each $t\in[n]$, and the task is to compute $({\vec{u}^{\,t}})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}$. As before, the algorithm has to output $({\vec{u}^{\,t}})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}$ before it gets $\vec{u}^{\,t+1},\vec{v}^{\,t+1}$ as input. It is known that OuMv is at least as difficult as OMv.

Theorem 5.1** (Theorem 2.4 in [23]).**

If there is some $\varepsilon>0$ such that OuMv can be solved in $n^{3-\varepsilon}$ time, then the OMv-conjecture fails.

5.2 The OV-conjecture

While OuMv and OMv turn out to be suitable for Boolean CQs and the enumeration of $k$-ary CQs, our lower bound for the counting complexity additionally relies on the orthogonal vectors conjecture (also known as the Boolean orthogonal detection problem, see [1, 38]). It is not known whether this conjecture implies or is implied by the OMv-conjecture. However, it is implied by the strong exponential time hypothesis (SETH) [38] and typically serves as a basis for SETH-based lower bounds of polynomial time algorithms.

The orthogonal vectors problem (OV) is the following static decision problem. Given two sets $U$ and $V$ of $n$ Boolean vectors of dimension $d$, decide whether there are $\vec{u}\in U$ and $\vec{v}\in V$ such that $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}\vec{v}=0$. This problem can clearly be solved in time $O(n^{2}d)$ by checking all pairs of vectors, and also slightly better algorithms are known [1]. The OV-conjecture states that this problem cannot be solved in truly subquadratic time if $d=\omega(\log n)$. The exact formulation of this conjecture in terms of the parameters varies in the literature, but all of them imply the following simple variant which is sufficient for our purposes.

Conjecture 5.2** (OV-conjecture).**

For every $\varepsilon>0$ there is no algorithm that solves OV for $d=\lceil\log^{2}n\rceil$ in time $O(n^{2-\varepsilon})$.

5.3 Proof Ideas

Before we establish the lower bounds in full generality, we illustrate the main ideas along the two representative examples $\varphi^{\prime}_{S\text{-}E\text{-}T}$ and $\varphi_{E\text{-}T}$ defined in (3) and (4). Note that if a conjunctive query is not q-hierarchical, then according to Definition 3.1 there are two distinct variables $x$ and $y$ that do not satisfy one of the two conditions. The Boolean query $\varphi^{\prime}_{S\text{-}E\text{-}T}$ is an example of a query where $x$ and $y$ do not satisfy the first condition (i.e., the condition of being hierarchical), and $\varphi_{E\text{-}T}$ is a query where the quantifier-free part is hierarchical, but where $x$ and $y$ do not satisfy the second condition on the free variables. Intuitively, every non-q-hierarchical query has a subquery whose shape is similar to either $\varphi^{\prime}_{S\text{-}E\text{-}T}$ or $\varphi_{E\text{-}T}$ (we will make this precise in Section 5.4).

Let us show how the OMv-conjecture can be applied to obtain a lower bound for answering the Boolean query $\varphi^{\prime}_{S\text{-}E\text{-}T}$ under updates.

Lemma 5.3**.**

Suppose there is an $\varepsilon>0$ and a dynamic algorithm with arbitrary preprocessing time and $t_{u}=n^{1-\varepsilon}$ update time that answers $\varphi^{\prime}_{S\text{-}E\text{-}T}$ in time $t_{a}=n^{2-\varepsilon}$ on databases whose active domain has size $n$, then OuMv can be solved in time $O(n^{3-\varepsilon})$.

Proof.

We show how a query evaluation algorithm for $\varphi^{\prime}_{S\text{-}E\text{-}T}$ can be used to solve OuMv. We get the $n\times n$ matrix $M$ and start the preprocessing phase of our evaluation algorithm for $\varphi^{\prime}_{S\text{-}E\text{-}T}$ with the empty database $D=(E^{D},S^{D},T^{D})$ where $E^{D}=S^{D}=T^{D}=\emptyset$. As this database has constant size, the preprocessing phase finishes in constant time. We apply at most $n^{2}$ update steps to ensure that $E^{D}=\{(i,j)\ :\ M_{i,j}=1\}$ is the relation corresponding to the adjacency matrix $M$. This preprocessing takes time $n^{2}t_{u}=O(n^{3-\varepsilon})$. If we get two vectors $\vec{u}^{\,t}$ and $\vec{v}^{\,t}$ in the dynamic phase of the OuMv problem, we update $S^{D}$ and $T^{D}$ so that their characteristic vectors agree with $\vec{u}^{\,t}$ and $\vec{v}^{\,t}$, respectively. Now we answer $\varphi^{\prime}_{S\text{-}E\text{-}T}$ on $D$ within time $t_{a}$ and output $1$ if $\varphi^{\prime}_{S\text{-}E\text{-}T}(D)=\texttt{yes}$ and [math] otherwise. Note that by construction this answer agrees with $({\vec{u}^{\,t}})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}$. The time of each step of the dynamic phase of OuMv is bounded by $2nt_{u}+t_{a}=O(n^{2-\varepsilon})$, and the overall running time for OMv accumulates to $O(n^{3-\varepsilon})$. ∎

Note that a lower bound on the answer time $t_{a}$ of a Boolean query directly implies the same lower bounds for the time $t_{c}$ needed to count the number of tuples and for the delay $t_{d}$ of an enumeration algorithm. Furthermore, this also holds true for any query that is obtained from the Boolean query by removing quantifiers.

Now we turn to our second example $\varphi_{E\text{-}T}$. Note that the Boolean version $\exists x\,\varphi_{E\text{-}T}(x)$ is q-hierarchical and hence can be answered in constant time under updates by Theorem 3.2. Thus, a lower bound on the delay $t_{d}$ does not follow from a corresponding lower bound on the Boolean version. Instead we obtain the lower bound by a direct reduction from OMv.

Lemma 5.4**.**

Suppose there is an $\varepsilon>0$ and a dynamic algorithm with arbitrary preprocessing time and $t_{u}=n^{1-\varepsilon}$ update time that enumerates $\varphi_{E\text{-}T}$ with $t_{d}=n^{1-\varepsilon}$ delay on databases whose active domain has size $n$, then OMv can be solved in time $O(n^{3-\varepsilon})$.

Proof.

We show that an enumeration algorithm with $n^{1-\varepsilon}$ update time and $n^{1-\varepsilon}$ delay helps to solve OMv in time $O(n^{3-\varepsilon})$. As in the proof of Lemma 5.3, we are given an $n\times n$ matrix $M$, start with the empty database $D=(E^{D},T^{D})$ where $E^{D}=T^{D}=\emptyset$ and perform at most $n^{2}$ update steps to ensure that $E^{D}=\{(i,j)\ :\ M_{i,j}=1\}$. In the dynamic phase of OMv, when a vector $\vec{v}^{\,t}$ arrives, we perform at most $n$ insertions or deletions to the relation $T^{D}$ such that $\vec{v}^{\,t}$ is the characteristic vector of $T^{D}$. Afterwards, we wait until the enumeration algorithm outputs the set $\varphi_{E\text{-}T}(D)$ and output the characteristic vector $\vec{u}^{\,t}$ of this set. By construction we have $\vec{u}^{\,t}=M\vec{v}^{\,t}$. If the enumeration algorithm has update time $t_{u}$ and delay $t_{d}$, then the overall running time of this step is bounded by $nt_{u}+nt_{d}$ which by the assumptions of our lemma is bounded by $O(n^{2-\varepsilon})$. Hence, the overall running time for solving the OMv is bounded by $O(n^{3-\varepsilon})$. ∎

Finally, we consider the counting problem for $\varphi_{E\text{-}T}$. Again, we cannot reduce from its tractable Boolean version. Moreover, we were not able to use OMv directly, in a similar way as in the proof of the previous lemma. Instead, we reduce from the orthogonal vectors problem.

Lemma 5.5**.**

Suppose there is an $\varepsilon>0$ and a dynamic algorithm with arbitrary preprocessing time and $t_{u}=n^{1-\varepsilon}$ update time that computes \big{|}\varphi_{E\text{-}T}(D)\big{|} in time $t_{c}=n^{1-\varepsilon}$ on databases whose active domain has size $n$, then the OV-conjecture fails.

Proof.

As in the previous proof we assume that there is a dynamic counting algorithm for $\varphi_{E\text{-}T}$ and start its preprocessing with the empty database over the schema $\{E,T\}$. Afterwards, we use at most $nd$ updates (where $d=\lceil\log^{2}(n)\rceil$) to encode all $d$-dimensional vectors $\vec{u}^{\,1}$, …, $\vec{u}^{\,n}$ in $U$ into the binary relation $E^{D}\subseteq[n]\times[d]$ such that $(i,j)\in E^{D}$ if and only if the $j$-th component of $\vec{u}^{\,i}$ is $1$. Then we make at most $d$ updates to $T^{D}$ to ensure that the first vector $\vec{v}^{\,1}\in V$ is the characteristic vector of $T^{D}$. Now we compute \big{|}\varphi_{E\text{-}T}(D)\big{|}. Note that \big{|}\varphi_{E\text{-}T}(D)\big{|}<n if and only if $(\vec{u}^{\,i})^{\,\mkern-1.5mu\mathsf{T}}\vec{v}^{\,1}=0$ for some $i\in[n]$. If this is the case, we output that there is a pair of orthogonal vectors. Otherwise, we know that $\vec{v}^{\,1}$ is not orthogonal to any $\vec{u}^{\,i}$ and apply the same procedure for $\vec{v}^{\,2}$, which requires again at most $d$ updates to $T^{D}$ and one call of the count routine. Repeating this procedure for all $n$ vectors in $V$ takes time O\big{(}ndt_{u}+n(dt_{u}+t_{c})\big{)}\leqslant O(n^{2-\varepsilon/2}) and solves OV in subquadratic time. ∎

5.4 Proofs of the Main Theorems

In this section we prove our lower bound Theorems 3.3, 3.4, and 3.5.

We will use standard notation concerning homomorphisms (cf., e.g. [2]). In particular, for CQs $\varphi$ and $\varphi^{\prime}$ we will write $h:\varphi\to\varphi^{\prime}$ to indicate that $h$ is a homomorphism from $\varphi$ to $\varphi^{\prime}$ (as defined in Section 3). A homomorphism $g:D\to\varphi$ from a database $D$ to a CQ $\varphi$ is a mapping from $\textrm{adom}(D)$ to $\textrm{vars}(\varphi)$ such that whenever $(a_{1},\ldots,a_{r})$ is a tuple in some relation $R^{D}$ of $D$, then $Rg(a_{1})\cdots g(a_{r})$ is an atom of $\varphi$. A homomorphism $h:\varphi\to D$ from a CQ $\varphi$ to a database $D$ is a mapping from $\textrm{vars}(\varphi)$ to $\textrm{adom}(D)$ such that whenever $Ru_{1}\cdots u_{r}$ is an atom of $\varphi$, then \big{(}h(u_{1}),\ldots,h(u_{r})\big{)}\in R^{D}. Obviously, for a $k$-ary CQ $\varphi(x_{1},\ldots,x_{k})$ and a database $D$ we have \varphi(D)=\{(h(x_{1}),\ldots,h(x_{k}))\ :\ h\text{ is a homomorphism from \varphi$to$D}\}.

We first generalise the proof idea of Lemma 5.3 to all Boolean conjunctive queries $\varphi$ that do not satisfy the requirement (i) of Definition 3.1. Thus assume that there are two variables $x,y\in\textrm{vars}(\varphi)$ and three atoms $\psi^{x},\psi^{x,y},\psi^{y}$ of $\varphi$ with $\textrm{vars}(\psi^{x})\cap\{x,y\}=\{x\}$, $\textrm{vars}(\psi^{x,y})\cap\{x,y\}=\{x,y\}$, and $\textrm{vars}(\psi^{y})\cap\{x,y\}=\{y\}$. Without loss of generality we assume that $\textrm{vars}(\varphi)=\{x,y,z_{1},\ldots,z_{\ell}\}$. For a given $n\times n$ matrix $M$ we fix a domain $\operatorname{dom}_{n}$ that consists of $2n+\ell$ elements $\{a_{i},b_{i}\ :\ i\in[n]\}\cup\{c_{s}\ :\ s\in[\ell]\}$. For $i,j\in[n]$ we let $\iota_{i,j}$ be the injective mapping from $\textrm{vars}(\varphi)$ to $\operatorname{dom}_{n}$ with $\iota_{i,j}(x)=a_{i}$, $\iota_{i,j}(y)=b_{j}$, and $\iota_{i,j}(z_{s})=c_{s}$ for all $s\in[\ell]$.

For the matrix $M$ and for $n$-dimensional vectors $\vec{u}$ and $\vec{v}$, we define a $\sigma$-db $D=D(\varphi,M,\vec{u},\vec{v})$ with $\textrm{adom}(D)\subseteq\operatorname{dom}_{n}$ as follows (recall our notational convention that $\vec{u}_{i}$ denotes the $i$-th entry of a vector $\vec{u}$). For every atom $\psi=Rw_{1}\cdots w_{r}$ in $\varphi$ we include in $R^{D}$ the tuple \big{(}\iota_{i,j}(w_{1}),\ldots,\iota_{i,j}(w_{r})\big{)}

• •

for all $i,j\in[n]$ such that $\vec{u}_{i}=1$,  if $\psi=\psi^{x}$,

• •

for all $i,j\in[n]$ such that $\vec{v}_{j}=1$,  if $\psi=\psi^{y}$,

• •

for all $i,j\in[n]$ such that $M_{i,j}=1$,  if $\psi=\psi^{x,y}$,  and

• •

for all $i,j\in[n]$,  if $\psi\notin\{\psi^{x},\psi^{x,y},\psi^{y}\}$.

Note that the relations in the atoms $\psi^{x}$, $\psi^{y}$, and $\psi^{x,y}$ are used to encode $\vec{u}$, $\vec{v}$, and $M$, respectively. Moreover, since $\psi^{x}$ ($\psi^{y}$) does not contain the variable $y$ ($x$), two databases $D=D(\varphi,M,\vec{u},\vec{v})$ and D^{\prime}=D(\varphi,M,\mbox{\vec{u},{}^{\prime}},\mbox{\vec{v},{}^{\prime}}) differ only in at most $2n$ tuples. Therefore, $D^{\prime}$ can be obtained from $D$ by $2n$ update steps. It follows from the definitions that $\iota_{i,j}$ is a homomorphism from $\varphi$ to $D$ if and only if $\vec{u}_{i}=1$, $\vec{v}_{j}=1$, and $M_{i,j}=1$. Therefore, $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}=1$ if and only if there are $i,j\in[n]$ such that $\iota_{i,j}$ is a homomorphism from $\varphi$ to $D$.

We let $g_{\varphi,n}$ be the (surjective) mapping from $\operatorname{dom}_{n}$ to $\textrm{vars}(\varphi)$ defined by $g_{\varphi,n}(c_{s}):=z_{s}$, $g_{\varphi,n}(a_{i}):=x$, and $g_{\varphi,n}(b_{j}):=y$ for all $i,j\in[n]$ and $s\in[\ell]$. Clearly, $g_{\varphi,n}$ is a homomorphism from $D$ to $\varphi$. Obviously, the following is true for every mapping $h$ from $\textrm{vars}(\varphi)$ to $\textrm{adom}(D)$ and for all $w\in\textrm{vars}(\varphi)$: if $h(w)=c_{s}$ for some $s\in[\ell]$, then $(g_{\varphi,n}\circ h)(w)=z_{s}$; if $h(w)=a_{i}$ for some $i\in[n]$, then $(g_{\varphi,n}\circ h)(w)=x$; if $h(w)=b_{j}$ for some $j\in[n]$, then $(g_{\varphi,n}\circ h)(w)=y$.

We define the partition \mathcal{P}_{\varphi,n}=\big{\{}\{c_{1}\},\ldots,\{c_{\ell}\},\{a_{i}\ :\ i\in[n]\},\{b_{j}\ :\ j\in[n]\}\big{\}} of $\operatorname{dom}_{n}$ and say that a mapping $h$ from $\textrm{vars}(\varphi)$ to $\textrm{adom}(D)$ respects $\mathcal{P}_{\varphi,n}$, if for each set from the partition there is exactly one element in the image of $h$.

Claim 5.6**.**

$\vec{u}^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}=1$  $\iff$  There exists a homomorphism $h\colon\varphi\to D$ that respects $\mathcal{P}_{\varphi,n}$.

Proof.

For one direction assume that $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}=1$. Then there are $i,j\in[n]$ such that $\iota_{i,j}$ is a homomorphism from $\varphi$ to $D$ that respects $\mathcal{P}_{\varphi,n}$. For the other direction assume that $h\colon\varphi\to D$ is a homomorphism that respects $\mathcal{P}_{\varphi,n}$. It follows that $(g_{\varphi,n}\circ h)$ is a bijective homomorphism from $\varphi$ to $\varphi$. Therefore, it can easily be verified that $h\circ(g_{\varphi,n}\circ h)^{-1}$ is a homomorphism from $\varphi$ to $D$ which equals $\iota_{i,j}$ for some $i,j\in[n]$. This implies that $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}=1$. ∎

Claim 5.7**.**

If $\varphi$ is a core, then every homomorphism $h\colon\varphi\to D$ respects $\mathcal{P}_{\varphi,n}$.

Proof.

Assume for contradiction that $h\colon\varphi\to D$ is a homomorphism that does not respect $\mathcal{P}_{\varphi,n}$. Then $(g_{\varphi,n}\circ h)$ is a homomorphism from $\varphi$ into a proper subquery of $\varphi$, contradicting that $\varphi$ is a core. ∎

Proof of Theorem 3.4.

Assume for contradiction that the query answering problem for $\varphi$ and hence for its non-q-hierarchical core $\varphi_{\text{core}}$ can be solved with update time $t_{u}=O(n^{1-\varepsilon})$ and answer time $t_{a}=O(n^{2-\varepsilon})$. We can use this algorithm to solve OuMv in time $O(n^{3-\varepsilon})$ as follows.

In the preprocessing phase, we are given the $n\times n$ matrix $M$ and let $\vec{u}^{\,0}$, $\vec{v}^{\,0}$ be the all-zero vectors of dimension $n$. We start the preprocessing phase of our evaluation algorithm for $\varphi_{\text{core}}$ with the empty database. As this database has constant size, the preprocessing phase finishes in constant time. Afterwards, we use at most $n^{2}$ insert operations to build the database $D(\varphi_{\text{core}},M,\vec{u}^{\,0},\vec{v}^{\,0})$. All this is done within time $O(n^{2}t_{u})=O(n^{3-\epsilon})$.

When a pair of vectors $\vec{u}^{\,t}$, $\vec{v}^{\,t}$ (for $t\in[n]$) arrives, we change the current database $D(\varphi_{\text{core}},M,\vec{u}^{\,t-1},\vec{v}^{\,t-1})$ into $D(\varphi_{\text{core}},M,\vec{u}^{\,t},\vec{v}^{\,t})$ by using at most $2n$ update steps. By the Claims 5.6 and 5.7 we know that $(\vec{u}^{\,t})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}=1$ if, and only if, there is a homomorphism from $\varphi_{\text{core}}$ to $D:=D(\varphi_{\text{core}},M,\vec{u}^{\,t},\vec{v}^{\,t})$. Hence, after answering the Boolean query $\varphi_{\text{core}}$ on $D$ in time $t_{a}=|\textrm{adom}(D)|^{2-\varepsilon}=O(n^{2-\varepsilon})$ we can output the value of $(\vec{u}^{\,t})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}$. The time of each step of the dynamic phase of OuMv is bounded by $2nt_{u}+t_{a}=O(n^{2-\varepsilon})$. Thus, the overall running time sums up to $O(n^{3-\varepsilon})$, contradicting the OMv-conjecture by Theorem 5.1. ∎

The same reduction from OuMv to the query evaluation problem for conjunctive queries is also useful for the lower bound on the counting problem, provided that the query is not hierarchical. If the query is hierarchical, but the quantifiers are not in the correct form (such that the query is not q-hierarchical), then OuMv does not provide us with the desired lower bound proof and we have to stick to the OV-conjecture instead. Another crucial difference between the Boolean and the non-Boolean case is the following: the dynamic counting problem for the Boolean query \varphi=\exists x\,\exists y\,\big{(}Exx\wedge Exy\wedge Eyy\big{)} is easy (because its core is $\exists x\,Exx$), whereas the dynamic counting problem for its non-Boolean version \varphi(x,y)=\,\big{(}Exx\wedge Exy\wedge Eyy\big{)} is hard (because the query is a non-q-hierarchical core). To take care of this phenomenon we utilise the following lemma.

Lemma 5.8**.**

Let $\varphi(x_{1},\ldots,x_{k})$ be a conjunctive query and $X_{x_{1}},\ldots,X_{x_{k}}$ be pairwise disjoint subsets of dom. Suppose that for every database $D$ under consideration there is a homomorphism $g\colon D\to\varphi$ such that $g(X_{x_{i}})=\{x_{i}\}$ for all $i\in[k]$. If \big{|}\varphi(D)\big{|} can be computed with $t_{p}$ preprocessing time, $t_{u}$ update time, and $t_{c}$ counting time, then the number \big{|}\varphi(D)\cap\bigl{(}X_{x_{1}}\times\cdots\times X_{x_{k}}\bigr{)}\big{|} can be computed with $2^{O(k)}(t_{u}+t_{c})$ update time and $O(1)$ counting time after $2^{\operatorname{\textit{poly}}(\varphi)}+2^{O(k)}(t_{p}+t_{c})$ preprocessing.

In the static setting, a similar result was shown by Chen and Mengel (see Section 7.1 in [11]) and it turns out that our dynamic version can be proven using the same techniques. We remark that the lemma holds even if we drop the additional requirement on the existence of the homomorphism $g$. However, as the databases we construct in our lower bound proof have the desired structure, this additional requirement helps to simplify the proof.

Proof of Lemma 5.8.

We first reduce the given task to counting tuples up to permutations, that is, computing the size of the set ${\mathcal{R}}(D):=$

[TABLE]

Let $\Pi$ be the set of all permutations ${\pi}\colon[k]\to[k]$ such that the mapping \big{(}x_{i}\mapsto x_{{\pi}(i)}\big{)}_{i\in[k]} extends to an endomorphism on $\varphi$ (i.e., a homomorphism from $\varphi$ to $\varphi$). We now show that

[TABLE]

First note that if (a_{1},\ldots,a_{k})\in\varphi(D)\cap\bigl{(}X_{x_{1}}\times\cdots\times X_{x_{k}}\bigr{)}, then $(a_{{\pi}(1)},\ldots,a_{{\pi}(k)})\in{\mathcal{R}}(D)$ for all ${\pi}\in\Pi$. Thus, the $\leqslant$-direction of (5) follows because all $X_{x_{i}}$ are pairwise disjoint. For the other direction, consider an arbitrary tuple $(a_{1},\ldots,a_{k})\in{\mathcal{R}}(D)$. In particular, there is a permutation ${\pi}:[k]\to[k]$ such that $a_{i}\in X_{x_{{\pi}(i)}}$ for all $i\in[k]$. Furthermore, since $(a_{1},\ldots,a_{k})\in\varphi(D)$, there is a homomorphism $h\colon\varphi\to D$ with $h(x_{i})=a_{i}$ for all $i\in[k]$. When combining $h$ with the homomorphism $g\colon D\to\varphi$ given by the lemma’s assumption, we obtain the endomorphism $f:=(g\circ h)$ on $\varphi$ that satisfies $f(x_{i})=x_{\pi(i)}$ for all $i\in[k]$. Thus, $\pi\in\Pi$. To conclude the proof of the $\geqslant$-direction of (5), it remains to show that $(a_{\pi^{-1}(1)},\ldots,a_{\pi^{-1}(k)})\in\varphi(D)$, i.e., it remains to show that there is a homomorphism $h^{\prime}:\varphi\to D$ with $h^{\prime}(x_{i})=a_{\pi^{-1}(i)}$ for all $i\in[k]$. Since $\pi$ is a permutation, $\pi^{-1}=\pi^{m}$ for some $m\geqslant 1$. Thus, iterating $f$ for $m$ times yields the endomorphism $f^{m}$ on $\varphi$ with $f^{m}(x_{i})=x_{\pi^{m}(i)}=x_{\pi^{-1}(i)}$ for all $i\in[k]$. Therefore, choosing $h^{\prime}:=(h\circ f^{m})$ completes the proof of (5).

As the set $\Pi$ depends only on the query and can be computed in time $2^{\operatorname{\textit{poly}}(\varphi)}$ in the preprocessing phase, it suffices to store and update information on the number $|{\mathcal{R}}(D)|$, whenever the database $D$ is updated. To do this efficiently, we store for every $I\subseteq[k]$ and every $j\in\{0,\ldots,k\}$ the sizes of the auxiliary sets

[TABLE]

Note that

[TABLE]

Hence, we can use the cardinalities of the sets ${\mathcal{R}}_{I,j}$ (with index $j:=k$) to compute $|{\mathcal{R}}(D)|$ by the following application of the inclusion-exclusion principle

[TABLE]

In order to compute the numbers $|{\mathcal{R}}_{I,j}|$ efficiently, we consider for every $I\subseteq[k]$ and every $\ell\in[k]$ the database $D_{I,\ell}$ which is obtained from $D$ by replacing every element from $\bigcup_{i\in I}X_{x_{i}}$ by $\ell$ copies of itself. Precisely, we consider fresh elements $\langle a\rangle^{1},\ldots,\langle a\rangle^{k}$ for every $a$ from the domain and define for every $r$-ary $R\in\sigma$

[TABLE]

We maintain these $k2^{k}$ auxiliary databases $D_{I,\ell}$ in parallel and call the count routines to determine the new result sizes \big{|}\varphi(D_{I,\ell})\big{|}. All this can be done in time $(t_{u}+t_{c})2^{O(k)}$. Afterwards, we compute the numbers \big{|}{\mathcal{R}}_{I,j}\big{|} given the cardinalities \big{|}\varphi(D_{I,\ell})\big{|} as follows. For every $\ell\in[k]$ we have

[TABLE]

Hence, in order to compute the values of \big{|}{\mathcal{R}}_{I,j}\big{|} it suffices to solve $2^{k}$ systems of linear equations of the form $V\vec{x}=\vec{b}$, where $V$ is a $k\times(k+1)$ Vandermonde matrix with $V_{\ell,j}:=\ell^{j}$ (for all $\ell\in[k]$ and $j\in\{0,\ldots,k\}$). Therefore, all these values are uniquely determined and can be computed in time $2^{O(k)}$. Finally, we can use (8) to compute and store the desired value $|{\mathcal{R}}(D)|$. Note that the entire time used for performing an update is $O((t_{u}+t_{c})2^{O(k)})$, as claimed. ∎

Proof of Theorem 3.5.

Let $\varphi$ be the non-q-hierarchical homomorphic core of the given conjunctive query. For contradiction, assume that the counting problem for $\varphi$ can be solved with update time $t_{u}=O(n^{1-\epsilon})$ and counting time $t_{c}=O(n^{1-\epsilon})$.

We first handle the case where $\varphi$ does not satisfy the first condition (i) of Definition 3.1. Hence, as in the Boolean case, there are variables $x,y$ and atoms $\psi^{x}$, $\psi^{x,y}$, $\psi^{y}$ with $\textrm{vars}(\psi^{x})\cap\{x,y\}=\{x\}$, $\textrm{vars}(\psi^{x,y})\cap\{x,y\}=\{x,y\}$, and $\textrm{vars}(\psi^{y})\cap\{x,y\}=\{y\}$. Again we reduce from OuMv, assume that $\textrm{vars}(\varphi)=\{x,y,z_{1},\ldots,z_{\ell}\}$, and let $D=D(\varphi,M,\vec{u},\vec{v})$ be the $\sigma$-db defined above for a given $n\times n$ matrix $M$ and $n$-dimensional vectors $\vec{u}$ and $\vec{v}$.

Note that the lower bound for counting the query result does not follow from the lower bound for Boolean queries (Theorem 3.4), because it might be the case that the core of the Boolean version $\exists x\,\exists y\,\exists z_{1}\cdots\,\exists z_{\ell}\,\varphi$ of $\varphi$ actually is q-hierarchical (consider \big{(}Exx\wedge Exy\wedge Eyy\big{)} for example). To take care of this, we apply Lemma 5.8 and let $X_{z_{1}}:=\{c_{1}\}$, …, $X_{z_{\ell}}:=\{c_{\ell}\}$, $X_{x}:=\{a_{i}\ :\ i\in[n]\}$, $X_{y}:=\{b_{i}\ :\ i\in[n]\}$ be the corresponding sets that partition the domain of $D(\varphi,M,\vec{u},\vec{v})$. Let us say that a homomorphism $h\colon\varphi\to D$ is good if $h(w)\in X_{w}$ for all $w\in\textrm{free}(\varphi)$. As in the proof of Claim 5.7, we have that every good homomorphism respects $\mathcal{P}_{\varphi,n}$ since otherwise $(g_{\varphi,n}\circ h)$ would be a homomorphism from $\varphi$ into a proper subquery of $\varphi$, contradicting that $\varphi$ is a core. By Lemma 5.8 we can count the number of result tuples produced by good homomorphisms $h:\varphi\to D$, and this can be done with counting time $O(1)$ and update time $O(n^{1-\epsilon})$ (here, the factor $2^{O(k)}$ mentioned in the lemma is subsumed by the $O$-notation, since the query $\varphi$ is fixed). By Claim 5.6, the number of result tuples produced by good homomorphisms $h:\varphi\to D$ is $>0$ if, and only if, $\vec{u}^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}=1$. Thus, we can proceed in a similar way as in the proof of Theorem 3.4 and solve OuMv within time $O(n^{3-\epsilon})$, contradicting the OMv-conjecture by Theorem 5.1.

For the second case suppose that $\varphi$ does not satisfy condition (ii) of Definition 3.1. Thus assume that there are two variables $x\in\textrm{free}(\varphi),y\in\textrm{vars}(\varphi)\setminus\textrm{free}(\varphi)$ and two atoms $\psi^{x,y},\psi^{y}$ of $\varphi$ with $\textrm{vars}(\psi^{x,y})\cap\{x,y\}=\{x,y\}$ and $\textrm{vars}(\psi^{y})\cap\{x,y\}=\{y\}$. Without loss of generality we assume that $\varphi=\varphi(x,z_{1},\dots,z_{{\ell^{\prime}}})$ and $\textrm{vars}(\varphi)=\{x,y,z_{1},\ldots,z_{\ell}\}$ for some ${\ell^{\prime}}\leqslant\ell$. We reduce from OV, generalising our example in Lemma 5.5. Suppose that U=\big{\{}\vec{u}^{\,1},\ldots,\vec{u}^{\,n}\big{\}} and V=\big{\{}\vec{v}^{\,1},\ldots,\vec{v}^{\,n}\big{\}} are two sets of $n$ Boolean vectors, each of length $d=\lceil\log^{2}n\rceil$. We fix a domain $\operatorname{dom}_{n}$ that consists of $n+d+\ell$ elements $\{a_{i}\ :\ i\in[n]\}\cup\{b_{j}\ :\ j\in[d]\}\cup\{c_{s}\ :\ s\in\ell\}$, and we let $X_{x}:=\{a_{i}\ :\ i\in[n]\}$, $X_{y}:=\{b_{j}\ :\ j\in[d]\}$, and $X_{z_{s}}:=\{c_{s}\}$ for all $s\in[\ell]$. As before, for $(i,j)\in[n]\times[d]$ we let $\iota_{i,j}$ be the injective mapping from $\textrm{vars}(\varphi)$ to $\operatorname{dom}_{n}$ with $\iota_{i,j}(x)=a_{i}$, $\iota_{i,j}(y)=b_{j}$, and $\iota_{i,j}(z_{s})=c_{s}$ for all $s\in[\ell]$.

For each vector $\vec{v}\in V$ we define a $\sigma$-db $D=D(\varphi,U,\vec{v})$ with $\textrm{adom}(D)\subseteq\operatorname{dom}_{n}$ as follows. For every atom $\psi=Rw_{1}\cdots w_{r}$ in $\varphi$ we include in $R^{D}$ the tuple \big{(}\iota_{i,j}(w_{1}),\ldots,\iota_{i,j}(w_{r})\big{)}

1. $\bullet$

for all $(i,j)\in[n]\times[d]$ such that the $j$-th component of $\vec{u}^{\,i}$ is 1,  if $\psi=\psi^{x,y}$, 2. $\bullet$

for all $(i,j)\in[n]\times[d]$ such that the $j$-th component of $\vec{v}$ is 1,  if $\psi=\psi^{y}$,  and 3. $\bullet$

for all $(i,j)\in[n]\times[d]$,  if $\psi\notin\{\psi^{x,y},\psi^{y}\}$.

From this definition it follows that

[TABLE]

and hence the size of this set equals the number of vectors from $U$ that are non-orthogonal to $\vec{v}$. By Lemma 5.8 we can count this number using $O(1)$ counting time and $O(n^{1-\epsilon})$ update time.

In order to solve OV, we first apply the preprocessing phase for the empty database and then perform $O(nd)$ update steps to build $D(\varphi,U,\vec{v}^{\,1})$. Afterwards, we compute the number of vectors in $U$ that are non-orthogonal to $\vec{v}^{\,1}$. If this number is $<n$, we know that there is an orthogonal pair of vectors. Otherwise, we apply at most $d$ update steps to the relation of the atom $\psi^{y}$ in order to obtain the database $D(\varphi,U,\vec{v}^{\,2})$ and check again if $\vec{v}^{\,2}$ is orthogonal to some vector in $U$. We repeat this procedure for all vectors in $V$ and this allows us to solve OV in time $O(ndn^{1-\epsilon})=O(n^{2-\varepsilon/2})$, contradicting the OV-conjecture. ∎

We now prove the hardness result for enumerating the results of self-join free conjunctive queries.

Proof of Theorem 3.3.

If $\varphi$ does not satisfy condition (i) of Definition 3.1, then also the query’s Boolean version $\exists x_{1}\cdots\exists x_{k}\,\varphi$ (where $\textrm{free}(\varphi)=\{x_{1},\ldots,x_{k}\}$) is non-q-hierarchical; and this Boolean version is its own core, since $\varphi$ is self-join free. The lower bound now follows immediately from Theorem 3.4, because if the results of $\varphi$ can be enumerated with preprocessing time $t_{p}$, update time $t_{u}$, and delay $t_{d}$, then we can answer $\exists x_{1}\cdots\exists x_{k}\,\varphi$ with preprocessing time $t_{p}$, update time $t_{u}$, and answer time $t_{a}=t_{d}$: to answer the Boolean query, just start enumerating the answers of $\varphi$ and answer yes or no depending on whether the first output is a tuple or the EOE message.

We can therefore assume that $\varphi$ satisfies condition (i), but not (ii) of Definition 3.1. Hence there are a free variable $x$, a quantified variable $y$, and two atoms $\psi^{x,y}$, $\psi^{y}$ such that $\textrm{vars}(\psi^{x,y})\cap\{x,y\}=\{x,y\}$ and $\textrm{vars}(\psi^{y})\cap\{x,y\}=\{y\}$. Without loss of generality we let $\textrm{vars}(\varphi)=\{x,y,z_{1},\ldots,z_{\ell}\}$ and $\textrm{free}(\varphi)=\{x,z_{1},\ldots,z_{\ell^{\prime}}\}$ and consider the query $\varphi(x,z_{1},\ldots,z_{\ell^{\prime}})$.

For contradiction, assume that there is a dynamic algorithm that enumerates $\varphi$ with $O(n^{1-\varepsilon})$ delay and $O(n^{1-\varepsilon})$ update time. We want to use this algorithm to solve OMv in time $O(n^{3-\varepsilon})$. For this we encode an $n\times n$ matrix $M$ and an $n$-dimensional vector $\vec{v}$ into a database, in a similar way as we have done for OuMv: We define the $\sigma$-db $D=D(\varphi,M,\vec{v})$ over the domain $\operatorname{dom}_{n}=\{a_{i},b_{i}\ :\ i\in[n]\}\cup\{c_{s}\ :\ s\in[\ell]\}$ consisting of $2n+\ell$ elements. For $i,j\in[n]$ we let $\iota_{i,j}:\textrm{vars}(\varphi)\to\operatorname{dom}_{n}$ be the injective mapping that sets $\iota_{i,j}(x)=a_{i}$, $\iota_{i,j}(y)=b_{j}$, and $\iota_{i,j}(z_{s})=c_{s}$ for all $s\in[\ell]$. For every atom $\psi=Rw_{1}\cdots w_{r}$ in $\varphi$ we include in $R^{D}$ the tuple $(\iota_{i,j}(w_{1}),\ldots,\iota_{i,j}(w_{r}))$

• •

for all $i,j\in[n]$ such that $\vec{v}_{j}=1$, if $\psi=\psi^{y}$,

• •

for all $i,j\in[n]$ such that $M_{i,j}=1$, if $\psi=\psi^{x,y}$, and

• •

for all $i,j\in[n]$, if $\psi\notin\{\psi^{x,y},\psi^{y}\}$.

Note that $\iota_{i,j}$ is a homomorphism from $\varphi$ to $D$ if and only if $M_{i,j}=1$ and $\vec{v}_{j}=1$. Recall that \varphi(D)=\big{\{}\big{(}h(x),h(z_{1}),\ldots,h(z_{\ell^{\prime}})\big{)}\ :\ \text{h$is a homomorphism from$\varphi$to$D}\big{\}}. Because $\varphi$ is self-join free, every homomorphism from $\varphi$ to $D$ agrees with some $\iota_{i,j}$. Therefore, $\varphi(D)$ is the set of all tuples $(a_{i},c_{1},\ldots,c_{\ell^{\prime}})$ for which there exists an index $j$ such that $\iota_{i,j}$ is a homomorphism from $\varphi$ to $D$. Hence, $(a_{i},c_{1},\ldots,c_{\ell^{\prime}})\in\varphi(D)$ if and only if $(M\vec{v})_{i}=1$. As $|\varphi(D)|\leqslant n$, we can enumerate the entire query result $\varphi(D)$ in time $O(nt_{d})=O(n^{2-\varepsilon})$, and from this query result we can easily compute the vector $M\vec{v}$. All this is done within time $O(n^{2-\varepsilon})$.

When a vector $\vec{v}^{\,t}$ arrives in the dynamic phase of OMv, we update $D(\varphi,M,\vec{v}^{\,t-1})$ to $D(\varphi,M,\vec{v}^{\,t})$ using at most $n$ insertions or deletions of tuples in the relation of the atom $\psi^{y}$. As this can be done in time $nt_{u}=O(n^{2-\varepsilon})$, we can compute $M\vec{v}^{\,t}$ in overall time $O(n^{2-\varepsilon})$ and hence solve OMv in time $O(n^{3-\varepsilon})$. ∎

6 Upper Bound

This section is devoted to the proof of Theorem 3.2. First of all, note that if we can prove the theorem for connected q-hierarchical queries, then the result easily follows also for non-connected q-hierarchical queries: If $\varphi_{1}(\overline{x}_{1}),\ldots,\varphi_{j}(\overline{x}_{j})$ are the connected components of a q-hierarchical query $\varphi(\overline{x}_{1},\ldots,\overline{x}_{j})$ for (possibly empty) tuples $\overline{x}_{1},\ldots,\overline{x}_{j}$ of variables, then during the preprocessing phase we build the data structures for all the $\varphi_{i}$, and when the database is updated, we update all these data structures. Note that $\varphi(D)=\varphi_{1}(D)\times\cdots\times\varphi_{j}(D)$. Thus, the count routine for $\varphi$ can perform a count for each $\varphi_{i}$ and output the number $|\varphi(D)|=\prod_{i=1}^{j}|\varphi_{i}(D)|$. Accordingly, the enumerate routine can easily be obtained by a nested loop through the enumerate routines for all the $\varphi_{i}$’s

For the remainder of this section we assume w.l.o.g. that $\varphi(x_{1},\ldots,x_{k})$ is a connected q-hierarchical conjunctive query, $\textrm{vars}(\varphi)=\{x_{1},\ldots,x_{m}\}$ with $0\leqslant k\leqslant m$, and $\varphi$ is of the form

[TABLE]

From Lemma 4.2 we know that $\varphi$ has a q-tree. We use the lemma’s algorithm to construct in time $\operatorname{\textit{poly}}(\varphi)$ a q-tree $T_{\varphi}$ of $\varphi$. For the remainder of this section, we simply write $T$ to denote $T_{\varphi}$. Recall that the vertex set $V$ of $T$ is the set of variables in $\varphi$, i.e., $V=\{x_{1},\ldots,x_{m}\}$. We will write $v_{\textsl{root}}$ to denote the root node of $T$.

6.1 Further notation

The following notation will be convenient for describing and analysing our algorithm. For a node $v$ of $T$, we write $\textrm{path}[v]$ to denote the set of all nodes of $T$ that occur in the path from $v_{\textsl{root}}$ to $v$ in $T$ (including $v$), and we let $\textrm{path}[v):=\textrm{path}[v]\setminus\{v\}$. $N(v):=\{u\ :\ (v,u)\in E(T)\}$ is the set of children of $v$ in $T$. A node $v$ of $T$ represents an atomic query $\psi$ iff $\textrm{path}[v]=\textrm{vars}(\psi)$, i.e., the variables in $\textrm{path}[v]$ are exactly the variables in $\psi$. For each $v\in V$, we write $\textrm{rep}(v)$ for the set of all atoms $\psi_{j}$ of $\varphi$ that are represented by $v$. Note that $\textrm{rep}(v)\subseteq\textrm{atoms}(v)$.

An assignment is a partial mapping from var to dom. As usual, we write $\textrm{dom}(\alpha)$ for the domain of $\alpha$. For a set $S\subseteq\textbf{var}$, by ${\alpha}_{|S}$ we denote the restriction of $\alpha$ to $\textrm{dom}(\alpha)\cap S$. For $x\in\textbf{var}$ and $a\in\textbf{dom}$ we write ${\alpha}\tfrac{a}{x}$ for the assignment $\alpha^{\prime}$ with domain $\textrm{dom}(\alpha)\cup\{x\}$, where $\alpha^{\prime}(x)=a$ and $\alpha^{\prime}(y)=\alpha(y)$ for all $y\notin\textrm{dom}(\alpha)\setminus\{x\}$. An assignment $\beta$ is called an expansion of $\alpha$ (for short: $\beta\supseteq\alpha$) if $\textrm{dom}(\beta)\supseteq\textrm{dom}(\alpha)$ and ${\beta}_{|\textrm{dom}(\alpha)}=\alpha$. The empty assignment $\emptyset$ is the assignment with empty domain. For pairwise distinct variables $v_{1},\ldots,v_{d}$ and constants $a_{1},\ldots,a_{d}\in\textbf{dom}$ we write $\frac{a_{1},\ldots,a_{d}}{v_{1},\ldots,v_{d}}$ to denote the assignment $\alpha$ with $\textrm{dom}(\alpha)=\{v_{1},\ldots,v_{d}\}$ and $\alpha(v_{i})=a_{i}$ for all $i\in[d]$.

6.2 The data structure

We now describe the data structure $\mathtt{D}$ that will be built by the preprocess routine and maintained while executing the update routine. Our data structure for a given database $D$ represents so-called items. Each item is determined by a variable $v\in V$, an assignment $\alpha:\textrm{path}[v)\to\textbf{dom}$, and a constant $a\in\textbf{dom}$; we will write $\texttt{[}v,\alpha,a\texttt{]}$ to denote this item. For an item $i=\texttt{[}v,\alpha,a\texttt{]}$ we write $v^{i}$, $\alpha^{i}$, and $a^{i}$ to denote the item’s variable $v$, assignment $\alpha$, and constant $a$. Moreover, for every item $i=\texttt{[}v,\alpha,a\texttt{]}$ and every child $u$ of $v$ in $T$ there is a doubly linked list $\mathcal{L}_{u}^{i}$ (the $u$-list of $i$) which contains items of the form $\texttt{[}u,{\alpha}\tfrac{a}{v},b\texttt{]}$ and we have one pointer $\textit{child}^{i}_{u}$ that points from $i$ to the first element in $\mathcal{L}_{u}^{i}$. It is important to note that not every item of the form $\texttt{[}u,{\alpha}\tfrac{a}{v},b\texttt{]}$ that is present in our data structure will be contained in the corresponding list $\mathcal{L}_{u}^{i}$, but for those items that are contained we store two pointers $\textit{next-listitem}^{i}$ and $\textit{prev-listitem}^{i}$ to navigate in $\mathcal{L}_{u}^{i}$. The parent item of an item of the form $\texttt{[}u,{\alpha}\tfrac{a}{v},b\texttt{]}$, where $u$ is a child of $v$ in $T$, is defined to be the item $\texttt{[}v,\alpha,a\texttt{]}$.

Let us now state which items are actually contained in our data structure.

An item $\texttt{[}v,\alpha,a\texttt{]}$ is present in our data structure if and only if there is an atom $\psi\in\textrm{atoms}(v)$ such that there is an expansion $\beta\supseteq{\alpha}\tfrac{a}{v}$ with $\textrm{dom}(\beta)=\textrm{vars}(\psi)$ and $(D,\beta)\models\psi$. It follows that every fact $R(a_{1},\ldots,a_{r})$ in the database gives rise to a constant number of items and that the overall number of items in our data structure is therefore linear in the size of the database. The definition also ensures that whenever an item is present in our data structure, then so is its parent item.

Let us now specify which of the present items are actually contained in the corresponding list $\mathcal{L}_{u}^{i}$. We will need the following definition.

An item $\texttt{[}v,\alpha,a\texttt{]}$ is fit if and only if there is an expansion $\beta\supseteq{\alpha}\tfrac{a}{v}$ such that $(D,\beta)\models\bigwedge_{\psi\in\textrm{atoms}(v)}\psi$. The doubly linked list $\mathcal{L}_{u}^{i}$ contains precisely those items that are fit. Being fit is a necessary requirement for participating in the query result and this is why we exclude unfit items from the lists. Note that whenever a tuple is inserted into or deleted from the database, this affects the “fit”-status of only a constant number of items. Furthermore, provided we have constant-time access to the items, we can update their status and include or exclude them from the corresponding lists in constant time. In addition to the items, our data structure also has a designated start pointer that points to (the first element of) a doubly linked list start-list $\mathcal{L}_{\text{start}}$, which consists of all fit items of the form $\texttt{[}v_{\textsl{root}},\emptyset,b\texttt{]}$.

In order to count the number of output tuples, we store for every item $i$ its weight $C^{i}$. The weight is used to measure the number of tuples in the query result that extend the item’s partial assignment and is defined as follows. For an item $i=\texttt{[}v,\alpha,a\texttt{]}$ we let

[TABLE]

By definition we have that $i$ is fit if and only if $C^{i}>0$, and we will use the weights to quickly determine whether an item becomes fit after an insertion of a tuple (or unfit after a deletion). In order to efficiently update these numbers, we store for every list $\mathcal{L}_{u}^{i}$ in our data structure as well for the start-list the sum of the weights of their elements

[TABLE]

The weights will also be used to determine the size of the query result. For example, suppose that $\varphi$ is quantifier-free. Then it follows from the definition of that $\varphi(D)$ is the disjoint union of the sets $\mathcal{E}^{i}$ for all $i\in\mathcal{L}_{\text{start}}$ (where every tuple in $\varphi(D)$ is viewed as an assignment $\beta:\textrm{free}(\varphi)\to\textbf{dom}$). Therefore, $|\varphi(D)|=C_{\text{start}}$ and we can immediately answer a count request by reporting the stored value $C_{\text{start}}$. Now suppose that $\varphi$ is Boolean. Then we respond to an answer request by reporting whether $C_{\text{start}}>0$. The remaining case, when $\varphi$ contains quantified and free variables, is similar and will be handled in Section 6.5. To illustrate the overall shape of our data structure, let us consider the following example.

Example 6.1**.**

Consider the query  $\varphi(x,y,z,y^{\prime},z^{\prime}):=$

[TABLE]

and the database ${D_{0}}$ with $E^{D_{0}}=\{(a,e),\,\allowbreak(a,f),\,\allowbreak(b,d),\,\allowbreak(b,g),\,\allowbreak(b,h)\}$, $S^{D_{0}}=\{(a,e,a),\,\allowbreak(a,e,b),\,\allowbreak(a,f,c),\,\allowbreak(b,g,b),\,\allowbreak(b,p,a)\}$, and $R^{D_{0}}=S^{D_{0}}\,\cup\,\{(a,e,c),\,\allowbreak(b,g,a),\,\allowbreak(b,g,c),\,\allowbreak(b,p,b),\,\allowbreak(b,p,c)\}$. Figure 2 depicts a q-tree $T$ for $\varphi$. The data structure $\mathtt{D}_{0}$ that represents the database ${D_{0}}$ is shown in Figure 3(a). Every box represents an item $i=\texttt{[}v,\alpha,a\texttt{]}$ and contains the item’s constant $a$. The number below each box is the weight $C^{i}$ of the item. The arrows labelled with $u$ represent the pointer from an item $i$ to the first element of its $u$-list $\mathcal{L}_{u}^{i}$. Horizontal lines between the items indicate pointers in the doubly linked lists $\mathcal{L}_{u}^{i}$ and $\mathcal{L}_{\text{start}}$. There are seven further unfit items (omitted in the figure) that do not have connections to any other items: $\texttt{[}y,\frac{b}{x},d\texttt{]}$, $\texttt{[}y,\frac{b}{x},h\texttt{]}$, $\texttt{[}z,\frac{a,e}{x,y},c\texttt{]}$, $\texttt{[}z,\frac{b,g}{x,y},a\texttt{]}$, $\texttt{[}z,\frac{b,g}{x,y},c\texttt{]}$, $\texttt{[}z,\frac{b,p}{x,y},b\texttt{]}$, and $\texttt{[}z,\frac{b,p}{x,y},c\texttt{]}$.

To enable quick access to the existing items, we store a number of arrays, where the elements of dom are used to index the positions in an array. For every $v\in V$ we store a $d$-ary array $\texttt{A}_{v}$, where $d:=|\textrm{path}[v]|$. We let $v_{1},\ldots,v_{d}$ be the list of variables in $\textrm{path}[v]$ in the order in which they are encountered in the path from $T$’s root to the node $v$ (in particular, $v_{1}=v_{\textsl{root}}$ and $v_{d}=v$). For constants $a_{1},\ldots,a_{d}\in\textbf{dom}$, the entry $\texttt{A}_{v}[a_{1},\ldots,a_{d}]$ represents the item $\texttt{[}v,\frac{a_{1},\ldots,a_{d-1}}{v_{1},\ldots,v_{d-1}},a_{d}\texttt{]}$, if such an item exists. Otherwise, the entry $\texttt{A}_{v}[a_{1},\ldots,a_{d}]$ is initialised to [math]. This will enable us to check in constant time whether a particular item exists, and if so, to also access this item within constant time. In the following, whenever an item $i=\texttt{[}v,\frac{a_{1},\ldots,a_{d-1}}{v_{1},\ldots,v_{d-1}},a_{d}\texttt{]}$ is newly created, we tacitly let $\texttt{A}_{v}[a_{1},\ldots,a_{d}]:=i$, and we set $\texttt{A}_{v}[a_{1},\ldots,a_{d}]:=0$ if $i$ is deleted. Note that while the support of all arrays (i.e., the non-[math] entries) is linear in the size of the current database $D$, a huge amount of storage has to be reserved for these arrays. In more practical settings one has to replace these arrays by more space-efficient data structures, such as suitable hash tables, that allow quick access to the items.

6.3 Enumeration

We now discuss how the data structure can be used to enumerate the query result with constant delay. For our Example 6.1, the $23$ result tuples of the enumeration process are shown in Table 1. To enumerate the result of a non-Boolean conjunctive query $\varphi(x_{1},\ldots,x_{k})$, let $T^{\prime}$ be the subtree of $T$ induced on $V^{\prime}:=\textrm{free}(\varphi)=\{x_{1},\ldots,x_{k}\}$. Note that by the definition of a q-tree, we know that $T^{\prime}$ is connected and contains $v_{\textsl{root}}$. For each node $v$ of $T^{\prime}$, let us fix an (arbitrary) linear order on the children of $v$ in $T^{\prime}$. In our example query we have $T^{\prime}=T$ and we let $y<y^{\prime}$ and $z<z^{\prime}$. If the start-list is empty, the enumerate routine stops immediately with output EOE. Otherwise, we proceed as follows to determine the first tuple in the query result. Let $i_{v_{\textsl{root}}}$ be the first item in the start-list. Inductively, for every $v\in V^{\prime}$ for which $i_{v}$ has been chosen already, we choose $i_{u}$ for every child $u$ of $v$ in $T^{\prime}$ by letting $i_{u}$ be the first item in the $u$-list of $i_{v}$. From the resulting items $\mathcal{I}:=(i_{v})_{v\in V^{\prime}}$ we obtain the first tuple $(a_{1},\ldots,a_{k})$ in the query result by letting $a_{\ell}$ be the constant of item $i_{x_{\ell}}$ for each $\ell\in[k]$. Thus, within time $O(k)$ we can output the first tuple that belongs to the query result.

To jump from one output tuple to the next, we proceed as follows. Assume that $\mathcal{I}=(i_{v})_{v\in V^{\prime}}$ are the items which determined the result tuple $(a_{1},\ldots,a_{k})$ that has just been output. Let $y_{1},\ldots,y_{k}$ be the list of all nodes $V^{\prime}$ of $T^{\prime}$ in document order, i.e., obtained by a pre-order depth-first left-to-right traversal of $T^{\prime}$ (in particular, $y_{1}=v_{\textsl{root}}$). In Example 6.1, the vertices thus are ordered $x,y,z,z^{\prime},y^{\prime}$.

Determine the maximum index $j\in[k]$ such that the item $i_{y_{j}}$ is not the last item of its doubly linked list. If no such $j$ exists, stop with output EOE. Otherwise, let $i^{\prime}_{y_{j}}$ be the item indicated by $\textit{next-listitem}^{i_{y_{j}}}$. For every $\mu<j$ we let $i^{\prime}_{y_{\mu}}:=i_{y_{\mu}}$. For $\mu=j{+}1,\ldots,k$ the item $i^{\prime}_{y_{\mu}}$ is determined inductively (along the document order) to be the first element of the $\mu$-list of its parent.

From the resulting items $i^{\prime}_{y_{1}},\ldots,i^{\prime}_{y_{k}}$ we obtain the next tuple $(a^{\prime}_{1},\ldots,a^{\prime}_{k})$ in the query result by letting $a^{\prime}_{\ell}$ be the constant of item $i^{\prime}_{x_{\ell}}$ for each $\ell\in[k]$. Note that the delay between outputting two consecutive result tuples is $O(k)$. The result of the enumeration process for Example 6.1 is given in Table 1, where the change of an item for a variable $y_{\ell}$ (i.e. $i^{\prime}_{y_{\ell}}\neq i_{y_{\ell}}$) for two consecutive tuples is indicated by a separating line.

The pseudo-code for the described enumerate routine is given in Algorithm 1. Our next goal is to prove the correctness of this algorithm. To this end, we let

[TABLE]

and note that $(a_{1},\ldots,a_{k})\in\varphi(D)$ if, and only if, there is an $i\in\mathcal{L}_{\text{start}}$ such that the corresponding $\beta\colon\textrm{free}(\varphi)\to\textbf{dom}$ with $\beta(x_{j})=a_{j}$ for all $j\in[k]$ is contained in $\widetilde{\mathcal{E}}^{i}$.

For every item $i=\texttt{[}v,\alpha,a\texttt{]}$ let $\beta^{i}:=\alpha\frac{a}{v}$. By construction of the algorithm we know that for any $\mathcal{I}=(i_{y_{1}},\ldots,i_{y_{k}})$ for which the procedure visit$(\mathcal{I})$ is executed by Algorithm 1, and for any two variables $y_{j},y_{k}\in V^{\prime}$ with $j<k$, the following is true:

• •

If $y_{j}\in\textrm{path}[y_{k})$, then $\beta^{i_{y_{j}}}\subseteq\beta^{i_{y_{k}}}$.

• •

Otherwise, $\beta^{i_{y_{j}}}\cap\beta^{i_{y_{k}}}=\beta^{i_{w}}$, where $w$ is the lowest common ancestor of $y_{j}$ and $y_{k}$ in $T^{\prime}$.

In particular, $\beta_{\mathcal{I}}:=\bigcup_{v\in V^{\prime}}\beta^{i_{v}}$ is a well-defined function $\beta_{\mathcal{I}}\colon\textrm{free}(\varphi)\to\textbf{dom}$.

The next lemma establishes the correctness of Algorithm 1.

Lemma 6.2**.**

1. (a)

If $\mathcal{I}=(i_{y_{1}},\ldots,i_{y_{k}})$ is a list of items for which the procedure visit$(\mathcal{I})$ is executed by Algorithm 1, then $\beta_{\mathcal{I}}\in\bigcup_{i\in\mathcal{L}_{\text{start}}}\widetilde{\mathcal{E}}^{i}$. 2. (b)

For every $\beta\in\bigcup_{i\in\mathcal{L}_{\text{start}}}\widetilde{\mathcal{E}}^{i}$ we have $\beta=\beta_{\mathcal{I}}$ for some list of items $\mathcal{I}=(i_{y_{1}},\ldots,i_{y_{k}})$ for which the procedure visit$(\mathcal{I})$ is executed by Algorithm 1. 3. (c)

Algorithm 1 does not output duplicates.

Proof.

For the proof of (a) note that by construction of the algorithm we know that any item $i_{v}$ of $\mathcal{I}$ appears either in the start-list or in the $v$-list of the item $i_{u}$, where $u$ is the parent node of $v$ in $T^{\prime}$. Therefore, every item in $\mathcal{I}$ is fit. For all $v\in V^{\prime}$ let $\gamma_{v}$ be the following inductively defined assignment:

• •

If $v$ is a leaf of $T^{\prime}$, let $\gamma_{v}$ be an assignment $\gamma_{v}\supseteq\alpha\frac{a}{v}$ such that $(D,\gamma_{v})\models\bigwedge_{\psi\in\textrm{atoms}(v)}\psi$ where $i_{v}=\texttt{[}v,\alpha,a\texttt{]}$. Note that such an assignment exists since $i_{v}$ is fit.

• •

For all other nodes $v$ of $T^{\prime}$ let $\gamma_{v}:=\bigcup_{w\in N(v)}\gamma_{w}$. Note that by construction of our data structure we know for any two $w,w^{\prime}\in N(v)$ that $\gamma_{w}(u)=\gamma_{w^{\prime}}(u)$ holds for all $u\in\textrm{path}[v]$.

Note that $\textrm{dom}(\gamma_{v_{\textsl{root}}})=\textrm{vars}(\varphi)=\bigcup_{\psi\in\textrm{atoms}(v_{\textsl{root}})}\textrm{vars}(\psi)$ and $(D,\gamma_{v_{\textsl{root}}})\models\bigwedge_{\psi\in\textrm{atoms}({v_{\textsl{root}}})}\psi$. Thus, $\gamma_{v_{\textsl{root}}}\in\mathcal{E}^{i_{v_{\textsl{root}}}}$. It is straightforward to see that $\beta^{i_{v}}\subseteq\gamma_{v}$ for every $v\in V^{\prime}$. Therefore,

[TABLE]

Since $\textrm{dom}(\beta_{\mathcal{I}})=\textrm{free}(\varphi)$, we have $\beta_{\mathcal{I}}\in\widetilde{\mathcal{E}}^{i_{v_{\textsl{root}}}}$. Furthermore, $i_{v_{\textsl{root}}}\in\mathcal{L}_{\text{start}}$, and therefore the proof of (a) is complete.

For the proof of (b) let $\beta\in\widetilde{\mathcal{E}}^{i}$ for an item $i\in\mathcal{L}_{\text{start}}$. There exists an assignment $\beta^{\prime}\supseteq\beta$ with $\beta^{\prime}\in\mathcal{E}^{i}$. We consider for all $v\in V$ the items $i_{v}=\texttt{[}v,\alpha,a\texttt{]}$ where $\beta^{\prime}\supseteq\alpha\frac{a}{v}$. Note that each item $i_{v}$ is fit. Therefore, the items $i_{v}$ are either contained in the start-list or in the $v$-list of their parents. By induction we show that $\mathcal{I}:=(i_{y_{1}},\ldots,i_{y_{k}})$ will be considered by the algorithm. This holds for $i_{v_{\textsl{root}}}$, since the algorithm iterates through all elements in the start-list. This establishes the induction base. For the induction step let $u,v\in V$ with $u\in N(v)$. By the induction hypothesis, $i_{v}$ will be considered by the algorithm. Therefore, the item $i_{u}$ will be considered by the algorithm, since it is contained in the $u$-list of $i_{v}$ and the algorithm ensures that all elements of the $u$-list of $i_{v}$ will be considered. In summary, $\textsc{visit}(\mathcal{I})$ will be called by the algorithm. Since $\beta_{\mathcal{I}}=\beta$, the proof of (b) is complete.

For the proof of (c) we define a linear order $\prec$ on all item tuples $\mathcal{I}$ by setting $(i_{y_{1}},\ldots,i_{y_{k}})\prec(i_{y_{1}}^{\prime},\ldots,i_{y_{k}}^{\prime})$ if, and only if, there is a $\mu\in[k-1]$ such that $i_{y_{1}}=i_{y_{1}}^{\prime}$, …, $i_{y_{\mu}}=i_{y_{\mu}}^{\prime}$, and $i_{y_{\mu+1}}^{\prime}$ occurs after $i_{y_{\mu+1}}$ in $y_{\mu+1}$-list of $i_{y_{\mu}}$. By the definition of the algorithm, the procedure visit$(\mathcal{I})$ is called along this linear order. To complete the proof, note that every tuple $\beta$ that is output by the algorithm uniquely determines an $\mathcal{I}$ such that $\beta_{\mathcal{I}}=\beta$ and $\beta$ is reported by call of visit$(\mathcal{I})$. ∎

6.4 Preprocessing and update

In the preprocessing phase we compute the q-tree (by Lemma 4.2 this can be done in time $\operatorname{\textit{poly}}(\varphi)$), and we initialise the data structure for the empty database. Afterwards, we perform $|{D_{0}}|$ update steps to ensure that the data structure represents the initial database ${D_{0}}$. By ensuring that the update time is constant, it follows that the preprocessing time is linear in the size of the initial database.

To illustrate the result of an update step, consider again our database ${D_{0}}$ from Example 6.1 and suppose that the tuple $(b,p)$ is inserted into relation $E$. The data structure $\mathtt{D}_{1}$ for the resulting database $D_{1}$ is shown in Figure 3(b). When an update command arrives, we have to modify our data structure accordingly so that it meets the requirements described in Section 6.2. For convenience, we summarise the conditions below.

1. (a)

An item $\texttt{[}v,\alpha,a\texttt{]}$ is present in our data structure if and only if there is an atom $\psi\in\textrm{atoms}(v)$ such that there is an expansion $\beta\supseteq{\alpha}\tfrac{a}{v}$ with $\textrm{dom}(\beta)=\textrm{vars}(\psi)$ and $(D,\beta)\models\psi$. 2. (b)

For every item $i=\texttt{[}v,\alpha,a\texttt{]}$ and every $u\in N(v)$ the list $\mathcal{L}_{u}^{i}$ consists of all fit items of the form $\texttt{[}u,{\alpha}\tfrac{a}{v},b\texttt{]}$ that are present in the data structure. 3. (c)

The start-list $\mathcal{L}_{\text{start}}$ contains all fit items of the form $\texttt{[}v_{\textsl{root}},\emptyset,b\texttt{]}$ that are present in the data structure. 4. (d)

All values of $C^{i}$, $C^{i}_{u}$, and $C_{\text{start}}$ are correct.

To be able to quickly decide whether an item meets the requirement (a), we store for every $i=\texttt{[}v,\alpha,a\texttt{]}$ and every $\psi\in\textrm{atoms}(v)$ the number $C^{i}_{\psi}$ of expansions $\beta\supseteq{\alpha}\tfrac{a}{v}$ with $\textrm{dom}(\beta)=\textrm{vars}(\psi)$ and $(D,\beta)\models\psi$. Whenever a tuple is inserted into or deleted from a relation, we increment or decrement these numbers accordingly. The number of values $C^{i}_{\psi}$ that change after an insertion or deletion of a tuple into an $r$-ary relation $R$ is $r$ times the number of occurrences of $R$ in $\varphi$. Hence these numbers can be updated in time $\operatorname{\textit{poly}}(\varphi)$. An item $i=\texttt{[}v,\alpha,a\texttt{]}$ satisfies condition (a) if, and only if, there is a $\psi\in\textrm{atoms}(v)$ such that $C^{i}_{\psi}>0$. By using the arrays $\texttt{A}_{v}$ and maintaining these numbers we can therefore create or remove items in constant time in order to preserve invariant (a).

Now we show how to update the weights $C^{i}$ and the variables $C^{i}_{u}$, $C_{\text{start}}$ which store sums of weights of list elements. The key lemma is the following (where we let products ranging over the empty set be $1$).

Lemma 6.3**.**

For every item $i=\texttt{[}v,\alpha,a\texttt{]}$ in the data structure it holds that

[TABLE]

Proof.

Note that for $\psi\in\textrm{rep}(v)$ we have $C^{i}_{\psi}\in\{0,1\}$. Furthermore, $\prod_{\psi\in\textrm{rep}(v)}C^{i}_{\psi}=1$ if and only if $(D,{\alpha}\tfrac{a}{v})\models\psi$ for all $\psi\in\textrm{rep}(v)$. Now we have two cases.

First suppose that $v$ is a leaf in $T$. In this situation we know that $\textrm{rep}(v)=\textrm{atoms}(v)$ and therefore we have to show that $C^{i}=\textstyle\prod_{\psi\in\textrm{atoms}(v)}C^{i}_{\psi}$, which follows immediately from the definition of $\mathcal{E}^{i}$.

For the second case suppose that $N(v)=\{u_{1},\ldots,u_{\ell}\}$ for $\ell\geqslant 1$. Note that $\textrm{atoms}(v)$ can be decomposed into pairwise disjoint sets $\textrm{rep}(v)$, $\textrm{atoms}(u_{1})$, …, $\textrm{atoms}(u_{\ell})$ and that the pairwise intersection of sets $U_{j}:=\bigcup_{\psi\in\textrm{atoms}(u_{j})}\textrm{vars}(\psi)$ is $\textrm{dom}(\alpha)\cup\{v\}$. If there is some $\psi\in\textrm{rep}(v)$ such that $(D,{\alpha}\tfrac{a}{v})\not\models\psi$, then $C^{i}_{\psi}=0$, and hence $\mathcal{E}^{i}=\emptyset$ and $C^{i}=0$. Otherwise, $C^{i}_{\psi}=1$ for all $\psi\in\textrm{rep}(v)$ and we have to show that $C^{i}=\prod_{u\in N(v)}C^{i}_{u}$. Note that for every $\beta\in\mathcal{E}^{i}$ and every $u_{j}\in N(v)$ there is a unique $i^{\prime}\in\mathcal{L}_{u_{j}}^{i}$ such that ${\beta}_{|U_{j}}\in\mathcal{E}^{i^{\prime}}$. Furthermore, for every choice of $\ell$ assignments $\beta_{j}\in\mathcal{E}^{i^{\prime}_{j}}$ with $i^{\prime}_{j}\in\mathcal{L}_{u_{j}}^{i}$ for $j\in[\ell]$, there is a unique $\beta=\beta_{1}\cup\cdots\cup\beta_{\ell}$ such that $\beta\in\mathcal{E}^{i}$. It follows that C^{i}=\textstyle\prod_{j\in[\ell]}\big{(}\sum_{i^{\prime}\in\mathcal{L}_{u_{j}}^{i}}\big{|}\mathcal{E}^{i^{\prime}}\big{|}\big{)}=\textstyle\prod_{u\in N(v)}C^{i}_{u}, which concludes the proof. ∎

We have already argued that upon insertion and deletion of a fact only a constant number of values $C^{i}_{\psi}$ change. It follows from Lemma 6.3 that the same holds true for the values of $C^{i}$, $C^{i}_{u}$, and $C_{\text{start}}$. Moreover, the lemma enables us to compute the new values bottom up in time $\operatorname{\textit{poly}}(\varphi)$.

Now we argue how to ensure condition (b) and (c). While recomputing the new weights $C^{i}$ we check for every considered item $i$ whether $C^{i}$ becomes zero or non-zero (recall that $i$ is fit if and only if $C^{i}>0$) and add or remove $i$ from the corresponding list. For every item this takes constant time, as we have random access to the items and the lists are doubly linked.

To summarise, the update procedure is as follows. Upon receiving $\textsf{update}\;R(b_{1},\ldots,b_{r})$ we repeat the following for all atoms $\psi=Rz_{1}\cdots z_{r}$ of $\varphi$ that satisfy \big{(}z_{s}=z_{t}\ \Rightarrow\ b_{s}=b_{t}\big{)} for all $s,t\in[r]$. Let $d=|\{z_{1},\ldots,z_{r}\}|$, let $v_{\textsl{root}}=v_{1},\ldots,v_{d}$ be the path in $T$ from $v_{\textsl{root}}$ to the vertex $v_{d}$ that represents $\psi$, and denote by $\alpha=\frac{a_{1},\ldots,a_{d}}{v_{1},\ldots,v_{d}}$ the assignment with $\alpha(z_{j})=b_{j}$ for all $j\in[r]$. Then for $j=d,\ldots,1$ and $i_{j}:=\texttt{[}v_{j},\frac{a_{1},\ldots,a_{j-1}}{v_{1},\ldots,v_{j-1}},a_{j}\texttt{]}$ we repeat the following steps.

If $\textsf{update}=\textsf{insert}$, then create $i_{j}$ (if it not already exists) and increment $C^{i_{j}}_{\psi}$.

Otherwise, decrement $C^{i_{j}}_{\psi}$. 2. 2.

Let $C^{i_{j}}_{\text{old}}:=C^{i_{j}}$ and compute $C^{i_{j}}$ using Lemma 6.3 as a product of $\operatorname{\textit{poly}}(\varphi)$ numbers. 3. 3.

If $C^{i_{j}}>0$, then add $i_{j}$ to $\mathcal{L}_{v_{j}}^{i_{j-1}}$ (if $j>1$) or $\mathcal{L}_{\text{start}}$ (if $j=1$) (unless it is already present in the according list).

Otherwise, remove $i_{j}$ from the corresponding list. 4. 4.

Compute the new value of $C^{i_{j-1}}_{v_{j}}$ (if $j>1$) or $C_{\text{start}}$ (if $j=1$) by subtracting $C^{i_{j}}_{\text{old}}$ and adding $C^{i_{j}}$. 5. 5.

If $\textsf{update}=\textsf{delete}$ and $C^{i_{j}}_{\psi}=0$ for all $\psi\in\textrm{atoms}(v_{j})$, then delete $i_{j}$ from the data structure.

6.5 Counting in the presence of quantifiers

We have already shown that in order to count the number of output tuples in the case where $\varphi$ is quantifier-free, it suffices to report the value of $C_{\text{start}}$. If $\varphi$ is non-Boolean and contains quantified variables $\overline{x}=(x_{k+1},\ldots,x_{m})$, we maintain the same numbers $C^{i}$, $C^{i}_{u}$, $C_{\text{start}}$ as before and additionally store numbers $\widetilde{C}^{i}$, $\widetilde{C}^{i}_{u}$, $\widetilde{C}_{\text{start}}$ for all present items $i=\texttt{[}v,\alpha,a\texttt{]}$ with $v\in\textrm{free}(\varphi)$. Recall that $\widetilde{\mathcal{E}}^{i}:=\{{\beta}_{|\textrm{free}(\varphi)}\ :\ \beta\in\mathcal{E}^{i}\}$. For an item $i=\texttt{[}v,\alpha,a\texttt{]}$ with $v\in\textrm{free}(\varphi)$ we let

[TABLE]

By definition we have $|\varphi(D)|=\widetilde{C}_{\text{start}}$, and we use this stored value to answer a count request in time $O(1)$. To efficiently update the values, we utilise the following technical lemma, which is similar to Lemma 6.3.

Lemma 6.4**.**

For every item $i=\texttt{[}v,\alpha,a\texttt{]}$ with $v\in\textrm{free}(\varphi)$ it holds that

[TABLE]

Proof.

First note that, in general, we have $\widetilde{\mathcal{E}}^{i}=\emptyset$ $\iff$ $\mathcal{E}^{i}=\emptyset$, and hence $\widetilde{C}^{i}=0$ $\iff$ $C^{i}=0$. If $N(v)\cap\textrm{free}(\varphi)=\emptyset$, then the lemma holds as $\widetilde{\mathcal{E}}^{i}$ is either empty or consists (only) of the assignment ${\alpha}_{|\textrm{free}(\varphi)}$, and hence $\widetilde{C}^{i}\in\{0,1\}$. Now suppose that $N(v)\cap\textrm{free}(\varphi)\neq\emptyset$ and $C^{i}>0$. Because $i$ is fit and because all descendants of quantified variables are quantified, it follows that for every $u\in N(v)\setminus\textrm{free}(\varphi)$ we have $(D,{\alpha}\tfrac{a}{v})\models\exists\overline{x}\textstyle\bigwedge_{\psi\in\textrm{atoms}(u)}\psi$. Therefore, by the same argument as in the proof of Lemma 6.3 we obtain that \big{|}\widetilde{\mathcal{E}}^{i}\big{|}=\textstyle\prod_{u\in N(v)\cap\textrm{free}(\varphi)}\big{(}\sum_{i^{\prime}\in\mathcal{L}_{u}^{i}}\big{|}\widetilde{\mathcal{E}}^{i^{\prime}}\big{|}\big{)}=\textstyle\prod_{u\in N(v)\cap\textrm{free}(\varphi)}\widetilde{C}^{i}_{u}. ∎

Now we can update the numbers $\widetilde{C}^{i}$, $\widetilde{C}^{i}_{u}$, $\widetilde{C}_{\text{start}}$ in the same way as we have done for $C^{i}$, $C^{i}_{u}$, $C_{\text{start}}$. In particular, we enrich the update procedure described in Section 6.4 by the following two steps 2a and 4a and execute them after 2 and 4, respectively.

• 2a.

If $v_{j}\in\textrm{free}(\varphi)$, let $\widetilde{C}^{i_{j}}_{\text{old}}:=\widetilde{C}^{i_{j}}$ and compute $\widetilde{C}^{i_{j}}$ using Lemma 6.4.

• 4a.

If $v_{j}\in\textrm{free}(\varphi)$, compute the new value of $\widetilde{C}^{i_{j-1}}_{v_{j}}$ (if $j>1$) or $\widetilde{C}_{\text{start}}$ (if $j=1$) by subtracting $\widetilde{C}^{i_{j}}_{\text{old}}$ and adding $\widetilde{C}^{i_{j}}$.

7 Discussion

We studied the complexity of answering conjunctive queries under database updates and showed that they can be evaluated efficiently if they are q-hierarchical. For Boolean conjunctive queries and the task of computing the result size of non-Boolean queries we proved corresponding lower bounds based on algorithmic conjectures and obtained a complete picture of the queries that can be answered efficiently under updates. Moreover, the q-hierarchical property also precisely characterises those self-join free conjunctive queries that can be enumerated efficiently under updates.

A natural open problem is the missing classification of the enumeration problem for conjunctive queries that contain self-joins. As an intriguing example consider the two CQs

[TABLE]

It is easy to see that in the static setting, the results of both queries can be enumerated with constant delay after linear time preprocessing (this also immediately follows from [4], since the queries are free-connex acyclic). But both queries are non-q-hierarchical. By similar arguments as in our lower bound proofs in Section 5, one can show that the results of $\varphi_{1}$ cannot be enumerated with $O(n^{1-\varepsilon})$ update time and $O(n^{1-\varepsilon})$ delay, unless the OMv-conjecture fails (see Appendix A). However, $\varphi_{2}$ can be enumerated with constant delay and constant update time after a linear time preprocessing phase, as the following argument shows. If the $\{E\}$-database $D$ is a digraph without loops, then the query result is empty. Otherwise, there is a loop $(c,c)\in E^{D}$ and we can immediately report the output tuples $(c,c)\times E^{D}$ with constant delay. During this enumeration process, which takes time $\Theta(|\!|D|\!|)$, we have enough time to preprocess, from scratch, the query $\varphi_{1}$ on the database $D^{\prime}$ obtained from $D$ by deleting the tuple $(c,c)$. Afterwards, we can enumerate with constant delay the remaining tuples, i.e., the tuples in $\varphi_{1}(D^{\prime})\times E^{D}$ (see the Appendix A for details).

Note that even in the static setting, a complexity classification for enumerating the results of join queries with self-joins is not in sight and it seems likely that there is no structural characterisation of tractable queries (see [10] for a discussion on that matter).

On a more conceptual level, the main contribution of this paper is to initiate a systematic theoretical investigation of the computational complexity of query evaluation under database updates. We are excited by the fruitful connections between database theory and the theory of dynamic algorithms — in particular, that a known concept from the database literature that classifies hard queries in various settings (“being non-hierarchical”) is tightly connected to the underlying combinatorial hardness shared by many dynamic algorithms (as captured by the OMv-conjecture). We suspect that there are further settings in which the theory of dynamic algorithms helps to advance our understanding of query evaluation under a dynamically changing database. Currently, we are working towards characterising the complexity of more expressive queries such conjunctive queries with negation and unions of conjunctive queries.

8 Bibliography

APPENDIX

This appendix contains proof details that were omitted from Section 7.

Appendix A Details on the Discussion about Queries with Self-Joins

We prove the statements about the dynamic enumeration complexity of the queries $\varphi_{1}$ and $\varphi_{2}$ as discussed in Section 7.

Lemma A.1**.**

Suppose there is an $\epsilon>0$ and a dynamic algorithm with arbitrary preprocessing time and $t_{u}=n^{1-\varepsilon}$ update time that enumerates  \varphi_{1}(x,y):=\big{(}Exx\wedge Exy\wedge Eyy\big{)}  with $t_{d}=n^{1-\varepsilon}$ delay on databases whose active domain has size $n$, then the OMv-conjecture fails.

Proof.

We show that a dynamic enumeration algorithm for $\varphi_{1}(x,y)$ helps to solve OuMv in time $O(n^{3-\varepsilon})$. We start the preprocessing phase of our evaluation algorithm for $\varphi_{1}$ with the empty database $D=(E^{D})$ where $E^{D}=\emptyset$. As this database has constant size, the preprocessing phase finishes in constant time.

Given an $n\times n$ matrix $M$, we fix $2n$ distinct elements $\{a_{i},b_{i}\ :\ i\in[n]\}$ of dom, and perform at most $n^{2}$ update steps to insert the tuple $(a_{i},b_{j})$ into $E^{D}$, for all $(i,j)$ with $M_{i,j}=1$. All this is done within time $n^{2}t_{u}=O(n^{3-\epsilon})$, and afterwards $D$ is the $\{E\}$-db with $E^{D}=\{(a_{i},b_{j})\ :\ M_{i,j}=1\}$.

When receiving two vectors $\vec{u}^{\,t}$ and $\vec{v}^{\,t}$ in the dynamic phase of OuMv, we insert and delete loops in $D$ such that the following is true:

• •

$(a_{i},a_{i})\in E^{D}$  $\iff$  the $i$-th entry of $\vec{u}^{\,t}$ is $1$,

• •

$(b_{i},b_{i})\in E^{D}$  $\iff$  the $i$-th entry of $\vec{v}^{\,t}$ is $1$.

Now we enumerate the result of \varphi_{1}(x,y)=\big{(}Exx\wedge Exy\wedge Eyy\big{)} evaluated on $D$ for $2n{+}1$ steps, and we output $1$ if there was some pair $(a_{i},b_{j})$ in the output, and otherwise we output [math]. Note that such a pair occurs among the first $2n{+}1$ output pairs as there are at most $2n$ loops $(a_{i},a_{i})$ and $(b_{j},b_{j})$. From the definition of $D$ it follows that the output agrees with $(\vec{u}^{\,t})^{\,\mkern-1.5mu\mathsf{T}}M\vec{v}^{\,t}$. For each $t\in[n]$, all this is done within time $2nt_{u}+(2n+1)t_{d}=O(n^{2-\varepsilon})$. The overall running time is $O(n^{3-\varepsilon})$. This contradicts the OMv-conjecture by Theorem 5.1. ∎

Lemma A.2**.**

The results of the query  \varphi_{2}(x,y,z_{1},z_{2}):=\big{(}Exx\wedge Exy\wedge Eyy\wedge Ez_{1}z_{2}\big{)}  can be enumerated with constant delay and constant update time after a linear time preprocessing phase.

Proof.

We first observe that in the static setting, the results of the query  \varphi_{1}(x,y):=\big{(}Exx\wedge Exy\wedge Eyy\big{)}  can be enumerated with constant delay after $O(|\!|D|\!|)$ preprocessing (this is easy to see and also follows from [4], since the query is free-connex acyclic).

Our dynamic algorithm for enumerating the results of $\varphi_{2}$ stores a doubly linked list of all elements $c$ such that $(c,c)\in E^{D}$. Furthermore, we store an adjacency matrix of $E^{D}$ as well as a doubly linked list of all tuples in $E^{D}$.

To achieve constant update time, we implement the latter by three 2-dimensional arrays A, $\texttt{B}_{next}$, $\texttt{B}_{prev}$ and two tuples $\texttt{first}_{\texttt{B}}$ and $\texttt{last}_{\texttt{B}}$, all of which are initialised by 0.

Upon an update command of the form $\textsf{insert}\;E(i,j)$, we proceed as follows. If $\texttt{A}[i,j]=1$, we are done. Otherwise, we set $\texttt{A}[i,j]:=1$. If $\texttt{last}_{\texttt{B}}=0$, then we set $\texttt{first}_{\texttt{B}}:=\texttt{last}_{\texttt{B}}:=[i,j]$. Otherwise, we set $[i^{\prime},j^{\prime}]:=\texttt{last}_{\texttt{B}}$, $\texttt{B}_{prev}[i,j]:=[i^{\prime},j^{\prime}]$, $\texttt{B}_{next}[i^{\prime},j^{\prime}]:=[i,j]$, and $\texttt{last}_{\texttt{B}}:=[i,j]$.

Upon an update command of the form $\textsf{delete}\;E(i,j)$, we proceed as follows. If $\texttt{A}[i,j]=0$, we are done. Otherwise, we set $\texttt{A}[i,j]:=0$. If $[i,j]=\texttt{first}_{\texttt{B}}=\texttt{last}_{\texttt{B}}$, then we set $\texttt{first}_{\texttt{B}}:=\texttt{last}_{\texttt{B}}:=0$ and $\texttt{B}_{next}[i,j]:=\texttt{B}_{prev}[i,j]:=0$. Otherwise, if $\texttt{first}_{\texttt{B}}=[i,j]$, then we set $\texttt{first}_{\texttt{B}}:=\texttt{B}_{next}[i,j]$ and $\texttt{B}_{prev}\texttt{first}_{\texttt{B}}:=\texttt{B}_{next}[i,j]:=0$. Otherwise, if $\texttt{last}_{\texttt{B}}=[i,j]$, then we set $\texttt{last}_{\texttt{B}}:=\texttt{B}_{prev}[i,j]$ and $\texttt{B}_{next}\texttt{last}_{\texttt{B}}:=\texttt{B}_{prev}[i,j]:=0$. Otherwise, we set $\texttt{B}_{next}\texttt{B}_{prev}[i,j]:=\texttt{B}_{next}[i,j]$, $\texttt{B}_{prev}\texttt{B}_{next}[i,j]:=\texttt{B}_{prev}[i,j]$, and $\texttt{B}_{prev}[i,j]:=\texttt{B}_{next}[i,j]:=0$.

Of course, we can use a similar data structure to store, and update within constant time, the doubly linked list of all elements $c$ such that $(c,c)\in E^{D}$.

Upon a call of the enumerate routine, we let $c_{0}$ be the first element in the list of all elements $c$ such that $(c,c)\in E^{D}$. If no such element exists, we know that the query result is empty, and we can immediately output the end-of-enumeration message EOE. Otherwise, we immediately start to output all tuples $(c_{0},c_{0})\times E^{D}$ with constant delay $t_{d}$ (where we choose the constant $t_{d}$ to be large enough). As this takes time $t_{d}|E^{D}|=\Omega(t_{d}\|D\|)$, there is enough time to perform, in the meantime, the full linear time preprocessing phase of the static enumeration algorithm for the query $\varphi_{1}(x,y)$ on the database $D^{\prime}$ that is obtained from $D$ by deleting the tuple $(c_{0},c_{0})$. This allows to afterwards enumerate with constant delay all remaining tuples in $\varphi_{2}(D)$, i.e., all tuples in $\varphi_{1}(D^{\prime})\times E^{D}$. ∎