CA2281331A1

CA2281331A1 - Database management system

Info

Publication number: CA2281331A1
Application number: CA002281331A
Authority: CA
Inventors: Glenn D. Rasmussen; Henk Cazemier; Liviu Ignat
Original assignee: Cognos Inc
Current assignee: Cognos Inc
Priority date: 1999-09-03
Filing date: 1999-09-03
Publication date: 2001-03-03
Also published as: US6609123B1; EP1081609A3; US6662188B1; EP1081609A2

Abstract

A database management system has a metadata model and metadata transformations.
The metadata transformations transform metadata from a lower level to a higher level in the metadata model to complete the metadata model. The metadata transformations perform the transformations by adding business intelligence. The database managing system also has a query engine. The query engine takes the metadata model and the user's request for information, and turning it into a query that can be executed against a relational database or data source based on the business intelligence in the metadata model.

Description

DATABASE MANAGEMENT SYSTEM
FIELD OF THE INVENTION
The present invention relates generally to a database management system, and more particularly to a database management system for use with a plurality of relational databases.
BACKGROUND OF THE INVENTION
Data is any information, represented in binary, that a computer receives, processes, or outputs. A database is a shared pool of interrelated data. Information systems are used to store, manipulate and retrieve data from databases.
It is known to use file processing techniques to design information systems for storing and retrieving data. File processing systems usually consist of a set of files and a collection of application programs. Permanent records are stored in the files, and application programs are used to update and query the files. Such application programs are generally developed individually to meet the needs of different groups of users. Information systems using file processing techniques have a number of disadvantages. Data is often duplicated among the files of different users. The lack of coordination between files belonging to different users often leads to a lack of data consistency. Changes to the underlying data requirements usually necessitate major changes to existing application programs. There is a lack of data sharing, reduced programming productivity, and increased program maintenance.
File processing techniques, due to their inherent difficulties and lack of flexibility, have lost a great deal of their popularity and are being replaced by database management systems (DBMS).
A DBMS is a software system for managing databases by allowing for the definition, construction, and manipulation of a database. A DBMS provides data independence, i.e., user requests are made at a logical level without any need for knowledge as to how the data is stored in actual files. Data independence implies that the internal file structure could be

2 modified without any change to the users's perception of the database. To achieve data independence, a DBMS will often use three levels of database abstraction.
With respect to the three levels of database abstraction, reference is made to Figure 1.
The lowest level in the database abstraction is the "internal level" or "physical layer" 1. In the physical layer 1, the database is viewed as a collection of files organized according to one of several possible internal data organizations.
The middle level in the database abstraction is the "conceptual level" or "business layer" 2. In the business layer 2, the database is viewed at an abstract level. The user of the business layers 2 thus shielded from the internal storage details of the physical layer 1.
The highest level in the database abstraction is the "external level" or "presentation layer" 3. In the presentation layer 3, each group of users has their own perception or view of the database. Each view is derived from the business layer 2 and is designed to meet the needs of a particular group of users. To ensure privacy and security, a group of users only has access to the data specified by its particular view.
The mapping between the three levels of database abstraction is the task of the DBMS. When changes to the physical layer (e.g., a change in file organization) do not affect the business and presentation layers, the DBMS is said to provide for physical data independence. When changes to the business layer do not affect the presentation layer, the DBMS is said to provide for logical data independence.
A data model is an integrated set of tools used to describe the data and its structure, data relationships, and data constraints. Some data models provide a set of operators that is used to update and query the database. Data models may be classified as either record based models or object based models. Both types of models are used to describe databases at the business layer and presentation layer. The three main record based models are the relational model, the network model and the hierarchical model.

3 In the relational model, data at the business level is represented as a collection of interrelated tables. The tables are normalized so as to minimize data redundancy and update anomalies. Data relationships are implicit and are derived by matching columns in tables.
The relational model is a logical data structure based on a set of tables having common keys that allows the relationships between data items to be defined without considering the physical database organization.
In the relational model, data is represented as a collection of relations. To a large extent, each relation can be thought of as a table. Each row in a relation is referred to as a tuple. A column name is called an attribute name. The data type of each attribute name is known as its domain. A relation scheme is a set of attribute names. A key is a set of attribute names whose composite value is distinct for all tuples. No proper subset of the key is allowed to have this property. A scheme may have several possible keys. Each possible key is known as a candidate key, and the one selected to act as the relation's key is referred to as the primary key. A superkey is a key with the exception that there is no requirement for minimality. In a relation, an attribute name (or a set of attribute names) is referred to as a foreign key, if it is the primary key of another relation. Because of updates to the database, the content of a relation is dynamic. For this reason, the data in a relation at a given time instant is called an instance of the relation.
A data model may describe data as entities, attributes, and relationships. An entity is an "object" in the real world with an independent existence. Each entity has a set of properties, called attributes, that describe the entity. A relationship is an association between entities. For example, a professor entity may be described by its name, age, and salary and can be associated with a department entity by the relationship "works for".
Business intelligence tools provide data warehousing, business decision making and data analyses support services. Business intelligence tools may have their own different ways of extracting and interpreting the metadata from the various data sources.
Thus, the user is unable to use these tools in combination in order to increase productivity.
Furthermore, the user will be unable to avoid the details of data storage in the data source.

4 Thus, there is a need for a DBMS that enables different business intelligence tools to extract and interpret the metadata from various data sources in the same way.
SUMMARY OF THE INVENTION
The present invention is directed to a database management system which has a metadata model and metadata transformations. The metadata transformations transform metadata from a lower level to a higher level in the metadata model to complete the metadata model. The metadata transformations perform the transformations by adding business intelligence.
The database managing system also has a query engine. The query engine takes the metadata model and the user's request for information, and turning it into a query that can be executed against a relational database or data source.
According to one aspect of the present invention, there is provided a database management system for managing a database, the database management system comprising:
a metadata model having a physical layer for receiving source data from the database, and a business layer for containing metadata which has business intelligence;
and transformations for transforming the source data received in the physical layer into the metadata in the business layer by adding the business intelligence to the source data.
According to another aspect of the present invention, there is provided a database management system for managing a database, the database management system comprising:
a metadata model having a physical layer for receiving source data from the database, and a business layer for containing metadata which has business intelligence;
and transformations for transforming the source data received in the physical layer into the metadata in the business layer by adding the business intelligence to the source data.
According to another aspect of the present invention, there is provided a method for generating a metadata model of a database, the method comprising the steps of obtaining source data from the database; and generating a metadata model by adding business intelligence to the source data.
According to another aspect of the present invention, there is provided a method for creating a report of a database, the method comprising the steps of obtaining source data from the database; generating a metadata model by adding the business intelligence to the source data; and creating a report based on a request for information using the business intelligence of the metadata model:
Other aspects and features of the present invention will become apparent to those ordinarily skilled in the art upon review of the following description of specific embodiments of the invention in conjunction with the accompanying figures.
BRIEF DESCRIPTION OF THE DRAWINGS
Embodiments of the invention will now be described with reference to the accompanying drawings, in which:
Figure 1 is a diagram showing a structure of metadata model;
Figure 2 is a diagram showing a database management system in accordance with an embodiment of the present invention;
Figure 3 is a diagram showing an example of a query engine shown in Figure 2;
Figure 4 is a diagram showing an example of functions of the query engine;
Figure 4A is a diagram showing an example of functions of the transformations shown in Figure 2;
Figure 5 is a diagram showing concept of the transformations;
Figure 6 is a diagram showing relationship of entities;
Figure 7 is a chart showing flags used in the metadata model;
Figure 8 is a diagram showing source and targe of an example of the transformations;
Figure 9 is a diagram showing an example of a physical model;
Figure 10 is a table representing the data structure of the model of Figure 9;
Figure 11 is a table showing results of a step of an example of the transformations;

Figure 12 is a table showing results of a step of the transformation;
Figure 13 is a part of the table of Figure 12;
Figure 14 is a part of the table of Figure 12;
Figure 15 is a table showing results of a step of the transformation;
Figure 16 is a diagram showing source and targe of an example of the transformations;
Figure 17 is a diagram showing source and targe of an example of the transformations;
Figure 18 is a diagram showing source and targe of an example of the transformations;
Figure 19 is a diagram showing source and targe of an example of the transformations;
Figure 20 is a diagram showing source and targe of an example of the transformations;
Figure 21 is a diagram showing source and targe of an example of the transformations;
Figure 22 is a diagram showing an example of the transformations;
Figure 23 is a diagram showing an example of the transformations;
Figure 24 is a diagram showing an example of the transformations;
Figure 25 is a diagram showing relations of objects;
Figure 26 is a diagram showing source and targe of an example of the transformations;
Figure 27 is a diagram showing relations of objects;
Figure 28 is a diagram showing source of an example of the transformations;
Figure 29 is a diagram showing targe of an example of the transformations;
Figure 30 is a diagram showing source and targe of an example of the transformations;
Figure 31 is a diagram showing source of an example of the transformations;
Figure 32 is a diagram showing targe of an example of the transformations;
Figure 33 is a diagram showing a step of an example of the transformations;
Figure 34 is a diagram showing a step of the transformation;

Figure 35 is a diagram showing a step of the transformation;
Figure 36 is a diagram showing a step of the transformation;
Figure 37 is a diagram showing a step of the transformation;
Figure 38 is a diagram showing a step of the transformation;
Figure 39 is a diagram showing an example of the transformations;
Figure 40 is a diagram showing source and targe of an example of the transformations;
Figure 41 is a diagram showing an example of the business model;
Figure 42 is a diagram showing an example of the physical model;
Figure 43 is a diagram showing an example of the business model;
Figure 44 is a diagram showing an example of the physical model;
Figure 45 is a diagram showing an example of the physical model;
Figure 46 is a diagram showing an example of relationship of objects;
Figure 47 is a diagram showing an example of relationship of objects; and Figure 48 is a diagram showing an example of relationship of objects.
DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION
Figure 2 illustrates a DBMS 4 for enabling different business intelligence tools to extract and interpret the metadata from various data sources in the same way.
The DBMS 4 includes common object services (COS) 5, a metadata exchange 10, a metadata model 15, transformations 20, a user interface 25 and a query engine 30. The fundamental objective of the DBMS 4 is to provide a rich model that allows the query engine to do the best job it is capable of doing to generate queries.
COS 5 is used as the foundation that defines the framework for object persistence.
The double head arrow from COS 5 in Figure 2 represents that COS 5 communicates with all other elements shown in Figure 2. COS 5 performs functions such as creating new objects, storing them on disk, deleting them, copying them, moving them, handling change isolation (check-in, check-out), object modelling (using CML that generates the C++
code).

The metadata exchange 10 is used to obtain and provide metadata from and to external metadata repositories, which may be third party repositories. The metadata exchange allows for the building of models from external metadata sources.
The metadata model 15 is a collection of CML files. These are compiled into C++
code which is then compiled. The metadata model 15 defines the objects that are needed to define the applications that users build.
Transformations 20 are used to complete the metadata model 15. When a database is 10 introduced, raw metadata is imported from the database. Other metadata may be also imported from one or more metadata repositories. If such metadata does not have good mapping to the metadata model 15, then the transformations 20 can be used to provide the missing pieces. Metadata may imported from a database that would build only a small number of the objects that would actually be needed to execute queries.
The user interface 25 sits on top of the metadata model 15 as a basic maintenance facility. The user interface 25 provides the ability to browse through the metadata model 15 and manipulate the objects defined thereby. The user interface 25 is also a point of control for metadata interchange, for writing transformations, handling check-in check-out and similar operations. The user interface 25 allows for the performance of basic maintenance tasks on the objects in the metadata model 15, e.g., change a name, descriptive text, data type.
The user interface 25 is a mechanism that involves the capabilities of the metadata exchange 10 and the transformations 20. The user interface 25 has the ability to diagram the metadata model 15, so that the user can see how objects are related.
The query engine 30 is responsible for taking the metadata model 15 and the user's request for information, and turning it into a query that can be executed against a relational database or data source. The query engine 30 is basically the reason for the existence of the rest of the blocks. The objective of the query engine 30 is to function as efficiently as possible and preserves the semantics of the original question. A user may ask a question that is not precise. The request be for something from "customers" and something from "products". But these may be related in multiple ways. The Query Engine needs to figure out which relationship is used to relate "customers" and "products".
With reference to Figure 3, an initial specification 35 or request for information is received from a user. Using the information that is in the metadata model 15, the query engine 30 makes the specification unambiguous and builds a sequel query for it so that the correct data 40 may be obtained.
Figure 4 illustrates the process of Figure 3 from the perspective of the query engine 30. At step 45, a request is received. At step 50, in the refiner process or refining stage, an ambiguous question is turned into a semantically precise unambiguous question.
At step 55, a precise request is formulated. Step 60 is the planner stage. At step 65, a sequel query is generated. Step 70 is the UDA stage. At step 75, data is obtained. The following is an example. There are a number of Branches. Each Branch has an ID and a Manager.
There are 1 S a number of Employees. Each Employee has an ID, a Name and a Branch Code.
There are two relationships between Branches and Employees. First, there is the relationship from ID
of Branch to Branch Code of Employee. Second, there is the relationship from Manager of Branch to ID of Employee. The following request is received: "Employee Name;
Branch Name". The request is ambiguous because it could mean "show me all employees that work in a branch" or "show me all branch managers". The refiner interacts with the user to build the correct query. If the information "Branch ID = Employee Branch Code" is received, then it is defined that this is the relationship to be used in the query, and the query is precise. The user may be prompted for this information, i.e. a dialogue. Alternatively, the first option may simply be taken.
Common Object Services 5 COS 5 will now be described in further detail. COS S is not part of the metadata model.
Rather, it provides a secure layer around the metadata storage. No actions on the objects in the metadata model can be performed without the involvement of COS 5. COS 5 communicates with the database directly.

The metadata storage can be accessed by many user at the same time. Each user may change objects or their properties, causing subsequent changes to the metadata model.
Most of the objects in the metadata model are part of different kinds of relationships, and changes may cause inconsistency in the metadata model.

5 COS 5 provides the means of preserving the physical integrity of the metadata model. COS
5, provides access to the objects within the repository; performs validation checks, insuring precision object storage; provides user security checks; oversees the changes to the objects;
and participates in the creating of new object and deleting of old ones.
COS 5 provides each new object with a base ID. The base ID guarantees that the object can be found in the metadata model. The base ID is unique and stable for each object, i.e., it never changes.
COS 5 also facilitates communication between the query engine 30 and the metadata storage.
The most important objects in COS 5 are, the gateway; the gateway broker; the gateway factory; and the transaction.
The gateway object is responsible for providing secure access to the objects in the metadata model. The gateway may be viewed as an intersection of the user and the repository.
Multiple users can work with the same repository at the same time. Each such user will have one separate gateway to this particular repository. A single user can work at the same time with multiple repositories and have a separate gateway object for each repository.
The gateway factory is a globally available single object responsible for creating and registering new repositories.
The gateway broker is a globally available single object responsible for opening existing repositories, enumerating the registered repositories, associating repository names with path/locations.

