sqlitepp.h

Go to the documentation of this file.

// Copyright (C) 2014--2015 Robin Krahl <robin.krahl@ireas.org>
// MIT license -- http://opensource.org/licenses/MIT

#ifndef SQLITEPP_SQLITEPP_H_
#define SQLITEPP_SQLITEPP_H_

#include <sqlite3.h>
#include <stdexcept>
#include <memory>
#include <string>



namespace sqlitepp {

class Uncopyable {
 protected:
  Uncopyable() {}
  ~Uncopyable() {}

 private:
  Uncopyable(const Uncopyable&);
  Uncopyable& operator=(const Uncopyable&);
};

class Openable {
 public:
  bool isOpen() const;

 protected:
  Openable(const bool open, const std::string& name);

  void requireOpen() const;

  void setOpen(const bool open);

 private:
  bool m_open;
  const std::string& m_name;
};

class DatabaseError : public std::runtime_error {
 public:
  explicit DatabaseError(const int errorCode);

  DatabaseError(const int errorCode, const std::string& errorMessage);

  int errorCode() const;

 private:
  const int m_errorCode;

  static std::string getErrorMessage(const int errorCode,
                                     const std::string& errorMessage);
};

class Database;
class ResultSet;

class Statement : private Uncopyable, public Openable {
 public:
  ~Statement();

  void bind(const int index, const double value);

  void bind(const std::string& name, const double value);

  void bind(const int index, const int value);

  void bind(const std::string& name, const int value);

  void bind(const int index, const std::string& value);

  void bind(const std::string& name, const std::string& value);

  void close();

  ResultSet execute();

  bool reset();

 private:
  explicit Statement(sqlite3_stmt* handle);

  int getParameterIndex(const std::string& name) const;
  void handleBindResult(const int index, const int result) const;
  void requireCanRead() const;
  void setInstancePointer(const std::weak_ptr<Statement>& instancePointer);
  bool step();

  sqlite3_stmt* m_handle;
  bool m_canRead;
  std::weak_ptr<Statement> m_instancePointer;

  friend class Database;
  friend class ResultSet;
};

class Database : private Uncopyable, public Openable {
 public:
  Database();

  explicit Database(const std::string& file);

  ~Database();

  void close();

  void execute(const std::string& sql);

  int lastInsertRowId() const;

  void open(const std::string& file);

  std::shared_ptr<Statement> prepare(const std::string& sql);

 private:
  sqlite3* m_handle;
};

class ResultSet {
 public:
  bool canRead() const;

  int columnCount() const;

  bool next();

  double readDouble(const int column) const;

  int readInt(const int column) const;

  std::string readString(const int column) const;

 private:
  explicit ResultSet(const std::shared_ptr<Statement> statement);

  const std::shared_ptr<Statement> m_statement;

  friend class Statement;
};

}  // namespace sqlitepp

#endif  // SQLITEPP_SQLITEPP_H_