Referential Constraints Research Articles

Rewriting the Infinite Chase for Guarded TGDs

Guarded tuple-generating dependencies (GTGDs) are a natural extension of description logics and referential constraints. It has long been known that queries over GTGDs can be answered by a variant of the chase —a quintessential technique for reasoning with dependencies. However, there has been little work on concrete algorithms and even less on implementation. To address this gap, we revisit Datalog rewriting approaches to query answering, where a set of GTGDs is transformed to a Datalog program that entails the same base facts on each base instance. We show that a rewriting consists of “shortcut” rules that circumvent certain chase steps, we present several algorithms that compute a rewriting by deriving such “shortcuts” efficiently, and we discuss important implementation issues. Finally, we show empirically that our techniques can process complex GTGDs derived from synthetic and real benchmarks and are thus suitable for practical use.

Rewriting the infinite chase

Guarded tuple-generating dependencies (GTGDs) are a natural extension of description logics and referential constraints. It has long been known that queries over GTGDs can be answered by a variant of the chase ---a quintessential technique for reasoning with dependencies. However, there has been little work on concrete algorithms and even less on implementation. To address this gap, we revisit Datalog rewriting approaches to query answering, where GTGDs are transformed to a Datalog program that entails the same base facts on each base instance. We show that the rewriting can be seen as containing "shortcut" rules that circumvent certain chase steps, we present several algorithms that compute the rewriting by simulating specific types of chase steps, and we discuss important implementation issues. Finally, we show empirically that our techniques can process complex GTGDs derived from synthetic and real benchmarks and are thus suitable for practical use.

Finite Open-world Query Answering with Number Restrictions

Open-world query answering is the problem of deciding, given a set of facts, conjunction of constraints, and query, whether the facts and constraints imply the query. This amounts to reasoning over all instances that include the facts and satisfy the constraints. We study finite open-world query answering (FQA), which assumes that the underlying world is finite and thus only considers the finite completions of the instance. The major known decidable cases of FQA derive from the following: the guarded fragment of first-order logic, which can express referential constraints (data in one place points to data in another) but cannot express number restrictions such as functional dependencies; and the guarded fragment with number restrictions but on a signature of arity only two. In this article, we give the first decidability results for FQA that combine both referential constraints and number restrictions for arbitrary signatures: We show that, for unary inclusion dependencies and functional dependencies, the finiteness assumption of FQA can be lifted up to taking the finite implication closure of the dependencies. Our result relies on new techniques to construct finite universal models of such constraints for any bound on the maximal query size.

Learning Join Queries from User Examples

We investigate the problem of learning join queries from user examples. The user is presented with a set of candidate tuples and is asked to label them as positive or negative examples, depending on whether or not she would like the tuples as part of the join result. The goal is to quickly infer an arbitrary n -ary join predicate across an arbitrary number m of relations while keeping the number of user interactions as minimal as possible. We assume no prior knowledge of the integrity constraints across the involved relations. Inferring the join predicate across multiple relations when the referential constraints are unknown may occur in several applications, such as data integration, reverse engineering of database queries, and schema inference. In such scenarios, the number of tuples involved in the join is typically large. We introduce a set of strategies that let us inspect the search space and aggressively prune what we call uninformative tuples, and we directly present to the user the informative ones—that is, those that allow the user to quickly find the goal query she has in mind. In this article, we focus on the inference of joins with equality predicates and also allow disjunctive join predicates and projection in the queries. We precisely characterize the frontier between tractability and intractability for the following problems of interest in these settings: consistency checking, learnability, and deciding the informativeness of a tuple. Next, we propose several strategies for presenting tuples to the user in a given order that allows minimization of the number of interactions. We show the efficiency of our approach through an experimental study on both benchmark and synthetic datasets.

Online processing of sentences containing noun modification in young children with high-functioning autism.

