Pessimistic Cardinality Estimation^††thanks: This work was partially supported by NSF-BSF 2109922, NSF IIS 2314527, NSF SHF 2312195, SNSF 200021-231956, and RelationalAI.

Given a query, the Cardinality Estimation problem, or CE for short, is to estimate the size of the query output, using precomputed statistics on the input database. This estimate is the primary metric guiding cost-based query optimization. The optimizer uses it to make decisions about every aspect of query execution. These range from broad logical optimizations like the join order and the number of servers to distribute the data over, to detailed physical optimizations like the use of bitmap filters and memory allocation for hash tables.

Unfortunately, CE is notoriously difficult. Density-based estimators, pioneered by System R [36], are widely used today, but they underestimate significantly due to their strong reliance on assumptions like data uniformity and independence. They tend to have large errors for queries with many joins and many predicates [16, 23]. A major limitation of density-based CE is that it does not come with any theoretical guarantees: it may under-, or over-estimate, by a little or by a lot, without any warning. Alternative approaches have been proposed, but they come with their own limitations: sampling-based estimators require expensive data access at estimation time, while ML-based estimators suffer from large memory footprints and long training time [38, 28, 16].

An alternative to estimation is to compute an upper bound on the size of the query output, based on the precomputed statistics on the data. This is called pessimistic cardinality estimation, or PCE for short [9]. The PCE returns a number that is larger than the size of the query output for any database instance that satisfies the given statistics. The inclusion of the term “estimation” in PCE is a little misleading, since it does not estimate but gives an upper bound, yet the term has stuck in the literature, and we will use it too. Of course, we want the upper bound to be as small as possible, but not smaller. When it achieves accuracy that is similar to, or even better than traditional estimators, PCE offers several advantages. Its one-sided theoretical guarantee can be of use in many applications, for example it can guarantee that a query does not run out of memory, or it can put an upper bound on the number of servers required to distribute the output data. It also has the advantage that the upper bounds combine naturally: if we have multiple upper bounds due to different techniques, we can apply them all and take the minimum.

This paper gives a high level overview of pessimistic cardinality estimation, and contrasts it with traditional methods. We start by discussing single-block SQL queries:

	SELECT *
	FROM R1, R2, ...		(1)
	WHERE [joins and filters]

Later we will restrict our discussion to conjunctive queries. Some of the PCE techniques described here also apply to group-by queries.

Modern database engines use a density-based approach for cardinality estimation. They compute periodically some simple statistics (or summaries) of the base relations, then use simplifying assumptions to estimate the cardinality. Specifically, the engine stores in its catalog, for each relation $R$, its cardinality $|R|$, and the number of distinct values¹¹1Denoted $V(R,X)$ in a popular textbook [19]. $|\textsf{Dom}(R.X)|$, where $X$ is a single attribute or a set of attributes. This quantity is computed periodically, and approximately, by sampling from $R$ (e.g. Postgres) or by using Hyper-Log-Log (e.g. DuckDB). The ratio $\frac{|R|}{|\textsf{Dom}(R.X)|}$ represents the average degree, or the density of the attribute(s) $X$.

Consider the uniform probability space whose outcomes are the tuples of the Cartesian product of all relations in (1), $R_{1}\times R_{2}\times\ldots$ This defines a probability $\mathop{\textnormal{Pr}}(X,Y,\ldots)$ over all attributes returned by the query. A density-based CE estimates the probability that a random tuple from the Cartesian product satisfies the condition in the where clause. The cardinality estimate is the multiplication of this probability with the size of the Cartesian product. For example, consider the following SQL query $Q$:

$\displaystyle\texttt{SELECT }*\texttt{ FROM Store }\texttt{WHERE City}=\texttt{'Seattle'}$

By the uniformity assumption and the containment of values assumption the probability that a random tuple satisfies the predicate is $\frac{1}{|\textsf{Dom}(\texttt{Store}.\texttt{City})|}$. The cardinality estimate is $\textsc{Est}(Q)=\frac{|\texttt{Store}|}{|\textsf{Dom}(\texttt{Store}.\texttt{City})|}$.

1-Dimensional Histograms relax the uniformity assumption, by storing separate statistics for each bucket of a histogram. The default number of buckets is small (200 for SQLServer [1], 100 for Postgres), and is strictly limited (typically to $1000-10000$ [38]).

Joins are estimated using similar assumptions. For example, consider the query $J$ given by:

$\displaystyle\texttt{SELECT * FROM R, S WHERE R.X}=\texttt{S.Y}$

(2)

One estimate could be $|R|\cdot\frac{|S|}{|\textsf{Dom}(S.Y)|}$, because each tuple in $R$ matches an estimated $\frac{|S|}{|\textsf{Dom}(S.Y)|}$ tuples in $S$. Or, symmetrically, $\frac{|R|}{|\textsf{Dom}(R.X)|}\cdot|S|$. Density-based CE returns their minimum²²2Justified by the containment-of-values assumption., usually written as:

$\displaystyle\textsc{Est}(J)=$

$\displaystyle\frac{|R|\cdot|S|}{\max(|\textsf{Dom}(R.X)|,|\textsf{Dom}(S.Y)|)}$

(3)

Finally, the estimate for a conjunction of predicates is computed by assuming independence between the predicates. For example, the estimate of the following query $Q$

	SELECT * FROM Store
	$\displaystyle\texttt{WHERE City}=\texttt{'Seattle' AND Zip}=\texttt{'98195'}$

is $\textsc{Est}(Q)=\frac{|\texttt{Store}|}{|\textsf{Dom}(\texttt{Store}.\texttt{City})|\cdot|\textsf{Dom}(\texttt{Store}.\texttt{Zip})|}$, which is an underestimate, since that entire zip code is in Seattle. 2-Dimensional Histograms can capture correlations between attributes, but few systems support them.³³3There are several reasons why 2-d histograms are rarely used. (1) There are too many candidates: $n(n-1)/2$ possible histograms for a relation with $n$ attributes. The number of buckets along each dimension is limited to $\sqrt{1000}-\sqrt{10000}$. (2) It is unclear how to combine multiple 2-d histograms [33], e.g. in order to estimate a predicate on 3 attributes $\mathop{\textnormal{Pr}}(X,Y,Z)$ from 2-d histograms on $XY,XZ,YZ$.

