72,199 research outputs found
Program Transformations for Asynchronous and Batched Query Submission
The performance of database/Web-service backed applications can be
significantly improved by asynchronous submission of queries/requests well
ahead of the point where the results are needed, so that results are likely to
have been fetched already when they are actually needed. However, manually
writing applications to exploit asynchronous query submission is tedious and
error-prone. In this paper we address the issue of automatically transforming a
program written assuming synchronous query submission, to one that exploits
asynchronous query submission. Our program transformation method is based on
data flow analysis and is framed as a set of transformation rules. Our rules
can handle query executions within loops, unlike some of the earlier work in
this area. We also present a novel approach that, at runtime, can combine
multiple asynchronous requests into batches, thereby achieving the benefits of
batching in addition to that of asynchronous submission. We have built a tool
that implements our transformation techniques on Java programs that use JDBC
calls; our tool can be extended to handle Web service calls. We have carried
out a detailed experimental study on several real-life applications, which
shows the effectiveness of the proposed rewrite techniques, both in terms of
their applicability and the performance gains achieved.Comment: 14 page
A negation query engine for complex query transformations
Natural language interfaces to ontologies allow users to query the system using natural language queries. These systems take natural language query as input and transform it to formal query language equivalent to retrieve the desired information from ontologies. The existing natural language interfaces to ontologies offer support for handling negation queries; however, they offer limited support for dealing with them. This paper proposes a negation query handling engine which can handle relatively complex natural language queries than the existing systems. The proposed engine effectively understands the intent of
the user query on the basis of a sophisticated algorithm, which is governed by a set of techniques and transformation rules. The proposed engine was evaluated using the Mooney data set and AquaLog dataset, and it manifested encouraging results
Node Query Preservation for Deterministic Linear Top-Down Tree Transducers
This paper discusses the decidability of node query preservation problems for
XML document transformations. We assume a transformation given by a
deterministic linear top-down data tree transducer (abbreviated as DLT^V) and
an n-ary query based on runs of a tree automaton. We say that a DLT^V Tr
strongly preserves a query Q if there is a query Q' such that for every
document t, the answer set of Q' for Tr(t) is equal to the answer set of Q for
t. Also we say that Tr weakly preserves Q if there is a query Q' such that for
every t_d in the range of Tr, the answer set of Q' for t_d is equal to the
union of the answer set of Q for t such that t_d = Tr(t). We show that the weak
preservation problem is coNP-complete and the strong preservation problem is in
2-EXPTIME.Comment: In Proceedings TTATT 2013, arXiv:1311.505
Schema Independent Relational Learning
Learning novel concepts and relations from relational databases is an
important problem with many applications in database systems and machine
learning. Relational learning algorithms learn the definition of a new relation
in terms of existing relations in the database. Nevertheless, the same data set
may be represented under different schemas for various reasons, such as
efficiency, data quality, and usability. Unfortunately, the output of current
relational learning algorithms tends to vary quite substantially over the
choice of schema, both in terms of learning accuracy and efficiency. This
variation complicates their off-the-shelf application. In this paper, we
introduce and formalize the property of schema independence of relational
learning algorithms, and study both the theoretical and empirical dependence of
existing algorithms on the common class of (de) composition schema
transformations. We study both sample-based learning algorithms, which learn
from sets of labeled examples, and query-based algorithms, which learn by
asking queries to an oracle. We prove that current relational learning
algorithms are generally not schema independent. For query-based learning
algorithms we show that the (de) composition transformations influence their
query complexity. We propose Castor, a sample-based relational learning
algorithm that achieves schema independence by leveraging data dependencies. We
support the theoretical results with an empirical study that demonstrates the
schema dependence/independence of several algorithms on existing benchmark and
real-world datasets under (de) compositions
Reconciliation of RDF* and Property Graphs
Both the notion of Property Graphs (PG) and the Resource Description
Framework (RDF) are commonly used models for representing graph-shaped data.
While there exist some system-specific solutions to convert data from one model
to the other, these solutions are not entirely compatible with one another and
none of them appears to be based on a formal foundation. In fact, for the PG
model, there does not even exist a commonly agreed-upon formal definition.
The aim of this document is to reconcile both models formally. To this end,
the document proposes a formalization of the PG model and introduces
well-defined transformations between PGs and RDF. As a result, the document
provides a basis for the following two innovations: On one hand, by
implementing the RDF-to-PG transformations defined in this document, PG-based
systems can enable their users to load RDF data and make it accessible in a
compatible, system-independent manner using, e.g., the graph traversal language
Gremlin or the declarative graph query language Cypher. On the other hand, the
PG-to-RDF transformation in this document enables RDF data management systems
to support compatible, system-independent queries over the content of Property
Graphs by using the standard RDF query language SPARQL. Additionally, this
document represents a foundation for systematic research on relationships
between the two models and between their query languages.Comment: slightly changed the definition of PGs and added the notion of
property uniquenes
- …