The transaction isolates the changes the user makes to the objects of the metadata model.
Thus, two or more users cannot make changes to the same repository objects simultaneously.
There are two types of transactions, namely, read-only and read-write. A read-only transaction provides a read-only access to the objects that make up the user transaction and does not restrict other users from access to these objects. A read-write transaction provides the user of that transaction with the ability to change objects that make up this user transaction. However, it locks these objects for other users, i.e., everybody else is only able to view these objects.
A transaction is made up of all the objects which have been changed, deleted, created or explicitly checked out by the current user.
A transaction may last days. Within that time, objects can be checked out or checked in back to the repository with the changes either saved or completely dismissed.
When the transaction is over, all the objects that were still within the transaction at the moment it went out of scope are checked in back to the repository. If no errors or exceptions occur at this moment, the changes are made permanent. Otherwise, all the changes to these objects are dismissed, and the changes will remain in their original state.
Transactions provide the means for the user to keep or not to keep the changes made to the objects while within the transaction while applying commit or roll back methods.
The gateway works in collaboration with the transaction, because such things as adding, changing and deleting or accessing objects can only be done within a transaction object.
Check in and check out are methods applicable to any repository object. The check out method places the object within the user transaction, where the changes to this object can be made. From this moment until the check in method will be applied to this object, the object will be in the locked state. That means that all other users will only be able to view this object in the way it was at the moment of being checked out. Any attempt by one user to change, delete or check out an object already in the locked state due to another user action will fail.
When the user makes changes to the object within the user transaction, the changes are not visible to all other users immediately. All the changes are performed in the series of atomic consistent isolated durable (ACID) database transactions. The object itself is aware of the fact that it is being changed, and who is making the changes. Until the user makes a decision to make the changes permanent and applies a check in method to the object in order to save these changes, the object is carrying around to data block. One of them contains information in the original object status (at the check out moment) and another contains the changed object status. Once the object is checked in, these changes become permanent.
The object in its brand new state becomes visible and available for further possible actions to all other users.
The check out - check in unit has only two possible outcomes. First, all the changes are successful and made permanently to the object in the repository (commit). This means that data block that kept information about the originals object ? is discarded.
Second, if anything goes wrong, all the changes are wiped out completely and objects remain in their original state. This means that the data block that kept the information about the changes object is discarded.
The object in the repository that is not within the user transaction, i.e., it is not being changed in any way by any user and has not been checked out, is in the normal state.
The new objects are only created within the user transaction, and they are visible only to that particular user, until certain described above methods make the new objects visible and/or available to other users.

The objects are deleted only within the user transaction and will only become invisible to that particular user. The objects will not be deleted and will remain visible for others until certain described above methods will remove the deleted object from the repository permanently.
The changes to particular objects may indirectly affect other objects in the model due to the set of various relationships these objects participate in, and the metadata model's contain structure. The user can check the integrity of the metadata model at any time by calling explicitly the metadata check method.
Thus, COS 5 is responsible for object persistence, i.e., the ability to keep an object's state across invocations of an application. COS 5 performs house keeping and maintenance of objects as operations are performed, such as copy, paste, move, delete. COS 5 insures that these operations are executed in a consistent manner.
COS 5 includes a modelling language, which is used to describe the objects stored in the repository. The modelling language reduces the amount of coding that required to be done.
In the preferred embodiment, the modelling language produces C++ code, which becomes part of the product. COS S also provides transaction management and repository services.
Note that anything that a user would manipulate, such as an entity or an attribute, is represented as an object in the metadata model.
COS 5 uses a proxy which is a shadow entity object that points to the original object. Any modifications made to one object are transferred to the other. The proxy is in the modelling language which makes code like a key word. Thus, error-prone tedious work in writing code for each task may be reduced.
Metadata Model 15 The metadata model 15 is a tool to supply the common metadata administration tool, unified and centralized modelling environment, and application program interfaces for business intelligence tools. The architecture of the metadata model 1 S will now be described in further detail.
The metadata model is organized as a single containment tree which starts at the highest level with a model object. The model object itself is at the root of the tool, and all other objects, except the relationship objects, are contained within this root object.
The metadata model is composed of several layers, namely, the physical layer 1, the business layer 2 and the presentation layer 3, as shown in Figure 1.
The physical layer 1 is used to formulate and refine queries against the underlying database.
The physical layer 1 contains objects that directly describe actual physical data objects and their relationships. The objects in the physical layer 1 may include, among other things, databases, catalogues, tables, columns, keys, schemata, and joined paths.
The objects in the physical layer 1 are usually raw metadata, which is created as a result of importing from the database and the user provided data source. The information of the object, except for join relationships, is generally available from the underlying database.
Additional information such as joined specifications, may also be imported.
The user can customize some objects in the physical layer 1, such as joins, in order to create relationships between object that were imported from various data sources.
The business layer 2 is used to provide business abstractions with which the user can formulate queries against the underlying tables. The business layer 2 contains objects that can be used to define in abstract terms the user's business entities and their inter relationships. The objects in the business layer 2 represent a single business model, although they can be related to physical data in a number of different databases. The objects in the business layer 2 may include entities, attributes, keys, filters, prompts, elements and styles.
The objects in the business layer 2 are closely related to the object in the physical layer 1, i.e., tables, columns, physical keys. However, the relationship is not always a one-to-one relationship.

Entities in the business layer 2 are related to tables indirectly. While the tables stored data as it is governed by the database design, the entity holds the metadata representing the business concept. Entities are collections of attributes. Attributes of entities are expressions related to columns and tables: for example, the entity customer could have attributes customer name, 5 customer address, and the like. In the simplest case, all the attributes of an entity are related one-to-one to the columns of a single table.
In the business layer 2, entities are related to other entities by a joined relationships, containment or subtyping.
An attribute is usually directly related to a single column of the physical layer 1. However, an attribute may be expressed as a calculation based on other attributes, contents and columns, e.g., an attribute that will be a total amount of all the orders placed by customer within a month (i.e., a summary of data in other attributes).
Entities and attributes in the business layer 2 are given user friendly meaningful names. For example, the column named Cust & M from the Cust table in the physical layer 1 could be mapped to Customer Name attribute contained in the Customer Entity in the business layer 2.
Filters and Prompts are used to restrict queries. Elements and styles are used to associate presentation information with an attribute.
The ways of use of entity relationships in the metadata model 15 are different from those in conventional modelling tools. For example, in most ER modelling tools, the ER
concept is used to provide an abstraction for defining a physical database, i.e., it is a different "view" of the physical database. Within the metadata model 15, the business model is used to provide an abstraction for accessing a physical database.
The information of the object of the business model is not generally available in external repositories. If it is, it is usually associated with the physical model. One thing that would be available in external repositories is the business names for objects. Again these tend to be for the physical tables and columns, so can be used if they can be mapped to the appropriate business entity or attribute.
The presentation layer 3 is used to provide an organized view of the information in the business model. The information is organized in terms of business subject areas or by how it is used. The presentation layer 3 is an abstract layer, since there is no submodel part in the model called presentation. Rather, the presentation layer exists as an isolation of the process where a user can combine references to the objects available from the business layer into combination that are frequently used in the user's business. These user defined folders that contain these combinations are called presentation folders.
The object in the presentation layer 3 may include user folders or presentation folders, and vistas. Presentation folders contain references to objects in the business model layer, including entities, attributes, filters and prompts. Presentation folders are building blocks to package information for the end user. Designers can combine them in order to organize the objects into collections of most frequently used views, or in order to support various business intelligent tools using the DBMS of the present invention as a metadata provider.
The information of the object is not generally available in external repositories. The concept of organized business subject areas exists but it relates to collections of tables and columns, not to entities and attributes.
For all objects in the physical model layer 1 and the business model layer 2, business descriptive metadata may be also included. Business descriptive metadata is used to help understand the source and the meaning of the data which is being manipulated.
It is true data about the data". Lineage, accuracy, description, refresh, calculations.
Business descriptive metadata is used by end user and application designer to understand the source of the information. Business descriptive metadata includes such things as descriptions and stewards (the owner of the data). Business descriptive metadata also includes information that can be used to relate the objects to information in external repositories.

Business descriptive metadata exists in many forms in external repositories.
General purpose repositories and business information directories collect this information as that is their raison d'etre. Warehouse ETL tools collect this information as a result of collecting the ETL
specifications. The information may be duplicated (collected) from a variety of sources in the metadata model so that it is available directly to the user and user's metadata. The metadata model may also include context information which can be used to retrieve information form external repositories.
Transformations 20 The transformations 20 are performed to automatically construct portions of the common metadata model 15 based on the objects contained in another portion of the model.
Each transformation records information in the model about the changes made during execution. When a transformation is subsequently executed, this information is used to avoid repeating the same operations.
Refernng to Figure 4A, the basic functions of the transformations 20 are described.
As the metadata model 15 has the three layers as described above, the transformations 20 also has three kinds. That is, the transformations 20 include physical model transformations 112, business model transformations 114, presentation model transformations 116.
The transformations 20 transform metadata from the lower level 1 to the higher level 3.
A database 100 is a source of physical definitions of the database. When the database 100 is introduced to the DBMS 4, the physical definitions are extracted from the database 100 into the physical model layer 1 in the metadata model 15. The DBMS 4 may also import metadata from other sources using the metadata exchange 10. Thus, objects are built in the physical model layer 1 in the metadata model 15. These objects build a solid picture of what exists in the database 100.

However, these objects that are constructed in the physical model 1 are not complete. That is, it is not enough to form the business model layer 2. In order to complete the physical model, the physical model transformations 112 take the objects that exist in the physical model layer 1, and make changes to them to complete the physical model layer 1.
Then, the business model transformers 114 get the objects from the physical model layer 1 and build their corresponding objects in the business model layer 2. However, these objects are not complete to provide reports. In order to complete the business model, the business model transformations 114 take the objects that exist in the business model layer 2, and make changes to apply some intelligence to them.
The presentation model transformations 116 get the objects from the business model layer 2 and build their corresponding objects in the business model layer 3. Then, the presentation model transformations 116 take the objects that exist in the presentation model layer 3, and make changes to complete the presentation model layer 3. The objects in the presentation model layer 3 may then be used to build reports.
Thus, by the transformations 20, a physical database design is converted into a logical database design, i.e., the transformations 20 deduce what the logical intent of the model was.
The transformations 20 may also include multidimensional model transformations and general transformations as described below.
Transformation Architecture There are a number of issues when performing model transformations of this nature. Early in the model lifecycle, the model designer will likely choose to use most, if not all of the transformations to develop a standard model. As the model progresses through the lifecycle, however, the number of transformations used by the designer is likely to decrease as the model is customized to suit the particular needs of the application.

The model designer may also determine that a transformation is not applicable to a particular model. Applying this knowledge to selecting a subset of transformations to execute can reduce the amount of processing considerably.
In order to facilitate these demands, each transformation is coded as independently as possible. In the simplest of scenarios, the architecture could be thought of as a pipeline with a number of pumping stations en route. Instead of transporting oil or natural gas, the model flows through the pipeline. A pumping station represents a transformation step, as shown in Figure 5.
Pipes can be constructed to suit the requirements of the scenario. As new transformations are constructed they can be added to pipes as required. Obsolete steps are easily removed.
However, as development of the transformations has progressed, a number of relationships have been developed between the transformations. Data about the model that is constructed during the processing of some transformations sometimes can be used by later transformations. The "Blackboard" pattern matches the requirements. The pattern uses the term "Knowledge Source" as the actor that manipulates the objects on the blackboard. Each transformation would be a Knowledge Source. Figure 6 shows the pattern diagram.
The use of this pattern preserves the independence of the transformations as much as possible, yet recognizes that the transformations are linked together by the data stored on the blackboard. The controller is responsible for scheduling the execution of the knowledge sources.
Transformation Data Recorded in the Model As previously mentioned, each transform records information in the model to avoid repeating the same activity in subsequent executions. Every object class that can be modified by the transformations supports an additional interface to store the transformation information.
Each transform uses two flags to determine the processing flow for each object. The first flag is a prohibit flag. If the prohibit flag is set the transform will not modify the object during the execution of the transformation. The second flag is a processed flag. This flag records whether the transform has ever processed the object.
When one object leads to the creation of another, a new relationship is created between the 5 two objects. In addition to the source and target object identifiers, the relationship also has the set of status flags as discussed previously. These flags are used to control the execution of a transformation over the relationship. Figure 7 shows a chart describes, in general terms, the execution flow over a relationship. Consult the specific transformation in question for details.
10 All objects are organized in a tree. The physical layer 1 has tables. The tables have columns.
Joins exist between tables. The business layer 2 has a corresponding tree of objects. The tables in the physical layer 1 correspond to entities in the business layer 2.
The columns in the physical layer 1 correspond to attributes in the business layer 2. Joins exist between entities. Thus each object has a partner, i.e. a relationship exists between a table and an 15 entity. This provides the context for processing all the children of the table. For example, if a particular column has not been processed, the transformations process the column in the context of a parent relationship, i.e., build an attribute and put under the entity.
There are times when something is important in the physical model, but the user does not 20 want it represented in the business model. In this case, the prohibit flag is used, e.g., not to build a partner for it in the model, not to build an attribute for it.
Physical Model Transformations 112 The physical model transformations 112 include transformations for constructing physical joins, constructing physical keys, constructing table extracts, and constructing physical cubes.
Physical Join Construction Transformation This transformation constructs join relationships between physical tables based on the contents of their indexes. Preconditions for this transformation are that a physical model exists; and the model contains tables with indexes. The following shows the operation of this transformation:

I. For each table:
A. Construct TableInfo:
1. Get list of columns in table and sort by name.
2. For each index:
a) Construct IndexInfo (1) Record columns used in index, whether index is unique.
(2) Sort column list based on name.
3. Sort IndexInfo objects based on uniqueness of index, number of columns.
4. For each index:
a) If the columns of the index are not all contained within an IndexInfo object representing a unique index already associated with the TableInfo object:
(1) Add the IndexInfo object to the TableInfo object (2) Remove columns used in index from TableInfo column list.
II. For each acceptable TableInfo pair {T1, T2}:
A. If either T1 or T2 has not been processed by this transformation:
1. Compare unique indexes {I1 from Tl, I2 from T2} to determine best match.
2. If a match is found:
a) Build a join using the matching columns.
3. Else a) Compare unique indexes from one table with non-unique indexes from the other table {I1 from T1, I2 from T2} to determine the best match.
b) If a match is found:
( 1 ) Build a join using the matching columns.
c) Else ( 1 ) Compare unique indexes from one table with column list from the other table {Il from Tl, C from T2} to determine the best match.
(2) If a match is found:
(a) Build a join using the matching columns.
III. Mark each table as transformed.
The best match is defined primarily as the match with the largest number of matching columns. In case of ties, the match that uses the largest index wins. Columns match if their names are identical (case insensitive). In all cases, one set of columns are a subset of the other column set (as defined by the indexes, or tables).
The following table shows the status flag usage.

