Evaluation Download – RDM 11.0
RDM 11.0 Architecture and Features PDF

Raima Database Manager Overview – Video Transcript

In today’s world, massive amounts of data are being generated from so many different sources and applications require a database that is capable of collecting these large volumes of information…
Storing that data reliably…
Providing intuitive methods for managing and navigating through the information quickly…

And finally, being able to then move that data in near real-time so that the most up-to-date and relevant data ultimately ends up available to any device, computer system or corporate enterprise that must have immediate access to that information so that proper decisions and actions can be taken.

The Raima Database Manager Solutions, known as “RDM”, introduces a new and innovative way of managing data in the every evolving world of software systems.

RDM provides software developers a wide variety of powerful programming tools and customizable building blocks so that developers are assured to be well-equipped to solve the most complex data management challenges facing them today.

I want to take this opportunity to introduce you to the RDM System and briefly walk you through the general architecture.

RDM System

The RDM System provides data management solutions in 4 key application verticals…

• Mobile Raima offers packages targeted at Mobile applications for those that are developing software programs for smart phone or tablet devices.
• Embedded We provide packages aimed at Embedded applications for companies building solutions to run on real-time operating systems commonly found in industrial automation controllers, telecom routers & switches, mission critical aerospace & defense system and more.
• Desktop & Server We also have packages for those developing applications for Desktop & Server environments such as business automation solutions, backup systems, security applications and a number of others.
• Enterprise Lite And finally, we have solutions architected to solve the needs of developers designing applications with Enterprise Lite requirements such as Business Intelligent solutions, Network Management systems, Cloud computing applications and more.

First let’s look at the general architecture and components of the core RDM database engine

Comprehensive API’s

RDM provides a comprehensive low-level C API for ultimate control while also providing a C++ API for object-oriented programing. With the mobile package, an Objective C API is provided to enable seamless development on the iOS platform. RDM also supports a powerful industry standard SQL API.

Interoperability

While RDM was originally designed with low-level programmers in mind, in today’s environment it is important to provide seamless interoperability with other systems and tools through standard interfaces. RDM meets this need by providing standard ODBC, JDBC and ADO.Net Drivers.

Extreme Performance

RDM provides dual database modeling capabilities…

RDM supports the industry standard relational model while providing the option to program in the network or hierarchical model which eliminates the need to manage and balance a relational index. This reduces overhead, limits disk I/O and keeps performance of the application much more consistent – even when the size of the database grows exponentially. RDM also supports a hybrid of the two, giving developers ultimate flexibility on how they model their database to meet the most stringent performance demands.

What’s more, RDM provides both b-tree and hash indexing for even more performance tuning flexibility.

Multicore Scalability

The latest architecture of RDM has gone through an extensive re-architecting effort carefully splitting up the runtime engine and its transaction system to take full advantage of today’s, and future, multi-core architectures resulting in greater performance and scalability.

In-Memory and Persistent Hybrid

RDM can be configured to run completely in-memory, on-disk, or a hybrid of the two where the application designer places part of the implementation in-memory and the other on-disk in a single system. This enables additional performance gains while at the same allowing you to persist your most critical data.

Multi-Versioning Concurrency Control (MVCC)

The MVCC support in RDM allows a database reader at any time to have access to a consistent view of the database while a database writer simultaneously changes its state. This means readers no longer interfere with writers removing deadlocks and scaling performance dramatically.

MicroHTTP Server

RDM’s lightweight MicroHTTP Server enables the developer to set up the application to monitor the activity taking place within multiple Raima databases deployed throughout various geographical locations from one central location through a web browser. It can be designed in such a way that you can have a graphical display of your data and watch the changes in near real-time.

What’s more, you can also update, delete or invoke changes to those databases from your central command center.

Replication

RDM provides replication technology enabling near real-time movement of information, collected on any Raima-based application, to any other device, computer system or corporate enterprise that must have immediate access to that information so that proper decisions and actions can be taken.

High-Availability

RDM provides mirroring functionality, a key building block for implementing a fault-tolerant 24×7 fail-over system when downtime is not an option. With partner products we are able to further enhance the capabilities of this high-availability offering.

