Eugene Inseok Chong

Implementing an Inference Engine for RDFS/OWL Constructs and User-Defined Rules in Oracle

This inference engines are an integral part of semantic data stores. In this paper, we describe our experience of implementing a scalable inference engine for Oracle semantic data store. This inference engine computes production rule based entailment of one or more RDFS/OWL encoded semantic data models. The inference engine capabilities include (i) inferencing based on semantics of RDFS/OWL constructs and user-defined rules, (ii) computing ancillary information (namely, semantic distance and proof) for inferred triples, and (iii) validation of semantic data model based on RDFS/OWL semantics. A unique aspect of our approach is that the inference engine is implemented entirely as a database application on top of Oracle database. The paper describes the inferencing requirements, challenges in supporting a sufficiently expressive set of RDFS/OWL constructs, and techniques adopted to build a scalable inference engine. A performance study conducted using both native and synthesized semantic datasets demonstrates the effectiveness of our approach.

Supporting ontology-based semantic matching in RDBMS

Ontologies are increasingly being used to build applications that utilize domain-specific knowledge. This paper addresses the problem of supporting ontology-based semantic matching in RDBMS. Specifically, 1) A set of SQL operators, namely ONT_RELATED, ONT_EXPAND, ONT_DISTANCE, and ONT_PATH, are introduced to perform ontology-based semantic matching, 2) A new indexing scheme ONT_INDEXTYPE is introduced to speed up ontology-based semantic matching operations, and 3) System-defined tables are provided for storing ontologies specified in OWL. Our approach enables users to reference ontology data directly from SQL using the semantic match operators, thereby opening up possibilities of combining with other operations such as joins as well as making the ontology-driven applications easy to develop and efficient. In contrast, other approaches use RDBMS only for storage of ontologies and querying of ontology data is typically done via APIs. This paper presents the ontology-related functionality including inferencing, discusses how it is implemented on top of Oracle RDBMS, and illustrates the usage with several database applications.

Supporting table partitioning by reference in oracle

Partitioning is typically employed on large-scale data to improve manageability, availability, and performance. However, for tables connected by a referential constraint (capturing a parent-child relationship), the current approaches require individually partitioning each table thereby burdening the user with the task of maintaining the tables equi-partitioned, which not only is cumbersome but also error prone. This paper proposes a new partitioning method (partition by reference) that allows tables with a parent-child relationship to be logically equi-partitioned by inheriting the partition key from the parent table without duplicating the key columns. The partitioning key is resolved through an existing parent-child relationship, enforced by an active referential constraint. This logical dependency is used to automatically i) cascade partition maintenance operations performed on parent table to child tables, and ii) handle migration of child rows when partition key or parent key in parent table is updated, as a single atomic operation. This method has been introduced in Oracle Database 11gR1 with support for tables with both single level and composite partitioning methods. The paper describes the key concepts of table partitioning by reference method, discusses the design and implementation challenges, and presents an experimental study covering a usage scenario common in Information Life Cycle Management (ILM) applications.

A Scalable Scheme for Bulk Loading Large RDF Graphs into Oracle

The growth of RDF data makes it imperative that an efficient mechanism for bulk-loading RDF graphs be supported. Thus, the paper proposes a bulk-load scheme that allows fast loading of arbitrarily large RDF graphs into a database. Specifically, three modes of load are supported: i) loading into an empty RDF graph, ii) appending to a non-empty RDF graph, and iii) concurrent loads into multiple graphs. The bulk-load scheme is implemented as part of Oracle database semantic technologies and the performance experiments conducted with a variety of RDF graphs (from UniProt and synthesized data of Lehigh University Benchmark) demonstrate the scalability of the approach. The paper outlines the challenges involved in bulk- loading of large RDF graphs, describes the bulk-load scheme, discusses its implementation, and presents a performance study.

Visualizing large-scale RDF data using Subsets, Summaries, and Sampling in Oracle

