USRE46380E1 - Type inference for datalog with complex type hierarchies - Google Patents

Type inference for datalog with complex type hierarchies Download PDF

Info

Publication number
USRE46380E1
USRE46380E1 US14/952,788 US201514952788A USRE46380E US RE46380 E1 USRE46380 E1 US RE46380E1 US 201514952788 A US201514952788 A US 201514952788A US RE46380 E USRE46380 E US RE46380E
Authority
US
United States
Prior art keywords
type
program
query
portion
database
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
US14/952,788
Inventor
Max Schaefer
Oege de MOOR
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Semmle Ltd
Original Assignee
Semmle Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US36457110P priority Critical
Priority to US13/183,514 priority patent/US8595213B2/en
Application filed by Semmle Ltd filed Critical Semmle Ltd
Priority to US14/952,788 priority patent/USRE46380E1/en
Application granted granted Critical
Publication of USRE46380E1 publication Critical patent/USRE46380E1/en
Assigned to SEMMLE LIMITED reassignment SEMMLE LIMITED ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: MOOR, OEGE DE, SCHAEFER, MAX
Application status is Active legal-status Critical
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G06F17/30421
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • G06F8/43Checking; Contextual analysis
    • G06F8/436Semantic checking
    • G06F8/437Type checking
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24Querying
    • G06F16/242Query formulation
    • G06F16/2433Query languages
    • G06F16/2448Query languages for particular applications; for extensibility, e.g. user defined types

Abstract

What is disclosed are a novel system and method for inferring types of database queries. In one embodiment a program and associated database schema that includes a type hierarchy is accessed. The program includes query operations to a database that contains relations described by a database schema. Types are inferred from definitions in the program by replacing each database relationship in the program by the types in the database schema. A new program is generated with the types that have been inferred with the new program only accessing unary relations in the database. In another embodiment, testing of each of the types that have been inferred is performed for type emptiness. In response to type emptiness being found for a type that have been inferred, a variety of different operations are performing including removing the type, providing a notification regarding the emptiness found for the type, and more.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS

This applicationThe present application is a reissue application of U.S. application Ser. No. 13/183,514, which was filed on Jul. 15, 2011 and issued as U.S. Pat. No. 8,595,213 on Nov. 26, 2013 which is based upon and claims priority from prior provisional patent application No. 61/364,571, filed on Jul. 15, 2010 the entire disclosure of which is herein incorporated by reference.

FIELD OF THE INVENTION

The present invention relates generally to information retrieval, in particular the way electronically stored data is accessed via queries that are formulated in a programming language. The invention concerns both the detection of errors in such queries, and their efficient execution.

BACKGROUND OF THE INVENTION

Like any other programming task, writing queries is error-prone, and it is helpful if the programming language in which queries are expressed gives assistance in identifying errors while queries are being written, and before they are executed on a database. Programming languages often provide “types” for that purpose, indicating for each variable what kind of value it may hold. A programming language for expressing queries is usually called a “query language”. The most popular example of a query language is SQL.

In SQL, and in most other query languages in prior art, types are assigned to each variable separately. As a consequence, very few errors are caught before the query is executed on a database. The only kind of error found is when an operation does not make sense: for instance, a string cannot be subtracted from an integer. In particular one cannot predict accurately (without running the query), whether a query will return any results or not. And yet, a query that returns no results is the most common symptom of a programming error.

In the logic programming community, some attempts have been made to construct type checkers that detect queries where there are no results at all, regardless of the contents of the database being queried. None of these attempts precisely tracks the dependencies between variables, however, and therefore they are suboptimal: there are many queries for which one could prove that no results are returned, and yet the type checkers do not find the errors. It is very confusing for users that some errors of this kind are caught, and others are not.

In the theoretical database community, there has been some work on proving containment between queries, but this is typically restricted to unnatural fragments of the query language. Furthermore these works do not take advantage of the type hierarchies that typically exist on data stored in a database.

What is desired, therefore, but not yet accomplished before the present invention, is a system and method of computing types for queries that accurately approximate the actual set of results, taking the type hierarchy into account.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an example program written in Datalog with a sequence of rules.

FIG. 2 is an example of a type hierarchy suitable for the program in FIG. 1.

FIG. 3 is a definition listing illustrating the approximation of every use of an extensional relation symbol by the conjunction of its column types.

FIG. 4 is a diagram illustrating the need for consensus formation when checking type inclusion.

FIG. 5 is a diagram further illustrating the need for consensus formation when checking type inclusion.

FIG. 6 is a plot illustrating the type inference time plotted on the y-axis versus the depth (i.e., number of layers) of the program on the x-axis.

FIG. 7 is a block diagram illustrating how types of database queries are inferred.

FIG. 10 is a block diagram of a computer system suitable for implementing the various embodiments of the present invention discussed herein according to one embodiment of the present invention.

FIG. 8 is a flow chart illustrating inclusion testing for types represented by sets of type tuple constraints (TTCs).

FIG. 9 is a flow chart illustrating saturation of sets of type tuple constraints (TTCs) for inclusion testing.

FIG. 11 is algorithm 1 of the present invention.

FIG. 12 is algorithm 2 of the present invention.

FIG. 13 is algorithm 3 of the present invention.

FIG. 14 is algorithm 4 of the present invention.

DESCRIPTION OF THE PREFERRED EMBODIMENTS

It should be understood that these embodiments are only examples of the many advantageous uses of the innovative teachings herein. In general, statements made in the specification of the present application do not necessarily limit any of the various claimed inventions. Moreover, some statements may apply to some inventive features but not to others. In general, unless otherwise indicated, singular elements may be in the plural and vice versa with no loss of generality.

1. Introduction

The present invention infers precise types for queries where the entities in the database satisfy complex conditions regarding subtyping, disjointness and so on.

To illustrate, consider the Datalog program in FIG. 1, which is a slight adaptation of an example in [1]. It assumes a database that contains monadic extensional relations for employee, senior, junior, parttime, student and manager. These monadic relations capture the entities that are manipulated by queries, and they are the building blocks of types. There is furthermore an extensional relation salary(x, z).

In the program, additional intensional relations are defined: bonus(x, y) computes the bonus y that an employee x will get. Non-students x get a bonus y that is computed by multiplying x's salary z by a factor f, which is returned by factor(x, f). The factor depends on the seniority of the employee. For students, the bonus is always 50, independent of their salary. Finally, the program defines a query, which is to find the bonus of all senior managers.

The entity types are expected to satisfy many interesting facts that are useful in reasoning about types, for instance those shown in FIG. 2. We call such a set of facts the type hierarchy. Note that the type hierarchy goes well beyond the usual notion of subtyping in traditional programming languages, in that one can state other relationships besides mere implication or equivalence. An example of such an interesting fact is the last statement, which says that managers cannot be part-time employees. The programmer will have to state these facts as part of the database definition, so that they can be checked when information is entered, and to enable their use in type inference and optimisation.

To do type inference, we of course also need to know some facts about extensional relations. For instance,
salary(x, z)→employee(x)

Figure USRE046380-20170425-P00001
float(z)
states that the first column of the extensional relation salary will contain values of type employee, and the second one will contain floating point numbers. A database schema provides this column-wise typing information for every extensional relation.

Given the schema and the hierarchy, type inference should infer the following implications from the definitions in the program:
bonus(x, y)→employee(x)

Figure USRE046380-20170425-P00001
float(y)
factor(x, y)→employee(x)
Figure USRE046380-20170425-P00001
float(y)
query(x, y)→senior(x)
Figure USRE046380-20170425-P00001
manager(x)
Figure USRE046380-20170425-P00001
float(y)

Note how these depend on facts stated in the type hierarchy: for example, in inferring the type of factor, we need to know that employee is the union of junior and senior.

Type inference will catch errors: when a term is inferred to have the type ⊥, we know that it denotes the empty relation, independent of the contents of the database. Also, the programmer may wish to declare types for intensional relations in her program, and then it needs to be checked that the inferred type implies the declared type.

The benefits of having such type inference for queries is not confined to merely checking for errors. Precise types are also useful in query optimisation. In particular, the above query can be optimised to:
query(x, y)←manager(x)

Figure USRE046380-20170425-P00001
senior(x)
Figure USRE046380-20170425-P00001
salary(x, z)
Figure USRE046380-20170425-P00001
y=0.15xz

This rewriting relies on the fact that we are asking for a manager, and therefore the disjunct in the definition of bonus that talks about students does not apply: a student is a parttime employee, and managers cannot be parttime. Again notice how the complex type hierarchy is crucial in making that deduction. The elimination of disjuncts based on the types in the calling context is named type specialisation; type specialisation is very similar to virtual method resolution in optimising compilers for object-oriented languages. Similarly, the junior alternative in the definition of factor can be eliminated. Once type specialisation has been applied, we can eliminate a couple of superfluous type tests: for instance,

Figure USRE046380-20170425-P00002
student(x) is implied by manager(x). That is called type erasure. The key to both type specialisation and type erasure is an efficient and complete test for type containment, which takes all the complex facts about types into account.

Overview The general problem we address is as follows. Given the class of all Datalog programs

Figure USRE046380-20170425-P00003
, we identify a sublanguage
Figure USRE046380-20170425-P00004
of type programs. Type inference assigns an upper bound ┌p┐ in the language of type programs to each program p. To say that ┌p┐ is an upper bound is just to say that p (plus the schema and the type hierarchy) implies ┌p┐. The idea of such ‘upper envelopes’ is due to Chaudhuri [8, 9].

In Section 2 we propose a definition of the class of type programs: any program where all extensionals called are monadic. Type programs can, on the other hand, contain (possibly recursive) definitions of intensional predicates of arbitrary arity. We then define a type inference procedure ┌p┐, and prove that its definition is sound in the sense that ┌p┐ is truly an upper bound of p. Furthermore, it is shown that for negation-free programs p, the inferred type ┌p┐ is also optimal: ┌p┐ is the smallest type program that is an upper bound of p.

For negation-free programs, the definition of ┌p┐ is in terms of the semantics of p, so that the syntactic presentation of a query does not affect the inferred type. It follows that the application of logical equivalences by the programmer or by the query optimiser does not affect the result of type inference.

The restriction that programs be negation-free can be relaxed to allow negation to occur in front of sub-programs that already have the shape of a type program. Not much more can be hoped for, since sound and optimal type inference for programs with arbitrary negations is not decidable.

To also do type checking and apply type optimisations, we need an effective way of representing and manipulating type programs. To this end, we identify a normal form for a large and natural class of type programs in Section 3. The class consists of those type programs where the only negations are on monadic extensionals (i.e., entity types). There is a simple syntactic containment check on this representation, inspired by our earlier work reported in [13].

That simple containment check is sound but not complete. A geometric analysis of the incompleteness in Section 4 suggests a generalisation of the celebrated procedure of Quine [22] for computing prime implicants. We present that generalised procedure, and show that the combination of the simple containment check plus the computation of prime implicants yields a complete algorithm for testing containment of type programs.

The algorithm we present is very different from the well-known approach of propositionalisation, which could also be used to decide containment. The merit of our novel algorithm is that it allows an implementation that is efficient in common cases. We discuss that implementation in Section 5. We furthermore present experiments with an industrial database system that confirm our claims of efficiency on many useful queries.

Finally, we discuss related work in Section 6, and conclude in Section 8.

In summary, the original contributions of this paper include:

    • The identification of a language of type programs for Datalog, suitable both for precise error checking and for type-based optimisations.
    • The definition of a very simple type inference procedure that is proved sound and optimal.
    • A containment check for type programs that relies on a novel generalisation of Quine's method of computing prime implicants.
    • Experiments in an industrial database system that show that this containment algorithm is efficient and useful.

2. Type Programs

It is customary to write Datalog programs as a sequence of rules as seen in FIG. 1, but this syntax is too imprecise for our purposes. In the remainder of the paper, all Datalog programs will be written as formulae of Stratified Least Fixpoint Logic (SLFP) over signatures without function symbols.

This logic, presented for example in [10], extends first order logic (including equality) with fixpoint definitions of the form [r(x1, . . . , xn)≡φ] ψ. Here, r is an n-ary relation symbol, the xi are pairwise different element variables, and φ and ψ are formulae. Intuitively, the formula defines r by the formula φ, which may contain recursive occurrences of r, and the defined relation can then be used in ψ.

The xi are considered bound in φ and free in ψ, whereas the relation r is free in φ and bound in ψ. To ensure stratification, free relation symbols are not allowed to occur under a negation, which avoids the problematic case of recursion through negation. For example, the formula
[s(x, y)≡x≐y

Figure USRE046380-20170425-P00005
∃z.e(x, z)
Figure USRE046380-20170425-P00001
s(z, y)]s(x, y)  (1)
defines the relation s to be the reflexive transitive closure of e. By way of illustration (and only in this example), free occurrences of element variables and relation variables have been marked up in bold face. The formula is trivially stratified since no negations occur anywhere.

In this program, the relation symbol s is an intensional predicate since it is given a defining equation. On the other hand, relation e is an extensional, which we assume to be defined as part of a database on which the program is run. We will denote the set of intensional relation symbols as

