Database.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_dbms_Database_hpp
#define anna_dbms_Database_hpp

#include <vector>

#include <anna/app/Component.hpp>

#include <anna/dbms/Connection.hpp>

namespace anna {

namespace comm {
class INetAddress;
class Delivery;
}

namespace dbms {

class Statement;
class InputBind;
class OutputBind;
class Data;
class FailRecoveryHandler;
class StatementTranslator;

class Database : public app::Component {
public:
  static const int MaxConnection = 32;

  struct Type {
    enum _v { Local, Remote } value;
    Type() : value(Local) {;}
    Type(const _v v) : value(v) {;}
    Type(const Type& v) : value(v.value) {;}
    operator int () const { return value; }
  };

  typedef std::vector <Connection*>::const_iterator const_connection_iterator; 
  typedef std::vector <Statement*>::const_iterator const_statement_iterator; 
  virtual ~Database();

  const Type& getType() const { return a_type; }

  const std::string& getName() const { return a_name; }

  void setFailRecoveryHandler(FailRecoveryHandler* failRecoveryHandler) { a_failRecoveryHandler = failRecoveryHandler; }

  void setStatementTranslator(StatementTranslator* statementTranslator) { a_statementTranslator = statementTranslator; }

  Connection* createConnection(const char* name, const char* user, const char* password)
  noexcept(false);

  Connection& findConnection(const char* name) noexcept(false);

  const_connection_iterator connection_begin() const { return a_connections.begin(); }

  const_connection_iterator connection_end() const { return a_connections.end(); }

  Statement* createStatement(const char* name, const char* expression, const bool isCritical = true)
  noexcept(false);

  Statement* createStatement(const char* name, const std::string& expression, const bool isCritical = true)
  noexcept(false) {
    return createStatement(name, expression.c_str(), isCritical);
  }

  Statement* findStatement(const char* name) ;

  void releaseStatement(Statement* statement) ;

  const_statement_iterator statement_begin() const { return a_statements.begin(); }

  const_statement_iterator statement_end() const { return a_statements.end(); }

  static Statement* statement(const_statement_iterator& ii) { return *ii; }

  virtual std::string asString() const ;

  virtual xml::Node* asXML(xml::Node* parent) const ;

  static const Connection* connection(const_connection_iterator& ii) { return *ii; }

protected:
  typedef std::vector <Connection*>::iterator connection_iterator; 
  Database(const char* rdbmsmsName, const char* dbmsName);

  void recover(Connection& connection, const int tryCounter) noexcept(false);

  virtual void do_initialize() noexcept(false);

  virtual void do_stop() ;

  connection_iterator connection_begin() { return a_connections.begin(); }

  connection_iterator connection_end() { return a_connections.end(); }

  static Connection* connection(connection_iterator& ii) { return *ii; }

private:
  const std::string a_name;
  std::vector <Connection*> a_connections;
  std::vector <Statement*> a_statements;
  const Type a_type;
  FailRecoveryHandler* a_failRecoveryHandler;
  StatementTranslator* a_statementTranslator;

  Database(const Database&);

  void do_cloneChild() noexcept(false);

  virtual Connection* allocateConnection(const std::string& name, const char* user, const char* password)
  noexcept(false) = 0;

  virtual Statement* allocateStatement(const char* name, const std::string& expression, const bool isCritical)
  noexcept(false) = 0;

  virtual InputBind* allocateInputBind(const char* name, Data& data)
  noexcept(false) = 0;
  virtual void deallocate(InputBind* inputBind)  = 0;

  virtual OutputBind* allocateOutputBind(const char* name, Data& data)
  noexcept(false) = 0;
  virtual void deallocate(OutputBind* outputBind)  = 0;

  friend class Statement;
  friend ResultCode Connection::execute(Statement*) noexcept(false);
};

}
}

#endif