core21Example_main.c
Simple record type, integer field, on-disk. Time creation of 50,000 records. Time scanning and summing of all records' integer field. Time deletion of all records. This example needs a compiled schema, core21.sdl.
/*
* Raima Database Manager
*
* Copyright (c) 2019 Raima Inc., All rights reserved.
*
* Use of this software, whether in source code format, or in executable,
* binary object code form, is governed by the Raima LICENSE which
* is fully described in the LICENSE.TXT file, included within this
* distribution of files.
*/
/* \file
* \brief Source code for the RDM core21 example
*/
#include <stdio.h>
#include "example_fcns.h"
#include "rdm.h"
#include "rdmstartupapi.h"
/* Generated \c struct and \c typedef definitions to be used with the RDM APIs
*/
#include "core21_structs.h"
/* Generated catalog definition to be used with the RDM rdm_dbSetCatalog() API
*/
#include "core21_cat.h"
RDM_CMDLINE cmd;
const char *const description = "Performance Test: reading in rowid order";
/*
* \mainpage core21 Popcorn Example
*
* The core21 example performs a number of atomic database operations
* on a very simple database schema using the RDM Core C APIs.
*
* Each time you run this example
* \li The database is initialized
* \li 50,000 new records are created
* \li Each record is read
* \li Each record is updated
* \li Each record is read again
* \li Each record is deleted
* \li Database is cleaned up
*
* \par Table of Contents
*
* - \subpage hDB
* - \subpage hPGMfunc
*
* For additional information, please refer to the product documentation at
* http://docs.raima.com/.
*
* \page hDB Database Schema
*
* \par Database Schema Definition
*
* The DDL (Database Definition Language) specification for the database used
* in this example is located in the file \c core21.sdl. The example utilizes
* the SQL DDL syntax and specifies database schema with a single table (\c
* SIMPLE). The table has a single column (\c INT_COL). There are no index
* definitions for this database.
*
* \include core21.sdl
*
* The schema was compiled using the RDM \c rdm-compile utility with the -s and
* -a options to generate an embedded database dictionary.
*
* \code rdm-compile -s -a core21.sdl \endcode
*
* The schema catalog information (\c core21_cat.c) is embedded inside the
* application.
*
* \page hPGMfunc Program Functions
* \li openEmptyDatabase() - \copybrief openEmptyDatabase
* \li add_records() - \copybrief add_records
* \li read_records() - \copybrief read_records
* \li update_records() - \copybrief update_records
* \li delete_records() - \copybrief delete_records
* \li cleanup() - \copybrief cleanup
* \li main() - \copybrief main
*/
/* \brief Insert 50,000 simple records into the core21 database
*
* This function adds 50,000 simple records into the inmemory perf database. The
* simple record contains only a single integer field with no index. The
* function will calculate and display the total time elapsed while inserting
* the records
*
* @return Returns an \c RDM_RETCODE code (\b sOKAY if successful)
*/
RDM_RETCODE add_records (
RDM_DB hDB) /*< [in] RDM db handle with the database open */
{
RDM_RETCODE rc;
SIMPLE simple_rec = {0};
perfTimer_t timer;
int ii;
timeMeasureBegin (&timer);
print_error (rc);
{
/* Loop to add 50,000 new simple record */
for (ii = 0; ii < 50000; ii++)
{
/* Set values for the new record */
simple_rec.int_col = 1;
/* Add the record to the database */
rc = rdm_dbInsertRow (
hDB, TABLE_SIMPLE, &simple_rec, sizeof (simple_rec), NULL);
print_error (rc);
}
rdm_dbEnd (hDB);
}
timeMeasureEnd (&timer);
printf (
"Add 50,000 records:\t\t\t\t%u milliseconds\n",
timeMeasureDiff (&timer));
return rc;
}
/* \brief Read all simple records and calculate the sum of the int_col column
*
* This function iterates through and reads all simple records stored in the
* core21 database. The iteration is done in table order. The function will
* calculate the sum of the \c INT_COL field from all simple records in the
* database. The function will also calculate and display the total time
* elapsed while reading the records.
*
* @return Returns an \c RDM_RETCODE code (\b sOKAY if successful)
*/
RDM_RETCODE read_records (
RDM_DB hDB) /*< [in] RDM db handle with the database open */
{
RDM_RETCODE rc = sOKAY;
SIMPLE simple_rec;
RDM_CURSOR cursor;
perfTimer_t timer;
unsigned int total = 0;
timeMeasureBegin (&timer);
print_error (rc);
if (rc == sOKAY)
{
/* allocate a cursor resource */
rc = rdm_dbAllocCursor (hDB, &cursor);
print_error (rc);
if (rc == sOKAY)
{
/* Fill a cursor with all the rows in a table */
rc = rdm_dbGetRows (hDB, TABLE_SIMPLE, &cursor);
print_error (rc);
if (rc == sOKAY)
{
/* Loop through each simple record in table order */
rc = rdm_cursorMoveToNext (cursor))
{
/* Read the record */
rc = rdm_cursorReadRow (
cursor, &simple_rec, sizeof (simple_rec), NULL);
print_error (rc);
if (rc == sOKAY)
{
/* Add the value read to the running sum */
total += simple_rec.int_col;
}
}
}
/* Free the cursor */
rdm_cursorFree (cursor);
}
rdm_dbEnd (hDB);
}
timeMeasureEnd (&timer);
/* We expect rc to be sENDOFCURSOR when we break out of the loop */
{
printf (
"Scanning, reading, summing 50,000 records:\t%u milliseconds\n",
timeMeasureDiff (&timer));
printf ("\tSum = %u\n", total);
rc = sOKAY;
}
return rc;
}
/* \brief Update all simple records in the database
*
* This function iterates through and updates all simple records stored in the
* core21 database. The iteration is done in table order. The function will
* read, increment, and then update the value stored in the \c INT_COL field.
*
* @return Returns an \c RDM_RETCODE code (\b sOKAY if successful)
*/
RDM_RETCODE update_records (
RDM_DB hDB) /*< [in] RDM db handle with the database open */
{
RDM_RETCODE rc;
SIMPLE simple_rec;
RDM_CURSOR cursor;
perfTimer_t timer;
timeMeasureBegin (&timer);
rc = rdm_dbStartUpdate (hDB, RDM_LOCK_ALL, 0, NULL, 0, NULL);
print_error (rc);
if (rc == sOKAY)
{
/* allocate a cursor resource */
rc = rdm_dbAllocCursor (hDB, &cursor);
print_error (rc);
if (rc == sOKAY)
{
/* Fill a cursor with all the rows in a table */
rc = rdm_dbGetRows (hDB, TABLE_SIMPLE, &cursor);
print_error (rc);
if (rc == sOKAY)
{
/* Loop through each simple record in table order */
rc = rdm_cursorMoveToNext (cursor))
{
/* Read the record */
rc = rdm_cursorReadRow (
cursor, &simple_rec, sizeof (simple_rec), NULL);
print_error (rc);
if (rc == sOKAY)
{
/* increment the inc_col field */
simple_rec.int_col++;
/* Update the simple record with the new int_col value
*/
rc = rdm_cursorUpdateRow (
cursor, &simple_rec, sizeof (simple_rec));
print_error (rc);
}
}
}
/* Free the cursor */
rdm_cursorFree (cursor);
}
rdm_dbEnd (hDB);
}
timeMeasureEnd (&timer);
/* We expect rc to be sENDOFCURSOR when we break out of the loop */
if (rc == sENDOFCURSOR)
{
printf (
"Updating 50,000 records:\t\t\t%u milliseconds\n",
timeMeasureDiff (&timer));
rc = sOKAY;
}
return rc;
}
/* \brief Delete all simple records from the database
*
* This function will iterate and delete all simple records stored in the core21
* database. The iteration is done in reverse table order.
*
* \note This function is implemented showing a shortcut for allocating an \c
* RDM_CURSOR. Cursor association functions, like rdm_dbGetRows(), will allocate
* the cursor \e IF the cursor is set to \c NULL.
*
* \warning If an uninitalized cursor is passed to a cursor association
* function, like rdm_dbGetRows(), program may abbend. The cursor allocated with
* this shortcut method \e STILL needs to be freed when the cursor is no longer
* needed.
*
* @return Returns an \c RDM_RETCODE code (\b sOKAY if successful)
*/
RDM_RETCODE delete_records (
RDM_DB hDB) /*< [in] RDM db handle with the database open */
{
RDM_RETCODE rc;
RDM_CURSOR cursor = NULL;
perfTimer_t timer;
timeMeasureBegin (&timer);
rc = rdm_dbStartUpdate (hDB, RDM_LOCK_ALL, 0, NULL, 0, NULL);
print_error (rc);
if (rc == sOKAY)
{
/* Fill a cursor with all the rows in a table */
rc = rdm_dbGetRows (hDB, TABLE_SIMPLE, &cursor);
print_error (rc);
if (rc == sOKAY)
{
/* Loop through each simple record in table order */
rc = rdm_cursorMoveToPrevious (cursor))
{
/* Read the record */
rc = rdm_cursorDeleteRow (cursor);
print_error (rc);
}
/* Free the cursor */
rdm_cursorFree (cursor);
}
rdm_dbEnd (hDB);
}
timeMeasureEnd (&timer);
/* We expect rc to be sENDOFCURSOR when we break out of the loop */
if (rc == sENDOFCURSOR)
{
printf (
"Deleting 50,000 records:\t\t\t%u milliseconds\n",
timeMeasureDiff (&timer));
rc = sOKAY;
}
return rc;
}
/* \brief Main function for core21 example
*
* The function initializes the RDM environment and runs the create, read,
* update, and delete operations.
*
* @return Returns the \c RDM_RETCODE on exit.
*/
int main_core21 (int argc, const char *const *argv)
{
RDM_TFS hTFS;
RDM_DB hDB;
RDM_RETCODE rc;
perfTimer_t timer;
rc = rdm_cmdlineInit (&cmd, argc, argv, description, opts);
print_error (rc);
if (rc == sOKAY)
{
/* Initialize the handles and open the database */
timeMeasureBegin (&timer);
timeMeasureEnd (&timer);
if (rc == sOKAY)
{
/* Display information */
printf (
"Preparing a new database:\t\t\t%u milliseconds\n",
timeMeasureDiff (&timer));
printf ("\tOne, simple record type.\n");
printf ("\tOn-Disk\n");
}
if (rc == sOKAY)
{
/* Add 50,000 records to the database */
rc = add_records (hDB);
if (rc == sOKAY)
{
/* Read all of the records in the database */
rc = read_records (hDB);
}
if (rc == sOKAY)
{
/* Update all of the records in the database */
rc = update_records (hDB);
}
if (rc == sOKAY)
{
/* Read all of the records in the database */
rc = read_records (hDB);
}
if (rc == sOKAY)
{
/* Remove all of the records in the database */
rc = delete_records (hDB);
}
timeMeasureBegin (&timer);
exampleCleanup (hTFS, hDB);
timeMeasureEnd (&timer);
printf (
"Cleanup:\t\t\t\t\t%u milliseconds\n",
timeMeasureDiff (&timer));
}
}
return (int) rc;
}
RDM_STARTUP_EXAMPLE (core21)
Header for the native RDM Runtime API.
#define exampleOpenEmptyDatabase(tfs, db, name, catalog)
Definition: example_fcns.h:39
void timeMeasureBegin(perfTimer_t *timer)
RDM_RETCODE rdm_dbStartRead(RDM_DB db, const RDM_TABLE_ID *tableIds, uint32_t numTableIds, RDM_TRANS *pTrans)
Get read locks.
RDM_RETCODE rdm_cursorReadRow(RDM_CURSOR cursor, void *colValues, size_t bytesIn, size_t *bytesOut)
Read all columns from a row.
void timeMeasureEnd(perfTimer_t *timer)
The buffer used by the command line parser to hold state information.
Definition: rdmcmdlinetypes.h:85
RDM_RETCODE rdm_dbGetRows(RDM_DB db, RDM_TABLE_ID tableId, RDM_CURSOR *pCursor)
Associate an RDM_CURSOR with rows based on a table id.
unsigned int timeMeasureDiff(perfTimer_t *timer)
RDM_RETCODE rdm_dbInsertRow(RDM_DB db, RDM_TABLE_ID tableId, const void *colValues, size_t bytesIn, RDM_CURSOR *pCursor)
Insert a new row into a table at the specified rowId.
RDM_RETCODE rdm_cmdlineInit(RDM_CMDLINE *cmd, int32_t argc, const char *const argv[], const char *description, const RDM_CMDLINE_OPT *opts)
Initialize an RDM_CMDLINE buffer and validate the command line.
RDM_RETCODE rdm_cursorUpdateRow(RDM_CURSOR cursor, const void *colValues, size_t bytesIn)
Update all columns in a row.
RDM_RETCODE rdm_dbStartUpdate(RDM_DB db, const RDM_TABLE_ID *writeTableIds, uint32_t numWriteTableIds, const RDM_TABLE_ID *readTableIds, uint32_t numReadTableIds, RDM_TRANS *pTrans)
Get write locks.
Definition: example_fcns.h:54
Internal RDM Startup API used by startup macros.