How Can I Extract My Essbase Outline to a SQL

Database?
By Chris Rothermel, Rothermel Consulting

This article highlights how a utility from Applied OLAP can save time
and development work by exporting Essbase outlines to SQL. Having
outline information in SQL makes Essbase outline information available
for ETL processes and also for historical comparison.

Alternatives
There are other options to export metadata to SQL such as:
Using IBM Cognos Integration Server (formerly Star Analytics
Integration Server)
A custom solution using the Oracle Data Integrator KM
o or the similar old Informatica KM that came with DIM
A custom solution using MaxL/XML parsed and loaded to SQL
loader
A custom solution using the Java API
All of these other solutions incur a cost of either complexity,
development time, or software license purchase. The Outline Extractor
really is a custom solution that uses the Java API; however, it is pre-
built and provided to the community for free. Instead of having to
make a build or buy decision, the Outline Extractor gives an even
simpler option: download. Thank you, Applied OLAP.

Overview
This article highlights the use of these three features:
1. Support for the super-fast MaxL Extracted Outline format
2. Configuring relational databases (RDBMS)
3. Configuring command line execution for automation

Use Cases
Run the Outline Extractor on a regular basis and keep historical
records of the extracts in a relational database so we can
monitor changes between dates
Use the information in the SQL tables to provide to ETL process
Perform ad hoc queries on the metadata
Step 1 Download the Outline Extractor
Navigate to AppliedOLAP.com / Resources / Free Tools / Outline
Extractor / Download Now

View files and download the latest one.

Step 1 Summary
The tool is provided by Applied OLAP and is free of charge.
Download the latest version.
Step 2 Install and Launch the Outline Extractor
The tool was written in Java, and all it needs to for installation is to be
unzipped. Make sure you put it in a directory where you have full
read/write/execute permissions. I encountered trouble on a client PC
when I put it in the C:\Windows\Program Files directory, so dont put it
there.

To launch, double-click the gui-olapunderground-outline-extractor.cmd

If the application complains about not knowing its JAVA_HOME, you
may need to modify the gui-olapunderground-outline-extractor.cmd file
to set the JAVA_HOME. Review the Applied OLAP instructions for further
detail. I modified mine as follows:

Step 2 Summary
Installation requires unzipping the file.
Java is required (chances are good you already have it installed)
and know your JAVA_HOME
Step 3 Test It by Exporting an Outline to a File
View the supplied documentation
(OutlineExtractorDocumentation.docx) to understand the process of
using this tool to export to a file. OTDUG members can also see Tim
Tows Kscope15 presentation on the utility.
Test: You should be able to use this utility to find Sample.Basic in
your environment and export all of the dimensions to a file.

Be sure to take advantage of the MaxL format, as this is a huge

performance improvement. Just how much faster is it? Daniel Gagnon
did a case study on this and found the speed improvement to be
100,000% .

There will be many files created by the Outline Extractor, and there are
many very useful formats.

Step 3 Summary
Follow the instructions provided and export an outline to a file
format.
Use the new MaxL Outline XML process because it is faster than
the older process.
o Thanks for the performance increase, Oracle!
Step 4 RDBMS Configuration
At Tim Tows Kscope15 presentation, I was most excited to learn the
tool has the ability to export to relational tables. It took some
additional configuration to get this to work with the Oracle RDBMS, and
Im writing to share what Ive learned.

The Outline Extractor has the ability to talk to many different relational
databases, but it may require some configuration. Microsoft SQL server
users will be happy to know they simply need to enter their credentials
into the tool and no other modification is need. Oracle users, however,
will need to download the specific Oracle .jar file to enable the Outline
Extractor to know how to communicate with an Oracle database.
Otherwise you will encounter this error message when you hit the
Commit & Test button:

To enable communication to Oracle RDBMS, download the appropriate

jar file from Oracle and put the file in the olapunderground/lib
directory with all the other jar files. I downloaded ojdbc6.jar because
Im running Java 1.6. Download the appropriate jar file for version for
your RDBMS and version of Java.

Next, update the gui-olapunderground-outline-extractor.cmd like the provided

instructions say to do. In my case, the name_of_jar.jar is ojdbc6.jar.
Instructions from Applied OLAP:
To write relational cache information to another type of database, the .jar
must be put in the lib/ folder, and then it must be listed in the runtime class-
path inside of gui-olapunderground-outline-extractor.cmd
Ex:
set GUI_CP=%GUI_JAR%;..........................
TO
set GUI_CP=lib/name_of_jar.jar;%GUI_JAR%;................

Restart the Outline Extractor and test to see the database connectivity
is now established, thanks to the jar file and path settings.

Open a new instance of the Extractor and you should be good to go.
Make sure you use the Commit and Test button and get a successful
connection as well.
Step 4 Summary
Additional jar files may be needed in the /lib directory to
establish RDBMS connectivity.
Modify the Outline Extractor command file to set
GUI_CP=lib/name_of_jar.jar if your RDBMS needs a jar file for
connectivity.

