Versant’s C++ Interface provides transparent, seamless integration for your high performance C++ based applications. Your persistent object model is stored directly into the Versant Database Engine as defined by your persistent C++ header files eliminating the need for costly OR-mapping code or tools, object state tracking, or expensive query/join operations.

Agile Development with Versant C++

Agile application development is directly supported with the Versant C++ interface. Your schema is defined in a text based schema implementation file that includes your application’s persistent C++ header files for those classes you choose to be “persistent capable”. Versant C++ provides a schema compiler that compiles the persistent C++ implementation file and creates a db schema that directly matches your application header. This resulting schema file is directly applied to your database resulting in an exact match between your persistent C++ application objects and your database schema.

As your application model evolves, the Versant C++ schema tool allows easy schema evolution of your persistent C++ classes so it always matches your application schema. Since you don’t need to remap your tables, re-factor, and modify your mapping code, rapid agile development is enabled.

Full Distributed Database Support with Versant C++

Versant C++ allows your application to connect to multiple databases residing on any reachable database server. Persistent C++ objects can be populated in any connected database, can refer to objects in any other database, and can be freely moved from one database to another. The Versant C++ concept of a “logical database” is supported allowing the application to connect and work with a “logical database” that is actually implemented as one or more physical databases distributed on multiple database servers. Both queries and commits are performed in parallel for optimal scalability and performance.

Versant C++ Offers Dual Cache Technology

Versant C++ includes a powerful persistent C++ object cache in addition to Versant’s server cache. Recently access persistent C++ objects are cached with the application providing “in-memory” performance. Supporting capabilities include refresh, eviction, and writes to server while still maintaining transaction capabilities such as roll-back. Many of our existing customer world-wide leverage our persistent C++ client cache technology to achieve unparalleled data retrieval rates.

Full Multi-Session, Multi-thread Support

Versant C++ supports the creation of as many database sessions as needed and session pool support as well. Additionally, each session can be accessed by multiple threads allowing highly efficient concurrent access to your persistent C++ application objects.

Persistent C++ Derived Class Queries

With VQL, you can easily query a persistent C++ sub-class and include instances of derived classes in you result set. Versant VQL executes this very efficiently as your persistent C++ object model is stored directly into your database. Even when performing this powerful derived class query, any available index will be automatically utilized for optimum query performance.

Optimal Concurrency via Object Level Locking with Two Models

Locking with Versant C++ is always at the object level providing for optimal and intuitive concurrency controls. Versant C++ supports both pessimistic locking via read and write locks maintained through an entire transaction or optimistic locking which provides for time stamp checks during commit time to ensure concurrent data integrity. Additional Versant C++ features include automatic deadlock detection, writer starvation prevention, and explicit locking API’s as well as the ability to completely turn off locking.

Advanced Query Capabilities via Versant Query Language (VQL 7)

VQL 7 is designed as the Versant C++ developer’s way of having the power of SQL queries, yet retaining the persistent C++ object relationships that exist in their application model. So besides being able to execute standard SQL queries, VQL adds many new capabilities.

Derived Class Queries

With VQL, you can easily query a sub-class and include instances of derived classes in you result set. Versant VQL executes this very efficiently as your persistent C++ object model is stored directly into your database. Even when performing this powerful derived class query, any available index will be automatically utilized for optimum query performance.

Collection Based Queries

Versant C++ enables you to query over any of your persistent C++ collection classes even when the collection class is contained in one of your other persistent C++ classes.

Support for Large Data Sets

Versant VQL provides seamless support for large datasets via “Cursor Queries”. By setting up your query to fetch batches of persistent C++ objects instead of the entire result set, developers can scale to very large populations without exhausting application memory.

Support For Existential and Universal Quantification Queries

If you are not familiar with existential or universal quantification, no worries – they just allow you to perform the following types of queries (given the familiar Company domain of Department having one or more Employees):

• Find all Department(s) having at least one employee who makes more then 50000 (Existential Quantification type query).
• Find all Department(s) who have all employees making more then 25000 (Universal Quantification type query).

Just to reiterate, these types of queries with Versant C++ do NOT require expensive join operations but instead use direct navigation on the server to efficiently execute the query.

 

Other Versant C++ Features

• Full ODMG Support for persistent C++
• API to create new classes at run time
• Persistent C++ Collection Classes based on STL (map, hashmap, list, set, array, etc)
• Distributed Transaction Support (XA - Open Transactions)
• Lazy Schema Evolution and Loose Schema Mapping