I work with the Essbase Java API quite a bit. In fact, it’s more or less the reason that I picked up Java oh so many years ago. If you’re writing an app to do custom queries against a cube, need to develop a middle tier for your mobile app, or want to pull some cube stats, it’s the place to be. For me it’s a lot more useable than the C or VB APIs.
That being said, working with it can be a little challenging sometimes. Not because of inherent complexity, but because it was designed quite some time ago (especially in technology years) and before a lot of Java niceties came to be. In particular, there are iterators and other constructs that require a fair bit of boilerplate code to deal with. Here’s an example of getting a count of connections from the server:
public int getConnectionCount2(String username, String password, String server) {
IEssbase essbase = null;
IEssOlapServer olapServer = null;
try {
essbase = IEssbase.Home.create(IEssbase.JAPI_VERSION);
olapServer = essbase.signOn(username, password, false, null, "embedded", server);
IEssIterator connections = olapServer.getConnections();
IEssBaseObject[] connectionInfoObjects = connections.getAll();
logger.info("Connection count: {}", connectionInfoObjects.length);
return connectionInfoObjects.length;
} catch (EssException e) {
logger.error("Essbase error: {}", e.getMessage());
return -1;
} finally {
try {
olapServer.disconnect();
essbase.signOff();
} catch (EssException e) {
}
}
}
Wow, that’s a lot of code – just to do something that’s ostensibly simple. We can’t realistically expect Oracle to overhaul their API. While it’s technically possible to create a new API (from Oracle’s standpoint) that’s also unlikely to happen. Unwieldy though it may be, it’s battle-tested and thorough (although a few of you out there are miffed that it doesn’t have support for varying attributes).
So if we can’t expect the API to be refactored and offer us some syntactic sugar, and can’t write a new API, what can we do? There’s another approach: wrap the API with another library with the express intent of making the Essbase Java API easier to use, less verbose, and leverage modern language features where it makes sense.
To that end, a side project of mine has been to create such a library, called the Java Antikythera Layer for Essbase (JALE). Here’s an example of some new code that can iterate the current Essbase connections. Note that this isn’t a direct replacement for the above since they do slightly different things:
@Test
public void testGetConnections() throws Exception {
try (OlapServer server = Ess.create().signOnEmbedded(SERVER, USER, PASS)) {
for (OlapConnectionInfo connInfo : server.getConnections()) {
System.out.println("Conn info: " + connInfo);
}
}
}
Note that this is taken from a unit test in one of the projects I have for this little experiment of a library. As the library evolves more or as more people are interested I’ll post more samples and open up a GitHub repository. Some things to note about the above code-snippet and the design of the wrapper layer in general:
- Adds a convenience signOn method (signOnEmbedded) to make the intent of the method instantly understandable versus passing in a parameter called “embedded” as the current API requires.
- Drops the IEss prefix on classes/interfaces. Modern IDEs have reduced the need for this quasi-Hungarian notation.
- Instead of returning an an array of objects that need to be iterated and cast to their real types, a List of the expected object is returned (server.getConnections() returns the list).
- Java 7’s new “try-with-resources” construct is used and the JALE server object implements AutoClosable, obviating the need for a finally block here.
- Also note that JALE wraps the EssException in disconnect/signoff methods so we don’t need a dummy try block inside our finally block.
- Ess.create() is a convenience method that auto passed in the IEssBase.JAPI_VERSION static field. We can use an overloaded method if we need to call it with that parameter.
- The more astute of you out there may notice a couple of other things. :)
Internally, JALE has a utility library designed to help ease the implementation of replacement classes and call the right methods. Of particular note is an “IEssIterator” unroll method that is a veritable Swiss army knife for easily replacing the boilerplate code around the Essbase iterator. For example, check this bad boy out:
public class IteratorUtil {
@SuppressWarnings("unchecked")
public static <E, F> List<F> iteratorToList(IEssIterator iterator, ConversionDelegate<E, F> delegate) throws EssException {
List<F> objects = new ArrayList<F>();
for (int index = 0; index < iterator.getCount(); index++) {
E object = (E) iterator.getAt(index);
F converted = delegate.convert(object);
objects.add(converted);
}
return objects;
}
}
[/java]
Then in our wrapper for the traditional Essbase server object, we can do this:
[java]
public List<OlapApplication> getApps() throws EssException {
return IteratorUtil.iteratorToList(olapServer.getApplications(), new ConversionDelegate<IEssBaseObject, OlapApplication>() {
public OlapApplication convert(IEssBaseObject from) {
return new IEssOlapApplicationWrapper((IEssOlapApplication) from);
}
});
}
Note that conversion delegate is a one method interface that just supports the generified convert method. It’s designed so we can just supply a lambda-esque convertion method block in the new method (in this case, getApps()) which in this case contains our logic for going from an IEssbaseObject to the designed type of OlapApplication (a new object in JALE).
Future Directions on JALE/a Hyperion Essbase API wrapper
There’s no timeline on a public release of JALE. At this point it’s highly experimental as I evaluate its feasibility. I am just implementing method as I need them, so don’t expect to see me wrapping the MDX routines any time soon (not that I don’t use them but it’s not a section of the API that “needs” much fixing). I’m not worried about a performance hit from wrapping the API but I do have some concerns about performance if there’s something in the native API that loads lazily or otherwise needs an active connection to the server that would cause things to act up when I wrap them an enumerate on them, for example.
As with all of my little side projects (particularly the open source variety), please let me know if you have any feedback or want to contribute. Unlike the others at this point, this one is very pre-alpha quality so I don’t have immediate plans to make it available, but jut wanted to discuss some of the things I am thinking of an working on.
