Search

The object-relational impedance mismatch (ORIM) problem characterises differences between the object-oriented and relational approaches to data access. Queries generated by object-relational mapping (ORM) frameworks are designed to overcome ORIM difficulties and can cause performance concerns in environments which use object-oriented paradigms. The aim of this paper is twofold, first presenting a survey of database practitioners on the effectiveness of ORM tools followed by an experimental investigation into the extent of operational concerns through the comparison of ORM-generated query performance and SQL query performance with a benchmark data set. The results show there are perceived difficulties in tuning ORM tools and distrust around their effectiveness. Through experimental testing, these views are validated by demonstrating that ORMs exhibit performance issues to the detriment of the query and the overall scalability of the ORM-led approach. Future work on establishing a system to support the query optimiser when parsing and preparing ORM-generated queries is outlined.

Nowadays, one of the most challenging situations for software developers is the presence of a mismatch between relational database systems and programming codes. In the literature, this problem is defined as "impedance mismatch". This study is to develop a framework built on innovations based on the existing Object Relational Mapping technique to solve these problems. In the study, users can perform operations for three different database systems such as MsSQL, MySql and Oracle. In addition, these operations can be done within the framework of C# and Java programming languages. In this framework, while the developers can define database tables in the interface automatically, they can create relations between tables by defining a foreign key. When the system performs these operations, it creates tables, views, and stored procedures automatically. In addition, entity classes in C# and Java for tables and views, and operation classes for stored procedures are created automatically. The summary of the transactions can be taken as pdf file by the framework. In addition, the project can automatically create Windows Communication Foundation classes to facilitate the handling of database elements created and the interfacing operations, as well. This framework, which supports distributed systems, can be downloaded at this link.

This chapter briefly introduces NORM (No-ORM) - a methodology of application development that avoids many of pitfals of widely accepted development patterns. Within NORM, the interactions between application code and the database are restricted by a contract that limits the number of interactions and ensures high performance. To address the consequences of impedance mismatch, an additional model, called transfer model, is mapped to both the database model and the application model, providing means for interactions in terms of high-level complex data objects.

NOSQL database management systems adopt semi-structured data models, such as JSON, to easily accommodate schema evolution and overcome the overhead generated from transforming internal structures to tabular data (i.e., impedance mismatch). There exist multiple, and equivalent, ways to physically represent semi-structured data, but there is a lack of evidence about the potential impact on space and query performance. In this paper, we embark on the task of quantifying that, precisely for document stores. We empirically compare multiple ways of representing semi-structured data, which allows us to derive a set of guidelines for efficient physical database design considering both JSON and relational options in the same palette. Partly funded by the European Commission through the programme “EM IT4BI-DC”.

Database performance tuning is a complex and varied active research topic. With enterprise relational database management systems still reliant on the set-based relational concepts that defined early data management products, the disparity between the object-oriented application development model and the object-relational database model, called the object-relational impedance mismatch problem, is addressed by techniques such as object-relational mapping (ORM). This, compounded with changes in the way data is produced, stored and managed can result in generally poor query performance for SQL produced by object-oriented applications and an irregular fit with cost-based optimisation algorithms, and leads to questions about the need for the relational model to better adapt to a more diverse set of queries. This paper discusses existing database performance optimisation techniques and approaches and makes the argument that current database performance tuning approaches need revisiting to support queries developed through ORM tools. This paper also introduces our current research, which includes exploring concepts such as dynamic schema redefinition; query analysis and optimisation modelling driven by machine learning; and augmentation of the cost-based optimiser model.

