cppdb/backend.h

//                                                                             
//  Copyright (C) 2010-2011  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  Distributed under:
//
//                   the Boost Software License, Version 1.0.
//              (See accompanying file LICENSE_1_0.txt or copy at 
//                     http://www.boost.org/LICENSE_1_0.txt)
//
//  or (at your opinion) under:
//
//                               The MIT License
//                 (See accompanying file MIT.txt or a copy at
//              http://www.opensource.org/licenses/mit-license.php)
//
#ifndef CPPDB_BACKEND_H
#define CPPDB_BACKEND_H
#include <iosfwd>
#include <ctime>
#include <string>
#include <memory>
#include <map>
#include <typeinfo>
#include <cppdb/defs.h>
#include <cppdb/errors.h>
#include <cppdb/ref_ptr.h>
#include <cppdb/connection_specific.h>

// Borland errors about unknown pool-type without this include.
#ifdef __BORLANDC__
#include <cppdb/pool.h>
#endif

namespace cppdb {
        class connection_info;
        // Borland needs pool.h, but not this forward declaration.
        #ifndef __BORLANDC__
        class pool;
        #endif

        namespace backend {     

                class CPPDB_API result : public ref_counted {
                public:
                        
                        typedef enum {
                                last_row_reached, 
                                next_row_exists,  
                                next_row_unknown  
                        } next_row;

                        virtual next_row has_next() = 0;
                        virtual bool next() = 0;
                        virtual bool fetch(int col,short &v) = 0;
                        virtual bool fetch(int col,unsigned short &v) = 0;
                        virtual bool fetch(int col,int &v) = 0;
                        virtual bool fetch(int col,unsigned &v) = 0;
                        virtual bool fetch(int col,long &v) = 0;
                        virtual bool fetch(int col,unsigned long &v) = 0;
                        virtual bool fetch(int col,long long &v) = 0;
                        virtual bool fetch(int col,unsigned long long &v) = 0;
                        virtual bool fetch(int col,float &v) = 0;
                        virtual bool fetch(int col,double &v) = 0;
                        virtual bool fetch(int col,long double &v) = 0;
                        virtual bool fetch(int col,std::string &v) = 0;
                        virtual bool fetch(int col,std::ostream &v) = 0;
                        virtual bool fetch(int col,std::tm &v) = 0;
                        virtual bool is_null(int col) = 0;
                        virtual int cols() = 0;
                        virtual int name_to_column(std::string const &) = 0;
                        virtual std::string column_to_name(int) = 0;

                        result();
                        virtual ~result();
                private:
                        struct data;
                        std::auto_ptr<data> d;
                };

                class statements_cache;

                class CPPDB_API statement : public ref_counted {
                public:
                        // Begin of API

                        virtual void reset() = 0;
                        virtual std::string const &sql_query() = 0;

                        virtual void bind(int col,std::string const &) = 0;
                        virtual void bind(int col,char const *s) = 0;
                        virtual void bind(int col,char const *b,char const *e) = 0;
                        virtual void bind(int col,std::tm const &) = 0;
                        virtual void bind(int col,std::istream &) = 0;
                        virtual void bind(int col,int v) = 0;
                        virtual void bind(int col,unsigned v) = 0;
                        virtual void bind(int col,long v) = 0;
                        virtual void bind(int col,unsigned long v) = 0;
                        virtual void bind(int col,long long v) = 0;
                        virtual void bind(int col,unsigned long long v) = 0;
                        virtual void bind(int col,double v) = 0;
                        virtual void bind(int col,long double v) = 0;
                        virtual void bind_null(int col) = 0;
                        virtual long long sequence_last(std::string const &sequence) = 0;
                        virtual unsigned long long affected() = 0;
                        virtual result *query() = 0;
                        virtual void exec() = 0;

                        // Caching support
                        static void dispose(statement *selfp);
                        
                        void cache(statements_cache *c);
                        statement();
                        virtual ~statement() ;
                private:
                        struct data;
                        std::auto_ptr<data> d;
                        statements_cache *cache_;
                };
        
                class CPPDB_API statements_cache {
                        statements_cache(statements_cache const &);
                        void operator=(statements_cache const &);
                public:
                        statements_cache();
                        bool active();
                        void set_size(size_t n);
                        void put(statement *p_in);
                        void clear();
                        ref_ptr<statement> fetch(std::string const &q);
                        ~statements_cache();
                private:
                        struct data;
                        std::auto_ptr<data> d;
                };


                class connection;

                class CPPDB_API driver : public ref_counted {
                        driver(driver const &);
                        void operator=(driver const &);
                public:
                        driver() {}
                        virtual ~driver() {}
                        virtual bool in_use() = 0;
                        virtual connection *open(connection_info const &cs) = 0;
                        virtual connection *connect(connection_info const &cs);
                };
        
                class CPPDB_API loadable_driver : public driver {
                        loadable_driver(loadable_driver const &);
                        void operator=(loadable_driver const &);
                public:
                        loadable_driver() {}
                        virtual bool in_use();
                        virtual ~loadable_driver() {}

                        virtual connection *connect(connection_info const &cs);
                };

                extern "C" {
                        typedef cppdb::backend::connection *cppdb_backend_connect_function(connection_info const &ci);
                }


                class CPPDB_API static_driver : public driver {
                public:
                        typedef cppdb_backend_connect_function *connect_function_type;

                        static_driver(connect_function_type c);
                        ~static_driver();
                        bool in_use();
                        backend::connection *open(connection_info const &ci);
                private:
                        connect_function_type connect_;
                };


                class CPPDB_API connection : public ref_counted {
                public:
                        connection(connection_info const &info);
                        virtual ~connection();
                        void set_pool(ref_ptr<pool> p);
                        ref_ptr<pool> get_pool(); 
                        void set_driver(ref_ptr<loadable_driver> drv);
                        static void dispose(connection *c);
                        ref_ptr<statement> prepare(std::string const &q);
                        ref_ptr<statement> get_prepared_statement(std::string const &q);
                        ref_ptr<statement> get_prepared_uncached_statement(std::string const &q);
                        ref_ptr<statement> get_statement(std::string const &q);

                        // API 

                        virtual void begin() = 0;
                        virtual void commit() = 0;
                        virtual void rollback() = 0;
                        virtual statement *prepare_statement(std::string const &q) = 0;
                        virtual statement *create_statement(std::string const &q) = 0;
                        virtual std::string escape(std::string const &) = 0;
                        virtual std::string escape(char const *s) = 0;
                        virtual std::string escape(char const *b,char const *e) = 0;
                        virtual std::string driver() = 0;
                        virtual std::string engine() = 0;

                        void clear_cache();

                        bool once_called() const;
                        
                        void once_called(bool v);

                        connection_specific_data *connection_specific_get(std::type_info const &type) const;
                        connection_specific_data *connection_specific_release(std::type_info const &type);
                        void connection_specific_reset(std::type_info const &type,connection_specific_data *p = 0);

                        bool recyclable();
                        
                        void recyclable(bool value);

                private:

                        struct data;
                        std::auto_ptr<data> d;
                        statements_cache cache_;
                        ref_ptr<loadable_driver> driver_;
                        ref_ptr<pool> pool_;
                        unsigned default_is_prepared_ : 1;
                        unsigned once_called_ : 1;
                        unsigned recyclable_ : 1;
                        unsigned reserverd_ : 29;
                };

        } // backend
} // cppdb

#endif