Eclipse's BIRT project.

Almost all end-user applications present reports on the data that they manage. These reports typically include charts such as pie and bar graph charts as well as data in tabular format that is formatted, sorted and aggregated. Content management systems are no exception. Unstructured information typically sits side-by-side with reports that present structured data in graphical or tabular form. It is common to find that application development teams treat the task of report development as secondary when compared to the task of developing the application specific logic. Java developers typically hand code or utilise JSP for their reporting needs, which limits the completeness and range of reports.

When the application enters its deployment phase or the user acceptance testing phase, or shortly after the application is deployed in production, users begin to use the application and find that the reporting functionality is rudimentary at best. A frequent request is to enhance the content of the application as well as its embedded reporting functionality. Other typical requests include additional output formats (spreadsheet, portable document format--PDF, or print), layouts, grouping, sorting criteria, ability to specify report parameters, embed images, calculate summary values on data, and include charts. Users also want changes to existing reports and the numbers of requests tend to increase the more successful the application becomes. Application developers soon realise that their time is best spent developing an appropriate infrastructure instead of developing reports. This leads to a division of labour between the content developer, the application developer and the report developer. The report developer expects easy-to-use report development tools, and focuses on developing reports utilising components and infrastructure developed by the application developer.

If the right technology framework choices are made when architecting the application, then it is easy to satisfy all these requirements. However, the time spent thinking through the requirements of the reporting architecture is typically insufficient to anticipate the kinds of requests mentioned above. This results in a brittle system where maintaining reporting code is time consuming, and limits the types of reports that can be created.

Eclipse's Business Intelligence and Report Tools (BIRT) Project

The Eclipse BIRT project addresses the reporting issues mentioned in the previous section by providing a reporting framework that allows developers to solve the reporting problem in their applications without resorting to hand-coding BIRT is an Eclipse-based report development environment in which Java and report developers can create complex, tightly integrated, and flexible report designs. These reports can access numerous types of data sources and deliver information in a variety of popular formats.

The BIRT report designer is implemented as a set of Eclipse plug-ins. The reports are created and stored in an XML format. The XML design can also be created or modified using the BIRT design engine API (DE API). Once the report design is complete, the XML file is then passed to the Report Engine API (RE API) for running and rendering the output. The output formats supported are PDF and HTML. The running and rendering operations can occur in one step or in separate steps. When run as separate steps, the running operation generates the report and stores it into an intermediate document (rptdocument), which is rendered at a later time. The Report Engine API can be used either in a standalone fashion, or embedded in a servlet, or called from an RCP application. BIRT also supplies the BIRT Viewer to render reports. This viewer is AJAX based and is delivered as an Eclipse plug-in or as a stand-alone servlet. The viewer wraps the RE API and supports Paginated HTML, Table of contents functionality, export to CSV and parameter entry. In addition to the DE API and RE API, BIRT supplies a Chart Engine API (CE API). This API is integrated within the designer to provide full charting capabilities within the BIRT report design perspective. The CE API can also be used in standalone operation.

BIRT High Level Task Flow

The BIRT Designer Perspective has a number of views for report creation. These views essentially wrap the Design Engine API and create the report design XML file.

BIRT Report Design Perspective

The Data Explorer view supports the creation of connections to data sources and identification of the data on which to report via data sets. XML files and streams, JDBC based RDBMS, and CSV files can act as data sources for BIRT reports. BIRT's extensibility supports the creation of custom data sources. Report parameters also defined in the Data Explorer view, tailor the report output based on input parameters. The Palette view contains the Report Elements that are used to present the report data identified in the Data Explorer view. To use a Report Element simply drag it from the Palette View to the Report Editor. All BIRT Report Elements support properties that can be configured in the Property Editor View and are described by the Report Object Model (ROM). The KOM is a schema definition for the Report Design and can be viewed at the Eclipse BIRT web site (http://www.eclipse.org/birt/phoenix/ref). Eclipse extension points are provided to facilitate adding additional Report Elements to the designer.

BIRT Views

BIRT 2.1 currently supports the following elements.

* Labels are used for displaying static text. As with most report elements the text can be externalised for localisation and supports such properties as hyper linking, font sizing and highlighting.

* Text elements are similar to Labels, with the additional benefit of being able to display multi-line formatted HTML. Values from existing Data Sets, Report Parameters, JavaScript functions, and special BIRT script functions can also be injected into the formatted HTML, using the BIRT Expression Builder.

* Dynamic Text elements are used to display CLOB data type values.

* Data elements are essential for displaying values from data sets.

* Image elements are used to include pictures in the report output. BIRT supports retrieving images from an URI, embedding the image in the report design, dynamic images (BLOB) from a database and image files in a resource folder.

* Grid elements act as containers for other report elements and are used to position them. Grid elements are displayed in tabular format.

* List elements also act as containers for other elements. Lists are different from other container elements in that they iterate over data sets that are bound to them. Lists are very useful in creating form letters.

* Table elements are similar to Lists in that they are container elements that iterate over bound Data Sets. They differ in that they present data in tabular format. The Table element layout is similar to an HTML table in that they have Header, Footer and Detail sections as well as columns.