Background With the growth of available sequenced datasets, analysis of heterogeneous processed data can answer increasingly relevant biological and clinical questions. Scientists are challenged in performing efficient and reproducible data extraction and analysis pipelines over heterogeneously processed datasets. Available software packages are suitable for analyzing experimental files from such datasets one by one, but do not scale to thousands of experiments. Moreover, they lack proper support for metadata manipulation. Results We present PyGMQL, a novel software for the manipulation of region-based genomic files and their relative metadata, built on top of the GMQL genomic big data management system. PyGMQL provides a set of expressive functions for the manipulation of region data and their metadata that can scale to arbitrary clusters and implicitly apply to thousands of files, producing millions of regions. PyGMQL provides data interoperability, distribution transparency and query outsourcing. The PyGMQL package integrates scalable data extraction over the Apache Spark engine underlying the GMQL implementation with native Python support for interactive data analysis and visualization. It supports data interoperability, solving the impedance mismatch between executing set-oriented queries and programming in Python. PyGMQL provides distribution transparency (the ability to address a remote dataset) and query outsourcing (the ability to assign processing to a remote service) in an orthogonal way. Outsourced processing can address cloud-based installations of the GMQL engine. Conclusions PyGMQL is an effective and innovative tool for supporting tertiary data extraction and analysis pipelines. We demonstrate the expressiveness and performance of PyGMQL through a sequence of biological data analysis scenarios of increasing complexity, which highlight reproducibility, expressive power and scalability.

In spatial hypertext, linking is implicit. Users can use spatial and visual attributes, such as proximity, shape, or color, to describe the information space. Spatial hypertext models are special. For example, they need a flexible handling of attributes. Using a relational database management system (DBMS) in the backend, leads to an impedance mismatch problem as spatial hypertext and relational database approaches build on different structural paradigms. In this paper, we introduce the spatial hypertext impedance mismatch and argue for a special structure store to avoid or, at least, reduce the introduced problem. Document stores appear to be an intuitive way or at least a good starting point for providing an intuitive way to store, retrieve, and manage spatial hypermedia structures. In this paper, we analyze document stores in more detail in order to estimate their suitability as spatial hypermedia structure store.

An educational module is developed to provide students with a tangible introduction to the fundamental principles of electromagnetic propagation along a transmission line. This module implements an active-learning approach, with both simulated and experimental elements, to demonstrate such concepts as incident and reflected waves, propagation delay, attenuation, and impedance mismatch. This module is designed to be implemented using only standard laboratory equipment and time-domain simulation software.

Operational NoSQL systems are relatively new in the data-management ecosystem, and there is much confusion about their capabilities and how they differ from traditional relational database systems. This summary of characteristics clearly distinguishes the two system classes and provides a glimpse into directions for future work.

This paper considers the impact of object-relational mapping (ORM) tools on relational database query performance. ORM tools are widely used to address the object-relational impedance mismatch problem but can have negative performance consequences. We first define the background of the problem, describing the growth of ORM tools against a backdrop of the changing application development landscape, then demonstrate examples of undesirable query performance patterns resulting from the application of these tools using a leading application stack. We review selected literature for prior research into this problem and summarise the findings. Finally, we conclude by suggesting future research directions to help mitigate the issues found with ORMs and signpost some potential solutions.

Object-oriented database management systems represent a technology in which the concepts of the object-oriented programming paradigm are implemented in databases. The impedance mismatch problem between different technologies (e.g., relational and object-oriented) has represented a challenge for developers and researchers for many years now. With the growing popularity of graph databases, it is important to resolve differences between the concepts of graph theory (used in graph databases) and the object-oriented paradigm. In this paper, we propose an approach for representing graph nodes as objects, and introduce the concept of node inheritance in graph databases, which we demonstrate on a simple showcase.

Recently, the number of high-definition media devices such as 8K ultra high-definition (UHD) TV and virtual reality (VR) is rapidly increasing. These multimedia systems require higher data rates for high resolution and versatility. With this increasing technical trend, high-speed connectors and cables are also becoming important. In this paper, we propose a highspeed connector that can transmit high-speed media data. The previous connectors have focused only on a physical connection and a mechanical reliability. However, as the data rate is increased, electrical performances of the connector have also become highly important. Therefore, signal integrity (SI) analysis for insertion loss, attenuation-to-crosstalk ratio (ACR), and impedance mismatch become essential for the high-speed connector. For verification, the 3D EM simulation tool is used to compare the performance of the previous and proposed connector. In conclusion, the proposed high-speed connector has better electrical performances than that of the previous connector.

