sqlite_back.h

Go to the documentation of this file.

#ifndef CYCLUS_SRC_SQLITE_BACK_H_
#define CYCLUS_SRC_SQLITE_BACK_H_
 
#include <string>
#include <map>
#include <set>
 
#include "query_backend.h"
#include "sqlite_db.h"
 
namespace cyclus {
 
/// An Recorder backend that writes data to an sqlite database.  Identically
/// named Datum objects have their data placed as rows in a single table.  Handles the
/// following datum value types: int, float, double, std::string, cyclus::Blob.
/// Unsupported value types are stored as an empty string.
class SqliteBack: public FullBackend {
 public:
  /// Creates a new sqlite backend that will write to the database file
  /// specified by path. If the file doesn't exist, a new one is created.
  /// @param path the filepath (including name) to write the sqlite file.
  SqliteBack(std::string path);
 
  virtual ~SqliteBack();
 
  /// Writes Datum objects immediately to the database as a single transaction.
  /// @param data group of Datum objects to write to the database together.
  virtual void Notify(DatumList data);
 
  /// Returns a unique name for this backend.
  std::string Name();
 
  /// Executes all pending commands.
  void Flush();
 
  /// Closes the backend, if approriate.
  void Close() {};
 
  virtual QueryResult Query(std::string table, std::vector<Cond>* conds);
 
  virtual std::map<std::string, DbTypes> ColumnTypes(std::string table);
 
  virtual std::set<std::string> Tables();
 
  /// Returns the underlying sqlite database. Only use this if you really know
  /// what you are doing.
  SqliteDb& db();
 
 private:
  void Bind(boost::spirit::hold_any v, DbTypes type, SqlStatement::Ptr stmt, int index);
 
  QueryResult GetTableInfo(std::string table);
 
  std::list<ColumnInfo> Schema(std::string table);
 
  /// returns a valid sql data type name for v (e.g.  INTEGER, REAL, TEXT, etc).
  std::string SqlType(boost::spirit::hold_any v);
 
  /// returns a canonical string name for the type in v
  DbTypes Type(boost::spirit::hold_any v);
 
  /// converts the string value in s to a c++ value corresponding the the
  /// supported sqlite datatype type in a hold_any object.
  boost::spirit::hold_any ColAsVal(SqlStatement::Ptr stmt, int col, DbTypes type);
 
  /// Queue up a table-create command for d.
  void CreateTable(Datum* d);
 
  void BuildStmt(Datum* d);
 
  /// constructs an SQL INSERT command for d and queues it for db insertion.
  void WriteDatum(Datum* d);
 
  /// An interface to a sqlite db managed by the SqliteBack class.
  SqliteDb db_;
 
  /// Stores the database's path+name, declared during construction.
  std::string path_;
 
  /// table names already existing (created) in the sqlite db.
  std::set<std::string> tbl_names_;
 
  std::map<std::string, SqlStatement::Ptr> stmts_;
  std::map<std::string, std::vector<DbTypes> > schemas_;
};
 
}  // namespace cyclus
 
#endif  // CYCLUS_SRC_SQLITE_BACK_H_