Statement.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_Statement_hpp
#define anna_dbms_Statement_hpp

#include <vector>

#include <anna/core/RuntimeException.hpp>
#include <anna/core/mt/Mutex.hpp>
#include <anna/core/util/Average.hpp>
#include <anna/core/util/Microsecond.hpp>

#include <anna/dbms/DatabaseException.hpp>
#include <anna/dbms/ResultCode.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace dbms {

class Database;
class Connection;
class InputBind;
class OutputBind;
class Data;

class Statement : public Mutex {
public:
  typedef std::vector <InputBind*>::iterator input_iterator;
  typedef std::vector <OutputBind*>::iterator output_iterator;

  virtual ~Statement();

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

  const std::string& getExpression() const { return a_expression; }

  bool isCritical() const { return a_isCritical; }

  Database& getDatabase() const { return a_database; }

  void bindInput(const char* name, Data& data) ;

  const dbms::OutputBind* bindOutput(const char* name, Data& data) ;

  void setRequiresCommit(const bool requiresCommit) { a_requiresCommit = requiresCommit; }

  bool requiresCommit() const { return (a_requiresCommit == true) || (a_outputBinds.empty() == true); }

  input_iterator input_begin() { return a_inputBinds.begin(); }

  input_iterator input_end() { return a_inputBinds.end(); }

  int input_size() const { return a_inputBinds.size(); }

  output_iterator output_begin() { return a_outputBinds.begin(); }

  output_iterator output_end() { return a_outputBinds.end(); }

  int output_size() const { return a_outputBinds.size(); }

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

  virtual std::string asString() const ;

  virtual bool fetch() noexcept(false) = 0;

  static Data& input(input_iterator& ii) ;

  static Data& output(output_iterator& ii) ;

protected:
  Statement(Database& database, const char* name, const char* expression, const bool isCritical) :
    a_database(database),
    a_name(name),
    a_expression(expression),
    a_prepared(false),
    a_isCritical(isCritical),
    a_measureTiming("Timing", "us"),
    a_requiresCommit(false) {
  }

  Statement(Database& database, const char* name, const std::string& expression, const bool isCritical) :
    a_database(database),
    a_name(name),
    a_expression(expression),
    a_prepared(false),
    a_isCritical(isCritical),
    a_measureTiming("Timing", "us"),
    a_requiresCommit(false) {
  }

  static InputBind* inputBind(input_iterator& ii) { return *ii; }

  static OutputBind* outputBind(output_iterator& ii) { return *ii; }

private:
  Database& a_database;
  const std::string a_name;
  std::string a_expression;
  std::vector <InputBind*> a_inputBinds;  
  std::vector <OutputBind*> a_outputBinds; 
  bool a_prepared;
  const bool a_isCritical;
  Average <Microsecond> a_measureTiming;
  bool a_requiresCommit;

  Statement(const Statement&);
  void measureTiming(const Microsecond & init, const Microsecond & end) { a_measureTiming += (end - init); }

  virtual void prepare(Connection* connection) noexcept(false) = 0;
  virtual ResultCode execute(Connection* connection) noexcept(false) = 0;

  friend class Connection;
  friend class Database;
};

}
}

#endif