Physical Key Construction Transformation This transformation constructs physical keys for tables based on their unique indexes.
Preconditions for this transformation are such that a physical model exists, and the model contains tables with unique indexes.
The operation of this transformation is as follows:
I. For each acceptable table:
A. For each unique index:
B. If index has already been transformed:
Ubject Class Prohibit Processed . 1. Attempt to locate target key.

C. Else 1. Build key 2. Mark index as transformed 3. Add relationship between index and key.

D. If key built or found:

1. For each column in index:

a) If column doesn't exist in key:

( 1 ) Add column to key.

2. For each column in key:

a) If column doesn't exist in index ( 1 ) Remove column from key.

The following table shows the status flag usage.
Object Class Prohibit Processed Table Extract Construction Transformation -Part 1 This transformation constructs the metadata required to mark a table as an extract. Extracts typically contain pre-computed summary values. These extract tables can be used to return query results in less time than would be required if the query was executed against the base tables. This transformation is unusual since it requires additional information about the database that typically isn't available as database metadata. The requirement is to have the SQL statement that populates the tables. This transformation is also unusual because it does not stand alone. This transformation will be followed by Part 2 to be effective. The SQL

statements could be available in a number of forms, but will likely consist of a set of text files.
Figure 8 shows the source and target of the transformation. The preconditions for this transformation are as follows:
I. The model contains a set of Table objects that describe the physical tables in the database, including the aggregate tables.
II. The transformation step has access to a set of SQL statements that contain a query that populates a subset of the tables in the model.
The operation of the transformation is as follows:
I. For each SQL statement:
A. If a Federation query can be constructed from the SQL statement (i.e. the statement can be expressed as a Federation query and only references tables and columns that are known to the model) and the target tables and columns are known to the model:
1. Build the corresponding Federation query in terms of physical tables and columns.
2. Build an I TableExtract object that references the destination table and the newly constructed query.
This part of the transformation constructs Federation queries that reference physical model objects. Since there may be other transformations executed against the logical (E/R) model, there would be an additional amount of bookkeeping required to reflect these logical model manipulations in the constructed queries. Implementing the transformation as two distinct steps avoids the bookkeeping.
Table Extract Construction Transformation -Part 1 (Alternate) This is an alternative for the previous transformation. It may be possible to determine which tables contain aggregate data by analyzing the keys and columns of the tables, as well as the relationships those tables have with other tables.
5 As a source of the transformation, consider the physical model shown in Figure 9. The bold boxes represent tables that contain aggregated data.
In this example, the attributes of each table are given as follows (minimal set supplied, obviously more could exist, key attributes are bolded):
Brands Brand #
Cities Country #, Region #, State #, City #
Countries Country #
Customers Customer #
Customer Sites Customer #, Site #
Dim-Customers Customer #, Site #
Dim-Date Date, Day-of Month, Day-of Week, Holiday, Quarter #, Week #
Dim-Locations Country #, Region #, State #, City #, Warehouse #, Office #, Sales Region #
Dim-Products Brand.#, Line #, Item #, SKU #
Dim-Sales Reps Sales Rep #
Fact-Inventory Date, Country #, Region #, State #, City #, Warehouse #, Brand #, Line #, Item #, SKU #, Quantity on Hand Fact-Orders Customer #, Site #, Date, Country #, Region #, State #, City #, Office #, Sales Region #, Brand #, Line #, Item #, SKU #, Sales Rep #, Units, Cost Inventory Warehouse #, SKU #, Date, Quantity on Hand Inventory by Date, Item and Region Country #, Region #, Item #, Date, Quantity on Hand Items Lines Offices Brand #, Line #, Item #
Line #
Country #, Region #, State #, City #, Office #, Sales Region #
Orders Order #, Sales Rep #, Customer #, Site #, Office #, Received Date Orders by Received Date, Brand, Line, and Item Received Date, Brand #, Line #, Item #, Units, Cost Orders by Received Date, Item and Customer Received Date, Item #, Customer #, Units, Cost Orders by Received Date, Offices Received Date, Office #, Cost Orders by Received Date, Sales Regions and Customers Received Date, Sales Region #, Customer #, Cost Order Details Order #, Order Line #, SKU #, Units, Cost Regions Country #, Region #
Sales Regions Sales Region #

Sales Rep Pictures Sales Rep #
Sales Reps Sales Rep #
SKU Items Item #, SKU #, Colour, Size States Country #, Region #, State #
Warehouses Country #, Region #, State #, City #, Warehouse #
The target is to recognize the bold boxes in the source diagram as extract tables. It is also possible to construct an query specification for the extract. Note that the query may be incorrect. There are (at least) three possible reasons:
(a) Matching of column names may be incorrect.
(b) Incorrect assumption regarding aggregate expressions:
Aggregate expression may not be Sum.
Aggregation level may not be correct (this is likely with date keys).
(c) Missing filter clauses in the query. The extract may be relevant to a subset of the data contained in the base table.
Preconditions of this transformation are such that the physical model exists.
Tables have keys.
The transformation performs a detailed analysis of the key segments in the tables in the database. The algorithm builds a list of extended key segments for the tables, and then attempts to determine a relationship between the extended keys. If the extended key of table A is a subset of the extended key of table B, then the data in table A is an aggregate of data in table B.

The first step in the analysis is to construct a list of key segments for each table in the database. This data structure can be represented as a grid as shown in Figure 10. The numbers across the top in Figure 10 are the number of tables using that particular key segment. The numbers down the left side of are the number of key segments in that particular table.
The next step in the analysis builds the extended key lists for the tables by tracing all { 0,1 } :1-{0,1 }:N join relationships, and all {0,1 }:1-{0,1}:1 join relationships. Join relationships of cardinality {0,1}:1-{0,1}:N are traced from the N side to the 1 side.
Cardinality is the minimum and maximum number of records that a given record can give on the other side of the relationship. As new tables are encountered, their key segments are added to the table being traced (clearly this can be accomplished by using a recursive algorithm). Figure 11 shows the results of constructing the extended keys.
Now the algorithm can sort the table shown in Figure 11 based on the number of keys segments in each table. The algorithm compares each table to determine which table extended key is a subset of the other table extract key. The algorithm only needs to compare those tables which are leaf tables (all {0,1 }:1-{0,1 }:N joins associated with the terminate at the table). Figure 12 shows the sorted result.
The algorithm now turns to the pair-wise comparisons of the leaf tables. The first two tables to be compared are Order Details and Fact-Orders, as shown in Figure 13. The extended keys differ only in the segments Order #, Order Line #, and Received Date. In order to determine the relationship between these two tables, the algorithm attempts to locate attributes that match the unmatched key segments in the tables (or their parent tables).
Consider Order #. The algorithm needs to locate an attribute with the same name in Fact-Orders, or one of its' parent tables. If the algorithm can locate one such attribute, then it can consider the keys matching with respect to this key segment. If not, then the algorithm can deduce that the Fact-Orders table is an aggregation of the Order Details table with respect to this key segment. Turning to the sample database, Order # is seen not an attribute of the Fact-Orders table or any of its' parents. The same search for Order Line #
will also fail. The algorithm now locate the Received Date attribute in Order Details, or one of its' parents. It finds such an attribute in the Orders table. It therefore declare that'Order Details and Fact-Orders match with respect to this key. In summary, the pair of the tables has a number of key S segments which allow the transformation to declare that Fact-Orders is an aggregation of Order Details. Since there are no keys that declare that Order Details is an aggregation of Fact-Orders, the transformation declares that Fact-Orders is an aggregation of Order Details.
The next two tables to be compared are Order Details and Inventory as shown in Figure 14.
The algorithm begins by attempting to find an attribute named Customer # in Inventory, or one of its' parents. This search fails, so the algorithm deduces that Inventory is a subset of Order Details with respect to this key segment. The next search attempts to locate an attribute named Date in Order Details. This search fails, so the algorithm deduces that Order Details is a subset of Inventory with respect to this key segment. The transformation now faced with contradictory information, and can therefore deduce that neither table is an aggregate of the other.
The algorithm continues the comparisons. At the end of the first pass, the algorithm determines the following relationships:
Table Relationship Order Details Base Table Fact-Orders Aggregate of Order Details Inventory Fact-Inventory Orders by Received Date, Office Aggregate of Order Details Inventory by Date, Item, Region Orders by Received Date, Item, Aggregate of Order Details Customer Orders by Received Date, Brand, Line Aggregate of Order Details and Item Orders by Received Date, Sales Region, Aggregate of Order Details Customer The algorithm can deduce that Order Details is a base table since it is not an aggregate of any other table. For the second pass, the algorithm only needs to examine those tables that have not been identified as either base tables or aggregates. The second pass completes the tables as follows:
5 Table Relationship Order Details ~ Base Table Fact-Orders Aggregate of Order Details Inventory Base Table Fact-Inventory Aggregate of Inventory 10 Orders by Received Date, Office Aggregate of Order Details Inventory by Date, Item, Region Aggregate of Inventory Orders by Received Date, Item, Aggregate of Order Details Customer Orders by Received Date, Brand, Line Aggregate of Order Details 15 and Item Orders by Received Date, Sales Region, Aggregate of Order Details Customer The algorithm can deduce that Order Details is a base table since it is not an aggregate of any 20 other table.
As the algorithm performs each pass, it remembers two pieces of inforrriation:
(a) the table that is the current base table candidate; and (b) the list of tables that are aggregates of the current base table candidate.
Each time an aggregate relationship is determined between two tables, the current base table is adjusted appropriately. The algorithm can use the transitivity of the aggregation relationship to imply that if A is an aggregate of B and B is an aggregate of C, then A is an aggregate of C.
The algorithm will be completed as follows. Now that the algorithm has determined which leaf tables are base tables, it can now turn its' attention to the remaining tables in the database. The next phase of the algorithm begins by marking each table that is reachable from a base table via a {0,1}:1-{0,1}:N join relationship (traced from the N
side to the 1 side), or a {0,1 } :1-{ 0,1 } :1 join relationship. This phase results in the following additional relationships:
Table _ _ Relationship ~

Order Details Base Table ~

Fact-Orders Aggregate of Order Details Inventory Base Table Fact-Inventory Aggregate of Inventory Orders by Received Date, OfficeAggregate of Order Details Inventory by Date, Item, RegionAggregate of Inventory Orders by Received Date, Item,Aggregate of Order Details Customer Orders by Received Date, Brand,Aggregate of Order Details Line and Item 1 S Orders by Received Date, SalesAggregate of Order Details Region, Customer Orders Base Dim-Locations Offices Base Warehouses Base Cities Base SKU Items Base Dim-Products Items Base States Base Customer Sites Base Regions Base Dim-Customers Brands Base Countries Base Customers Base Lines Base Sales Regions gee Sales Rep Pictures Base Sales Reps gee Dim-Sales Reps Dim-Date The algorithm still hasn't determined the status for the some tables (in this case, they are all dimension tables).
The next step in the process is the construction of the extract objects for those tables that are identified as aggregates. In order to perform this activity, the transformation determines the smallest set of base tables that can provide the required key segments and attributes. To do this, the transformation uses the extended key segment grid that was constructed in the first phase of the algorithm.
As an example, the aggregate table Inventory by Date, Item and Region are used. Figure 15 shows the grid with the cells of interest highlighted. Note that the only tables of interest in this phase are base tables; therefore, some tables that have matching key segments are not of interest.
Once all of the tables are marked, the algorithm can proceed with matching non-key attributes of the aggregate table to non-key aggregates in the highlighted base tables.
If a matching attribute is found, then the table is declared to be required. In this case, the only attributes are from the Inventory table.
Once all of the attributes have been matched, the algorithm can turn its attention to the key segments. The first step is to determine which key segments are not provided by the required tables identified above. The remaining highlighted tables can be sorted based on the number of unprovided key segments that the table could provide if added to the query.
The unprovided keys in this example are Country #, Region #, and Item #. The tables Cities and Regions each provide two key segments; Countries, Inventory and Items provide one key segment each.
Processing begins with the tables that have the highest number of matches (in this case, Cities and Regions). Since the key segments provided by these tables overlap, some additional analysis be performed with these two tables. The algorithm picks the table that is the closest to the base table (Inventory). In this case, that table is Cities. Once Cities has been added to 33 .
the query, the only key segment that is unprovided is Item #, which is only provided by Items.
Once the queries for all aggregate tables have been determined, the algorithm can turn to the tables that have not yet been assigned a status (in this example, the dimension tables). The same algorithm can be used for each of these tables. If the algorithm fails to determine a query for the table, the table is deemed to be a base table. In this example, the dimension table Dim-Date is declared to be a base table since a query which provides all of the required attributes cannot be constructed from the set of base tables.
Table Extract Construction Transformation - Part 2 This transformation completes the work that was started in Part 1 of this transformation by converting the references to physical objects in the constructed queries into references to logical objects. Figure 16 shows the source and target. Preconditions are that the first part of this transformation constructed at least one table extract.
The operation is as follows:
I. For each constructed table extract:
A. Replace each reference to a physical object (column) with its corresponding logical object (attribute).
Physical Cubes Construction Transformation This transformation constructs a set of physical cubes based on the logical cubes in the model. The preconditions are that the model contains at least one logical cube.
The operation is as follows:
1. For each logical cube:
a) Construct physical cube.
b) For each dimension in the cube:
i) Add the "All" view of the dimension to the physical cube.

This transformation constructs physical cubes to instantiate the multidimensional space defined by the logical cube.
Business Model Transformations 114 The business model transformations include transformations for basic business model construction, fixing many to many join relationships, coalescing entities, eliminating redundant join relationships, introducing subclass relationships, referencing entities, determining attribute usage and identifying date usage.
In the simple case, there is a 1:1 mapping between the physical model and the business model, e.g., for every table there is an entity, for every column there is an attribute. More complicated transformations will manipulate the business layer and make it simpler and/or better.
Basic Business Model Construction This transformation constructs an E/R model that is very similar to the existing physical model. Figure 17 shows the source and target of the transformation. The preconditions are as follows:
1. A physical model exists.
2. The model contains eligible objects.
a) A table or view is eligible if it is not associated with a table extract and hasn't been transformed.
b) A stored procedure result set call signature is eligible if it hasn't been transformed.
c) A join is eligible if it has not been transformed, is not associated with a table associated with a table extract, and both tables have been transformed.
d) A synonym is eligible if the referenced object has been processed by this transformation and the synonym hasn't been processed. A synonym for a stored procedure is eligible only if the stored procedure has a single result set call signature.

The operation is as follows:
1. For each acceptable table:
a) If table has already been transformed:
i) Attempt to locate target entity.
b) Else i) Build entity.
ii) Mark table as transformed.
iii) Add relationship between table and entity.
c) If entity built, or found:
10 i) For each column in table:
a) If column hasn't been transformed yet:
(1) Build attribute (2) Mark column as transformed (3) Add relationship between column and attribute 15 ii) For each physical key in table:
a) If physical key has already been transformed:
( 1 ) Attempt to locate key b) Else ( 1 ) Build key 20 (2) Mark physical key as transformed (3) Add relationship between physical key and key c) If key built or found:
( 1 ) For each column in physical key:
(a) If column has been transformed:
25 (i) Attempt to locate attribute:
(ii) If attribute found and attribute not in key:
(a) Add attribute to key 2. For each acceptable view:

a) If view has already been transformed:

i) Attempt to locate target entity.

b) Else i) Build entity.

ii) Mark view as transformed.

iii) Add relationship between view and entity.

c) If entity built, or found:

i) For each column in view:

a) If column hasn't been transformed yet:

(1) Build attribute (2) Mark column as transformed (3) Add relationship between column and attribute 3. For each acceptable stored procedure result set call signature:

a) If signature has already been transformed:

i) Attempt to locate target entity.

b) Else i) Build entity.

ii) Mark signature as transformed.

iii) Add relationship between signature and entity.

c) If entity built,. or found:

i) For each column in signature:

a) If column hasn't been transformed yet:

(1) Build attribute (2) Mark column as transformed (3) Add relationship between column and attribute 4. For each acceptable synonym:

a) Build entity.

b) Mark synonym as transformed.
c) Add relationship between synonym and entity.
d) Make entity a subtype of entity corresponding to object referenced by synonym. (If the synonym refers to a stored procedure, use the one and only result set call signature of the stored procedure instead.) 5. For each acceptablejoin:
a) Map join expression.
b) If either cardinality is 0:1 replace with 1:1.
c) If either cardinality is O:N replace with 1:N.
d) Construct new join.
If a source object has been marked as transformed, an attempt is made to locate the target if the source object could contain other objects. If multiple target objects are found, processing of that source object halts and an error message is written to the log file.
If there are no target objects, then processing of the source object halts, but no error is written.
In this case, the algorithm assumes that the lack of a target object indicates the administrator's desire to avoid transforming the object.
Fix Many to Many Join Relationships This transformation step seeks out entities that exist as an implementation artifact of a many to many relationship. Joins associated with entities of this type are replaced with a single join.
These entities are also marked so that they will not be considered when the presentation layer is constructed. Figure 18 shows the first source and its corresponding target.
Figure 19 shows the second source and its corresponding target. The preconditions are as follows:
1. An entity (artificial) participates in exactly two join relationships with one or two other entities.
2. The cardinalities of the join relationships are 1:1 and {0,1 }:N. The N
side of each of the join relationships is associated with artificial-entity.

3. Each attribute of artificial-entity participates exactly once in the join conditions of the join relationships.
4. Artificial-entity has a single key that is composed of all attributes of the entity.
5. The artificial entity does not participate in any subtype, containment or reference relationships.
The operation of this transformation is divided into two sections. The behaviour of the transform will vary for those entities that are related to a single join only.
Entity of Interest Related to Two Other Entities 1. Create new join that represents union of the two existing joins.
2. Delete existing joins.
3. Delete artificial entity.
Entity of Interest Related to One Other Entity 1. Create new entity that is a subtype of the other entity.
1 S 2. Create a new join that represents union of the two existing joins. The join associates the other entity and its' new subtype.
3. Delete existing joins.
4. Delete the artificial entity.
The status flag usage is as follows:
Coalesce Entities This transformation step seeks out entities that are related via a 1:1 join relationship and coalesces these entities into a single entity. The new entity is the union of the entities participating in the join relationship. The source and target are shown in Figure 20. Note that ud~ect Class Prohibit Processed Key B.1 is removed since the associated attribute B.2 is equivalent to attribute A.1, and is therefore not retained as an entity of A. Since the attribute is not retained, the key is not retained. The preconditions are as follows:
1. Two entities (left and right) are related by a single join that has cardinalities 1:1 and 1:1. The join condition consists of a number of equality clauses combined using the logical operator AND. No attribute can appear more than once in the join clause. The join is not marked as processed by this transformation.
2. The entities cannot participate in any subtype or containment relationships.
3. Any key contained within the left-entity that references any left-attribute in the join condition references all left-attributes in the join condition.
4. Any key contained within the right-entity that references any right-attribute in the join condition references all right-attributes in the join condition.
The operation is as follows:
1. Scan join clause to construct mapping between left-attributes and right-attributes.
2. Delete right-keys that reference right-attributes in the join clause.
3. Delete right-attributes that occur in the join clause from their presentation folder.
4. Delete right-attributes that occur in the join clause.
5. Move remainder of right-attributes from their presentation folder to left-entity presentation folder.

6. Move remainder of right-attributes and right-keys to left-entity.

7. For each join associated with right-entity (other than join that triggered the transformation):
a) Build new join between other-entity and left-entity, replacing any right-entity that occurs in attribute map (from step 1) with corresponding left-entity. All other join attributes have the same value.
b) Add join to appropriate presentation folders.
c) Delete old join from presentation folders.
d) Delete old join.

8. Delete folder corresponding to right-entity from presentation folders.

9. Delete right-entity.
The status flag usage is as follows:
5 Object Class Prohibit Processed This step transforms a set of vertically partitioned tables into a single logical entity.

10 Eliminate Redundant Join Relationships This transformation eliminates join relationships that express the transitivity of two or more other join relationships in the model. This transformation can reduce the number of join strategies that need to be considered during query refinement. The source and target are shown in Figure 21. The preconditions are as follows:
15 1. Two entities (start and end) are related by two join paths that do not share a common join relationship.
2. The first join path consists of a single join relationship.
3. The second join path consists of two or more join relationships.
4. The join relationships all have cardinalities 1:1 and 1:N.
20 5. The join relationship that forms the first join path has cardinality 1:1 associated with start-entity.
6. The join relationship that forms the second join path has cardinality 1:1 associated with start-entity. The set of join relationships associated with each intermediate-entity in the second join path has a single member with cardinality 1:1 at the intermediate-25 entity. The other member has cardinality 1:N. (The joins are all "point" in the same direction.) 7. Both join paths return the same set of records.
8. All joins are of type association only.
30 The operation is as follows:

1. Only 1:1 - l :N join relationships is considered in this section.
2. Order entities in graph using algorithm to determine Strongly Connected Components. Treat the join relationships as directed edges (from 1:1 end to 1:N end).
3. Apply a distance to each entity:
a) For each entity:
i) distance = distance[ entity ] + 1;
ii) for each join relationship leaving this entity:
a) distance[ otherEntity ] = max( distance[ otherEntity ], distance ) 4. For each entity:
a) For each join relationship leaving this entity:
i) If distance[ rightEntity J - distance[ leftEntity ] > 1 a) This join relationship is a candidate for elimination.
b) Find all alternate join relationship paths from startEntity to endEntity. Note that an alternate path can have no more than distance[ rightEntity ] - distance[ leftEntity ] relationships in it.
c) For all alternate paths:
(1) If the candidate join relationship is equivalent to the alternate path (a) Remove candidate join relationship from presentation layer folders.
(b) Remove candidate join relationship from model.
(c) Break. Continue processing at Step 4.
The status flag usage is as follows:
Object Class Prohibit Processed ~: ~ r,~
~~,.,.~.'~: rk~P.~,~ -°, '.~o ?~, . .xi<. _rW p~
.s, ur.,Y.,~R~'~....,.,. ~ < , ; R ~sA~~z'~~m r~>
a"~P~2. v This entity/relationship diagram contains a number of redundant join relationships that is eliminated using this transformation (the curved lines). This section will illustrate the (effective) graph manipulations performed by the various steps in the operation section as shown in Figure 22.
After Step 3 in the algorithm, the graph looks like Figure 23. Consider the processing of Step 4 for the first entity ("Countries"). There are two join relationships that leave this entity, but only one is a candidate for elimination. It is represented by the curved line from Countries to Offices. There are two alternate paths, as shown in Figure 24 with thick lines. After analysing the join conditions, the algorithm determines that the candidate join can be eliminated from the graph.
Comparing Join Paths Once an alternate path has been found, it is compared to the other path to determine if it is equivalent. Say the alternate path involves entities A, B, C, D, and E, and join relationships AB, BC, CD, DE. The original path involves entities A, E, and join relationship AE, as shown in Figure 25.
The alternate expression will consist of the expressions from each of the join relationships in addition to the expressions of any filters involving the intermediate entities B, C and D, all combined using the And operator.
The original expression will consist of the expression from the join relationship AE.
Using our example expressions, the alternate expression is:
1 = B.1 ) && (B.1 ---- C.1 && B.2 = C.2) && (C.1 = D.1 && C.2 = D.2 && C.3 =-.3) && (D.1 == E.1 && D.2 = E.2 && D.3 = E.3 && D.4 = E.4) The condition the transformation wishes to verify is:

During processing, a map is constructed which records equality specifications in the joins.
The expressions are then modified using these maps before comparing them.
The comparison function simplifies both of these expressions to true, so the join paths are equivalent.
Introduce Subclass Relationships This transformation eliminates some join ambiguities by introducing new entities and subclass relationships into the model. The source and target are shown in Figure 26. The preconditions are as follows:
1. Two entities (left and right) are related by two join relationships.
2. The cardinalities of the join relationships are identical.
3. The cardinalities of the join relationships associated with each entity are identical.
4. , The related entities do not participate in any subtype, containment or reference relationships.
5. The join condition of the join relationships matches. Details of the matching criteria are described below.
The operation is as follows:
1. Create two new entities (derivedl, derived2) based on entity whose attributes were not substituted (constant) in the matching join conditions (the base entity). If attributes from neither entity are substituted, then create four new entities (two for each base entity).
2. Create subclass relationships.
3. Create new join relationships between other entity and derived entities (or solely from the derived entities). If the join cardinality at either end of the relationship was O:N, change the cardinality to 1:N (0:1 is changed to 1:1 ).
4. Add a filter condition to each derived entity. The condition is identical to the join condition of the join constructed in the previous step.
5. Delete old join relationships.

6. Fix up presentation layer by removing folder references that were constructed based on the old joins.
This transformation will require model changes. The subclasses in this example represent roles. A staff member can act as an Instructor or as a Tutor, or as a generic staff member. The filter conditions that are assigned to the new entities define the roles. By assigning a filter condition to the entity, the transformer will cause the join relationship to be used in the query.
Since the join relationship will always specify an inner join, the transformer restricts the set of records retrieved to suit the role.
Two join condition expressions are considered to match if the only logical change in the expression is the substitution of attributes of a single entity with other attributes of the same entity. Note that simple rearrangement of expressions such as "a + b" to "b +
a" is not considered to be a significant enough change to prevent these expressions from matching. A
1 S change such as "(a + b) * c" to "a + (b * c)" does prevent the expressions from matching.
Some form of tree comparison will be required to implement the matching logic.
Here are some examples of matching and non-matching expressions:
(A.1=B.1) and (B.l =A.2) These expressions match because the only difference is that A.1 has been replaced with A.2.
(A.1= B.1 & & A.2 = B.2) and (A3 = B.2 & & A.4 = B.1) These expressions match because the only difference is that A. l has been replaced with A.4 and A.2 has been replaced with A.3.
(A.l =- B.1 & & A.2 = B.2) and (A.l = B.3 8c & A.3 = B.2) These expressions do not match because the differences A.2 has been replaced with A.3 and B.1 has been replaced with B.3. Since attributes from both entities have been substituted, these expressions do not match.

(A.1= B.1 & 8c A.1= B.2) and (A.2 = B.l and A.3 = B.2) These expressions do not match because A. l has been replaced by both A.2 and A.3.
Reference Entities 5 This transformation eliminates some join ambiguities by changing the association type of business joins. The source is shown in Figure 27. The preconditions are as follows:
1. An entity (the reference entity) is related to two (or more) other entities via a {0,1 }:1-{ 0,1 } :N with the {0,1 } :1 end associated with the reference entity.
2. Each join references non-key attributes of the non-reference entities.
10 3. The reference entity cannot participate in any subtype or containment or reference relationships.
The operation is as follows:
1. Mark the appropriate joins as reference relationships on the reference entity side.
15 The status flag usage is as follows:
Ubject Class Prohibit Processed Entity ~~bo not process this instance. =~Do not process this instance.
Business Join ~Do not process this instance. ~,~>1VA
20 Consider an entity such as Address that is referenced by both Customers and Suppliers.
Formulating a report that shows the relationships between customers and shippers with their addresses would prove very difficult without the ability to define an alias in the query definition. Without this capability, the query would likely attempt to join via the Address entity. It is very unlikely that both a Customer and Shipper would share the same address.
Introducing the reference relationships into the model allows the query engine refiner to avoid joining through the Address table. A user (or client application) would need to define a query unit for each instance of the Address entity required in the query.
Determine Attribute Usage This transformation determines the usage of an attribute based on how it is used by other model objects. The preconditions are that business model exists.
The operation is as follows:
I. For each non-prohibited entity:
A. For each key 1. Construct list of attributes (not attribute proxies) as descriptive list B. For each join related to this entity 1. Extract attributes (not attribute proxies) of this entity, add to descriptive list.
C. Add attributes (not attribute proxies) of entity that aren't in descriptive list to value list.
D. For each attribute in descriptive list 1. If attribute usage is unknown && not prohibited && not marked as transformed a) set usage to descriptive b) mark attribute as transformed E. For each attribute in value list 1. If attribute usage is unknown && not prohibited && not marked as transformed a) If attribute is numeric ( 1 ) set usage to performance indicator (2) mark attribute as transformed The status flag usage is as follows:
Ubject Class Prohibit Processed k.Entity ~ Do not process the instance, or n s. ~.,, xk.r ,~ 1 3 rcontained attributes. ' Attribute ~ Do not process the instance. ~~Do not process the instance.

Identifying Date Usage This transformation examines model attributes to determine where dates are used in the model. Identifying date sensitive information can assist in the construction of dimensions in subsequent transformations. This transformation will build a date table in the physical layer, in addition to the required business model objects to reflect the physical table. Note that this transformation is unique in that the Database Administrator will be required to make changes to the physical database to use the model to perform queries after the transformation has completed. The administrator will also be required to populate this table. For these reasons, this transformation is always considered as optional.
As a source, consider the business model shown in Figure 28. The target is shown in Figure 29. In this example, date attributes exist within the entities are: Inventory, Warehouses, Orders, Sales Reps, Customers, Offices, etc. (but not in Order Details). In this example, the entity "Date" (and underlying physical objects) has been created and joined to a number of entities. The new objects are presented in bold. The locations to join to the date entity is based on the proximity of the date attribute's entity to the "fact" entities -those entities that participate on the { 0,1 } :N side of join relationships. There is no preconditions for this transformation.
The operation is as follows:
1. Order entities in graph using algorithm to determine Strongly Connected Components. Treat the join relationships as directed edges (from 1:1 end to 1:N end).
2. For each entity (from "deepest" to "shallowest"):
i) If the entity isn't marked and the entity contains a date attribute:
a) If the transformation hasn't been run before:
( 1 ) Create date objects in model.
(2) Mark model as transformed.
b) Else (1) Locate previously created date entity and attribute.
c) If date attribute hasn't been transformed and date entity and attribute exist:

(1) Create join between the entity's attribute and the date attribute.
d) Mark all ancestor entities to prevent adding additional joins to Date entity.
The goal of this transformation is to provide a reasonable set of relationships between the Date entity and other entities. The relationships are added in a manner that facilitates the construction of dimensions in later transformations.
Multidimensional Model Transformations The multidimensional model transformations include transformations for identifying measures and constructing measure dimensions, constructing category dimensions and levels, and constructing logical cubes.
Identifying Measures and Constructing Measure Dimensions This transformation identifies a reasonable set of measures by analyzing the structure of the E/R model to identify entities that contain measure candidates. For this transformation, the only join relationships considered have cardinalities {0,1 }:1 - {0,1 }:N. A
join relationship with these cardinalities can be considered to be directed, beginning at the end with cardinality { 0,1 } :1 and terminating at the end with cardinality { 0,1 } :N. An entity could contain a measure candidate if all of the considered join relationships terminate at the entity.
Once a suitable entity has been discovered, each attribute of the entity is tested to determine if the attribute could be a measure. An acceptable attribute is numeric, and is not a member of a key and is not referenced in any join relationship associated with the entity.
The source and target are shown in Figure 30. In this example, Attributes A.1, A.2, are A.4 not suitable because they are participate in keys. Attribute A.7 is unacceptable because it is a string. The preconditions are as follows:
The model contains at least one entity whose associated {0,1}:1 - {0,1}:N join relationships terminate at the entity.

2. The suitable entries have numeric attributes that do not participate in keys (or in any join relationship).
The operation is as follows:
1. For each entity:
a) If all joins with cardinalities {0,1 }:1, {0,1 }:N terminate at this entity:
i) If entity has been marked as transformed:
a) Attempt to locate measure dimension.
ii) If measure dimension found or entity not marked as transformed:
a) For each attribute in entity:
( 1 ) If attribute hasn't been transformed, not used by any key or join, and is numeric:
(a) Build measure (b) If entity hasn't been transformed:
(i) Build measure dimension (ii) Mark entity as transformed.
(iii) Add relationship between attribute and measure.
(c) Add measure to measure dimension.
This transformation identifies a basic set of measures based on an analysis of the E/R model.
This transformation will not identify all of the attributes that could be measures in the model, since only the "fact table" entities are examined for attributes that could be measures.
Constructing Category Dimensions and Levels This transformation analyzes the E/R model and constructs dimensions and levels for the structure. If necessary, additional Date entities are created to maintain the consistency of the model. As a source, consider the E/R model as shown in Figure 31. The target is shown in Figure 32.

In this example, there are identified two logical "fact tables": Inventory, and the pair of tables Orders and Order Details. There are also identified five dimensions:
geographical (Countries and Sales Regions), customers (Customers), sales reps (Sales Reps), products (Brands and Lines), time (Date). The preconditions are as follows:
The model contains at least one entity whose associated {0,1 } :1 - { 0,1 } :N
join relationships terminate at the entity.
2. Entities that are keyed with an attribute of type date only participate on the {0,1 } :1 side of all associated join relationships.
3. The transformation has not been run against this model before.
Since this transformation relies rather heavily on recursion, the operation of the transformation will explained by following the algorithm's progress on the sample model provided above in the source section.
The first part of the algorithm is to determine which entities are fact entities and which entities are dimension entities. The algorithm begins by processing all entities that have join relationships with cardinality {0,1 }:1-{0,1 }:N all terminate at the entity.
For the sample model, the entities that satisfy this criterion are Inventory and Order Details.
Consider the Inventory node. The algorithm marks this entity as a fact entity.
It then processes all associated (via {0,1 }:1-{0,1 }:N join relationships) entities in a recursive fashion. If the entity hasn't been processed yet, the algorithm will process it. If the entity has a key of type date, the algorithm marks the entity as a Time entity.
Otherwise, the entity is marked as a dimension entity, and it's related entities are processed recursively. After the transformer completes the processing of the Inventory entity, the graph is decorated as shown in Figure 33.
The algorithm now turns its attention to the Order Details entity, where some of the interesting things happen. Once again, the algorithm marks Order Details as a fact entity, and processes the associated entities recursively if they have not yet been processed. For the sake $1 of explanation, say the algorithm is currently processing the Orders entity.
It has processed the related entities Sales Reps and Customer Sites, marking them as dimension entities. The algorithm is about to process the Date entity. Figure 34 shows how the graph has been decorated to this point.
When attempting to process the Date entity, the algorithm notes that the entity has already been processed, and it is a time entity. This forces the Orders entity to be marked as a fact entity instead of a dimension entity. Processing of the Offices entity continues normally. The tail of the recursive process marks all intermediate entities between Orders and Order Details as fact entities. In this case, there are no such entities. Figure 3 $ shows the model at the end of the first step in processing.
The next phase of the algorithm groups entities into groups that will eventually be dimensions. For this step, the algorithm processes all of the entities tagged as fact entities.
1$ The algorithm recursively processes all associated entities of the fact entities, and assigns to them a dimension number. Figure 37 shows the graph after processing the Inventory fact entity.
The algorithm now considers the processing of the Order Details entity. Since all associated dimension entities (SKU Items) already has a dimension number assigned to it, the processing of the Order Details entity is complete.
When processing Orders, the algorithm can process the associated entities Sales Reps and Customer Sites. Consider the graph shown in Figure 37 during processing of the Offices 2$ entity, immediately after processing the Sales Regions entity. When the algorithm attempts to process the Cities entity, it notes that this entity has already been assigned a dimension number. In this situation, the algorithm merges the dimension group under construction with the existing group. This is accomplished by changing the dimension numbers of those entities in the new group to the dimension number of the existing group. In this case, all entities tagged with the number 6 would be re-tagged with 3. This merge operation also happens to complete this step in the algorithm.
The next step in the transformation is the construction of dimensions and levels. Each group corresponds to a dimension. The algorithm processes each group in turn. For each group, the algorithm finds all of the roots in the dimension. It then constructs a name for the dimension by concatenating these names together. When the dimension is constructed, it is added to the appropriate presentation folder.
For every dimension other than the dimension based on a time entity, the next step is the construction of the levels. Each entity in the dimension group is used to construct the level.
The entity key is used as the level source value expression. Each level is added to the dimension as it is constructed. Then, based on the entity join relationships, drill relationships are constructed between the levels. Figure 38 is an illustration of each dimension (other than the time dimension) after it has been constructed.
When the transformer constructs a time dimension, extra objects are added to the model.
(This will require a model change.) The extra object is a drill object, which coordinates settings across levels for time dimensions. Some examples of the type of information managed include the year start date, the beginning day of the week, and the rule for managing the construction of partial weeks.
The construction of the time dimension yields a structure that is very similar to the dimension as produced by Transformer. Figure 39 shows the structure for the time dimension. The categories are constructed within levels based on the data processed.
The last part of the process that are completed is the association of measures with levels. The association is required to determine the level of detail of data of the measure, as well as determine which dimensions are relevant to the measure. For example, a measure which tracks the number of days in a month is associated only with the Month level.
A measure such as Units from Orders is associated with all of the dimensions in the model.
This step of the processing is accomplished by examining each measure in the model to determine which entities are used to define the measure (all of these entities are fact entities).
The measure is associated with the level of each dimension entity that this associated with the fact entity. So, fur Units of Order Details, the associated level list is Sales Reps, Customer Sites, Offices, SKU Items, and Month. Note that in the case of Month, the most detailed level (as determined by following drill relationships) is associated with the measure.
Constructing Logical Cubes This transformation constructs a set of logical cubes based on the dimensions in the model.
The preconditions are such that the model contains at least one measure dimension; and this transformation hasn't been executed before.
The operation is s follows:
1. For each measure dimension:
a) Construct a logical cube that contains the measure dimension. Add the logical cube to the presentation layer.
b) For each associated entity in the E/R model:
i) If the entity has a level:
a) Add the dimension using the dimension to the cube (if the dimension isn't already used by the cube).
This transformation collects dimensions that are related to measures in a single measure dimension together to form a logical multidimensional space. The model change required is the addition of associations between measures and levels. Once these associations are in place, it will not be necessary to use the E/R graph in this transformation.

Presentation Model Transformations 116 The presentation model transformations include transformations for basic presentation model construction, and multidimensional presentation model construction.
Basic Presentation Model Construction This transformation constructs a presentation model that is very similar to the existing E/R
model. The source and target are shown in Figure 40. The preconditions are as follows:
1. Business Model exists.
2. All entities except those marked by the Fix Many to Many Join Relationships transformation are acceptable. Note that if an entity is so marked, but participates in a subtype or containment relationship, it is considered acceptable.
3. A join is acceptable if it hasn't been transformed yet, joins two entities that have been transformed, and the entities each have a single transformation target.
The operation is as follows:
1. For each acceptable entity:
a) If entity has already been transformed:
i) Attempt to locate target presentation folder.
b) Else i) Build presentation folder.
ii) Mark entity as transformed.
iii) Add relationship between entity and presentation folder.
c) If presentation folder built, or found:
i) For each attribute in entity:
a) If attribute hasn't been transformed yet:
( 1 ) Add reference to attribute to presentation folder.
(2) Mark attribute as transformed 2. For each acceptablejoin:
a) Cross reference the target presentation folders for each entity.

If a source object has been marked as transformed, an attempt is made to locate the target if the source object could contain other objects. If multiple target objects are found, processing of that source object halts and an error message is written to the log file.
If there are no target objects, then processing of the source object halts, but no error is written.
In this case, the 5 algorithm assumes that the lack of a target object indicates the administrator's desire to avoid transforming the object.
Multidimensional Presentation Model Construction This transformation constructs a presentation model that suggests dimensional structures by 10 constructing folders in a predefined manner. As a source, consider the business model shown in Figure 41. The target folder structure would be as follows:
Dimensional Folders Inventory <attributes of Inventory>
Brands <Attributes of Brands>
Items <Attributes of Items>
SKU Items <Attributes of SKU Items>
Arc 1 Brands <Attributes of Brands>
SKU Items <Attributes of SKU Items>
Arc~2 Lines <Attributes of Lines>
Items <Attributes of Items>
SKU Items <Attributes of SKU Items>
Arc~3 Lines <Attributes of Lines>
SKU Items <Attributes of SKU Items>
Arc~4 Countries <Attributes of Countries>
Regions <Attributes of Regions>
States <Attributes of States>
Cities <Attributes of Cities>
Warehouses <Attributes of Warehouses>
Orders <attributes of Orders, Order Details>
Arc Brands <Attributes of Brands>
Items <Attributes of Items>
SKU Items <Attributes of SKU Items>
Arc 1 Brands <Attributes of Brands>
SKU Items <Attributes of SKU Items>
Arc~2 Lines <Attributes of Lines>
Items <Attributes of Items>
SKU Items <Attributes of SKU Items>
Arc~3 Lines <Attributes of Lines>
SKU Items <Attributes of SKU Items>
Arc~4 Sales Reps <Attributes of Sales Reps>
Arc~S
Customers <Attributes of Customers>
Customer Sites <Attributes of Customer Sites>
Arc~6 Customers <Attributes of Customers>
Arc~7 Sales Regions <Attributes of Sales Regions>
Offices <Attributes of Offices>
~c~g~
Sales Regions <Attributes of Sales Regions>
Arc~9 Countries <Attributes of Countries>
Regions <Attributes of Regions>
States <Attributes of States>
Cities <Attributes of Cities>
Offices <Attributes of Offices>
Arc 10~
Countries <Attributes of Countries>
Regions <Attributes of Regions>
Offices <Attributes of Offices>
Arc 11 Countries <Attributes of Countries>
Offices <Attributes of Offices>
The preconditions are as follows:
1. Business Model exists.
2. All entities except those marked by the Fix Many to Many Join Relationships transformation are acceptable. Note that if an entity is so marked, but participates in a subtype or containment relationship, it is considered acceptable.
3. A join is considered acceptable if it references two acceptable entities.
The operation is as follows:
1. Build an entity graph:
a) Add a node to represent an entity that isn't contained by another entity.
b) Add an edge to represent a { 0,1 } :1 - { 0,1 } :N join. If the entity on either end is contained by another entity, add the edge to the ultimate containing entity. Don't add an edge that represents a self join.
c) Add two edges to represent a { 0,1 } :N - { 0,1 } :N join.
d) Ignore { 0,1 } :1 - { 0,1 } :1 joins.
2. Determine strongly connected components.
3. For each node:
a) If the node has no reachable nodes (it is a "fact table"):

i) Construct a folder for the node, add attributes of entity, and all contained entities.

ii) For every reaching node (recursive):
a) Get all reaching nodes, filter by nodes used to reach this node.
b) If no reaching nodes:
( 1 ) Create "Arc" folder in fact table folder.
(2) For this node and each node used to reach this node:
(a) Construct a folder and add attributes of entity and all contained entities.
c) else (1) Process all reaching nodes recursively (3.ii).
This transformation attempts to construct hierarchies that can be used to construct dimensions in Transformer. While this transformation is being added for the User Conference, the final fate of this transformation is unknown at this time.
General Transformations The general transformations include transformation for name mutation.
Name Mutation This transformation constructs user friendly names for objects. Text substitution is based on a dictionary. The preconditions are as follows:
1. A name has a fragment that matches an entry in the dictionary. The match criteria can include the location of the fragment within the name.
2. The object has not been transformed.
The operation is as follows:
1. Replace fragment with associated entry from dictionary.

The status flag usage is as follows:

This transformation is very open ended in nature and can be improved over time by adding additional entries to the dictionary. Users may also benefit if they could provide their own dictionaries.
Consider the example name "CUSTNO". If a dictionary entry that specified that "NO", when discovered at the end of a name, could be replaced with " Number", then the resulting text would be "CUST Number". A second transformation could state that "CUST" at the beginning of the name is replaced with "Customer". The result of these transformations would be "Customer Number". An additional operation could change the case of letters in the name. For example, "Customer Number" "Customer number" could be the result of this transformation.
Obviously, the effectiveness of this transformation is only as good as the supplied dictionary.
It is possible to construct a dictionary rich enough to translate over 75% of the names found in a physical database. With a custom dictionary, the success rate is much higher.
If nothing else" this transformation would be a cool demo feature that would cost almost nothing in implementation cost.
Object Class Prohibit Processed Transformation Prerequisites This section documents the optimal order for the execution of the model transformations.
Since most of the transformations can now be applied repeatedly with no ill effects, a strict ordering is no longer necessary. However, better results may be possible if, for example, the physical model was complete before starting the business model transformations.

Construct Physical~ None Joins Construct Physical~ None Keys Table Extract W'his transformation requires keys. Depending on the physical Construction layer contents, it may be best to run the - Part 1 transformation Construct Physical Keys before executing this transformation.

1 S Table Extract ~ run with a completed business layer.

Construction - Part 2 Constructing - run after Constructing Logical Cubes Physical Cubes Basic Business ~ execute after Table Extract Construction Model -Part 1 to avoid Construction generation of entities which represent aggregate tables. Since these tables store aggregated data, they do not deserve representation in the business layer of the model.

