Thought inc.

The Dynamic O/R Mapping Company
  case studies
  tech support

standards based  


CocoBase is a Standards Based,
Open (non-proprietary)
Dynamic O/R Mapping Tool


POJO / JDO / J2EE / J2SE / EJB 2.0 / JDBC 2.0 / JMS 1.0 / JDK 1.4


The CocoBase Dynamic - Repository based O/R Mapping architecture is based on the major industry standards, ensuring that customers have a solution that fits their needs in an expected manner.

POJO Data Persistence

POJO - Sun announces new direction for data persistence with plain old Java objects, spec. expects to be released in late 2005 or early 2006

The CocoBase® tool offers Dynamic Transparent Persistence (i.e. transparent to the object), both locally and distributed with an integrated Query Manager for use with standard plain old Java Objects that is now being referred to as Dynamic POJO Data Persistence.

POJO Data Persistence can be defined as an unified persistence and query manager for local J2SE and distributed J2EE environments which is completely transparent to the object and does not require the modification of the byte-code of the object. Enterprise JavaBeans is a distributed method for persisting data that has proven to have some key drawbacks that have over time limited the use quite dramatically. Java Data Objects (JDO) is a local (non-distributed) method for persisting data. Combining the best points of these two standards into a local and distributed method that is transparent to the Java object is the apparent goal of the new POJO specification. The CocoBase® implementation of POJO Data Persistence is quite flexible and as the new specification is clarified and finalized any changes needed to conform should be made.

The CocoBase® Dynamic POJO Data Persistence™ is fully portable, extensible, and scalable. It is vendor neutral and 100% portable across J2EE/J2SE compliant systems. There is no need for the developer to write database specific code in order to persist objects. The transparent nature of the persistence makes it possible to track and persist any object type, including POJO's, EJB Entity Beans, CORBA objects, RMI objects, and Java classes without the requirements of query language in application code, or object model intrusion.

The CocoBase® Dynamic POJO Data Persistence™ allows the developer to persist relational data with a simple, non-invasive, widely distributable object. These capabilities operate as an extensible persistence layer - invisible to the object. Without any byte code or object model intrusion it runs on local, as well as distributed environments, and is designed to minimize maintenance without sacrificing performance. It is built for both J2SE and J2EE performance. Objects are versatile enough to be reusable, and to persist and manage objects simultaneously across a wide number of databases. CocoBase® employs an independent persistent monitor - invisible to the application object - which persists, retrieves, and reconciles copies of objects to ensure proper network programming and serialization with its persistence facilities. The Dynamic POJO Data Persistence™ can also manipulate multiple copies within the same JVM, so as to enable threaded servers to have a unique context and persist on parallel transactions.

See Dynamic POJO Data Persistence whitepaper >>


JDO 2.0 - Awaiting Finalization of the 2.0 Version to release JDO into CocoBase.

CocoBase is in the process of adding in an implementation of Java Data Objects (JDO), a local (non-distributed) method for persisting data. This can be a very good solution for customers and Thought Inc. is excited to offer this technology.


EJB 2.0 - Using Entity Beans

Full support for both EJB 1.0 / 1.1 / 2.0 including CMP / BMP Entity Beans.
CocoBase provides complete support for the EJB component model, including full and uncompromised support of Bean Managed Persistence (BMP) and Container Managed persistence (CMP). We also generate standard Java classes and EJB components, from user editable code generation templates that are simply property files and 100% customizable as needed.

We also generate fully optimized and portable EJBs. Since application servers all interpret the EJB specification slightly differently, our CMP / BMP Entity Bean Code generation helps ensure that developers are concentrating on business logic, and not worrying if they are coding a bean that will work properly in their server environment.

Our portable CMP installer supports more EJB servers than all other O/R or server solutions put together. This portable CMP is so revolutionary, that the architecture has been adopted as the J2EE specification for how to implement CMP persistence for EJB.

CocoBase CMP is a significant extension over built-in CMP through support of dependent objects, built-in support for sequences and identity columns, support for value object single network transfer of the Bean state (remotely not just locally), real O/R mapping including the ability to retrieve and persist a Bean to and from multiple tables and a variety of other advanced features that turn the CMP into a solution for the enterprise and not just a prototyping solution.

Benefits of using CocoBase for EJB;

  • CocoBase CMP that supports a bean being persisted to multiple tables from multiple databases, table joins and supports relationships!
  • Ability to Map all your data sources to your Enterprise Java Beans.
  • Provides a simplified layer for persisting your Java classes with EJB, without requiring embedded JDBC & SQL calls in your objects.
  • Manage complex relationships between Entity Beans, and between Entity Beans and non-beans (important for EJB Server performance).
  • Auto generates methods to Serialize Bean data. Between client and server all at once, instead of an attribute at a time - essential for enterprise scaling!
  • Works with any standard JTS service included in the EJB servers. CocoBase doesn't require proprietary extensions to the JTS of the EJB Server in order to ensure transactional and data integrity for either Session Beans, BMP or CMP Entity Beans, and is fully compatible with any of these component types.
  • Support for Sequences and Identity Columns for primary key generation of Entity Beans.
  • Support for Proprietary SQL of databases.
  • Dynamic loading of Maps & SQL generation at runtime so BMP & CMP beans remain completely portable across databases even when schema/table layout is different. This feature doesn't require redeployment or recompile unlike other less refined CMP implementations.

EJB 2.0 - NOT Using Entity Beans

For the J2EE (Enterprise Edition) platform when customers are not using Entity Beans, there are three other enterprise level technologies that can be used to provide persistence. Session Beans, Java Server Pages, Servlets, and Dynamic Transparent Persistence™ are methods for persisting data supported by CocoBase.

