Data processing: database and file management or data structures – Database design – Data structure types
Reexamination Certificate
1999-11-01
2003-05-27
Robinson, Greta (Department: 2177)
Data processing: database and file management or data structures
Database design
Data structure types
C717S152000
Reexamination Certificate
active
06571232
ABSTRACT:
FIELD OF THE INVENTION
The present invention relates, in general, to databases and methods for accessing such databases with query objects, and, in particular, to apparatus and methods for interactively examining database information, including database schema information, for the construction of query objects.
BACKGROUND OF THE INVENTION
Databases represent an important data processing area in many applications. They are often used to store large amounts of information and then efficiently retrieve selected portions of the information. Many present day systems use a client/server database approach in which application programs running in clients access a central database management system (DBMS) located in a database server. In order to efficiently access the information in the database, the clients form queries which request information with selected characteristics. The queries are transmitted to the DBMS server which retrieves the desired information which meets the characteristics specified in the query. The results (commonly called a “result set”) are returned to the client.
Presently, such database environments are predominantly based on a “two-tiered” model consisting of a top tier containing one or more applications which generate queries that access the DBMS server in a bottom tier. The two-tiered model suffers from several drawbacks. First, the queries must be formulated in a specific query language, which is accepted by the DBMS server. While standard query languages exist, such as the Structured Query Language (SQL), specific DBMS query languages are often non-standard as a result of proprietary extensions made to the basic SQL query language. As a result, application programs written to generate queries in a particular query language are often not portable between different DBMS servers.
In addition, in order to generate the queries in the first place, each application developer, and, in some cases, the ultimate user, must understand the mechanics of the database, including the relationship of the files and tables therein and any relationships in the data required by the database organization. These relationships are commonly referred to as “business logic” since the relationships are typically based on shared business processes, practices and policies. Therefore, many parties must learn the business logic in order to generate meaningful queries.
Further, commonly-performed routines are typically replicated in each application program even if the application programs operate within the same business environment because each application functions autonomously from other applications. This replication results in poor code re-use and maintenance problems if the replicated routines must be changed.
Consequently, there is a trend towards using a three-tiered model for database environments. Generally, the top tier in such a model consists of clients containing the application programs and the user interfaces, the middle tier consists of code that embodies the business logic and the bottom tier consists of the DBMS servers which contain the data. In this model, the applications are implemented as “thin” clients, all of which interface with the business logic by means, of a common interface which does not involve knowledge of the business logic. The commonly-performed routines are all consolidated into the middle tier as part of the business logic. Since the business logic is shareable between the clients, code replication is avoided. The Common Object Request Broker Architecture (CORBA) presents one object-oriented approach to forming a three-tiered database environment, such as described in R. Orfali et al., “The Essential Client/Server Survival Guide,” pp. 375-458, John Wiley & Sons, Inc. (2d ed. 1996), the disclosure of which is incorporated herein by reference.
Several prior art methods of implementing the three-tiered model exist, however, most existing DBMS access mechanisms arid tools, including fourth generation languages (4GLs) and application programming interfaces (APIs), have been designed for the two-tiered model and are ill-suited for use in the three-tiered model. Consequently, several prior art designs including “database” objects and “active data” objects have their own strengths and drawbacks. One promising prior art approach to constructing a middle tier containing business logic uses “query objects.” Each query object is a server object that:
(1) translates client method invocations into equivalent queries in a query language which is understood by a database;
(2) issues those queries to the database; and
(3) returns the results as strongly-typed data values.
The query object effectively encapsulates the DBMS specific query language so that the application programs do not have to know or use the DBMS query language. Query objects also encapsulate the database organization or “schema”, so that query object clients are isolated from database changes (although the query object itself may have to be changed if the underlying database must be changed.) Query objects also present their clients with a DBMS independent API, for example, CORBA defines an Interface Definition Language (IDL) interface. They do not require that the data be mapped into objects as is the case with active data objects so that significant performance advantages can be obtained and concurrency issues avoided.
Each query object provides as part of its interface one or more parameterized methods and calls on each method are translated by the query object into one or more standard queries such as SELECT, UPDATE, INSERT and DELETE, or into initiation of one or more stored procedures in the database. In order to use the query object, a client first establishes a connection to the query object via some mechanism, such as the CORBA naming service. One of the query object's methods is then invoked and the query object then executes the query.
However, in order to operate properly, the query object must be constructed to generate the correct DBMS queries in response to client requests. Otherwise, the query object may operate as designed, but produce results which are not intended. Constructing a query object to generate the correct queries requires a knowledge of SQL, an understanding of the underlying database schema, the possible handling of intermediate results generated by the query and interpretation of the results. In addition, a query object developer must consider other issues such as connection to the database using CORBA or similar arrangement, concurrency problems and translation required between the interface used by the query object and the API used by the database. Consequently, tools have been developed to automate the generation of query objects. Some tools can generate a query object from a query described in conventional SQL language which is entered, by a user.
However, even with such tools, it may be necessary to understand the schema of the underlying database in order to correctly construct the initial SQL query and map the SQL query into the query language used by the underlying database. Since the database schema is related to the business logic, it is therefore, necessary to understand the business logic at some level. At the very least, the query object developer must obtain the names of tables and stored procedures in the database and their descriptions, including column names and types for tables and input and output parameters for stored procedures. For a particular query, it is also necessary to obtain a description of the result set produced by the query, including numbers and types of result expressions as well as possible bounds on the result set.
Further, the underlying database may use vendor specific data types which do not directly match the standard data types used in SQL expressions. Consequently, it may be necessary to first translate the data types before the query can be used. While these translations are well-known, they can be time-consuming details which distract the user from other, more important work.
Therefore, there is a need to easily
Goldberg Robert N.
Lam Gloria Y.
White Seth J.
Kudirka & Jobse LLP
Le Debbie M.
Robinson Greta
Sun Microsystems Inc.
LandOfFree
System and method for browsing database schema information does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with System and method for browsing database schema information, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and System and method for browsing database schema information will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3080185