cpp35Example_main.cpp

R-Tree example (see R-Tree CPP Example). This example needs a compiled schema, cpp35Example.sdl.

/* ----------------------------------------------------------------------------
                                                    
*
                                                    
* Raima Database Manager
                                                    
*
                                                    
* Copyright (c) 2020 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 "rdm.h"
                                                    
#include "rdmstartupapi.h"
                                                    
#include "rdmapi.h"
                                                    
#include "rdmtfsapi.h"
                                                    
#include "cpp35Example_structs.h"
                                                    
#include "cpp35Example_cat.h"
                                                    
#include "cpp35Example_gen_api.h"
                                                    

                                                    
#include "cpp-tfs.h"
                                                    
#include "cpp-exception.h"
                                                    
#include "cpp-transaction.h"
                                                    

                                                    
#include <iostream>
                                                    

                                                    
using namespace RDM_CPP;
using namespace RDM_CPP::CPP35EXAMPLE;

                                                    
#define FIXED_FLOAT(x) std::fixed << (x)
                                                    

                                                    
/* \file rtreeExample.c
                                                    
\brief Simple r-tree example using the RDM C++ API
                                                    

                                                    
This example will show you how to manage 2 dimensional data, using an
                                                    
r-tree index.
                                                    

                                                    
The example will insert several rows containing point data which
                                                    
will be put into an r-tree.
                                                    

                                                    
The example will then perform a series of queries to retrieve the data
                                                    
that meet specific criteria.
                                                    
*/
                                                    

                                                    
/* \brief Delete all data from the database
                                                    

                                                    
This function will remove all rows from all tables in the database.
                                                    
*/
                                                    
static void delete_data (Db_cpp35Example db)
{
RDM_TABLE_ID tablesToLock[1] = {TABLE_RTREE_TABLE};

                                                    
std::cout << "Removing all data from the database" << std::endl;

                                                    
/* Start an update transaction */
                                                    
db.StartUpdate (tablesToLock, 1);
try
                                                    
{
db.DeleteAllRows ();
db.End ();
} catch (rdm_exception e)
{
db.EndRollback ();
throw;
}
}

                                                    
/* \brief Print the contents of a rectangle
                                                    
*/
                                                    
static void printRectangle (double rect[4])
{
std::cout << "{ (" << std::fixed << rect[0] << ", " << rect[1] << "), ("
<< rect[2] << ", " << rect[3] << ") }";
}

                                                    
/* \brief Insert rows into the RTREE_TABLE table
                                                    

                                                    
This function will insert two rows into the RTREE_TABLE table.
                                                    
*/
                                                    