Distributed & Data Partitioning

RDM offers the components needed to develop complex distributed applications and allows any application to connect to one or more databases and query them as if they were one. With this distributed functionality there are also methods that allow you to partition your data.

Conclusion:

Thanks for allowing me a moment of your time to introduce you to Raima’s Database Management System. As you look into your roadmap for current or future development initiatives, we hope you will consider the value RDM can bring to your overall project.

We encourage you to visit us at www.raima.com to learn more about our company and data management solutions. There you can download a free copy of RDM to start to get familiar with what the database has to offer.

We believe you will find RDM to be an extremely powerful data management system for your next software development project.

View More videos

Free Badge

Complete this JDBC tutorial to receive this free badge.

Before you Begin

There are a few things you should make sure you understand/obtain before you begin. Take a look below:

• Basic understanding of object oriented programming fundamentals.
• Limited Database knowledge including SQL Syntax.
• JDK 1.6 or greater installed and ready to go.
• A text editor.
• A JDBC Database Driver contained in products such as MySQL, PostgreSQL or RDM Workgroup

Steps to Creating your Application

This JDBC tutorial is meant for those using a command line interface. Here is the Full .java File to use during the tutorial.

Step 1 Open a command line prompt

If using a Windows operating system, click the start menu and where it says, “search for programs or files”, type cmd. Then press return.
For a Unix based system, find the application labeled “Terminal”. Open that application.

Step 2 Creating your .java file

Using your text editor, create a new .java file called HelloWorld_JDBCTutorial_main.java

Step 3 Creating your class

Your class must contain the same name as the .java file you just created. Create your class exactly like the code snippet below.

This class is a public class because it has the ability to be accessed outside the scope of this class. In this example everything is done within this class.

Step 4 Creating your main method