The quest to develop increasingly sophisticated verification systems continues unabated. Tools such as Dafny, Spec#, ESC/Java, SPARK Ada, and Whiley attempt to seamlessly integrate specification and verification into a programming language, in a similar way to type checking. A common integration approach is to generate verification conditions that are handed off to an automated theorem prover. This provides a nice separation of concerns, and allows different theorem provers to be used interchangeably. However, generating verification conditions is still a difficult undertaking and the use of more “high-level” intermediate verification languages has become common-place. In particular, Boogie provides a widely used and understood intermediate verification language. A common difficulty is the potential for an impedance mismatch between the source language and the intermediate verification language. In this paper, we explore the use of Boogie as an intermediate verification language for verifying programs in Whiley. This is noteworthy because the Whiley language has (amongst other things) a rich type system with considerable potential for an impedance mismatch. We report that, whilst a naive translation to Boogie is unsatisfactory, a more abstract encoding is surprisingly effective.

Archive management system based on modern information technology as the support, the archives information as management object, the archives work as the core and implement management information system, database design is the core work of the development of archives management system work, this article launches the research from four aspects according to the database design process. First, from the business requirements, functional requirements, performance requirements, such as security requirements for demand analysis; Second, according to the result of requirement analysis, conceptual design using E-R diagram; Third, converting E-R diagram logic structure supported by the database management system; Fourth, for the logic model to determine the storage structure and access method. In this paper, it based on the relational database design, a relational database with full-text database is the development direction of the future.

Archive management system based on modern information technology as the support, the archives information as management object, the archives work as the core and implement management information system, database design is the core work of the development of archives management system work, this article launches the research from four aspects according to the database design process. First, from the business requirements, functional requirements, performance requirements, such as security requirements for demand analysis; Second, according to the result of requirement analysis, conceptual design using E-R diagram; Third, converting E-R diagram logic structure supported by the database management system; Fourth, for the logic model to determine the storage structure and access method. In this paper, it based on the relational database design, a relational database with full-text database is the development direction of the future.

The ability of web applications to respond fast is critical to the success of any web-based business, and time spent on the interaction with the database is often the most time-consuming portion of the overall response time. Although recent research suggest lots of proven algorithms to improve this interaction, the technicalities of implementation are often considered too time consuming by application developers. In this paper we present a tool that eliminates a significant portion of these technical difficulties and allows almost seamless incorporation of complex database queries and functions into object-oriented applications.

Extracting information from a database system becomes a primary obligation. More and more we are forced to recognize the importance of providing easy access to information stored in a database system. However existing tools that allow users to query database using database query languages such as SQL (Structured Query Language) are difficult for non-experts users. Wherefore asking questions to databases in natural language is a very simple method that can provide powerful improvements to the use of data stored in databases. This paper presents the Architecture and the implementation of a generic natural language interface based on machine learning approach for a relational database. The advantage of this interface is that it functions independently of the database domain and automatically improves through experience its knowledge base.

We present chidb, a medium to large-scale programming project where students implement the main components of a relational database management system, including B-tree data structures for tables and indexes, a database machine with registers and a selection of high-level and low-level instructions, and a SQL compiler targeting that machine. Moreover, chidb's SQL compiler's internal representation is a direct encoding of the relational algebra, whereby the theory that might otherwise be relegated to notes and blackboards is directly connected to practice and experience. The project uses the C programming language and is demonstrably suitable for use in advanced undergraduate courses; we have administered this project through five iterations of our databases course for advanced undergraduates. chidb is freely available online and customizable to suit the needs and tastes of any particular instructor.

GORM (Grails Object Relational Mapping) is an Object Relational Mapping Framework for the Grails web framework. Object Relational Mapping (ORM) frameworks reduce the problems arising out of the object-relational impedance mismatch between the object oriented design model and the relational database design. Unlike other ORM frameworks which require application programmers to configure a lot of XML files, GORM sits transparently between the application logic and the database relieving the programmer from maintaining any sort of configuration files. The default ORM provided by Grails through GORM introduces performance issues in a web application especially when it experiences large loads. This paper identifies problems faced when applying default GORM to application which includes the N+1 select problem, issues with handling one-to-many relationships, bulk insertions as well as problems related to bulk mail transfer and keeping the query cache unused. The paper also suggests optimization techniques which could be applied to each of the problems in order to improve the overall performance of a web application using GORM as its ORM solution. General Terms Relational Database, Object Oriented Design, Object Relational Mapping

