|
|
|
The paper's point of view is that "SQL's syntax is too restricted to express quantified queries," and that "SQL queries that simulate quantifiers are frequently ill-supported by existing relational query processors." With these contentions I strongly agree. In fact, SQL's difficulties are not limited to quantified queries, as has been observed by many people; see [2], for example, for similar issues regarding nested aggregation.
The fundamental issue is that there are idioms (in this case quantifiers) that (a) are natural in the context of the query being specified, (b) are implemented efficiently with appropriate data structures and algorithms, and (c) are hard to express directly in SQL, and must be expressed in a verbose and indirect manner. A commonly held, but mistaken view about such idioms is that SQL rewriting together with query optimization would enable efficient processing of the queries. This paper demonstrates that the commercial systems of the time were significantly less efficient (when processing the more verbose SQL version of the query) than a specialized query processor built by themselves operating on a query specified using generalized quantifiers. There are good reasons to believe that the limitation on efficient processing is (in general) inherent, and (except for special cases) won't be overcome in future SQL implementations.
The importance of this paper is that it is one of the first to combine the notions that (a) an idiom should be specified directly in a query, and (b) specialized algorithms to implement the idiom should be provided by the query evaluation engine. I think there is much potential for future work on the notion of query language idioms, perhaps leading to query languages that are extensible not just in the methods that can be applied to datatypes, but also in the fundamental idioms with which queries are composed.
Copyright © 1999 by the author(s). Review published with permission.