Step 5 Export to the RDBMS and Find the Tables

As we saw in Step 3, the utility can export the outline into many files. If
you have many outlines and plan on archiving outputs, youll end up
with hundreds of files to manage. It is much easier to access and
analyze large volumes of data in a relational database. To do this,
make sure youve set the Output Handler to Relational and have
configured the database correctly in Step 4. Execute the extract.
The Outline Extractor creates 5 tables.

The same type of information is in these tables as was exported in the

file format in Step 3.
Each successive time the RDBMS output is used for your extracts, the
Outline Extractor will create a version of it in the tables instead of
creating many new files. The tables are designed to store outlines for
an unlimited number of Essbase cubes and an unlimited number of
versions. Whats also nice is the utility automatically creates these
tables the first time it extracts to the target RDBMS. Of course the
RDBMS user ID must have the appropriate permissions to do this.

Save your export settings to a .PROPERTIES file that stores your

Essbase login credentials (encrypted), the Essbase database to be
exported, your database credentials (encrypted), and all of the other
options. The properties file can be reused later using either the GUI
utility or the command line utility.

Step 5 Summary
Tables are created by the Outline Extractor utility.
o Proper RDBMS permissions are needed by the user ID.
Properties files can be saved.

Step 6 Automation via the Command Line Utility

In addition to the gui interface, the Outline Extractor comes with a
command line interface. The command line interface is run using a
properties file. In order to use the command line utility with the Oracle
relational database, the manifest in the WAR file had to be updated.
Here are the instructions, thanks to the folks at Applied OLAP:
Open the olapunderground-outline-extractor.jar with WinRAR or
other compression utility.
Edit the MANIFEST.MF file to include the ojdbc6.jar (or whichever
driver that you downloaded) in the Class-Path.

Save the MANIFEST.MF file and replace the existing one.

The original olapunderground-outline-extractor.cmd file can be
modified to call multiple properties files. This single file can then either
be run on-demand or scheduled. In our environment we have it set up
to run every day, so we can compare outline changes in multiple
production cubes. This is similar to the SET GUI_CP = lib/ojdbc6.jar;
%GUI_JAR% statement in Step 4.

The job can then be executed at the command line, and it will perform
the outline extraction for all of the listed properties files.
Step 6 Sample SQL Queries

SQL queries can be written to answer questions about the cube such
as:
How many members are in the outline?
What are the L0 members in the outline?
What are the members with member formulas?

How many members for each dimension are in the outline?

SELECT version_id, DIMENSION_NAME, count(*)
FROM cached_outline_members mbr
,cached_outline_versions vrs
WHERE mbr.version_id = vrs.id
and vrs.id = (SELECT max(id)
FROM cached_outline_versions
WHERE APPLICATION = 'Sample')
GROUP BY version_id, dimension_name
----------------------------------------------
 VERSION_ID DIMENSION_NAME COUNT(*)

---------- ------------------ ----------

7460876 Caffeinated 3

7460876 Market 25

7460876 Year 17

7460876 Product 22

7460876 Pkg Type 3

7460876 Ounces 5

7460876 Scenario 5

7460876 Measures 17

7460876 Population 15

7460876 Intro Date 8

10 rows selected

What are the L0 members in the outline?

SELECT mbr.*
FROM cached_outline_members mbr
,cached_outline_versions vrs
WHERE mbr.version_id = vrs.id
and Level_Number = 0
and vrs.id = (SELECT max(id)
FROM cached_outline_versions
WHERE APPLICATION = 'Sample')
What are the members with member formulas?

SELECT Dimension_Name, Member_Name, Member_Formula

FROM cached_outline_members mbr
,cached_outline_versions vrs
WHERE mbr.version_id = vrs.id
and vrs.id = (SELECT max(id)
FROM cached_outline_versions
WHERE APPLICATION = 'Sample')
and member_formula is not null

When multiple versions have been stored in the database, queries

can be written to answer questions such as the following:
What hierarchy changes happened between the last two Outline
Extracts?
What property changes happened between the last two Outline
Extracts?
What attribute changes happened between the last two Outline
Extracts?

Thanks to:
Id like to echo Glenn Schwartzbergs comment that we all need to
thank Applied OLAP. In particular, Id like to thank Tim Tow and Jay
Zuercher at Applied OLAP. Special thanks to Jeff Cunningham, who
successfully tested these steps in his Essbase and Oracle RDBMS
environment and for finding my typos. Thanks also to ODTUG for
Kscope and giving me the opportunity to write this article. Please send
us a note if you have something you think the EPM Community can
benefit from.
APPENDIX A Screenshot of Sample.Basic Export and
Saving the Properties File