mysql.hpp

Go to the documentation of this file.

/***************************************************************************
* Copyright (C) 2007 Eddie Carle [eddie@erctech.org]                       *
*                                                                          *
* This file is part of fastcgi++.                                          *
*                                                                          *
* fastcgi++ is free software: you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as  published   *
* by the Free Software Foundation, either version 3 of the License, or (at *
* your option) any later version.                                          *
*                                                                          *
* fastcgi++ 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 fastcgi++.  If not, see <http://www.gnu.org/licenses/>.       *
****************************************************************************/


#ifndef MYSQL_HPP
#define MYSQL_HPP

#include <mysql/mysql.h>
#include <boost/scoped_array.hpp>
#include <boost/scoped_ptr.hpp>
#include <deque>

#include <asql/asql.hpp>

namespace ASql
{
   namespace MySQL
   {
      class Statement;

      class Connection: public ConnectionPar<MySQL::Statement>
      {
      private:

         boost::scoped_array<MYSQL> m_connection;


         boost::scoped_array<MYSQL_STMT*> foundRowsStatement;


         boost::scoped_array<MYSQL_BIND> foundRowsBinding;

         bool m_initialized;

      public:
         Connection(const char* host, const char* user, const char* passwd, const char* db, unsigned int port, const char* unix_socket, unsigned long client_flag, const char* const charset="latin1", const int threads_=1): ConnectionPar<MySQL::Statement>(threads_), m_initialized(false)
         {
            connect(host, user, passwd, db, port, unix_socket, client_flag, charset);
         }


         Connection(const int threads_=1):
            ConnectionPar<MySQL::Statement>(threads_),
            m_connection(new MYSQL[threads_]),
            foundRowsStatement(new MYSQL_STMT*[threads_]),
            foundRowsBinding(new MYSQL_BIND[threads_]),
            m_initialized(false) {}
         ~Connection();


         void connect(const char* host, const char* user, const char* passwd, const char* db, unsigned int port, const char* unix_socket, unsigned long client_flag, const char* const charset="latin1");


         void getFoundRows(unsigned long long* const& rows, const unsigned int id);

         MYSQL& connection(unsigned int id) { return m_connection[id]; }

         inline void commit(const unsigned int thread=0) { mysql_commit(&m_connection[thread]); }
         inline void rollback(const unsigned int thread=0)  { mysql_rollback(&m_connection[thread]); }
      };


      class Statement: public ASql::Statement
      {
      public:

         Statement(Connection& connection_, const char* const queryString, const size_t queryLength, const Data::Set* const parameterSet, const Data::Set* const resultSet):
            ASql::Statement(connection_.threads()),
            connection(connection_),
            stmt(new MYSQL_STMT*[connection_.threads()]),
            m_initialized(false),
            paramsBindings(new boost::scoped_array<MYSQL_BIND>[connection_.threads()]),
            resultsBindings(new boost::scoped_array<MYSQL_BIND>[connection_.threads()]),
            m_stop(new const bool*[connection_.threads()])
         {
            init(queryString, queryLength, parameterSet, resultSet);
         }


         Statement(Connection& connection_):
            ASql::Statement(connection_.threads()),
            connection(connection_),
            stmt(new MYSQL_STMT*[connection_.threads()]),
            m_initialized(false),
            paramsBindings(new boost::scoped_array<MYSQL_BIND>[connection_.threads()]),
            resultsBindings(new boost::scoped_array<MYSQL_BIND>[connection_.threads()]),
            m_stop(new const bool*[connection_.threads()]) {}

         ~Statement();
         

         void init(const char* const& queryString, const size_t& queryLength, const Data::Set* const parameterSet, const Data::Set* const resultSet, bool customPlaceholders=false);


         void execute(const Data::Set* const parameters, Data::SetContainer* const results, unsigned long long int* const insertId=0, unsigned long long int* const rows=0, bool docommit=true, const unsigned int thread=0);


         bool execute(const Data::Set* const parameters, Data::Set& results, bool docommit=true, const unsigned int thread=0);


         void execute(const Data::SetContainer& parameters, unsigned long long int* rows=0, bool docommit=true, const unsigned int thread=0);


         inline void queue(QueryPar& query, int instance=-1)
         {
            connection.queue(this, query, instance);
         }
      private:
         Connection& connection;

         boost::scoped_array<MYSQL_STMT*> stmt;

         std::deque<unsigned char> paramOrder;

         boost::scoped_array<boost::scoped_array<MYSQL_BIND> > paramsBindings;

         boost::scoped_array<boost::scoped_array<MYSQL_BIND> > resultsBindings;
         

         static void buildBindings(MYSQL_STMT* const& stmt, const Data::Set& set, Data::Conversions& conversions, boost::scoped_array<MYSQL_BIND>& bindings, const std::deque<unsigned char>* order=0);


         static void bindBindings(Data::Set& set, Data::Conversions& conversions, boost::scoped_array<MYSQL_BIND>& bindings, const std::deque<unsigned char>* order=0);


         void executeParameters(const Data::Set* const& parameters, const unsigned int thread);
         

         bool executeResult(Data::Set& row, const unsigned int thread);

         bool m_initialized;

         boost::scoped_array<const bool*> m_stop;

         friend class ConnectionPar<Statement>;
         friend class Transaction<Statement>;
      };

      typedef ASql::Transaction<Statement> Transaction;


      template<class T> struct TypedConversion: public Data::Conversion
      {
         enum_field_types bufferType;

         unsigned long length;

         virtual void convertResult() { grabIt(*(T*)external); }

         virtual void convertParam();


         void* getPointer() { return 0; }

         TypedConversion(const int& column_, MYSQL_STMT* const& statement_, const enum_field_types& bufferType_, void*& buffer_): bufferType(bufferType_), length(0), buffer(buffer_), column(column_), statement(statement_) {}
      protected:
         void*& buffer;

         int column;

         MYSQL_STMT* const& statement;


         void grabIt(T& data);
      };
      
      template<> struct TypedConversion<Data::Datetime>: public Data::Conversion
      {
         MYSQL_TIME internal;

         virtual void convertResult();

         virtual void convertParam();


         void* getPointer() { return &internal; }
      };

      template<> struct TypedConversion<Data::Date>: public TypedConversion<Data::Datetime>
      {
         void convertResult();

         void convertParam();
      };

      template<> struct TypedConversion<Data::Time>: public TypedConversion<Data::Datetime>
      {
         void convertResult();

         void convertParam();
      };
      
      template<> struct TypedConversion<Data::Wtext>: public TypedConversion<Data::Blob>
      {
         TypedConversion(int column_, MYSQL_STMT* const& statement_, void*& buffer_): TypedConversion<Data::Blob>(column_, statement_, MYSQL_TYPE_STRING, buffer_) {}

         void convertResult();

         void convertParam();
      private:
         std::vector<char> inputBuffer;
      };

      struct Error: public ASql::Error
      {
         Error(MYSQL* mysql);
         Error(MYSQL_STMT* stmt);
      };

      extern const char CodeConversionErrorMsg[];
   }
}

#endif