Thought inc.

The Dynamic O/R Mapping Company

features overview
> pure pojo - ejb3
> magic mapper
> high performance
> product tours
> o/r mapping
> querying solutions
> cocobase is free
> eclipse, spring
> technical spec's
> whitepapers

  tech support

object to relational mapping  

Developers can easily create their mapping from Objects to Tables, Tables to Objects, and both Objects and Tables at the same time.

Patented, Highly Flexible Dynamic O/R Mapping Layer Architecture

CocoBase provides a powerful yet simple to use approach for persisting data that decouples the object from being hard-coded to the database. CocoBase takes the database specific code and prewritten SQL out of the object and saves this information to the mapping layer (i.e. map). The database specific code and SQL is dynamically created at runtime. This allows objects to be easily reused over and over enterprise-wide. This dynamic layer provides amazing flexibility as well as a multitude of performance and scaling optimizations that are easily changed by the programmer to best fit their specific requirements. The architecture is protected in landmark patents thus protecting the customer as well.

Architectural Highlights of Version 5.0;

  • Simple Persistence API -

  • Custom SQL on all CRUD operations is available which is easily editable by the developer. This allows developers to pre-define the SQL whenever it is prudent to do so.  Thus SQL can be generated either at runtime or at "design-time."

  • A new and totally decoupled “project-based” repository architecture is a major advance of the new version of CocoBase 5.   Provides total independence between the mapping metadata and the storage mechanism used to persist that mapping information. This means that CocoBase can load or store its projects and maps in a variety of formats (e.g. XML, binary, jdbc database, etc.). Even custom formats can be supported once a proper implementation of repository apis is provided.

  • Easily extensible tool and pluggable runtime architecture, with several interfaces that can be implemented to reflect any non-standard mapping behaviors that may be required by applications.

Most Comprehensive O/R Mapping Technology

CocoBase® Enterprise O/R offers a flexible and sophisticated system for meeting your Object to Relational mapping needs. The tool delivers mapping that easily evolves from the simple to the complex and gets out of your way when you need it to. It offers an easy to use GUI Admin. Tool that supports features such as; maps that span across tables, 1-1 1-M M-M relationships, maps in subsets of tables, sql is created and is tunable, maps tables from classes and classes from tables, automatic mapping that speeds the process of development, dynamic querying, supports proxy objects, configurable code generation, etc.

Sessionless "Off-line Application" Data Persistence

This helps to simplify web application development for applications that are used in off-line environments like a web browser. It provides the ability to have an application reconnect to the persistence layer and call up the information from the previous connection (i.e. reset the session state). The persistence layer will then automatically reconcile any changes to the object model and related data and save them with the appropriate database commands. This provides required data integrity and optimistic locking for off-line environments, even when complex object models are used, greatly simplifying development of these applications.

Relationship Support

Automatically supports all types of relationships.
CocoBase® auto detects foreign keys, supports bean to bean and bean to object relationships, can auto persist a graph of objects with no changes to the classes or their relationship code which is a non-invasive architecture that simplifies development. CocoBase® support for relationships is one of the most thorough and complete in the industry which does the work for you, not just support it and still let you write all the code.

Automatically supports all types of relationships

CocoBase® auto detects foreign keys, supports bean to bean and bean to object relationships, can auto persist a graph of objects with no changes to the classes or their relationship code which is a non-invasive architecture that simplifies development. CocoBase® support for relationships is one of the most thorough and complete in the industry which does the work for you, not just support it and still let you write all the code.

Increased Flexibility and Reuse with Support for any Inheritance Tree.

By keeping this support available to any inheritance tree the customer desires with the same maps CocoBase® avoids the traditional trap of a rigid approach that tightly glues O/R to a narrow and specific inheritance tree. This rigid approach can severely limit the long-term usefulness of an O/R tool in reasonable sized projects or organizations.

Enterprise level Recursive Object Support.

CocoBase® offers both a Factory and a Plugin model where developers can lookup, retrieve, cache, link, etc. any sort of recursive option they desire.

Upgrade Relational Table to Object Schema.

Upgrades a relational table to a CocoBase® Object schema automatically in seconds. This creates a CocoBase® Object wrapper for the specified table and leaves the table unaffected. This is a deceptively simple tool that provides rapid jump starts for creating immediately available Internet ready SQL views of existing databases for development projects.

Generate Java Class Source Code from Schema

Takes a CocoBase® Object schema and generates Java Class Source code. This allows you to represent the data objects defined by you as Java Class files. This saves a great deal of time in generating new Java code because the code is written it for you.

Create SQL Tables from Java Classes

The Workbench is an easy to use, point and click tool that allows to create SQL tables from CocoBase® Java classes and non-CocoBase® compatible classes. This can be accomplished using the graphical workbench or as a command-line tool with an API which can be called from your own programs. It creates a table in your database and also creates a CocoBase® object schema for you.

Enterprise Extensibility built into the tool and at each Integration Point

The CocoBase® architecture was designed entirely with the idea of being completely extensible to the developer. Every point of integration, every built in function, every facility, even code generation is 100% customizable and extensible. CocoBase® does most of the work for you and can get out of your way when you need it to.

Broad Support for All Types of Mapping

CocoBase® supports the broadest range of ways to map data. The mapping technology is designed for flexibility needed for development from simple to complex enterprise applications. The mapping is more generic than most other O/R tools and features the ability where a single map can support many different behaviors and relationship types simultaneously ( 1-1, 1-M, M-M, etc.). Many to One, Many to Many can be interchanged on the fly with the same map, and with no map changes! Most O/R tools have rigid, inflexible and in our opinion virtually unusable rigidity in their mapping, which tries to constrain mapping to one and only one possible use.

Full Inheritance Support.

Unlike many O/R tools, CocoBase® doesn't have rigid Inheritance requirements. Mappings can be used by most any inheritance structure without change. Inheritance models, and placements of attributes can change on the fly with no changes to CocoBase® Maps! The rigid mapping of most O/R tools requires a great deal of maintenance and modification for even the slightest of changes to an Object model. A Map in CocoBase® is MUCH more flexible than with other O/R tools. CocoBase® provides flexible - dynamic binding between any number of object structures and object relationships, thus reducing cost and improving time to market, increasing the viability and flexibility of large Java projects. In other words, CocoBase® by comparison to other O/R tools more loosely binds mapping, making the possibilities exponentially more flexible and easier to use.

Ease of Use for Inheritance

Unlike other O/R tools which require attention to their arbitrary definitions of what Inheritance is, CocoBase® can support any inheritance model a developer may wish to pursue, without special mappings or changes to existing maps... CocoBase® simplifies the use of inheritance and increases the flexibility, by allowing a map to be used against any inheritance structure that may be required. CocoBase® can persist parent objects, children, proxied data, etc. all with a single map! Most other O/R tools have no such flexible concept, and thus are really designed for more simplistic and rigid prototyping instead of the 'real' enterprise world where you may wish to share a single map across multiple development projects. With CocoBase® your DB experts can define optimized maps centrally that could be shared across different objects and different hierarchies with NO modifications to the map (i.e. no need for remapping each and EVERY project which is error prone and increases maintenance).