Product Overview
Dynamic
O/R Mapping™
CocoBase aids in the creation, management and maintenance of database
access for Application Server / J2EE components and J2SE Java programming
classes. CocoBase®
supports an unlimited styles of mapping starting with one to one /
one to many / many to many relationships.
CocoBase®
takes the database specific code and pre-written SQL out of the object
and saves this information to the mapping layer (i.e. map). Thus decoupling
the object from being hard coded to the database. The database specific
code and SQL is dynamically created at runtime. This allows objects
to be easily reused over and over. This dynamic layer provides a multitude
of performance and scaling optimizations that are easily changed by
the programmer to best fit their specific needs.
Dynamic
Transparent Persistence™
CocoBase® provides transparent object persistence for both development
of EJB and Java classes.
CocoBase® can persist complex data object graphs in both a local
and distributed environment that can be managed with a few lines
of code. This
provides completely reusable components for the developer with no
CocoBase code in the object required.
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.
Dynamic
Universal Querying™ with EJB-QL
Powerful
and easy-to-use querying system for issuing meaningful queries with
EJB-QL and/or CBQuery Builder API across the J2EE, J2SE and J2ME
platforms.
UML Modeling
Tool Integrations
CocoBase® works side by side with the following modeling tools
such as Embarcadero Describe, Rational Rose, Together Control Center
and Sybase Power Designer. Simply import the model and generate
the persistence code.
EJB Support
CocoBase® provides full Application Support for CMP / BMP Entity
Beans, including the EJB Component Transaction model, Java Server
Page compatibility for fast Internet user interface construction,
and full enterprise oriented management tools designed for the entire
J2EE technical requirements for database integration. This is done
for all of the top EJB Servers!
Java Development
Environment Integrations
CocoBase® is fully integrated with Forte for Java from Sun Microsystems®.,
JBuilder from Borland, and Visual Age from IBM. CocoBase® Enterprise
O/R is available to easily work within your Java development environments.
Simply call CocoBase® from within JDE, create database map,
generate cmp/bmp/jsp, and deploy to application server.
Application
Servers Integrations
CocoBase® is now tightly integrated with the top application
servers providing both CMP & BMP Entity Beans that work seamlessly
with the server. Supported servers include; BEA Weblogic, Borland,
IBM WebSphere, JBoss, Macromedia JRun, Oracle, Orion, SunOne, Sybase
EAServer and Tomcat.
Customer
Service
We provide superior customer service and quickly respond to both
technical and sales inquiries. We pride ourselves on top-level technical
support and rapid response times. Specific services available are:
1) In-depth training,
2) Architectural Mentoring to facilitate best use of O/R Mapping
and CocoBase, 3) Expert-level Sales Engineering, and 4) Rapid Response
Technical Support. The combination of excellent customer service
and the full range of support services strongly supports companies
through to successful J2EE & J2SE applications.
Technical
Specifications
Persistence
Features
- Centralized
repository based mapping technology
- XML and database
repository formats
- Relational
database server independent
- Application
model independent
- Sessionless
"Offline App" Data Persistence
- 100% non-intrusive
transparent persistence
.....* No source or byte code post-processing
.....* No proprietary interfaces
or superclasses
O/R
Data Mapping
- Direct field-to-column
mapping
- Multiple
table to single object mapping
- Multiple
object to single table mapping
- Inheritance
mapping
- Operation
based SQL management
- Single and
composite key support
- Comprehensive
JOIN support
- Supports
stored procedures and functions
- Supports
proprietary SQL (i.e. dialects) on all
operations
- Supports
any sequence generation strategy
- Supports
multiple sequence generators per map
- Support for
cartesian products & other denormalized
resultsets
- Supports
JDBC 1.1 & 1.2 datatypes (e.g. ARRAY
CLOB, BLOB, etc.)
- Configurable
read-only & write-only field mapping
- Configurable
optimistic & pessimistic locking
- Support for
multiple inheritance mapping strategies
in a single class hierarchy
- Classless
mapping (no Java business class
required)
O/R
Relationship Mapping
- Uni- &
bi-directional relationships
- 1:1, 1:M
& M:M relationships
- Cascade control
(e.g. cascade deletion) on all
operations, & in local and distributed environments
- Local and
distributed lazy loading
- Automatic
key constraint management (maintains
referential integrity by proper ordering of database
operations)
- Supports
recursive object graphs to any level of
complexity
- Out of the
box relationship proxies for dynamic link
loading and management
- Relationship
proxies for Java 1.1 & 1.2 collection
fields
- Relationship
proxies for 1:1 field types
- Extension
framework for custom relationship
proxy classes
Performance
- JIT optimized
runtime
- Out of the
box 200% - 300% performance advantage
over hand coded JDBC
- Up to 4000%
performance improvement with optimal
configuration
Persistence
API
- No SQL or
JDBC required in application code
- Persistence
by reachability for all operations
- Customizable
instance factories (e.g. polymorphic
instantiation)
- Customizable
persistence plug-ins (e.g. data
conditioning pre & post - JDBC layer access)
- Layered API
architecture with extensive
documentation and examples
- High level
CBFacade API for local or distributed,
object & object graph life cycle management
- CBFacade
architecture provided as source code
- Object oriented
transactions w/ smart updates
- Batch updates
- Development
Tools
- UML/XMI,
class & table importers render complete
data models in seconds
- GUI integrations
for major IDEs focus on business
application development
- Map repository
export feature allows easy porting
from development to deployment platforms
- Free form
SQL and EJB-QL test consoles
- Command line
tools available for scripting
CocoBase
Dynamic Querying
- Built-in
query by example system for field based
queries
- Query builder
API for complex querying
- Declarative
EJB-QL API for dynamic querying
- Abstraction
allows map based queries to be
database schema independent
- Object based
& relational based queries can be
combined through a common base infrastructure
- Raw SQL can
be embedded within any query
- Local and
distributed scrollable cursor based
querying
- Supports
projections and classless querying
- Support for
scalar functions (i.e. count, max, etc.)
Enterprise
Highlights
- Smart reconciliation
- object identities preserved
across serialized copies
- 2 to N tier
architectures fully supported
- Local, shared
(single server) or distributed (peer to
peer) caching
- Supports
J2EE distributed transactions
- Seamless
CMP & BMP integrations
- Configurable,
multi-level debug & SQL listings
Compatibility
- 100% pure
Java
- Works with
any JDBC 1.1 or 1.2 compliant driver
- Works with
JDBC 1.1 & 1.2 datasources
- J2EE Integrations
with major application / EJB servers
- GUI toolset
integrations with major IDEs
..
..
Detailed Descriptions
Object
to Relational Mapping
Powerful
Dynamic O/R Mapping™.
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.
Centrally
Managed Access to cut database administration costs to almost
zero.
CocoBase®, first
of all, provides an easy to use Object to Relational point and
click GUI mapping tool.
This tool allows full control
down to many to many relationships and is the only tool on the
market that can handle fully table spanning select, updates, inserts,
deletes, and procedure calls with out recompile of the Java application.
Because reconfiguring of the database can happen on the fly without
recompile or reload of every Java application, database administration
costs can be cut to almost zero.
Tool is
written entirely in Java.
The tool delivers
wide portability as it is 100% Java and can run anywhere Java
does.
VERY High
Performance O/R Layer.
Offers
a no-overhead mapping layer (plus or minus a few percent versus
straight JDBC code). The overhead is typically not measurable
and the resulting O/R code is often more efficient than hand coded
JDBC code. Most O/R systems advertise around 20% overhead, CocoBase®
is at most a 1-5% overhead or performance boost on most systems.
DBA's
create/manage the Data Objects and the Programmers can just use
them.
No need to be an
expert in JDBC / Databases / Tuning SQL / etc. thus providing
good separation of duties that capitalizes on each groups talents
and saves time and money.
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.
Architecturally
Designed to be EXTENSIBLE Everywhere.
CocoBase®
is designed to be extensible EVERYWHERE for the developer (i.e.
it is NOT a closed system without scriptability or proper extensibility).
CocoBase® has open APIs for every key aspect of the system,
and is written completely in Java, making it more useable with
standard IDEs, Modeling tools, etc. The key integrations with
other products such as Caching Databases, Proxy Objects, etc.
are all included as Open Source code for easy customization.
Out of
the box compatibility with any JDBC supported Database.
Supports
all of the most current relational databases that are support
by a JDBC driver, such as Oracle, DB2, Microsoft, Sybase, etc.
Reduced
Time on Development / Maintenance.
With ability to
Modify Maps at runtime instead of compile-time.
No need
to Recompile Application due to Database Changes.
Patented
Technology protecting Future Use.
We hold the key
patent on repository based O/R Mapping. We created this concept,
delivered the first implementation of it in the market, and have
the oldest most mature Java O/R product available.
EJB
Support
Full support
for both EJB 1.0 , 1.1, 2.0 including CMP / BMP Entity Beans and
Session Beans. Full Support for JDBC 2.0.
Editable
Template based Code Generation of CMP & BMP Entity Beans.
Dramatically
reduces time spent hand coding and the errors along with it.
CMP Entity
Beans that work with virtually any EJB Server.
By
using our CMP Installer Tool, and developers can customize this
extensible tool for their own installation and configuration requirements.
Increase
speed of EJB Applications by up to 4000% / More...
Over
hand coded, non pooled JDBC with our optional smart fetching.
If an EJB server supports connection pooling, we're typically
about 30% faster than regular hand coded JDBC due to our smart
fetching. In most, if not all cases, CocoBase® is at a minimum
just as fast as JDBC (i.e. no real speed degradation due to our
persistence framework). We recommend that developers do performance
testing in their own environments to ensure performance levels.
Our plug-in allows cache databases to be used transparently from
an EJB, a profound performance implication for busy corporate
databases.
CocoBase®
CMP that supports a bean being persisted to multiple tables from
multiple databases, table joins and supports relationships!
E-Commerce
Shopping Cart DEMO that shows working examples of CMP and BMP
Entity Beans, Stateful and Stateless Session Beans
(request
CocoBase® Enterprise O/R to retrieve this demo example).
Extremely
Scalable
With support for
a wide variety of platforms and databases.
Solution
is Portable across standard EJB Server Vendors
Not all EJB servers
are standard, so please ask your server vendor if the support
the complete EJB spec. as well as Container and Bean managed persistence.
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.
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.
Ability
to tightly integrate with any EJB Server.
By
creating and editing a new CocoBase® Template for that server.
Widest
range of Support for Databases and Application Servers in the
Market.
The CocoBase®
family of tools provides extensive support for the current range
of databases (relational, object, mainframe, etc.), application
servers (EJB), JDBC drivers, CORBA Orbs, development environments,
etc. This gives our customers the most options, least risk and
greatest opportunity for success.
Customer
Satisfaction
Top Level
Technical Support.
We
are known for having one of the best support organizations in
the business. Our competitors are known for saying "well
you can always have our consultants come in and fix this"
when their products don't deliver what they should. We by comparison,
don't have a consulting arm, and therefore don't have incentive
to build products that require consulting to deliver on the promises
made, a seemingly all to common practice.
Ease of
Doing Business.
Customers and partners
who work with us have found that we are much easier to deal with
than most organizations. We are clear, focused with a clear corporate
and market mission. We are not a consulting company that gives
away tools to get more consulting business.
FREE 30
Day Use of the Software available by Internet Download.
CocoBase® is
free to use for thirty days making it easy to evaluate the tool
prior to purchase. The tool is available at any time to anyone
with an Internet connection simply by requesting it from the website.
An email is sent to you with the download location.
Dramatic
Cost Savings with NO Server Fees OR Runtime Fees !
CocoBase® Enterprise
O/R is sold by the developer license and does not charge runtime
or server fees. We have found this to be the lowest cost model
for our customers. We hear stories of server fees or deployment
fees being prohibitively expensive that makes the cost of doing
business unworkable.
Technical Details
Generate
all Entity Bean code needed with standard default implementations
for top Application Servers.
Vendor
specific descriptor files automatically generated. Compile and
Jar generation scripts automatically generated. Runtime Environment
and Map-Cache management files automatically generated.
Enterprise
level Caching Support.
CocoBase®
supports caching as a plugin with an example shipped as source
code for customers. Automatic integration with Javelin from eXcelon
as well as other integrations coming soon. Customers can also
integrate their own caching solution into the tool.
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
Admin. Tool 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
Admin. Tool 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.
Extensive
Querying Abilities.
Extensive
Abilities to Query Across Database tables, and by extension across
Object Relationships. Unlike many O/R layers that use proprietary
or closed querying facilities, CocoBase® relies on the underlying
SQL of the database for the most robust querying possible. The
maps can include complex table spanning and nested SQL statements,
as well as access to relational Stored procedures. Since each
CocoBase® map can span any number of tables, CocoBase®
maps are completely extensible, and will not restrict the developer
on Querying functionality. With full Stored procedure support,
the querying options are vast.
Full Inheritance
Support.
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).
|