A landmark paper [30] evaluated the cardinality estimators deployed in modern database systems and their impact on the query optimizer. It found that their CE almost always underestimates (because of the independence assumption) with typical errors of up to $10^{4}$ for queries with many joins. Later studies have confirmed these findings across a wide variety of workloads and database systems [29, 35, 38, 23, 28].

Given the importance of the problem and the limitations of density-based methods, many recent proposals have been published exploring alternatives to traditional density-based CE. Two alternatives have attracted particular interest: sampling-based CE and learned CE.

Sampling-based CE methods compute an unbiased estimate without requiring any assumptions. Offline sampling pre-computes a uniform sample $R_{\text{sample}}\subseteq R$ of each relation, then estimates the size of the query output over the base relations from the size of the query output over the sample using the Horvitz-Thompson’s formula.⁴⁴4The size estimate is the multiplication of the size of the query output over the sample with the ratio $|R|/|R_{\text{sample}}|$ for each relation in the query. More robust estimates, such as bottom-k [12], are not commonly used for CE [11]. This method can be very accurate for queries over a single relation and easily supports arbitrary user-defined predicates beyond equality and range predicates. However, it becomes ineffective for highly selective predicates, because of sampling collapse: when no sampled tuple matches the query, then the system must return 0 or 1. In particular, this is a problem for joins, since their selectivity is relative to the cartesian product of the input relations and therefore almost always extremely low.⁵⁵5The estimate is still unbiased, over the random choices of the samples, but the standard deviation is high. Online sampling addresses this issue by sampling only tuples that join with already sampled tuples. Based on this principle, Wander Join [31, 32] achieves remarkable accuracy [35]; however, it requires access to an index on every join column, and has a high latency.

Learned CE aims to remove the assumptions of traditional CE by training an ML model that captures the complex correlations empirically [38, 28]. Data-driven estimators compute a generative ML model for the probability $\mathop{\textnormal{Pr}}(X,Y,\ldots)$ over all attributes returned by the query. This is trained on the database [39, 40]. The model needs to represent all attributes, of all relations. Intuitively, these models aim for a lossy compression of the full outer join of the database relations then estimate the selectivity of the predicates in the query relative to it. This is an extremely ambitious approach, and it tends to require large models that either struggle with, or completely disallow queries that do not follow the schema’s natural join structure, like self-joins. Query-driven estimators compute a discriminative model for $\textsc{Est}(Q)$. The model is trained using a workload of queries and their true cardinalities. In general, ML-based estimates can be quite accurate on the training data, but they suffer from distribution drift, can be memory intensive (1MB to 1GB models are reported in the literature), support only limited types of queries and predicates, and require full retraining when the data changes, e.g. when a new relation is added [23].

Stepping back from existing estimators, we ask a more general question: What properties do we wish a cardinality estimator to have? We propose here six such properties, which we argue any good CE should have:

Accuracy/Speed/Memory:

It should have good accuracy, small estimation time, small memory footprint.

Locality:

It should use statistics that are computed separately on each input relation.

Composition:

It should be able to compute an estimate for a query from the estimates for its subqueries; this is useful in bottom-up query optimizers.

Combination:

It should be able to combine multiple sources of statistics on the database. Given two estimates $\textsc{Est}_{1}$ and $\textsc{Est}_{2}$ computed using different methods, or different statistics, one should be able to combine them to obtain a better estimate Est.

Incremental Updates:

It should be possible to update the statistics incrementally when the input data is updated.

Guarantees:

It should offer some theoretical guarantees. This will allow the application to reason about decisions based on CE.

All CE’s aim for good speed/accuracy/memory, with various degrees of success. Density-based and sampling-based CE’s are local, while learned CE are definitely not local: they are monolithic, in that they require access to all relations at training time. Density-based CE is compositional⁶⁶6Under the preservation of values assumption., but it cannot do combination. For example, to estimate the size of $\sigma_{X=a\wedge Y=b\wedge Z=c}(R)$ we could use $|\textsf{Dom}(R.X)|$ and $|\textsf{Dom}(R.YZ)|$, or we could use $|\textsf{Dom}(R.XY)|$ and $|\textsf{Dom}(R.Z)|$, but we cannot combine these two estimates to get a better estimate [33]. For another example, given the cardinalities of both joins $R\Join S$ and $S\Join T$, there is no canonical way to combine them to estimate the cardinality of $R\Join S\Join T$ [10]. ML-based estimators can be neither composed nor combined, and need to be re-trained from scratch after an update. Finally, of all methods discussed here, only sampling-based methods offer theoretical guarantees: the others offer no guarantees.

Next, we will discuss the alternative, pessimistic approach to cardinality estimation. We will return to our wish-list in Sec. 11.

A Pessimistic Cardinality Estimator, PCE, computes a guaranteed upper bound on the cardinality, instead of an estimate. For a very simple example, an upper bound of the join (2) is $|R|\cdot|S|$. If we know the largest number $b$ of occurrences of any value in $S.Y$, also called the maximum degree of $Y$ in $S$, then a better bound is $|R|\cdot b$; for example, if $Y$ is a key in $S$, then $b=1$ and the bound becomes $|R|$. Symmetrically, if we know the maximum degree of $Y$ in $R$, call it $a$, then $a\cdot|S|$ is also an upper bound. We can combine these bounds by taking their $\min$:

$\displaystyle|J|\leq\min(|R|\cdot b,\ a\cdot|S|)$

(4)

This should be compared with the traditional estimator (3), which replaces the maximum degrees $a$ and $b$ with the average degrees.

Two advances make pessimistic cardinality estimators practical today. The first is the observation that degree sequences can be used to compute an upper bound on the query output size [15]. The second is a long line of theoretical results on using information inequalities to compute upper bounds on the query’s output [18, 21, 22, 20, 4, 5, 37, 2]. We review both topics in the rest of the paper.

The existing PCE’s use statistics derived from degree sequences of the input relations.

Let $R$ be a relation, and $U,V\subseteq\texttt{Attrs}(R)$ two sets of attributes. We assume throughout the paper that relations are sets. The degree sequence

$\displaystyle\texttt{deg}_{R}(V|U)\stackrel{{\scriptstyle\text{def}}}{{=}}$

$\displaystyle(d_{1},d_{2},\ldots,d_{n})$

(5)