Fix Many to Many~ run after Basic Business Model Construction.

Join Relationships Eliminate Redundant~ run after Fix Many to Many Join Relationships.

Join Relationships Coalesce Entities~ run after Eliminate Redundant Join Relationships because there will be less joins to examine and manipulate.

Introduce Subclass~ run after Eliminate Redundant Join Relationships because Relationships there will be less joins to examine and manipulate.

Identifying Date~ run before Introduce Subclass Relationships since this Usage transformation can generate multiple joins between entities (as a result of multiple date attributes in an entity).

Identifying Measures~ execute after completion of all business layer manipulations.

and Constructing Measure Dimensions 35 Constructing ~ execute after completion of all business layer manipulations.

Category Dimensions and Levels Constructing - execute after Identifying Measures and Constructing Logical Cubes Measure Dimensions since this transformation will construct logical cubes based on measure dimensions constructed by that transformation.

execute after Constructing Category Dimensions and levels since this transformation will require the dimensions constructed by that transformation to construct meaningful logical cubes.

Basic Presentation~ run after completion of Business and Multidimensional Model ConstructionLayers.

Multidimensional~ run after completion of the Business Layer.

Presentation Model 45 Construction Name Mutation ~ None SO Metadata Exchange 10 The DBMS environment may include both an automation interface and an API to the repository. Both of these interfaces allow complete manipulation of the metadata model.
Using these interfaces, anything that can be done within the UI can be done from an external program.
SS
The metadata exchange 10 allows bridges between external metadata sources and the DBMS
4. The metadata exchange 10 may be an import bridge where information in external sources is brought into the DBMS 4, or an export bridge where information that has been collected in the DBMS 4 is made available in another repository.
External repositories will include additional business metadata for objects.
This may be as simple as a descriptive name, to more complex transformation and lineage information. The exchange 10 allows as much of this information as possible to be captured and used at all levels of the metadata model. At the least it is descriptive names for tables and columns in the physical model which is different than the actual database name. This information is required at the physical level so it can be brought forward, through transformations, to the business model. The actual object properties required depend on an analysis of the available sources. But it needs to be done early as it is built into the automation and API interfaces.
Other types of Business Descriptive metadata include:
Database subsets. If the model involves a portion of the entire physical database, then only a portion of the database may be represented in the metadata source. This can be used to restrict the information which is imported from the database.
2. Business Names. These are used to name the entities and attributes in the business model. Because they are usually mapped to physical objects in the external repositories, it may make sense to update the physical model entries first then use transforms to generate the default business model entries. An algorithm may be used to that allows us to determine which business model entries to update based by mapping through to the physical model entries.
3. Business Subject Areas. These are the business organization of information in the model. In most cases they are logical views or hierarchies over the physical model objects. This information needs to be mapped to the structure and organization of the business model folders and user folders.
4. Business Description. This information needs to be associated with the corresponding Business Model entry (Entity or Attribute).

The exchange 10 can be built outside the main product stream as they will be using the external interfaces to maintain information in the repository. The information that will be exchanged will depend on the external source itself.
Query Engine 30 The objective of the query engine 30 is to allow the formulation of queries based on the objects defined in the business model that are stored in the metadata model repository and for the retrieval of the data specified in the underlying data sources.
The query engine 30 is provided above the physical layer with some business rules. It takes advantages of the non-existence of entities either on the left or on the right side of a join with the explicit specification of cardinalities in a business layer. The query engine 30 overrides what is in the physical layer, which allows to make the reports more likely to what the user expects. The query engine 30 provides a business view of the cardinalities.
For example, the cardinality between "customer" and "order" information is a minimum cardinality in the "customer" side of one-to-one cardinality on the "order"
side one to many.
The query engine 30 creates a subtype on a customer and creates a new relationship to the order information that has an optional cardinality in it. Reporting on those cardinalities calls in all the customers that do not have orders. Thus, a different view of the relationship may be obtained.
Cardinality also allows the query engine to simplify the expressions. If the relationship is a one-to-one relationship, rather to a many-to-many or a many-to-one relationship, the creators can be specified in simpler terms by taking advantage of the information.
The query engine 30 also uses the concept of a reference relationship between two entities.
This involves the concept of a container simplifying the model from the user's point of the envelope.

In order to create a table more than once within the same record, the query engine 30 refers to entity that can be used multiple times in a reference of relationships. The query engine 30 can then take advantage of that knowledge when it is navigating the model of picking up information to report to make sure that the report does not navigate through an entity that is used as a reference entity. The reporting to the user can then dynamically create a unit around this. Also, it may be captured in the business layer as roles by adding attributes from the referred two entities within the entity that wants to make a reference.
The use of a reference relationship reduces the number of entities that a user deals with considerably.
A container relationship is influenced by how tables are joined when the user requests information from various tables. The query engine 30 replaces the table weights with a more logical concept of how closely entities have tied together so that a container relationship is picked up during the joint path calculation between the entities that need to be queried.
The query engine 30 also make use of a entity consistent view. With the introduction of the business layer, the query engine 30 can consistently view the number of roles that come back out on an entity that represents a database view. In the database view, a net is being created and it consists of information between two tables. It is as if a joiner is always created on that information, which is carned forward into the business layer. The query engine 30 calculates to find out which of the tables that are used by the entity is going to be a driver table.
The drive table is a table with the highest cardinality because that is the table that always needs to be included in a generator SQL in its joint path so the numbers of rows stays consistent. If no data is retrieved from that table, then that is immaterial to the SQL
generation as the join will be generated into the SQL statement. If, however, the only information that is retrieved comes from the driver table, the other tables are not presented in the generated SQL. Thus, the query engine can simplify the query. This also takes advantage of the cardinality information that is stored in the business layer and in the physical layer in order to determine which one of the tables are used in an entity is the driver table.
Functional Specification of the Query Engine The query engine 30 includes some objects to facilitate the formulation of queries. The objects may include a query specification and data matrix. The query specification is a compound object modelled in the DBMS 4 to allow queries to be defined in the DBMS 4 and referenced in other queries. The data matrix is a class that defines an organization of the retrieved data.
The query engine 30 include querySpecification. The querySpecification allows for simple as well as multidimensional queries. Data can be obtained using a flexible set of classes, which is defined by a concept called a dataMatrix. Applications of the querySpecification are not restricted to this data retrieval method and can obtain the SQL statements for the various components of a querySpecification.
The querySpecification also allows the specification of more detailed information, which determines explicitly how the data is to be obtained from the underlying database. This is supported by explicit specification of queryUnits and joins between queryUnits or specification of joins between entities.
The query engine 30 generates SQL, and applications is given access to the generated SQL.
The connection to the DBMS 4 supports attaches to multiple databases, such that queries may be specified to obtain data from multiple databases. The DBMS 4 enforces compliance with a standard for table name qualification, e.g., the SQL-92 standard's 4-level table name qualification. According to the SQL-92 standard's 4-level table name qualification a table is contained in a schema, a schema is contained in a catalogue, and a catalogue is contained in a database. The mapping of these 4 levels for a specific database may be performed by the Universal Data Access (UDA/DMS) component. For RDBMS that do not support the catalogue and/or schema qualification the table references will be generated such that these levels are omitted. UDA/DMS will provide a feature such that this can be done dynamically.
The query engine 30 is accessed through either the C++ callable interface or the automation interface. The querySpecification is a component constructed from a group of classes and can be stored in the repository. Two interface classes provide access to the query engine 30 at different levels of detail; these are the classes AQE I SimpleRequest and AQE I AdvancedRequest. The first interface provides a very coarse interface:
specify a query and execute it. The latter allows the application greater control over the execution of the components of the query engine 30, such as the Refine, Prepare, Execute and BuildMatrix steps. The advanced interface also allows applications to ask for the generated SQL.
The following are some general interpretation rules of the DBMS model made by the query engine 30. These rules are closely related to the rules for query specification data access.
1. The query engine 30 interacts at the business layer 2 of the metadata model 15.
Adding objects from the package layer, such as subjectltems, to a querySpecification will result in an exception.
2. The number of rows returned from an entity is the same regardless of the attributes that are selected from the entity.
3. When attributes of an entity refer to more than one physical dataSource, then there is an unambiguous join path between these dataSources.
4. The query engine 30 is able to uniquely identify the dataSource with the highest cardinality from the set of dataSources on which an entity is based.
5. Joins that are declared of type Containment have a low weight when calculating the join path, thus these joins are favoured to be included in the resultant query. A
relationship can be considered of type containment if there is a strong bond between two entities, such that the one entity does not exist without the other. For example the entity Orders contains the entity Order Details. i.e., it is not possible/likely to view an Order Detail record without the existence of an Order record. The cardinality is usually 1:1 to l :n, but can be relaxed to 1:1 to O:n.
6. Joins that are declared of type Reference have a high weight when calculating the join path. Thus these joins are not favoured for inclusion in the resultant query.
The probability of a calculated join path to 'go through' a reference entity (i.e.
an entity which has all joins of type Reference) is very low. Reference relationship is is a 'look-up' type of relationship of one entity to another. e.g., the entity Customer-Address may contain an attribute Country Code, which is used as the key into the Country entity. The relationship from Customer-Address to Country is a reference relationship, because from the perspective of the Customer-Address information it provides additional descriptive information. The cardinality of these types of relationships is usually l :n to 1:1, but can be relaxed to O:n to 0:1.
7. The filter property of an entity will be added by the query engine 30 to the querySpeci~cation using the AND operator, thus further restricting the result set. The query engine 30 will always add these filters to the where-clause of any generated SQL.
8. The filter associated with the relationship between userClass and (entity or attribute) will be added by the query engine 30 to the querySpecification using the AND
operator. This operation will be applied recursively to the supertype of the entity.
9. The previous rule is applied for all the ancestors of the userClass.
10. If the added filter (see rules 7, 8 and 9) contains an aggregate operator then it is interpreted as a 'summary' filter.

11. If the added filter (see rules 7, 8 and 9) does not contain an aggregate operator then it is interpreted as a 'detail' filter.
An example of a violation of rule 4 is modelling the 3 tables: employee, skills and billings in a single entity as shown in Figure 42. The relationships between these tables reflect that an employee may have more than one skill record and more than one billing record.
Thus the cardinality between the employee and skill tables is 1:1 to O:n. The cardinality of the relationship between the employee and billing tables is also 1:1 to O:n. This allows for some employees to be recorded without either skills or billing records. However every skill or billing record relates to one and only one employee. It is a violation of rule 4 to create an entity that defines attributes that use all three tables, because the query engine 30 can not determine the dataSource with the highest cardinality. In other words: it can not calculate the driver table for this entity.
An expression containing references to objects may be restricted in that all the referenced objects are children of the same type. In other words expressions are based on either all attributeslattributeProxies or columns. Expressions that contain both attributes and columns will cause an exception to be thrown.
Query Specification 5 The querySpecification is a compound object modeled in DBMS 4. This allows queries, similar to the Impromptu dataset, to be defined in DBMS 4 and referenced in other queries.
The two aspects of a querySpecification are the data layout and the data access. The data layout is encapsulated in the concepts of edges, levels and dataAreas. Data access is encapsulated by queryUnits and join information.
Query Specification Layout The query specification layout consists of the following major classes:
querySpecification edge ~ level dataArea (a.k.a. DimensionDataArea) queryltem Key Sort ~ DataArea (MeasureDataArea) queryltem Sort These classes define which data is to be retrieved and how the data is to be organized to facilitate rendering by the application. The use-cases show how to these classes and their relationships are used. Hereafter, the terms edge and dimension are considered equivalent.
The QuerySpecification allows for zero to n-dimensional queries to be defined.
The various component classes of a querySpecification are created using constructor blocks, a concept of the COS component of DBMS 4. The addition of an edge to a querySpecification automatically creates an 'Overall' level for that edge. The addition of a level to an edge will cause the creation of a dataArea for that level. The dataArea associated with a level is often referred to as a dimensionDataArea.
The definition of a dataArea for the querySpecification allows for the specification of one level from each edge defined in the querySpecification. The dataArea associated with the querySpecification is often referred to as a measureDataArea.
Defining a measureDataArea and specifying only one level is similar to using the dimensionDataArea that is defined for the level provided that the usage property of this measureDataArea is set to kInHeader. When using the dataMatrix interface to obtain results, each dataArea requires a separate iterator. It may be defaulted such that level identification will be the 'overall' level of the edges for which no level was identified.
It is preferable that each dataArea definition has a usage property, which can have one of the values (kInHeader, kInFooter or kInDetail). This property indicates how the application intends to use the data that is returned for the dataArea. Besides this, it also has impact on the amount of data returned for the dataArea. The usage property of a dimensionDataArea can only be set to kInHeader or kInFooter. The usage property of a measureDataArea can be set to any of the defined values. kInHeader: the results are to be available when the first row of data for a given key-value of a level is available. The application will only process one row per key-value. kInFooter: the results are to be available when the last row of data for a given key-value is available. The application will only process one row per key-value. kInDetail:
multiple rows of result data are expected per combination of key-values defined for the measureDataArea. The the Query Engine uses this information to interpret the number of rows that the application expects. In addition it allows the the query engine 30 to turn extended aggregate expressions into running aggregate expressions as long as the results are consistent. The latter feature is only applicable for dataAreas where the usage property is set to kInFooter. It may be defaulted such that for dimensionDataAreas the usage property is kInHeader; for measureDataAreas.
All dimensionDataAreas associated with application defined levels contain at least one queryltem. The querltem contains an expression made up of queryUnitltems, attributes and queryltems. It may be defaulted such that the level will be ignored. Any measureDataAreas that reference such a level will be in error and it is likely that an exception will be thrown.
All dimensionDataAreas associated with application defined levels identify one and only one of its queryltems as the key. It may be defaulted such that the key will be the first queryltem of the dataArea. All dimensionDataAreas associated with the automatically created 'overall' levels do not contain any key definition. The query engine 30 will ignore any key definition in these objects.
The queryltems associated with a dimensionDataArea are usually called properties. It is suggested that join relationships between the entity of the key queryltem and the entities of the other queryltems for a given dimensionDataArea has a cardinality of {0,1 }
: { l,n} to {0,1 } :1 (This allows for left-side cardinalities 0:1, O:n, 1:1, l :n and a right-side cardinalities of 0:1 or 1:1 ) . If the cardinality does not match one of the allowed values then the generated SQL will use the FIRST set function ( a SQL extension) to reduce the cardinality. Note that a left-outer join will be used in the cases that the right-side cardinality has a minimum value of 0. A left-outer join preserves the unmatched rows of the column on the left of the join (In PowerHouse syntax: Access A link to B optional). A right-outer join preserves unmatched rows of the table on the right of the join.
All dataAreas that return more than one set of values contain a sort order.
The dimensionDataAreas associated with the automatically created 'overall' levels are usually single-valued and thus do not require a sort order. It may be defaulted such that the queryltem identified as the key will be the sortltem and the sort direction will be ascending.
If the collection of sortltems specified for a dimensionDataArea does not contain a reference to the key queryltem then the queryltem that is referenced by the key will be added to the end of the sort specification with a sort direction of ascending.