Meta-modelling is one of the pillars of Model-Driven Engineering (MDE), where it is used for language engineering and domain modelling. Even though the current trend is the use of two-level meta-modelling frameworks, several researchers have pointed out limitations of this scheme for some scenarios and suggested a metamodelling approach with an arbitrary number of meta-levels in order to obtain more flexible and simpler system descriptions. Unfortunately, such multi-level meta-modelling systems are still in their infancy, lacking for example, integration with model manipulation languages, a characterization of different possibilities for instantiation and inheritance, and primitives for interconnecting multi-level languages in a flexible way. In this paper, we propose a number of extensions to multi-level (also called deep) meta-modelling, based on the needs raised by its use for practical MDE. In particular, we discuss on the issues related to code generation from deep languages, the benefits of allowing inheritance at every meta-level, and patterns and techniques for a fine-grain control of the meta-level of elements. Finally, we provide primitives to control the impedance mismatch when connecting models at different meta-levels.

XML has recently emerged as the leading medium for data storage and data transfer over the World Wide Web due to its adaptable structure and flexibility in defining the tags. Many organizations had adopted XML as the principal facet in their online business applications. On the other hand, relational database is still widely used as the back-end database in most organizations. The diversity of these models need to be taken into account to ensure transparent and seamless integration. In this paper, we propose s-XML, an effective mapping scheme to bridge XML and relational database. Experimental results indicate that (1) s-XML is robust in terms of database storage and data loading; (2) s-XML processes query efficiently for complex chain and twig queries; and (3) s-XML is able to support large and skew-structured dataset as compared to relational DTD, Attribute and Edge approaches.

Problem statement: The databases introduce the digital era the fact that requirement to maintain large and ample data. The growth of information development and improvement that pursued it transformed the databases into a global reality. This study enquired and described the vital role of storing the context data to an appropriate database in the area of context aware computing. It also addson limitations of the existing relational and object relational databases with respect to context aware computing. Approach: This article examines traditional database like relational database, object relational database and spatial database. It helps to make an optimal decision while choosing the database for context aware applications. Results: All the traditional databases are compared with context aware features like semantic support, ease of transaction of large data, query optimization, reasoning support, formality, scalability, spatial data and xml support. Conclusion: This study confirmed that using object relational database along with ontology is more apt for storing the context data for context aware computing applications.

Regardless of the paradigm used to model the application domain, most enterprise applications use the relational model for data storage. Relational database technology is mature, widely understood, and successfully deployed in countless applications. However, its dominance has also had some undesirable consequences for application development. For an application that models the business logic in an object-oriented way, the developer faces an impedance mismatch between the application's object model and the data's relational model. Object-relational mapping (ORM) frameworks exist to bridge this divide, but ORMs aren't trivial to use and often introduce more complexity than the problem they solve.

In this paper, we take Oracle as the example of relational database, and Caché as a post-relational database. We implement the performance test between relational database and post-relational database in HIS. The results prove post-relational are much more efficient than relational database.

A novel, table-driven approach based on relational database technology is proposed for the design and early validation of cache coherence protocols. A protocol is specified as multiple communicating, multi-input, multi-output, finite-state machines each represented by a relational database table. The tables are automatically generated by solving relational calculus constraints specifying the protocol transactions. Early protocol validation prior to an implementation is performed by testing these tables for several protocol properties expressed using relational queries and database integrity constraints. The debugged tables are automatically mapped to a high-level hardware implementation while preserving their correctness. The proposed approach has been deployed at Fujitsu Systems Technology Division for the design of their next-generation multiprocessor and has been highly successful in reducing the overall protocol development time and has discovered several errors early in the design cycle. Copyright © 2006 John Wiley & Sons, Ltd.