is defined as follows. If $u_{1},\ldots,u_{n}$ are the distinct values of $\Pi_{U}(R)$, then $d_{i}\stackrel{{\scriptstyle\text{def}}}{{=}}|\sigma_{U=u_{i}}(\Pi_{UV}(R))|$ is the degree of the value $u_{i}$. We assume that the values $u_{i}$ are sorted in decreasing order of their degrees, i.e. $d_{1}\geq d_{2}\geq\cdots\geq d_{n}$. We say that the value $u_{i}$ has rank $i$. Notice that $\texttt{deg}_{R}(V|U)=\texttt{deg}_{R}(UV|U)$.

Figure 1 illustrates some simple examples of degree sequences, while Figure 2 shows the degree sequence of the IMDB dataset from the JOB benchmark [30]. If the functional dependency $U\rightarrow V$ holds, then $\texttt{deg}_{R}(V|U)=(1,1,\ldots,1)$. When $|U|\leq 1$ then we call the degree sequence $\texttt{deg}_{R}(V|U)$ simple, and when $UV=\texttt{Attrs}(R)$ are all the attributes of $R$, then we call $\texttt{deg}_{R}(V|U)$ full and also denote it by $\texttt{deg}_{R}(*|U)$. The degree sequence $\texttt{deg}_{R}(YZ|X)$ in Fig. 1 is both simple and full, and we can write it as $\texttt{deg}_{R}(*|X)$.

The $\ell_{p}$-norm of the degree sequence (5) is:

$\displaystyle||\texttt{deg}_{R}(V|U)||_{p}\stackrel{{\scriptstyle\text{def}}}{{=}}$

$\displaystyle\left(d_{1}^{p}+d_{2}^{p}+\cdots+d_{n}^{p}\right)^{1/p}$

Degree sequences and their $\ell_{p}$-norms generalize common statistics used by density-based estimators: the relation cardinality is $||\texttt{deg}_{R}(*|U)||_{1}=|R|$, the number of distinct values $|\textsf{Dom}(R.U)|$ is the length $n$ of the sequence (5) (and also equal to $||\texttt{deg}_{R}(U|\emptyset)||_{1}$); and the maximum degree of $R.U$ is $||\texttt{deg}_{R}(*|U)||_{\infty}=d_{1}$. But degree sequences contain information that can significantly improve the accuracy of PCE. For example the inequality $|J|\leq a\cdot|S|$ in (4) assumes pessimistically that all degrees in $\texttt{deg}_{R}(X|Y)$ are equal to the maximum degree $a$. By using the degree sequence and more sophisticated inequalities we can account for the true distribution of the data, as we will see later.

Historically, the first cardinality upper bound was introduced by Atserias, Grohe, and Marx [8], and builds on earlier work by Friedugut and Kahn [18] and Grohe and Marx [21]. The bound is known today as the AGM bound. It uses only the cardinalities of the input relations, $|R_{1}|,\ldots,|R_{m}|$, and is defined as follows. A fractional edge cover of the query $Q$ in (6) is a tuple of non-negative weights, $\bm{w}=(w_{1},w_{2},\ldots,w_{m})$, such that every variable $X_{j}$ is “covered”, meaning $\sum_{i:X_{j}\in U_{i}}w_{i}\geq 1$, for $1\leq j\leq n$. Then, the following inequality holds:

$\displaystyle|Q|\leq$

$\displaystyle|R_{1}|^{w_{1}}\cdot|R_{2}|^{w_{2}}\cdots|R_{m}|^{w_{m}}$

(7)

The AGM bound of $Q$ is defined as the minimum of (7), taken over all fractional edge covers $\bm{w}$.

The classical illustration of the AGM bound is for the 3-cycle query:

$\displaystyle C_{3}(X,Y,Z)=$

$\displaystyle R(X,Y)\wedge S(Y,Z)\wedge T(Z,X)$

(8)

One fractional edge cover is $(1,1,0)$, which proves $|C_{3}|\leq|R|\cdot|S|$. Other fractional edge covers are $(1,0,1)$, $(0,1,1)$, and $(\frac{1}{2},\frac{1}{2},\frac{1}{2})$, and each leads to a similar upper bound on $|C_{3}|$. The AGM bound is their minimum:⁷⁷7These four fractional edge covers are called the vertices of the edge cover polytope. In (7) it suffices to restrict the $\min$ to the vertices of the edge cover polytope, because any other fractional edge cover is $\geq$ than some convex combination of the vertices.

$\displaystyle|C_{3}|\leq$

$\displaystyle\min\left(|R|\cdot|S|,\ |R|\cdot|T|,\ |S|\cdot|T|,\ \left(|R|\cdot|S|\cdot|T|\right)^{1/2}\right)$

The AGM bound enjoys two elegant properties: it is computable in PTIME in the size of the query $Q$ (by solving a linear program), and the bound is guaranteed to be tight. The latter means that, for any set of cardinalities $|R_{1}|,|R_{2}|,\ldots$ there exists a worst case database instance, with the same cardinalities, where the size of the query output is equal to the AGM bound, up to a rounding error equal to a query-dependent multiplicative constant.⁸⁸8The constant is $\frac{1}{2^{n}}$, where $n$ is the number of variables.

Despite these attractive theoretical properties, the AGM bound has not been adopted in practice, because it uses very limited statistics on the input data, namely just the relation cardinalities. In particular, for acyclic queries the AGM bound is achieved by an integral (not fractional) edge cover, and expression (7) is a product of the cardinalities of some relations. For example, for the 2-way join query:

$\displaystyle J_{2}(X,Y,Z)=$

$\displaystyle R(X,Y)\wedge S(Y,Z)$

(9)

The AGM bound is $|R|\cdot|S|$. In contrast, a density-based estimator uses both cardinalities and average degrees, as seen for example in (3), and for this reason it returns a better estimate for $J_{2}$ than the AGM bound, even if it cannot provide any guarantees.

The chain bound [4], CB for short, uses as statistics both cardinalities $|R_{i}|$, and maximum degrees $||\texttt{deg}_{R_{i}}(V|U)||_{\infty}$. It strictly generalizes the AGM bound, but a popular simplification adopted by several implementations is weaker than the AGM bound. To describe CB, it is convenient to view each cardinality $|R_{j}|$ as a maximum degree, namely $|R_{j}|=||\texttt{deg}_{R_{j}}(*|\emptyset)||_{\infty}$. Thus, all statistics are max degrees: $||\texttt{deg}_{R_{j_{i}}}(V_{i}|U_{i})||_{\infty}$, for $i=1,k$.

