The Object Store is an object oriented database, or a distributed object model, depending on how you see it. Object Store allows you to write distributed object oriented applications without having to write the code for distribution or storage.
The primary benefit from Object Store as opposed to other database solutions is that it is object oriented and the model you use for your application code is used for data storage and distribution.
Object Store has signifant benefits compared to a relation database when it comes to model complex data as well as having better performance in certain applications.
Data in an object oriented database are stored as individual objects, not in tables as in a relational database. There is no need for the applications to convert from one data model to the other when new data is inserted into the database.
Object Store has a server / client architecture. Objects are stored permanently on the server, and each client access the server to request objects. Objects are transferred to the clients by explicit requests of the application or implicitly through dynamic reference types that can be used to load only the required objects.
The server keeps track of what objects are on the clients and thus can be intelligent in terms of what data to transfer. The most notable difference from other database systems is that Object Store's server is active in that it notifies clients when updates have been made.
The server is installed on either a client machine or on a dedicated server machine. And as with other database systems, the server can manage multiple object databases simultaneously.
Multiple servers can be set up to replicate each other, or be used in a workload balanced system, where incoming connections are redirected to less busy servers.
Client applications are programmed with the Object Store development kit, and use the API provided for interacting with the database. The application is linked with the provided static or dynamic libraries.
Once the client program runs, it connects to the server with a user name and password, and requests objects as needed by the application. Objects are normally not queried for as with an SQL database, but rather retrieved using pointer or reference semantics.
Clients can be set up to do local caching. When an application starts and request an object, the API will first look in local storage to see if the object exist there to avoid a network transfer. When the client first connects to the server, a list of which object's have been updated centrally will be sent to the client so that the local objects can be updated if required.
The Object Store server has a number of features that makes it easy to manage in an enterprise environment.
The Object Store manager is a graphical user interface for the server. Through the Object Store manager you can set up and administer your databases, set up access rights, backups, replication servers, browse objects and see database statistics.
Through the Object Store manager you can connect to any server on the network - as long as you have access rights - so that you can easily manage any number of databases from one location.
One of the primary objectives when designing Object Store has been to make it able to store and transfer large amount of data efficiently.
If you have a scientific or financial application running Monte Carlo modelling for example, you may very well have a few GB of data that needs to be fed into a calculation process. Pulling a few GB from an SQL database will take quite a while. Carefully structured classes with the use of for example floating point arrays will make Object Store as fast as binary files.
Object Store supports object level access control. That means that you can control access to individual objects or groups of objects depending on the user.
The access control model is based on defining roles that are assigned priviligies such as read or write. Users are assigned to these roles.
The design of Object Store has been focused on making life as easy as possible for the software developer - to enable the developer to focus his efforts on designing the application rather than on the details of network I/O, access control or data storage. This will lead to improved code quality and improved project times.
When using Object Store you will use object oriented paradigms and design patterns, probably more so than what you would have done otherwise, as the framework depends on a well defined object model.
The main difference between a normal object model and the model you use with Object Store is that you have to consider all objects shared between all client applications. Object Store will handle data transfers and object synchronization for you, you will define the classes in your favorite programming language and define ownership relationships between classes and objects.
Each object in the Object Store model is unique and has a distinct life span across all client applications. When an object is created on one client, it is assigned an identity which follows it throughout it's life. The object keeps it's identity across clients and regardless of any modifications to its data members.
Object Store is using Clear Objects' Object Serialization Library ( OSL ) for data transfer and class introspection. The OSL provides all necessary functionality for data serialization, and can handle any inheritance structure, polymorphism, class version control and complex object graphs.
Unlike other database systems, the data structures are not defined by the database, but rather by the application. This means that there is only one definition needed.
Changes to the data model is handled by OSL's class version control, which means that you can upgrade your application easily, and use the provided features for upgrading existing client's databases.
Just as you can lock files on the local file system or tables in an SQL database, Object Store supports an object locking mechanism. By locking an object you can ensure no other clients are allowed to update the object on the server.
Object Store supports transaction management which is a form of optimistic locking. That is, you can require that a sequence of updates to the server are all applied or all of them are rolled back. You start the transaction with a begin command, make the updates / commits needed, and then have the option of a rollback or a commit. If some objects have already been updated on the server since the transaction was started, all the changes that has been previously sent to the server within the transaction will be rolled back.
Object Store is designed to be accessible from any object oriented language. The features you use depend on the languages you intend to use for your applications. Using C++ for example, will allow you to design classes with multiple inheritance for example. However, when combining multiple languages in a system solution it would be advisable to look at the least common denominator.
Object Store's framework provide an API based on classes and function for all supported languages.
The Object Store supports a form of distributed processing, in which you can easily write applications that distribute objects across a network.
By applying a command like design pattern, and using the provided framework for distributed programming, the Object Store server can be instructed to send commands to clients that perform the processing.
Object Store supports tracking of changes to objects. By telling the Object Store server to keep a history of every object, you can easily go back to any previous version of the database.
 |
Object Serialization
Object Store