The application can request the SQL statement for one of the following components:
querySpecification, edge, level, dimensionDataArea and measureDataArea.
Requesting the SQL for a dimensionDataArea is the same as requesting it for the level.
The application can execute the Refiner component for a given queryRequest.
The application can provide the functionality to select a join path for those cases where the Refiner determines that there are multiple join paths possible between the entities that are involved in the query. It may be defaulted such that the Refiner determines the join path using a shortest path algorithm, which allows weights to be assigned to each join. The lightest path will be chosen. If multiple paths have the same lightest weight then the first one calculated by the Refiner will be selected, which from an application perspective is a random select.
Query Specification Data Access The querySpecification data access consists of the following major classes:
~ querySpecification queryUnit queryUnitltem joins (model) joins (dynamic) ~ filters Multiple queryUnits can be specified, each containing one or more queryUnitltem objects Default: Each querySpecification has a default queryUnit, which is used to contain all the queryltems that do not explicitly reference a queryUnit. A queryUnitltem object references a single attribute or a single filter (both from the Business Layer) Note that these objects do not contain an expression, but exist of merely a reference to another object.
QueryUnitltems are referenced in the queryltem expressions. All attributes that are used in expressions that do not relate to a queryUnitltem will be assumed to belong to a queryUnitltem that belongs to the default queryUnit If the same entity is used in multiple queryUnits then these are considered separate instances.
This rule is carned forward to the generated SQL statements, which will contain multiple references to the same dataSources (tables, views, flat files, etc.) that are used by the query.
The prudent use of this rule will allow applications to create dynamic aliases/subtypes for entities.
Join resolution will first take place within a queryUnit and subsequently between queryUnits.
Joins that are defined in the Business Layer can be added to a query specification to give these joins a preference to be included in the join path when the join path for a query is calculated. This is not a guarantee that the join will be included.
Joins between entities can be explicitly specified. This is a completely dynamic join for which no information needs to be stored in the Business Layer. The join expression may contain references to QueryUnitltems.
Multiple filters can be specified and are interpreted as narrowing the selection, i.e. these are And-ed. A Boolean expression containing aggregate operators may be specified as a 'summary' filter. It may be defaulted such that the filter is marked as a 'summary' filter if the expression contains an aggregate operator.
A Boolean expression that does not contain aggregate operators may be specified as either a 'detail' filter or as a 'summary' filter. It may be defaulted such that the filter is marked as a 'detail' filter if the expression is void of aggregate operators.
The query engine 30 supports the Impromptu concept of prefilter and postfilter calculations for nested aggregate computations in the presence of summary filters. It may be defaulted such that postfilter results are calculated for aggregate computations, meaning that the aggregate operators applied to aggregates are calculated after the summary filters have been applied. Note that the summary filters may contain any Boolean expression.

Data Matrix The dataMatrix classes define an organization of the retrieved data.
Applications are not restricted to this method of obtaining data, they may opt to obtain the generated SQL and pass this information directly on to DBMS 4. The generated SQL contains 4-part table references, thus the application is required to have a multi-database connection with DMS.
This can be obtained using either the sqlAttach or the sqlMultiDbAttachDirect calls.
The dataMatrix is well suited for applications that require a multi-dimensional view of the data. Various iterators are defined to access the individual components in the dataMatrix.
Query Engine Components Both a simple and a more detailed interface are supported to access the components of the query engine 30. The query engine 30 has the following components querySpec~catdefines the data and organization of the data to be returned to the ion application.

Re mer applies defaults for missing/unspecified information, performs join path resolution based on the information in the DBMS 4 repository.

Planner allows for a bidding process of various Data Providers and Integrators to determine the best method of obtaining the data.

Execution executes the query and stores the results in a data matrix.

dataMatrix storage of and access methods for the retrieved data Refiner The Refiner component of the query engine 30 completes the query. It applies various defaults and rules to the querySpecification to make it semantically precise.
Complete Aggregate Operations Aggregate operations are commonly specified without break clauses. The break clauses can be derived from the level information for which the expression is specified.
Thus specifying in a level that is keyed by Customer Number, the application may define a query item as total(Order Detail.Quantity auto). This step of the Refiner will translate this into:
XSUM(Order Detail.Quantity for Customer.Customer Number).
The aggregate operators defined in DBMS 4 fall into two categories:
1. Those that return a single value for each row of the set of rows involved in the calculation. These aggregates are closely related to standard aggregates. Both Impromptu and DBMS 4 give the user the illusion that standard aggregates are not available. This is just a simplification of the user interface. The functions in this category are:
- total (xsum or sum) - minimum(xmin or min) - maximum (xmax or max) - average (xavg or avg) - count (xcount or count) - count rows (xcount or count*) - XFirst (not exposed to user) 2. Those that return potentially different value for each row of the set of rows involved in the calculation. These functions are also referred to as OLAP functions.
There are no equivalents in SQL 92 for these functions, though some database vendors have started to support equivalent functions. The functions in this category are:
- Rank (Xrank) - Percentile (Xpercentile) - Quantile (XNTILE) - Quartile (XNTILE with second argument=2) - Tertile (Xtertile) - Percentage (Xpercentage) - Standard-Deviation (XstdDev) - Variance (XVariance) - Running-total (Rsum) 3 0 - Running-minimum (RMin) - Running-maximum (RMax) - Running-average (RAverage) - Running-count (RCount) - Running-difference (RDifference) - Moving-total (XMOVINGSUM) - Moving-average (XMOVINGAVG) The interpretation of the auto option for these two groups is different. The notes here are only valid for zero and one-dimensional queries.
1. first group of functions (aggregates returning one value for a set of rows): replace auto with a for-clause containing the key expressions of the levels for which the dataArea is defined (either the measureDataArea or dimensionDataArea) 2. second group of functions (aggregates returning a different value for each row in a set) replace auto with a for-clause containing the key expressions of the next-higher level for which the dataArea is defined. If the expression containing the auto clause is belongs to the highest level of an edge, then it will be used as the level, i.e. it will result in an empty for clause .
Remove Redundant breakclauses The break-clauses in explicitly specified expressions will be evaluated to remove redundant levels. Given a submodel Customer----Order----OrderDetail as in the Use Cases, then the expression XSUM(Order Detail.Quantity for Customer.Customer Number, Order.Order Number) contains the redundant break level Customer.Customer Number.
The rule for this removal depends on the cardinality of the relationships between the entities to which the attributes in the break clause belong. The left to right cardinality of 1:1 to l :n allows the removal of the break clauses to the left. In this example an OrderDetail record is uniquely identified by the OrderNumber and LineNumber, the Customer Number does not add any value in uniquely identifying an OrderDetail record. Grouping at the OrderNumber does not require the inclusion of the Customer Number. This step simplifies the expression and allows for better query formulation.

7g Determine the Join Path The calculation of the join path to use for a query depends on the relationships defined in the Business Layer and the join information defined in the querySpecification.
Each path segment is assigned a value in the following order from light to heavy weight:
1. Joins referenced in the query specification 2. Joins defined in the query specification 3. Joins of type containment 4. Joins of type association 5. Joins inherited from the super type of an entity 6. Joins of type reference The join path with the lowest overall weight is the considered to be the preferred path and will be chosen if multiple paths are possible. Applications may override this selection method.
SQL generation The query engine 30 will generate semantically precise SQL. It will rely on DMS to perform additional transformations on the generated SQL to optimize the retrieval of data and the requested computations. The query engine 30 will not generate queries containing standard aggregates, with having- and group by- clauses. It will rely instead on the DMS
transformation that allows the conversion to standard aggregates.
For example:
select distinct PNO, XSUM(QTY for PNO) from SUPPLY
is transformed by DMS to:
select PNO, SUM(QTY) from SUPPLY group by PNO
Logging The results of initialization steps performed by the query engine 30 are logged to a file. The results of the execution of the query engine 30 components are logged to a file. The log file location, filename, and default log level (amount of detail recorded in the log file) are stipulated by User Configuration settings. On Win32 platforms, these settings are stored in the system Registry.
Use Cases The SQL listed here as being generated by the query engine 30 is for illustrative purpose only. The actual generated SQL may or may not match what is shown here. The uncertainty is in the many features that can be added to the planning of queries, including optimizations that still need to be determined.
Customer Use Case The model The model used in the examples described in this section has the following set of entities and attributes, which is loosely based on the Great Outdoors database.
roduct Customer Order ~~~ Order tatus etail Product Id Customer Order NumberOrder Status Code Number Number Product Customer Customer Line Category Name Name Number Number Unit Price Customer Sale Status Product Name Id Status Product [Status Code][Status Code]Quantity Description Status [Status Line Code] Amount For the purpose of this example, it will assume that the Status.Status Code is a one character field and the Status.Name is a short name, e.g. ('A', 'Active'; 'C', 'Closed'). In the underlying database, both the Status Code and Name of the Status table could be defined as unique keys. More importantly the Business Layer reflects reality and defines the attributes for these columns as keys.

The status attributes in the entities, like Product.Product Status, Customer.Customer Status and Order.Order Status, are expressions that refer to the Name attribute of the sub-entities of the Status entity.
The bracketed attributes [Status Code) in the above table are present in the entity, but are not 5 exposed through the subject in the Package Layer. Though this is not a requirement, it does reduce unuseful attributes. This means that the user can not select these attributes in the application, though they do exist in the model. These attributes are required in the model to define the join relationship to the Status entity.
10 The following sub-entities are defined.
roductStatus OrderStatusCustomerStatu Status Code Status CodeStatus Code Category Category Category Name Name Name 15 Description DescriptionDescription The entity Relationship diagram for this model is displayed in Figure 43. Note that none of the relationships have optional sides.
20 The joins in this model are defined as:
eft 'ght Entity eft fight eft Attribute 'ght ntity Card Card ttribute n....4~~-_~/'~ 1 ~~~--_~- ~.u..l ~.~ ~:n customer. Vrder Customer Customer Number Number Order Order Detail1:1 l Order. Order Detail.
:n Order Number Or er Number 25 Order Product l :n 1:1 Order Detail. d Produc Detail Product Id Product Id Customer Customer l:n 1:1 Customer. CustomerStatus Status Status Code Status Code Order Order Statusl:n 1:1 Order. OrderStatus.

~ ~ Status Code ~ Status Code Product Product l:n 1:1 Product. ProductStatus.
Status Status Code Status Code The business model is based on an underlying database with the following layout:
RODUCT CUSTOMER ORDER ~ ORDER DETAIL TATUS

PROD ID _ ORDE
CUST NO

_____ _ __ _ R_NO O_RD_ER _NO STATUS_CODE
PROD _NAME ~ CUST _NAME' CUST ~_NO ~~ LINE_NO TABLE_ID
UNIT PRICE STATUS CODE STATUS CODE PROD _ID STATUS_NAME
STATUS CODE QTY DESCR
AMOUNT
The attributes map in most cases one for one to the columns in the physical layer. The STATUS table contains the status information for the whole database and has a unique key based on the two columns STATUS CODE and TABLE ID. These two columns are mapped to the attributes Status Code and Category with the following definitions:
attribute [Status Code] - Column[STATUS.STATUS CODE]
attribute [Category] - Column[STATUS.TABLE ID]
Note how there are filters applied at the category level in order to subtype the Status entity.
A zero dimensional query QuerySpec [Customer Information]

MeasureDataArea [Customer Info]

QueryItem [Number) = Attribute [Customers.Customer Number]

QueryItem [Name] = Attribute [Customers.Customer Name]
i QueryItem [Status] = Attribute [Customers.Customer Status) ~ Sort .-' SortItem [) = QueryItem [Number] ASC
i Note that the sort specification references a queryltem, the notation used here uses strings, which matches the name given to the first queryltem. This type of specification is supported by the quern en~,, ine 30 automation interface. The application can ask for the SQL statement for this query using the method :CogQE::I AdvancedRequest(const CogCS::BaseId&
queryComponent) Since this query contains only one result set, namely at the QuerySpecifrcation level, the only valid call to this method requires the BaseId of the QuerySpecification to be passed.
The returned SQL will look like as follows:
select Tl.CUST NO, T1.CUST NAME, T2.STATUS NAME

from GoDatabase. . .CUSTOMER T1, GoDatabase. . .STATUS T2 where T1.STATUS_CODE = T2.STATUS CODE

and T2.TABLE ID = 'C' order by T1.CUST NO

A zero dimensional query with filters The following query is similar to the previous one, except that the resultset is narrowed down by the application of two filters.
QuerySpec [Old, Active Customer Information]

MeasureDataArea [Customer Info]

QueryItem [Number] = Attribute [Customers.Customer Number]

QueryItem [Name] = Attribute [Customers.Customer Name]

QueryItem [Status] = Attribute [Customers.Customer Status]

Sort -' SortItem [] = QueryItem [Number] ASC

Filters FilterItem [Old Customers) Expression = Attribute [Customers.Customer Number] < 50,000 FilterItem [Active Customers]

Expression = Attribute [Customers.Customer Status] _ 'Active' The returned SQL will look like select T1.CUST NO, T1.CUST NAME, T2.STATUS NAME

from GoDatabase. . .CUSTOMER T1, GoDatabase. . .STATUS T2 where T1.STATUS CODE = T2.STATUS CODE

and T2.TABLE ID = 'C' and T1.CUST NO < 50000 and T2.STATUS NAME = 'Active' order by Tl.CUST NO

A one dimensional query Dimensional queries are used if grouping takes place. For each level a number of properties can be requested. Summary expressions are also good candidates for properties, see the queryltem "Total Ordered Quantity" in the Customer level.
QuerySpec [Old, Active Customer Information]
[Customer]
Level [Customer]
~- QueryItem [Number]

Expression = Attribute [Customers.Customer Number]

QueryItem [Name) Expression = Attribute [Customers.Customer Name]

QueryItem [Status]

Expression = Attribute [Customers.Customer Status]

QueryItem [Total Ordered Quantity]

