To demonstrate how the integration works, i will be using a simple report built in Web Analysis and expose that in Weblogic Portal. The procedure remains the same for HFR & IR as well. I chose Web Analysis for a couple of reasons

1. Its one of the most under-rated tools in the Hyperion Stack. Its one of the best tools in Oracle that provides excellent multi-dimensional analysis even on relational data. There are so many features that makes BI EE 10g look like a very simple analysis tool in comparison, atleast from a multi-dimensional analysis standpoint. Its major downside though is it does not scale very well & lacks a slick UI like BI EE.

2. HFR & IR both require windows clients. In my case, both my VM’s (one running EPM Workspace and the other running Weblogic portal) were on Oracle Enterprise Linux.

From a portal standpoint, i believe Weblogic Portal 10.3 is now superseded by the Webcenter Suite portal framework. I had to choose Weblogic to reduce the memory footprint on my VM’s. Somehow the SOA Suite 11g portal along with JDeveloper on OEL seemed to bring my VM’s to a grinding halt. The procedure for portlet integration with Webcenter Suite is a bit different from Weblogic Portal which i do hope to cover in future(after sorting out the memory issue). One point to note is, while installing Weblogic Portal ensure that you are installing the Portal Samples as well. These samples contain a sample DVT application which provides a login portlet for the portal.

Having used Weblogic Portal, i can surely say that it is much better than the Oracle Portal 10g. Portlet development/deployment is a lot easier in Weblogic as it is purely java based. I still remember i had to get 2/3 patches applied on Oracle Portal 10.2.0.x to 10.2.0.4 just to make the Oracle Portal WSRP compliant so that it can consume JSR-168 compliant BI EE portlets. In the case of Weblogic, it supports WSRP by default. One downside though is Weblogic Portal 10.3 does not provide login portlets out of the box. This is essential to render EPM 11 portlets. I will demonstrate how we can enable a login portlet in the Weblogic Portal later here. One other good thing about Weblogic portal is it supports Portal deployment directly from the Eclipse IDE. This is so essential during the development cycles and i thought that is the biggest differentiating factor between Oracle portal 10g and Weblogic Portal 10g. Oracle Portal 10g supported only web based development and lacked a true IDE integration.

When you install EPM Workspace or Web Analysis, the Workspace portlets get installed automatically. There is nothing extra that we will have to do to use the portlets.

We will start with creating a very simple report in Web Analysis as shown below. This a report based on the SH schema.

Once the report is created, login to the machine where the portlets are installed. Navigate to the directory {HYPERION_HOME}\products\Foundation\workspace\InstallableApps\portlets

In this directory, you would find all the portlet files for various portals. In our case, since we are using Weblogic Portal, we will have to copy the bea-avaproxy.zip to a temporary directory and decompress it.

The next step is to navigate to the Weblogic Portal and open up the eclipse IDE (workshop). If you are new to Weblogic Portal, the following steps will basically highlight what you need to do to quickly create a portal. Start with creating a simple Portal EAR Project directly from the Eclipse IDE.

Once you have created the EAR Project created, associate the project with a Weblogic domain. If you do not have a domain, you can create it as part of the EAR creation process.

Once the EARProject is created, we will have to create the Portal Web Project. While creating the Portal Web Project ensure that you are assigning the Samples DVT application as part of the project facets. This is very important for the portlet integration to work. This DVT application provides a login portlet that we can use within the portal. Remember that EPM portlets cannot be used by autonomous(non-authenticated) users.

Once the Portal Web Project is created, we need to deploy the portlets that we decompressed before. Portlet deployment in weblogic is done by copying the portlet.xml from the decompressed portlets folder to {BEA_HOME}\{Workspace_Home}\{PortalWebDirectory}\WEB-INF folder. In my case i had to copy the portlet.xml from /home/oracle/portlets/WEB-INF to /u01/app/bea/user_projects/workspaces/default/EPMPortalWebProject/WebContent/WEB-INF. Remember while copying on linux, the portlet.xml will contain Ctrl characters like ^M. Ensure that you do a dos2unix on this file before copying.

After copying the portlet.xml, merge the contents web.xml in /home/oracle/portlets/WEB-INF with web.xml in /u01/app/bea/user_projects/workspaces/default/EPMPortalWebProject/WebContent/WEB-INF folder.  For reference i have attached the web.xml and portlet.xml files here and here. Then ensure that every other file/folder (from decompressed portlet directory) is copied within the Portal Web applications portlets directory as is.  This will enable us to use the EPM portlets within the workshop framework. After the deployment, the eclipse IDE will recognize the portlets and will list it in the Design Palette as shown below

To use the portlets, lets create a page in the Workshop portal and include the following portlets

1. DVT Enabler – Login portlet
2. Hyperion Reporting and Analysis Portlet
3. Hyperion Reporting and Analysis credentials Manger Portlet

Now run this portal directly from Workshop. Remember to alter the name of the portal to remove the .portal extension. Else deploy the portal from Portal Web Admin console. If you deploy it with the portal extension, the portlets will not render properly.

As you see, since we have not logged in, both the portlets will throw an error. Lets login as the admin user. After logging in, we customize the portlets by entering the EPM username/password. The report portlet basically has 2 options. One is to specify the path of the report. And the other is any parameters that we would like to pass. When i tried this, the portlet seemed to be very fast, much faster than workspace itself.

Not all the functionality available in the EPM workspace will be available in the portlets like Drill up, Keep/Remove etc. Basic drill functionality will work though.

The biggest compelling feature, in my opinion to upgrade from 9.3 to the EPM 11 release is the inclusion of the new Life Cycle Management utility which makes the process of migration from one machine to another all the more smoother. Not that this utility works perfectly or isnt without bugs, it is nevertheless a significant leap from the older 9.3 release and can drastically reduce migration times/effort involved.

The 2 common issues in the 9.3 release was

1. There was no automated way of migrating shared services users/groups/provisioning information from one machine to the other. There did exist a CSV/XML import-export utility but it was never straight forward to use. Just to work around this we had to build a custom JAPI based User/Group extractor.

2. There was no automated way of migrating Essbase artifacts without doing copying from the file system (Outlines, rule files, calc scripts etc). EAS does provide an option to copy applications across multiple servers but unfortunately cannot be automated out of the box. Even if we can somehow automate it by reusing the EAS Jars, we cannot reuse the same scripts without modification across environments.

Now only if we could have a similar such utility in BI EE, it will make the process of migration all the more smoother. Anyway i am digressing. Today, i will demonstrate how this utility can be used to migrate Essbase applications from one environment to another.

LCM Utility supports 2 kinds of migration

1. Application to Application Migration – If you have multiple instances of Essbase registered in a single shared services instance, then this migration automatically migrates the Essbase Application & Database Artifacts to the other Essbase instance through the common Shared Services CSS.

2. Application to File System Migration – This is the most common case. If you have multiple instances of Essbase registered in different shared services instances then this utility migrates all the necessary artifacts on to the file system. Then we need to move the extracted artifacts to the target machine and then run the utility again which will reimport the application in the target machine.

I will demonstrate the 2nd type of migration for Essbase as that is the most commonly used one. We start with migrating a very simple database Sample->Basic. The migration can be executed directly from shared services or can be remotely executed using the LCM utility. But for either of them to work, we will need something called as a Migration XML. This XML basically defines the source and target artifacts that we will be migrating from/to. This XML is created from Shared Services by navigating to the corresponding Application Group that we would like to migrate