Fix an ordering $\pi$ of the query variables. We say that the pair $(V|U)$ covers the variable $X$ w.r.t. $\pi$, and write $X\in_{\pi}(V|U)$, if $X\in V$ and all variables in $U$ strictly precede $X$ in the order $\pi$. For a simple example, if $U=\emptyset$, then $(V|\emptyset)$ covers all variables in $V$; for another example, if the order $\pi$ is $X,Y,Z$ then $(XZ|Y)$ covers only $Z$. If a set of non-negative weights $w_{1},\ldots,w_{k}$ is a fractional cover of $(V_{1}|U_{1}),\ldots,(V_{k}|U_{k})$, meaning that it covers every variable $X$ (i.e., $\sum_{i:(X\in_{\pi}V_{i}|U_{i})}w_{i}\geq 1$), then the following holds (we give the proof in the Appendix):

$\displaystyle|Q|\leq$

$\displaystyle\prod_{i=1,k}||\texttt{deg}_{R_{j_{i}}}(V_{i}|U_{i})||_{\infty}^{w_{i}}$

(10)

CB is the minimum of the quantity above over all fractional covers $\bm{w}$ and variable orderings $\pi$, and is always an upper bound on $|Q|$. If $\pi$ is fixed, then CB can be computed in PTIME by using an LP solver, but minimizing over all $\pi$ requires exponential time.⁹⁹9Computing CB is NP-hard [25]. When all statistics are cardinalities then CB is independent on the choice of $\pi$ and coincides with the AGM bound. When the statistics also include max-degrees, then CB is lower (better) than the AGM bound.

Several implementations have adopted a simplified version of CB which does not require the use of an LP solver, called BoundSketch in [9, 24] or MOLP in [10]: we will use the term BoundSketch. It corresponds to restricting the fractional cover $\bm{w}$ in (10) to be an integral cover.¹⁰¹⁰10BoundSketch also hash partitions the data in order to improve the estimate [9]. We will use BoundSketch to refer to integral CB, without data partitioning. We describe BoundSketch, following the presentation in [10]. Consider the following nondeterministic algorithm.

• •

  Set $W:=\emptyset$, $CB:=1$.

• •

  Repeatedly choose non-deterministically one statistics, $d_{i}\stackrel{{\scriptstyle\text{def}}}{{=}}||\texttt{deg}_{R_{j_{i}}}(V_{i}|U_{i})||_{\infty}$, such that $U_{i}\subseteq W$. Set $W:=W\cup V_{i}$ and $CB:=CB\cdot d_{i}$.

• •

  Stop when $W$ contains all query variables, and return $CB$.

BoundSketch is the minimum value returned by all executions of the non-deterministic algorithm. This is equivalent to computing the shortest path in the graph called $CEG_{M}$ in [10]: its nodes are all subsets $W\subseteq\{X_{1},\ldots,X_{n}\}$, and for every statistics $d_{i}=||\texttt{deg}_{R_{j_{i}}}(V_{i}|U_{i})||_{\infty}$ there is an edge with weight $d_{i}$ from $W$ to $W\cup V_{i}$, for all $W\supseteq U_{i}$. Then BoundSketch is the shortest¹¹¹¹11Weights along a path are multiplied. path from $\emptyset$ to $\{X_{1},\ldots,X_{n}\}$. BoundSketch still requires exponential time.¹²¹²12When the statistics are restricted to cardinalities (no max-degrees), then BoundSketch or, equivalently, MOLP [10], is larger (worse) than the AGM bound, as it considers only integral covers. The original definition of MOLP [27] (called MO in [27]) claims the opposite, a claim repeated in [10]. However, that claim only holds under the assumption that one first regularizes the data, then computes a separate bound for each degree configuration, using both cardinalities and max-degree statistics.

BoundSketch is similar to a density-based estimator, where the average degrees are replaced by maximum degrees: this was noted in [10]. We illustrate this on an example with a 3-way join query:

$\displaystyle J_{3}(X,Y,Z,U)=$

$\displaystyle R(X,Y)\wedge S(Y,Z)\wedge T(Z,U)$

(11)

BoundSketch is the minimum of the following quantities:¹³¹³13We omit non-optimal expressions, like $|R|\cdot|S|\cdot|T|$.

	$\displaystyle|J_{3}|\leq$	$\displaystyle|R|\cdot||\texttt{deg}_{S}(Z|Y)||_{\infty}\cdot||\texttt{deg}_{T}(U|Z)||_{\infty}$		(12)
	$\displaystyle|J_{3}|\leq$	$\displaystyle||\texttt{deg}_{R}(X|Y)||_{\infty}\cdot|S|\cdot||\texttt{deg}_{T}(U|Z)||_{\infty}$
	$\displaystyle|J_{3}|\leq$	$\displaystyle||\texttt{deg}_{R}(X|Y)||_{\infty}\cdot||\texttt{deg}_{S}(Y|Z)||_{\infty}\cdot|T|$
	$\displaystyle|J_{3}|\leq$	$\displaystyle|R|\cdot|T|$

Let us compare this with the density-based estimator described in Sec. 2, which, for $J_{3}$, is:

$\displaystyle\textsc{Est}(J_{3})=$

$\displaystyle\frac{|R|\cdot|S|\cdot|T|}{\max(|R.Y|,|S.Y|)\cdot\max(|S.Z|,|T.Z|)}$

For illustration, assume that $|R.Y|\leq|S.Y|$ and $|S.Z|\leq|T.Z|$. Then the estimate can be written as:

$\displaystyle\textsc{Est}(J_{3})=$

$\displaystyle|R|\cdot\frac{|S|}{|S.Y|}\cdot\frac{|T|}{|T.Z|}$

This is the same expression as (12), where the maximum degrees are replaced with the average degrees.

The main advantage of CB and its simplified variant BoundSketch is their simplicity and resemblance to the density-based estimator. A disadvantage is that their computation requires exponential time, because we need to iterate over all variable orderings $\pi$. Another limitation is that, unlike the AGM bound, CB is not tight: the polymatroid bound described below can be strictly lower than CB. However, in the special case when the set of statistics is acyclic, CB is both tight and computable in PTIME. In this case, there exist variable orderings such that, for every statistics $||\texttt{deg}_{R_{j_{i}}}(V_{i}|U_{i})||_{\infty}$, all variables in $U_{i}$ come before those in $V_{i}$, which implies $V_{i}\subseteq_{\pi}(V_{i}|U_{i})$ for $i=1,k$. Such an ordering $\pi$ can be computed in linear time using topological sort. We then use an LP solver to compute the optimal fractional cover for $\pi$.

