db/db.h

/*--------------------------------------------------------------------------

  This is part of the Distributed system of the Karoo project.

  (C) 2009 Brian Modra <brian@zwartberg.com>

  This library is free software; you can redistribute them and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License,
  or (at your option) any later version.

  This library 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with these libraries; if not, write to the Free Software Foundation,
  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

--------------------------------------------------------------------------*/

#ifndef db_h
#define db_h

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include "config.h"
#include "rock.h"
#include "log.h"
#include "util.h"
#include <pqxx/pqxx>
#include <vector>
using std::vector;

namespace karoo {

    class db: public referable {
    private:
        log logger;
        text conf;
        rock* parent;

        class conn_data: public referable {
        private:
            pqxx::connection* c;
            text conf;
        public:
            conn_data(const text& conf);
            virtual ~conn_data();
            operator pqxx::connection_base&();
            text getConf() { return conf; }
        };

        class conn_cleanup: public pebble {
        private:
            db* parent;
            mutable karoo_mutex sem;
            
        public:
            conn_cleanup(db* parent);
            virtual ~conn_cleanup();
            void run();
            void stop();
        };

    public:
        class conn {
        private:
            conn_data* c;
        public:
            conn(conn_data* c);
            conn(const conn& ref);
            virtual ~conn();

            const conn& operator=(const conn& ref);
            conn_data* getData() { return c; }
            operator pqxx::connection_base&();
            text getConf() { return c->getConf(); }
        };

    private:
        mutable karoo_mutex pool_sem;
        mutable karoo_mutex sem;
        bool stopping;
        size_t pool_sz;
        size_t prev_pool_sz;
        vector<db::conn*> pool;
        conn_cleanup* cleaner;
        mutable karoo_mutex types_sem;
        map<pqxx::oid,db_data_type> types;
    protected:
    public:
        db(rock* parent, const text& conf, size_t pool_sz = 1);
        virtual ~db();

        void setLogger(const log& logger);

        void setPoolSize(size_t sz);
        void configure(const text& conf, size_t pool_sz);

        db::conn getConnection();
        void cleanup();
        bool isStopping() const;
        void stop();
        void start();
        rock* getParent() { return parent; }
        db_data_type getColumnType(pqxx::oid id) const;
    };
}

#endif

---