| |
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).
|
|
