A design document for the CORAL deductive database system

CORAL is a deductive database system that supports a rich declarative language, and an interface to C++ that allows for a combination of declarative and imperative programming. It is important to know the design and the implementation for CORAL in order to be able to extend this system. This report documents the design for CORAL. The Unified Modeling Language (UML) is used to describe the Architecture, Structural Model and Behavioral Model. The design documentation is based on the study of the source code, the user manual and the published papers about CORAL

Linking CORAL to MySQL and PostgreSQL

A Graph Database System is developed at Concordia University. In this system, CORAL is used as the deductive engine. Since MySQL and PostgreSQL are selected to manage the persistent data, connections between CORAL and MySQL as well as PostgreSQL need to be established. This thesis mainly proposes a solution for these connections. Firstly, CORAL's architecture is analyzed. Its relational database interface is described. Class diagrams, object diagrams, and interaction diagrams are drawn to illustrate CORAL's rules and to identify the requirements. Then, classes are designed as an extension of CORAL's structure to communicate with MySQL and PostgreSQL. Data type conversion rules are defined based on the characteristics of each database system. Classes and parent classes are described in detail and patterns applied in these classes are discussed for the reusability of the design. Additionally, databases for MySQL and PostgreSQL are created and the extended CORAL system is tested. Finally, a CORAL client process is designed and implemented so as to integrate the TGL translator, which translates from the GraphLog graph database language to CORAL, with client-server mode CORAL and communicate with the underlying relational databases. The implementation of this solution uses C++ in a UNIX environment

Experiences with Some Benchmarks for Deductive Databases and Implementations of Bottom-Up Evaluation

OpenRuleBench is a large benchmark suite for rule engines, which includes deductive databases. We previously proposed a translation of Datalog to C++ based on a method that "pushes" derived tuples immediately to places where they are used. In this paper, we report performance results of various implementation variants of this method compared to XSB, YAP and DLV. We study only a fraction of the OpenRuleBench problems, but we give a quite detailed analysis of each such task and the factors which influence performance. The results not only show the potential of our method and implementation approach, but could be valuable for anybody implementing systems which should be able to execute tasks of the discussed types.Comment: In Proceedings WLP'15/'16/WFLP'16, arXiv:1701.0014

Principles and Implementation of Deductive Parsing

We present a system for generating parsers based directly on the metaphor of parsing as deduction. Parsing algorithms can be represented directly as deduction systems, and a single deduction engine can interpret such deduction systems so as to implement the corresponding parser. The method generalizes easily to parsers for augmented phrase structure formalisms, such as definite-clause grammars and other logic grammar formalisms, and has been used for rapid prototyping of parsing algorithms for a variety of formalisms including variants of tree-adjoining grammars, categorial grammars, and lexicalized context-free grammars.Comment: 69 pages, includes full Prolog cod

Storing and Querying Ontologies in Logic Databases

The intersection of Description Logic inspired ontology languages with Logic Programs has been recently analyzed in [GHVD03]. The resulting language, called Description Logic Programs, covers RDF Schema and a notable portion of OWL Lite. However, the proposed mapping in [GHVD03] from the corresponding OWL fragment into Logic Programs has shown scalability as well as representational de�cits within our experiments and analysis. In this paper we propose an alternative mapping resulting in lower computational complexity and more representational exibility. We also present benchmarking results for both mappings with ontologies of di�erent size and complexity

Expert system shell to reason on large amounts of data

The current data base management systems (DBMS's) do not provide a sophisticated environment to develop rule based expert systems applications. Some of the new DBMS's come with some sort of rule mechanism; these are active and deductive database systems. However, both of these are not featured enough to support full implementation based on rules. On the other hand, current expert system shells do not provide any link with external databases. That is, all the data are kept in the system working memory. Such working memory is maintained in main memory. For some applications the reduced size of the available working memory could represent a constraint for the development. Typically these are applications which require reasoning on huge amounts of data. All these data do not fit into the computer main memory. Moreover, in some cases these data can be already available in some database systems and continuously updated while the expert system is running. This paper proposes an architecture which employs knowledge discovering techniques to reduce the amount of data to be stored in the main memory; in this architecture a standard DBMS is coupled with a rule-based language. The data are stored into the DBMS. An interface between the two systems is responsible for inducing knowledge from the set of relations. Such induced knowledge is then transferred to the rule-based language working memory