Due to the emergence of cloud computing and big data applications, modern software systems are becoming more dependent on the underlying database management systems (DBMSs) for data integrity and management. Since DBMSs are very complex and each technology has some implementation-specific differences, DBMSs are usually used as black boxes by software developers, which allow better adaption and abstraction of different database technologies. For example, Object-Relational Mapping (ORM) is one of the most popular database abstraction approaches that developers use. Using ORM, objects in Object-Oriented languages are mapped to records in the DBMS, and object manipulations are automatically translated to SQL queries. Despite ORM's convenience, there exists impedance mismatches between the Object-Oriented paradigm and the relational DBMSs. Such impedance mismatches may result in developers writing inefficiently and/or incorrectly database access code. Thus, this thesis proposes several approaches to improve the quality of database-centric software systems by looking at the application source code. We focus on troubleshooting and detecting inefficient (i.e., performance problems) and incorrect (i.e., functional problems) database accesses in the source code, and we prioritize the detected problems based on severity. Through case studies on large commercial and open source systems, we plan to demonstrate the value of improving the quality of database-centric software systems from a new perspective - helping developers access the database more efficiently and accurately.

Relational database management systems build on the closed world assumption requiring upfront modeling of a usually stable schema. However, a growing number of today's database applications are characterized by self-descriptive data. The schema of self-descriptive data is very dynamic and prone to frequent changes; a situation which is always troublesome to handle in relational systems. This demo presents the relational database management system FRDM. With flexible relational tables FRDM greatly simplifies the management of self-descriptive data in a relational database system. Self-descriptive data can reside directly next to traditionally modeled data and both can be queried together using SQL. This demo presents the various features of FRDM and provides first-hand experience of the newly gained freedom in relational database systems.

The purpose of this paper is to present a comparative study between relational and non-relational database models in a web-based application, by executing various operations on both relational and on non-relational databases thus highlighting the results obtained during performance comparison tests. The study was based on the implementation of a web-based application for population records. For the non-relational database, we used MongoDB and for the relational database, we used MSSQL 2014. We will also present the advantages of using a non-relational database compared to a relational database integrated in a web-based application, which needs to manipulate a big amount of data.

Most approaches for the extraction of association rules look for associations from a dataset in the form of a single table. However, with the growing interest in the storage of information, relational databases comprising a series of relations (tables) and relationships have become essential. We present the first grammar-guided genetic programming approach for mining association rules directly from relational databases. We represent the relational databases as trees by means of genetic programming, preserving the original database structure and enabling rules to be defined in an expressive and very flexible way. The proposed model deals with both positive and negative items, and also with both discrete and quantitative attributes. We exemplify the utility of the proposed approach with an artificial generated database having different characteristics. We also analyse a real case study, discovering interesting students’ behaviors from a moodle database.

This paper describes the ADO.NET Entity Framework, a platform for programming against data that raises the level of abstraction from the logical (relational) level to the conceptual (entity) level, and thereby significantly reduces the impedance mismatch for applications and data services such as reporting, analysis, and replication. The conceptual data model is made real by a runtime that implements an extended relational model (the Entity Data Model aka the EDM), that embraces entities and relationships as first class concepts; a query language for the EDM; a comprehensive mapping engine that translates from the conceptual to the logical (relational) level, and a set of model-driven tools that help create entity-object, object-xml, and entity-xml transformers.

Object-Oriented Technology is an important discipline in the field of software engineering in general and it is, therefore, natural to ask whether it is relevant to the field of database management in particular and what that relevance is. There is, however, no consensus on answer to these questions. Some authorities believe that object oriented database systems will take over the world replacing relational system whereas others believe that they are suited only to certain very specific problems and will never capture more than a small fraction of the overall market. Object-Oriented technology represents real world very well, focusing on data rather than procedure and gives more security to data. Also, it is safe from unauthorized use of data because it provides three access specifiers viz. private, public and protected and strictly provides security to data in database. This technology also provides function as well as data together so that the data can be manipulated by the given function. In this paper, we show that how the data is more secure in object-oriented database than in relational database and also why do we migrate from RDBMS into OODBMS.

A pattern for information system implementation is proposed. The pattern is based on the commonly accepted object-oriented methodologies of design and development oriented toward widely used imperative programming languages. At the same time, this pattern makes it possible to fully use the power of declarative possibilities of the DBMS query language. The presented estimations demonstrate much higher performance of the applications obtained compared to those created by means of commonly accepted techniques.