Figure USRE046380-20170425-P00006
and that of extensional relation symbols as
Figure USRE046380-20170425-P00007
, and require them to be disjoint.

Model-theoretically, the role of the database is played by an interpretation

Figure USRE046380-20170425-P00008
which assigns, to every n-ary relation symbol e ∈
Figure USRE046380-20170425-P00007
, a set of n-tuples of some non-empty domain. To handle free variables we further need an assignment σ that maps free element variables to domain elements and free relation variables to sets of tuples.

Just as in first order logic, we can then define a modelling judgement

Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ φ stating that formula φ is satisfied under interpretation
Figure USRE046380-20170425-P00008
and assignment σ. In particular, stratification ensures that formulae can be interpreted as continuous maps of their free relation variables, so that fixpoint definitions can be semantically interpreted by the least fixpoints of their defining equations.

For a formula φ with a single free element variable x, we set [[φ]]

Figure USRE046380-20170425-P00008
:={c|
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
x:=c φ}, omitting the subscript
Figure USRE046380-20170425-P00008
where unambiguous.

Just as the semantics of the intensional predicates is determined with respect to the semantics of the extensional predicates, the types of the intensional predicates are derived with respect to the types of the extensional predicates. These are provided by a schema

Figure USRE046380-20170425-P00010
which assigns, to every n-ary extensional predicate, an n-tuple of types. As is customary, types are themselves monadic predicates from a set
Figure USRE046380-20170425-P00004
Figure USRE046380-20170425-P00007
of type symbols. For consistency, we require that the schema assigns a type symbol to itself as its type.

For the program in (1), for example, we might have two type symbols a and b, with the schema specifying that

Figure USRE046380-20170425-P00010
(e)=(a, b) and of course
Figure USRE046380-20170425-P00010
(a)=(a),
Figure USRE046380-20170425-P00010
(b)=(b).

Semantically, we understand this to mean that in every interpretation of the extensional symbols conforming to the schema, the extension of a given column of an extensional symbol should be exactly the same as the extension of the type symbol assigned to it by the schema.

We can define a first order formula, likewise denoted as

Figure USRE046380-20170425-P00010
, which expresses this constraint: For every n-ary relation symbol e ∈
Figure USRE046380-20170425-P00007
\
Figure USRE046380-20170425-P00011
and every 1≦i≦n where u ∈
Figure USRE046380-20170425-P00007
is the type assigned to the i-th column of e, the formula
Figure USRE046380-20170425-P00010
contains a conjunct
∀xi.(∃x1, . . . , xi−1, xi+1, . . . , xn.e(x1, . . . , xn))
Figure USRE046380-20170425-P00012
u(xi)  (2)

Our example schema above, for instance, would be expressed by the formula
(∀x.(∃y.e(x,y))

Figure USRE046380-20170425-P00012
a(x))
Figure USRE046380-20170425-P00001
(∀y.(∃x.e(x, y))
Figure USRE046380-20170425-P00012
b(y))

In the literature, the types assigned by the schema are often not required to fit exactly, but merely to provide an overapproximation of the semantics. We could achieve this by relaxing (2) to use an implication instead of a bi-implication.

Instead, we take a more general approach by allowing arbitrary additional information about the types to be expressed through a hierarchy formula

Figure USRE046380-20170425-P00013
. Our only requirements about this formula are that it be a closed first order formula containing only type symbols (and no other relation symbols).

In particular, the hierarchy may stipulate subtyping relations; in our example, the hierarchy could be ∀x.a(x)→b(x), expressing that a is a subtype of b. Perhaps more interestingly, it can also express disjointness of types, e.g. by stating that ∀x.

Figure USRE046380-20170425-P00002
a(x)
Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00002
b(x); we could then deduce that in the definition of the reflexive transitive closure e can, in fact, be iterated at most once. Many other kinds of constraints are just as easily expressed, and provide opportunities for advanced optimisations.

We now approximate programs by type programs, which are programs that only make use of type symbols (and no other extensional relation symbols), and do not contain negation. (Compare this with the hierarchy which can contain negations, but no fixpoint definitions.) To every SLFP formula φ we assign a type program ┌φ┐ by replacing negated subformulae with τ T and approximating every use of an extensional relation symbol by the conjunction of its column types. The complete definition is given in FIG. 3.

For our example program, we would obtain the type
[s(x, y)≡x≐y

Figure USRE046380-20170425-P00005
∃z.a(x)
Figure USRE046380-20170425-P00001
b(z)
Figure USRE046380-20170425-P00001
s(z, y)]s(x,y)

which is semantically equivalent to
x≅y

Figure USRE046380-20170425-P00005
a(x)
Figure USRE046380-20170425-P00001
b(y)

We will see in the next section that, in fact, fixpoint definitions can always be eliminated from such type programs, yielding formulae of monadic first order logic.

As the example suggests, the types assigned to programs semantically over-approximate them in the following sense:

Theorem 1 (Soundness). For every program φ we have

Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, φ
Figure USRE046380-20170425-P00009
┌φ┐

That is, every interpretation and assignment satisfying the schema, the hierarchy and φ also satisfies ┌φ┐.

Proof Sketch. We can show by induction on φ the following stronger version of the the—orem: For any interpretation

Figure USRE046380-20170425-P00008
with
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00010
and any two assignments σ and σ′, which assign the same values to element variables, and where σ(r) σ′(r) for every r ∈
Figure USRE046380-20170425-P00006
, we have
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ′ ┌φ┐ whenever
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
σφ.

From this, of course, it follows that

Figure USRE046380-20170425-P00010
, φ
Figure USRE046380-20170425-P00009
┌φ┐, and again
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, φ
Figure USRE046380-20170425-P00009
┌φ┐ by monotonicity of entailment.

Perhaps more surprisingly, our type assignment also yields the tightest such over-approximation, in spite of our very lax restrictions on the hierarchy:

Theorem 2 (Optimality). For a negation-free program φ and a type program

Figure USRE046380-20170425-P00015
, if we have
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, φ
Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00015

then also
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, ┌φ┐
Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00015

To prove this theorem, we need a monotonicity result for the type assignment.

Lemma 3. For two negation-free programs φ and ψ, if it is the case that

Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, φ
Figure USRE046380-20170425-P00009
ψ then also
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00013
, ┌φ┐
Figure USRE046380-20170425-P00009
┌ψ┐.

An easy way to prove this result is to make use of cartesianisation, which is the semantic equivalent of the typing operator ┌•┐. For a relation R Dn, we define its cartesianisation cart (R)=π1(R) x . . . . xπn(R) to be the cartesian product of the columns of R. Likewise, the cartesianisation cart(

Figure USRE046380-20170425-P00008
) of an interpretation
Figure USRE046380-20170425-P00008
is the interpretation which assigns cart(
Figure USRE046380-20170425-P00008
(e)) to every relation symbol e.

It is then not hard to see that
cart(

Figure USRE046380-20170425-P00008
)
Figure USRE046380-20170425-P00016
σ φ
Figure USRE046380-20170425-P00017
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00016
σ┌φ┐  (3)
for any negation-free formula φ, interpretation
Figure USRE046380-20170425-P00008
and assignment σ whenever
Figure USRE046380-20170425-P00010
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00010
. Also, cart(
Figure USRE046380-20170425-P00008
)
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00010
if
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00010
, and cart(
Figure USRE046380-20170425-P00008
)
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00014
iff
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00014
.

From this observation, we easily get the

Proof of Lemma 3. Assume

Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00014
, φ | ψ, and let
Figure USRE046380-20170425-P00008
, σ be given with
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00008
and
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00016
σ ┌φ┐.

By (3), we have cart(

Figure USRE046380-20170425-P00008
) |
Figure USRE046380-20170425-P00010
, cart(
Figure USRE046380-20170425-P00008
) |
Figure USRE046380-20170425-P00014
and also cart(
Figure USRE046380-20170425-P00008
) ψ σφ, so by assumption cart(
Figure USRE046380-20170425-P00008
) | σ ψ, but then by applying (3) again we get
Figure USRE046380-20170425-P00008
| σ┌ψ┐.

We briefly pause to remark that Lemma 3 also shows that type inference for negation-free programs respects semantic equivalence: If φ and ψ are semantically equivalent (under

Figure USRE046380-20170425-P00010
and
Figure USRE046380-20170425-P00014
), then so are their types. This does, of course, not hold in the presence of negation, for given a type symbol u, we have ┌u(x)┐=u(x) yet ┌
Figure USRE046380-20170425-P00018
Figure USRE046380-20170425-P00018
u(x)┐=τ.

Continuing with our development, we can now give the

Proof of Theorem 2. Assume

Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00014
, φ
Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00015
; by Lemma 3 this means
Figure USRE046380-20170425-P00010
,
Figure USRE046380-20170425-P00014
, ┌φ┐
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00015
┐. But since
Figure USRE046380-20170425-P00015
is a type program we have ┌
Figure USRE046380-20170425-P00015
┐=
Figure USRE046380-20170425-P00015
, which gives the result.

So far we have handled negation rather crudely, trivially approximating it by τ. In fact, we can allow negations in type programs and amend the definition of ┌•┐ for negations to read

