sqlitepp.h

/* Copyright (C)
 * 2012 - Paul Weingardt
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef SQLITEPP_H
#define SQLITEPP_H

#include <sqlite3.h>
#include <time.h>
#include <stdlib.h>
#include <map>
#include <string>

namespace sqlitepp {

    std::string doubleToString(const double value);

    std::string floatToString(const float value);

    std::string intToString(const int value);

    class Statement;

    enum TransactionFlags {DEFERRED, IMMEDIATE, EXCLUSIVE};

    enum StepValue {ROW, DONE, UNKNOWN};

    enum OpenFlags {READONLY, READWRITE, CREATE};


    class Database {
        friend class Statement;
        private:
            void init(void);

            bool isopen;

            bool transaction;

            sqlite3* database;

            int lastResult;

            inline void checkDatabaseOpened() const;
        public:
            Database(void);

            Database(const std::string& path, const OpenFlags flag = CREATE);

            ~Database(void);

            void open(const std::string& path, const OpenFlags flag = CREATE);

            bool isOpen(void);

            void close(void);

            void activateForeignKeys(void);

            void deactivateForeignKeys(void);

            int exec(const std::string& sql);

            void beginTransaction(const TransactionFlags = DEFERRED);

            void endTransaction(void);

            void rollback(void);

            int getLastRowId(void);
    };


    class Statement {
        private:
            int lastResult;

            bool finalized;

            sqlite3_stmt* statement;

            Database& db;

            std::map<std::string, int> columns;

            StepValue step(void);

            inline void checkPrepared() const;

        public:
            Statement(Database& db);

            ~Statement();

            void bindString(const int n, const std::string& value);

            void bindInt(const int n, const int value);

            void bindDouble(const int n, const double value);

            void bindNull(const int n);

            std::string getString(const std::string& column) const;

            int getInt(const std::string& column) const;

            double getDouble(const std::string& column) const;

            void getString(const int n, std::string& out) const;

            void getInt(const int n, int& out) const;

            void getDouble(const int n, double& out) const;

            std::string getString(const int n) const ;

            int getInt(const int n) const;

            double getDouble(const int n) const;

            void prepare(const std::string& sql);

            bool fetchRow(void);

            void exec(void);

            void finalize(void);
    };


    class SQLiteException : public std::exception {
        private:
            std::string error;

        public:
            SQLiteException(const std::string& str) {
                this->error = str;
            }

            SQLiteException(sqlite3* db) {
                this->error = std::string(sqlite3_errmsg(db));
            }

            virtual ~SQLiteException() throw() {
            }

            virtual const char* what() const throw() {
                return this->error.c_str();
            }
    };

    extern SQLiteException DatabaseNotOpened;
    extern SQLiteException DatabaseOpened;
    extern SQLiteException StatementNotPrepared;
}

#endif