Raima Database Manager


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 to 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.

select-apisRDM 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 3rd 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 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.

platform-groupsRaima 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:

  1. 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.
  2. 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 accessible through 3rd 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 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.


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 an advantage because there is no concurrent access to the database, hence no locking or waiting.






in-memory databaseNow, 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!




Test in-memory, on-disk performance and other configurations within your app’s environment! Each demo takes less than 5 minutes.
Go to Demo page

Evaluation SDKs

Over 40 free downloads are available on the Downloads page for evaluation of RDM on almost any platform you need.

Free Evaluation Download


What is under the covers of Raima’s technical solutions? What is a database union? How does MVCC impact read performance?
Go to Technology Page


Raima’s collection of informative and instructional videos are available on one page.
Go to Videos


Raima’s Development and QA team occasionally add details about topics not found elsewhere.
Go to Blog page

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 a hybrid of both; combining 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 re-write 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 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 image 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).


  • Maximum Databases Open Simultaneously: No Limit
  • Maximum Records Per Database: No Limit
  • Maximum Size of Database File: Limited only by file system
  • Maximum Tables Per Database: No Limit
  • Maximum Records Per Table: No Limit
  • Maximum Record Size: 32 kb (excluding BLOB or VARCHAR)
  • Maximum Fields Per Table: No Limit
  • Maximum Keys Per Database: No Limit
  • RAM Requirements: User configurable, minimum 50 kb
  • Code Footprint: Starting at ~270 kb, depending on OS and database features
Modes of Operation
  • Single-Process, Multi-Thread
  • Multi-Process, separate Transactional File Server
  • Multi-Process, shared in-process Transactional File Server
Data Types Supported
  • BLOBs
  • Character
  • Widechar
  • Varchar
  • Floating Point – 32bit and 64bit
  • Integer 0 8bit, 16bit, 32bit and 64bit
  • C Struct (Core only)
  • Data/Time/Timestamp
  • BCD (SQL Decimal)
  • GUID
Additional SQL Data Types:
  • Binary
  • Unicode
Data Providers and Drivers: Interoperability
  • ADO.Net 4.0 Data Provider
  • JDBC 4 Type 4 Driver
  • ODBC 3.5 Driver

Multiple APIs: for Enhanced Usability

  • Cursor API (new) – RDM 12 introduces a new API, a modern alternative to the legacy RDM Navigational API.  The Cursor API facilitates the traversal of database records for retrieval, additional and removal of database records.  Thus the database cursor resembles modern programming concepts of iteration over a collection.  The Cursor API fits seamlessly with RDM’s database concepts with Record, Key and Set Cursors.
  • Navigational C API – For well over 25 years developers have been using RDM’s low-level C API of over 200 intuitive easy to use functions provides application developers with ultimate control of the database.
  • Comprehensive SQL API – RDM’s SQL is accessed internally through an easy-to-use API designed by Raima. This non-standard API is simpler than ODBC. In fact, our ODBC API is based on this one.
  • Standards Based ODBC API – Following the ODBC standards Raima developed the ODBC API to provide developers with a familiar way to utilize the power of the RDM database engine.
  • JDBC – There are two modes of operation for this interface. The first is through TCP/IP and the second is a direct link through JNI.
  • Object Oriented C++ API – The C++ API was designed with ease of use as its primary requirement while still providing developers with full access and control to both RDM’s network and relational functionality.
  • Objective C API – The Objective-C 2.0 interface to RDM Workgroup is designed to augment the RDM navigation on the Mac OS X  and iOS platforms by creating custom objects to represent records and interface with the database. This combines the performance of RDM Workgroup with the intuitiveness of an object oriented interface, making it easy to integrate with Cocoa applications.




Mac OS X












QNX Neutrino


Wind River VxWorks



What We Do

Raima is a provider of high performance, always on database management system technology for both in-memory database usage and persistent storage devices. We deliver database solutions which are cross-platform, small footprint database systems designed for distributed architecture in resource-constrained environments.
Learn More

What They Say...

Loading Quotes...

Latest Feeds