The Polymatroid Bound [5], PolyB, can use any $\ell_{p}$-norms of degree sequences to compute an upper bound on the size of the query output. The input statistics for PolyB are norms $||\texttt{deg}_{R}(V|U)||_{p}$, for a relation $R$, sets of attributes $U,V$ of $R$, and numbers¹⁴¹⁴14$p$ can be fractional. $p>0$. The system uses all available statistics to compute an upper bound on the query’s output. PolyB strictly generalizes both CB and the AGM bound. Its theoretical foundation lies in information inequalities, which we will review shortly, after presenting some examples of PolyB.

Examples To warm up, consider again the two-way join $J_{2}(X,Y,Z)=R(X,Y)\wedge S(Y,Z)$. The following upper bounds on the size of the query output hold:

	$\displaystyle|J_{2}|\leq$	$\displaystyle|R|\cdot|S|$		(13)
	$\displaystyle|J_{2}|\leq$	$\displaystyle|R|\cdot||\texttt{deg}_{S}(Z|Y)||_{\infty}$		(14)
	$\displaystyle|J_{2}|\leq$	$\displaystyle||\texttt{deg}_{R}(X|Y)||_{\infty}\cdot|S|$		(15)
	$\displaystyle|J_{2}|\leq$	$\displaystyle||\texttt{deg}_{R}(X|Y)||_{2}\cdot||\texttt{deg}_{S}(Z|Y)||_{2}$		(16)

The PolyB is the minimum of these four quantities¹⁵¹⁵15If all statistics consists of $\ell_{p}$-norms with $p$ an integer, or $p=\infty$, then the best bound on $J_{2}$ is the minimum of inequalities (14)-(16).. The first three inequalities are trivial (and were discussed in Sec. 4), while (16) follows from Cauchy-Schwartz.

Consider now the 3-way join $J_{3}(X,Y,Z,U)=R(X,Y)\wedge S(Y,Z)\wedge T(Z,U)$. PolyB includes all CB inequalities (see Eq. (12)) and new inequalities using $\ell_{p}$-norms, for example the following inequality holds for all $p\geq 2$:

	$\displaystyle|J_{3}|\leq$	$\displaystyle\big{(}|R|^{p-2}\cdot||\texttt{deg}_{R}(X|Y)||_{2}^{2}$
		$\displaystyle\cdot||\texttt{deg}_{S}(Z|Y)||_{p-1}^{p-1}\cdot||\texttt{deg}_{T}(U|Z)||_{p}^{p}\big{)}^{1/p}$		(17)

For example, assume that the system has computed the $\ell_{1},\ell_{2},\ell_{3}$ norms of all degree sequences, then it can compute the expression above for both $p=2$ and $p=3$, and take their minimum.

Considering the 3-cycle query in (8), the following inequalities hold:

	$\displaystyle|C_{3}|\leq$	$\displaystyle\left(|R|\cdot|S|\cdot|T|\right)^{1/2}$		(18)
	$\displaystyle|C_{3}|\leq$	$\displaystyle\left(||\texttt{deg}_{R}(Y|X)||_{2}^{2}\cdot||\texttt{deg}_{S}(Z|Y)||_{2}^{2}\cdot||\texttt{deg}_{T}(X|Z)||_{2}^{2}\right)^{1/3}$		(19)
	$\displaystyle|C_{3}|\leq$	$\displaystyle\left(||\texttt{deg}_{R}(Y|X)||_{3}^{3}\cdot||\texttt{deg}_{S}(Y|Z)||_{3}^{3}\cdot|T|^{5}\right)^{1/6}$		(20)

The first is the AGM bound; the others are new, and quite surprising. This list is not exhaustive: one can derive many more inequalities, using various $\ell_{p}$-norms. PolyB is the minimum of all of them (restricted to the available $\ell_{p}$-norms), and can be computed using a linear program, as explained later.

Inequalities (17)-(20) do not appear to have simple, elementary proofs. Instead, they are proven using Shannon inequalities.

Shannon Inequalities We review briefly Shannon Inequalities, which are special cases of entropic inequalities, or information inequalities, and show how to use them to prove the inequalities above.

Let $X$ be a finite random variable, with $N$ outcomes $x_{1},\ldots,x_{N}$, and probability function $\mathop{\textnormal{Pr}}$. Its entropy is defined as:¹⁶¹⁶16Usually $\log$ is in base 2, but any base can be used without affecting any results.

$\displaystyle h(X)\stackrel{{\scriptstyle\text{def}}}{{=}}$

$\displaystyle-\sum_{i}\mathop{\textnormal{Pr}}(x_{i})\log\mathop{\textnormal{Pr}}(x_{i})$

It holds that $0\leq h(X)\leq\log N$, and $h(X)=\log N$ iff $\mathop{\textnormal{Pr}}$ is uniform, i.e., $\mathop{\textnormal{Pr}}(x_{1})=\cdots=\mathop{\textnormal{Pr}}(x_{N})=1/N$.

Let $X_{1},\ldots,X_{n}$ be $n$ finite, jointly distributed random variables. For every subset $U$ of variables, $h(U)$ denotes the entropy of the joint random variables in $U$. For example, we have $h(X_{1}X_{3})$, $h(X_{2}X_{4}X_{5})$, etc. This defines an entropic vector, $\bm{h}$, with $2^{n}$ dimensions, one for each subset of variables. The following inequalities hold and are called Shannon basic inequalities (the second is called monotonicity and the third is called submodularity):

	$\displaystyle h(\emptyset)=$	$\displaystyle\ 0$
	$\displaystyle h(U\cup V)\geq$	$\displaystyle\ h(U)$
	$\displaystyle h(U)+h(V)\geq$	$\displaystyle\ h(U\cup V)+h(U\cap V)$

A vector $\bm{h}\in{\mathbb{R}}_{\tiny+}^{2^{n}}$ that satisfies Shannon basic inequalities is called a polymatroid. Every entropic vector is a polymatroid, but the converse does not hold in general [42].