static void insert_data (Db_cpp35Example db)
{
uint32_t ii;
RDM_TABLE_ID tablesToLock[1] = {TABLE_RTREE_TABLE};
RTREE_TABLE row_data[] =
{/* utm coordinates */
/* id | x-min | y-min | x-max | y-max
                                                    
*/
                                                    
{"T_SIG_4356_UTM",
{536606.1538, 5279277.737, 536606.1538, 5279277.737}},
{"T_SIG_4357_UTM",
{536610.0608, 5279253.421, 536610.0608, 5279253.421}},
{"T_SIG_4358_UTM",
{536584.7699, 5279251.706, 536584.7699, 5279251.706}},
{"T_SIG_4359_UTM",
{536588.0522, 5279278.956, 536588.0522, 5279278.956}},
{"T_SIG_4405_UTM",
{536175.4322, 5278455.695, 536175.4322, 5278455.695}},
{"T_SIG_4406_UTM",
{536159.8151, 5278443.372, 536159.8151, 5278443.372}},
{"T_SIG_4407_UTM",
{536143.4427, 5278455.941, 536143.4427, 5278455.941}},
{"T_SIG_4408_UTM",
{536150.6135, 5278474.102, 536150.6135, 5278474.102}},
{"T_SIG_4458_UTM",
{536201.2532, 5278082.970, 536201.2532, 5278082.970}},
{"T_SIG_4459_UTM",
{536191.8691, 5278070.464, 536191.8691, 5278070.464}},
{"T_SIG_4460_UTM",
{536182.6727, 5278076.075, 536182.6727, 5278076.075}},
{"T_SIG_4461_UTM",
{536192.0458, 5278090.360, 536192.0458, 5278090.360}},

                                                    
/* geo coordinates */
                                                    
/* id | x-min | y-min | x-max | y-max */
                                                    
{"T_SIG_4356_GEO", {47.665856, 9.487589, 47.665856, 9.487589}},
{"T_SIG_4357_GEO", {47.665637, 9.487639, 47.665637, 9.487639}},
{"T_SIG_4358_GEO", {47.665623, 9.487302, 47.665623, 9.487302}},
{"T_SIG_4359_GEO", {47.665868, 9.487348, 47.665868, 9.487348}},
{"T_SIG_4405_GEO", {47.658484, 9.481784, 47.658484, 9.481784}},
{"T_SIG_4406_GEO", {47.658374, 9.481575, 47.658374, 9.481575}},
{"T_SIG_4407_GEO", {47.658488, 9.481358, 47.658488, 9.481358}},
{"T_SIG_4408_GEO", {47.658651, 9.481455, 47.658651, 9.481455}},
{"T_SIG_4458_GEO", {47.655129, 9.482097, 47.655129, 9.482097}},
{"T_SIG_4459_GEO", {47.655017, 9.481971, 47.655017, 9.481971}},
{"T_SIG_4460_GEO", {47.655068, 9.481849, 47.655068, 9.481849}},
{"T_SIG_4461_GEO", {47.655196, 9.481975, 47.655196, 9.481975}}};

                                                    
/* First we will remove all existing data from the database */
                                                    
delete_data (db);

                                                    
std::cout << "Inserting data..." << std::endl;

                                                    
/* Start a transaction */
                                                    
db.StartUpdate (tablesToLock, 1);
try
                                                    
{
for (ii = 0; ii < RDM_LEN (row_data); ii++)
{
db.Insert_rtree_table_Row (row_data[ii]);

                                                    
std::cout << " ** Inserted Row id: " << row_data[ii].id
<< ", rect = ";
printRectangle (row_data[ii].rect);
std::cout << std::endl;
}
db.End ();
} catch (rdm_exception e)
{
db.EndRollback ();
throw;
}
}

                                                    
/* \brief Print the current for of a cursor based on the RTREE_TABLE
                                                    
*/
                                                    
static void printCurrentRtreeTableRow (Cursor_rtree_table cursor)
{
RTREE_TABLE row;

                                                    
/* Read the value of the current row into a structure */
                                                    
cursor.ReadRow (row);

                                                    
/* Print the row that was read */
                                                    
std::cout << " ** Found Row id: " << row.id << ", rect = ";
printRectangle (row.rect);
std::cout << std::endl;
}

                                                    
/* \brief Look up rectangles that meet the specified criteria
                                                    

                                                    
This function will read create a cursor containing all rectangles in the
                                                    
r-tree that meet the bounding box criteria. It will then iterate through
                                                    
the cursor and display the rows.
                                                    
*/
                                                    
static void displayRectangles (
Db_cpp35Example db, /*< [in] database handle */
RDM_RTREE_TYPE type, /*< [in] The query type */
double boundingBox[4] /*< [in] The bounding box */
)
{
Cursor_rtree_table cursor;
RDM_TABLE_ID tablesToLock[] = {TABLE_RTREE_TABLE};
RDM_BOOL_T found = RDM_FALSE;

                                                    
/* Get a read lock on the RTREE_TABLE table */
                                                    
db.StartRead (tablesToLock, RDM_LEN (tablesToLock));
try
                                                    
{
/* Create the cursor using the r-tree */
                                                    
cursor = db.Get_rtree_table_RowsBy_rect (boundingBox, type);

                                                    
/* Move to the first resulting row */
                                                    
cursor.MoveToFirst ();
while (cursor.GetStatus () == CURSOR_AT_ROW)
{
found = RDM_TRUE;

                                                    
/* Print the current cursor row */
                                                    
printCurrentRtreeTableRow (cursor);

                                                    
/* Move to the next row */
                                                    
cursor.MoveToNext ();
}

                                                    
/* Free the locks */
                                                    
db.End ();
} catch (rdm_exception e)
{
std::cerr << "Error in displayRectangles";
db.End ();
throw;
}

                                                    
/* Display a message if we didn't retrieve any rows */
                                                    
if (found == RDM_FALSE)
{
std::cout << " ** No Rows Found" << std::endl;
}
}

                                                    
/* \brief Look up rectangles contained by the specified bounding box
                                                    
*/
                                                    
