add forgotten file

/*******************************************************************************

 * Copyright (c) 2023, Jan Koester jan.koester@gmx.net

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright

 *      notice, this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright

 *      notice, this list of conditions and the following disclaimer in the

 *      documentation and/or other materials provided with the distribution.

 * Neither the name of the <organization> nor the

 *      names of its contributors may be used to endorse or promote products

 *      derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *******************************************************************************/

#include <iostream>

#include <atomic>

#include <httppp/exception.h>

#include <sqlite3.h>

#include <database.h>

namespace dbpp {

    std::atomic<bool> sqllock(false);

    class SQLite : public DatabaseApi{

    public:

        SQLite(const char *constr){

            while( sqllock.exchange(true, std::memory_order_acquire) );

            int status=sqlite3_open(constr,&_dbconn);

            if (status != SQLITE_OK ){

                libhttppp::HTTPException exp;

                exp[libhttppp::HTTPException::Critical] << sqlite3_errmsg(_dbconn);

                sqlite3_close(_dbconn);

                throw exp;

            }

            sqllock.store(false);

        }

        ~SQLite(){

            sqlite3_close(_dbconn);

        }

        int exec(const SQL &sql,DBResult &res) override{

            while( sqllock.exchange(true, std::memory_order_acquire) );

            char *ssql;

            ssql=new char[sql.size()];

            memcpy(ssql,sql.c_str(),sql.size());

            sqlite3_stmt *prep;

            int rcount = 0;

            res.clear();

            DBResult::Data *lastdat;

            const char *cssql=ssql;

            do{

                const char *sqlptr=nullptr;

                int pstate=sqlite3_prepare_v3(_dbconn,cssql,sql.size(),0,&prep,&sqlptr);

                cssql=sqlptr;

                if(pstate == SQLITE_ERROR) {

                    std::cerr << sqlite3_errmsg(_dbconn) << std::endl;

                    continue;

                }

                if(!prep)

                    continue;

                int pcode;

                while( ( pcode = sqlite3_step(prep) ) !=SQLITE_DONE ) {

                   if(pcode==SQLITE_ERROR){

                        libhttppp::HTTPException exp;

                        exp[libhttppp::HTTPException::Critical] << sqlite3_errmsg(_dbconn);

                        delete[] ssql;

                        sqllock.store(false);

                        throw exp;

                    }

                    if(pcode==SQLITE_ROW){

                         int i;

                         for(i=0; i < sqlite3_column_count(prep); ++i){

                            if(!res.firstRow){

                                res.firstRow = new DBResult::Data(rcount,i,(const char*)sqlite3_column_text(prep,i),sqlite3_column_bytes(prep,i));

                                lastdat=res.firstRow;

                            }else{

                                lastdat->nextData=new DBResult::Data(rcount,i,(const char*)sqlite3_column_text(prep,i),sqlite3_column_bytes(prep,i));

                                lastdat=lastdat->nextData;

                            }

                        }

                        ++rcount;

                    }

                } 

                sqlite3_finalize(prep);

            }while(cssql != ssql+sql.size());

            sqllock.store(false);

            delete[] ssql;

            return rcount;

        };

        const char *getDriverName() override{

            return "sqlite";

        };

        const SQL &autoincrement(SQL &sql) override{

            return (sql <<"AUTOINCREMENT");

        }

        const SQL &getUUIDType(SQL &sql) override{

            return (sql << "Binary()");

        }

        bool isConnected() override{

            int current,high;

            if(sqlite3_db_status(_dbconn,0,&current,&high,0)==SQLITE_OK)

                return true;

            return false;

        }

        void reset() override{

            int current,high;

            sqlite3_db_status(_dbconn,0,&current,&high,1);

        }

    private:

        sqlite3  *_dbconn;

    };

}