[ieee 22nd international conference on data engineering (icde'06) - atlanta, ga, usa...

Laws for Rewriting Queries Containing Division Operators

Ralf RantzauIBM Almaden Research Center

650 Harry Road, San Jose, CA 95120, [email protected]

Christoph MangoldUniversitat Stuttgart

Universitatsstraße 38, 70569 Stuttgart, [email protected]

Abstract

Relational division, also known as small divide, is aderived operator of the relational algebra that realizes amany-to-one set containment test, where a set is repre-sented as a group of tuples: Small divide discovers whichsets in a dividend relation contain all elements of the setstored in a divisor relation. The great divide operator ex-tends small divide by realizing many-to-many set contain-ment tests. It is also similar to the set containment joinoperator for schemas that are not in first normal form.

Neither small nor great divide has been implemented incommercial relational database systems although the op-erators solve important problems and many efficient algo-rithms for them exist. We present algebraic laws that al-low rewriting expressions containing small or great divide,illustrate their importance for query optimization, and dis-cuss the use of great divide for frequent itemset discovery,an important data mining primitive.

A recent theoretic result shows that small divide must beimplemented by special purpose algorithms and not be sim-ulated by pure relational algebra expressions to achieve ef-ficiency. Consequently, an efficient implementation requiresthat the optimizer treats small divide as a first-class opera-tor and possesses powerful algebraic laws for query rewrit-ing.

1 Introduction

In this section, we motivate our work, give an intuition ofthe small and great divide operators, and outline the paper.

1.1 Problem Statement and Main Results

The division operator can be used to answer queriesinvolving universal quantification like “Find the suppliersthat supply all blue parts.” Division is a derived operatorlike join, that is, it can be expressed by the basic algebraoperators projection, selection, Cartesian product (some-times called cross-product), union, and difference. How-ever, several algorithms exist that realize its behavior moreefficiently than an execution plan based on the basic op-erators [14]. More importantly, recent theoretic work hasdemonstrated that division must be implemented as a stand-alone operator to achieve efficiency [24].

The small divide operator has two input relations, thedividend and the divisor. The dividend is composed of zeroor more groups of tuples and each group is matched againstall tuples of the divisor relation. The great divide is a natu-ral extension of small divide, where the divisor can be com-posed of zero or more groups of tuples like the dividend. Ittests each divisor group against each dividend group.

What is the role of algebraic laws for query optimiza-tion? Before a query is executed by the query execu-tion engine of a relational database management system(RDBMS), the query optimizer rewrites the algebraic rep-resentation of the query according to transformation rules.Typically, one type of transformation rules is based on alge-braic laws and the other maps logical operators to a physicaloperators. For instance, the logical operator join is mappedto the physical operator hash-join.

An algebraic law is a logical equivalence between twodifferent representations of an algebraic expression. Bothrepresentations describe the same set of tuples for everypossible database content. Together with heuristics and/orcost estimations, the optimizer applies transformation rulesto subexpressions of the query such that the entire querycan be evaluated with the minimal resource consumptionor the shortest response time. Algebraic laws for the basicoperators of the relational algebra are discussed, for exam-ple, in [13, 23]. The implementation of transformation rules(rewrite rules) in a commercial RDBMS are described, forexample, in [25, 30]. Frameworks for building query opti-mizers, like Cascades [15] and XXL [3], allow to study thecode that is required to realize transformation rules in anRDBMS.

To the best of our knowledge, no commercial RDBMShas an implementation of relational division. One reason isthat there is no keyword in the SQL standard that wouldallow to express universal quantification (that is, the all-quantifier) intuitively. Another reason is that set contain-ment tests are not considered as important as the existentialelement test that is realized by the join operator. However,special applications like frequent itemset discovery couldbe processed efficiently and formulated more intuitively ifdivision would be a first-class operator. Suppose that anRDBMS offers one or more efficient implementations of di-vision, that is, physical division operators like hash-divisionor merge-sort division [16, 35]. Since division is a derivedoperator, an optimizer could replace the division operator byan expression that simulates the operator and apply transfor-mation rules on the basic operators in the expression. In ad-dition, it should also be able to apply rewrite rules to the di-vision operator directly since efficient implementations are

Proceedings of the 22nd International Conference on Data Engineering (ICDE’06) 8-7695-2570-9/06 $20.00 © 2006 IEEE

a b

1 1

1 4

2 1

2 2

2 3

2 4

3 1

3 3

3 4

(a) r1 (dividend)

b

1

3

(b) r2 (divisor)

a

2

3

(c) r3 (quotient)

Figure 1. Division: r1 ÷ r2 = r3

available in the query execution engine.The algebraic laws presented in this paper either preserve

the division operator (it occurs in the both expression of theequivalence) or produce some non-trivial rewrite result thatmay improve efficiency of the computation in an RDBMS.Note that there are an infinite number of equivalent expres-sions for any given algebraic expression. We have tried todistill effective and interesting laws for rule based optimiz-ers.

No previous work has covered the rewriting of queriesinvolving division or generalized division although data-intensive applications like frequent itemset discovery wouldbenefit from a division syntax in SQL and an efficient im-plementation of the operator in a query execution engine.

1.2 Outline

The remainder of this paper is organized as follows. Inthe following section, we discuss several definitions for thesmall and great divide, which are used in the proofs of thelaws. In Section 3, we motivate the potential of the greatdivide for an important data mining primitive. In Section 4,we suggest a hypothetical SQL syntax extension for the op-erators before we present the algebraic laws in Section 5.Section 6 discusses related work. We conclude the paperin Section 7. Due to lack of space, the proofs of theoremsand algebraic laws are given in the appendix of technicalreport [34], where they are presented in sufficient detail tomake them easy to comprehend.

2 The Division Operator

We will discuss the original division operator as well as ageneralization of it, which was given three different namesin previous work. After this section, we will refer to the twooperators as small divide and great divide for the rest of thispaper.

2.1 The Small Divide

Let R1(A ∪ B) and R2(B) be relation schemas, whereA = {a1, . . . , am} and B = {b1, . . . , bn} are nonemptydisjoint sets of attributes. Let r1(R1) and r2(R2) be re-lations on these schemas. We call r1 the dividend, r2the divisor, and r3 the quotient of the division operationr1 ÷ r2 = r3. The schema of r3 is R3(A). Figure 1 il-lustrates example input and output relations of the divisionoperator.

The original definition of the division operator was givenby Codd [10], formulated as a query in tuple relational cal-culus:

DEFINITION 1 (CODD’S DIVISION): r1 ÷ r2 ={t | t = t1.A ∧ t1 ∈ r1 ∧ r2 ⊆ ir1

(t)}, where ir1(x) is

called the image set of x under r1 and is defined byir1

(x) = {y | (x, y) ∈ r1}

In this calculus expression, the term t = t1.A means that atuple in the result (quotient) consists of the attribute valuesfor A of the dividend tuple t1.

In the following, we give two further equivalent defini-tions of division, provided by Healy and Maier in [26] usingrelational algebra.1 We use Codd’s, Healy’s, and Maier’sdefinitions for the proofs of our algebraic laws.

DEFINITION 2 (HEALY’S DIVISION): r1÷r2 = πA (r1)−πA ((πA (r1) × r2) − r1)

DEFINITION 3 (MAIER’S DIVISION): r1 ÷ r2 =⋂t∈r2

πA (σB=t (r1))

In [11], the basic division operator was called small di-vide to distinguish it from a generalization of it, called greatdivide, to be discussed next.

2.2 The Great Divide

Before we discuss three equivalent definitions of an ex-tended division operator, we briefly consider another op-erator related to them: the set containment join. LetR1(A ∪ B1), R2(B2 ∪ C), and R3(A ∪ B1 ∪ B2 ∪ C)be relation schemas, where A = {a1, . . . , am}, B1 = {b1},B2 = {b2}, and C = {c1, . . . , cp} are attribute sets, A andC are disjoint and may be empty, B1 and B2 are disjointand nonempty, A and B1 are disjoint, and B2 and C aredisjoint. Note that the sets B1 and B2 consist of a singleset-valued attribute, respectively. Let r1(R1), r2(R2), andr3(R3) be relations on these schemas. The set containmentjoin r1 ��b1⊇b2 r2 = r3 is a join between the set-valuedattributes b1 and b2, where we ask for the combinations oftuples t1 ∈ r1 and t2 ∈ r2 such that set t1.b1 contains all el-ements of set t2.b2. Several efficient algorithms and strate-gies for realizing this operator in an RDBMS have been pro-posed [18, 28, 29, 31, 32].

We have recently suggested a generalization of divisionthat we called set containment division, denoted by ÷∗

1,because of its similarity to the set containment join [35].Let R1(A ∪ B), R2(B ∪ C), and R3(A ∪ C) be relationschemas, where A = {a1, . . . , am}, B = {b1, . . . , bn}, andC = {c1, . . . , cp} are nonempty sets of attributes, A and Bare disjoint, and B and C are disjoint. Let r1(R1), r2(R2),

1Another algebraic definition given in the literature isr1 ÷ r2 = ((r1 � r2) �� r2)�r2 [9], where semi-join (�),anti-semi-join (�), and left outer join (��) are used. An indirectapproach based on counting was discussed in [16], where GγF (r1)is the grouping operator [13], G is a list of r1’s attributes andF is a list of aggregation functions applied to an attribute of r1:r1 ÷ r2 = πA

`Aγcount(B)→c (r1 � r2) �� γcount(B)→c (r2)

´.

A definition in tuple relational calculus is r1 ÷ r2 ={t | ∀t2 ∈ r2∃t1 ∈ r1 : t = t1.A ∧ t1.B = t2.B} [11]. A def-inition mixing tuple relational calculus with relational algebra isr1 ÷ r2 = {t ∈ πA(r1) | (t) �� r2 ⊆ r1} [1].


a b

1 1

1 4

2 1

2 2

2 3

2 4

3 1

3 3

3 4

(a) r1 (dividend)

b c

1 1

2 1

4 1

1 2

3 2

(b) r2 (divisor)

a c

2 1

2 2

3 2

(c) r3 (quotient)

Figure 2. Generalized division: r1 ÷∗ r2 = r3

a b1

1 {1, 4}

2 {1, 2, 3, 4}

3 {1, 3, 4}

(a) r1

b2 c

{1, 2, 4} 1

{1, 3} 2

(b) r2

a b1 b2 c

2 {1, 2, 3, 4} {1, 2, 4} 1

2 {1, 2, 3, 4} {1, 3} 2

3 {1, 3, 4} {1, 3} 2

(c) r3

Figure 3. Set containment join: r1 ��b1⊇b2 r2 =r3

and r3(R3) be relations on these schemas. Although we de-fine a new operator, we continue to use the terms dividend,divisor, and quotient for the relations r1, r2, and r3, respec-tively. The dividend relation r1 has the same schema as forthe small divide. However, the divisor relation r2 has addi-tional attributes C. The set containment division operator isdefined as follows:

DEFINITION 4 (SET CONTAINMENT DIVISION):r1 ÷∗

1 r2 =⋃

t∈πC(r2) (r1 ÷ πB (σC=t (r2))) × (t)

The idea is to iterate over the groups defined by the at-tributes r2.C. Each group is a separate divisor for a divi-sion with dividend r1. We “attach” the divisor group valueto the resulting quotient tuples by a Cartesian product be-tween each quotient group and a one-tuple relation (t).

The similarity between set containment division and setcontainment join can be seen by comparing Figures 2 and 3.Despite the similarity of the output, the operators have somesubtle differences:

1. The input relations of set containment join are not infirst normal form due to the set-valued attributes.

2. Set containment division does not preserve the “join”attributes in B.

3. Set containment join allows empty sets as join attributevalues whereas set containment division does not havethe notion of an empty set.

4. The attribute sets A and C of the set containment joinmay be empty.

Despite these differences, the operators both solve the sameproblem—to find those pairs of sets (s1, s2) from two col-lections of sets where s1 ⊇ s2.

In 1982, Robert Demolombe suggested a generalized di-vision operator, denoted by ÷∗

2, that is equivalent (see The-orem 1 below) to set containment division [12]. Besidesa definition of the operator in tuple relational calculus andpredicate calculus, he gives an algebraic definition:

DEFINITION 5 (GENERALIZED DIVISION):r1 ÷∗

2 r2 = (πA (r1) × πC (r2)) −πA∪C ((πA (r1) × r2) − (r1 × πC (r2)))

In 1988, Stephen Todd suggested—presumably indepen-dent from Demolombe—a generalized division operator buthe did not publish it himself. However, it has been discussedby Darwen and Date [11], where it was called great divide,denoted by ÷∗

3. A definition in relational algebra is givenby the following expression:

DEFINITION 6 (GREAT DIVIDE): r1 ÷∗3 r2 =

(πA (r1) × πC (r2))− πA∪C ((πA (r1) × r2) − (r1 �� r2))

Definition 6 differs only slightly from Definition 5 of gen-eralized division. It uses a join instead of a Cartesian prod-uct. Darwen and Date write that great divide degenerates tosmall divide, as specified in Definition 2, if C = ∅ [11]. Westate the following theorem:

THEOREM 1: Set containment division (÷∗1), generalized

division (÷∗2), and great divide (÷∗

3) are equivalent opera-tors.

The three definitions have been suggested independently.However, while the publications on generalized divi-sion [12] and great divide [11] solely focus on the rela-tionship between the logical operator and the basic divisionoperator, our previous work on the set containment divi-sion operator [33, 35] put its emphasis on algorithms thatimplement physical operators and investigated applicationsfor this operator. In the rest of the paper, we will use De-molombe’s term generalized division and use the symbol÷∗ for the operator.

3 Frequent Itemset Discovery: An Applica-tion of Great Divide

Frequent itemset discovery is an important data min-ing subtask of association rule discovery algorithms [2]. Itsearches for combinations of elements that occur more fre-quently in a large amount of sets, called transactions, than auser-defined threshold, called minimum support. Most fre-quent itemset discovery algorithms such as Apriori proceediteratively. In the kth iteration, the algorithm computes allfrequent itemsets of size k. The first iteration simply countsthe frequency of each item in the transactions, filters outthose that have insufficient support, and adds the frequentones to the result. Each of the following iterations is two-phase. In the candidate generation phase of the kth iter-ation, the algorithm computes a superset of the frequentitemsets of size k, called candidate k-itemsets. In the sup-port counting phase, the candidate k-itemsets are probedagainst the transactions to check how many times a candi-date is contained in a transaction. The itemsets that occurmore frequently than the minimum support are added to theresult.

Suppose, we want to discover frequent itemsets us-ing an RDBMS. Let us focus on the support count-ing phase. For instance, given a table of transactionstransactions(tid, item) and a table of candidate itemsetscandidates(itemset, item), where itemset is a set identifierand item is an item identifier. A query-based frequent item-


set discovery algorithm can compute a quotient table con-taining value pairs (transactions.tid, candidates.itemset)such that the item values belonging to candidates.itemsetare contained in the set of items belonging to transac-tions.tid. This test is exactly the behavior of the great di-vide operator: quotient = transactions÷∗ candidates. Notethat this computation does not require the candidate item-sets to have the same size k. The frequent itemsets can thenbe found by grouping the quotient table on itemset, count-ing the tid values per group, and discarding the groups withinsufficient support.2

4 Embedding the Operators into SQL

In this section, we present a straightforward hypotheticalsyntax for the small and great divide operator in SQL andillustrate how these operators can be used for real queries.We will use a more straightforward example problem do-main for the queries than in the previous section, namelythe suppliers and parts scenario from database textbooks.

In the SQL standard [21], a production rule is definedfor table references, which occur in the FROM clause of aquery expression. We extend this clause by a nonterminal〈quotient〉 as follows:3

<table reference> ::= <table factor> |<joined table> |<quotient>

Without going into every detail of the SQL standard, thisrule states that a table can be a base table, derived table,named query, etc., or the result of a join expression or theresult of a division operation. We specify the following rulefor expressions involving the small and great divide opera-tors:

<quotient> ::= <table reference>DIVIDE BY<table reference>ON <search condition>

We illustrate the syntax using an example using asupplier-parts database with a table supplies(s#, p#) thatlists the parts (p#) supplied by each supplier (s#) and a ta-ble parts(p#, color). The following query delivers for eachcolor the suppliers who supply all parts with that color:4

Q1: SELECT s#, colorFROM supplies AS s DIVIDE BY parts AS p

ON s.p# = p.p#

Note that we do not distinguish between the small andgreat divide on the language level. The great divide is a nat-ural generalization of the small divide and can always beused on the implementation/execution level. The 〈quotient〉

2The idea of using a “vertical” representation for itemsets in the sameway as for transactions that we just described was discussed in [35]. It isdifferent from all SQL-based approaches of frequent itemset discovery inthe literature as, for example, in [20, 36, 37].

3shown in extended Backus Normal Form (BNF) as in [22].4We actually ask only for those suppliers who supply at least one part,

that is, those s# values in a suppliers(s#, . . . ) table, where there exists atuple in the supplies table with that s# value. This is a slight semanticdifference between set containment join and great divide, as mentioned inSection 2.2.

construct is equivalent to a small divide if all divisor at-tributes appear in the join condition of the ON clause as aconjunction5 of equi-joins. An example use of small divideis the query “Find the suppliers that supply all blue parts”that was mentioned in Section 1.1, which can be formulatedas follows:

Q2: SELECT s#FROM supplies AS s DIVIDE BY (

SELECT p#FROM partsWHERE color = ’blue’) AS p

ON s.p# = p.p#

Concerning the power of the suggested SQL syntax, onecould allow a more general join condition than equi-joinsbetween columns in the ON clause. However, the resultof such a query would have a semantics that is completelydifferent from small or great divide. We suggest to disallowthis case. If such a different behavior is required, a user canstill formulate the problem using other, basic operators ofthe SQL syntax.

We contrast query Q1 with an equivalent query that sim-ulates the universal quantification by two “NOT EXISTS”clauses, applying the mathematical equivalence between∀x∃y : p(x, y) and ¬∃x¬∃y : p(x, y), where p is a predi-cate involving variables x and y:

Q3: SELECT DISTINCT s#, colorFROM supplies AS s1, parts AS p1WHERE NOT EXISTS (

SELECT *FROM parts AS p2WHERE p2.color = p1.color AND

NOT EXISTS (SELECT *FROM supplies AS s2WHERE s2.p# = p2.p# AND

s2.s# = s1.s#))

A direct translation of this query asks for each supplier andcolor whether there is no part of the same color that is notsupplied by the supplier. We use the keyword DISTINCTin the outermost SELECT clause to remove duplicates fromthe result. Otherwise, we would get the same (s#, color)value combination as many times as there are parts of thesame color in parts.

Clearly, the query using a special syntax for the set con-tainment problem is more concise and hence (likely) lesserror-prone to formulate than the query based on existen-tial quantifications. Furthermore, it is not simple to devise aquery-rewriting algorithm for a query optimizer that is ableto detect those existential quantification constructs that canbe replaced by a (great) divide operator. Only if the appro-priate joins between inner and outer query are present doesthe query solve a real set containment problem.

5 Algebraic Laws

Some of the algebraic laws discussed in this section arebased on the notion of a partitioned relation. We use thefollowing notations for partitions:

5For tables r1 and r2 with schemas R1(a, b, c) and R2(b, c), respec-tively, we would use a query like SELECT a FROM r1 DIVIDE BYr2 ON r1.b = r2.b AND r1.c = r2.c.


a b

1 1

1 4

2 1

2 2

2 3

2 4

3 1

3 3

3 4

4 1

4 3

(a) r1

b

1

3

4

(b) r2

b

1

3

(c) r′2

b

3

4

(d) r′′2

a

2

3

4

(e) r1 ÷ r′2

a b

2 1

2 2

2 3

2 4

3 1

3 3

3 4

4 1

4 3

(f) r1 � (r1 ÷ r′2)

a

2

3

(g) r3

Figure 4. An example for Law 1

• r′i and r′′i denote nonempty horizontal partitions of re-lation ri such that r′i ∪ r′′i = ri, where i ∈ {1, 2},that is, we define a decomposition of ri’s tuples. Thetwo partitions may actually be different relations. Wejust express by this notation that two relations have thesame schema.

• r∗i and r∗∗i denote relations that conform to theschemas of the vertical partitions R∗

i and R∗∗i of Ri,

respectively, such that R∗i ∪ R∗∗

i = Ri, where i ∈{1, 2}. Hence, we define a decomposition of Ri’s at-tributes.

For the laws that follow, we will indicate when we re-quire partitions to be disjoint or not. The proofs of the lawsand theorems can be found in [34].

Before we present the laws, we state two theorems thatemphasize that this binary operator is clearly asymmetric.

THEOREM 2: Small divide is non-commutative, that is,r1 ÷ r2 �= r2 ÷ r1 for relations r1 and r2.

THEOREM 3: Small divide is non-associative, that is, r1 ÷(r2 ÷ r3) �= (r1 ÷ r2) ÷ r3 for nonempty relations r1, r2,and r3.

5.1 Algebraic Laws for the Small Divide

5.1.1 Union

When the divisor r2 is decomposed into horizontal parti-tions then one can divide by these divisors separately:

LAW 1: r1 ÷ (r′2 ∪ r′′2 ) = (r1 � (r1 ÷ r′2)) ÷ r′′2 .

This law holds also for overlapping divisor partitions, asillustrated in the example in Figure 4. In this example, ther′2 and r′′2 have one tuple in common with value b = 3. Theresulting relation r3 is the same if the table (a) is dividedby the union of tables (c) and (d) compared to dividing (f)by (d).

It can help an RDBMS to employ pipeline parallelism asfollows. Suppose, r1 is grouped on A. We can employ effi-cient group-preserving algorithms for the inner small divide

a b

1 1

1 2

1 3

(a) r′1

a b

1 2

1 4

(b) r′′1

b

1

4

(c) r2

Figure 5. An example where the preconditionof Law 2 is not fulfilled

r1 ÷ r′2 as well as the semi-join and deliver the result as thedividend to the outer small divide, which can be realized bya group-preserving algorithm itself.

When we decompose the dividend horizontally insteadof the divisor, we must take care of the situation sketched inFigure 5. There is a quotient candidate value (a = 1) whosetuples are dispersed across the dividend relations but noneof the groups contains all values of the divisor. However,the union of the groups does. In other words, r′1 ÷ r2 = ∅and r′′1 ÷r2 = ∅ but (r′1∪r′′1 )÷r2 �= ∅. We have to excludethis situation in the precondition of Law 2. Formally, thefollowing precondition must hold:

c1(r′1, r

′′1 ) ≡ ∀a ∈ πA(r′1) ∩ πA(r′′1 ) :

r2 ⊆ πB (σA=a (r′1))∨

r2 ⊆ πB (σA=a (r′′1 ))∨

r2 �⊆ πB (σA=a (r′1) ∪ σA=a (r′′1 ))

LAW 2: If condition c1 (r′1, r′′1 ) is true then (r′1 ∪ r′′1 ) ÷

r2 = (r′1 ÷ r2) ∪ (r′′1 ÷ r2).

Since testing condition c1 can be expensive, an RDBMSmay use a stricter condition c2 that is easier to check:

c2(r′1, r

′′1 ) ≡ πA (r′1) ∩ πA (r′′1 ) = ∅.

It can be shown easily that for any relations r1 = r′1 ∪ r′′1and r2 as defined before, if c2 holds then also c1 holds. Byusing condition c2 instead of c1 with Law 2, an RDBMScan parallelize a query execution with degree 2 as follows.Suppose that the query execution engine can access the datain table r1 via an index on A. We can employ two parallelscans on table r1: one that starts with the lowest value ofA and scans the leaves of the index in ascending order ofA and another that starts with the highest value of A andretrieves data in descending order of A. Both scans stop assoon as they encounter the same value for A. Exactly oneof them has to process the entire last group. Higher degreesof parallelism can be achieved by partitioning r1 into n > 2partitions.

5.1.2 Selection

Let p(X) denote a predicate involving only elements of aset of attributes X . Since only r1 contains the attribute setA, we can state the following “selection push-down” law:

LAW 3: σp(A) (r1 ÷ r2) = σp(A) (r1) ÷ r2.

For a predicate that involves only attributes in B, the fol-lowing “replicate-selection” law holds:


a b

1 1

1 4

2 1

2 2

2 3

2 4

3 1

3 3

3 4

4 1

4 3

(a) r1

a b

1 1

2 1

2 2

3 1

4 1

(b) σb<3 (r1)

b

1

3

4

(c) r2

b

1

(d) σb<3 (r2)

a

(e) σb<3 (r1) ÷ r2

a

1

2

3

4

(f) σb<3 (r1) ÷ σb<3 (r2)

a b

1 3

1 4

2 3

2 4

3 3

3 4

4 3

4 4

(g) πa (r1) × σb≥3 (r2)

a

1

2

3

4

(h) πa

`πa (r1) × σb≥3 (r2)

´

a

(i) (σb<3 (r1) ÷ σb<3 (r2)) − πa

`πa (r1) × σb≥3 (r2)

´

Figure 6. An illustration for Example 1

LAW 4: r1 ÷ σp(B) (r2) = σp(B) (r1) ÷ σp(B) (r2).

As a third example of selection conditions, we will nowanalyze the case where there’s a restriction specified on div-idend attributes in B, only.

EXAMPLE 1:

σp(B) (r1) ÷ r2 =(σp(B) (r1) ÷ σp(B) (r2)

)−

πA

(πA (r1) × σ¬p(B) (r2)

).

This expression is very similar to Law 4. We only haveto take care of the situation where σ¬p(B) (r2) �= ∅. In thiscase, the expression σp(B) (r1)÷r2 is equal to the empty setbecause no dividend tuple has a value of B that can matcha tuple in σ¬p(B) (r2). Hence, if σ¬p(B) (r2) contains atleast one tuple, we can enforce that the result relation beempty by simply removing all A values in r1 from the quo-tient candidates in σp(B) (r1) ÷ σp(B) (r2). The Cartesianproduct is merely used to “switch” πA (r1) “on or off.”6

Figure 6 illustrates the example and exhibits the inter-mediate results in detail. The predicate on the B columns isdefined as b < 3. Note that the result tables (e) and (i) areboth empty since table (h) is nonempty.

To make our argumentation clearer, we could rewrite ourexpression as follows: Since our equivalence represents arather extreme case, we do not state it as a law but leave itas an example. �

6Of course, it would suffice to combine πA(r1) with only a singletuple of σ¬p(B) (r2) by the Cartesian product.

5.1.3 Intersection

We can push small divide into intersections of dividend re-lations.

LAW 5: (r′1 ∩ r′′1 ) ÷ r2 = (r′1 ÷ r2) ∩ (r′′1 ÷ r2) .

5.1.4 Difference

The following law can be used when we perform two re-stricted scans over the same dividend relation where bothrestrictions are defined only on the attributes in A. For ex-ample, r′1 = σa>10(r1) and r′′1 = σa>20(r1). In this case,we can push small divide into a difference of the dividendrelations:

LAW 6: If r′1 = σp′(A)(r1) ⊇ σp′′(A)(r1) = r′′1 then(r′1 − r′′1 ) ÷ r2 = (r′1 ÷ r2) − (r′′1 ÷ r2).

For a similar law, we require as precondition that πA (r′1)and πA (r′′1 ) are disjoint.7

LAW 7: If πA (r′1) ∩ πA (r′′1 ) = ∅ then (r′1 ÷ r2) −(r′′1 ÷ r2) = r′1 ÷ r2.

Clearly, this law can save a lot of resources of anRDBMS if the computation of r′′1 ÷ r2 would be expen-sive. For example, suppose that A consists of a sin-gle integer attribute with values [1..106] and the query is(σa≤10(r1)÷ r2)− (σa>10(r1)÷ r2). Computing only thefirst part of the difference is inexpensive.

5.1.5 Cartesian Product

Let A1 and A2 be disjoint subsets of the attribute set A suchthat A1∪A2 = A. Let r∗1 be a relation with schema R∗

1(A1)and r∗∗1 be a relation with schema R∗∗

1 (A2 ∪ B). As usual,let R2(B) be the schema of the divisor r2. Then it sufficesto apply the small divide only to some of the attributes ofthe dividend:

LAW 8: (r∗1 × r∗∗1 ) ÷ r2 = r∗1 × (r∗∗1 ÷ r2).

Figure 7 illustrates Law 8 with an example. The law canhelp when the query optimizer finds that a predicate θ of atheta-join ��θ is always true since ��true≡ ×.

Let B1 and B2 be disjoint nonempty subsets of the at-tribute set B such that B1 ∪ B2 = B. Let r∗1 be a relationwith schema R∗

1(A∪B1) and r∗∗1 be a relation with schemaR∗∗

1 (B2). Again, let R2(B) be the schema of the divisor r2.Then, we can state the following

LAW 9: If πB2(r2) ⊆ r∗∗1 then (r∗1 × r∗∗1 ) ÷ r2 = r∗1 ÷

πB1(r2).

Figure 8 illustrates Law 9 with an example. All intermediaterelations are shown. Note that the Cartesian product (d)does not necessarily have to be materialized by an RDBMSprovided that the implementation of the subsequent smalldivide can cope with pipelined input. The same holds for

7This is not the weakest precondition. For the the law to hold,it would suffice to require that ∀a ∈ σA=a

`πA

`r′1

´ ∪ πA

`r′′1

´´:

r2 ⊆ σA=a

`πA

`r′1

´´ ∨ r2 ⊆ σA=a

`πA

`r′′1

´´ ∨ r2 ⊆σA=a

`πA

`r′1

´ ∪ πA

`r′′1

´´. However, we prove the law only for the

stronger precondition πA

`r′1

´ ∩ πA

`r′′1

´= ∅.


a1

1

2

(a) r∗1

a2 b

1 1

1 2

1 3

2 1

2 3

3 2

3 3

(b) r∗∗1

b

2

3

(c) r2

a1 a2 b

1 1 1

1 1 2

1 1 3

1 2 1

1 2 3

1 3 2

1 3 3

2 1 1

2 1 2

2 1 3

2 2 1

2 2 3

2 3 2

2 3 3

(d) r∗1 × r∗∗1

a2

1

3

(e) r∗∗1 ÷ r2

a1 a2

1 1

1 3

2 1

2 3

(f) r3


a b1

1 1

1 2

1 3

2 2

2 3

3 1

3 3

3 4

(a) r∗1

b2

1

2

(b) r∗∗1

b1 b2

1 2

3 1

3 2

(c) r2

a b1 b2

1 1 1

1 1 2

1 2 1

1 2 2

1 3 1

1 3 2

2 2 1

2 2 2

2 3 1

2 3 2

3 1 1

3 1 2

3 3 1

3 3 2

3 4 1

3 4 2

(d) r∗1 × r∗∗1

b1

1

3

(e) πB1(r2)

b2

1

2

(f) πR∗∗1

(r2)

a

1

3

(g) r3


the Cartesian product on the left hand side of Law 8 thatwas illustrated in 7(d).

EXAMPLE 2: With the help of Law 9 we can prove that(r1 × s) ÷ (r2 × s) = r1 ÷ r2. Let B = B1 ∪ B2. Wehave R∗

1(A ∪ B1), R∗∗1 (B2), R∗

2(B1), R∗∗2 (B2) and thus

R1(A∪B1 ∪B2) as the dividend schema and R2(B1∪B2)as the divisor schema. We define s = r∗∗1 = r∗∗2 . Thecondition r∗∗1 ⊆ πR∗∗

1(r2) is fulfilled since r∗∗1 = r∗∗2 =

πR∗∗2

(r2) = πR∗∗1

(r2). Hence, we have

(r∗1 × s) ÷ (r∗2 × s)

= (r∗1 × r∗∗1 ) ÷ (r∗2 × r∗∗2 ) (Definition of s)

= (r∗1 × r∗∗1 ) ÷ r2 (Definition of R2)

= r∗1 ÷ πB1(r2) (Law 9)

= r∗1 ÷ r∗2 (Definition of R2)

5.1.6 Join

Join, like small divide, is a derived operator. When a smalldivide operator occurs together with a join operator in anexpression, it may be beneficial for the execution strategyof an RDBMS to rewrite the join operator and subsequentlyapply algebraic laws to rewrite the result in combinationwith small divide. The laws involving the selection operatorin Section 5.1.2 as well as the laws concerning the Cartesianproduct in Section 5.1.5 can be used to rewrite expressionsinvolving join and small divide, since r ��θ s = σθ(r × s),where ��θ is a theta-join with the condition θ. The followingexample illustrates such a rewrite.

EXAMPLE 3: Let r∗1 , r∗∗1 , and r2 be relations with schemasR∗

1(a, b1), R∗∗1 (b2), and R2(b1, b2), respectively. Further-

more, let r∗∗1 .b2 be a unique attribute and let r2.b2 be a for-eign key that references r∗∗1 , that is, πb2 (r2) ⊆ r∗∗1 . Sup-pose, we want to compute relation r3 = (r∗1 ��b1<b2 r∗∗1 )÷r2. We can derive the following expressions:

r3 = (r∗1 ��b1<b2 r∗∗1 ) ÷ r2

= σb1<b2 (r∗1 × r∗∗1 ) ÷ r2 (Definition of theta-join)

= (σb1<b2 (r∗1 × r∗∗1 ) ÷ σb1<b2 (r2))−

πa (πa (r∗1 × r∗∗1 ) × σb1≥b2 (r2)) (Example 1)

= ((r∗1 × r∗∗1 ) ÷ σb1<b2 (r2))−

πa (πa (r∗1 × r∗∗1 ) × σb1≥b2 (r2)) (Law 4)

= (r∗1 ÷ πb1 (σb1<b2 (r2)))−

πa (πa (r∗1 × r∗∗1 ) × σb1≥b2 (r2)) (Law 9)

= (r∗1 ÷ πb1 (σb1<b2 (r2)))−

πa (πa (r∗1) × σb1≥b2 (r2))

(since a ∈ R∗1 but a /∈ R∗∗

1 )

Note that the term πa (r∗1) × σb1≥b2 (r2) is merely usedto test if σb1≥b2 (r2) contains at least one tuple. If yes,r3 is an empty relation because πa (r∗1) represents all avalues in r∗1 and removing these values from the quotientr∗1 ÷πb1 (σb1<b2 (r2)) would leave no tuples. Otherwise, r3is simply r∗1÷πb1 (σb1<b2 (r2)). Figure 9 sketches some in-termediate results that occur during the computation of ourexample expression.

An RDBMS might be able to execute a plan based on thisexpression more efficiently than a plan based on the originalexpression because no join between r∗1 and r∗∗1 is required.Such a situation occurs, for instance, when there is no indexavailable on r∗1 .b1 and no index on r∗∗1 .b2, but when thereare two indexes defined on the columns b1 and b2 of tabler2, respectively. �

Let us focus on a special type of join: the semi-join. Letr3 be a relation with schema R3(A). Then we can state thefollowing

LAW 10: (r1 ÷ r2) � r3 = (r1 � r3) ÷ r2.

This law can help an RDBMS if r3 has few tuples and r1and r2 have many tuples. It may be cheaper to keep r3 inmemory and to compute the semi-join in one scan over r1,especially if the join is highly selective and removes manytuples from r1. Then, the small divide of the join result withr2 is likely to be cheap.


a b1

1 1

1 2

1 3

2 2

2 3

3 1

3 3

3 4

(a) r∗1

b2

1

2

4

(b) r∗∗1

b1 b2

1 4

3 4

(c) r2

a b1 b2

1 1 2

1 1 4

1 2 4

1 3 4

2 2 4

2 3 4

3 1 2

3 1 4

3 3 4

(d) r∗1 ��b1<b2 r∗∗1

b1

1

3

(e) πb1(σb1<b2 (r2))

a

1

3

(f) r3

Figure 9. An illustration of Example 3

a x

1 1

1 2

1 3

2 1

2 3

3 1

3 3

3 4

(a) r0

a b

1 6

2 4

3 8

(b) r1 = aγsum(x)→b(r0)

b

4

(c) r2

a b

2 4

(d) r1 � r2

a

2

(e) πA(r1 � r2)


5.1.7 Grouping

We consider two special cases involving the grouping oper-ator. Concerning the first special case, let r0 be a relationwith schema R0(A∪X) for some nonempty attribute set X .Let r1 = Aγf(X)→B(r0), where f is an aggregate functionand its result is assigned to the attributes in B.8 In otherwords, each quotient candidate group of the dividend con-sists of a single tuple. Hence, in order to find a quotient, thedivisor cannot have more than one tuple. For this specialcase, we can formulate

LAW 11: r1÷r2 =

⎧⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎩

r1

if σc=0

(γcount(B)→c (r2)

)�= ∅,

πA (r1 � r2)if σc=1

(γcount(B)→c (r2)

)�= ∅,

and∅ otherwise.

Figure 10 illustrates an example for this law. Here, the ag-gregation operator computes the sum of the x values foreach group of b in table r0. This value is used as the newattribute a in r1. Since each group formed defined by b hasa single tuple the table (e) constitutes the result.

Now, let us consider another special case. Let r0 be a re-lation with schema R0(X∪B) for some nonempty attribute

8The assignment f(X) → B is a simplification. In general, f is alist of aggregate functions f1, . . . , fn, where n = |B|, such that f(X) =(f1(e1(X)), . . . , fn(en(X))) = (b1, . . . , bn) = B and ei(X) is anarithmetic expression using attributes of X, for example, e5 = 7x3 −√

x5. The set X may have any number of attributes, it need not be equalto B.

x b

1 1

1 2

1 3

2 1

2 3

3 1

3 3

3 4

(a) r0

a b

6 1

1 2

6 3

3 4

(b) r1 = bγsum(x)→a(r0)

b

1

3

(c) r2

a b

6 1

6 3

(d) r1 � r2

a

6

(e) πA(r1 � r2)


set X . Let r1 = Bγf(X)→A(r0), where f is an aggregatefunction and its result is assigned to the attributes in A.8In other words, each divisor attribute value B of the divi-dend occurs in a single tuple, that is, the groups defined byB have size one. Furthermore, let r2.B be a foreign keyreferencing r1.B, that is, r2.B ⊆ πB (r1).

Hence, there can be at most one dividend tuple for eachB value. We simply have to check if πA(r1 � r2) containsa single value. If it does, then this value is the quotient.Otherwise, there is no quotient.

LAW 12: r1 ÷ r2 =

⎧⎪⎨⎪⎩

πA (r1 � r2)if σc=1

(γcount(A)→c (

πA (r1 � r2))) �= ∅, and∅ otherwise.

Figure 11 illustrates an example for this law. Since table (e)contains a single tuple, this table also constitutes the quo-tient.

The two laws involving the grouping operator can im-prove the query execution time considerably because thesmall divide operation is replaced by a single join operationand a projection on the join result. However, since Laws 11and 12 have rather restrictive prerequisites, we believe thattheir implementation is beneficial only in special purposeRDBMS.

5.2 Algebraic Laws for the Great Divide

We have identified several laws for the great divide op-erator ÷∗. In the following, we show some of the laws thatwe consider as important.

5.2.1 Union

When the divisor r2 is decomposed into horizontal parti-tions then one can divide by these divisors separately:

LAW 13: If πC (r′2)∩πC (r′′2 ) = ∅ then r1 ÷∗ (r′2 ∪ r′′2 ) =(r1 ÷∗ r′2) ∪ (r1 ÷∗ r′′2 ).

This law allows to parallelize the execution of a query. Sup-pose that the dividend r1 is replicated on n nodes of a queryexecution engine and that the divisor is equally distributedaccording to a hash function on r2.C across the nodes. Thenit is possible to reduce the execution time to 1

nof the origi-

nal time provided that the great divide execution is consid-


erably more expensive than the final union/merge operatorplus the cost for data shipping to and from the nodes.

5.2.2 Selection

The following law is the same as Law 3 for the small divideoperator.

LAW 14: σp(A) (r1 ÷∗ r2) = σp(A) (r1) ÷∗ r2.

A similar “predicate push-down” law holds for attributeC of the divisor relation:

LAW 15: σp(C) (r1 ÷∗ r2) = r1 ÷∗ σp(C) (r2).

The following law is the same as Law 4 for the smalldivide:

LAW 16: r1 ÷∗ σp(B) (r2) = σp(B) (r1) ÷

∗ σp(B) (r2).

5.2.3 Cartesian Product

The following law is the same as Law 8 for the small divide.It is useful for expressions involving joins when combinedwith Laws 15 and 16.

LAW 17: (r∗1 × r∗∗1 ) ÷∗ r2 = r∗1 × (r∗∗1 ÷∗ r2).

5.2.4 Join

The following example illustrates how an expression in-volving great divide and theta-join can be rewritten usingthe laws discussed before.

EXAMPLE 4: Let r∗1 , r∗∗1 , and r2 be relations with schemasR∗

1(a1), R∗∗1 (a2, b1), and R2(b1, b2), respectively. We can

derive the following expressions:

r∗1 ��a1=a2(r∗∗1 ÷∗ r2)

= σa1=a2(r∗1 × (r∗∗1 ÷∗ r2)) (Def. of theta-join)

= σa1=a2((r∗1 × r∗∗1 ) ÷∗ r2) (Law 17)

= σa1=a2(r∗1 × r∗∗1 ) ÷∗ r2 (Law 14)

= (r∗1 ��a1=a2r∗∗1 ) ÷∗ r2 (Definition of theta-join)

Suppose that an index is available on r∗1 .a1 or on r∗∗1 .a2.The join r∗1 ��a1=a2

r∗∗1 in the last expression can then becomputed very efficiently. If this join has a high selectivity,it is possible that much fewer dividend groups of b valueshave to be tested against r2 in the last expression comparedto the first expression. �

6 Related Work

An interesting theoretical result about the small divideoperator has recently been published [24]. It justifies the ef-forts made by previous work on implementing small divideand set equality joins as efficient special purpose operators,which can achieve a time complexity of O(n log n) for al-gorithms based on sorting and counting. They prove thatany expression of the small divide operator in the relationalalgebra with union, difference, projection, selection, and

equi-joins, must produce intermediate results of quadraticsize.9

Set containment join is considered an important opera-tor for queries involving set-valued attributes [17, 19, 27,29, 28, 31, 32, 39]. For example, set containment test op-erations have been used for optimizing a workload of con-tinuous queries, in particular for checking if one query isa subquery of another. For instance, Chen and DeWitt [8]suggested an algorithm that re-groups continuous queries tomaintain a close-to-optimal global query execution plan.

Another example of set containment joins is content-based retrieval using a search engine in documentdatabases, where a huge set of documents is tested againsta set of keywords that all have to appear in the document.

We have already discussed the area of data mining asanother potential application area in Section 3.

The small divide operator has been studied in the con-text of fuzzy relations, for example, [6]. In a fuzzy rela-tion, the tuples are weighted by a number between 0 and1. One interpretation of an extended division operator forfuzzy relations, the fuzzy quotient operator [38], is basedon one of several relaxed versions of the universal quan-tifier, called “almost all,” which is realized by a so-calledordered weighted average operator. The fuzzy quotient op-erator produces those values of a ∈ πA(r1), where for “al-most all” elements b ∈ πB(r2) the tuple ((a)× (b)) is in r1for some fuzzy relations r1 and r2 with schemas R1(A∪B)and R2(B), respectively. Other interpretations of a “fuzzy”version for division are discussed, for example, in [5, 4].

Carlis proposed a generalization of the division opera-tor, called HAS [7]. He argues that “division is misnamed”because there are more operators ◦ than division (÷) thatfulfill the equation (r1 × r2) ◦ r2 = r1. He further claimsthat division is “hard to understand” because, among otherarguments, “division is the only algebra operation that givesstudents any trouble.” Finally, he writes that division is “in-sufficient” because it is not flexible enough, it allows onlyqueries of the form “find the sets that contain all elementsof a given set” but it does not help for queries asking for setsthat contain, for example, at least five elements of a givenset.

The HAS operator involves three relations: r1 containsentities about which we want the answer if it qualifies in theresult, r2 contains entities that are used for the qualifica-tion, and r3 contains the relationships between the entitiesin r1 and r2. For example, in the supplier-parts databasementioned in Section 4, r1 = suppliers, r2 = parts, andr3 = supplies. In addition, the HAS operator uses a combi-nation of six “adverbs,” called associations, to describe thequalification: strictly more than, strictly less than, some ofbut not all plus something else, exactly, none of plus some-thing else, and none at all. There are 26 − 1 = 63 possiblecombinations to choose between one and six associationsfor a specific HAS operator. Such a combination is consid-ered as a disjunction of the participating associations.

We illustrate the algebra syntax used in [7] by show-ing how the small divide can be expressed by the HASoperator using one of the 63 association combinations:r1 VIA r3 HAS (exactly or strictly more than) OF r2. The

9Their main, more general, result is to show that any relational algebraexpression that never produces intermediate results of quadratic size, willproduce only intermediate results of linear size.


combination “exactly or strictly more than” is equivalent tothe adverb “at least,” typically used to describe division.

7 Conclusions

We have presented equivalences of the relational algebrafor two important operators that realize a universal quantifi-cation, called small and great divide. The latter is a natu-ral extension of the classic small divide operator that wasintroduced by Codd. The algebraic laws can serve as log-ical rewrite rules within the optimizer of an RDBMS thatprovides an implementation of small or great divide in theexecution engine. To achieve efficiency for universal quan-tification queries, division operators must be implementedas first-class operators, as it was recently proven in [24].

Until today, relational division operators have not beenimplemented in any commercial RDBMS. However, withthese operators, data-intensive data mining primitives likefrequent itemset discovery or simple text searches usingconjunctive queries can be formulated intuitively and becoupled more closely with an RDBMS. Hence, such “for-all” queries enjoy an optimization according to the currentdata characteristics and can be processed efficiently by thesespecial-purpose operators. We do not claim that the lawspresented in this paper constitute the only relevant ruleset.Nevertheless, we believe that several of our algebraic equiv-alences are necessary to enable an effective optimization ofqueries that use the small or great divide as a first-class op-erator.

Clearly, logical query rewriting is only one aspect of thequery optimization problem. The mapping of logical opera-tors to physical operators is another issue. We have recentlyimplemented a collection of physical great divide operatorsinto a Java query execution engine prototype based on theclass library XXL [3]. A description of several great di-vide algorithms together with cost estimations based on in-put data characteristics (such as grouped or sorted columnsin the dividend and divisor) was given in [35]. Future workwill assess the effectiveness of the algebraic laws when im-plemented as transformation rules in a query optimizer. Be-sides such engineering problems, it is interesting to studyfurther data-intensive applications with an intrinsic univer-sal quantification problem besides frequent itemset discov-ery.

Acknowledgments

We thank Rakesh Agrawal for invaluable suggestions,Bernhard Mitschang for starting the project and guiding ourwork at Stuttgart, where much of this work was done, andLeonard Shapiro for the inspiration.

References

[1] S. Abiteboul, R. Hull, and V. Vianu. Foundations of Databases. Addison-Wesley, 1995.

[2] R. Agrawal, T. Imielinski, and A. Swami. Mining association rules betweensets of items in large databases. In SIGMOD, Washington DC, USA, pages207–216, May 1993.

[3] J. V. d. Bercken, B. Blohsfeld, J.-P. Dittrich, J. Kramer, T. Schafer, M. Schnei-der, and B. Seeger. XXL—A library approach to supporting efficientimplementations of advanced database queries. In VLDB, Rome, Italy, pages39–48, September 2001.

[4] P. Bosc. On the primitivity of the division of fuzzy relations. In SAC, San Jose,California, USA, pages 197–201, February–March 1997.

[5] P. Bosc, D. Dubois, O. Pivert, and H. Prade. Flexible queries in relationaldatabases—the example of the division operator. Theoretical ComputerScience, 171(1–2):281–302, 1997.

[6] B. P. Buckles and F. E. Petry. A fuzzy representation of data for relationaldatabases. Fuzzy Sets and Systems, 7(3), May 1982. 213–226.

[7] J. V. Carlis. HAS, a relational algebra operator or divide is not enough toconquer. In ICDE, Los Angeles, California, USA, pages 254–261, February1986.

[8] J. Chen and D. DeWitt. Dynamic re-grouping of continuous queries. In VLDB,Hong Kong, China, pages 430–441, August 2002.

[9] J. Claußen, A. Kemper, G. Moerkotte, and K. Peithner. Optimizing querieswith universal quantification in object-oriented and object-relational databases.In VLDB, Athens, Greece, pages 286–295, August 1997.

[10] E. Codd. Relational completeness of database sub-languages. In R. Rustin,editor, Courant Computer Science Symposium 6: Database Systems, pages65–98. Prentice-Hall, 1972.

[11] H. Darwen and C. Date. Into the great divide. In C. Date and H. Darwen,editors, Relational Database: Writings 1989–1991, pages 155–168. Addison-Wesley, Reading, Massachusetts, USA, 1992.

[12] R. Demolombe. Generalized division for relational algebraic language.Information Processing Letters, 14(4):174–178, 1982.

[13] H. Garcia-Molina, J. Ullman, and J. Widom. Database Systems—The CompleteBook. Prentice-Hall, 2002.

[14] G. Graefe. Relational division: Four algorithms and their performance. InICDE, Los Angeles, California, USA, pages 94–101, February 1989.

[15] G. Graefe. The Cascades framework for query optimization. BTCDE,18(3):19–29, September 1995.

[16] G. Graefe and R. Cole. Fast algorithms for universal quantification in largedatabases. TODS, 20(2):187–236, 1995.

[17] S. Helmer. Performance Enhancements for Advanced Database Manage-ment Systems. PhD thesis, University of Mannheim, Germany, December 2000.

[18] S. Helmer and G. Moerkotte. Evaluation of main memory join algorithms forjoins with set comparison join predicates. In VLDB, Athens, Greece, pages386–395, August 1997.

[19] S. Helmer and G. Moerkotte. Compiling away set containment and intersectionjoins. Technical report, University of Mannheim, Germany, April 2002.

[20] M. Houtsma and A. Swami. Set-oriented data mining in relational databases.DKE, 17(3):245–262, December 1995.

[21] ISO/IEC. Information Technology—Database Language—SQL—Part 2:Foundation (SQL/Foundation), Working Draft 9075-2:2003, December 2002.

[22] ISO/IEC. Information Technology—Database Language—SQL—Part 2:Framework (SQL/Framework), Working Draft 9075-2:2003, December 2002.

[23] M. Jarke and J. Koch. Query optimization in database systems. ACMComputing Surveys, 16(2):111–152, June 1984.

[24] D. Leinders and J. V. den Bussche. On the complexity of division and set joinsin the relational algebra. In PODS, Baltimore, MD, June 2005.

[25] G. M. Lohman. Grammar-like functional rules for representing query opti-mization alternatives. In SIGMOD, Chicago, Illinois, USA, pages 18–27, June1988.

[26] D. Maier. The Theory of Relational Databases. Computer Science Press, 1983.[27] N. Mamoulis. Efficient processing of joins on set-valued attributes. In

SIGMOD, San Diego, California, USA, June 2003.[28] S. Melnik and H. Garcia-Molina. Divide-and-conquer algorithm for computing

set containment joins. In EDBT, Prague, Czech Republic, pages 427–444,March 2002.

[29] S. Melnik and H. Garcia-Molina. Adaptive algorithms for set containmentjoins. TODS, 28(1):56–99, March 2003.

[30] H. Pirahesh, J. M. Hellerstein, and W. Hasan. Extensible/rule based queryrewrite optimization in Starburst. In SIGMOD, San Diego, California, USA,pages 39–48, June 1992.

[31] K. Ramasamy. Efficient Storage and Query Processing of Set-valued Attributes.PhD thesis, University of Wisconsin, Madison, Wisconsin, USA, 2002. 144pages.

[32] K. Ramasamy, J. M. Patel, J. F. Naughton, and R. Kaushik. Set containmentjoins: The good, the bad and the ugly. In VLDB, Cairo, Egypt, pages 351–362,September 2000.

[33] R. Rantzau. Processing frequent itemset discovery queries by division and setcontainment join operators. In DMKD, San Diego, California, USA, June 2003.

[34] R. Rantzau and C. Mangold. Laws for rewriting queries containing divisionoperators. Technical report no. 2005/08, Faculty of Computer Science,Electrical Engineering, and Information Technology, Universitat Stuttgart,Germany, October 2005.

[35] R. Rantzau, L. Shapiro, B. Mitschang, and Q. Wang. Algorithms and applica-tions for universal quantification in relational databases. Information Systems,28(1):3–32, January 2003.

[36] S. Sarawagi, S. Thomas, and R. Agrawal. Integrating association rule miningwith relational database systems: Alternatives and implications. In SIGMOD,Seattle, Washington, USA, pages 343–354, June 1998.

[37] S. Thomas and S. Chakravarthy. Performance evaluation and optimization ofjoin queries for association rule mining. In DaWaK, Florence, Italy, pages241–250, August–September 1999.

[38] R. R. Yager. Fuzzy quotient operators for fuzzy relational databases. In IFES,Yokohama, Japan, pages 289–296, November 1991.

[39] C. Zhang, J. Naughton, D. DeWitt, Q. Luo, and G. Lohman. On supportingcontainment queries in relational database management systems. In SIGMOD,Santa Barbara, California, USA, May 2001.


[ieee 22nd international conference on data engineering (icde'06) - atlanta, ga, usa...

Documents