There is variability in the language of children with autism, even those who are high functioning. However, little is known about how they process language structures in real time, including how they handle potential ambiguity, and whether they follow referential constraints. Previous research with older autism spectrum disorder (ASD) participants has shown that these individuals can use context to access rapidly the meaning of ambiguous words. The severity of autism has also been shown to influence the speed in which children with ASD access lexical information. To understand more about how children with ASD process language in real time (i.e., as it unfolds). The focus was the integration of information and use of referential constraints to identify a referent named in a sentence. We used an eye-tracking task to compare performance between young, high-functioning children with autism (HFA) and children with typical development (TD). A large sample of 5-9-year-old children (mean age = 6;8 years), 48 with HFA and 56 with TD participated; all were attending mainstream schools. For each item participants were shown a display of four images that differed in two dimensions. Each sentence contained an adjective and noun that restricted the choice from four to two (the target and competitor), followed by a prepositional phrase (e.g., the blue square with dots); this added modifying information to provide a unique description of the target. We calculated looking time at the target, the competitor and the two distractors for each 200 ms time interval as children processed the sentence and looked at the display. Generalized estimating equations were used to carry out repeated-measures analyses on the proportion of looking time to target and competitor and time to fixate to target. Children in both groups (HFA and TD) looked at the target and competitor more than at the distractors following the adjective and noun and following the modifying information in the prepositional phrase more at the target. However, the HFA group was significantly slower in both phases and looked proportionally less at the target. Across the sample, IQ and language did not affect the results; however, age and attention had an impact. The older children showed an advantage in processing the information as did the children with higher attention scores. The HFA group took longer than the TD group to integrate the disambiguating information provided in the course of processing a sentence and integrate it with the visual information, indicating that for the ASD group incremental processing was not as advanced as for children with ASD, and they were less sensitive to referential conventions. Training for young children with ASD on the use of referential conventions and available contextual clues may be of benefit to them in understanding the language they hear.

La Duplicación Pronominal Del Objeto Indir Ecto En Español

This contribution presents results of a corpus study on the referential and syntactic variables that determine the occurrence of indirect object clitic doubling in modern (written) Spanish. From a functional-typological perspective, indirect object doubling is explained by two diachronic triggers: (1) indexation of referential properties that are typical of the indirect object and account for high topicality, namely animacy, definiteness and specificity; (2) disambiguation between the indirect and the direct object. The analysis reveals that the change towards doubled indirect objects is more advanced in informal speech than in formal speech and that variation between the registers is not random: In the formal corpus, indirect object doubling is still restricted to its original functions (1) and (2), whereas in informal speech this is not the case. However, in both registers non-doubled indirect objects are predominant. Contrary to other studies, this analysis also considers features of the direct object such as animacy and syntactic category showing that these properties also have an impact on the presence or absence of the coreferential dative clitic. Therefore, indirect object doubling should be reconsidered for ditransitive constructions and appears not to be as grammaticalized as sometimes assumed due to various referential and syntactic constraints.

Automated Insertion of Exception Handling for Key and Referential Constraints

Key and referential constraints are two main integrity constraints in database applications. These constraints can be automatically enforced by the Database Management System with their exception—violation from these constraints—handled by programmers. This paper proposes an approach to relieve the burden of programmers from mechanical coding for handling exceptions of these constraints violation by using program transformation. We first propose an extended abstract syntax tree to include SQL query semantics. Based on it, each code pattern that requires exception handling together with the exception handling code to be inserted is represented as a transformation rule. We provide two alternatives to handle the exceptions: one is to handle the exceptions in conjunction with the built-in enforcement feature in Database Management System; the other is handling them without using the feature provided in Database Management System. Hence, two types of transformation rules are provided accordingly. A tool GEHPHP (Generation of Exception Handling for PHP Systems) has been developed to implement the proposed approach. Experiments have also been conducted to evaluate the applicable of the approach.

Effects of referential ambiguity, time constraints and addressee orientation on the production of morphologically complex words

In five experiments, participants were asked to describe unambiguously a target picture in a picture–picture paradigm. In the same-category condition, target (e.g., water bucket) and distractor picture (e.g., ice bucket) had identical names when their preferred, morphologically simple, name was used (e.g., bucket). The ensuing lexical ambiguity could be resolved by compound use (e.g., water bucket). Simple names sufficed as means of specification in other conditions, with distractors identical to the target, completely unrelated, or geometric figures. With standard timing parameters, participants produced mainly ambiguous answers in Experiment 1. An increase in available processing time hardly improved unambiguous responding (Experiment 2). A referential communication instruction (Experiment 3) increased the number of compound responses considerably, but morphologically simple answers still prevailed. Unambiguous responses outweighed ambiguous ones in Experiment 4, when timing parameters were further relaxed. Finally, the requirement to name both objects resulted in a nearly perfect ambiguity resolution (Experiment 5). Together, the results showed that speakers overcome lexical ambiguity only when time permits, when an addressee perspective is given and, most importantly, when their own speech overtly signals the ambiguity.

Coupled Transformation of Schemas, Documents, Queries, and Constraints