In the screenshot above, we have basically chosen all the artifacts corresponding to the Sample->Basic database. One very good thing about this is, it migrates the security & Substitution variables(which are not stored as separate files but are created through MaxL) as well. All the major artifacts are identified using the file extensions. This does not support data migration i.e if your cube has data in development, the LCM utility will not migrate the data to the test/prod machine. We will have to do that manually. Also, Partitions will have to be recreated manually in the target instance using MaxL. Once the artifacts are chosen, we need to click on “Define Migration” to specify how we would like to migrate the Sample->Basic database artifacts.

We shall choose the file system migration for the Destination as shown above. We can specify any folder name here. This will in turn create a folder under {HYPERION_HOME}\common\import_export\<user>@<Directory>\<foldername>. The folder will be created only when we execute the migration. Currently we are just defining the XML for the migration. Once we have defined the destination options we need to save the MigrationDefinition XML

<Package name="web-migration" description="Migrating Product to File System">
    <LOCALE>en_US</LOCALE>
    <Connections>
        <ConnectionInfo name="MyHSS-Connection1" type="HSS" description="Hyperion Shared Service connection" user="" password=""/>
        <ConnectionInfo name="FileSystem-Connection1" type="FileSystem" description="File system connection" HSSConnection="MyHSS-Connection1" filePath="/SampBasic"/>
        <ConnectionInfo name="AppConnection2" type="Application" product="ESBAPP" project="Essbase:oraepm2.venkatlap.com:1" application="Sample" HSSConnection="MyHSS-Connection1" description="Source Application"/>
    </Connections>
    <Tasks>
        <Task seqID="1">
            <Source connection="AppConnection2">
                <Options/>
                <Artifact recursive="true" parentPath="/Databases/Basic" pattern="*"/>
            </Source>
            <Target connection="FileSystem-Connection1">
                <Options/>
            </Target>
        </Task>
    </Tasks>
</Package>

If you notice we have defined our XML for doing the migration which is from Shared Services to File System. After defining the XML, we need to execute the Migration. This will extract the necessary artifacts from Essbase to the folder that we specified. Shared Services has a nice console view to look at the status of all the migrations.This can come in very handy if you have a lot of applications and you are migrating all or most of them.

Once the migration is complete you will notice that all the Essbase artifacts will now have been copied over to the File System directory we specified before

To migrate this to another Essbase instance, we can zip the entire File System folder that was created and then move it over to the target machine. We also will have to copy the Migration XML as well. To complete the migration we will have to modify the XML a bit to cater to File System to Essbase migration. The modified XML is given below

<Package name="web-migration" description="Migrating File System to Essbase">
    <LOCALE>en_US</LOCALE>
    <Connections>
        <ConnectionInfo name="MyHSS-Connection1" type="HSS" description="Hyperion Shared Service connection" user="" password=""/>
        <ConnectionInfo name="FileSystem-Connection1" type="FileSystem" description="File system connection" HSSConnection="MyHSS-Connection1" filePath="file:/u01/app/SampBasic"/>
        <ConnectionInfo name="AppConnection2" type="Application" product="ESBAPP" project="Essbase:oraepm2.venkatlap.com:1" application="SampLCM" HSSConnection="MyHSS-Connection1" description="Source Application"/>
    </Connections>
    <Tasks>
        <Task seqID="1">
            <Source connection="FileSystem-Connection1">
                <Options/>
                <Artifact recursive="true" parentPath="/Databases/Basic" pattern="*"/>
            </Source>
            <Target connection="AppConnection2">
                <Options/>
            </Target>
        </Task>
    </Tasks>
</Package>

Remember you will have to modify some of the config files(sourceInfo.xml etc) in the extracted files to support target updates. To import the Sample->Basic application we just have to call the LCM utility directly from command line. This facilitates integration with external schedulers so that we can do the migrations at regular intervals. Also supported is a Java API, so that external applications like ODI etc can call this.

This is pretty straight forward and works pretty well too. But the actual interesting part is in migrating shared services users/groups. This is where it can become tricky. In a couple of my installs, the exports worked absolutely fine but the import process corrupted the entire shared service instance. I observed this on a couple of my OEL-EPM-Weblogic instances. I might have to log this as a LCM bug. But i will cover a workaround in my next blog entry and show how users/groups can be migrated from one instance to the other.

1. Styles
2. Skins

I have blogged about the method for customizing the BI EE UI using both Styles and Skins almost 2 years back here and here. In the case of EPM Workspace, the terminology used is a little bit different. Also, Oracle has an agreement with Bindows, a third party vendor which basically provides the entire framework for customizing EPM Workspace. The full agreement is available on Bindows website here.  I am not sure how the agreement works, but i believe it does allow for change in the UI styles implemented as part of the Bindows framework. In fact Bindows has a nice set of themes on their website(for download) which can effectively be retrofitted back to EPM workspace with some amount of work.

In the EPM 11 release, a new feature was added to support high contrast themes. This can be invoked directly from within the EPM workspace by pressing Ctrl+Shift+H.

Though a third party framework is used, there are also some internal themes that Oracle EPM uses. To understand how this all work together, we need to start with understanding how EPM workspace renders all the themes, styles, images etc. Whenever we deploy the Workspace war manually or do an automated deployment into an application server, the deployment process manually copies certain part of the installed Workspace(or different application) files to the App Server accessible area (within its relative URL reach). This is very similar to what happens in BI EE. When we deploy Presentation Services Plug-in to an app server, all the themes, images etc are copied to the context accessible area of the application server.

As you see in the above screenshot, i have deployed Workspace into Tomcat and hence we have a multitude of workspace related files in the deployed directory. You can see a couple of folders here. themes and thirdparty/bindows/html/themes.

If you notice, we have completely different set of folders under both the theme folders. My initial impression was that only the bindows one was used (not the workspace native one). But on further analysis i realized that both the folders above are required to make the themes to work. Bindows themes are just for Workspace alone(bringing all the components together while using 19000 workspace port). But the individual themes can vary for different products. In the above screenshot we basically had theme_tadpole and theme_tadpole_hc as native workspace themes(workspace as a product). Also, the Bindows specific themes Bpmtadpole and BpmtadpoleHc. Similarly lets look at the ui_themes folder of Hyperion Scorecards

As you see we only have the product specific ones theme_tadpole and theme_tadpole_hc. So, there are a couple of conclusions that we can derive out of this.

1. When customizing the UI of EPM components, the bindows theme as well as the individual product themes should be in sync with each other
2. Ensure that when you have EPM components deployed in multiple machines, all of them get a common ui through the same default theme theme_tadpole. The _hc version of the themes are the high contrast variants of the original themes.

In BI EE, we typically start off with creating new themes(styles) as a copy of existing themes(styles). But in the case of EPM workspace, due to the nature of interaction (or lack of it) between the bindows and the product themes, i would recommend not to create new themes but to modify the existing ones(Its better to backup the older themes so that we have something to revert back on).

To start with lets look at a way of customizing the login screen of EPM workspace.
The login screen basically has 2 parts. One is the background color. And the other is the Oracle EPM logo. Remember, whenever you are customizing the EPM workspace, the same customization will have to be done across all the other product component themes as well. The primary reason is each product can be invoked either through the workspace or directly. In either case, we need to ensure that the UI remains the same. Once you start thinking in those lines, you will actually realize that the customization is actually pretty easy. To customize the logo, navigate to

{HYPERION_HOME}/deployments/<appserver>/<application>/webapps/<application>/(ui_)themes/(theme_)tadpole/images_global/

In my case, since i am customizing the login of workspace alone, i had to navigate to /u01/app/oracle/hyperion/deployments/Tomcat5/Workspace/webapps/workspace/themes/theme_tadpole/images_global folder. Here you would find a file called logon_panel.gif. This is the image that actually gets rendered in the logon screen. Replace this image with you corporate logo. Ensure that the image size is 298*367 (pixels).

Copy the same image over to

{HYPERION_HOME}/products/<product>/AppServer/InstalledApps/<application>/(ui_)themes/(theme_)tadpole/images_global

