Raima Database Manager
Summary
For over 30 years, Raima has developed, sold and supported Raima Database Manager (RDM), a relational DBMS that runs in almost any computing environment, from mobile phones to embedded computers from UNIX servers to the Cloud. RDM is a fast, small footprint, inexpensive database engine, provided by Raima as an SDK for Windows, Linux or UNIX development environments. For embedded and mobile targets, RDM’s Windows or Linux SDKs will perform cross-platform development.
RDM has been used by thousands of programmers to create successful products, utilities or tools that have been distributed worldwide. Programmers use C, C++, Java, or C# to call a suite of APIs in RDM, or access it from third-party tools through the ODBC Driver Manager.
RDM may be configured to run as a single process, single database program, or as a multi-computer, multi-process, multi-thread, multi-core, distributed database system of programs - and also as everything in between. Its SQL is ready for those who prefer SQL programming, but low-level API access is also available for advanced programmers who want to squeeze out the ultimate performance. For even greater performance, a database may be managed in-memory. ACID compliance means that on-disk databases are safe and always recoverable, while MVCC and non-repeatable-read features allow fast reading or analysis of databases that are being concurrently updated.
Raima has always made the RDM source code available at a reasonable cost. Raima and its experienced developers are proud of this code and don’t mind if you take a peek, or even step through it in your own debugging system. Source code comes complete with project files necessary for you to build it yourself.
Since RDM can be freely downloaded and licensed for application development at a very low entry fee until it is ready to deploy, and with source code availability, there is very little cost difference between Raima’s commercial licensing and Open Source with support or for commercial use.
Raima supports RDM through online documentation and forums, standard product support, robust tutorial examples, and through professional services where we apply our database expertise to your application requirements.
Architecture - A Deeper Dive
RDM's runtime environment is composed as two powerful but well-defined modules:
- The Runtime Library - This re-entrant linkable library becomes part of your executable program. It maintains a cache of database objects as it responds to function calls from your program.
- The Transactional File Server - This tight, multi-user server interacts with one or more Runtime Libraries concurrently. It manages access to database files. The TFS responds to runtime requests to read objects, to lock objects, or to apply transactional changes.
Runtime Library
As a re-entrant library, RDM fully supports multi-threaded applications. Each thread may open a database and operate on it concurrently with the others.
As a linkable library, RDM operates on data kept in a heap-based cache. Its robust APIs give you full visibility and control over the data. SQL is available through a C-based API, but also is accessible through third-party tools. Other APIs allow fine-tuning of database operations using a cursor view or an object-oriented view.
Transactional File Server
At its core, the TFS is a library of functions. These functions are called by the runtime library. If the TFS is running in a separate process, its functions are called as RPCs (Remote Procedure Calls) using TCP/IP between computers and shared memory within the same computer.
However, the TFS functions also may be linked directly into your application also. This has significant performance benefits and simplicity in operation. It's faster because the Remote Procedure Calls become Local Procedure Calls (in-process). It's simpler because everything is running within your program and there is no separate process to start first.
Configurations
Yes, the Runtime Library and TFS are powerful and well-defined, but they can be configured in several ways. The figures below show just a few.
When multiple computers are involved, they communicate through TCP/IP. If the runtime and TFS are on the same computer, shared memory is used to speed it up.
But when the runtime and TFS are in the same process, the inter-process communication is avoided, resulting in even more speed.
Multi-threaded applications are great for handling multiple windows on a screen, each with independent contents.
Simpler, single-user applications have an advantage because there is no concurrent access to the database, hence no locking or waiting.
Now, load the database from disk into memory and you have database management with all the stops pulled.
The RDM in-memory database option allows for volatile (it goes away when the application stops) and persistent (loaded from disk and saved to disk) databases.
It's faster because there is no disk latency for reading and no waiting for disk writes during a transaction commit.
These are vulnerable to data loss if the application terminates without saving the data. Sometimes it's a risk worth taking!
Full Multi-Core Support
Efficiently allocate transaction processing to take advantage of multi-core systems for optimal speed.
Multi-Versioning Concurrency Control (MVCC)
Implement read-only transactions where a virtual snapshot of your desktop database is readable until the read-only transaction is terminated by the task, even if it is being concurrently updated. Avoid read locks to improve multi-user performance.
Pure and Hybrid In-Memory Database Operation
Configure your desktop database to run completely on-disk, completely in-memory, or as a hybrid of both that combines the speed of an in-memory database and the stability of on-disk in a single system.
Multiple Indexing Methods
Use B-Trees or Hash Indexes on tables. Hashing on large volumes often provides faster access to data than b-tree indexing methods. Hashing enhances speed by using buckets to store the index information.
Better Performance Through Scaling Out
Easily achieve true horizontal scaling across clustered or distributed systems without the need to rewrite of your application.
True Global Queries
Connect any application to one or more databases and query them as if it is a single instance. Perform global, locally or across a network, to multiple database instances with no regard for where the data is located.
Database Cursors
The addition of cursors to the standard library allows for an easy-to-use, natural traversal of records in the database.
Shared Memory Protocol
Improves performance with clients on the same computer through the addition of shared memory as a transport for communication between the application and the TFServer.
Application-specified Memory Limit
Allows the application to limit the amount of memory used by the RDM runtime system and, optionally, provide a pointer to a memory buffer within which the memory will be allocated.
New Data Types
Three new data types, including Date/Time/Timestamp (Core level), BCD (decimal), GUID (UUID).
Bulk insert API Function
The Bulk Insert API function is a new performance optimization API to efficiently insert large quantities of data at the Core level.
Unrepeatable Read Isolation Level
Support for lockless reading. This is a new isolation level that allows any committed data to be read without first requesting a read lock. Since there are no locks, data may change without notice. When this is acceptable for the application, it is much faster.
Encryption
Encryption of the database files using the Rijndael/AES algorithm for encryption or decryption is now available. The algorithm supports the use of 128, 192 or 256 bit keys.
Selective Replication & Notification
Extends replication functionality by adding the ability to “selectively” specify the table(s) and column(s) to be replicated. Enhancing Replication further, version 12.0 also introduces change logging enhancements by providing pre- and post-images of updated rows with the replication notification API.
SQL enhancements:
- Update Statistics – provides for the collection of data distribution statistics so that the SQL optimizer can make more informed execution plan choices.
- Rowid Primary & Foreign Keys – rowid primary keys allow individual rows of a table to be directly accessed based thus providing optimal retrieval performance without having to incur the cost of a separate index.
- Improved Group/Order By Performance – Group by processing performance has been significantly improved in RDM 12. Order by sort costs have also been reduced.
- New Data Types – support was added for the previously mentioned new Core types, decimal (BCD) and guid (SQL already had date/time/timestamp support).
