15 research outputs found
Querying Schemas With Access Restrictions
We study verification of systems whose transitions consist of accesses to a
Web-based data-source. An access is a lookup on a relation within a relational
database, fixing values for a set of positions in the relation. For example, a
transition can represent access to a Web form, where the user is restricted to
filling in values for a particular set of fields. We look at verifying
properties of a schema describing the possible accesses of such a system. We
present a language where one can describe the properties of an access path, and
also specify additional restrictions on accesses that are enforced by the
schema. Our main property language, AccLTL, is based on a first-order extension
of linear-time temporal logic, interpreting access paths as sequences of
relational structures. We also present a lower-level automaton model,
Aautomata, which AccLTL specifications can compile into. We show that AccLTL
and A-automata can express static analysis problems related to "querying with
limited access patterns" that have been studied in the database literature in
the past, such as whether an access is relevant to answering a query, and
whether two queries are equivalent in the accessible data they can return. We
prove decidability and complexity results for several restrictions and variants
of AccLTL, and explain which properties of paths can be expressed in each
restriction.Comment: VLDB201
A schema-only approach to validate XML schema mappings
Since the emergence of the Web, the ability to map XML data between different data sources has become crucial. Defining a mapping is
however not a fully automatic process. The designer needs to figure out whether the mapping is what was intended. Our approach to this
validation consists of defining and checking certain desirable properties of mappings. We translate the XML schemas and the mapping into
first-order logic formalism and apply a reasoning mechanism to check the desirable properties automatically, without assuming any
particular instantiation of the schemas.Preprin
Optimization of multi-domain queries on the Web
Where can I attend an interesting database workshop close
to a sunny beach? Who are the strongest experts on service
computing based upon their recent publication record and
accepted European projects? Can I spend an April week-
end in a city served by a low-cost direct
flight from Milano
offering a Mahler's symphony? We regard the above queries
as multi-domain queries, i.e., queries that can be answered
by combining knowledge from two or more domains (such
as: seaside locations,
flights, publications, accepted projects,
conference offerings, and so on). This information is avail-
able on the Web, but no general-purpose software system
can accept the above queries nor compute the answer. At
the most, dedicated systems support specific multi-domain
compositions (e.g., Google-local locates information such as
restaurants and hotels upon geographic maps).
This paper presents an overall framework for multi-domain
queries on the Web. We address the following problems: (a)
expressing multi-domain queries with an abstract formalism,
(b) separating the treatment of "search" services within the
model, by highlighting their dierences from "exact" Web
services, (c) explaining how the same query can be mapped
to multiple "query plans", i.e., a well-dened scheduling of
service invocations, possibly in parallel, which complies with
their access limitations and preserves the ranking order in
which search services return results; (d) introducing cross-
domain joins as first-class operation within plans; (e) eval-
uating the query plans against several cost metrics so as to
choose the most promising one for execution. This frame-
work adapts to a variety of application contexts, ranging
from end-user-oriented mash-up scenarios up to complex ap-
plication integration scenarios
Validation of schema mappings with nested queries
With the emergence of the Web and the wide use of XML for representing data, the ability to map not only flat relational but also nested data has become crucial. The design of schema mappings is a semi-automatic process. A human designer is needed to guide the process, choose among mapping candidates, and successively refine the mapping. The designer needs a way to figure out whether the mapping is what was intended. Our approach to mapping validation allows the designer to check whether the mapping satisfies certain desirable properties. In this paper, we focus on the validation of mappings between nested relational schemas, in which the mapping assertions are either inclusions or equalities of nested queries. We focus on the nested relational setting since most XML’s Document Type Definitions (DTDs) can be represented in this model. We perform the validation by reasoning on the schemas and mapping definition. We take into account the integrity constraints defined on both the source and target schema.Preprin
Rewriting Queries using Views with Access Patterns under Integrity Constraints
We study the problem of rewriting queries using views in the presence of access patterns, integrity constraints, disjunction, and negation. We provide asymptotically optimal algorithms for (1) finding minimally containing and (2) maximally contained rewritings respecting the access patterns (which we call executable) and for (3) deciding whether an exact executable rewriting exists. We show that rewriting queries using views in this case reduces (a) to rewriting queries with access patterns and constraints without views and also (b) to rewriting queries using views under constraints without access patterns. We show how to solve (a) directly and how to reduce (b) to rewriting queries under constraints only (semantic optimization). These reductions provide two separate routes to a unified solution for problems 1, 2, and 3 based on an extension of the relational chase theory to queries and constraints with disjunction and negation. We also handle equality and arithmetic comparisons. We also show that in an information integration setting, maximally contained rewritings are given by the certain answers (under the usual semantics) for a set of constraints derived from the binding patterns. That is, except for defining the appropriate constraints, binding patterns do not need special treatment. Finally, we show that if there is an exact executable rewriting, there is an executable rewriting which is a union of conjunctive queries with negation