In my case the actual product folder was /u01/app/oracle/hyperion/products/Foundation/AppServer/InstalledApps/workspace_static/themes /theme_tadpole/images_global.

This is very similar to BI EE customization where we need to have the modified style in both the product directory as well as the installed app server directory. Once we have changed the image, the next step is to change the background color. It can be a little bit difficult to do understand this part as there are 4 places that we need to modify the settings. I will just list them down here

1. Global.css file in {HYPERION_HOME}/products/Foundation/AppServer/InstalledApps/workspace_static/themes/theme_tadpole/ - Product Customization
2. Global.css file in {HYPERION_HOME}/deployments/Tomcat5/Workspace/webapps/workspace/themes/theme_tadpole/ – Product Customization
3. theme.css file in {HYPERION_HOME}/deployments/Tomcat5/Workspace/webapps/workspace/thirdparty/bindows/thirdparty/ themes/Bpmtadpole
4. theme.css file in {HYPERION_HOME}/products/Foundation/AppServer/InstalledApps/workspace_static/thirdparty/bindows/ thirdparty/themes/Bpmtadpole

Just edit the css files and modify the necessary property (in our case the background color property). The above changes will ensure that you have customized your workspace application as well as the overall workspace. If you have deployed more applications like Planning, Shared Services etc to be accessible through the workspace, the same customizations will have to be done in those components as well.

Update: Though theoretically we can customize the entire look and feel of EPM Workspace, you might want to check the licensing agreements to see what can be and cannot be customized.

One major problem with an Oracle EPM installation is in the number of components involved and the dependencies among them. Immediately after the Hyperion Acquisition (with the EPM 11 release), Oracle has done significant improvements to the end to end install. The entire installation/configuration is now more or seamless through the EPM system configurator. Though it is much easier to deploy an EPM system now, there still are quite a few components that we need to be aware of while doing a distributed deployment. It would always help if we can understand how they interact with each other. Oracle EPM system has the following products

1. Oracle Shared Services – Grouped under Foundation Services
2. Oracle Workspace – Grouped under Foundation Services
3. Oracle Planning
4. Oracle Essbase, Essbase Admin Console, Provider Services, Studio
5. Oracle Enterprise Performance Management Architect
6. Oracle Financial Reporting, Web Analysis, Interactive Reporting & Production Reporting
7. Oracle Financial Management
8. Oracle Scorecards
9. Oracle Data Integration Management (DIM with its adapters)

There are other components as well(like CMC etc). But above 9 are the most commonly used ones. If you consider the number of products and how they can all work together you can imagine that we can never get the full performance out of them if we install all the components in a single machine. So, to get the maximum performance out of them we need to identify an architecture where each component can be clustered separately but at the same time work in tandem with the other components. At a high level from a deployment standpoint i have depicted the entire Oracle EPM architecture as shown below

The actual deployment can (web & app servers can be swapped, reused, added etc) vary but the above will give a high level conceptual overview of what components we will need in every machine in a distributed installation. Every component can work in isolation or can be brought together through a common workspace.