Expression = total( Attribute [Order Detail.QuantityJ auto) Key [] = QueryItem [Number]

Sort SortItem [] = QueryItem [Number] ASC

MeasureDataArea [Order Info] for { Level [Customer.CustomerJ

QueryItem [Order] expression = Attribute [Orders.Order Number) QueryItem [Order Status] expression = Attribute [Orders.Order Status]

Sort SortItem [] = QueryItem [Number) ASC

The application has the option of retrieving the data as a single resultset or as multiple resultsets. The lowest granularity of resultsets is based on a dataArea. In this query there are two dataAreas. There are three different datasets that can be returned to the application.
Use the Id of the guerySpecification Use the Id of the level named "Customer"
Use the Id of the measureDataArea named "Order Info"
MeasureDataArea SQL
The SQL for the measureDataArea named "Order Info" will look like select T1.CUST NO, g$
T2.ORDER-NO, T3.STATUS NAME

from GoDatabase. . .CUSTOMER Tl, GoDatabase. . .ORDER T2, $ GoDatabase. . .STATUS T3 where T1.CUST NO = T2.CUST NO

and T2.STATUS CODE = T3.STATUS_CODE and T3.TABLE ID = 'O' order by T1.CUST NO, T2.ORDER NO

The attributes and entities have been mapped to the appropriate underlying tables The filter that is on the subtype entity Customer Status shows up in the where clause The tables have 4-part names Level SQL
The SQL for the Level named "Customer" will look like:
1$ select distinct TI.CUST NO, T1.CUST NAME, T2.STATUS NAME, xsum (T4.AMOUNT for T1.CUST NO) as Total Ordered Quantity from GoDatabase. . .CUSTOMER T1, GoDatabase. . .STATUS T2, GoDatabase. . .ORDER T3, GoDatabase. . .ORDER DETAIL T4 where T1.STATUS CODE = T2.STATUS CODE and T2.TABLE ID = 'C' 2$ and T1.CUST NO = T3.CUST NO

and T3.ORDER NO = T4.ORDER NO

by T1.CUST NO
Note the distinct option on the select statement, this appears because it is a level related query.
The general purpose function total has been translated to an XSUM
The quern en. ine 30 will likely be improved to generate SUM with a GROUP BY
instead of the XSUM
The rename of the XSUM expression to Total_Ordered-Quantity is based on the queryltem name, the query en ine 30 may take a shortcut implementation and use abbreviated names such as cl, c2 instead.
QuerySpec SQL
The SQL for the whole querySpecification will look like as below, note that it includes an alias for the STATUS table, since both the Customer and Order entities need this information.
select distinct TI.CUST NO, T1.CUST NAME, T2.STATUS_NAME, xsum (T4.AMOUNT for T1.CUST NO) as Total Ordered_Quantity, T3.ORDER NO, TS.STATUS NAME

from GoDatabase. . .CUSTOMER T1, GoDatabase. . .STATUS T2, GoDatabase. . .ORDER T3, GoDatabase. . .ORDER DETAIL T4, GoDatabase. . .STATUS TS

where T1.STATUS CODE = T2.STATUS CODE and T2.TABLE ID = 'C' g7 and T1.CUST NO = T3.CUST NO

and T3.ORDER NO = T4.ORDER NO

and T3.STATUS CODE = TS.STATUS CODE and TS.TABLE ID = 'O' order by T1.CUST NO, T3.ORDER NO

All the data for both dataAreas is returned in a single result set. The application will be responsible for organizing it correctly.
Note the alias for the STATUS table, both T3 and TS
The order by clause of the select statement uses the ordering from first edge to last edge and then the measureDataAreas in order of occurrence. Within each edge, the sort specification of each level is picked up in the order that the levels are defined.
Aliases in Practice Use Case This Use Case illustrates the applicability of generating queryUnits in a query Specification, which is the method to create aliases outside of the DBMS model.
Physical Layer Consider a Physical Layer with 3 tables, as shown in Figure 44. The table to focus on is the Shipment table. Each shipment is associated with a customer and each customer may have multiple shipments. Each shipment is related to the Address table via the FromAddress and the ToAddress fields of the shipment table.
Business Layer The Business Layer is in essence a one for one mapping from the Physical Layer. The Business Layer does not include subtypes for Address entity, even though it is used in two ways. Thus the Business Layer consists of 3 entities and 3 Join Relationships.
Query Specification For the purpose of this example the user wants a list style report, which contains the following information:

8g Customer Customer number Customer name Shipment all shipments for the customer Shipment date For the FromAddress:
Street City For the ToAddress Street City There are two parts to the querySpecification. The data-access part and the data-layout part.
1. The data-access part complements the Business Layer and gives additional specifications on how the data is to be related for this report. It is a reflection of information that is gather by the application from the user based on information in the Package Layer of the model.
2. The data-layout part is closely related to the way the data is presented to the user. It depends on how the user interacts with the application that will display the data.
Data-access This part of the query Specification is used to specify that this query needs to use the Address entity twice. It also needs to specify how these two instances are related to the other entities in the query. Thus the minimal specification consists of:
QuerySpec [one]

QueryUnit [ToAddress]

QueryUnitItem [Street] expression = Attribute [Address.Street]

QueryUnitItem [City] expression = Attribute [Address.City]

QueryUnitItem [address code] expression = Attribute [Address.Address Code]

QueryUnit [FromAddress]

QueryUnitItem [Street] expression = Attribute [Address.Street) QueryUnitItem [City] expression = Attribute [Address.City]

QueryUnitItem [address code] expression = Attribute [Address.Address Code]

DynamicJoin [Shipment 13> ToAddress) LeftEntity = Entity [Shipment]

RightEntity = Entity [Address]

LeftCardinality = l:n RightCardinality = 1:1 Expression -Attribute [Shipment.to address code] _ QueryUnitItem [one.ToAddress.address code]

DynamicJoin [Shipment 13> FromAddress) LeftEntity = Entity [Shipment ]

RightEntity = Entity [Address]

LeftCardinality =l:n RightCardinality =1:1 Expression -Attribute [Shipment.from-address code] _ QueryUnitItem [one.FromAddress.address code]

Data-layout This query can be considered a one-dimensional query. It is important to note that the queryltems contain expressions that reference the queryUnits that were declared in the Data-5 access part. This is not a requirement in order to refer to the attributes from entities for which no queryUnit has been specified. The implication is that if a queryUnit is not specified, then the attribute will be considered to belong to the default queryUnit and thus there will only be a single instance of that attribute in the query.
Edge [Customer]

10 ~ Level [Customer]

QueryItems QueryItem [Customer Number]

Expression =Attribute [Customer.Customer Number]

QueryItem [Customer Name]

15 Expression =Attribute [Customer.Customer Name]

Key [] = QueryItem [Customer Number]

MeasureDataArea [] for { Level [Customer.Customer] }

QueryItems QueryItem [Date]

20 Expression = Attribute [Shipment.Departure Date]

QueryItem [From Street]

Expression = QueryUnitItem [FromAddress.Street]

QueryItem [From City]

Expression = QueryUnitItem [FromAddress.City]

QueryItem [To Street]

Expression = QueryUnitItem [ToAddress.Street]

QueryItem [To City]

Expression = QueryUnitItem (ToAddress.City]

The above querySpecification illustrates:
1. queryUnits - specification of the set of attributes that you want to get information from 2. Relationships between queryUnits - these are added to the querySpecifrcation as dynamic joins.
A number of other items to note:
1. Expressions can reference the attributes that are defined in a queryUnit.
These are indicated in the above text with queryUnitltem[]
2. Filter expressions added to the querySpecification filter collection may also contain references to queryUnitltems. This is handy for example if you want to construct a filter to select only inter-city shipments. e.g.:
QueryUnitItem[one.ToAddress.City] O QueryUnitItem[one.FromAddress.City]
3. A queryUnit is usually related to a subject in the Package Layer User View and Navigation of the Model The user is presented with a view of the business that will allow for easy and correct formulation of complicated queries. There are many possible approaches to the user interface. Two examples are described below, one based on a tree-view dialog, the other based on a diagram approach. In both cases the user will be displayed with information that is defined in the Package Layer. It is the responsibility of the reporting/query application to present the user with information in the Package Layer not the Business Layer.
The user is allowed to select from the presented information, organize it and formulate a report based on it. The application is to translate the selected information and how the user has organized it into a query Specification, which is in terms of the Business Layer.
Giving the application the responsibility of translating the Package Layer into a query based on Business Layer terminology may seem inappropriate, but provides for a greater level of flexibility in the types of queries that can be formulated. The two approaches described here are an attempt to illustrate that. Note that the Package Layer consists mainly of two concepts:
a Folder structure and a set of references to objects in the Business Layer.
Tree View Dialog This example displays a tree view of the Subjects and their relationships in the model. A
Subject may be related to one or more Subjects. This relationship also identifies the join (from the Business Layer) on which this relationship is based. These relationships can be used in the Tree View Dialog for navigation. Subjects can be organized in a folder structure.
The following tree view uses » to indicate that a subject in a folder and it uses the <o> to indicate a relationship between two subjects.
CustomerShipments -- this is a folder containing a number of subjects.
» Customer -- based on entity [Customer]
Name -- subject item referencing attribute [Customer.Name]
Number <o> Shipments -- relationship from Customer to Shipments Date <o> ToAddress Street City <o> FromAddress Street City » Address Street City » Shipments Date <o> ToAddress Street City <o> FromAddress Street City - 10 <o> Customer Name Number Diagram 15 The initial view of the business based on the abstraction in the Package Layer may show a diagram showing the subjectFolders and subjects at the root level of the Package Layer.
These usually relate directly to the major components of the business. In the model used in this example the Customer and Shipment subjects are likely candidates. The Address subject is more or less fulfilling a supporting role and is not a good starting point for most queries.
The user could select one of the core subjects and get a context diagram, which shows two layers of subjects and the relationships between them. If the user selected the Shipment subject as the center of his universe, then the diagram may be as shown in Figure 45. The diagram shown in Figure 45 is not the most interesting, so adding a few more subjects and relationships gives the.diagram shown in Figure 46.
As can be seen there are number of loops in this diagram, which by the way, are all very valid. The challenge for the reporting/query formulation tool is to allow the user freedom in selecting what is needed. i.e. the user is able to select some subjectltems from the Shipment subject. Selecting data from just one Subject does not pose a great difficulty.

The diagram shown in Figure 46 shows 5 relationships to the Address subject.
The least interesting seems to be the Address to Country relationship. The user is able to perform an action to the Address object on the diagram so that is splits out into a number of distinct subjects (which map to the queryUnits in the querySpecification).
Let's assume the diagram shown in Figure 47 is obtained. Observe that the Address subject is split into 4 Address subject and not 5. There could be 2 reasons for this:
The Country subject is in the outer circle i.e. the focus of the diagram has been changed to Address in order to pull in an alias for the Country subject. The cardinality of the relationship between Address and Country, base on a join in the Business Layer, is N to 1, where the other four relationships e.g. Address to Shipment (ToAddress) are 1 to N. Actually there are two 1 to N
relationships between the Address and the Shipment subjects.
There is no objection to packaging the information in a more user-friendly form as depicted in the following diagram. It is also feasible for the Package Layer to allow drill-down into the categories of information.
A CrossTab Report The same data that is used in this Use Case can also be presented in a cross-tab report. This report has all the from-addresses as rows and all the to-addresses as columns.
The cells of the report contain the number of shipments. For this type of report only the data-layout portion is changed. There is no need to change the data-access portion of the report, since the data that is to be reported is essentially the same.
Edge [FromAddress]

Level [City]

QueryItem [FromCity]

Expression = QueryUnitItem [one.FromAddress.City]

Edge [ToAddress]

Level [City]
QueryItem [ToCity]
Expression = QueryUnitItem [one.ToAddress.City]
MeasureDataArea [] for { Level [FromAddress.City], Level [ToAddress.City] }
QueryItem [count(shipments)]
Expression = Attribute [Shipment.ShipmentId]
This query also refers to the Address twice, once as ToAddress and once as FromAddress.
10 The queryUnit of the data-access part of the query Specification nicely accommodates this requirement.
While the present invention has been described in connection with what is presently considered to be the most practical and preferred embodiments, it is to be understood that the 15 invention is not limited to the disclosed embodiments. To the contrary, the present invention is intended to cover various modifications, variations, adaptations and equivalent arrangements included within the spirit and the scope of the appended claims.
The scope of the claims is to be accorded the broadest interpretation so as to encompass all such modifications and equivalent structures and functions.

Claims

WHAT IS CLAIMED IS:

1. A database management system for managing a database, the database management system comprising:
a metadata model having a physical layer for receiving source data from the database, and a business layer for containing metadata which has business intelligence;
and transformations for transforming the source data received in the physical layer into the metadata in the business layer by adding the business intelligence to the source data.

2. A database management system as claimed in claim 1, wherein the transformations comprise:
physical model transformations for transforming the source data into a physical model in the physical layer; and business model transformations for transforming the physical model into a business model in the business layer.

3. A database management system as claimed in claim 2, wherein the metadata model further comprises a presentation layer for containing presentation folders, and the transformers further comprise a presentation model transformations for transforming the business model into a presentation model in the presentation layer.

4. A database management system as claimed in claim 2, wherein the database contains interrelated tables and the source data includes physical definitions of the database, and the physical model transformations transform the tables using the source data.

5. A database management system as claimed in claim 3, wherein the physical model transformations include one or more of transformations for constructing join relationships, physical keys for tables, table extracts, and physical cubes.

6. A database management system as claimed in claim 3, wherein the business model transformations comprise one or more of transformations for basic business model construction, fixing many to many join relationships, coalescing entities, eliminating redundant join relationships, introducing subclass relationships, referencing entities, determining attribute usage and identifying date usage.

7. A database management system as claimed in claim 1 further comprising:
a query engine which creates a query based on a request for information using the business intelligence in the business layer of the metadata model.

8. A database management system as claimed in claim 7, wherein the query engine includes a query specification which allows queries to be defined in the metadata model.

9. A database management system as claimed in claim 7, wherein the query engine comprises an engine for simplifying query expressions using cardinalities in the business layer.

10. A database management system as claimed in claim 7, wherein the query engine comprises an engine for forming a query using a reference relationship between two entities in the business layer.

11. A database management system as claimed in claim 7, wherein the query engine comprises an engine for determining a drive table using cardinalities in the business layer.

12. A database management system as claimed in claim 1 further comprising:
common object services for determining framework for object persistence.

13. A database management system as claimed in claim 1 further comprising:
a metadata exchange for communicating with,an external metadata repository.

14. A method for generating a metadata model of a database, the method comprising the steps of:
obtaining source data from the database; and generating a metadata model by adding business intelligence to the source data.

15. A method as claimed in claim 14, wherein the generating step comprise:
transforming the source data into a physical model; and transforming the physical model into a business model.

16. A method as claimed in claim 15 further comprises the step of transforming the business model into a presentation model.

17. A method as claimed in claim 14, wherein the source data transforming step comprises any one or more of the steps of constructing join relationships, physical keys for tables, table extracts, and physical cubes.

18. A method as claimed in claim 14, wherein the physical model transforming step comprises any one or more of the steps of transforming for basic business model construction, fixing many to many join relationships, coalescing entities, eliminating redundant join relationships, introducing subclass relationships, referencing entities, determining attribute usage and identifying date usage.

19. A method for creating a report of a database, the method comprising the steps of obtaining source data from the database;
generating a metadata model by adding the business intelligence to the source data;
and creating a report based on a request for information using the business intelligence of the metadata model.

20. A method as claimed in claim 19, wherein the creating step comprises the step of using a query specification which allows queries to be defined in the metadata model.

21. A method as claimed in claim 19, wherein the creating step comprises the step of simplifying query expressions using cardinalities in the business layer.

22. A method as claimed in claim 19, wherein the creating step comprises the step of forming a query using a reference relationship between two entities in the business layer.

23. A method as claimed in claim 19, wherein the creating step comprises the step of determining a drive table using cardinalities in the business layer.