c-core/23_core/core23Example_main.c

/*
 * Raima Database Manager
 *
 * Copyright (c) 2012 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.
 */

#include <stdio.h>
#include "rdm.h"
#include "example_fcns.h"
#include "rdmstartupapi.h"

/* Generated \c struct and \c typedef definitions to be used with the RDM APIs
 */
#include "core23_structs.h"

/* Generated catalog definition to be used with the RDM rdm_dbSetCatalog() API
 */
#include "core23_cat.h"

RDM_CMDLINE cmd;
const char *const description =
    "Performance Test: reading/deleting in key order";
const RDM_CMDLINE_OPT opts[] = {{NULL, NULL, NULL, NULL}};

RDM_RETCODE add_records (
    RDM_DB hDB) 
{
    RDM_RETCODE rc;
    SIMPLE simple_rec = {0};
    perfTimer_t timer;

    timeMeasureBegin (&timer);

    rc = rdm_dbStartUpdate (hDB, RDM_LOCK_ALL, 0, NULL, 0, NULL);
    print_error (rc);

    if (rc == sOKAY)
    {
        /* Loop to add 50,000 new simple record */
        for (int 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;
}

RDM_RETCODE read_records (
    RDM_DB hDB) 
{
    RDM_RETCODE rc = sOKAY;
    SIMPLE simple_rec;
    RDM_CURSOR cursor;
    perfTimer_t timer;
    unsigned int total = 0;

    timeMeasureBegin (&timer);

    rc = rdm_dbStartRead (hDB, RDM_LOCK_ALL, 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_dbGetRowsByKey (hDB, KEY_SIMPLE_INT_COL, &cursor);
            print_error (rc);

            if (rc == sOKAY)
            {
                /* Loop through each simple record in table order */
                for (rc = rdm_cursorMoveToFirst (cursor); rc == sOKAY;
                     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 */
    if (rc == sENDOFCURSOR)
    {
        printf (
            "Scanning, reading, summing 50,000 records:\t%u milliseconds\n",
            timeMeasureDiff (&timer));
        printf ("\tSum = %u\n", total);
        rc = sOKAY;
    }
    return rc;
}

RDM_RETCODE update_records (
    RDM_DB hDB) 
{
    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 */
                for (rc = rdm_cursorMoveToFirst (cursor); rc == sOKAY;
                     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;
}

RDM_RETCODE delete_records (
    RDM_DB hDB) 
{
    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_dbGetRowsByKey (hDB, KEY_SIMPLE_INT_COL, &cursor);
        print_error (rc);

        if (rc == sOKAY)
        {
            /* Loop through each simple record in table order */
            for (rc = rdm_cursorMoveToLast (cursor); rc == sOKAY;
                 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;
}

int main_core23 (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);
    if (rc != sCMD_USAGE)
        print_error (rc);

    if (rc == sOKAY)
    {
        /* Initialize the handles and open the database */
        timeMeasureBegin (&timer);
        rc = exampleOpenEmptyDatabase (&hTFS, &hDB, "core23", core23_cat);
        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 (core23)