Object-oriented software development as well as relational data storage are leading standards in their respective areas. The persistent storage of objects in relational tables is therefore a topic of major interest. To do so efficiently, a plethora of problems has to be overcome due to the impedance mismatch between the object-oriented and relational paradigms. Nowadays, dedicated object-relational middlewares are frequently used to decouple relational databases from object-oriented applications. Even if this approach shields the developer from the majority of run-time related aspects, the manual mapping of incrementally evolving complex object models to relational tables still remains as an inherently difficult and error-prone task. Therefore, this article focuses on automation support for the model driven generation and testing of object-relational mappings.

There is much current interest in publishing and viewing databases as XML documents. The general benefits of this approach follow from the popularity of XML and the tool set available for visualizing and processing information encoded in this universal standard. In this paper, we explore the additional and unique benefits achieved by this approach on temporal database applications. We show that XML with XQuery can provide surprisingly effective solutions to the problem of supporting historical queries on past content of database relations and their evolution. Indeed, using XML, the histories of database relations can be naturally represented by temporally grouped data models. Thus, we identify mappings from relations to XML that are most conducive to modeling and querying database histories, and show that temporal queries that would be difficult to express in SQL can be easily expressed in standard XQuery. This approach is very general, insofar as it can be used to store the version history of arbitrary documents and, for relational databases, it also supports queries on the evolution of their schema. Then, we turn to the problem of supporting efficiently the storage and the querying of relational table histories. We present an experimental study of the pros and cons of using native XML databases, versus using traditional databases, where the XML-represented histories are supported as views on the historical tables.

We present a novel approach to implement a graph transformation engine based on standard relational database management systems (RDBMSs). The essence of the approach is to create database views for each rules and to handle pattern matching by inner join operations while negative application conditions by left outer join operations. Furthermore, the model manipulation prescribed by the application of a graph transformation rule is also implemented using elementary data manipulation statements (such as insert, delete, update).

The relationship between XML and database management systems has become an important topic for coverage at the undergraduate level. This paper presents an approach to teaching the use of XML through the study of data exchange. After a brief review of XML, the paper provides a tutorial on the different features that are provided in major relational database products for the import and export of XML, providing a discussion of how these features can be used as implementation exercises for students. In addition to addressing the use of XML for data exchange in relational systems, the paper also provides an overview of several teaching tools that are also used in the study of XML for object-oriented data and also for the exchange of object-oriented and object-relational data.

Database is a collection of tables of data items, if the database is organized according to relational model it is called relational database. In a relational database, a logical and efficient design is just as critical. A poorly designed database may provide erroneous information, or may even fail to work properly may be difficult to use. Most of these problems are the result of two bad design features called redundant data and anomalies. Database normalization is the process of designing a database satisfying a set of integrity constraints, efficiently and in order to avoid inconsistencies when manipulating the database. Most of the research work has been devoted to functional dependencies. There are several algorithms have been developed in the past year like TANE, FD_Mine FD_Discover, Dep-Miner, FUN, FD Analysis using Rough sets, FD discovery by Bayes Net. In This paper we present a comparative study over Dep-Miner and FUN. We compare the working process of Dep-Miner and FUN using a simple example.

As applications are becoming increasingly dynamic, the notion that a schema can be created in advance for an application and remain relatively stable is becoming increasingly unrealistic. This has pushed application developers away from traditional relational database systems and away from the SQL interface, despite their many well-established benefits. Instead, developers often prefer self-describing data models such as JSON, and NoSQL systems designed specifically for their relaxed semantics. In this paper, we discuss the design of a system that enables developers to continue to represent their data using self-describing formats without moving away from SQL and traditional relational database systems. Our system stores arbitrary documents of key-value pairs inside physical and virtual columns of a traditional relational database system, and adds a layer above the database system that automatically provides a dynamic relational view to the user against which fully standard SQL queries can be issued. We demonstrate that our design can achieve an order of magnitude improvement in performance over alternative solutions, including existing relational database JSON extensions, MongoDB, and shredding systems that store flattened key-value data inside a relational database.