φ = { φ if φ is a type program otherwise

All the above results, including soundness and optimality, go through with this new definition, and the optimality and monotonicity results can be generalised to hold on all programs which contain only harmless negations, i.e. negations where the negated formula is a type program.

There is little hope for an optimality result on an even larger class of programs: Using negation, equivalence checking of two programs can be reduced to emptiness, and a program is empty iff its optimal typing is ⊥. As equivalence is undecidable [23], any type system that is both sound and optimal for all programs would likewise have to be undecidable.

Our proposed definition of type programs is significantly more liberal than previous proposals in the literature. Frühwirth et al. in a seminal paper on types for Datalog [16] propose the use of conjunctive queries, with no negation, no disjunction, no equalities and no existentials.

As an example where the additional power is useful, consider a database that stores the marriage register of a somewhat traditionally minded community. This database might have types male and female, specified to be disjoint by the type hierarchy, and an extensional relation married with schema (female, male). (Note that this means that all male and female entities in the database are married, i.e. occur somewhere in the married relation.)

Using our above terminology, we have

Figure USRE046380-20170425-P00019
={male, female} and
Figure USRE046380-20170425-P00007
=
Figure USRE046380-20170425-P00019
∪ {married};
Figure USRE046380-20170425-P00014
is ∀x.
Figure USRE046380-20170425-P00018
male(x)
Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00018
female (x).

Let us now define an intensional predicate spouse:
[spouse(x, y)≡married(x, y)

Figure USRE046380-20170425-P00005
married(y, x)]spouse(x, y)

What is the type of spouse(x, y)? In the proposal of [16], we could only assign it (female(x)

Figure USRE046380-20170425-P00005
male(x))
Figure USRE046380-20170425-P00001
(female(y)
Figure USRE046380-20170425-P00005
male(y)), so both arguments could be either male or female. By contrast, when employing our definition of type programs, the inferred type is
(female(x)
Figure USRE046380-20170425-P00001
male(y))
Figure USRE046380-20170425-P00005
(male(x)
Figure USRE046380-20170425-P00001
female(y))

This accurately reflects that x and y must be of opposite sex. By properly accounting for equality, we can also infer that the query spouse(x, y)

Figure USRE046380-20170425-P00001
x≐y has type ⊥ under the hierarchy: nobody can be married to themselves.

3. Representing Type Programs

For query optimisation and error checking, the single most important operation on types is containment checking, i.e. we want to decide, for two type programs

Figure USRE046380-20170425-P00015
and
Figure USRE046380-20170425-P00015
′, whether
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
Figure USRE046380-20170425-P00015
|
Figure USRE046380-20170425-P00015
′, which we will write
Figure USRE046380-20170425-P00015
|
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00015
′ for short.

As mentioned in the introduction, we are often interested in checking whether a formula is unsatisfiable, that is whether it always gives an empty set of results regardless of the interpretation of the extensional relations. If such a formula occurs in a user program, it is regarded as a type error and the user is alerted to this fact; if it occurs during optimisation, it provides an opportunity for logical simplification. By the results of the previous section, a formula φ containing only harmless negations is unsatisfiable iff its type is equivalent to ⊥, that is iff ┌φ┐

Figure USRE046380-20170425-P00016
Figure USRE046380-20170425-P00014
⊥.

Our type programs only make use of monadic extensionals, and their containment can be decided by a straightforward extension of the well-known decision procedure for monadic first order logic [6]. This construction, however, incurs an exponential blowup in formula size and does not directly yield a practical algorithm.

Under some mild restrictions on the class of type programs and the hierarchy, however, we can represent type programs in a compact manner that allows efficient containment checking in practice.

The class of type programs we deal with falls in between the two classes discussed in the previous section by allowing negation, but only in front of type symbols (and never before equalities). The definition of ┌•┐ is easily changed to accommodate this by setting ┌

Figure USRE046380-20170425-P00018
φ┐=
Figure USRE046380-20170425-P00018
φ if φ is of the form u(t) for u ∈
Figure USRE046380-20170425-P00019
, and τ otherwise. We call a possibly negated application of a type symbol to a variable a type literal.

Furthermore, we require the hierarchy

Figure USRE046380-20170425-P00014
to be of the form ∀x.h(x), where h(x) does not contain quantifiers or equations, and only a single free variable x.

The basic unit of our representation are type propositions, which are Boolean combinations of type symbols, all of them applied to the same variable. In other words, a type proposition is a quantifier-free type program without fixpoint definitions or free relation variables, having precisely one free element variable. For example, the subformula h(x) of

Figure USRE046380-20170425-P00014
is a type proposition.

A type proposition φ behaves essentially the same as the propositional formula |φ| that results from it by replacing every atom u(x) with the propositional letter u; for example, it is easily seen that ∀x.y is (first order) valid iff |φ| is (propositionally) valid [20]. Hence we will sometimes identify the two notationally.

For example, if a and b are type symbols, then a(x)

Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00018
b(x) is a type proposition with |a(x)
Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00018
b(x)|=a
Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00018
b.

For the restricted class of type programs under consideration, fixpoint definitions can be eliminated. To see this, recall that fixpoint definitions can be expanded into infinite disjunctions [10]. It thus suffices to show that the type programs without free relation variables and without fixpoint definitions (which we shall henceforth call flat) form a complete lattice, so that even a prima facie infinite disjunction can in fact be represented by a single formula.

Lemma 4. The flat type programs form a complete lattice under the order

Figure USRE046380-20170425-P00020
Figure USRE046380-20170425-P00021
.

Proof. The lattice structure is obviously given by the logical operations of conjunction and disjunction. To show completeness, we show that the set of flat type programs is finite (modulo equivalence under

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00021
).

Notice that every flat type program with m free element variables from X={x1, . . . , xm} can be written in prenex form as

y 1 , , y n · i [ 1 j m ψ i , j 1 k n χ i , k ( y k ) ζ ]
for a set Y={y1, . . . , yn} of element variables, where all the ψi,j and Xi,k are type propositions, and ζ is a conjunction of equations between element variables from X ∪ Y.

Existentials distribute over disjunctions, and also over conjunctions if the variable they bind is only free in one of the conjuncts. Also, note that ∃x.(x≐y

Figure USRE046380-20170425-P00001
φ) is semantically equivalent to φ with y substituted for x. Hence we can further bring the type program into the form

i [ 1 j m ψ i , j ( x j ) 1 k n ( y k · χ i , k ( y k ) ) ζ ]
where ζ′ now contains only variables from X. We will say that a formula of this shape is in solved form.

Clearly, there are only finitely many different formulae in solved form (modulo semantic equivalence), since there are only finitely many type propositions.

Notice that the set of flat type programs is no longer finite if we allow negated equalities. Indeed, for every natural number n, let εn be a formula asserting that there are at least n different individuals; for example, ε2 is ∃x1, x2.

Figure USRE046380-20170425-P00002
x1≐x2. Then
Figure USRE046380-20170425-P00002
εn
Figure USRE046380-20170425-P00020
Figure USRE046380-20170425-P00021
Figure USRE046380-20170425-P00002
εn+1 for every n, yet all the εn are semantically distinct; so the lattice is not even of finite height anymore.

Corollary 5. Every type program without free relation variables is semantically equivalent to a flat type program, and hence to a formula of monadic first order logic.

Here is an example of how a type program (with only a single disjunct) can be brought into solved form.
∃z·a(x)

Figure USRE046380-20170425-P00001
z≐y
Figure USRE046380-20170425-P00001
b(y)
Figure USRE046380-20170425-P00001
c(x)
Figure USRE046380-20170425-P00001
x≐y
Figure USRE046380-20170425-P00001

Figure USRE046380-20170425-P00002
c(z)≡{sorting by variable}∃z·a(x)
Figure USRE046380-20170425-P00001
c(x)
Figure USRE046380-20170425-P00001
b(y)
Figure USRE046380-20170425-P00001
x≐y
Figure USRE046380-20170425-P00001

z≐y
Figure USRE046380-20170425-P00001
Figure USRE046380-20170425-P00002
c(z)≡{pushing in ∃}a(x)
Figure USRE046380-20170425-P00001
c(x)
Figure USRE046380-20170425-P00001
b(y)
Figure USRE046380-20170425-P00001
x≐y
Figure USRE046380-20170425-P00001

∃z·z≐y
Figure USRE046380-20170425-P00001
Figure USRE046380-20170425-P00002
c(z)≡{eliminating≐under ∃}a(x)
Figure USRE046380-20170425-P00001
c(x)
Figure USRE046380-20170425-P00001
b(y)
Figure USRE046380-20170425-P00001

x≐y
Figure USRE046380-20170425-P00001
Figure USRE046380-20170425-P00002
c(y)≡{sorting again}a(x)
Figure USRE046380-20170425-P00001
c(x)
Figure USRE046380-20170425-P00001
b(y)
Figure USRE046380-20170425-P00001
Figure USRE046380-20170425-P00002
c(y)
Figure USRE046380-20170425-P00001
x≐y

We will now introduce data structures that represent formulae in solved form, and develop a containment checking algorithm that works directly on this representation.

We define an order on type propositions by taking φ<: ψ to mean | |h|

Figure USRE046380-20170425-P00022
|φ|→|ψ|, where |h| is the propositional formula corresponding to
Figure USRE046380-20170425-P00013
as defined above. It is not hard to see that this holds precisely when φ
Figure USRE046380-20170425-P00020
Figure USRE046380-20170425-P00021
ψ. In the remainder, we will identify type propositions that are equivalent under <: so that it becomes a partial order. Where needed, we make equivalence under <: explicit by writing it as ≡
Figure USRE046380-20170425-P00021
.

If t is a single type proposition and C a set of type propositions, we write t<:C (C<:t) to mean that t<:c (c<:t) for some c∈C.

The order <: can be extended to sets of type propositions by defining C<:D to mean that for any d∈D there is some c∈C with c<:d. This order is clearly reflexive and transitive, and is anti-symmetric (and hence a partial order) on lean sets, i.e. sets C where c<:c′ for c, c′∈C implies c=c′. One way of making a set of type propositions lean is to discard its non-minimal elements, which we write as min(C).

We can represent every disjunct of a formula in solved form using the following data structure:

Definition 1. An n-ary type tuple constraint, or TTC, τ is a structure (t1, . . . , tn|p|C) where

    • each component ti is a type proposition,
    • p is an equivalence relation over {1, . . . , n},
    • C is a set of type propositions called inhabitation constraints, such that
    • for all 1≦i, j≦n with i˜p j (i.e., i and j belong to the same partition of p) we have ti=tj,
    • C is lean,
    • for all 1≦k≦n we have C<:tk.

If p is a relation, we write p to mean the smallest equivalence relation containing it. The equivalence class of an element x under p is written [x]p, where we omit the subscript p if it is clear from context. We call an equivalence relation q finer (or, more precisely, no coarser) than p if whenever x˜qy then also x˜py.

Whenever we have a pre-TTC τ=(t1, . . . , tn|p|C) that does not satisfy one of the requirements, we can build a TTC that does by setting
∥τ∥:=(∥t1 p . . . , ∥tn p |p|,om(C∪{t1, . . . , tn}))
where ∥tiq=

Figure USRE046380-20170425-P00022
{tj|i˜qj}.

For a TTC τ=(t1, . . . , tn|p|C), we define τi:=ti, and τi:=r is the TTC resulting from τ by replacing the component ti (and every component tj where i˜p j) by r and adding r to the inhabitation constraints.

The formula represented by a TTC is easily recovered:

Definition 2. Given a list of n different element variables x1, . . . , xn, we define the type program [τ](x1, . . . , xn) corresponding to a TTC τ=(t1, . . . , tn|p|C) as

( 1 k n t i ( x i ) ) ( i p j x i x j ) ( c C y · c ( y ) )

A TTC is called degenerate if ⊥ is among its inhabitation constraints; it represents an unsatisfiable formula. The equivalence relation is called trivial if it is in fact the identity relation id, and the set of inhabitation constraints is called trivial if it only constrains the component types to be inhabited. When writing a TTC, we will often leave out trivial partitionings or inhabitation constraints.

We extend the order <: to TTCs component-wise:

Definition 3. For two n-ary TTCs τ=(t1, . . . , tn|p|C) and τ′=(t1′, . . . , tn′|p′|C′) we define τ<:τ′ to hold iff

    • for every 1≦i≦n we have ti<:ti′,
    • p′ is finer than p,
    • C<:C′.

It is routine to check that this defines a partial order with maximal element τTTC=(τ, . . . , τ), with binary meets defined by

( t 1 , , t n p C ) _ ( t 1 , , t n p C ) = ( t 1 t 1 , , t n t n p p C C ) ( 4 )

Since all type programs can be brought into solved form, we can represent them as sets of TTCs.

Definition 4. A lean set of non-degenerate TTCs is called a typing.

The formula represented by a typing is
[T]:=

Figure USRE046380-20170425-P00023

The order <: is extended to typings by defining T<:T′ to hold if, for every τ∈T there is a τ′∈T′ with τ<:τ′.

To convert any set of TTCs into a typing we can eliminate all non-maximal and degenerate TTCs from it; this operation we will denote by max.

The order on typings is again a partial order with least element ∅ and greatest element {τTTC}. Binary meets can be defined point-wise as
T

Figure USRE046380-20170425-P00024
T′=max({τ
Figure USRE046380-20170425-P00024
τ′|τ∈T, τ′∈T′}  (5)
and joins are given by
T
Figure USRE046380-20170425-P00025
T′=max(T∪T′)  (6)

We will now show that every type program can be translated to a typing. We already have enough structure to model conjunction and disjunction; existential quantification is also not hard to support.

Definition 5. The i-th existential of a TTC τ=(t1, . . . , tn|p|C), where 1≦i≦n, is defined as
i(τ):=(t1, . . . , ti−1, ti+1, . . . , tn|p′|min(C∪{ti}))
where p′ is the restriction of p to {1, . . . , i−1, i+1, . . . , n}.

The existential of a typing is defined pointwise:
i(T):=max{∃i(τ)|τ∈T}

To see that this models the existential quantifier on type programs, we can easily convince ourselves of the following:

Lemma 6. Let τ be an n-ary TTC,

Figure USRE046380-20170425-P00008
an interpretation and σ a statement. Then
Figure USRE046380-20170425-P00008
| σ [∃i(τ)] iff there is a domain element d such that
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ, x i :=d[τ]. An analogous statement holds for typings.

Although typings cannot directly represent type programs with fixpoint definitions or free relation variables, we can translate every closed type program to a typing by eliminating definitions. Let us start with a translation relative to an assignment to free relation symbols.

Definition 6. Let φ be a type program without fixpoint definitions containing the intensional relation variables r1, . . . , rm and the element variables x1, . . . , xn. We translate it to a mapping

Figure USRE046380-20170425-P00026
φ
Figure USRE046380-20170425-P00027
: Typingm→Typing by recursion on the structure of φ:
Figure USRE046380-20170425-P00026
Figure USRE046380-20170425-P00027
({right arrow over (T)})=∅
Figure USRE046380-20170425-P00026
xi≐xj
Figure USRE046380-20170425-P00027
({right arrow over (T)})={(τ, . . . , τ|{{ij}})}
Figure USRE046380-20170425-P00026
u(xj)
Figure USRE046380-20170425-P00027
({right arrow over (T)})={τTTC j:=u}
Figure USRE046380-20170425-P00026
Figure USRE046380-20170425-P00002
u(xj)
Figure USRE046380-20170425-P00027
({right arrow over (T)})={τTTC j:=
Figure USRE046380-20170425-P00002
u}
Figure USRE046380-20170425-P00026
ri({right arrow over (x)})
Figure USRE046380-20170425-P00027
({right arrow over (T)})=Ti
Figure USRE046380-20170425-P00026
ψ
Figure USRE046380-20170425-P00022
X
Figure USRE046380-20170425-P00027
({right arrow over (T)})=(ψ)({right arrow over (T)})
Figure USRE046380-20170425-P00024
Figure USRE046380-20170425-P00026
X
Figure USRE046380-20170425-P00027
({right arrow over (T)})
Figure USRE046380-20170425-P00026
ψ
Figure USRE046380-20170425-P00022
X
Figure USRE046380-20170425-P00027
({right arrow over (T)})=(ψ)({right arrow over (T)})
Figure USRE046380-20170425-P00025
Figure USRE046380-20170425-P00026
X
Figure USRE046380-20170425-P00027
({right arrow over (T)})
Figure USRE046380-20170425-P00026
∃xi
Figure USRE046380-20170425-P00027
({right arrow over (T)})=∃i(
Figure USRE046380-20170425-P00026
ψ
Figure USRE046380-20170425-P00027
({right arrow over (T)}))

It is easy to check that

Figure USRE046380-20170425-P00026
φ
Figure USRE046380-20170425-P00027
is a monotonic mapping for every φ with respect to the order <:, and since the set of typings is finite its least fixpoint can be computed by iteration. Thus we can translate every type program φ which does not have free relation variables into a typing
Figure USRE046380-20170425-P00026
φ
Figure USRE046380-20170425-P00027
which represents it:

Lemma 7. For every type program φ without free relation variables, we have φ

Figure USRE046380-20170425-P00028
Figure USRE046380-20170425-P00021
[
Figure USRE046380-20170425-P00026
φ
Figure USRE046380-20170425-P00027
].

Proof Sketch. In fact, we can show that, for any type program φ with m free relation variables and every m-tuple {right arrow over (T)} of typings, we have the equivalence φ([{right arrow over (T)}])

Figure USRE046380-20170425-P00028
[
Figure USRE046380-20170425-P00026
φ
Figure USRE046380-20170425-P00027
({right arrow over (T)})], where [{right arrow over (T)}] is the m-tuple of type programs we get from applying [•] to every component of {right arrow over (T)}.

This can be proved by structural induction on φ by showing that [

Figure USRE046380-20170425-P00026
Figure USRE046380-20170425-P00027
] commutes with the logical operators (using Lemma 6 for the case of existentials) and with fixpoint iteration. The lemma then follows for the case m=0.

4. Containment Checking

We are now going to investigate the relation between the orders <: (component-wise or syntactic subtyping) and

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00021
(semantic subtyping). The former is convenient in that it can be checked component-wise and only involves propositional formulae, so it would be nice if we could establish that T1<:T2 iff [T1]|
Figure USRE046380-20170425-P00021
[T2].

Unfortunately, this is not true. The ordering <: is easily seen to be sound in the following sense:

Theorem 8. For any two typings T and T′, if T<:T′ then [T]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00021
[T′].

However, it is not complete. Consider, for example, the typings T={(b

Figure USRE046380-20170425-P00005
c, a)} and T′={(a
Figure USRE046380-20170425-P00005
b, a), (c
Figure USRE046380-20170425-P00005
d, a)}. Clearly we have [T]
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00021
[T′], yet T
Figure USRE046380-20170425-P00029
T′.

If we interpret type symbols as intervals of real numbers, this example has an intuitive geometric interpretation, shown in FIG. 4.

The individual TTCs then become rectangles in the two-dimensional plain, and it is easy to see that the single TTC in T (depicted by the single rectangle in heavy outline filled with vertical lines) is contained in the union of the TTCs in T′ (the two rectangles filled with slanted lines), but not in either one of them in isolation.

A similar problem can arise from the presence of equality constraints: Consider the typings T={(a

Figure USRE046380-20170425-P00005
b, a
Figure USRE046380-20170425-P00005
b|{{1, 2}})} and T′={(a, a), (b, b)}. The former appears in FIG. 5 as a heavy slanted line, which is not contained in either of the two squares representing the TTCs in T′, but only in their union.

Intuitively, the problem is that <: tests containment of TTCs in isolation, whereas the semantic inclusion check considers containments between sets of TTCs.

The following lemma paves the way for a solution:

Lemma 9. The mapping [•] is the lower adjoint of a Galois connection, i.e. there is a mapping (|•|) from type programs to typings such that
[T]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00015
iff T<:(|
Figure USRE046380-20170425-P00015
|)

Proof. As we have established, typings and type programs form complete lattices under their respective orders. Since [•] distributes over joins it must be the lower adjoint of a Galois connection between these lattices.

An immediate consequence of this is that [T1]

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00008
[T2] implies T1<:(|[T2]|). To check, then, whether T1 is semantically contained in T2, we compute (|[T2]|) and check for component-wise inclusion.

One possible implementation of (|•|) comes directly from the definition of the Galois connection: For any type program

Figure USRE046380-20170425-P00015
, (|
Figure USRE046380-20170425-P00015
|) is the greatest typing T such that [T]
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00015
, and since there are only finitely many typings and containment is decidable we could perform an exhaustive search to find this T.

Clearly, this algorithm is not ideal, since one of our goals is to avoid having to explicitly decide the relation

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
. Inspiration for a better solution comes from a perhaps somewhat unexpected direction, namely the theory of Boolean function minimisation:

Quine [22] introduces an algorithm whose first part determines the set of prime implicants of a Boolean formula, which are conjunctive formulae such that every conjunctive formula that implies the original formula implies one of the prime implicants.

Generalising from conjunctions to TTCs and from propositional formulae to typings, we will introduce a saturation mapping sat that generates the set of all prime implicant TTCs for a typing, which are TTCs such that every TTC that (semantically) entails the typing entails one of them componentwise. Hence whenever [T1]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[T2] we have T1<:sat(T2), so sat is an implementation of (|[•]|). The saturation mapping also preserves semantics, so the other direction of the implication holds as well.

We can follow Quine's definitions and proofs almost paragraph by paragraph, starting with the generalisation of the consensus operation:

Definition 7. The consensus τ⊕J τ′ over J of two n-ary TTCs τ and τ′, where J{1, . . . , n} is an index set, is defined by

( t 1 , , t n p C ) J ( t 1 , , t n p C ) = ( u 1 , , u n p p J × J C C )

where

u i = { j J t j j J t j if i J t i t i otherwise

We will sometimes write

Figure USRE046380-20170425-P00001
J τ for
Figure USRE046380-20170425-P00001
j∈J t j.

Roughly, the consensus operation equates all columns in J and preserves all other equalities and inhabitation constraints of its operands, takes disjunctions over the columns in J, and conjunctions over all the others.

For example, in the example shown in FIG. 5 we can take the consensus of (a, a) and (b, b) over J={1, 2} to obtain the TTC (a

Figure USRE046380-20170425-P00005
b, a
Figure USRE046380-20170425-P00005
b|{{1, 2}}), which is precisely the missing piece to show that T is a subtype of T′.

In the particular case where J={j} is a singleton set, and both partitions and inhabitation constraints are trivial, the consensus takes conjunctions on all columns except j, where it takes a disjunction. This is a generalisation of the behaviour of the consensus operator used in the minimisation of Boolean functions.

For example, in FIG. 4 we can take the consensus of (a

Figure USRE046380-20170425-P00005
b, a) and (c
Figure USRE046380-20170425-P00005
d, a) on J={1} to obtain the TTC (a
Figure USRE046380-20170425-P00005
b
Figure USRE046380-20170425-P00005
c
Figure USRE046380-20170425-P00005
d, a) which covers (b
Figure USRE046380-20170425-P00005
c, a).

We need another kind of consensus to deal with inhabitation constraints:

Definition 8. The existential consensus of two n-ary TTCs τ and τ is defined by

( t 1 , , t n p C ) ( t 1 , , t n p C ) = ( t 1 t 1 , , t n t n p p C C )
where C

Figure USRE046380-20170425-P00005
C′={c
Figure USRE046380-20170425-P00005
c′|c∈C, c′∈C′}.

To see why this is necessary, assume we have type symbols a, b, c with

Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00014
∀x.a(x)
Figure USRE046380-20170425-P00005
b(x)→c(x), and consider typings T={(c|id|a
Figure USRE046380-20170425-P00005
b)} and T′={(c|id|a), (c|id|b)}. Clearly, [T]=c(x1)
Figure USRE046380-20170425-P00005
∃z.(a(z)
Figure USRE046380-20170425-P00005
b(z))=[T′], yet T
Figure USRE046380-20170425-P00029
T′ since {a
Figure USRE046380-20170425-P00005
b}
Figure USRE046380-20170425-P00029
:{a} and {a
Figure USRE046380-20170425-P00005
b}
Figure USRE046380-20170425-P00029
:{b}. However, if we add the existential consensus (c|id|a
Figure USRE046380-20170425-P00005
b) to T′, we will be able to prove that T<:T′.

It is not hard to verify that adding the consensus of two TTCs to a typing does not change its semantics.

Lemma 10. For two TTCs τ, τ and an index set J we have [τ⊕Jτ′]

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
[{τ, τ′}] and [τ⊕τ′]
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
[{τ, τ′}].

Proof Sketch. Clearly, if J=∅ the consensus is just the meet, so nothing needs to be proved.

Otherwise, let

Figure USRE046380-20170425-P00008
and σ be given such that
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ[τ⊕Jτ′]. Then, for some i∈J, either
Figure USRE046380-20170425-P00008
| σ
Figure USRE046380-20170425-P00001
j∈Jtj(xi) or
Figure USRE046380-20170425-P00008
| σ
Figure USRE046380-20170425-P00001
j∈Jtj′; in the former case
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ[τ], and in the latter case
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
σ[τ′].

For the existential consensus, assume

Figure USRE046380-20170425-P00008
|σ[τ⊕τ′] and further assume there is some inhabitation constraint c of τ such that
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00030
┌y.c(y) (for otherwise
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
σ[τ] is immediate). We must have
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
∃y.c(y)
Figure USRE046380-20170425-P00005
c′(y) for all inhabitation constraints c′ of τ′, so certainly
Figure USRE046380-20170425-P00008
| ∃y.c′(y). We then easily see that
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ[τ′].

Remember that typings do not contain non-maximal elements. The following result shows that we do not lose anything by eliminating them.

Lemma 11. Consensus formation is monotonic in the sense that for TTCs σ, σ′, τ, τ′ with σ<:σ′ and τ<:τ′ and for an index set J we have σ⊕Jτ<: σ′⊕Jτ′ and σ⊕τ<:σ′⊕τ′

Proof Sketch. The components of the two TTCs are combined using conjunction and disjunction, which are monotonic with respect to subtyping, and the partitionings and inhabitation constraints are combined using set union which is also monotonic.

Definition 9. An n-ary typing T is said to be saturated if the consensus of any two TTCs contained in it is covered by the typing; i.e. for any τ, τ′∈T and any index set J{1, . . . , n} we have τ⊕Jτ′<:T and τ⊕τ′<:T.

Lemma 12. Every typing T can be converted into a semantically equivalent, saturated typing sat(T) by exhaustive consensus formation.

Proof. We use Algorithm 2 to collect all consensus TTCs of two given TTCs. As shown in Algorithm 1, this is performed for every pair of TTCs in the typing, and this procedure is repeated until a fixpoint is reached.

Notice that in each iteration (except the last) the set of TTCs covered by the typing becomes larger, and since there are only finitely many TTCs, the termination condition must become true eventually.

We now generalise the concepts of implicants and prime implicants.

Definition 10. A TTC τ is an implicant for a typing T′ if we have [τ]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[T′]; it is a prime implicant if it is a <:-maximal implicant.

More explicitly, a TTC π is a prime implicant for a typing T′ if

1. π is an implicant of T′

2. For any τ with π<:τ and [τ]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[T′], we have τ<:π.

The second condition is equivalent to saying that for any τ with τ<:τ and τ

Figure USRE046380-20170425-P00029
:π we have [τ]
Figure USRE046380-20170425-P00031
Figure USRE046380-20170425-P00013
[T].

Lemma 13. Every implicant implies a prime implicant.

Proof. The set of all implicants of a typing is finite, so for any implicant τ there is a maximal implicant π with τ<:π, which is then prime by definition.

Remark 14. If π is a prime implicant of T, then π<:T iff π∈T.

Proof. The direction from right to left is trivial. For the other direction, suppose π<:T, i.e. π<:π′ for some π′∈T. Certainly [π′]

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
[T], so π′<:π since π is prime. But this means that π=π′∈T.

We want to show that sat(T) contains all prime implicants of T, so we show that saturation can continue as long as there is some prime implicant not included in the saturated set yet.

Lemma 15. If there is a prime implicant π of T with π∉T, then T is not saturated.

Proof. Let π be a prime implicant of T with π∉T. Consider the set
M:={τ|[τ]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[π], τ
Figure USRE046380-20170425-P00029
:T}
This set is not empty (it contains π by the preceding remark) and it is finite, so we can choose a <:-minimal element ψ∈M.

The proof proceeds by considering three cases. In the first, we shall show that a consensus step is possible, thus proving that T is not saturated. In the second, we show that an existential consensus step can be made, again proving non-saturation. Finally, we show that either the first or second case must apply, as their combined negation leads to a contradiction.

    • Assume there is an index i for which ψi
      Figure USRE046380-20170425-P00013
      r′
      Figure USRE046380-20170425-P00005
      r″ for two r′, r″ neither of which equals ψi.
    • Then we form ψ′:=ψi:=r′ and ψ″:=ψi:=r″. Observe that ψ and ψ are strictly smaller than ψ, so they cannot be in M. They both, however, entail π, so there must be φ′, φ″ ∈ T with ψ′<:φ′ and ψ<:φ″.
    • Note that ψ=ψ′ ⊕[i] φ″, where [i] is the equivalence class of i in ψ. By Lemma 11, this means that ψ<:φ′⊕[i]φ″, and since ψ
      Figure USRE046380-20170425-P00029
      :T we also have φ′⊕[i]φ″
      Figure USRE046380-20170425-P00029
      :T, which shows that T is not saturated.
    • Assume for some c∈C, where C is the set of inhabitation constraints of ψ, we have c≡
      Figure USRE046380-20170425-P00013
      r′
      Figure USRE046380-20170425-P00005
      r″ for two r′, r″ neither of which equal c.
    • We form ψ from ψ by setting the inhabitation constraints to C\{c} ∪ {r′} and minimising, and similarly for ψ″. As above, those two are strictly smaller than ψ and we can find φ′ and φ″. The proof goes through as in the previous case, since it is easy to see that ψ=ψ′⊕ψ″.
    • Otherwise, for any index i and r′, r″ with ψi
      Figure USRE046380-20170425-P00013
      r′
      Figure USRE046380-20170425-P00005
      r″ we have either ψi
      Figure USRE046380-20170425-P00013
      r′ or ψi
      Figure USRE046380-20170425-P00013
      r″ (i.e. every ψi is join-irreducible) and likewise for all c∈C.

We will show that in this case ψ<:T, contrary to our assumptions. We know that [ψ] |

Figure USRE046380-20170425-P00013
[T], so any interpretation
Figure USRE046380-20170425-P00008
and assignment σ with
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
and
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
σ [ψ] will satisfy some TTC τ∈E T. Put differently, if
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
σ(
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
ψ) (xi) for all i and
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
∃y.(
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00005
c) (y) for all inhabitation constraints c and moreover a satisfies the partition of ψ, then we will find τ∈T with
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
τ[τ].

Observe that for every i the (propositional) formula |h|

Figure USRE046380-20170425-P00001
i| can be written as a conjunction li, l
Figure USRE046380-20170425-P00001
. . .
Figure USRE046380-20170425-P00001
li, m i of type literals. We can moreover assume that every type symbol occurs in precisely one of these literals, for if, say, type t does not occur, then li, 1
Figure USRE046380-20170425-P00001
. . .
Figure USRE046380-20170425-P00001
li, m i
Figure USRE046380-20170425-P00001
t
Figure USRE046380-20170425-P00005
li, 1
Figure USRE046380-20170425-P00001
. . .
Figure USRE046380-20170425-P00001
li, m i
Figure USRE046380-20170425-P00005
Figure USRE046380-20170425-P00002
is a join reduction of |h|
Figure USRE046380-20170425-P00001
i|.

Let such a decomposition be fixed and let Li:={1 i, 1, , . . . , li, m i }. Since ψij whenever i and j are in the same partition, we can clearly choose the decomposition such that Li=Lj in this case. Likewise, for every inhabitation constraint c we can write |h|

Figure USRE046380-20170425-P00001
|c| as lc, 1
Figure USRE046380-20170425-P00001
. . .
Figure USRE046380-20170425-P00001
lc, m c , and define Lc by analogy.

We define an interpretation

Figure USRE046380-20170425-P00008
over the domain {x[1], . . . , x[n]}∪C of variables modulo the partition of ψ plus the inhabitation constraints by
Figure USRE046380-20170425-P00008
(b)={x[i]|b∈Li}∪{c|b∈Lc}
for every type symbol b. The assignment is simply defined by σ(xi)=x[i].

It is easy to see that x[i]∈[[l]] iff l∈Li for all 1≦i≦n, and c∈[[l]] iff l∈Lc for all inhabitation constraints c, from which we deduce

Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00014
σ (
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
ψi) (xi) for all i, and
Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
∃y.(
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
) (y) for all inhabitation constraints c. By definition, σ satisfies the partition of ψ. So we have some τ∈T with
Figure USRE046380-20170425-P00008
| σ[τ].

We claim that ψ<:T.

Indeed, let an index 1≦i≦n be given. Then we can write τi as a disjunction of conjunctions, such that one of its disjuncts, of the form li, 1

Figure USRE046380-20170425-P00001
. . .
Figure USRE046380-20170425-P00001
li, m i′ ′, is satisfied under
Figure USRE046380-20170425-P00008
and σ, meaning that x[i]∈[[li,j′]]
Figure USRE046380-20170425-P00008
for all j, so all the li,j′ are in fact in Li, so ψi<:τi.

Since σ satisfies the partition of τ, this partition must be finer than the partition of ψ.

Finally, let an inhabitation constraint d of τ be given. Since

Figure USRE046380-20170425-P00008
Figure USRE046380-20170425-P00009
∃y.(
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
) (y), the interpretation of
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
d cannot be empty. As above, we can write
Figure USRE046380-20170425-P00013
Figure USRE046380-20170425-P00001
d in a disjunctive form such that all the literals in one of its disjuncts are non-empty in
Figure USRE046380-20170425-P00008
. So there must be some domain element that occurs in the denotation of all these literals. If it is one of the x[i], then we have ψi<:d, which implies c<:d for some inhabitation constraint c of ψ; if it is an inhabitation constraint c, then we have c<:d directly.

Taking these facts together, we get ψ<:τ, whence ψ<:T. This contradicts our assumption, and we conclude that this subcase cannot occur.

Now we can declare victory:

Theorem 16. If [T1]

Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[T2], then T1<:sat(T2).

Proof. Assume [T1]

Figure USRE046380-20170425-P00014
Figure USRE046380-20170425-P00013
[T2] and let τ∈T1 be given. Then [τ]
Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[T2], so certainly [τ]
Figure USRE046380-20170425-P00009
Figure USRE046380-20170425-P00013
[sat(T2)], since saturation does not change the semantics. By Lemma 13 this means that there is a prime implicant π of sat(T2) with τ<:π. By Lemma 15 we must have π∈sat(T2), so τ<: sat(T2). Since this holds for any τ∈T1 we get T1<:sat(T2).

5. Implementation

It is not immediately clear that the representation for type programs proposed in the preceding two sections can be implemented efficiently. While the mapping ┌•┐ from programs to type programs is, of course, easy to implement and linear in the size of the program, the translation of type programs into their corresponding typings involves fixpoint iterations to eliminate definitions. Saturation is also potentially very expensive, since we have to compute the consensus on every combination of columns for every pair of TTCs in a typing, and repeat this operation until a fixpoint is reached.

We report in this section on our experience with a prototype implementation based on Semmle's existing type checking technology as described in [13]. The type checker computes typings for programs and immediately proceeds to saturate them to prepare for containment checking. It uses a number of simple heuristics to determine whether a consensus operation needs to be performed. This drastically reduces the over-head of saturation in practice and makes our type inference algorithm practically usable.

TTCs can be compactly represented by encoding their component type propositions as binary decision diagrams. The same can be done for the hierarchy, so checking containment of type propositions can be done with simple BDD operations.

As with any use of BDDs, it is crucial to find a suitable variable order. We choose a very simple order that tries to assign neighbouring indices to type symbols that appear in the same conjunct of the hierarchy formula

Figure USRE046380-20170425-P00013
. For example, if the hierarchy contains a subtyping statement u1(x)→u2(x) or a disjointness constraint
Figure USRE046380-20170425-P00002
(u1(x)
Figure USRE046380-20170425-P00001
u2(x)), then u1 and u2 will occupy adjacent BDD variables. This heuristic is simple to implement and yields reasonable BDD sizes as shown below.

To mitigate the combinatorial explosion that saturation might bring with it, we avoid useless consensus formation, i.e. we will not form a consensus τ⊕τ′ if τ⊕τ′<:{τ, τ′} or τ⊕τ′ is degenerate. The following lemma provides a number of sufficient conditions for a consensus to be useless:

Lemma 17. Let τ=(t1, . . . , tn|p|C) and τ′=(t1′, . . . , tn′|p′|C′) be two TTCs and J {1, . . . , n} a set of indices. Then the following holds:

    • 1. If N:={i|ti
      Figure USRE046380-20170425-P00001
      ti′=⊥} J then τ⊕Jτ′ is degenerate.
    • 2. If
      Figure USRE046380-20170425-P00001
      ∈Jtj=⊥ or
      Figure USRE046380-20170425-P00001
      ∈Jtj′=⊥, then τ
      Figure USRE046380-20170425-P00001
      J′τ′<:{τ, τ′} for any J′J.
    • 3. If we have l∉J with
      Figure USRE046380-20170425-P00001
      j∈Jtj<:tl and
      Figure USRE046380-20170425-P00001
      j∈Jtj′<:tj′, then τ⊕J∪{l}τ′<:τ⊕Jτ′.
    • 4. If
      Figure USRE046380-20170425-P00001
      j∈Jtj<:
      Figure USRE046380-20170425-P00001
      j∈Jtj′ or vice versa, then τ⊕Jτ′<:{τ, τ′}.
    • 5. For j∈J, j′∉J with j˜ p∪p′ j′ we have τ⊕Jτ′<:τ⊕J∪{j′}τ′.
    • 6. If N≠∅, then τ⊕τ′ is degenerate.

Proof. Recall that τ⊕Jτ′=∥(u1, . . . , un|p∪p′∪J×J|C∪C′)∥ where

u i = { j J t j j J t j if i J t i t i otherwise
We prove the individual claims:

    • 1. Indeed, assume k∈N\J, then uk=tk
      Figure USRE046380-20170425-P00001
      tk′=⊥.
    • 2. Assume, for example,
      Figure USRE046380-20170425-P00001
      j∈Jtj=⊥ and let J′J be given, then
      Figure USRE046380-20170425-P00001
      ∈J′tj=⊥, so ui=
      Figure USRE046380-20170425-P00001
      j∈J′t′j′<:ti′ if i∈J, and ui=ti
      Figure USRE046380-20170425-P00001
      ti′<:ti′ otherwise, so τ⊕J′τ′<:τ′. If the other disjunct is ⊥, we see that τ⊕J′τ′<:τ by a similar argument.
    • 3. Note that
      Figure USRE046380-20170425-P00001
      j∈J∪{l}tj=
      Figure USRE046380-20170425-P00001
      j∈J tj and
      Figure USRE046380-20170425-P00001
      j∈J∪{l}tj′=
      Figure USRE046380-20170425-P00001
      ∈Jtj′, so τ⊕J∪{l}τ′<:τ⊕Jτ′.
    • 4. The argument is similar to 2.
    • 5. Writing J′ for J ∪ {j′}, we see that the partitioning will be the same for J and J′. Now consider the ith component of τ
      Figure USRE046380-20170425-P00032
      Jτ′. If i˜i′ for some i′ ∈ J, then i˜j′, so we have
      Figure USRE046380-20170425-P00032
      Jτ′)i=(
      Figure USRE046380-20170425-P00001
      j∈Jtj
      Figure USRE046380-20170425-P00005
      Figure USRE046380-20170425-P00001
      j∈Jt′j)
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      {tk
      Figure USRE046380-20170425-P00001
      t′k|k˜i, k∉J}=
      (
      Figure USRE046380-20170425-P00001
      j∈Jtj
      Figure USRE046380-20170425-P00005
      Figure USRE046380-20170425-P00001
      j∈Jt′j)
      Figure USRE046380-20170425-P00001
      (tj′
      Figure USRE046380-20170425-P00001
      t′j′)
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      {tk
      Figure USRE046380-20170425-P00001
      t′k|k˜i, k∉J′}=
      (t′j′
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      j∈J′tj
      Figure USRE046380-20170425-P00005
      tj′
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      j∈J′ t′j)
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      {tk
      Figure USRE046380-20170425-P00001
      t′k|k˜i, k∉J′}<:(
      Figure USRE046380-20170425-P00001
      j∈J′ tj
      Figure USRE046380-20170425-P00005
      Figure USRE046380-20170425-P00001
      j∈J′ t′j)
      Figure USRE046380-20170425-P00001
      Figure USRE046380-20170425-P00001
      {tk
      Figure USRE046380-20170425-P00001
      t′k|k˜i, k∈J′}=(τ⊕J′ τ′)i

Otherwise we have (τ

Figure USRE046380-20170425-P00032
Jτ′)i=(τ
Figure USRE046380-20170425-P00032
J′τ′), so overall τ
Figure USRE046380-20170425-P00032
Jτ′<:τ
Figure USRE046380-20170425-P00032
J′τ′.

    • 6. Obvious, since the components of τ⊕τ′ are obtained by forming the meet.

This suggests an improved implementation of Algorithm 2, shown in two parts as Algorithm 3 and Algorithm 4, which straightforwardly exploit the above properties to avoid performing useless consensus operations whose result would be discarded by the maxoperator anyway. In the latter, we make use of an operation PART(ν, i) which returns the equivalence partition index i belongs to in TTC ν.

To show that these improvements make our type inference algorithm feasible in practice, we measure its performance on some typical programs from our intended application domain. The Datalog programs to be typed arise as an intermediate representation of programs written in a high-level object-oriented query language named .QL [14, 15], which are optimised and then compiled to one of several low-level representations for execution.

We measure the time it takes to infer types for the 89 queries in the so-called “Full Analysis” that ships with our source code analysis tool SemmleCode. These queries provide statistics and overview data on structural properties of the analysed code base, compute code metrics, and check for common mistakes or dubious coding practices.

A type inference for the query being compiled is performed at three different points during the optimisation process, giving a total of 267 time measurements. All times were measured on a machine running a Java 1.6 virtual machine under Linux 2.6.28-13 on an Intel Core2 Duo at 2.1 GHz with four gigabytes of RAM, averaging over ten runs, and for each value discarding the lowest and highest reading.

Of the 267 calls to type inference, 65% finish in 0.5 seconds or less, 71% take no more than one second, 93% no more than two, and in 98% of the cases type inference is done in under three seconds. Only two type inferences take longer than four seconds, at around 4.5 seconds each.

The size of the programs for which types are inferred varies greatly, with most programs containing between 500 and 1500 subterms, but some programs are significantly larger at more than 3000 subterms. Interestingly, program size and type inference time are only very weakly correlated (p<0.4), and the correlation between the number of stratification layers (which roughly corresponds to the number of fixpoint computations to be done) and type inference time is also not convincing (ρ<0.6).

The low correlation is evident in FIG. 6 which shows the type inference time plotted on the y-axis versus the depth (i.e., number of layers) of the program on the x-axis. In particular, the two cases in which type inference takes longer than four seconds are both of medium size and not among the deepest either.

This suggests that the asymptotic behaviour of the algorithm in terms of input size is masked by the strong influence of implementation details (at least for the kind of programs we would expect to deal with in our applications), and we can expect significant performance gains from fine tuning the implementation.

Our experiments also show that saturation, while extremely expensive in theory, is quite well-behaved in practice: in 78% of all cases, no new TTCs are added during the first iteration of Algorithm 1, so the typing is already saturated. In another 17% of all cases we need only one more iteration, and we almost never (≈0.01%) need to do more than four iterations.

Although in every individual iteration we potentially have to take the consensus over every combination of columns, our heuristics manage to exclude all combinations of more than one column in 94% of all cases, and sometimes (14%) can even show that no consensus formation is needed at all.

Since our type inference algorithm makes heavy use of BDDs, some statistics about their usage may also be of interest. We use about 300 BDD variables (one for every type symbol), with most of the BDDs constructed during type checking being of rather moderate size: the BDD to represent the type hierarchy (which encodes about 800 constraints automatically derived during translation from .QL to Datalog) occupies around 4000 nodes, while the BDDs for individual type propositions never take more than 100 nodes.

While we have anecdotal evidence to show that the optimisation techniques we have presented in earlier work [13] benefit greatly from combining them with the richer type hierarchies our type system supports, we leave the precise investigation of this matter to future work.

6. Benefits

The present invention handles negated types accurately. Also, the present invention handles inhabitation constraints (i.e., existentials in type programs) precisely.

We achieve pleasing theoretical properties and can support a rich language of type constraints by sacrificing polynomial time guarantees, although our experiments show that this is a reasonable tradeoff for our application area.

While the performance of our prototype implementation is promising, other implementation approaches certainly exist and may be worth exploring. Bachmair et al. [4] develop a decision procedure for monadic first order logic based on the superposition calculus. Since type programs can readily be expressed as monadic first order formulae, their algorithm could be used to decide type containment. Another possibility would be to use Ackermann's translation from monadic first order logic to equality logic [2], and then employ a decision procedure for this latter logic.

7. Review of High Level Flow Diagrams

FIG. 7 is a block diagram illustrating how types of database queries are inferred. Type inferencer 701 receives database schema 703 and query 704 and infers types from definitions in the program by replacing each use of a database relation in the program by the types in the database schema, resulting in type program 706 as described in the section above entitled “2. Type Programs.” The type inferencer furthermore receives type hierarchy 705 to check types in the type program for inclusion as described in the section above entitled “4. Containment Checking,” generating information about type inclusion 708. The type inferencer also uses the type hierarchy to generate emptiness information 710 indicating which types in the type program are empty as described in the section above entitled “2. Type Programs.” In one embodiment the inclusion and emptiness information is used by query optimizer 711 to generate an optimized version of the query that can be run on query engine 712 to query relational data source 713, as described in the section above entitled “1. Introduction,” subsection “Overview.”

FIG. 8 is a flow chart illustrating inclusion testing for types represented by sets of type tuple constraints (TTCs). To test inclusion of a type represented by a set S1 of TTCs 801 in a type represented by a set S2 of TTCs 802, set S2 is first saturated 803 by adding all prime implicants of all TTCs in S2 to the set, yielding a larger set S2804, as described in the section above entitled “4. Containment Checking.” All TTCs in S1 are then examined in turn 805, and for every TTC 807 in S1 it is checked whether there is a larger, covering TTC in S2808, as described in the section above entitled “4. Containment Checking,” subsection “Definition 7.” If no such larger TTC is found 809, the type represented by S1 is not included in S2. Otherwise the TTC is removed from S1 810 and the next TTC is examined. If a covering TTC is found for every TTC in S1 806, then the type represented by S1 is included in the type represented by S2.

FIG. 9 is a flow chart illustrating saturation of sets of type tuple constraints (TTCs) for inclusion testing. Starting with a given set S of TTCs 901, every pair of TTCs from S is considered in turn 902, and a consensus of the two TTCs is computed 903, as described in the section above entitled “3. Representing Type Programs,” subsection “Definition 4.” If S does not contain a TTC larger than the consensus 904, it is added to the set S 905. This is repeated until all pairs of TTCs have been considered 907.

8. Conclusion

We have presented a type inference procedure that assigns an upper envelope to each Datalog program. That envelope is itself a Datalog program that makes calls to monadic extensionals only. The algorithm is able to cope with complex type hierarchies, which may include statements of implication, equivalence and disjointness of entity types.

The type inference procedure is itself an extremely simple syntactic mapping. The hard work goes into an efficient method of checking containment between type programs. We achieve this via a novel adaption of Quine's algorithm for the computation of the prime implicants of a logical formula. Generalising from logical formulae to type programs, we bring types into a saturated form on which containment is easily checked.

As shown by our experiments, the algorithm for inferring a type and saturating it works well on practical examples. While it may still exhibit exponential behaviour in the worst case, such extreme cases do not seem to arise in our application area. Thus our algorithm is a marked improvement over well-known simpler constructions that always require an exponential overhead.

Many avenues for further work remain. Perhaps the most challenging of these is the production of good error messages when type errors are identified: this requires printing the Boolean formulae represented via TTCs in legible form. We have made some progress on this, employing Coudert et al.'s restrict operator on BDDs, which is another application of prime implicants [12].

There is also substantial further engineering work to be done in the implementation. Careful inspection of the statistics show that our use of BDDs is very much unlike their use in typical model checking applications [26], and we believe this could be exploited in the use of a specialised BDD package. For now we are using JavaBDD [25], which is a literal translation of a C-based BDD package into Java.

Finally, we will need to investigate how to best exploit the advanced features offered by our type system. In particular, much experience remains to be gained in how to make it easy and natural for the programmer to specify the constraints making up the type hierarchy, and which kinds of constraints benefit which kinds of programs.

9. Non-Limiting Hardware Examples

Overall, the present invention can be realized in hardware or a combination of hardware and software. The processing system according to a preferred embodiment of the present invention can be realized in a centralized fashion in one computer system, or in a distributed fashion where different elements are spread across several interconnected computer systems and image acquisition sub-systems. Any kind of computer system—or other apparatus adapted for carrying out the methods described herein—is suited. A typical combination of hardware and software is a general-purpose computer system with a computer program that, when loaded and executed, controls the computer system such that it carries out the methods described herein.

An embodiment of the processing portion of the present invention can also be embedded in a computer program product, which comprises all the features enabling the implementation of the methods described herein, and which—when loaded in a computer system—is able to carry out these methods. Computer program means or computer programs in the present context mean any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after either or both of the following a) conversion to another language, code or, notation; and b) reproduction in a different material form.

FIG. 10 is a block diagram of a computer system useful for implementing the software steps of the present invention. Computer system 1000 includes a display interface 1008 that forwards graphics, text, and other data from the communication infrastructure 1002 (or from a frame buffer not shown) for display on the display unit 1010. Computer system 1000 also includes a main memory 1006, preferably random access memory (RAM), and optionally includes a secondary memory 1012. The secondary memory 1012 includes, for example, a hard disk drive 1014 and/or a removable storage drive 1016, representing a floppy disk drive, a magnetic tape drive, an optical disk drive, etc. The removable storage drive 1016 reads from and/or writes to a removable storage unit 1018 in a manner well known to those having ordinary skill in the art. Removable storage unit 1018, represents a CD, DVD, magnetic tape, optical disk, etc. which is read by and written to by removable storage drive 1016. As will be appreciated, the removable storage unit 1018 includes a computer usable storage medium having stored therein computer software and/or data. The terms “computer program medium,” “computer usable medium,” and “computer readable medium” are used to generally refer to media such as main memory 1006 and secondary memory 1012, removable storage drive 1016, a hard disk installed in hard disk drive 1014, and signals.

Computer system 1000 also optionally includes a communications interface 1024. Communications interface 1024 allows software and data to be transferred between computer system 1000 and external devices. Examples of communications interface 1024 include a modem, a network interface (such as an Ethernet card), a communications port, a PCM-CIA slot and card, etc. Software and data transferred via communications interface 1024 are in the form of signals which may be, for example, electronic, electromagnetic, optical, or other signals capable of being received by communications interface 1024. These signals are provided to communications interface 1024 via a communications path (i.e., channel) 1026. This channel 1026 carries signals and is implemented using wire or cable, fiber optics, a phone line, a cellular phone link, an RF link, and/or other communications channels.

Although specific embodiments of the invention have been disclosed, those having ordinary skill in the art will understand that changes can be made to the specific embodiments without departing from the spirit and scope of the invention. The scope of the invention is not to be restricted, therefore, to the specific embodiments. Furthermore, it is intended that the appended claims cover any and all such applications, modifications, and embodiments within the scope of the present invention.

REFERENCES

Each of the following twenty-seven references are hereby incorporated by reference in their entirety.

  • [1] Serge Abiteboul, Georg Lausen, Heinz Uphoff, and Emmanuel Waller. Methods and rules. In ACM SIGMOD International Conference on Management of Data, pages 32-41. ACM Press, 1993.
  • [2] Wilhelm Ackermann. Solvable Cases of the Decision Problem. North-Holland Publishing Company, Amsterdam, 1954.
  • [3] Leo Bachmair, Harald Ganzinger, and Uwe Waldmann. Set constraints are the monadic class. In Logic in Computer Science, pages 75-83, 1993.
  • [4] Leo Bachmair, Harald Ganzinger, and Uwe Waldmann. Superposition with Simplification as a Decision Procedure for the Monadic Class with Equality. In KGC '93: Proceedings of the Third Kurt Gödel Colloquium on Computational Logic and Proof Theory, pages 83-96, London, UK, 1993. Springer-Verlag.
  • [5] Sacha Berger, Emmanuel Coquery, Wlodzimierz Drabent, and Artur Wilk. Descriptive Typing Rules for Xcerpt and their soundness. In Francois Fages and Sylvain Soliman, editors, Principles and Practice of Semantic Web Reasoning, volume 3703 of LNCS, pages 85-100. Springer, 2005.
  • [6] George S. Boolos and Richard C. Jeffrey. Computability and Logic. Cambridge University Press, 3rd edition, 1989.
  • [7] Ashok K. Chandra and Philip M. Merlin. Optimal Implementation of Conjunctive Queries in Relational Data Bases. In STOC '77: Proceedings of the ninth annual ACM symposium on Theory of computing, pages 77-90, New York, N.Y., USA, 1977. ACM.
  • [8] Surajit Chaudhuri. Finding nonrecursive envelopes for Datalog predicates. In Principles of Database Systems (PODS), pages 135-146, 1993.
  • [9] Surajit Chaudhuri and Phokion G. Kolaitis. Can Datalog be approximated? In Principles of Database Systems (PODS), pages 86-96, 1994.
  • [10] Kevin J. Compton. Stratified least fixpoint logic. Theoretical Computer Science, 131(1):95-120, 1994.
  • [11] Stavros Cosmadakis, Haim Gaifman, Paris Kanellakis, and Moshe Vardi. Decidable Optimization Problems for Database Logic Programs. In Proceedings of the 20th annual ACM Symposium on Computing, pages 477-490, 1988.
  • [12] Olivier Coudert, Christian Berthet, and Jean Christophe Madre. Verification of synchronous sequential machines based on symbolic execution. In Automatic Verification Methods for Finite State Systems, volume 407 of Lecture Notes in Computer Science, pages 365-373. Springer, 1989.
  • [13] Oege de Moor, Damien Sereni, Pavel Avgustinov, and Mathieu Verbaere. Type Inference for Datalog and Its Application to Query Optimisation. In PODS '08: Proceedings of the twenty-seventh ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pages 291-300, New York, N.Y., USA, 2008. ACM.
  • [14] Oege de Moor, Damien Sereni, Mathieu Verbaere, Elnar Hajiyev, Pavel Avgustinov, Torbjörn Ekman, Neil Ongkingco, and Julian Tibble. .QL: Object-oriented queries made easy. In Ralf Lämmel, João Saraiva, and Joost Visser, editors, Generative and Transformational Techniques in Software Engineering, LNCS. Springer, 2007.
  • [15] Oege de Moor, Mathieu Verbaere, Elnar Hajiyev, Pavel Avgustinov, Torbjörn Ekman, Neil Ongkingco, Damien Sereni, and Julian Tibble. .QL for source code analysis. In Source Code Analysis and Manipulation (SCAM '07), pages 3-16. IEEE, 2007.
  • [16] Thom W. Frühwirth, Ehud Y. Shapiro, Moshe Y. Vardi, and Eyal Yardeni. Logic programs as types for logic programs. In Logic in Computer Science (LICS), pages 300-309. IEEE Computer Society, 1991.
  • [17] John P. Gallagher, Kim S. Henriksen, and Gourinath Banda. Techniques for Scaling Up Analyses Based on Pre-Interpretations. In M. Gabbrielli and G. Gupta, editors, International Conference on Logic Programming (ICLP '05), volume 3668 of LNCS, pages 280-296. Springer, 2005.
  • [18] John P. Gallagher and Germán Puebla. Abstract Interpretation over Non-deterministic Finite Tree Automata for Set-Based Analysis of Logic Programs. In Practical Aspects of Declarative Languages (PADL), volume 2257 of LNCS, pages 243-261. Springer, 2002.
  • [19] Nevin C. Heintze and Joxan Jaffar. A finite presentation theorem for approximating logic programs. In Symposium on Principles of Programming Languages (POPL), pages 197-209, 1990.
  • [20] David Hilbert and Wilhelm Ackermann. Grundzüge der Theoretischen Logik. Julius Springer, Berlin, 1928.
  • [21] Kim Marriott, Harald Søndergaard, and Neil D. Jones. Denotational Abstract Interpretation of Logic Programs. ACM Transactions on Programming Languages and Systems, 16(3):607-648, 1994.
  • [22] Willard V. Quine. On Cores and Prime Implicants of Truth Functions. The American Mathematical Monthly, 66(9):755-760, Nov. 1959.
  • [23] Oded Shmueli. Equivalence of Datalog Queries is Undecidable. Journal of Logic Programming, 15(3):231-241, 1993.
  • [24] Fang Wei and Georg Lausen. Containment of Conjunctive Queries with Safe Negation. In ICDT '03: Proceedings of the 9th International Conference on Database Theory, pages 346-360, London, UK, 2002. Springer-Verlag.
  • [25] John Whaley. JavaBDD. http://javabdd.sourceforge.net/, 2007.
  • [26] Bwolen Yang, Randal E. Bryant, David R. O'Halloran, Armin Biere, Olivier Coudert, Geert Janssen, Rajeev K. Ranjan, and Fabio Somenzi. A Performance Study of BDD-Based Model Checking. In 2nd International Conference on Formal Methods in Computer-Aided Design, volume 1522 of Lecture Notes in Computer Science, pages 255-289. Springer, 1998.
  • [27] David Zook, Emir Pasalic, and Beata Sarna-Starosta. Typed Datalog. In Practical Aspects of Declarative Languages, pages 168-182. Springer Berlin/Heidelberg, 2009.

Claims (22)

What is claimed is:
1. A computer-implemented method comprising:
accessing a query program with, the query program containing one or more queries to a database that contains relations described by at least one a database schema, wherein the database schema specifies a column type for every column of every extensional predicate that occurs in the query program;
receiving the database schema and at least one an entity type hierarchy for the database; and
inferring a first type program from definitions in the query program by replacing each use of a database relation an extensional predicate in the query program by its type in the conjunction of the column types of the columns of the extensional predicate, the column types being provided by the database schema, and the wherein each column type is at least portion of a respective second type program,
wherein each of the first type program and the second type program is a derived program using type symbols without other extensional relation symbols, and each of the first type program and the second type program do not contain negation,
wherein the first type program and the second type program uses programs use only extensionals that are monadic extensions, and the first type program and the second type programs do not contain negation;
testing portion portions of the first type program that has been inferred for type emptiness and type inclusion; and
finding type emptiness or type inclusion for a first portion of the first type program, wherein the first portion is also a type program; and
providing at least one of error information and or optimization information regarding the type emptiness and or type inclusion being found for the type first portion of the first type program.
2. The computer-implemented method of claim 1, further comprising:
in response to type emptiness being found for a the first portion of the first type program that has been inferred during determining of the testing portion of portions of the first type program, performing at least one of:
removing the a type test from the query program a first portion of the query program that corresponds to the first portion of the first type program;
providing a notification regarding the emptiness found for the first portion of the first type program; or
providing notification on combining queries in the query program by conjunction without creating empty parts in a combined query;
in response to an empty part of a query being a conjunction, finding a smallest set of query parts that has a conjunction that is empty;
in response to a search for a smallest empty part of a database query that traverses all parts of the database query, pushing a conjunction of an approximation of the smallest empty part and a context on top of a stack of approximations of all contexts where the empty part is being used; and
eliminating empty query parts to achieve virtual method resolution in an object-oriented query language.
3. The computer-implemented method of claim 1, further comprising:
in response to type inclusion being found for a second portion of the first type program that has been inferred during determining of the testing portion of portions of the first type program, performing at least one of:
removing the a type test from the query program a second portion of the query program that corresponds to the second portion of the first type program; and or
providing a notification regarding the type inclusion being found for the second portion of the first type program.
4. The computer-implemented method of claim 1, further comprising wherein:
inferring the first type program includes inferring an inferred type for an intensional predicate in the query program that has a declared type in the query program; and
the method further comprises:
testing the type program that has been inferred for whether a database query is contained in a given portion of the type program; and in response to the database query not being contained in the given portion, performing at least one of:
removing a type test; and
determining that the inferred type does not contain the declared type; and
providing a notification regarding that the database query declared type is not being contained in the given portion inferred type.
5. The computer-implemented method of claim 1, wherein portions of the first type program that has been inferred are represented by a set respective sets of type tuple constraints (TTCs), wherein each of the TTCs includes:
a tuple of type propositions;
an equivalence relation between tuple components, each tuple component being a type proposition; and
a set of inhabitation constraints.
6. The computer-implemented method of claim 5, further comprising:
checking inclusion of a third portion of the first type program that has been inferred represented by a first set of TTCs into another, fourth portion of the first type program represented by a second set of TTCs by:
computing a set of prime implicants of the second set; and
checking each TTC in the first set and finding determining whether a larger TTC exists in the set of prime implicants of the second set of TTCs; and
determining that the third portion is included in the fourth portion if for each TTC in the first set a larger TTC exists in the set of prime implicants of the second set of TTCs.
7. The computer-implemented method of claim 6, further comprising:
computing the set of prime implicants of the second set of TTCs by saturating the second set by exhaustively applying consensus operations to ensure all relevant TTCs are included.
8. The computer-implemented method of claim 7, wherein each of the consensus operations are performed by includes generating a new TTC from two existing TTCs by
receiving two TTCs as operands two TTCs, the tuple of type propositions of each TTC having the same number of type propositions;
receiving a set of indices and, each index in the set identifying a type proposition in a tuple of type propositions by the position of the type proposition in the tuple;
equating in each operand TTC all columns whose indices type propositions at index positions that occur in the set of indices, and preserving all other equalities and inhabitation constraints of the operands each TTC operand, and then for each index position taking disjunctions over columns type propositions indexed in the set of indices and conjunctions over all other columns type propositions as the type propositions of the tuple of type propositions of the new TTC; and
takinggenerating a union of two or more of the equivalence relations in of the operands operand TTCs as the equivalence relation between tuple components of the new TTC; and
generating a pointwise disjunction of the inhabitation constraints of the operandsoperand TTCs as the inhabitation constraints of the new TTC.
9. The computer-implemented method of claim 8, further comprising:
reducing a number of consensus operations that need to be performed during saturation by omitting consensus operations where a resulting TTC will be covered by TTCs already present in the set, wherein a TTC τ is covered by a TTC τ′ if τ<:τ′.
10. The computer-implemented method of claim 8, further comprising:
receiving a logical formula that represents a type hierarchy, and representing a component type proposition of a TTC as a binary decision diagram (BDDs BDD), and choosing a BDD variable order by assigning neighboring indices of the set of indices to type symbols that appear in a same conjunct of the logical formula that represents the type hierarchy.
11. The computer-implemented method of claim 1, wherein further comprising:
using the first type program as an approximation is used to find erroneous parts of a database query in the query program that will return an empty set of results, regardless of contents stored in the database.
12. The computer-implemented method of claim 2, wherein the providing notification on combining queries in the query program by conjunction without creating empty parts in a combined query includes depicting compatible types with similar pictures in a user interface.
13. The computer-implemented method of claim 1, wherein the one or more queries to the database contain calls to other query procedures, and the method further comprises:
using the first type program as an approximation is used to optimize these called the query procedures, by and eliminating query parts from the query procedures that will return an empty set of results in a context where they are called, regardless of any contents of the database.
14. The computer-implemented method of claim 13, wherein the context of a procedure in a database query is computed by comprising:
computing the context of each query procedure called by a query program by
traversing a call graph of that query program, and
keeping a stack of approximations of all contexts where the query procedure is being used, and
when entering a procedure in the call graph, pushing a conjunction of an approximation of a body of that procedure and a top of the stack onto the stack as a new context.
15. The computer-implemented method of claim 1, wherein further comprising:
using the first type program as an approximation is used to optimize queries, in the query program by eliminating from the query program query parts that test whether a value is included in a portion of the first type program has a particular declared type in the query program, and the approximation first type program indicates at least one of:
the value will be included in this portion of the first type program have the particular declared type regardless of contents stored in the database; and
the value will not be included in the portion of the first type program have the particular declared type regardless of contents stored in the database.
16. A system comprising:
a computer system comprising one or more computers each having a memory;and a processor communicatively coupled to the memory; and
a type inferencer communicatively coupled to the memory and the processor computer program loaded in the computer system, wherein the type inferencer is adapted to cause the computer system perform the operations of:
accessing a query program with, the query program containing one or more query operations to a database that contains relations described by at least one a database schema, wherein the database schema specifies a column type for every column of every extensional predicate that occurs in the query program;
receiving the database schema and at least one an entity type hierarchy for the database; and
inferring a first type program from definitions in the query program by replacing each use of a database relation an extensional predicate in the query program by its type in the conjunction of the column types of the columns of the extensional predicate, the column types being provided by the database schema, and the wherein each column type is at least portion of a respective second type program,
wherein each of the first type program and the second type program is a derived program using type symbols without other extensional relation symbols, and each of the first type program and the second type program do not contain negation,
wherein the first type program and the second type program uses programs use only extensionals that are monadic extensions, and the first type program and the second type programs do not contain negation;
testing portion portions of the first type program that has been inferred for type emptiness and type inclusion; and
finding type emptiness or type inclusion for a first portion of the first type program, wherein the first portion is also a type program; and
providing at least one of error information and optimization information regarding the type emptiness and or type inclusion being found for the type first portion of the first type program.
17. The system of claim 16, wherein the type inferencer is further adapted to perform the operations of:
in response to type emptiness being found for a the first portion of the first type program that has been inferred during determining of the testing portion of portions of the first type program, performing at least one of:
removing a type test from the query program a first portion of the query program that corresponds to the first portion of the first type program;
providing a notification regarding the emptiness found for the first portion of the first type program; or
providing notification on combining queries in the query program by conjunction without creating empty parts in a combined query;
in response to an empty part of a query being a conjunction, finding a smallest set of query parts that has a conjunction that is empty;
in response to a search for a smallest empty part of a database query that traverses all parts of the database query, pushing a conjunction of an approximation of the smallest empty part and a context on top of a stack of approximations of all contexts where the empty part is being used; and
eliminating empty query parts to achieve virtual method resolution in an object-oriented query language.
18. The system of claim 16, wherein the type inferencer is further adapted to perform the operations of:
in response to type inclusion being found for a second portion of the first type program that has been inferred during determining of the testing portion of portions of the first type program, performing at least one of:
removing a type test from the query program a second portion of the query program that corresponds to the second portion of the first type program; and or
providing a notification regarding the type inclusion being found for the second portion of the first type program.
19. A non-transitory computer program product, the computer program product comprising instructions for to cause a computer system to perform the operations of:
accessing a query program with, the query program containing one or more query operations to a database that contains relations described by at least one a database schema, wherein the database schema specifies a column type for every column of every extensional predicate that occurs in the query program;
receiving the database schema and at least one an entity type hierarchy for the database; and
inferring a first type program from definitions in the query program by replacing each use of a database relation an extensional predicate in the query program by its type in the conjunction of the column types of the columns of the extensional predicate, the column types being provided by the database schema, and the wherein each column type is at least portion of a respective second type program,
wherein each of the first type program and the second type program is a derived program using type symbols without other extensional relation symbols, and each of the first type program and the second type program do not contain negation,
wherein the first type program and the second type program uses programs use only extensionals that are monadic extensions, and the first type program and the second type programs do not contain negation;
testing portion portions of the first type program that has been inferred for type emptiness and type inclusion; and
finding type emptiness or type inclusion for a first portion of the first type program, wherein the first portion is also a type program; and
providing at least one of error information and optimization information regarding the type emptiness and or type inclusion being found for the type first portion of the first type program.
20. The non-transitory computer program product of claim 19, further comprising instructions to cause the computer system to perform the operations of:
in response to type emptiness being found for a the first portion of the first type program that has been inferred during determining of the testing portion of portions of the first type program, performing at least one of:
removing a type test from the query program a first portion of the query program that corresponds to the first portion of the first type program;
providing a notification regarding the emptiness found for the first portion of the first type program; or
providing notification on combining queries in the query program by conjunction without creating empty parts in a combined query;
in response to an empty part of a query being a conjunction, finding a smallest set of query parts that has a conjunction that is itself empty;
in response to a search for a smallest empty part of a database query that traverses all parts of the database query, pushing a conjunction of an approximation of that part and a context on top of a stack; and
eliminating empty query parts to achieve virtual method resolution in an object-oriented query language.
21. The computer-implemented method of claim 1, wherein:
each of the column types is a monadic type found in a set of type symbols.
22. The computer-implemented method of claim 2, further comprising:
in response to finding that the first portion of the query program is a conjunction, finding a smallest set of query parts in the first portion of the query program that has a conjunction that is empty, and providing a notification regarding the emptiness found for the smallest set of query parts that has a conjunction that is empty.
US14/952,788 2010-07-15 2015-11-25 Type inference for datalog with complex type hierarchies Active USRE46380E1 (en)

Priority Applications (3)

Application Number Priority Date Filing Date Title
US36457110P true 2010-07-15 2010-07-15
US13/183,514 US8595213B2 (en) 2010-07-15 2011-07-15 Type inference for datalog with complex type hierarchies
US14/952,788 USRE46380E1 (en) 2010-07-15 2015-11-25 Type inference for datalog with complex type hierarchies

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US14/952,788 USRE46380E1 (en) 2010-07-15 2015-11-25 Type inference for datalog with complex type hierarchies

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US13/183,514 Reissue US8595213B2 (en) 2010-07-15 2011-07-15 Type inference for datalog with complex type hierarchies

Publications (1)

Publication Number Publication Date
USRE46380E1 true USRE46380E1 (en) 2017-04-25

Family

ID=45467751

Family Applications (2)

Application Number Title Priority Date Filing Date
US13/183,514 Active 2031-09-08 US8595213B2 (en) 2010-07-15 2011-07-15 Type inference for datalog with complex type hierarchies
US14/952,788 Active USRE46380E1 (en) 2010-07-15 2015-11-25 Type inference for datalog with complex type hierarchies

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US13/183,514 Active 2031-09-08 US8595213B2 (en) 2010-07-15 2011-07-15 Type inference for datalog with complex type hierarchies

Country Status (1)

Country Link
US (2) US8595213B2 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9996583B1 (en) * 2017-05-25 2018-06-12 Semmle Limited Differential recursive evaluation of recursive aggregates

Families Citing this family (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8806451B2 (en) * 2011-06-16 2014-08-12 Microsoft Corporation Monad based cloud computing
US20140249882A1 (en) * 2012-10-19 2014-09-04 The Curators Of The University Of Missouri System and Method of Stochastic Resource-Constrained Project Scheduling
US9720961B1 (en) 2016-09-30 2017-08-01 Semmle Limited Algebraic data types for database query languages
US9633078B1 (en) 2016-09-30 2017-04-25 Semmle Limited Generating identifiers for tuples of recursively defined relations

Citations (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6006214A (en) * 1996-12-04 1999-12-21 International Business Machines Corporation Database management system, method, and program for providing query rewrite transformations for nested set elimination in database views
US6338055B1 (en) * 1998-12-07 2002-01-08 Vitria Technology, Inc. Real-time query optimization in a decision support system
US20020069193A1 (en) * 2000-12-06 2002-06-06 Beavin Thomas A. Optimization of SQL queries using filtering predicates
US20050086639A1 (en) * 2003-10-21 2005-04-21 Jun-Ki Min Method of performing queriable XML compression using reverse arithmetic encoding and type inference engine
US7089266B2 (en) * 2003-06-02 2006-08-08 The Board Of Trustees Of The Leland Stanford Jr. University Computer systems and methods for the query and visualization of multidimensional databases
US20070043702A1 (en) * 2005-08-19 2007-02-22 Microsoft Corporation Query expressions and interactions with metadata
US20070276787A1 (en) * 2006-05-15 2007-11-29 Piedmonte Christopher M Systems and Methods for Data Model Mapping

Patent Citations (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6006214A (en) * 1996-12-04 1999-12-21 International Business Machines Corporation Database management system, method, and program for providing query rewrite transformations for nested set elimination in database views
US6338055B1 (en) * 1998-12-07 2002-01-08 Vitria Technology, Inc. Real-time query optimization in a decision support system
US20020069193A1 (en) * 2000-12-06 2002-06-06 Beavin Thomas A. Optimization of SQL queries using filtering predicates
US7089266B2 (en) * 2003-06-02 2006-08-08 The Board Of Trustees Of The Leland Stanford Jr. University Computer systems and methods for the query and visualization of multidimensional databases
US20050086639A1 (en) * 2003-10-21 2005-04-21 Jun-Ki Min Method of performing queriable XML compression using reverse arithmetic encoding and type inference engine
US20070043702A1 (en) * 2005-08-19 2007-02-22 Microsoft Corporation Query expressions and interactions with metadata
US20070276787A1 (en) * 2006-05-15 2007-11-29 Piedmonte Christopher M Systems and Methods for Data Model Mapping

Non-Patent Citations (25)

* Cited by examiner, † Cited by third party
Title
Ashok K. Chandra and Philip M. Merlin, "Optimal Implementation of Conjunctive Queries in Relational Data Bases." In STOC '77: Proceedings of the ninth annual ACM symposium on Theory of computing, pp. 77-90, New York, NY, USA, 1997. ACM.
Bowlen Yang, Randal E. Bryant, David R. O'Halloran, Armin Biere, Olivier Coudert, Geert Janssen, Rajeev K. Ranjan, and Fabio Somenzi, "A Performance Study of BDD-Based Model Checking." In 2nd International Conference on Formal Methods in Computer-Aided Design, vol. 1522 of Lecture Notes in Computer Science, pp. 255-289. Springer, 1998.
David Zook, Emir Pasalic, and Beata Sarna-Starosta, "Typed Datalog." In Practical Aspects of Declarative Languages, pp. 168-182. Springer Berlin/Heidelberg, 2009.
Fang Wei and Georg Lausen, "Containment of Conjunctive Queries with Safe Negation." In ICDT '03: Proceedings of the 9th International Conference on Database Theory, pp. 346-360, London, UK, 2002. Springer-Verlag.
John P. Gallagher and Germén Puebla, "Abstract Interpretation over Non-deteriministic Finite Tree Automata for Set-Based Analysis of Logic Programs." In Practical Aspects of Declarative Languages (PADL), vol. 2257 of LNCS, pp. 243-261. Springer, 2002.
John P. Gallagher, Kim S. Henriksen, and Gourinath Banda, "Techniques for Scaling Up Analyses Based on Pre-Interpretations." In M. Gabbrielli and G. Gupta, editors, International Conference on Logic Programming (ICLP '05), vol. 3668 of LNCS, pp. 280-296. Springer, 2005.
John Whaley. JavaBDD. http://javabdd.sourceforge.net/, 2007.
Kevin J. Compton, "Stratified least fixpoint logic." Theoretical Computer Science, 31 (1):95-120, 1994.
Kim Marriott, Harald Søndergaard, and Neil D. Jones, "Denotational Abstract Interpretation of Logic Programs." ACM Transactions on Programming Languages and Systems, 16(3):607-648, 1994.
Leo Bachmair, Harald Ganzinger, and UweWaldmann, "Set constraints are the monadic class." In Logic in Computer Science, pp. 75-83, 1993.
Leo Bachmair, Harald Ganzinger, and UweWaldmann, "Superposition with Simplification as a Decision Procedure for the Monadic Class with Equality." in KGC '93: Proceedings of the Third Kurt Gödel Colloquium on Computational Logic and Proof Theory, pp. 83-96, London, UK, 1993. Springer-Verlag.
Max Schafer, Oege de Moor, "Type Inference for Datalog with Complex Type Hierarchies." POPL '10, Jan. 17-23, 2010, Madrid, Spain, copyright 2010 ACM 978-1-60558-479-9/10/01.
Nevin C. Heintze and Joxan Jaffar, "A finite presentation theorem for approxmating logic programs." In Symposium on Principles of Programming Languages (POPL), pp. 197-209, 1990.
Oded Shmueli, "Equivalence of Datalog Queries is Undecidable." Journal of Logic Programming, 15(3):231-241, 1993.
Oege de Moor, Damien Sereni, Mathieu Verbaere, Elnar Hajiyev, Pavel Avgustinov, Torjörn Ekman, Neil Ongkingco, and Julian Tibble, "QL: Object-oriented queries made easy." In Ralf Lämmel, João Saraiva, and Joost Visser, editors, Generative and Transformational Techniques in Software Engineering, LNCS. Springer, 2007.
Oege de Moor, Damien Sereni, Pavel Avgustinov, and Mathieu Verbaere, "Type Inference for Datalog and Its Application to Query Optimisation." In PODS '08: Proceedings of the twenty-seventh ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pp. 291-300, New York, NY, USA, 2008. ACM.
Oege de Moor, Mathieu Verbaere, Elnar Hajiyev, Pavel Avgustinov, Torbjörn Ekman , Neil Ongkingco, Damien Sereni, and Julian Tibble, "QL for source code analysis." In Source Code Analysis and Manipulation (SCAM '07), pp. 3-16, IEEE, 2007.
Olivier Coudert, Christian Berthet, and Jean Christophe Madre, "Verification of synchronous sequential machines based on symbolic execution." In Automatic Verification Methods for Finite State Systems, vol. 407 of Lecture Notes in Computer Science, pp. 365-373. Springer, 1989.
Sacha Berger, Emmanuel Coquery, Wlodzimierz Drabent, and Artur Wilk, "Descriptive Typing Rules for Xcerpt and their soundness." in François Fages and Sylvain Soliman, editors, Principles and Practice of Semantic Web Reasoning, vol. 3703 of LNCS, pp. 85-100. Springer, 2005.
Serge Abiteboul, George Lausen, Heinz Uphoff, and Emmanuel Waller, "Methods and rules". In ACM SIGMOND International Conference on Management of Data, pp. 32-41, ACM Press, 1993.
Stavros Cosmadakis, Haim Gaifman, Paris Kanellakis, and Moshe Vardi, "Decidable Optimazation Problems for Database Logic Programs." In Proceedings of the 20th annual ACM Symposium on Computing, pp. 477-490, 1988.
Surajit Chaudhuri and Phokion G. Kolaitis, "Can Datalog be approximated?" In Principles of Database Systems (PODS), pp. 86-96, 1994.
Surajit Chaudhuri, "Finding nonrecursive envelopes for Datalog predicates." In Principles of Database Systems (PODS), pp. 135-146, 1993.
Thom W. Frühwirth, Ehud Y. Shapiro, Moshe Y. Vardi, and Eyal Yardeni, "Logic programs as types for logic programs." In Logic in Computer Science (LICS), pp. 300-309. IEEE Computer Society, 1991.
Willard V. Quine, "On Cores and Prime Implicants of Truth Functions." The American Mathematical Monthly, 66(9):755-760, Nov. 1959.

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9996583B1 (en) * 2017-05-25 2018-06-12 Semmle Limited Differential recursive evaluation of recursive aggregates

Also Published As

Publication number Publication date
US8595213B2 (en) 2013-11-26
US20120016912A1 (en) 2012-01-19

Similar Documents

Publication Publication Date Title
Calì et al. On the decidability and complexity of query answering over inconsistent and incomplete databases
Godefroid et al. Abstraction-based model checking using modal transition systems
Alkhateeb et al. Extending SPARQL with regular expression patterns (for querying RDF)
Pérez et al. nSPARQL: A navigational language for RDF
Blumensath et al. Automatic structures
Donini et al. The complexity of concept languages
Gottlob et al. Ontological queries: Rewriting and optimization
Van der Werf et al. Process discovery using integer linear programming
Stickel A Prolog technology theorem prover: a new exposition and implementation in Prolog
Motik et al. A Faithful Integration of Description Logics with Logic Programming.
Motik Reasoning in description logics using resolution and deductive databases
Rodriguez-Muro et al. High performance query answering over DL-Lite ontologies
Niemelä et al. Extending the Smodels system with cardinality and weight constraints
Kanellakis Elements of relational database theory
Distefano et al. jStar: Towards practical verification for Java
McSherry Privacy integrated queries: an extensible platform for privacy-preserving data analysis
Kanellakis et al. Constraint programming and database query languages
Swift et al. XSB: Extending Prolog with tabled logic programming
Costan et al. A policy iteration algorithm for computing fixed points in static analysis of programs
Pérez-Urbina et al. Tractable query answering and rewriting under description logic constraints
Motik et al. A comparison of reasoning techniques for querying large description logic ABoxes
Galmiche et al. The semantics of BI and resource tableaux
Kuper et al. Constraint databases
Zimmermann et al. A general framework for representing, reasoning and querying with annotated semantic web data
Beyer et al. Invariant synthesis for combined theories

Legal Events

Date Code Title Description
FPAY Fee payment

Year of fee payment: 4

RF Reissue application filed

Effective date: 20170421

CC Certificate of correction
AS Assignment

Owner name: SEMMLE LIMITED, UNITED KINGDOM

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:SCHAEFER, MAX;MOOR, OEGE DE;SIGNING DATES FROM 20110714 TO 20110715;REEL/FRAME:045690/0336