CSimpleDatabase.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "db-precomp.h"  // Precompiled headers
 
#include <mrpt/db/CSimpleDatabase.h>
#include <mrpt/serialization/CArchive.h>
#include <mrpt/system/os.h>
 
using namespace mrpt::db;
using namespace mrpt::system;
using namespace std;
 
#undef _UNICODE  // JLBC
 
#include "xmlparser/xmlParser.h"
 
#include <iostream>
 
// This must be added to any CSerializable class implementation file.
IMPLEMENTS_SERIALIZABLE(CSimpleDatabase, CSerializable, mrpt::db)
IMPLEMENTS_SERIALIZABLE(CSimpleDatabaseTable, CSerializable, mrpt::db)
 
uint8_t CSimpleDatabase::serializeGetVersion() const { return 0; }
void CSimpleDatabase::serializeTo(mrpt::serialization::CArchive& out) const
{
        // Save all tables in DB:
        uint32_t n = (uint32_t)m_tables.size();
        out << n;
 
        for (const_iterator i = m_tables.begin(); i != m_tables.end(); ++i)
        {
                out << i->first;  //.c_str();
                out << *i->second;
        }
}
void CSimpleDatabase::serializeFrom(
        mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                {
                        std::string aux;
 
                        // Clear existing tables:
                        clear();
 
                        // Load all tables in DB:
                        uint32_t n;
                        in >> n;
 
                        for (uint32_t i = 0; i < n; i++)
                        {
                                in >> aux;
 
                                CSimpleDatabaseTable::Ptr newTb =
                                        mrpt::make_aligned_shared<CSimpleDatabaseTable>();
                                in >> (*newTb);
 
                                m_tables[aux] = newTb;
                        }
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
uint8_t CSimpleDatabaseTable::serializeGetVersion() const { return 0; }
void CSimpleDatabaseTable::serializeTo(mrpt::serialization::CArchive& out) const
{
        uint32_t row, col, nRec = (uint32_t)getRecordCount(),
                                           nFie = (uint32_t)fieldsCount();
 
        out << nRec << nFie;
 
        for (col = 0; col < nFie; col++) out << field_names[col];  //.c_str();
 
        for (row = 0; row < nRec; row++)
                for (col = 0; col < nFie; col++) out << data[row][col];  //.c_str();
}
void CSimpleDatabaseTable::serializeFrom(
        mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                {
                        uint32_t row, col, nRec, nFie;
                        // char         str[10000];
 
                        in >> nRec >> nFie;
 
                        data.resize(nRec);
                        field_names.resize(nFie);
 
                        for (col = 0; col < nFie; col++) in >> field_names[col];
 
                        for (row = 0; row < nRec; row++)
                        {
                                data[row].resize(nFie);
 
                                for (col = 0; col < nFie; col++) in >> data[row][col];
                        }
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
/*---------------------------------------------------------------
                                                Constructor
 ---------------------------------------------------------------*/
CSimpleDatabase::CSimpleDatabase() {}
/*---------------------------------------------------------------
                                                Destructor
 ---------------------------------------------------------------*/
CSimpleDatabase::~CSimpleDatabase() { clear(); }
/*---------------------------------------------------------------
                                                Clear the DB
 ---------------------------------------------------------------*/
void CSimpleDatabase::clear() { m_tables.clear(); }
/*---------------------------------------------------------------
                                                getTable
 ---------------------------------------------------------------*/
CSimpleDatabaseTable::Ptr CSimpleDatabase::getTable(
        const std::string& tableName)
{
        MRPT_START
 
        iterator it = m_tables.find(tableName);
        if (it != m_tables.end()) return it->second;
 
        THROW_EXCEPTION_FMT("Table '%s' was not found", tableName.c_str())
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                getTable
 ---------------------------------------------------------------*/
CSimpleDatabaseTable::Ptr CSimpleDatabase::getTable(size_t tableIndex)
{
        MRPT_START
 
        ASSERT_(tableIndex < tablesCount());
        iterator it = m_tables.begin();
        std::advance(it, tableIndex);
        return it->second;
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                        tablesCount
 ---------------------------------------------------------------*/
size_t CSimpleDatabase::tablesCount() const { return m_tables.size(); }
/*---------------------------------------------------------------
                                        tablesName
 ---------------------------------------------------------------*/
string CSimpleDatabase::tablesName(size_t tableIndex) const
{
        MRPT_START
 
        ASSERT_(tableIndex < tablesCount());
        const_iterator it = m_tables.begin();
        std::advance(it, tableIndex);
        return it->first;
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                createTable
 ---------------------------------------------------------------*/
CSimpleDatabaseTable::Ptr CSimpleDatabase::createTable(const string& name)
{
        CSimpleDatabaseTable::Ptr table =
                mrpt::make_aligned_shared<CSimpleDatabaseTable>();
        m_tables[name] = table;
        return table;
}
 
/*---------------------------------------------------------------
                                                Constructor
 ---------------------------------------------------------------*/
CSimpleDatabaseTable::CSimpleDatabaseTable() {}
/*---------------------------------------------------------------
                                                Destructor
 ---------------------------------------------------------------*/
CSimpleDatabaseTable::~CSimpleDatabaseTable() {}
/*---------------------------------------------------------------
                                        fieldsCount
 ---------------------------------------------------------------*/
size_t CSimpleDatabaseTable::fieldsCount() const { return field_names.size(); }
/*---------------------------------------------------------------
                                                addField
 ---------------------------------------------------------------*/
void CSimpleDatabaseTable::addField(const char* fieldName)
{
        field_names.push_back(string(fieldName));
        data.clear();
}
 
/*---------------------------------------------------------------
                                                getFieldName
 ---------------------------------------------------------------*/
string CSimpleDatabaseTable::getFieldName(size_t fieldIndex) const
{
        MRPT_START
 
        ASSERT_(fieldIndex < fieldsCount());
        return field_names[fieldIndex];
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                        fieldIndex
 ---------------------------------------------------------------*/
size_t CSimpleDatabaseTable::fieldIndex(const char* fieldName) const
{
        MRPT_START
 
        size_t i, n = field_names.size();
 
        for (i = 0; i < n; i++)
                if (!os::_strcmpi(fieldName, field_names[i].c_str())) return (int)i;
 
        THROW_EXCEPTION_FMT("fieldIndex: Field '%s' not found", fieldName);
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                getRecordCount
 ---------------------------------------------------------------*/
size_t CSimpleDatabaseTable::getRecordCount() const { return data.size(); }
/*---------------------------------------------------------------
                                                get
 ---------------------------------------------------------------*/
string CSimpleDatabaseTable::get(size_t recordIndex, string field) const
{
        MRPT_START
        ASSERT_(recordIndex < getRecordCount());
        return data[recordIndex][fieldIndex(field.c_str())];
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                get
 ---------------------------------------------------------------*/
string CSimpleDatabaseTable::get(size_t recordIndex, size_t fieldIndex) const
{
        MRPT_START
        ASSERT_(recordIndex < getRecordCount());
        ASSERT_(fieldIndex < fieldsCount());
        return data[recordIndex][fieldIndex];
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void CSimpleDatabaseTable::set(size_t recordIndex, string field, string value)
{
        MRPT_START
 
        ASSERT_(recordIndex < getRecordCount());
        data[recordIndex][fieldIndex(field.c_str())] = value;
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void CSimpleDatabaseTable::set(
        size_t recordIndex, size_t fieldIndex, string value)
{
        MRPT_START
 
        ASSERT_(recordIndex < getRecordCount());
        ASSERT_(fieldIndex < fieldsCount());
        data[recordIndex][fieldIndex] = value;
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                query
 ---------------------------------------------------------------*/
int CSimpleDatabaseTable::query(string field, string value) const
{
        int fieldInd, i, n = (uint32_t)getRecordCount();
 
        try
        {
                fieldInd = (uint32_t)fieldIndex(field.c_str());
        }
        catch (...)
        {
                return -1;
        }
 
        for (i = 0; i < n; i++)
        {
                if (!os::_strcmpi(value.c_str(), data[i][fieldInd].c_str())) return i;
        }
 
        // Do not found:
        return -1;
}
 
/*---------------------------------------------------------------
                                                appendRecord
 ---------------------------------------------------------------*/
size_t CSimpleDatabaseTable::appendRecord()
{
        std::vector<std::string> new_rec;
 
        new_rec.resize(fieldsCount());
        data.push_back(new_rec);
 
        return data.size() - 1;
}
 
/*---------------------------------------------------------------
                                                deleteRecord
 ---------------------------------------------------------------*/
void CSimpleDatabaseTable::deleteRecord(size_t recordIndex)
{
        MRPT_START
        ASSERT_(recordIndex < getRecordCount());
        std::vector<std::vector<std::string>>::iterator it = data.begin();
        std::advance(it, recordIndex);
        data.erase(it);
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                saveAsXML
 ---------------------------------------------------------------*/
bool CSimpleDatabase::saveAsXML(const string& fileName) const
{
        try
        {
                // Root node:
                XMLNode rootXml =
                        XMLNode::createXMLTopNode("CSimpleDatabase-MRPT-Object");
 
                // For each table:
                for (const_iterator it = m_tables.begin(); it != m_tables.end(); ++it)
                {
                        CSimpleDatabaseTable::Ptr t = it->second;
                        XMLNode tabNod = rootXml.addChild("table");
                        tabNod.addAttribute("name", it->first.c_str());
 
                        // Add field descriptions:
                        // ------------------------
                        size_t nFields = t->fieldsCount();
                        size_t nRecs = t->getRecordCount();
 
                        XMLNode fNod = tabNod.addChild("fields");
                        for (unsigned int i = 0; i < nFields; i++)
                                fNod.addChild(t->getFieldName(i).c_str());
 
                        // Add record contents:
                        // ------------------------
                        for (unsigned int i = 0; i < nRecs; i++)
                        {
                                XMLNode recNod = tabNod.addChild("record");
                                for (size_t j = 0; j < nFields; j++)
                                {
                                        XMLNode recContent =
                                                recNod.addChild(t->getFieldName(j).c_str());
                                        recContent.addText(t->get(i, j).c_str());
                                }
                        }
 
                }  // end for each table.
 
                rootXml.writeToFile(fileName.c_str());
 
                return true;  // Ok
        }
        catch (exception& e)
        {
                cerr << "[CSimpleDatabase::saveAsXML] Exception ignored:" << endl
                         << e.what() << endl;
                return false;  // Errors found
        }
        catch (...)
        {
                return false;  // Errors found
        }
}
 
/*---------------------------------------------------------------
                                                loadFromXML
 ---------------------------------------------------------------*/
bool CSimpleDatabase::loadFromXML(const string& fileName)
{
        try
        {
                XMLResults results;
                XMLNode root = XMLNode::parseFile(fileName.c_str(), nullptr, &results);
 
                if (results.error != eXMLErrorNone)
                {
                        cerr << "[CSimpleDatabase::loadFromXML] Error loading XML file: "
                                 << XMLNode::getError(results.error) << " at line "
                                 << results.nLine << ":" << results.nColumn << endl;
                        return false;
                }
 
                root = root.getChildNode("CSimpleDatabase-MRPT-Object");
                if (root.isEmpty())
                {
                        cerr << "[CSimpleDatabase::loadFromXML] Loaded XML file does not "
                                        "have a 'CSimpleDatabase-MRPT-Object' tag";
                        return false;
                }
 
                // Clear previous contents:
                clear();
 
                // Get tables:
                size_t i, j, nTables = root.nChildNode("table");
                for (i = 0; i < nTables; i++)
                {
                        XMLNode tabNod = root.getChildNode("table", (int)i);
                        ASSERT_(!tabNod.isEmpty());
                        // Create table:
                        CSimpleDatabaseTable::Ptr t =
                                createTable(tabNod.getAttribute("name"));
 
                        // Create fields:
                        XMLNode fNod = tabNod.getChildNode("fields");
                        ASSERT_(!fNod.isEmpty());
                        size_t nFields = fNod.nChildNode();
                        for (j = 0; j < nFields; j++)
                        {
                                t->addField(fNod.getChildNode((int)j).getName());
                        }  // end for each field
 
                        // Add record data:
                        size_t nRecs = tabNod.nChildNode("record");
                        for (size_t k = 0; k < nRecs; k++)
                        {
                                size_t recIdx = t->appendRecord();
 
                                XMLNode recNod = tabNod.getChildNode("record", (int)k);
                                ASSERT_(!recNod.isEmpty());
                                for (j = 0; j < nFields; j++)
                                {
                                        XMLCSTR str =
                                                recNod.getChildNode(t->getFieldName(j).c_str())
                                                        .getText();
                                        t->set(recIdx, j, str != nullptr ? string(str) : string());
                                }
 
                        }  // end for each record
 
                }  // for each table
 
                return true;  // Ok
        }
        catch (exception& e)
        {
                cerr << "[CSimpleDatabase::loadFromXML] Exception ignored:" << endl
                         << e.what() << endl;
                return false;  // Errors found
        }
        catch (...)
        {
                return false;  // Errors found
        }
}
 
/*---------------------------------------------------------------
                                                dropTable
 ---------------------------------------------------------------*/
void CSimpleDatabase::dropTable(const std::string& tableName)
{
        MRPT_START
 
        iterator it = m_tables.find(tableName);
        if (it == m_tables.end())
                THROW_EXCEPTION_FMT("Table '%s' was not found", tableName.c_str())
 
        m_tables.erase(it);
 
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                renameTable
 ---------------------------------------------------------------*/
void CSimpleDatabase::renameTable(
        const std::string& tableName, const std::string& newTableName)
{
        MRPT_START
 
        if (tableName == newTableName) return;  // done
 
        iterator it = m_tables.find(tableName);
        if (it == m_tables.end())
                THROW_EXCEPTION_FMT("Table '%s' was not found", tableName.c_str())
 
                {
                        iterator itNew = m_tables.find(newTableName);
                        if (itNew != m_tables.end())
                                THROW_EXCEPTION_FMT(
                                        "A table with the name '%s' already exists",
                                        newTableName.c_str())
                }
 
        CSimpleDatabaseTable::Ptr tb = it->second;
 
        m_tables.erase(it);
        m_tables[newTableName] = tb;
 
        MRPT_END
}