We now have the tools needed to prove inequalities (17)-(20). We illustrate only (18), and defer the others to the Appendix. Consider three input relations $R,S,T$, and let $C_{3}$ denote the output to the query, i.e. $C_{3}(x,y,z)$ iff $R(x,y)$, $S(y,z)$, and $T(z,x)$. Define the uniform probability space on $C_{3}$: there are $|C_{3}|$ outcomes $(x,y,z)$, each with the same probability $1/|C_{3}|$. Let $\bm{h}\in{\mathbb{R}}_{\tiny+}^{8}$ be its entropic vector. Note that $h(XYZ)=\log|C_{3}|$, because the probability distribution is uniform, and $h(XY)\leq\log|R|$, because the support of the variables $XY$ is a subset of the relation $R$. Then the following inequalities hold, and imply (18):

	$\displaystyle\log|R|$	$\displaystyle+\log|S|+\log|T|\geq$
	$\displaystyle\geq$	$\displaystyle\underline{h(XY)+h(YZ)}+h(ZX)$
	$\displaystyle\geq$	$\displaystyle h(XYZ)+\underline{h(Y)+h(ZX)}$
	$\displaystyle\geq$	$\displaystyle 2h(XYZ)=2\log|C_{3}|$

We have applied Shannon submodularity inequality twice, and shown it by underlying the used terms.

Entropic Constraints To prove upper bounds that involve degree sequences, like (17), (19), (20), we need to relate their $\ell_{p}$-norms to the entropic vector.

Let $X_{1},\ldots,X_{n}$ be jointly distributed random variables, whose support is the finite relation $R(X_{1},\ldots,$ $X_{n})$. Let two sets of variables $U,V$. Let $\bm{h}$ be the entropic vector of the variables. The conditional entropy of $U,V$ is defined as $h(V|U)\stackrel{{\scriptstyle\text{def}}}{{=}}h(UV)-h(U)$.

The following was proven in [3], for any $p>0$:

$\displaystyle\frac{1}{p}h(U)+h(V|U)\leq$

$\displaystyle\log||\texttt{deg}_{R}(V|U)||_{p}$

(21)

When $p=1$, the inequality becomes $h(UV)\leq\log|\Pi_{UV}(R)|$, and when $p=\infty$, it becomes $h(Y|X)\leq\log||\texttt{deg}_{R}(V|U)||_{\infty}$. For a simple example, using (21) we can prove (16):

	$\displaystyle\log$	$\displaystyle||\texttt{deg}_{R}(X|Y)||_{2}+\log||\texttt{deg}_{S}(Z|Y)||_{2}\geq$
	$\displaystyle\geq$	$\displaystyle\left(\frac{1}{2}h(Y)+h(X|Y)\right)+\left(\frac{1}{2}h(Y)+h(Z|Y)\right)$
	$\displaystyle=$	$\displaystyle h(Y)+h(X|Y)+h(Z|Y)$
	$\displaystyle\geq$	$\displaystyle h(Y)+h(X|Y)+h(Z|XY)=h(XYZ)=\log|J_{2}|$

Inequalities (17)-(20) are proven similarly: we include them in Appendix B.

Computing PolyB So far, we introduced PolyB as the minimum bound that can be obtained from Shannon inequalities and entropic constraints (21). To compute it, we use an equivalent, dual definition, as the maximum value of a linear program (LP).

Suppose $Q$ has $n$ variables $X_{1},\ldots,X_{n}$. The LP has $2^{n}$ real-valued variables, $h(U)$, representing the unknown polymatroid vector $\bm{h}\in{\mathbb{R}}_{\tiny+}^{2^{n}}$. The objective is to maximize $h(X_{1}X_{2}\cdots X_{n})$, given two sets of linear constraints:

• •

  Statistics constraints: there is one inequality of type (21) for each available input statistics.

• •

  Shannon basic inequalities: the list of all submodularity and monotonicity inequalities.

PolyB is the optimal value of this linear program. Intuitively, we maximize $\log|Q|=h(X_{1}\cdots X_{n})$, while constraining $\bm{h}$ to be a polymatroid that satisfies all statistics (21).

We illustrate with an example, by showing the linear program for the query $C_{3}$ in (8):

$\displaystyle\begin{array}[]{|rl|l}\cline{1-2}\cr\cline{1-2}\cr&&\\ \vrule\lx@intercol\hfil\texttt{maximize }h(XYZ)\texttt{ subject to}\hfil\lx@intercol\vrule\lx@intercol&\\ &&\\ \cline{1-2}\cr\cline{1-2}\cr&&\\ h(XY)\leq&\log|R|&\text{cardinality}\\ h(XZ)\leq&\log|S|&\text{constraints}\\ \ldots&&\\ \frac{1}{2}h(X)+h(Y|X)\leq&\log||\texttt{deg}_{R}(Y|X)||_{2}&\text{Other $\ell_{p}$}\\ \frac{1}{3}h(X)+h(Y|X)\leq&\log||\texttt{deg}_{R}(Y|X)||_{3}&\text{constraints}\\ \ldots&&\\ \cline{1-2}\cr&&\\ h(X)+h(Y)\geq&h(XY)&\text{all Shannon}\\ h(XY)+h(XZ)\geq&h(X)+h(XYZ)&\text{inequalities}\\ \ldots&&\\ \cline{1-2}\cr\end{array}$

PolyB has several attractive properties. It strictly generalizes both CB and the AGM bound, which use only statistics given by $\ell_{1}$ and $\ell_{\infty}$. In addition, PolyB can also be used to estimate output sizes for queries with group-by (and select distinct) clauses; for this, we just need to adjust the objective of the linear program to refer to the entropic term for the group-by attributes. Access to more statistics is guaranteed to never make the bound worse; e.g., we can improve the bound if we decide to add the statistics $\ell_{3},\ell_{4},\ell_{5}$ in addition to $\ell_{1},\ell_{2},\ell_{\infty}$. The inference time is exponential in $n$, the number of query variables, but several special cases are known when it can be computed in PTIME [34, 26, 7] (see Sec. 10). Finally, when all statistics are restricted to simple degree sequences, then PolyB is provably tight, up to a query-dependent multiplicative rounding error,¹⁷¹⁷17The factor is $1/2^{2^{n}-1}$. similar to the AGM bound. Beyond simple degree sequences, the PolyB is not tight in general, due to the existence of non-Shannon inequalities [42, 37], but the only known non-tight examples are artificial and unlikely to occur in practice.

The Degree Sequence Bound [15, 16], DSB for short, was the first system that proposed to use degree sequences for PCE. DSB provides tighter bounds than both AGM and CB bounds, and an empirical evaluation [16] found it to be often tighter than density-based estimators, while always returning a guaranteed upper bound. Instead of using $\ell_{p}$-norms, DSB uses compressed representation of the degree sequences. We illustrate here DSB assuming access to the full degree sequence, and discuss compression in Sec. 10.

