AUCS/TR9302 Constraint Maintenance Using Generated Methods in the P/FDM Object-Oriented Database (original) (raw)

Constraint maintenance using generated methods in the P/FDM object-oriented database

Rules in Database Systems., …, 1994

We discuss the use of code-generated methods in Prolog as a exible and e cient way to implement complex semantic constraints in an OODB. We introduce a high-level constraint language CoLan, based on functions and sets and including range quanti ers, from which fragments of code are generated to check the constraints. These fragments are attached to slots in class descriptors, and are also inherited (constraints cannot be overridden). Thus many fragments can come from one constraint and one slot may have attached fragments from many constraints. Constraints can be selectively disabled or removed which causes inhibition or disabling of corresponding fragments. This overcomes many objections to implementing constraints through methods. We have prototyped it by using the metaclass facilities of ADAM to initiate code generation. We are now re-implementing it in P/FDM, using changes to metadata (P/FDM does not have full metaclasses). This will incorporate a transaction mechanism and also provide queries on constraints. This approach opens a number of interesting future directions.

An Efficient OODB Model for Ensuring the Integrity of User-Defined Constraints

Integrity and Internal …, 2004

In this paper, a new structural model is proposed to ease the checking of the integrity constraints in an object-oriented database system. The structure accepts declarative global specification of constraints including user-defined constraint, and an efficient representation that permits localized constraints checking. A new method called "Detection" is added to the structure to check the status of violation of the relations in an object-oriented database. The new approach is demonstrated using ALICE rule.

The Design and Implementation of an Object-Oriented Prolog Engine

The implementation of Prolog systems has a long history, starting from the first interpreter written in 1972, to the first Prolog compiler simplifying basic operations like unification and backtracking with the aim of optimizing performances, and to the Warren Abstract Machine, later becoming a de facto standard model. The tuProlog engine differs from those systems in that maximum efficiency is not amongst its primary concerns. Instead, it aims at becoming the enabling technology for building complex systems like dynamic Internet infrastructures based on intelligent components, a domain where logic languages could effectively face, in principle, the key issues of intelligence and interaction. To accomplish this task, a logic engine must meet engineering properties such as deployability, configurability and scalability; to be usable as a development tool, it also must sustain a certain degree of traceability, by allowing the inspection of its internal processes at runtime, thus easying the typical pain of debugging activities. The design and implementation of such a system must follow sound principles: object-oriented code structuring, reuse of established community knowledge under the form of patterns, loose coupling of composing elements, modularity and a clear and clean separation of concerns. In this paper, we present the architecture of tuProlog, based upon a set of managers handling control of sensible parts of the system and operating around a minimal core shaped as a Finite State Machine; then, the representation of Prolog data and the unification algorithm's implementation are discussed; finally, the resolution part of the engine is illustrated.

Constraints in an object-oriented deductive database

Lecture Notes in Computer Science, 1991

This paper relates our experience in integrating constraint resolution into an object-oriented deductive system. We motivate this work by showing that disjunctive information and global constraints fit naturally in an object-oriented model and are actually necessary to perform common tasks. We identify three difficulties in developing such an extended object-oriented system (namely, compilation, domain reduction, and heuristics) and propose a solution for each. We provide a formal semantics and prove the correctness of those three techniques. We illustrate the performance results with the implementation we have built in LAURE.

CR-Prolog as a Specification Language for Constraint Satisfaction Problems

Lecture Notes in Computer Science, 2009

In this paper we describe an approach for integrating CR-Prolog and constraint programming, in which CR-Prolog is viewed as a specification language for constraint satisfaction problems. Differently from other methods of integrating ASP and constraint programming, our approach has the advantage of allowing the use of off-the-shelf, unmodified ASP solvers and constraint solvers, and of global constraints, which substantially increases practical applicability.

The Ciao clp (FD) Library. A Modular CLP Extension for Prolog

2013

We present a new free library for Constraint Logic Programming over Finite Domains, included with the Ciao Prolog system. The library is entirely written in Prolog, leveraging on Ciao's module system and code transformation capabilities in order to achieve a highly modular design without compromising performance. We describe the interface, implementation, and design rationale of each modular component. The library meets several design goals: a high level of modularity, allowing the individual components to be replaced by different versions; highefficiency, being competitive with other FD implementations; a glass-box approach, so the user can specify new constraints at different levels; and a Prolog implementation, in order to ease the integration with Ciao's code analysis components. The core is built upon two small libraries which implement integer ranges and closures. On top of that, a finite domain variable datatype is defined, taking care of constraint reexecution depending on range changes. These three libraries form what we call the FD kernel of the library. This FD kernel is used in turn to implement several higher-level finite domain constraints, specified using indexicals. Together with a labeling module this layer forms what we name the FD solver. A final level integrates the CLP(FD) paradigm with our FD solver. This is achieved using attributed variables and a compiler from the CLP(FD) language to the set of constraints provided by the solver. It should be noted that the user of the library is encouraged to work in any of those levels as seen convenient: from writing a new range module to enriching the set of FD constraints by writing new indexicals.

On the Expressive Power of the Object Constraint Language OCL

1999

The Object Constraint Language (OCL) has been introduced by IBM for business modelling and adopted by UML as a mean to specify invariants of classes and types in a class model, to specify type invariant of stereotypes, to describe pre- and postconditions on operations and methods, to describe guards, and also as a navigation language. OCL is a language of typed expressions, where an expression can be universally and existentially quantified. This paper

A Data Base Support System for Prolog

1983

In the current literature PROLOG is often connected with databases, eg (Warren 81), (Lloyd 82). That intuition is, in our opinion, correct. Nevertheless, two main points have been missed: how to organize large PROLOG databases and why they should be superior to the conventional, eg relational, ones. In this paper, we concentrate on the former question. We start by discussing the advantages of PROLOG over the relational model of data. Then we outline simple PROLOG solutions to several database problems. However, some of the most difficult issues of database management do not depend on the language used for defining and manipulating databases. We describe a database support system for PROLOG implemented at the Institute of Informatics, Warsaw University. According to the taxonomies of (Lloyd 82), our efforts may be described as an interpreted approach, providing ( currently)limited database management system capabilities. The system is primarily meant for the storage, retrieval and mo...

The GNU Prolog system and its implementation

2000

We describe in this paper the GNU-Prolog system, a free system consisting of a Prolog compiler and a constraint solver on nite domains. GNU-Prolog is based on a low-level mini-assembly platform-independent language that makes it possible for e cient compilation time, and allows to produce small stand alone executable les as the result of the compilation process. Interestingly, the Prolog part is compliant to the ISO standard, and the constraint part includes several extensions, such as an e cient handling of rei ed constraints. The overall system is e cient and comparable in performances with commercial systems, both for the Prolog and constraint parts.

Constraint satisfaction with an object-oriented knowledge representation language

Applied Intelligence, 1994

This paper gives a detailed presentation of constraint satisfaction in the hybrid LAURE language. LAURE is an object-oriented language for Artificial Intelligence (AI) applications which allows the user to combine rules, constraints and methods that cooperate on the same objects in the same program. We illustrate why this extensibility is necessary to solve some large and difficult problems by presenting a real-life application of LAURE. We describe the syntax and the various modes in which constraints may be used, as well as the tools that are proposed by LAURE to extend constraint resolution. The resolution strategy as well as some implementation details are given to explain how we obtain good performances.