The above architecture will also provide an overview of how we need to go about adding new components to an existing installation. Every component, for example hyperion planning, has its own web interface (http://machineA:8300/HyperionPlannig). So in a distributed environment, every machine requires an application server, a web server and the component itself. There are some components like Essbase that do not require application servers and web servers. But for the sake of this discussion lets club Essbase installation with EAS, Provider Services and Essbase Studio. But remember most of these web enabled components are brought together in a single interface through Workspace (For ex. http://machineC:19000/workspace). How does that work? Also, Workspace has its own Application Server and Web Server (http://machineC:45000/workspace) which works in a standalone mode without any component integration.

For security reasons, all the web enabled components do not talk to each other directly since they can typically reside in multiple hostnames (possibility of cross domain scripting). So, Oracle EPM combines all the components together into a single web enabled workspace (http://machineC:19000/workspace) either using an Apache HTTP Server or an IIS Server. One distinctive advantage of this is it provides a means of complete security where there is a need to expose the components over the web. In such cases, we can just put the web server alone to be internet facing and everything else inside a DMZ and then put a firewall (on both sides of the DMZ) to protect the corporate intranet. There can be other variations like multiple firewalls across multiple layers but the point is it provides flexibility

I think Oracle/Hyperion also did this for a couple of other reasons

1. Workspace was a product that was introduced, much after Planning and Essbase, EAS etc to bring them all together. So, they had to find an architecture where every component will be in a different machine but at the same time should be able to work together through a common console
2. Incremental product/component purchase. If someone purchases Planning along with Shared Services today, they can add more components like BI EE etc later and will still be in a position to bring them all together.

One more point to note is, multiple components can be installed on a single machine and then deployed on to the same application and web servers. So, depending on the usage, performance required, an optimal number of servers required etc can be arrived at before doing a deployment. Lets look at a very simple distributed deployment scenario today. We will start with the first component which is shared services. The application server i will be using is Weblogic Server 9.3. Other app servers are supported as well. But ensure that, for the workspace integration to work the application server used for workspace deployment will have to be used for other components as well.

The order of installation of various components can be different. But the configuration should be done in a certain order. In our case, on MachineA we will start with shared services installation. Once the installation is done, install Weblogic Server on that machine as well. Ensure that while installing weblogic server, you choose the servlets option. This is what will enable the Apache redirects between the main workspace http server and individual Weblogic embedded http servers through mod_so.

After the installation, install an Oracle Database or use a new database schema from an existing database instance. The Oracle client installation on any of the machines is not necessary as the connections happen through JDBC with pre-bundled drivers. Start the configurator and then point to a database schema specific to sharedservices. It is a standard practice to have one schema for each component.

Choose the automatic deployment for Oracle Weblogic 9. Also enter the Weblogic home. During deployment, a weblogic domain for Hyperion is automatically created(no need to create before hand). If multiple components are deployed at the same time, all the components will be deployed onto the same domain. Once the deployment is successful, ensure that shared services is up and running. Shared Services has to be up and running for other components to be configured from other machines.

Once the shared services is installed and configured, we can move on to other components. In my case, i will install Workspace & Planning together in another machine.

Once the install is done, install Weblogic server again in this machine (i believe using weblogic node manager it is possible to use a single em managing multiple instances of weblogic, but i will leave that for now). While installing ensure that the Servlet Plugins option is enabled as well. In this we will configure 2 components(Planning & Workspace) on to a single weblogic domain. Start the EPM configurator.

If you have other components installed on other machines, while in the system configurator, do not check the “Configure Web Server” option. This is always done at the end once every component is registered with shared services. This option basically configures the URL redirects from the main HTTP Server to the individual component http servers. In our case, since we do not have any other component to install, we shall choose every option available for Workspace and Planning (Except clustering). Every other configuration remains the same. The only addition is in the Web Server configuration. You will notice that all the web enabled registered components will be listed in the web server configuration screen

You will also see components along with their machine names as well. This will ensure that Workspace can automatically make redirects to other applications using its http.

If you notice this is very different from a BI EE deployment. BI EE has only one web facing component which is through the http server and the presentation services Plugin(deployed in the Java Container). Every other component like Presentation Services, BI Server talk to each other through specific ports but are not web enabled by themselves. The main reason is, BI EE itself is a single product. Presentation Services alone will not make sense without the BI Server. BI Scheduler cannot work in isolation. So, in effect, this comparison itself is not valid since we are comparing a multiple product deployment (EPM) with a single product deployment i.e BI EE. But if you look at the whole architecture in the first figure, it blends overall with the entire Oracle EPM universe story. The integration of BI EE with Oracle EPM is very similar to the integration of Hyperion Planning with Workspace. End users connect to the Workspace http server. When BI Presentation Services is chosen, Apache does a redirect to the local apache of the app server on which BI EE is deployed. But what is not seamless yet is the security integration. In the case of Planning, Workspace etc, since Hyperion itself developed it, all of them more or less followed the same security model. But in the case of BI EE, the security model is completely different. Hence Oracle i believe, had to come up in some way to pass the SSO tokens from EPM to BI EE and then make BI EE to recognize them. Hopefully this integration will become more seamless with future releases of EPM and BI EE. I can envision BI EE becoming the core of reporting in the EPM architecture replacing Web Analysis.

Lets look at the list of steps that we typically go through while integrating BI EE with EPM Workspace.

1. We start with Registering the BI EE into Hyperion Shared Services Registry (using BI EE Administration->Manage EPM Connection tab). This step enables the configurator to recognize BI EE as another EPM product. This will basically enable apache redirects between the EPM Workspace HTTP Server and the BI EE http server.

2. Once the registration is done, we enable BI EE to recognize the Oracle EPM SSO tokens (as the security model is different). This is done by adding the the following configuration tags to instanceconfig.xml

<Auth>
 <ExternalLogon enabled="true" logonPageAllowed=”true”>
   <ParamList>
      <Param name="UID" source="url" nameInSource="sso_token"/>
      <Param name="PWD" source="constant" value="obips.hss.ssotoken"/>
   </ParamList>
 </ExternalLogon>
</Auth>

3. There are a couple of ways in which the EPM SSO tokens can be recognized by the Javahost. One is through the cssURL method wherein the CSS values are derived from the cssURL. The cssURL can be verified using the URL http://machineA:28080/interop/framework/getCSSConfigFile. If you query this, it will generate an XML as shown below

<css>
	<hub location="http://esscluster1.venkatlap.com:28080">
		<dirPort>28089</dirPort>
	</hub>
	<spi>
		<provider>
			<native name="Native Directory">
			</native>
		</provider>
	</spi>
	<searchOrder>
		<el>Native Directory</el>
	</searchOrder>
	<token>
		<timeout>480</timeout>
	</token>
	<logger>
		<priority>WARN</priority>
	</logger>
	<delegatedUserManagement>
		<enabled>false</enabled>
	</delegatedUserManagement>
</css>

Javahost can extract the required values out of this config XML itself. But in many cases, since this can be extracted directly from sharedservices registry, there is an option to specify the HYPERION_HOME registry property file within Javahost so that it can communicate with sharedservices and authenticate accordingly.

4. The next step is to make sure BI Server authenticates against shared services using the custom authenticator.

5. Once all the above are done, we need to enable the apache from Workspace through the EPM configurator to redirect requests for BI EE to the app server on which Presentation Services plugin is deployed.

If you look at it from an overall perspective the only complicated piece is in the enabling the EPM to BI EE security. But hopefully in 11g, BI EE would have the same authentication model like Oracle EPM. If that is the case, the only configuration that we probably would have to do is the first and the last steps i.e register with shared services and then enable apache redirect. Now, how about bundling BI EE along with the EPM installer(i think we might even see this in the coming future). Even that will become straightforward like other Hyperion Components once the security model is straightened out hopefully in 11g(again based on rumours in the public domain). Now we can realize why Oracle is planning on moving BI EE towards a common security framework. Its all for seamless integration with Oracle EPM. But again from a shared services perspective, i think there need to be significant improvements there. From a provisioning standpoint, shared services does not have a good integration with Essbase or with BI EE currently. Now, only if they can revamp shared services with more Essbase & BI EE specific provisioning capabilities, it will become all the more interesting.

Clustering of Essbase servers can be very critical if you have a mission critical reporting system that requires to be online almost all the time. There are 2 kinds of clustering that Oracle supports for Essbase

1. Horizontal Clustering – This is a normal clustering scenario wherein we have an exact replica of the Essbase server spread across multiple machines and each machine is in active state (active-active).

2. Vertical Clustering – This is clustering scenario which is similar to Horizontal clustering wherein instead of having multiple instances, multiple instances of Essbase are created on the same machine (adding more hardware). If you compare this with BI EE, BI EE does not support this clustering architecture yet.

At a high level, the Essbase clustering architecture is given below

The idea is to have multiple Essbase servers being served in turns by the Provider Services. For complete high availability scenario, the Provider Services itself can be clustered so that there is no single point of failure. The Provider services clustering is very similar to Presentation Services clustering in BI EE. In a BI EE cluster, multiple presentation services write to a common shared web catalog. Similarly, in the case of Provider services, multiple web instances share a common cluster definition stored in a shared directory. This blog entry will focus only on the Essbase server clustering using a single provider services.

Scenario: We basically have 2 instances of Essbase running on 2 separate machines. One machine hosting one of the Essbase Servers and a corresponding provider services. Another machine hosting another Essbase server with no provider services. To cluster both the servers we shall start with logging into the Essbase Administration console and then adding both the servers under the Essbase Server node.

Once these Essbase Servers have been added, the next step is to add a Provider Services under the Provider Services node.

One of the advantages of Essbase clustering is the fact that it allows clustering at database level. That is, one has the ability to either include all the applications to be part of a cluster or only certain necessary ones. In our case, lets add both the Essbase Servers to the Essbase Cluster node.

While specifying the name for the cluster, ensure that you have a name without any spaces in them. Also, in our example, we shall just add the SampEast Application(from both servers) to the cluster

Whenever new applications/servers are added/removed from a cluster, the provider services need to be restarted (but they can be enabled/disabled after adding them without a restart)

Clustering capability can be leveraged only by those applications that can connect through Provider Services. So, if you have a smart-view client or an external application using JAPI, then clustering can be leveraged. To test our cluster, lets login to Smart-view using the provider services. While adding the Essbase Server, instead of the actual Essbase Server names use the cluster name that we gave above.

As you see we now have the application/database that we added under the cluster being displayed by Smart-View through the provider services. Now, lets create a report using this database and check where the session gets created.

As you see the first session gets created in the first Essbase Server. Now lets open up another instance of the Smart-View client and create the same report. You will notice that Smart-View pushes this new session to the other essbase server

Also, as another test, lets kill the first essbase server and then try running both the reports(both instances of Smart-View) again. You will notice that, both the sessions will now have moved to the valid & live Essbase Server.

Though it works out of the box and is quite good, it has certain drawbacks. Lets look at them one by one.

1. Write backs directly from Smart-view are not supported. If you try to write-back to a database cell, an error message would pop-up denoting the fact that write-backs are not supported in a clustered mode.

The only work around is to connect to the servers directly (without the provider services cluster) and then write-back on them. But the end user will have to ensure that both the servers are kept in sync manually. So, this cannot be used in Hyperion Planning apps.

2. Essbase Add-in cannot leverage the clusters.

3. Security across the nodes should exactly be the same. Both the nodes should have same security setup (native authentication or shared services authentication)

Apart from the above 3 limitations, every other individual essbase feature can be leveraged and hence all of them will be in a highly available mode. It is easy to add new nodes and remove them as and when necessary. In future, we shall see how to go about clustering Provider Services, OpenLDAP and Hyperion Workspace. All the clustering topics that i am planning to cover will all be based on active-active clustering mode. Active-Passive clustering is also supported though it is typically achieved through an external software solution (to keep machines in sync through some background process). Hence i will not be covering the latter.

Listening to the presentation and reading the slides, it’s clear that this is a work in progress and there’s the usual disclaimers about not being able to make purchasing decisions based on what they say. As this session was a preview and it’s at such an early stage, I won’t be too specific about what they said, though you can listen to the session in full and download the slides on Open World on Demand, session S308151, if you’re interested in the full details. Anyway, here’s what was talked about:

The product is called the “Oracle BI Applications Essbase Integrator” and aims to deliver in three areas:

1. A seamless user experience between the OBIA dashboard and SmartView
2. Metadata sychronization between the BI Apps RPD and the Essbase Outline
3. An Extension to BI Apps Financial Analytics and Supply Chain/Order Analytics

Looking at the demo screenshots, the way that this would be delivered would be through additional narrative views on the BI Apps dashboard (the platform targeted is Oracle BI EE 10.1.3.4+, BI Apps 7.9.6 and Essbase 11.1.1) that would provide drop-down menus linking to SmartView analyses. When the menu item is selected, SmartView would be contacted (via the OracleSV protocol that Venkat blogged about here) with context being passed from OBI Apps to Essbase. Dimensions would be on the correct axes, security would be honoured and the user should not have to do anything to maintain their train of thought.

The way that data and metadata would work, is that the BI Apps RPD would be used as the initial data definition for the Essbase cube. The BI Apps RPD would be read and parsed, with data being extracted via UDML and then loaded into a Fusion Middleware MDS repository that stores an abstracted data model for the two systems. This would then be used to generate an Essbase outline along with the neccessary SQL scripts to extract data via the BI Apps RPD. Then, a similar process would work over time to keep the Essbase cube in sync with the BI Apps RPD, but preserving user changes to the Essbase cube so that models and other Essbase-specific analyses are preserved during updates. There is quite a sophisticated process at work here with bi-directional synchronization between the two products, from what I can see it doesn’t use Essbase Studio but instead relies on custom data and metadata loaders.

An area that appears to have had significant thought is how to apply OBI data filters, aggregations and calculations to the Essbase cube. OBI filters are essentially predicate based – filter products on “electrical”, for example – whereas Essbase ones are hierarchical, whilst OBI calculations are in SQL whilst Essbase ones are in MDX. OBI aggregations are also transferred 100% to Essbase, and the whole thing is aimed at the current set of BI Apps and Essbase products together with EBS rather than being reliant on the Fusion (11g) generation of products.

So, I won’t say any more as this session was the first public unveiling of the product, but as I said if you have Oracle Open World on Demand access you can listen to the presentation and see the slides for more details. I’ll be trying to get Alaric across to ODTUG Kaleidoscope later in 2010 to see if he can demo this later in the year, but if like us you’re a user of both the BI Apps and Essbase, this sounds like an interesting development.

I covered a basic introduction to Hyperion Planning a few months ago, where I outlined the basic idea behind the product and how it fitted into the EPM Suite framework. To recap, Hyperion Planning is a part of Oracle EPM Suite and is currently at version 11.1.1.3. It is used by organizations to plan and budget within their organization, and where it differs to ordinary Essbase is that it’s a packaged application designed to do one thing (planning), rather than being just an OLAP server or a toolkit like Java. Planning uses a combination of Essbase (for multi-dimensional analysis, allocations, forecasts and calculations) and relational storage (for additional planning metadata), and is generally accessed by end-users either through the Planning Web Application (part of EPM Workspace), or through Excel via SmartView or the classic Excel add-in.

At a very high-level, Planning fits in with Oracle’s general EPM/BI architecture at the “application” level, along with the Oracle B Applications.

At a product level, Planning sits underneath the EPM Workspace and Smartview/Essbase Add-in and is administered using both it’s own Web Application and through Enterprise Performance Manager Architect, a general metadata management/lightweight ETL/application management tool that first appeared with Hyperion System 9. Planning as I said stores its planning data in Essbase, additional supporting metadata in relational tables, and can take data from applications, data warehouses and master data management tools, or from files and other structured data sources.

Note that EPM Architect, the Planning Web Application and infact Workspace itself are all delivered through the Hyperion Workspace application, so they all appear in the same user interface but accessible through different menu options, but conceptually they can be thought of as different applications. A typical end-user session in the Planning Web Application looks like the screenshot below, note the fact that the forms (of course) support write-back, and its this ability for users to submit their own numbers coupled with the workflow element of the product that sets it apart from a standard sales analysis-type Essbase application.

So, the question is, how do we build a Planning application? The actual “application” itself is stored in Essbase as a regular application, with an outline, dimensions, attributes and data stored within it, with everything stored in a single Essbase database within the application. If you opened up Essbase Administration Services and took a look at the application, a typical one would look like this:

But you can’t load a Planning database like a regular Essbase database, as you have to manage it using the Planning application itself. Planning acts as a wrapper around Essbase and manages dimensions etc within its own repository, publishing these to the Essbase server when you deploy a Planning application. Essbase is effectively hidden under the covers (at least in the current EPMA-enabled release, in previous versions you still needed to know a lot about Essbase to get it working) and you use Planning, and from System 9, Enterprise Performance Manager Architect (EPMA) to manage applications instead.

Data in Planning breaks down into two main areas; dimension data, such as entity, period, scenario and ones that you define yourself, and data, the actual numbers (actuals, forecast, budgets) that you load into the database. Planning (in its standard form, there are variations for workforce and capital expenditure planning) ships with six standard dimensions:

• Entity, for organizational units, countries or similar (current calculations are based around these)
• Scenario, so that you can try different types of plan or planning methods
• Version, typically top-down or bottom-up, but also allowing you to split plans into public ones and ones for internal use
• Period, such as financial period, month, financial quarter etc
• Year (typically split from period to make plans easier to work with)
• Account, the measures in the plan such as profit, margin, costs etc

In addition, you can define your own dimensions to allow you to budget by product, for example.

When you load data into a Planning application, the actual numbers go into the Essbase database, whilst a support relational database holds all the textual data, workflow steps, plan status and so on. Up until System 9, you would create Planning applications using the Planning administration tool, which allows you to define the application in metadata before deploying it to a suitable Essbase server. This approach is preserved for backward compatibility in System 9 and EPM Suite 11.1 (a.k.a. System 9.5), and I walked through an example in a previous posting where I created an application using what is now called the Classic Application Wizard. This works pretty well (indeed, most Planning administrators still use this approach for reasons I’ll outline later on), but it’s not the “strategic” way of doing it and we can’t take advantage of the metadata management features of EPMA if we go down this route (though we can upgrade classic planning applications to EPMA ones, if you like, in order to take advantage of these features).

So after running through the upgrade myself on one of my classic applications, I thought I’d run through the process of creating a new one from scratch, just using EPMA. The first hurdle with this is that EPMA needs Microsoft Internet Information Services to run, and so I dug out the Windows CD and installed it (feeling a bit dirty in the process), then got all the services up and running.

Hyperion tends to create lots of services anyway (at last count, including Planning, there were 31 Hyperion-related services running on my Windows machine) but as you can see from the screenshot above, EPM Architect and Calc Manager take up eight of their own. The different services for EPMA hint and what the product actually does, as EPMA actually consists of a number of components:

• A Dimension Library, for holding metadata on the shared and local dimensions used by EPMA-enabled applications
• An Application Library, for holding definitions of the various Essbase, Planning and HFM applications EPMA manages
• A Data Sychronization Engine, for loading data (numbers) into EPMA-managed applications
• Workspace, Security and Taskflow elements

EPMA has its own repository that holds all the metadata on the applications it manages, and as with classic planning applications you define the dimensions there first and then deploy them to Essbase. To start off them, as with the Classic Application Wizard you can define the basics of the Planning application using a wizard in EPMA, where you can say whether the application has one or more plans, whether it’s multi-currency, what time periods it uses and so on.

Note the option in the above screenshot to “auto-create local dimensions”. The first (System 9) version of EPMA made you define all dimensions as “shared”, which meant that you defined them in the “dimension library” within EPMA and then made them available for use by various applications, each of which then used the same dimension definition. EPMA 11.1.1 introduced the concept of local dimensions, detached independent dimensions that only exist within a particular dimension, allowing you to have different definitions of entities for example in different planning applications. Classic applications that are imported into EPMA have by default local dimensions, and local dimensions are the default when setting up fresh applications directly within EPMA, however if you are looking to standardize data and access across all of your planning applications you’ll probably want to move towards shared ones. For me though, I created my application using the standard dimensions and in shared mode, choosing to create period and year ones at the same time.

As well as creating the standard dimensions, I also wanted to create a custom, “product” dimension to allow me to plan across my product line. This also was created as a local dimension, again using the wizard, as shown below.

So now I’ve got my basic dimensions including one for Accounts, to hold the measures that I’ll be planning against. What I haven’t got at this stage though are any members for my dimensions, which I’ll need to hold details such as the scenario name, entity names, period and products.

If the dimensions are small (scenario, for example), you can define them directly within EPMA in a similar manner to Essbase Administration Services. In the screenshot below, I’m adding a child member to the Accounts dimension:

Doing this allows me to build up the accounts that will hold my actuals, budgets, forecasts and so on.

Repeating this for Version and Scenario allows me to quickly add the members for these dimensions, and even Entity is straightforward as there are only a few territories where my company is operating.

Period and Year have their members automatically created for you by the EPMA Application Wizard, and so the only dimension left to create members for is the Product dimension, which won’t be easy to create easily as it has lots of members. When I created a planning application using the Classic Application Wizard I was able to use the Outline Load Utility to mass-create dimension members using a flat file as a source, but you can’t use this utility when managing a Planning application using EPMA (nor can you use ODI or DIM, strangely enough). So how do you get large amounts of dimension members into a Planning application when you are using EPMA?

It’s probably worth taking a moment out to understand how data and metadata flows through Planning when EPMA is involved. As you can see from the diagram below, data and metadata from the various sources goes first into interface tables or files before being accessed by EPMA, which then takes this data, maps it and then uses it to construct the applications that you want to create.

So what we need to get to grips with then, to bulk load dimension members into our product dimension, is either the interface tables or the interface file structure, and the Dimension Library part of EPMA to bring them in. In my case, the data that will define the members in my dimension is held in a flat file, to start I select the Dimension Library tool within Workspace, and create what’s called a new “profile”.

The profile will contain the information on the file that I’ll be importing, so I start by naming the profile, pointing it to the file containing the list of members, and selecting a particular application rather than the Shared Library, thereby making the dimension local to that application.

Now the tricky bit for me was getting the data in the input file in the correct format for the Dimension Library application to read. Unlike the Outline Load Utility which uses one format, input files for dimensions into EPMA use another, and after a bit of experimentation I got one together that firstly defines the dimension that we’ll be importing, then the list of dimension members, then the hierarchy within the dimension.

See the “Managing Application Metadata” / “Working with Dimensions” section of the EPM 11.1 documentation for full details on the dimension file format.

Once the file is imported and then processed, you can then check back into the EPMA Dimension and Application libraries to see the newly created dimension members and hierarchy. In my case, my products are all now showing as I’d expect, and it’s time to deploy the Planning application to Essbase.

Deploying it was the easy bit, as it takes care of the creation of the Essbase outline directly from within EPMA, meaning that you only really need to use the Planning Web Application to create the forms and workflows/tasks. Before you can start working with forms though, there’s one more task to do – to load the data (i.e the actuals, the baseline planning data) into Essbase. Getting the initial data ready for Planning is actually a two stage process; firstly, you usually want to load some initial data in, and then secondly you process, calculate and otherwise manipulate this data to allocate, for example, top-level budget figures down to individual departments based on headcount, which in classic planning applications you’d do using Hyperion Business Rules and in EPMA-managed ones, you’d use the Calc Manager. Starting off with the data load though, you’ve got a couple of options on how to get the initial data in.

Probably the easiest way is to do an old-fashioned data load into the Essbase database. Unlike dimensions which can only be loaded from EPMA, data can be loaded in whichever way you see fit, although if you bypass EPMA you’ll miss the logging, management and other benefits you get when you manage all your loads using this environment. Doing a data load in this way is pretty straightforward though, you can for example select the dimension in Essbase Administration Services, right-click on it and select Load Data, then point it towards the file containing your data.

Your file needs to hold the data in a particular format (see this previous posting for more details) but it’s easy to understand and only takes a few minutes to set up. The “proper” way of doing it though is to use the Data Synchronizer feature within EPMA, which can bring in data from applications such as Financial Management, in the future it’ll link to Oracle GL, but for now we can point it towards the interface tables I mentioned previously or files, as I’m going to use in the final example.

Data Synchronization, like the Dimension and Application Libraries, is accessed from the Workspace menu.

Once the application is loaded, you start by defining a new External File Definition (or a Data Interface Table Definition, if you are bringing data in from interface tables).

Then, in a process familiar to Warehouse Builder developers, you sample the file and go on to specify which dimension each file field refers to.

Then once the file definition is complete, you then use the tool to define a new “data synchronization”, which maps the incoming fields to the dimensions in your application, with the remaining field containing the data for the specified account.

So there you go. Once you’ve set all of this up and brought some data into the Essbase database, you can follow the same steps in the Planning Web Application to define the web forms and task list that the application will use, and from that point onwards the planning application is the same as far as end-users are concerned (though you need to make any dimension metadata changes in EPMA and redeploy as necessary, rather than make the changes in the Planning Web Application).

So how did it all pan out, compared to creating a Planning application using the Classic Application Wizard? Well I was discussing it with Venkat as I went through the process, and it was interesting to see how restrictive using EPMA can become once you start using it. Tools such as ODI and DIM (the adapters for Informatica) only work with classic applications, which means that you can’t make use of ODI’s ETL capabilities when working with EPMA Planning applications. You can’t use the Outline Load Utility to load your dimension metadata, you have to use Profiles and the Dimension Library, but you can use regular data loads from EAS if you don’t want to use Data Synchronization.

EPMA is clearly the way that Oracle want us to go though, and there are are obvious benefits if you have a whole estate of Planning, Profitability, Financial Management and Essbase applications to manage. It’s also worth thinking about how EPMA might work going into the future – will Essbase dimensions continue to be managed using this tool, could there perhaps be some merging between the Semantic Model that OBIEE uses, will we ever get to that nirvana where we have one repository, one dimensional modeling tool, one set of metadata for all our Oracle Bi tools? Who knows, but for now this is how planning applications using EPMA are initially put together.

Shared Services currently does not support table authentication whereas BI EE does. So, one common issue that people faced while using EPM and BI EE together in prior releases(pre-9.3) is in migrating the users from a database table to shared services. The only way then was to use an export/import utility shipped with shared services that accepted a CSV or an XML file for the import process. So, the database table would have to be exported into a CSV in a specific format (which in itself was not documented well) and then imported back to shared services using the import utility. But now with the advent of Java APIs it has become easier to manage the export import process. In addition, this opens up a lot of integration opportunities revolving around using shared services as a federating user directory.

Today we shall see what pre-requisites are needed to get this working. Unfortunately, the documentation falls short in explaining all the bits and pieces. Following are the components you will need

1. Hyperion Shared Services 11.1.1.1 client archive (or fully installed shared services)
2. JDeveloper or any Java IDE/client

One of the first things that you would notice is the fact that JAPIs of Hyperion are completely different(due to a different implementation methodology probably) from any other Oracle’s own native product like BI Publisher etc. Looking at the API you can clearly understand why it was not documented before (you can find a lot of jar files used extensively, interchangeably by a lot of Hyperion Components) as there are still quite a lot of jar files you would need to get it to work. Unfortunately the documentation just points to the fact that you would need the class path to be qualified correctly without mentioning where or what those jar files are.

To start with i would be using the sample.java file that comes with the EPM documentation. For the sake of clarity i have provided the code for this java file below.

package hsssecurity;

import java.io.PrintStream;
import java.util.HashMap;
import java.util.Map;

import com.hyperion.css.CSSAPIIF;
import com.hyperion.css.CSSDirectoryManagementAPIIF;
import com.hyperion.css.CSSException;
import com.hyperion.css.CSSSystem;
import com.hyperion.css.CSSUserProvisioningAPIIF;
import com.hyperion.css.common.CSSGroupIF;
import com.hyperion.css.common.CSSPrincipalIF;
import com.hyperion.css.common.CSSRoleIF;
import com.hyperion.css.common.CSSUserIF;

public abstract class hsssecurity {
	 // Handle to Instance of CSS System
    protected CSSSystem system = null;
    // Handle to Instance of CSSAPI
	protected CSSAPIIF cssAPI = null;
	//Handle to Directory management API
	protected CSSDirectoryManagementAPIIF cssDMAPI;
	//Handle to User Provisioning API
	protected CSSUserProvisioningAPIIF cssUPAPI;
	//the identity of the entity performing the operation.
	protected CSSPrincipalIF principal = null; 

	protected HashMap context;

	public static String PRODUCT = "HUB-9.5.0";

	public hsssecurity() {
		initialize();
	}

   /**
    * Initialize the CSS Framework
    */
    private void initialize()
    {
        try
        {
        	System.out.println("Initializing CSS ...");
        	context = new HashMap();

            // Get Instance of the CSS System. Specify the location of
            // the Shared Services Client log file.
            // CSS will be intialized from configuration stored in Registry.
             System.out.println("Initializing CSS ...");
            system = CSSSystem.getInstance(context, "C:/Oracle/Hyperion/logs");
            System.out.println("Initialized CSS.");

            // get Handle the CSS API Interface
            cssAPI = system.getCSSAPI();

            cssDMAPI = cssAPI.getDirectoryManagementAPI(new HashMap());

            cssUPAPI = cssAPI.getUserProvisioningAPI(new HashMap()); 

            System.out.println("Getting the Principal ...");
            principal = getPrincipal();
            System.out.println("Got Principal.\n");

            context = new HashMap();
        }
        catch (Exception ce)
        {
            ce.printStackTrace();
        }
    }

	/**
	 * Shuts down the CSS framework.
	 */
    public void shutdown() {
    	try {
    		system.shutdown();
    	} catch (Exception e) {
    		e.printStackTrace();
    	}
    }

      private CSSPrincipalIF getPrincipal() {
    	  CSSUserIF admin  = authenticate("admin","password");
    	return admin.getPrincipal();
      }

      protected HashMap getContext() {
    	return new HashMap();
      }

      protected CSSUserIF authenticate(String username, String password)
      {
          CSSUserIF user = null;
          System.out.println("Authenticating user: " + username);
          try
          {
              Map context = new HashMap();
              user = cssAPI.authenticate(context, username, password);
              System.out.println("Got User: " + user);
          }
          catch(CSSException ce)
          {
              ce.printStackTrace();
          }

          return user;
      }

      protected void dump(PrintStream out, String msg, String [] arr){
    	  out.println(msg);
    	  for (int i = 0; i < arr.length; i++){
    		  out.println(arr[i]);
    	  }
      }

      protected void dumpUsers(PrintStream out, String msg, CSSUserIF[] users){
    	  out.println(msg);
		  out.println();
    	  for (int i=0 ; i  "+ users[i].getLoginName());
    		  out.println("User Email-->" + users[i].getEmailAddress()[0]);
    		  out.println("User Description-->" + users[i].getDescription());
    		  out.println("User FN -->" + users[i].getFirstName());
    		  out.println("User Identity-->" + users[i].getIdentity());
    		  out.println();
    	  }

      }

      protected void dumpGroups(PrintStream out, String msg, CSSGroupIF[] groups){
    	  out.println(msg);
		  out.println();
    	  for (int i=0 ; i " + groups[i].getName());
    		  out.println("Group Description-->" + groups[i].getDescription());
    		  out.println("Group Identity-->" + groups[i].getIdentity());
    		  out.println();
    	  }

      }

      protected void dumpRoles(PrintStream out, String msg, CSSRoleIF[] roles){
    	  out.println(msg);
		  out.println();
    	  for (int i=0 ; i " + roles[i].getName());
    		  out.println("role Description-->" + roles[i].getDescription());
    		  out.println("role Identity-->" + roles[i].getIdentity());
    		  out.println();
    	  }
      }

      protected abstract void cleanup(String []identities) throws CSSException;

	  protected void printMsg(PrintStream out, String msg) {
		  out.println(msg);
	  }

}

As you see, all this class does is, it authenticates into shared services and provides a set of methods for displaying the groups, users, roles etc. But if you notice, the recommended approach is to use the abstract class method implementation as we need to ensure that when we have multiple instances of the client application the memory is shared across the applications if necessary(this is not always necessary but this is what seems to be the recommended approach by Oracle). So, in order to test this out, we would have to create a sub-class as shown below

package hsssecurity;

import com.hyperion.css.CSSException;

public class hssImplementation extends hsssecurity{
    public hssImplementation() {
    }

    protected void cleanup(String []identities) throws CSSException{
    }

    public static void main(String[] args) {
        hssImplementation a = new hssImplementation();
    }
}

The sub-class would have to provide implementation methods for non-abstract methods in the abstract class. Now, coming to the classpath, you would have to ensure that you have all the jar files under the {HYPERION_HOME}\common\utilities\LCM\9.5.0.0\lib folder to be available to the main executing class.

Once that is done, go to the Run-time execution profile and add an HYPERION_HOME parameter as shown below

With this you should be able to execute any of the methods in the main sample.java file.

The above should get you started on using the Java APIs of shared services. I would cover some more complex integration methods like export/importing users into shared services, custom application to main users/groups etc in the future.

QlikView, compared to Oracle’s relational and OLAP query tools, has a slightly different approach to storing and querying data. Whilst it can load data from relational and file-based data sources, it then stores the data in-memory in a compressed form with associations defined between data items rather than the traditional joins that we see in relational query tools. The idea behind these associations is that they are derived by Qlikview during the data load based on matching up columns across tables with the same name, and then when you query the resulting dataset you can analyze your data using these associations.

To take an example, the following QlikView demonstration shows data for a consulting company in a Windows thick client application. To analyze your data, you click on a data item, the numbers on the charts are then filtered by this value, and other data items that are associated with this selected value are then also made available for selection. The screenshot below shows this filtering in action, you can see the selected fields in green, the ones that are greyed out are no longer available for selection.

Now obviously this way of selecting data items, and this method of “association”, is fairly alien to traditional Oracle BI users and so I put together a simple example using the Sales History (SH) dataset available on recent Oracle databases. The first step in creating some QlikView reports is to define a new document, which in the end will hold the report layout, the data loading queries and the actual reporting data itself, which gets loaded in to memory when you open the QlikView document. Once you’ve defined the new document, you create a script to load data in from in this case an Oracle database.

This is in fact a similar process to putting load scripts together for Essbase and Oracle Express, with connections being made through ODBC and OLE DB for databases and direct connections being made to file and HTTP data sources. I get the impression that the most regular use case for data loading in QlikView is loading from files, and this would correspond to the target market for this tool which is desktop analysts who want to report on their data separately from the infrastructure around their enterprise BI tools and data warehouse.

Once you’ve brought your data in, you can view it either as a database (source) data model, or as the logical model that QlickView generates when it loads in the data. In fact for the SH schema, these are both the same as the joins in the Oracle schema are turned into the associations that QlikView uses, so what you see looks just like the regular sort of data model you’d see in any relational query tool.

The joins (or associations) are defined by QlikView during the import process by matching up columns of the same name – each match creates an association. This means that to create a join, you need to alias column names as they come in (to change ID to CUSTOMERID for example, if this is required to join to another CUSTOMERID), and you need to create aliases to break associations so that the STATUS column from the orders table isn’t linked to the STATUS column from the customer table when this isn’t really appropriate.

For an Oracle dataset with well defined primary and foreign keys, the logical table structure that QlikView creates in memory is usually pretty much the same as the Oracle schema, but for files or with data sets with lots of cross-related data, QlikView will create synthetic keys and synthetic tables to record the associations and assist with analysis. Internally QlikView tokenizes and compresses the data as well which meant that, for the Sales History data set that I worked with earlier, the total size of the QlikView document (including the data) was only 4MB and took about 1 minute to load and prepare, whereas the corresponding Essbase data set (as built in this OTN article) took up several gigabytes of space and took over an hour to load and prepare. Impressive stuff.

Loading the normalized data set that I used for this article on OBIEE data modeling produced the following logical QlikView table diagram, which as you can see is a direct reflection of the normalized Oracle data model.

This ability to report against normalized data obviously makes setting up the data model easier compared to OBIEE (notwithstanding the need to rename columns to make and break associations), but it then doesn’t make any distinction between columns that are measures and ones that are dimension attributes, which makes working with data in reports a bit more complicated.

So once you’ve got the data in, how do you create a report? And more importantly, how do these reports compare to Essbase or OBIEE reports? The actual report creation process is a bit like working with tools such as Hyperion Interactive Reporting or Web Analysis in that you construct an application made up of crosstabs, graphs, gauges and the like, which are then run either in the thick-client Windows application or online using a variety of thick and thin web clients. If I wanted to create a bar chart that allows users to select the product category, month and state of purchase and then graph product sales broken down by customer satisfaction rating, I’d add three field list boxes to my document and then create a bar graph chart, which would be automatically filtered by whatever I select in the lists.

In the screenshot above, I’ve first selected the “Computers” product category which filters the graph, and highlights the states and months that have sales for this category. If I then selected the CA and NY states, only the months that are associated with sales (quantity) for Computers and CA / NY sales would be highlighted, and so on. As such, the “Qlik” part of Qlikview seems to translate to progressive filters of your data based on the items you have selected, with the filtered-down dataset being made up of the data that will join (or “associate”) with the data items that you have selected.

If you’re looking to produce Essbase-like reports where data is shown in hierarchies, this is a bit trickier. There isn’t really a concept of hierarchies in Qlikview; you can create column groups which group together columns that are related, but I can’t see a simple way to select column members, for example, by their position in a hierarchy which is pretty standard in OLAP tools such as Essbase.

Displaying data in hierarchies is a bit simpler, especially as QlikView automatically calculates the relationship between columns and their values so that, for example, if you display product categories and products in a pivot table chart, the product are automatically shown under the categories that they relate to.

What I found trickier (as in I couldn’t do it) was to create a pivot table with regions, for example, across the top of the pivot, or to add page items or other controls. I’ve only used QlikView for a few days and so I may well have missed this feature, but none of the example documents that came with either of these features and therefore I suspect that it’s not something that the product does, for the moment.

Working through the examples that ship with QlikView 9, visualizations and fast access to data seem to be the main strengths of the tool. For example, the Sparkline graph type that features strongly in Stephen Few’s “Information Dashboard Design” book is present and correct in QlikView:

As are butterfly financial-style tables, used for displaying P&L reports and other finance data.

One of the examples uses Google Maps to illustrate data, in this case around house for sale in London.

Where QlikView is weaker in my view, compared to any of the Essbase-backed query tools, is around number-intensive and hierarchy-intensive applications. It’s not easy to select dimension members via a hierarchy, the scripting and calculation language that comes with the tool obviously doesn’t support the richness of languages like MDX and Essbase calculations scripts, and of course there are not the applications such as Planning and Financial Management that you’d expect to make use of in the Finance Department.

That said, for what it does (provide fast access to star and normalized data sets, including data sourced from files and from the web) it does the job very well, with excellent load and preparation times and sub-second response times, even with large data sets. You probably wouldn’t use Qlikview instead of Essbase or Oracle BI EE as they address different requirements, but as a sales analysis tool or a tool to analyze OLTP datasets, it takes some beating.

It wouldn’t surprise me to find that Oracle or another of the big vendors acquires QlikTech at some point as QlikView would make a nice complement to the more enterprise, heavy-duty query tools, especially when tools such as this and the forthcoming Gemini from Microsoft threaten to create desktop BI tool “bridgeheads” on users’ desktops as they are just so easy to use and to set up (can you imagine getting Business Objects and all its technology stack up and running over a couple of evenings, for example, let alone learning how to use it?). It wouldn’t also surprise me if vendors such as Oracle do more to bring their database and query tool processing in-memory, given the amounts of RAM available on users’ desktops these days and some of the advances being made in data compression technologies.

Like last year’s Training Days event, the focus is on in-depth technical knowledge around Oracle BI EE, Essbase, Oracle Data Integrator and the BI Applications, with each of us running several sessions over the three days. Unlike other “beginners-level” courses this event focuses on real project issues and we’ll be going through the reality of designing, architecting, performance-tuning and integrating products across the range of Oracle’s BI and EPM product stack. I’m particularly pleased to have Venkat on board because of his deep knowledge of OBIEE and Essbase integration, and it’s great to have Christian presenting as well as he’s worked on so many successful OBIEE and Oracle BI Applications projects. Anyway, here’s the agenda for the three days:

• Day 1
• Oracle BI and EPM architecture overview – Mark Rittman
• Oracle BI EE Data Modeling against DW and 3NF sources – Mark Rittman
• Oracle BI Delivers + Integration with Java and BI Publisher – Venkat Janakiraman
• What’s new in Oracle BI, DW and EPM from Oracle Open World – Mark Rittman
• Day 2
• Oracle BI EE Data Modeling against Essbase – Venkat Janakiraman
• Leveraging MDX functions and calculations in OBIEE – Christian Berg
• Integrating Security across OBIEE and EPM – Venkat Janakiraman
• I can do this in Hyperion – how do I do it in OBIEE? – Christian Berg and Venkat Janakiraman
• Day 3
• OBIEE Systems Management with OEM BI Mgmt Pack – Mark Rittman
• OBIEE Configuration Management Best Practices – Christian Berg
• ODI functionality in Oracle BI Applications – Mark Rittman
• ODI Integration with Essbase, Planning and Oracle EPM Suite – Venkat Janakiraman

As with our BI Forum in Brighton earlier in the year, this is a great opportunity to meet and train with real-world Oracle BI and EPM consultants who have real project experience to back up their training materials. With lots of discussions and the opportunity for you to bring your own laptops and try out some of the techniques we discuss, this is a rare opportunity to take your OBIEE, Oracle BI and EPM knowledge up to the next level. Unlike the BI Forum though, this is an intensive three days with just three trainers, where we’ll look at topics in much greater detail and follow a common theme from start to finish.

Like last year, you can either book for just one day, or you can book for all three in a “three for the price of two” deal (though last year, everyone ended up staying for all three days). There is also an “early-bird” offer where we are discounting both rates by 10% up to the end of September, so if you’re interested in coming take a look at the event website for more details. The rate includes lunch on all three days and a special meal on the second night where we can kick back and discuss the world of Oracle BI in one of London’s top restaurants.

I’m really excited about this event and I know Christian and Venkat are as well. We only have twenty spaces available, so if you’re interested make sure you register now and we’ll see you in London in October.