Coupled transformation occurs when multiple software artifacts must be transformed in such a way that they remain consistent with each other. For instance, when a database schema is adapted in the context of system maintenance, the persistent data residing in the system's database needs to be migrated to conform to the adapted schema. Also, queries embedded in the application code and any declared referential constraints must be adapted to take the schema changes into account. As another example, in XML-to-relational data mapping, a hierarchical XML Schema is mapped to a relational SQL schema with appropriate referential constraints, and the XML documents and queries are converted into relational data and relational queries. The 2LT project is aimed at providing a formal basis for coupled transformation. This formal basis is found in data refinement theory, point-free program calculation, and strategic term rewriting. We formalize the coupled transformation of a data type by an algebra of information-preserving data refinement steps, each witnessed by appropriate data conversion functions. Refinement steps are modeled by so-called two-level rewrite rules on type expressions that synthesize conversion functions between redex and reduct while rewriting. Strategy combinators are used to composed two-level rewrite rules into complete rewrite systems. Point-free program calculation is applied to optimized synthesize conversion function, to migrate queries, and to normalize data type constraints. In this paper, we provide an overview of the challenges met by the 2LT project and we give a sketch of the solutions offered.

Effects of prosodic and lexical constraints on parsing in young children (and adults)

Prior studies of ambiguity resolution in young children have found that children rely heavily on lexical information but persistently fail to use referential constraints in online parsing [Trueswell, J.C., Sekerina, I., Hill, N.M., & Logrip, M.L, (1999). The kindergarten-path effect: Studying on-line sentence processing in young children. Cognition, 73, 89–134; Snedeker, J. & Trueswell, J. (2004). The developing constraints on parsing decisions: The role of lexical-biases and referential scenes in child and adult sentence processing. Cognitive Psychology, 49(3), 238–299]. This pattern is consistent with either a modular parsing system driven by stored lexical information or an interactive system which has yet to acquire low-validity referential constraints. In two experiments we explored whether children could use a third constraint—prosody—to resolve globally ambiguous prepositional-phrase attachments (“You can feel the frog with the feather”). Four to six-year-olds and adults were tested using the visual world paradigm. In both groups the fixation patterns were influenced by lexical cues by around 200 ms after the onset of the critical PP-object noun (“feather”). In adults the prosody manipulation had an effect in this early time window. In children the effect of prosody was delayed by approximately 500 ms. The effects of lexical and prosodic cues were roughly additive: prosody influenced the interpretation of utterances with strong lexical cues and lexical information had an effect on utterances with strong prosodic cues. We conclude that young children, like adults, can rapidly use both of these information sources to resolve structural ambiguities.

Une démarche et un outil

To assist the decisional designer in building data mart star schemes relying on a relational data source, we propose an approach supported by a tool. Our approach is independent of the semantic of any source information system; it classifies the relations in Rentities and R-associations and, is based on the structural semantics of the relations which is disseminated through the primary keys and referential constraints. This approach extracts facts, dimensions and hierarchies using a set of appropriate heuristics. A software tool baptized CAME is developed to support our proposed method; it constructs automatically star scheme data marts.

Rewriting Union Queries Using Views

The problem of finding contained rewritings of queries using views is of great importance in mediated data integration systems. In this paper, we first present a general approach for finding contained rewritings of unions of conjunctive queries with arbitrary built-in predicates. Our approach is based on an improved method for testing conjunctive query containment in this context. Although conceptually simple, our approach generalizes previous methods for finding contained rewritings of conjunctive queries and is more powerful in the sense that many rewritings that can not be found using existing methods can be found by our approach. Furthermore, implication constraints (Zhang, X., & Ozsoyoglu, Z.M. (1997). Implication and referential constraints: A new formal resaoning. IEEE TKDE, 9(6):894--910, Now/Dec.) over the base relations can be easily handled. We then present a simplified approach which is less complete, but is much faster than the general approach, and it still finds maximum rewritings in several special cases. Our general approach finds more rewritings than previous algorithms such as the Bucket and the resolution-based algorithms. Our simplified approach generalizes the U-join and the MiniCon algorithms with no loss of efficiency.

Minimal-change integrity maintenance using tuple deletions

We address the problem of minimal-change integrity maintenance in the context of integrity constraints in relational databases. We assume that integrity-restoration actions are limited to tuple deletions. We focus on two basic computational issues: repair checking (is a database instance a repair of a given database?) and consistent query answers [in: ACM Symposium on Principles of Database Systems (PODS), 1999, 68] (is a tuple an answer to a given query in every repair of a given database?). We study the computational complexity of both problems, delineating the boundary between the tractable and the intractable cases. We consider denial constraints, general functional and inclusion dependencies, as well as key and foreign key constraints. Our results shed light on the computational feasibility of minimal-change integrity maintenance. The tractable cases should lead to practical implementations. The intractability results highlight the inherent limitations of any integrity enforcement mechanism, e.g., triggers or referential constraint actions, as a way of performing minimal-change integrity maintenance.

The developing constraints on parsing decisions: The role of lexical-biases and referential scenes in child and adult sentence processing

