- An Object Oriented Distributed Computing Platform
Clear ODB is a Distributed Computing Platform and Object Oriented / Graph NoSQL Database.
Clear ODB provides an easy, fast and efficient way to implement distributed applications. It is built from the core to take
advantage of object oriented design all throughout from API to data storage. The main design goal
has been to make the developer's life easy.
Clear ODB is a client / server system, very much like a traditional database.
The Clear ODB server installs on a server machine and your application connects as a
client to the server through the Clear ODB API. The Clear ODB API comes as a static library (c++) or dll (.Net).
The API knows how to store objects and linkages between objects. When committing objects to the server,
the Clear ODB API knows how to find linked objects (through pointers/references) and sends any updated or
new objects to the server.
Retrieving objects is done either through select statements (through the C++/Java/C# interface) based on member
field values or by direct object lookup.
Faster Development Cycle
- Use one language for application programming and data modelling
- If your application requires to be written in an object oriented language,
the drawback with existing data storage solutions is usually that you need
to use another language for modelling the data for that storage (i.e. if storing in
a relational database, you design the tables etc in SQL). Using Clear ODB, you only
use C++, or you only use C# or only Java for example.
- Storage data model same as runtime model
- With existing solutions, you normally end up having to design your
classes in both your application language (e.g. C++) and model them in a database tool (or SQL), or you
may end up designing file formats. With Clear ODB, you only model your C++,
or C#, or Java classes. There is no need for duplicate data models just for storing your data.
- No storage to runtime transformation required
- With Clear ODB, there is no need for coding the input or output code in order to
store or retrieve your data. With a minimum of declarative code, the Clear ODB's API understands
how to convert the runtime objects into the storage format.
Better Data Modelling
- Object oriented modelling is a better fit to many real world problems
- With Clear ODB, you can still use all data modelling features
of your favourite language. It supports inheritance (including multiple in C++), and
polymorphism, and object ownership relations just as you would expect from an object oriented language.
These features would be hard or impossible to model in a relational model without a performance impact.
- Develop processes and algorithms that fits an object oriented model
- Encapsulation of functionality and generic programming are two of the core strengths in object oriented design.
By being able to use inheritance, Clear ODB makes it easier to create applications the way that was intended with object oriented design.
If you are forced to mix two programming paradigms such as relational and object orientation, it requires more effort
to create systems that have clear cut interfaces; or where functionality can be reused thanks to polymorphism for example.
- Type safe; no casting from database types to runtime types required
- Clear ODB takes care of any casting, if any. Data is normally stored in it's primitive binary format. Primitives, strings, pointers,
classes are all converted to the expected data types. There is no need for explicit casting.
- Atomic commits & transactional data storage
- It is important that your data is saved safely and that referential integrity is maintained at all times.
When Clear ODB returns successfully from a commit, you can be sure that the data is stored on disk. Storing potentially a large number of
objects in one commit, is done as one atomic transaction. Either the entire transaction is stored successfully, or there are
no changes to the data on the server.
- Objects can never be updated concurrently. A locking and versioning mechanism ensures that
only one client updates an object in an ongoing transaction. If a client tries to update objects that are
currently locked, the transaction will fail.
- Successfully completed transactions stays completed, even after a hardware failure. Data is always
appended to the data store, and old transactions are never overwritten.
- Client / server architecture
- The Clear ODB system consists of a database server (proprietary back-end) and a client interface that links as
static or dynamic libraries to your application code. On Windows, the server runs as a standard Windows service.
- Object queuing and distribution mechanism
- Clear ODB has features for distributed object queues, allowing for streaming of objects and makes it easy to develop
applications requiring distributed processing.
Integration with OO Languages
- API for popular Object Oriented Languages:
C++ (Windows 7, Linux, Mac OS X)
C# (Work in progress)
Java (Work in progress)
Using Clear ODB enables you to design and develop truly object oriented solutions; allowing you to take full advantage of the benefits of object oriented design such as code reuse and encapsulation; and not having to compromise because of your data storage options.
Clear ODB is not an object-relational mapping solution. That means that at no point is there a translation from object model to relational model.