Consider the 2-way join $J_{2}(X,Y,Z)=R(X,Y)\wedge S(Y,Z)$, and assume that the degree sequences of $R.Y$ and $S.Y$ are:

$\displaystyle\texttt{deg}_{R}(*|Y)=$

$\displaystyle(a_{1},a_{2},\ldots)$

$\displaystyle\texttt{deg}_{S}(*|Y)=$

$\displaystyle(b_{1},b_{2},\ldots)$

Recall that the degree sequences are sorted, e.g. $a_{1}\geq a_{2}\geq\cdots$, and that the rank of a value $y$ in $R.Y$ is the index $i$ for which the degree of $y$ is $a_{i}$. If every value $y$ has the same rank in $R.Y$ and in $S.Y$, then the size of the join is precisely $|J_{2}|=\sum_{i}a_{i}b_{i}$. In general, the following inequality holds:

$\displaystyle|J_{2}|\leq$

$\displaystyle\sum_{i}a_{i}b_{i}$

(22)

This bound is a strict improvement over the chain bound (4), because $\sum_{i}a_{i}b_{i}\leq a_{1}\sum_{i}b_{i}=a_{1}|S|$, and similarly $\sum_{i}a_{i}b_{i}\leq|R|b_{1}$.

DSB enjoys several nice properties. It can be computed in linear time in the size of the compressed degree sequences; it is compositional, meaning that the estimate of a query plan can be computed bottom-up; given appropriate histograms (see Sec. 10) DSB is more accurate than density-based estimators [16]; finally, DSB is provably a tight upper bound of the query’s output. DSB also has a few limitations. It is limited to Berge-acyclic queries (see [17]), and its estimate is not given in terms of an inequality, like PolyB, but instead it is computed by an algorithm.

We discuss here some practical aspects that need to be considered by PCE, or have been considered in previous implementations of PCE [9, 24, 16, 7].

Statistics selection While a density-based estimator only stores the number of distinct values $|\textsf{Dom}(R.X)|$ of an attribute, PolyB can use multiple $\ell_{p}$-norms of various degree sequences $\texttt{deg}_{R}(V|U)$. A reasonable choice is to store, say, four numbers $\ell_{2},\ell_{3},\ell_{4},\ell_{\infty}$. We assume that $|R|$ is stored separately and do not include $\ell_{1}$. This means that the memory footprint increased by 4 times that of a density-based estimator. But, in general, it is not clear whether we want to stop at $\ell_{4}$. An implementation needs to choose which $\ell_{p}$ norms to precompute. Empirically, we have observed improvements of accuracy up to $\ell_{30}$ for JOB queries on the IMDB dataset, although with diminishing returns [7]. On the other hand, DSB compresses the degree sequence, and requires tuning the hyperparameters of the compression.

Computing the statistics All input statistics are computed offline. For example, the degree sequence $\texttt{deg}_{R}(*|X)$ can be computed using a group-by query:

$\displaystyle\texttt{SELECT }X,\texttt{COUNT(*)}\texttt{ FROM }R\texttt{ GROUP BY }X$

(23)

DSB sorts the query output, while PolyB computes all desired $\ell_{p}$-norms in one pass over this output.

Conditional statistics In order to improve the estimates of queries with predicates, a pessimistic estimator can adopt traditional techniques like Most Common Values (MCV) and histograms. Assume that the system decides to store the following global statistics for column $X$: $||\texttt{deg}_{R}(*|X)||_{p}$ for $p=2,3,4,\infty$, for a total of 4 numbers (recall that $\ell_{1}$ is the cardinality which we store anyway). To support equality predicates $A=a$ on some attribute $A$, the system computes additional conditional statistics:

• •

  For each value $a\in\Pi_{A}(R)$, compute the degree sequence $\texttt{deg}_{\sigma_{A=a}(R)}(*|X)$, which we denote by $\texttt{deg}_{R}(*|X,A=a)$:

  	$\displaystyle\texttt{CREATE TABLE }DS\texttt{ AS }\texttt{SELECT }A,X,$		(24)
  	$\displaystyle\texttt{COUNT(*)}\texttt{ as }C\texttt{ FROM }R\texttt{ GROUP BY }A,X;$

  Then, compute the $\ell_{p}$-norms of these degree sequences (shown only for $\ell_{2}$ below):

  	$\displaystyle\texttt{SELECT }A,(\texttt{SQRT}(\texttt{SUM}(C*C)))\texttt{ AS }L_{2}$		(25)
  	$\displaystyle\texttt{ FROM }DS\texttt{ GROUP BY }A;$

• •

  For each Most Common Value (MCV) $a$, store its $\ell_{p}$-norms in the catalog. Call these conditional MCV statistics. If we used $100$ MCVs (which is the default in Postgres), then these statistics consist of 400 numbers.

• •

  Compute the conditional common statistics, $\max_{a}||\texttt{deg}_{R}(*|X,A=a)||_{p}$, and add these 4 numbers to the catalog.

• •

  At estimation time, consider three cases. If the query does not have a predicate on $A$, then use the global statistics; if the predicate is $A=a$, where $a$ is an MCV, then use the corresponding conditional MCV statistics; otherwise use the conditional common statistics.

Histograms Histograms can further improve the accuracy. Continuing the example above, we partition the values of the attribute $A$ into buckets, and for each bucket store conditional common statistics: $\max_{a\in\texttt{Bucket}}||\texttt{deg}_{R}(*|X,A=a)||_{p}$. There are 4 numbers per bucket. To support range predicates we need to store in each bucket the value $||\texttt{deg}_{R}(*|X,A\in\texttt{Bucket})||_{p}$.

Boolean Expressions The most powerful advantage of pessimistic estimators is that the Boolean connectives $\wedge,\vee$ simply becomes $\min$ and $+$. For example, if the query contains predicate $R.A=a\wedge R.B=b$, then we use as statistics $\min(||\texttt{deg}_{R}(*|X,A=a)||_{p},||\texttt{deg}_{R}(*|X,B=b)||_{p})$; similarly, for $R.A=a\vee R.B=b$, we use¹⁸¹⁸18 We need to require $p\geq 1$, because Minkowski’s inequality $||\bm{a}+\bm{b}||_{p}\leq||\bm{a}||_{p}+||\bm{b}||_{p}$ only holds for $p\geq 1$. $+$. This principle extends to IN predicates (which are equivalent to $\bigvee$), and to LIKE predicates, which can be upper-bounded by a set of 3-grams, see [16].

