SQLiteQuery.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_SQLITEQUERY_H_
#define _MIRA_SQLITEQUERY_H_

#include <utils/ToString.h>
#include <serialization/adapters/std/pair>
#include <serialization/adapters/std/vector>

struct sqlite3;
struct sqlite3_stmt;

namespace mira {


class SQLiteQuery
{
public:

    SQLiteQuery();

    SQLiteQuery(sqlite3* db, sqlite3_stmt* statement, bool more);

    // no copy as copying statement would be illegal
    SQLiteQuery(const SQLiteQuery& other) = delete;
    SQLiteQuery& operator=(const SQLiteQuery& other) = delete;

    // move, moves statement
    SQLiteQuery(SQLiteQuery&& other) noexcept;
    SQLiteQuery& operator=(SQLiteQuery&& other) noexcept;

    ~SQLiteQuery();


public:

    bool valid() const
    {
        return mStatement != NULL;
    }

    bool eof() const
    {
        return mMore == false;
    }

    int getColumnCount() const
    {
        return mColumnCount;
    }

    std::string getName(std::size_t column);

    template<typename T>
    T getValue(std::size_t column)
    {
        const char* data = getTxtValue(column);
        if ( data == NULL )
            MIRA_THROW(XBadCast, "Value of column '" << column << "' is NULL");
        return fromString<T>(data);
    }

    template<typename T>
    T getValue(std::size_t column, const T& defaultValue)
    {
        const char* data = getTxtValue(column);
        if ( data == NULL )
            return defaultValue;
        return fromString<T>(data);
    }

    int getDataType(std::size_t column);

    bool isNull(std::size_t column);


    void next();

    SQLiteQuery& operator++()
    {
        next();
        return *this;
    }

private:
    const char* getTxtValue(std::size_t column);

    sqlite3* mDB;
    sqlite3_stmt* mStatement;
    bool mMore;
    int mColumnCount;
};


class SQLiteCachedQuery
{
public:
    typedef std::vector<std::string> HeaderVector;
    typedef std::vector<std::vector<std::pair<int, std::string>>> ValueVector;

public:

    SQLiteCachedQuery();

    SQLiteCachedQuery(SQLiteQuery& query);


public:
    
    bool eof() const
    {
        return mCurrent >= mCache.size();
    }

    int getColumnCount() const
    {
        return mHeader.size();
    }

    std::string getName(std::size_t column)
    {
        if(column>=mHeader.size())
            MIRA_THROW(XAccessViolation, "Column " << column << " does not exist");

        return mHeader[column];
    }
    
    template<typename T>
    T getValue(std::size_t column)
    {
        if (isNull(column))
            MIRA_THROW(XBadCast, "Value of column '" << column << "' is NULL");
        return fromString<T>(mCache[mCurrent][column].second);
    }

    template<typename T>
    T getValue(std::size_t column, const T& defaultValue)
    {
        if (isNull(column))
            return defaultValue;
        try
        {
            return fromString<T>(mCache[mCurrent][column].second);
        }
        catch(...)
        {
        }
        return defaultValue;
    }

    int getDataType(std::size_t column);
    
    bool isNull(std::size_t column);


    void next()
    {
        validate();
        ++mCurrent;
    }

    SQLiteCachedQuery& operator++()
    {
        next();
        return *this;
    }

    ValueVector getValues() const
    {
        return mCache;
    }


public:
    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Header", mHeader, "The header of the query");
        r.member("Values", mCache, "The values of the query");
    }

protected:

    void validate()
    {
        if(eof())
            MIRA_THROW(XAccessViolation, "Access to invalid query object.");
    }

    void validate(std::size_t column)
    {
        validate();
        if(column>=mCache[mCurrent].size())
            MIRA_THROW(XAccessViolation, "Column " << column << " does not exist");
    }

    HeaderVector mHeader;
    ValueVector mCache;
    std::size_t mCurrent;
};


}

#endif