* Chart elements allow charts to be inserted into the report design. Seven primary chart types and many combinations of sub-types are available. The Chart Builder provides drag and drop functionality, live chart preview, and data filtering and parameterisation. Chart elements can be rendered in PNG, JGP, BMP, and SVG output which support drill-through, highlighting, toggle visibility and client side script.

BIRT Viewer

BIRT supplies a viewer that wraps the Report Engine API. This viewer is encapsulated in an Eclipse plug-in that the BIRT Report Designer uses to preview the reports. The BIRT Viewer is also available as a servlet that can be deployed to a J2EE application server. The viewer has two modes of operation that correspond to two servlet mappings (run and frameset) within the viewer application.

The frameset mapping is used to display an AJAX based viewer that has controls for Table of Contents, Parameter entry, export to CSV, and printing the report. Additionally, this mapping supports paginated HTML and features a set of page navigation controls.

When using the run mapping, the reports are returned as PDF or HTML With this mapping the HTML that is returned is not paginated. This mapping also does not make use of interactive features such as Table of Contents and export to CSV. The designer uses this mapping when the preview tab is selected in the report editor.

Within the designer it is possible to launch the Viewer in a separate window. This enables iterative report development and speeds the report design phase.

BIRT 2.1 Overview

In conjunction with the Callisto release, BIRT 2.1 expands on the already impressive features of BIRT 2.0 and offer improvements in many areas. Notable ones include Joint Data Sets, Charting, and report parameterization.

Joint Data Sets

Data Sets are one of the fundamental BIRT elements for retrieving data. Data Sets contain tabular data, fetched from Data Sources, which can be used within the BIRT data container elements such as Tables and List. These BIRT elements are only bound to one Data Set. If the report developer wishes to display data from multiple Data Sources within a given Table this becomes complex. To address this issue, BIRT 2.1 now provides the ability to create a special Joint Data Set. The Joint Data Set allows combining two existing Data Sets using Inner and Outer Joins.

Charting Improvements

BIRT 2.1 introduces many charting improvements. Notable ones include a new Bar Stick subtype for Stock Charts, legend auto wrapping, improved interactivity and scripting, marker lines, enhanced axis scaling, legend text rotation, additional y axis support, added data point markers, and percentage pie charts. Rendering of Pie, Area and 3D charts has also been improved and a new PDF Device rendering feature is available to the charting engine.

Cascaded Parameters

BIRT currently has a very flexible parameter collection model, where the report designer can define very simple or complex parameters. With cascaded Parameters, a group of parameters are defined in such a way that each parameter choice affects the values available for selection in the next parameter within the group. For example, if a report is written that is presenting geographic sales data, a user of this report may only want a particular region for a given country. This can be achieved by creating a cascaded parameter group containing two parameters, country and region. When presented to the end user, the country selection list would display all countries. After selecting the desired country, the second parameter list for region would then be repopulated with only the regions for the desired country. In prior versions of BIRT, the report developer was limited to using just one data set to drive both the parameters in this cascaded group. This is no longer the case, Cascaded parameters now support multiple Data Sets. At each subsequent level of the cascade parameter group, an entirely new query is possible, perhaps even from a different Data Source. The nested query can then use the prior parameters within its query to cull the result set.

Use of BIRT in a TYPO3 Project

BIRT supports the following highlights that are considered important to users of TYPO3:

* Ease-of-use: BIRT's point-and-click and drag-and-drop capabilities make it easy to design reports quickly and continue to maintain them over time.

* Templates: BIRT Templates act as starting points for report development and capture standard visual look-and-feel characteristics of web sites. Developers can create their own templates and make them available for use by others in their team.

* Feature Rich/Extension: BIRT embraces Eclipse's philosophy on extensibility and provides the developer with an easy way to extend its rich base feature set.

* Libraries: BIRT supports the creation of report libraries that are archives of reporting elements. A library could contain the company header or a complex chart. Once developed, libraries can be made available to any BIRT developer. If a change is made in the library, reports that reference it will automatically be updated. This will speed the process of creating and updating reports.

* Charting: BIRT provides an integrated charting module that comprises a rich set of charts that are extensible.

* Stand alone APIs. Integration with PEP can occur in several areas. First would be to use a Java bridge and call the BIRT engine to generate and return the content. Currently the BIRT team is actively involved with Zend to produce an example of this integration. Similarly the chart and design engine APIs could be called. PEP can also be used to generate a report design dynamically. As stated earlier report designs are just XML documents. See the BIRT Website (www.eclipse.org/birt/phoenix/deploy/usingPHP.php) for an example using this approach.

Summary

Developing reporting functionality for Java applications can be an arduous task if undertaken without sufficient thought given to selecting the right framework. Reporting requirements quickly extend far beyond the facilities that are envisioned. Eclipse's BIRT project has evolved nicely with the 2.1 release providing a large set of features that improve its usability, scalability, and extensibility while appealing to a wider audience. It is an open framework with sufficient functionality to handle a large variety of reports.

Applications that handled both unstructured and structured data benefit from the use of Eclipse BIRT. Content management systems in particular can easily embed structured fragments that consist of appealing graphics and text. BIRT is well suited to integration with leading CMS such as TYPO3.

www.eclipse.org