The paper addresses the problem of visualizing large scale RDF data via a 3-S approach, namely, by using, 1) Subsets: to present only relevant data for visualisation; both static and dynamic subsets can be specified, 2) Summaries: to capture the essence of RDF data being viewed; summarized data can be expanded on demand thereby allowing users to create hybrid (summary-detail) fisheye views of RDF data, and 3) Sampling: to further optimize visualization of large-scale data where a representative sample suffices. The visualization scheme works with both asserted and inferred triples (generated using RDF(S) and OWL semantics). This scheme is implemented in Oracle by developing a plug-in for the Cytoscape graph visualization tool, which uses functions defined in a Oracle PL/SQL package, to provide fast and optimized access to Oracle Semantic Store containing RDF data. Interactive visualization of a synthesized RDF data set (LUBM 1 million triples), two native RDF datasets (Wikipedia 47 million triples and UniProt 700 million triples), and an OWL ontology (eClassOwl with a large class hierarchy including over 25,000 OWL classes, 5,000 properties, and 400,000 class-properties) demonstrates the effectiveness of our visualization scheme.

Supporting Keyword Columns with Ontology-based Referential Constraints in DBMS

Keywords are typically used to qualify rows in a table. However, the fact that a keyword denotes a concept, which belongs to a specific knowledge domain, is not semantically enforced in current database systems. This paper proposes defining ontology based referential constraint for such keyword columns. A query on ontology, specified as part of the referential constraint, is used to identify the domain for the keyword column. Furthermore, since ontology may evolve causing change to the domain of the keyword column, the paper proposes use of ontology based transformation functions to either automatically evolve or to recommend refinements for the values in the keyword column. Also, queries on a keyword column can perform semantic match, that is, match a keyword to related terms based on the associated ontology. Thus, the proposed approach of semantically connecting keyword columns to ontologies 1) enhances semantic data integrity, 2) facilitates evolution of keyword columns with the referenced ontology, and 3) enables semantic match queries on keyword columns.

B/sup +/-tree indexes with hybrid row identifiers in Oracle8i

Most commercial database systems support B/sup +/-tree indexes using either: physical row identifiers, for example, DB2; or logical row identifiers, for example, NonStop SQL. Physical row identifiers provide fast access to data. However, unlike logical row identifiers, they need to be updated whenever the row moves. This paper describes an alternate approach where hybrid row identifiers are used. A hybrid row identifier consists of two components: a logical component, namely, the primary key of the base table row; and a physical component, namely, the database block address (DBA) of the row. By treating the DBA as a guess regarding where the row may be found, performance comparable to physical B/sup +/-tree indexes is attained for valid guess-DBAs. This scheme retains the logical index advantage of avoiding an immediate index update when the base table row moves. Instead, an online utility can be used to lazily fix the invalid guess-DBAs. This scheme has been used to implement B/sup +/-tree indexes for Oracle8i index-organized tables (primary B/sup +/-tree like structure) which encounter both row movement and table reorganization.

Efficient Storage and Query Processing of Large String in Oracle

Variable size strings are a fundamental data type in RDBMS and used in virtually all database components and applications including XMLs, blogging, customer service comments, e-commerce product descriptions, etc. Many applications could require large strings to store XML documents, JSON documents, customer support history, blog entries, or HTML documents. Many social network applications as well as web 3.0 applications also require large string type. A naive implementation would simply increase the size of the traditional variable strings, but this will incur performance problems due to row chaining. Using Large Object type LOB will enable users to store large string without row chaining, but it is difficult to manipulate LOBs and many built-in operators for strings are not applicable to LOBs. Oracle 12c provides a capability of storing large strings without the row-chaining problem while eliminating LOB?s deficiencies. In addition, users can control the data placement and storage format based on their application workload. However, reading the large string from storage for each reference to the string would be inefficient for queries that reference the strings frequently. This paper presents an efficient processing strategy for queries involving large strings, while supporting theoretically unlimited size of the strings. It illustrates how seemingly simple conceptual work involves careful design and extensive engineering work to have a scalable and efficient implementation. The solution has been implemented in Oracle 12c, and the performance results show its efficiency.