Developing an OLAP API Application

As an application developer, you perform the following steps to create an OLAP API application:

1. Decide on general design issues.
2. Decide on requirements for end-user queries.
3. Design OLAP API Template objects that create end-user queries. This is an optional step.
4. Write and test the Java code for the application.
5. Deploy the application to users.

The rest of this topic presents a general description of each step.

Step 1: Decide on General Design Issues

Consider broad questions such as the following:

• Will the application be a standalone application (two-tier architecture), or will it be divided, with end-user code on a separate tier from the data manipulation code (three-tier architecture)?
• Will the application always access the same known metadata (for example, describing employee data whose structure is constant), or must it discover what metadata is available every time it makes a connection?

Step 2: Decide on Requirements for End-User Queries

Specify, in as much detail as possible, the nature of the queries that the end user will be able to make. Because the OLAP API makes it possible to define queries in a step-by-step process, it is also important to decide on the query modification capabilities that the application will offer the user. Consider questions such as the following:

• By what criteria will the end user select data through the application's dialog boxes? For example, will the application present a list of dimensions? Can the user drill up and down on the hierarchy of a dimension? Are there attributes of dimensions that the user can specify for selecting data (for example, color or size)? Can the user make selections based on data values (for example, population over 20,000)?
• As the user refines a query through a series of steps, can the user undo a step in the process to return the query to an earlier state?
• As the user refines a query, can the user specify the scope of an undo request? For example, the undo request might apply only to the values of one field out of many in the selection dialog box.

Planning the end-user queries is a crucial step in the application design process, so you should complete it as thoroughly as possible. Ideally, you should create an end-user query model that identifies all the conceptual query objects with which the application user interface will deal. This strategy takes advantage of the strengths of object-oriented design, and it allows for a clear correspondence between user interface objects and OLAP API objects.

The following are examples of conceptual query objects for an application user interface:

• Dimension. This object has hierarchies on which the user can drill and attributes from which the user can select.
• Dimension selection. This object represents a selection of dimension elements.
• Edge. This object represents one side of a cube and has related dimension objects.
• Cube. This multidimensional object has related edge objects. It also has a related measure.

Each of these conceptual query objects can be represented by an OLAP API Template object.

Step 3: Design OLAP API Template Objects That Create End-User Queries

An optional step in implementing an OLAP API application is designing Template objects. This step is recommended because, the use of Template objects offers the following benefits:

• Dynamic queries. With a Template, you can create a modifiable query. That is, when you have created one query and you want to execute another one that is similar but not identical, you do not have to create an entirely new query. You simply make a small change to the existing query. Thus, the query is dynamic, rather than static.
• Refinement and rollback of queries. With a Template, you can capture a series of steps that a user has completed when specifying a query. Each step refines the query further and is recorded as a new query state. If the user decides to cancel one or more of the specification steps, you can rollback the query to an earlier state.
• Matching of code to user interface characteristics. When you design a Template, you can make it correspond directly to the operations that a user performs. For example, if your application includes a balance sheet, you can create a balance sheet Template that incorporates all the appropriate characteristics (such as a method of aggregation) and behaviors (such as automatic totalling).

For a more detailed example of how Template objects mirror the query-building aspects of an application's user interface, imagine an application that allows the user to create a three-dimensioned cube of data through the following steps:

1. Choose a measure whose data will be in the cube.
2. Select the values for each dimension that will provide structure to the cube.
3. Specify the placement of the dimensions on the three edges of the cube.

As the application developer for this interface, you would design a Template subclass for each of the following objects: dimension, dimension selection, edge, and cube. As part of the design, you would specify methods on the Template subclasses that allow you to combine objects as needed. For example, the edge Template class might have an addDimension method, and the cube Template class might have an addEdge method. Once you have implemented the dimension, dimension selection, edge, and cube Template classes, you can use them again and again in your application. They are basic building blocks in your application's code for querying and manipulating data.

In this stage of the application design process, you should make detailed specifications for each Template in the application. For information about designing Template objects, see Chapter 10, "Creating Dynamic Queries".

Step 4: Write and Test the Java Code for the Application

Up to this step, you have not written any Java code. You have considered questions about the design of your application, and you have made detailed specifications for the Template objects that your application will include. Now you must do the following to implement the application:

1. Set up the OLAP API client software on your development computer, as described in Appendix A, "Setting Up the Development Environment". If you are designing a three-tiered application, the development computer (from the OLAP API point of view) is the middle-tier computer.
2. Identify the data store that you will use for developing and testing the application. Ensure that the data is structured as a star or snowflake schema in an Oracle data warehouse, and ensure that the OLAP management feature in Oracle Enterprise Manager has provided the metadata.
3. Write the Java classes for your application, importing the OLAP API classes as needed. Among the Java classes that you write, include the Template classes that you designed.
4. Test your application using the test data store.

For information about coding an application that uses the OLAP API, see the subsequent chapters of this guide and the OLAP API Javadoc. See "Tasks That an OLAP API Application Performs" for a description of the tasks that an application typically performs.

Step 5: Deploy the Application to users

Keep the following in mind when you deploy your application:

• Include the OLAP API Java classes along with the ones that you have developed.
• Ensure that the user's computer (or the middle tier computer) has access to an Oracle database instance that includes the OLAP option.
• Ensure that the user has access to an appropriate Oracle data warehouse with metadata prepared by the OLAP Metadata APIs.
• Provide documentation for your application, giving installation instructions and explaining the user interface that you have created.