Lossy Compression The complete degree sequence can be as large as the data, and therefore it is not usable as a statistic for cardinality estimation. Since DSB needs access to the entire degree sequence, it uses three observations to drastically reduce the size of the statistics. First, run-length compression is very effective on degree sequences: it compresses a sequence $\bm{a}=(a_{1}\geq a_{2}\geq\cdots)$ by replacing any constant subsequence $a_{i}=a_{i+1}=a_{i+2}=\cdots$ with the common value plus length. Second, DSB uses a lossy compression, replacing the original sequence $\bm{a}$ with $\bm{a}^{\prime}$ such that $\bm{a}\leq\bm{a}^{\prime}$ (element-wise) and the compression of $\bm{a}^{\prime}$ is much smaller: since the DSB is monotone in the input degree sequences, it still returns an upper bound when $\bm{a}$ is replaced with $\bm{a}^{\prime}$. However, since $||\bm{a}||_{1}<||\bm{a}^{\prime}||_{1}$ , the new sequence represents a relation with a larger cardinality. Instead, DSB upper bounds the CDF of the degree sequence, $A_{i}\stackrel{{\scriptstyle\text{def}}}{{=}}\sum_{j\leq i}a_{i}$, instead of the PDF. That is, it uses a degree sequence $\bm{a}^{\prime\prime}$ such that $\bm{A}\leq\bm{A}^{\prime\prime}$ where $A_{i}^{\prime\prime}=\sum_{j\leq i}a_{i}^{\prime\prime}$. It is no longer obvious why DSB is still an upper bound when it uses $\bm{a}^{\prime\prime}$: we give the main intuition in Appendix C. Fig. 3 illustrates this method. The original sequence, $\bm{a}=(4,2,2,1,1,1)$, can be compressed to $\bm{a}^{\prime}=(4,4,4,2,2,2)$, but the $\ell_{1}$ norm increased from 11 to 18. Instead, DSB upper bounds the CDF to $\bm{A}\leq\bm{A}^{\prime\prime}$, see the second graph. The degree sequence that produces $\bm{A}^{\prime\prime}$ is $\bm{a}^{\prime\prime}=(4,3.5,3.5,0,0,0)$: notice that $\bm{a}\not\leq\bm{a}^{\prime\prime}$, yet by using $\bm{a}^{\prime\prime}$ DSB still returns an upper bound.

Runtime of the Pessimistic Estimator The runtime of DSB is linear in the size of the compressed representation of all degree sequences. The runtime of PolyB is exponential in $n$ (the number of query variables, Eq. (6)), because the LP uses $2^{n}$ numerical variables. This is undesirable, but there are a few ways to mitigate this. First, when all statistics are for simple degree sequences (meaning of the form $\texttt{deg}_{R}(V|X)$, where $X$ is a single variable, or $X=\emptyset$), then PolyB can be computed in PTIME, by using a totally different LP, with $n^{2}$ numerical variables instead of $2^{n}$ [26, 7]; furthermore, we only need $O(n)$ numerical variables in case of Berge acyclic queries [7]. Restricting the pessimistic estimator to simple degree sequences is quite reasonable, because many current systems already restrict their statistics to a single attribute, e.g. they store $|\textsf{Dom}(R.X)|$, but rarely $|\textsf{Dom}(R.XY)|$. When multi-attribute statistics are needed, then there are a few ways to optimize the LP that computes PolyB. First, ensure that it includes only the elemental Shannon inequalities [41, Chap.14.1]: there are $n(n-1)2^{n-3}+n$ elemental inequalities. Second, drop unnecessary variables. For example, to compute the PolyB of a 2-way join $R(X,Y,Z,U,V)\Join S(V,W,K,L)$ it suffices to keep only one non-joining variable in each relation, i.e. simplify the query to $R(X,V)\Join S(V,W)$. Third, it is well known that creating the input for the LP solver often takes more time than the solver itself: to speedup the creation of the LP, the system can precompute and represent all elemental Shannon inequalities, since these depend only on $n$ and not on the query.

We return now to our wish list in Sec. 3 and examine how pessimistic cardinality estimators do or do not satisfy them. The main advantage of PCE’s is their one-sided guarantee. An application can count on the fact that the query output size will never exceed the PCE bound. The ability to provide a strong guarantee without any assumption is the main advantage of PCE over both traditional methods and ML-based methods. They are also local, in the sense that they only use statistics collected on each relation independently: if a new relation needs to be added to the database schema, then we only need to add statistics for that relation. This is similar to traditional CE’s, and different from estimators based on trained models, which need access to the entire database.

The next question is how accurate the PCE’s are. Only a few empirical evaluations have been done: for BoundSketch [9, 10, 35], DSB [16], and PolyB [7]. Out of the box, BoundSketch produces worse estimates than traditional estimators, however all implementations augment BoundSketch with hash-partitioning [9, 35], which improves the accuracy, but at the cost of increased memory and significantly increased construction and estimation time.¹⁹¹⁹19An improved partitioning is described recently in [14]. While BoundSketch uses only cardinalities and max degrees, DSB and PolyB use the complete degree sequences (under lossy compression) and norms on these degree sequences, respectively, and produce much better bounds with less memory and with small estimation time [16, 7]. What several implementations report is that, when the traditional estimator in Postgres is replaced by BoundSketch, DSB, or PolyB, the performance of expensive SQL improves, sometimes significantly, because it causes the optimizer to be more cautions in choosing an execution plan. Cheap queries, however, tend to suffer from a regression.

In general, the empirical evaluation of PCE’s is still very limited. Future research is needed to evaluate the impact of indices, on the essential query subexpressions, or of bitmap filtering, see [29] for an extensive discussion of the impact of the cardinality estimator on the query optimizer.

Moving down on our wish list, we note that DSB is compositional; in fact the algorithm computing DSB [15, 16] is defined by recursion on the structure of a Berge-acyclic query. On the other hand, PolyB is not compositional. This appears to be unavoidable for cyclic queries, which do not admit a recursive definition. For example, computing the upper bounds on the join $R\Join S$ does not help us in deriving the bound $\left(|R|\cdot|S|\cdot|T|\right)^{1/2}$ of the 3-cycle $C_{3}$ (Eq. (18)). An open question is whether PolyB can be made compositional on (Berge-) acyclic queries.