There has been recent interest in using relational database systems to store and query XML documents. Each of the techniques proposed in this context works by (a) creating tables for the purpose of storing XML documents (also called relational schema generation ), (b) storing XML documents by shredding them into rows in the created tables, and (c) converting queries over XML documents into SQL queries over the created tables. Since relational schema generation is a physical database design issue -- dependent on factors such as the nature of the data, the query workload and availability of schemas -- there have been many techniques proposed for this purpose. Currently, each relational schema generation technique requires its own query processor to efficiently convert queries over XML documents into SQL queries over the created tables. In this paper, we present an efficient technique whereby the same query-processor can be used for all such relational schema generation techniques. This greatly simplifies the task of relational schema generation by eliminating the need to write a special-purpose query processor for each new solution to the problem. In addition, our proposed technique enables users to query seamlessly across relational data and XML documents. This provides users with unified access to both relational and XML data without them having to deal with separate databases.

Database management systems have been widely used for storing and retrieving data. However, databases are hard to use since their interface is rigid in cooperating with users. Large number of e-governance applications like weather forecasting, agriculture, banking, railways etc. use database. For the people who are comfortable with Hindi language require these applications to accept a Hindi sentence as a query, process it and after execution provide result to the user in Hindi language. In this paper, we discuss the architecture of system to convert a Hindi sentence into equivalent SQL query. To make data retrieval easy for common person, in the developed system, the user can input query in Hindi language and get the result in same language. The users have no need to learn any formal query language like SQL to access the database.

Several negative results are proved about the ability to type-check queries in the only existing proposed standard for object-oriented databases. The first of these negative results is that it is not possible to type-check OQL queries in the type system underlying the ODMG object model and its definition language ODL. The second negative result is that OQL queries cannot be type-checked in the type system of the Java binding of the ODMG standard either. A solution proposed in this paper is to extend the ODMG object model with explicit support for parametric polymorphism (universal type quantification). These results show that Java cannot be a viable database programming language unless extended with parametric polymorphism. This is why type-checking OQL queries presents no problem for the type system of the C++ binding of the ODMG standard. However, a type system that is strictly more powerful than any of the type systems of the ODMG standard is required in order to properly type ordered collectgions and indices. The required form of polymorphism is bounded type quantification (constrained genericity) and even F-bounded polymorphism. A further result is that neither static nor the standard dynamic object-oriented type-checking is possible for Java OQL, in spite of the fact that Java OQL combines features of two strongly and mostly statically-typed languages. Contrary to one of the promises of object-oriented database technology, this result shows that the impedance mismatch does not disappear in the ODMG standard. A type-safe reflective technique is proposed for overcoming this mismatch.

Deductive databases intellectualize relational databases by providing complex inference ability and they are competitive with current commercial relational databases. The deductive system presented in this paper is a unified logic/database system where programs may be expressed declaratively, in a form close to first-order logic, and at the same time efficiently access very large data bases. The implementation is based on a logic-based language compilation. A Prolog-like program is translated into Warren Abstract Machine (WAM) instructions by a compiler, and the resulting WAM code is executed by an emulator. The inference engine and the relational database are tightly coupled, i.e. external records are retrieved from the underlying database and unified with Prolog-like terms as and when required. The tight coupling of a logic-based language and a relational DBMS achieved a satisfactory performance.

Very often the need is felt to store information extracted from the web, from databases or from documents and converted to XML (eXtensible Markup Language) in a database, in most cases, in a relational one, in order to be able to query this database for further operational or strategic decision-making. Unfortunately the XML files do not always have the same structure, and their elements (tags) do not always have the same name. In many companies, a correspondence (mapping) between elements of the XML files and the columns of the tables in the target database is still established manually. In this paper we present a system which loads the data contained in XML files into several tables of a relational database. The system supplies the user with mappings which are based on similarities with mappings already performed by the user in the past. User intervention is therefore required less frequently over time, resulting in full automation of the process of loading data into the target database.

