sqlite_db.h

Go to the documentation of this file.

#ifndef CYCLUS_SRC_SQLITE_DB_H_
#define CYCLUS_SRC_SQLITE_DB_H_

#include <vector>
#include <string>
#include <boost/shared_ptr.hpp>

#include "error.h"

class sqlite3;
class sqlite3_stmt;

namespace cyclus {

typedef std::vector<std::string> StrList;

class SqliteDb;

/// Thin wrapper class over sqlite3 prepared statements.  See
/// http://sqlite.org/cintro.html for an overview of how prepared statements
/// work.
class SqlStatement {
  friend class SqliteDb;
 public:
  typedef boost::shared_ptr<SqlStatement> Ptr;

  ~SqlStatement();

  /// Executes the prepared statement.
  void Exec();

  /// Executes the prepared statement.
  void Reset();

  /// Step to next row of previously executed query. Returns false when there
  /// are no more rows. Previously retrieved text or blob column data memory
  /// is deallocated.
  bool Step();

  /// Returns an int value for the specified column of the current query row.
  int GetInt(int col);

  /// Returns a double value for the specified column of the current query row.
  double GetDouble(int col);

  /// Returns a byte array value for the specified column of the current query
  /// row. This can be used for retrieving TEXT and BLOB column data.
  char* GetText(int col, int* n);

  /// Binds the templated sql parameter at index i to val.
  void BindInt(int i, int val);

  /// Binds the templated sql parameter at index i to val.
  void BindDouble(int i, double val);

  /// Binds the templated sql parameter at index i to val.
  void BindText(int i, const char* val);

  /// Binds the templated sql parameter at index i to the value pointed to by
  /// val. n is the length in bytes of the value.
  void BindBlob(int i, const void* val, int n);

 private:
  SqlStatement(sqlite3* db, std::string zSql);

  /// throws an exception if status (the return value of an sqlite function)
  /// does not represent success.
  void Must(int status);

  sqlite3* db_;
  std::string zSql_;
  sqlite3_stmt* stmt_;
};

/// An abstraction over the Sqlite native C interface to simplify database
/// creation and data insertion.
class SqliteDb {
 public:
  /// Creates a new Sqlite database to be stored at the specified path.
  ///
  /// @param path the path+name for the sqlite database file
  /// @param readonly a boolean indicating true if db is readonly
  SqliteDb(std::string path, bool readonly = false);

  virtual ~SqliteDb();

  /// Finishes any incomplete operations and closes the database.
  /// @throw IOError if failed to close the database properly
  void close();

  /// Opens the sqlite database by either opening/creating a file (default) or
  /// creating/overwriting a file (see the overwrite method).
  ///
  /// @throw IOError if failed to open existing database
  void open();

  /// Instead of opening a file of the specified name (if it already exists),
  /// overwrite it with a new empty database.
  void Overwrite();

  /// Creates a sqlite prepared statement for the given sql.  See
  /// http://sqlite.org/cintro.html for an overview of how prepared statements
  /// work.
  SqlStatement::Ptr Prepare(std::string sql);

  /// Execute an SQL command.
  ///
  /// @param cmd an Sqlite compatible SQL command
  /// @throw IOError SQL command execution failed (e.g. invalid SQL)
  void Execute(std::string cmd);

  /// Execute an SQL query and return its results
  ///
  /// @param cmd an Sqlite compatible SQL query
  /// @return a list of row entries
  /// @throw IOError SQL command execution failed (e.g. invalid SQL)
  std::vector<StrList> Query(std::string cmd);

 private:
  sqlite3* db_;

  bool isOpen_;

  std::string path_;

  /// indicates if open() will overwrite a file at 'path'.
  bool overwrite_;

  /// indicates true if the db is readonly false otherwise
  bool readonly_;
};

}  // namespace cyclus

#endif  // CYCLUS_SRC_SQLITE_DB_H_