Two striking contrasts currently exist in the sentence processing literature. First, whereas adult readers rely heavily on lexical information in the generation of syntactic alternatives, adult listeners in world-situated eye-gaze studies appear to allow referential evidence to override strong countervailing lexical biases ( Tanenhaus, Spivey-Knowlton, Eberhard, & Sedivy, 1995). Second, in contrast to adults, children in similar listening studies fail to use this referential information and appear to rely exclusively on verb biases or perhaps syntactically based parsing principles ( Trueswell, Sekerina, Hill, & Logrip, 1999). We explore these contrasts by fully crossing verb bias and referential manipulations in a study using the eye-gaze listening technique with adults (Experiment 1) and five-year-olds (Experiment 2). Results indicate that adults combine lexical and referential information to determine syntactic choice. Children rely exclusively on verb bias in their ultimate interpretation. However, their eye movements reveal an emerging sensitivity to referential constraints. The observed changes in information use over ontogenetic time best support a constraint-based lexicalist account of parsing development, which posits that highly reliable cues to structure, like lexical biases, will emerge earlier during development and more robustly than less reliable cues.

Drawing database schemas

AbstractA wide number of practical applications would benefit from automatically generated graphical representations of database schemas, in which tables are represented by boxes, and table attributes correspond to distinct stripes inside each table. Links, connecting attributes of two different tables, represent referential constraints or join relationships, and may attach arbitrarily to the left‐ or to the right‐hand side of the stripes representing the attributes. To our knowledge no drawing technique is available to automatically produce diagrams in such a strongly constrained drawing convention. In this paper we provide a polynomial time algorithm for solving this problem, and test its efficiency and effectiveness against a large test suite. Also, we describe an implementation of a system that uses such an algorithm and we study the main methodological problems we faced in developing such a technology. Copyright © 2002 John Wiley & Sons, Ltd.

Exploring into programs for the recovery of data dependencies designed

Data dependencies play an important role in the design of a database. Many legacy database applications have been developed on old generation database management systems and conventional file systems. As a result, most of the data dependencies in legacy databases are not enforced in the database management systems. As such, they are not explicitly defined in database schema and are enforced in the transactions, which update the databases. It is very difficult and time consuming to find out the designed data dependencies manually during the maintenance and reengineering of database applications. In software engineering, program analysis has long been developed and proven as a useful aid in many areas. With the use of program analysis, this paper proposes a novel approach for the recovery of common data dependencies, i.e., functional dependencies, key constraints, inclusion dependencies, referential constraints, and sum dependencies, designed in a database from the behavior of transactions, which update the database. The approach is based on detecting program path patterns for implementing most commonly used methods to enforce these data dependencies.

Implication and referential constraints: a new formal reasoning

The authors address the issue of reasoning with two classes of commonly used semantic integrity constraints in database and knowledge-base systems: implication constraints and referential constraints. They first consider a central problem in this respect, the IRC-refuting problem, which is to decide whether a conjunctive query always produces an empty relation on (finite) database instances satisfying a given set of implication and referential constraints. Since the general problem is undecidable, they only consider acyclic referential constraints. Under this assumption, they prove that the IRC-refuting problem is decidable, and give a novel necessary and sufficient condition for it. Under the same assumption, they also study several other problems encountered in semantic query optimization, such as the semantics-based query containment problem, redundant join problem, and redundant selection-condition problem, and show that they are polynomially equivalent or reducible to the IRC-refuting problem. Moreover, they give results on reducing the complexity for some special cases of the IRC-refuting problem.

CONSTRUCTING PARTIAL AND COMPLETE INTELLIGENT ANSWERS FOR RECURSIVE QUERIES

In this paper we study the issue of providing intelligent answers to recursive queries initially proposed in [Imie88]. In contrast to conventional query answers, which are sets of tuples, intelligent answers are rules describing the characteristics of the results. This way, an intelligent answer facilitates users to better capture the meaning of the query. To this aim, we first extend the notion of intelligent answers by allowing them to be partial (or incomplete). Complete and partial intelligent answers are both useful, in that they provide (possibly partial) characterizations of queries. We will show that complete intelligent answers also give a more efficient way to evaluate queries. For constructing intelligent answers, we propose a general approach that enables us to combine several cases studied in [Imie88]. Moreover, we will show that semantic constraints can be systematically utilized to provide complete intelligent answers to a wider range of queries. We consider two commonly used classes of semantic constraints called implication and referential constraints, and prove that the completeness of intelligent answers with respect to semantic constraints can be reduced to the semantics-based query containment problem. Finally, a necessary and sufficient condition is given to solve this containment problem.