The main method is the entry point for your program. For this simple example we are only using one .java file. Therefore, HelloWorld_JDBCTutorial_main { will contain the main method as shown below. For this example we will throw the outermost SQLException (The exception related to the Connection object) for simplicity.

Step 5 Creating and initializing your Connection Object

You will need to initialize your Connection object before you have access to any of the methods it contains. You will retrieve the connection object by calling a method from the DriverManager class called DriverManager.getConnection({Connection URL}). The return from this method is your Connection object.

It is good practice to start a new try block for every object that you initialize. When you are done with the object, simply add a finally block that performs the corresponding close() method, and the outermost block will contain your catch block to handle all possible SQLExceptions. This will be easier to see with the full code.

*Note: The URL will change depending on the Driver you are using, in this case, the RDM JDBC driver is being used. The comments are specific to this driver.

Step 6 Creating your Statement Object

The newly created Connection object Conn has a method in it called createStatement() that will return a Statement object. You will then use with this Connection to the database.

Step 7 Execute Statements with your newly created Statement Object

Using the Statement object Stmt you just created (Stmt) you can execute several different methods depending on the type of statement you want to execute. For example, if you would like to execute a statement such as “OPEN database_name” or “DELETE * FROM table_name” you would perform a Statement.execute() method. You can see execute() used in the code snippet below. In this example we will create the database programmatically, and we want it to be self contained (if it is run twice the database will be deleted before being created again). See step 9 for committing changes.

*Note: This database is created programatically. There are tools out there to create your database separate from your program. View a quick “How to Create a SQL Database” tutorial on how to do this.

Step 8 Creating a Prepared Statement Object and using it in your program

A good way to insert data into your database is to use a Prepared Statement. This statement will be prepared at compile time and have numerous other advantages. The main advantage being that you can dynamically tell the program what data values you would like to insert into your database. This is done using setter and getter methods from the Prepared Statement object. A setter method is a method that is used to set a specific field or in this case a parameter to a given value. You will be able to see this used below. A getter method is used to retrieve a field or value, but we are not going to be using that here.

What is happening here is that you first create the Object and it contains your Prepared SQL Statement inside of it. In this example the Statement is an insert statement that inserts into the table at a single row with an unknown value (?). By performing the next prepStmt.setString(1, “Hello World!”), you are setting this parameter to the value “Hello World!”. When the prepStmt.execute() is called, that string is inserted into the database.

Step 9 Committing Changes

In order to have your changes finalized in the database you must perform a commit. In JDBC this is done through a method using the Connection object. The method we will be using is Connection.commit() and that will finalize any changes you made during a transaction.

Step 10 Creating your Result Set Object (retrieving data from the database)

In JDBC, when you want to retrieve data from the database, you perform a SQL Select Statement using your Statement object with an execute method that returns a Result Set object. This method is called Statement.executeQuery(). This means it will execute the specified Query and return the Query results in the given Result Set.

Step 11 Accessing the Result Set

In order to access every piece of data in your Result Set, you must iterate through it. A method is provided within the Result Set to check if the next result in the Result Set is NULL, meaning no more data. If the method ResultSet.next() returns TRUE then there is data in the database and you can retrieve it from your result set.

To access the data inside the Result Set you must perform a getter method, similar to the setter method you performed above. There are numerous getter methods available to retrieve the specific data type from the Result Set. In this example we want a string, therefore we use the ResultSet.getString() method, with the parameter being the column you are retrieving from.

Take a look at the code below to see an example of how this can be done.

Step 12 Deallocating Resources

Here you will deallocate all of the resources you used above. In this case your resources are each object that you used above, being your Connection object, Statement, Prepared Statement and Result Set objects. For each nested try block you will have a finally block, which performs the corresponding close method. In this example we dropped the database to clean up resources and keep the program self contained. This would normally not be necessary. Look at the code snippet below.

Step 13 Final Catch and Finally block

The very last block contains both a catch block and a finally block. The catch block determines what to do if an exception was thrown in the code above. In this case just displaying the exception to standard out is sufficient. The finally block will be executed regardless of an exception being thrown. Here we will deallocate our Connection object. In this example, if your Connection object does throw an exception for some reason, it is “thrown” out of the method. In a normal situation you could either add another try catch block, or declare this program as a separate method and handle it elsewhere.

Step 14 Compiling your application

If your JDK is installed correctly you should have access to the Java Compiler, called javac. In order to have your program successfully compile, you must first set your CLASSPATH to contain all of your class files, including .jar files that you are using. Since the JDBC driver is usually a .jar file you will need to include this in your CLASSPATH. If you are using command line you will perform operations similar to this:

Linux: CLASSPATH=$CLASSPATH;{Current working directory};{Direct Path to .jar file}

*Note: ./ can be used to signify current working directory

Windows: set CLASSPATH=%CLASSPATH%:{Current working directory}:{Direct path to .jar file}

After you have set up your CLASSPATH you should be ready to compile. In order to do this you must use the javac compiler. On all platforms the compile will be the same. The format looks like this:
javac {main_class.java (entry point to program)}

In this case you would type:

You should see no warnings, and after completion a .class file will have been generated. You directory should contain:

Step 15 Running the program

Running the program is as simple as typing “java {executable name}”. In this case you would have “java HelloWorld_JDBCTutorial_main” as that is the entry point to your program. If everything works as expected you should see this displayed on your screen:

Here is the Full .java File to compare to your own.

Done!   Get Your Free Badge Below

Congratulations! You have just finished your first JDBC application. This specific JDBC Tutorial is very simple, and your future endeavors may prove to be much more difficult.

Copy and paste this snippet onto your website or blog.
<a href="http://www.raima.com/jdbc-tutorial/" title="I am a JDBC Master" style="background:url('http://www.raima.com/wp-content/uploads/jdbc_badge.png');height:50px;width:141px;display:block"></a>

If you do not have the SDK for RDM, you can download the trial version here.

Creating a database via importing a .sdl file

This section will show you how to define and create a .sdl file. You will then use the RDM tool rdmsql to import the file and execute the statements, in return creating the database.

Structure a .sdl File

Inside of an .sdl file, you will define a series of SQL Statements, such as the SQL CREATE DATABASE statement, to execute to define and create your database including the tables and rows. The format will look similar to this.

Taking a look at the above SQL Statements, you can see that it starts by creating a database with the SQL Statement format “CREATE DATABASE {database_name}”. The next statement creates the table “hello_table” with f00 being the only row in the table. Be sure to save the file, then proceed to the next step.

Compile a .sdl File

Raima Database Manager has a tool for executing SQL statements, which is exactly what the file above is doing. It is executing the required statements to create a simple database. The name of this tool is rdmsql. You will be using this tool through command line operations, which will be the same regardless of what platform you are on.

Step 1) Open a cmd prompt or terminal and navigate to the RDM installation directory. “/opt/Raima on linux or C:\Raima on Windows“.