Session Bean Persistence
To use session beans with CocoBase, the bean directly calls CocoBase facilities such as the mapping runtime, database transaction object, navigation / transaction facilities. CocoBase provides two examples for users that can be easily adapted their specific requirements. The first example is an application session bean that is used for just one application and provides the persistence needed. The second example is a generic session bean that handles all of the persistence for multiple applications if desired. This session bean acts like a persistence server, easily managing all of the varied data access and any complex relationships if they exist. We refer to this functionality as Distributed Transparent Persistence and provide a pre-built Session bean for this functionality.

Java Server Page Persistence
To use Java Server Pages with CocoBase, once the mapping of the tables and objects is completed, CocoBase will generate the JSP for you from editable templates. The JSP also directly calls the CocoBase facilities such as the mapping runtime, database transaction object, and navigation / transaction facilities to get data persistence. An example of using CocoBase with JSPs is available on the download page specially built for Tomcat to demonstrate this feature. The JSP support however is generic.

Servlet Persistence
To use Servlets with CocoBase, once the mapping of the tables and objects is completed, the developer copies in the code into their servlet to provide the persistence. Since Servlets are fairly complex to write and are greatly modified for each use, CocoBase does not generate them, however provides a system to manage the optimizations between the objects and relational tables necessary to increase performance and scalability.

Dynamic Transparent Persistence
Persisting complex data object graphs in both a local and distributed environment is greatly simplified to a few lines of code. This is accomplished dynamically thus not polluting the object graph allowing for optimal continued reuse. It is important to compare and contrast this development with existing systems such as ODMG and JDO. These specifications say that the APIs are open, however, in order to achieve a practical implementation the result becomes proprietary and vendor specific. This means that either the class must be rewritten by hand or rewritten by some tool to be compatible with their systems. The increased complexity and developer time to create and maintain such a large code base can quickly become unreasonable.

CocoBase's architecture by contrast doesn't require CocoBase code to be inserted into the objects or the object graph. Therefore reprocessing of source code or byte code in order to persist the objects does not occur. Instead, the CocoBase product can persist an entire graph of objects created elsewhere with no changes to either the object source or binary code.

Both ODMG & JDO require changes to the source or binary code of the objects. These approaches are both unnecessary and often increase error-prone code to an unacceptable level. Many consider the designs of ODMG and JDO to be counter to Java's open access - cross platform - component reuse design intent. While CocoBase's architecture makes Java classes vendor neutral, the other approaches deeply tie the source or binary code to only one vendor. Their system creates a Java class hierarchy that once processed and integrated by one vendor becomes completely incompatible with another.

This latest generation of CocoBase's technology can identify 'copies' of objects and parts of object graphs, and manage them in both a local and distributed environment. Entire graphs of objects can be copied to some remote machine, manipulated and then processed in some form to be returned synchronized with the original and the copy. CocoBase, using this facility, can manage virtually any serializable object graph.

J2SE Platform

For the standard edition of Java, CocoBase provides data persistence in two general ways through the use of Applets and Applications. With CocoBase the developer has full access to all of the mapping features including Transparent Persistence (i.e. ability to map simple to complex graphs of objects in a local and/or distributed environments with just a few lines of code), simple to complex relationships (i.e. one to one, one to many and many to many), and all of the performance / scaling managed by the runtime.

Dynamic Transparent Persistence
Persisting complex data object graphs in both a local and distributed environment is greatly simplified to a few lines of code. This is accomplished dynamically thus not polluting the object graph allowing for optimal continued reuse.

In the typical situation the architecture used is a database, webserver and a browser. CocoBase works between the database and the webserver to provide persistence. CocoBase also works with Corba servers (i.e. Orbs) and databases to provide persistence.

Using stand alone applications, CocoBase works between the webserver and the database to provide the data persistence.

JDBC 2.0

CocoBase® fully supports the key features of JDBC 2.0 including JDBC 2.0 types, JNDI connection pooling, JTS Transaction server compatibility, scrollable cursor support, user extensible type retrieval and JDBC 2.0 meta data retrieval. CocoBase® fully supports Blob & Clob types for jdbc drivers that a JDBC 2.0 compliant. Some drivers use non-standard & proprietary APIs for Blob & Clob access, so testing your driver for compliance is recommended.

JMS 1.0

CocoBase® can persist JMS messages, as well as leverage JMS for delivering distributed, clustered and fault tolerant caching. CocoBase® has expanded available caching options with an implementation of a JMS based distributed cache that can be used with clustering for JMS providers that support the clustering features. It is based on the current JMS specification and integrates with any standard third party JMS Messaging software.

The CocoBase® JMS Cache is designed to work with any JMS 1.0 compliant messaging software stand-alone or within the J2EE platform. As a result, the CocoBase® JMS Cache can also work with industry leading application servers such as BEA Weblogic, Sybase EAServer, JBoss and the Sun reference implementation application server.


CocoBase® can import and turn UML/XMI Object Models into persistence maps, DDL and table creation and generate a complete range of abstract Java classes, EJB components and JSPs that greatly simplifies the complex process of mapping and persisting relational data. This keeps developers focused on building business logic and not on hand-coding the persistence layer. Turning a conceptual model into a concrete application implementation has never been easier.

Users of Rational Rose, Together Control Center, Embarcadero Describe, Sybase Power Designer, ArgoUML, and MagicDraw Can Now Instantly Generate and Manage Database Access Directly from the Object Model With CocoBase®.

JDK 1.4
CocoBase has implemented and tested for compliance with the newest release of Java - JDK 1.4. The CocoBase system has been tested to run properly with JDK 1.4 for both the CocoAdmin GUI and the CocoBase runtime has been tested for Server usage.