static void displayContainedRectangles (
Db_cpp35Example db, /*< [IN} The database handle */
double boundingBox[4] /*< [IN] The bounding box value */
)
{
displayRectangles (db, RDM_RTREE_CONTAINS, boundingBox);
}

                                                    
/* \brief Look up rectangles overlapping the specified bounding box
                                                    
*/
                                                    
static void displayOverlappingRectangles (
Db_cpp35Example db, /*< [IN] The database handle */
double boundingBox[4] /*< [IN] The bounding box value */
)
{
displayRectangles (db, RDM_RTREE_OVERLAP, boundingBox);
}

                                                    
/* \brief The main function
                                                    

                                                    
This function will do initialization and cleanup as well as call
                                                    
the functions that insert/retrieve data
                                                    
*/
                                                    
int32_t main_rtreeCPP (int32_t argc, const char *const *argv)
{
TFS tfs = NULL;
Db_cpp35Example db;
double boundingBox[4];

                                                    
RDM_UNREF (argc);
RDM_UNREF (argv);

                                                    
try
                                                    
{
/* Allocate RDM_TFS handle */
                                                    
tfs = TFS::Alloc ("");

                                                    
/* Allocate RDM_DB handle */
                                                    
db = tfs.AllocDatabase ();

                                                    
/* Open database */
                                                    
db.Open ("cpp35Example");

                                                    
/* Insert data */
                                                    
insert_data (db);

                                                    
/* Do lookups with a bounding box that contains two of the rows in the
                                                    
table that use utm coordinates. In this case there are tree
                                                    
candidates for the X value, but only 2 matches for the Y value */
                                                    
boundingBox[0] = 536100.0000; /* Min X Value */
boundingBox[1] = 5278440.0000; /* Min Y Value */
boundingBox[2] = 536159.0000; /* Max X Value */
boundingBox[3] = 5278475.000; /* Max Y Value */

                                                    
std::cout << std::endl
<< std::endl
<< "Looking for rows CONTAINED by the bounding box ";
printRectangle (boundingBox);
std::cout << std::endl << "There should be 2 rows found" << std::endl;
displayContainedRectangles (db, boundingBox);

                                                    
/* Do lookups with a bounding box that contains two of the rows in the
                                                    
* table that use geo coordinates */
                                                    
boundingBox[0] = 47.655000; /* Min X Value */
boundingBox[1] = 9.481000; /* Min Y Value */
boundingBox[2] = 47.665600; /* Max X Value */
boundingBox[3] = 9.482000; /* Max Y Value */

                                                    
std::cout << std::endl
<< std::endl
<< "Looking for rows CONTAINED by the bounding box ";
printRectangle (boundingBox);
std::cout << std::endl << "There should be 7 rows found" << std::endl;
displayContainedRectangles (db, boundingBox);

                                                    
/* Do lookups with a bounding box that doesn't contain rows from
                                                    
either of the coordinate systems */
                                                    
boundingBox[0] = 6; /* Min X Value */
boundingBox[1] = 14; /* Min Y Value */
boundingBox[2] = 19; /* Max X Value */
boundingBox[3] = 25; /* Max Y Value */

                                                    
std::cout << std::endl
<< std::endl
<< "Looking for rows CONTAINED by the bounding box ";
printRectangle (boundingBox);
std::cout << std::endl << "There should be 0 rows found" << std::endl;
displayContainedRectangles (db, boundingBox);

                                                    
} catch (rdm_exception e)
{
std::cerr << "Database Error: " << e.GetEnum () << " - "
<< e.GetDescription () << std::endl;
}

                                                    
return 0;
}

                                                    
RDM_STARTUP_EXAMPLE (rtreeCPP)