Step 2) Set up the RDM environment by running “rdm.bat” on Windows or “. ./rdm.sh” on Linux.

Step 3) Navigate to the location of where you want your database stored.

Step 4) Run rdmsql –b “name_sdl_file“. The –b signifies that you will be passing the arguments in through a text file.

Ex: rdmsql –b hello_worldJDBC.sdl
*Note: hello_worldJDBC.sdl can be found in the Raima Install directory under “**\RDM\11.0\GettingStarted\tutorials\HelloWorldJDBC\”
This will generate all of the necessary database files under a folder call hello_worldJDBC.

Alternate Method: Execute SQL Statements Directly | Using the rdmsql Tool

The rdmsql tool can also be used to execute SQL statements directly via the command line interface to the tool.

Simply run the following command on the command line to start up the tool :

This will bring up the interface. The interface will look like the screenshot below.

Begin by creating a connection by typing this command into the tool:

This creates connection handle 1.

Next, Execute your SQL Statements in order using the above statements from the .sdl as an example

Type the following:

*Note: make sure to add the commit on rdmsql otherwise your database will not be created*

Finally quit the tool by typing “.q” and your database will be ready to go! View the screenshot below for further reference.

You have now successfully initialized your database!

Now to create your first JDBC application.

References

Click the links below to view more information about SQL.
MSDN SQL Create Database Reference

The Database Benchmark Rule of Thumb

The only truly meaningful benchmarks are those that are based on your own database application requirements!

Why?

• There are no “standard” database benchmarks that mimic and stress a DBMS in the same manner that your application will. Your application is unique. The reason you are developing it is to fill a need that is not being met by an existing solution. You are looking to differentiate your product from competitors. It only follows that your database requirements are going to be unique so why would you rely on so call standard benchmarks that measure performance of features and functionality that is not even remotely relevant to what your application will do?
• Most reputable DBMS will perform well under a group of common use cases and perform less well under other more complicated use cases. We have rarely found an application with requirements limited to just the most common use cases. Most applications are going to stress the DBMS in multiple different scenarios and under multiple different loads and conditions. It would be nice if one size “solution” fit all but this isn’t reality.
• Benchmarks provided by a DBMS vendor usually focus on those usage scenarios that demonstrate their system’s strengths. This is why you should never rely solely on database benchmark results provided by any database vendor in deciding which DBMS is best for your application.

Suggested Guidelines

• Define those use cases that will be core to your specific application requirements. The more specific you can be the better chance that you will be able to truly represent your application’s performance requirements. If you cannot articulate your application’s requirements you should hold off on performing any benchmarking until you can. The risk of making an incorrect database selection based on irrelevant benchmarks is too high.
• Plan on making the investment to create a test database that most closely represents the one that will be needed for your resulting application. This is not cheap but it is truly a case of “pay me now or pay me later.” Designing your database while writing your application can lead to many iterations of the design and rework of your application. To avoid this it makes sense to spend the time now to create a test database to avoid costly project delays later.
• Elicit the assistance of the DBMS vendors, once you have clearly defined your database requirements and have identified the relevant use cases. They can be a valuable resource for aiding in the development of your own unique database benchmarks.
  • This will allow you to evaluate not only the system itself but the kind of support you can expect to receive from the DBMS vendor.
  • It also allows the vendor to show you ways to get more out of their products which you would not necessarily have discovered by doing a simple “out of the box” test.

If you follow these guidelines when analyzing database vendors, your projects will definitely benefit. Raima welcomes the opportunity to work with you on your next project.