Object-Relational DBMSs have been receiving a great deal of attention from industry analysts and press as the next generation of database management systems. The motivation for a next generation DBMS is driven by the reality of shortened business cycles. This dynamic environment demands fast, cost-effective, time-to-market of new or modified business processes, services, and products. To support this important business need, the next generation DBMS must: 1. leverage the large investments made in existing relational technology, both in data and skill set; 2. Take advantage of the flexibility, productivity, and performance benefits of OO modeling; and 3. Integrate robust DBMS services for production quality systems. The objective of this article is to provide a brief overview of UniSQL's commercial object-relational database management system.

Today, thanks to more powerful machines and more robust data models, relational databases have gained broad industry acceptance. As relational databases grow in power and popularity, developers face pressure to convert legacy databases to this newer model. The author proposes a technique for doing so efficiently. The approach involves a bridge program that adds a relational software layer atop the nonrelational database management system. The interface translates the relational database management language into the nonrelational database management language to access the existing nonrelational database.

Summary: Downloading the information stored in relational databases into XML and other flat formats is a common task in bioinformatics. This periodical dumping of information requires considerable CPU time, disk and memory resources. YAdumper has been developed as a purpose-specific tool to deal with the integral structured information download of relational databases. YAdumper is a Java application that organizes database extraction following an XML template based on an external Document Type Declaration. Compared with other non-native alternatives, YAdumper substantially reduces memory requirements and considerably improves writing performance. Availability: YAdumper is freely available.

A knowledge-based system, called the Knowledge Extraction System (KES), is presented which performs the process of reverse engineering of relational databases. KES generates an extended entity-relationship (EER) model from a relational database. Within its extraction procedure, domain semantics are obtained by analyzing the data schema and data instances of an existing database, by using heuristics, or asking the user. Relations and attributes are classified into several categories and then converted into the corresponding modelling structures of the EER model. KES demonstrates how knowledge-based system technology can be applied to ease the work of database reverse engineering. It also illustrates that the reverse engineering process can be implemented at a high level of automation. To do so, KES is integrated with the target database management system so that data can be analyzed directly through dynamic SQL queries.

This paper describes the design and implementation of an OODBMS, namely the METU Object-Oriented DBMS (MOOD). MOOD [Dog 94b] is developed on the Exodus Storage Manager (ESM) [ESM 92] and therefore some of the kernel functions like storage management, concurrency control, backup and recovery of data were readily available through ESM. In addition ESM has a client-server architecture and each MOOD process is a client application in ESM. The kernel functions provided by MOOD are the optimization and interpretation of SQL statements, dynamic linking of functions, and catalog management. SQL statements are interpreted whereas functions (which have been previously compiled with C++) within SQL statements are dynamically linked and executed. A query optimizer is implemented by using the Volcano Query Optimizer Generator. A graphical user interface, namely Mood-View [Arp 93a, Arp 93b], is developed using Motif. MoodView displays both the schema information and the query results graphically. Additionally it is possible to update the database schema and to traverse the references in query results graphically.The system is coded in GNU C++ on Sun Sparc 2 workstations. MOOD has a SQL-like object-oriented query language, namely MOODSQL [Ozk 93b, Dog 94c]. MOOD type system is derived from C++, thus eliminating the impedance mismatch between MOOD and C++. The users can also access the MOOD Kernel from their application programs written in C++. For this purpose MOOD Kernel defines a class named UserRequest that contains a method for the execution of MOODSQL statements. The MOOD source code is available both for anonymous ftp users from ftp.cs.wisc.edu and for the WWW users from the site http://www.srdc.metu.edu.tr along with its related documents.In MOOD, each object is given a unique Object Identifier (OID) at object creation time by the ESM which is the disk start address of the object returned by the ESM. Object encapsulation is considered in two parts, method encapsulation and attribute encapsulation. These encapsulation properties are similar to the public and private declarations of C++.Methods can be defined in C++ by users to manipulate user defined classes and after compilation, they are dynamically linked and executed during the interpretation of SQL statements. This late binding facility is essential since database environments enforce run-time modification of schema and objects. With our approach, the interpretation of functions are avoided thus increasing the efficiency of the system. Dynamic linking primitives are implemented by the use of the shared object facility of SunOS [Sun 90]. Overloading is realized by making use of the signature concept of C++.