sql.h

Go to the documentation of this file.

#ifndef CVMFS_SQL_H_
#define CVMFS_SQL_H_

#include <cassert>
#include <string>

#include "duplex_sqlite3.h"
#include "util/file_guard.h"
#include "util/pointer.h"

namespace sqlite {

struct MemStatistics {
  MemStatistics()
    : lookaside_slots_used(-1)
    , lookaside_slots_max(-1)
    , lookaside_hit(-1)
    , lookaside_miss_size(-1)
    , lookaside_miss_full(-1)
    , page_cache_used(-1)
    , page_cache_hit(-1)
    , page_cache_miss(-1)
    , schema_used(-1)
    , stmt_used(-1)
  { }
  int lookaside_slots_used;
  int lookaside_slots_max;
  int lookaside_hit;
  int lookaside_miss_size;
  int lookaside_miss_full;
  int page_cache_used;   
  int page_cache_hit;
  int page_cache_miss;
  int schema_used;  
  int stmt_used;  
};

class Sql;

template <class DerivedT>
class Database : SingleCopy {
 public:
  enum OpenMode {
    kOpenReadOnly,
    kOpenReadWrite,
  };

  static const float kSchemaEpsilon;  // floats get imprecise in SQlite

  static DerivedT* Create(const std::string  &filename);

  static DerivedT* Open(const std::string  &filename,
                        const OpenMode      open_mode);

  bool IsEqualSchema(const float value, const float compare) const {
    return (value > compare - kSchemaEpsilon &&
            value < compare + kSchemaEpsilon);
  }

  bool BeginTransaction() const;
  bool CommitTransaction() const;

  template <typename T>
  T GetProperty(const std::string &key) const;
  template <typename T>
  T GetPropertyDefault(const std::string &key, const T default_value) const;
  template <typename T>
  bool SetProperty(const std::string &key, const T value);
  bool HasProperty(const std::string &key) const;

  sqlite3*            sqlite_db()       const { return database_.database();  }
  const std::string&  filename()        const { return database_.filename();  }
  float               schema_version()  const { return schema_version_;       }
  unsigned            schema_revision() const { return schema_revision_;      }
  bool                read_write()      const { return read_write_;           }

  unsigned GetModifiedRowCount() const;

  double GetFreePageRatio() const;

  void GetMemStatistics(MemStatistics *stats) const;

  bool Vacuum() const;

  void PrintSqlError(const std::string &error_msg);

  std::string GetLastErrorMsg() const;


  void TakeFileOwnership();

  void DropFileOwnership();

  bool OwnsFile() const { return database_.OwnsFile(); }

  void EnforceSchema(float version, unsigned revision) {
    schema_version_ = version;
    schema_revision_ = revision;
  }

 protected:
  Database(const std::string  &filename,
           const OpenMode      open_mode);

  bool Initialize();

  bool CreatePropertiesTable();
  bool PrepareCommonQueries();

  bool OpenDatabase(const int sqlite_open_flags);
  bool Configure();
  bool FileReadAhead();

  void ReadSchemaRevision();
  bool StoreSchemaRevision();

  void set_schema_version(const float ver)     { schema_version_  = ver; }
  void set_schema_revision(const unsigned rev) { schema_revision_ = rev; }

 private:
  struct DatabaseRaiiWrapper {
    DatabaseRaiiWrapper(const std::string   &filename,
                        Database<DerivedT>  *delegate)
      : sqlite_db(NULL)
      , lookaside_buffer(NULL)
      , db_file_guard(filename, UnlinkGuard::kDisabled)
      , delegate_(delegate) {}
    ~DatabaseRaiiWrapper();

    sqlite3*           database() const { return sqlite_db;            }
    const std::string& filename() const { return db_file_guard.path(); }

    bool Close();

    void TakeFileOwnership() { db_file_guard.Enable();           }
    void DropFileOwnership() { db_file_guard.Disable();          }
    bool OwnsFile() const    { return db_file_guard.IsEnabled(); }

    sqlite3             *sqlite_db;
    void                *lookaside_buffer;
    UnlinkGuard          db_file_guard;
    Database<DerivedT>  *delegate_;
  };

  static const char *kSchemaVersionKey;
  static const char *kSchemaRevisionKey;

  DatabaseRaiiWrapper database_;

  const bool          read_write_;
  float               schema_version_;
  unsigned            schema_revision_;

  UniquePtr<Sql>      begin_transaction_;
  UniquePtr<Sql>      commit_transaction_;

  UniquePtr<Sql>      has_property_;
  UniquePtr<Sql>      set_property_;
  UniquePtr<Sql>      get_property_;
};


//
// # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//


class Sql {
 public:
  Sql(sqlite3 *sqlite_db, const std::string &statement);
  virtual ~Sql();

  bool Execute();
  bool FetchRow();
  std::string DebugResultTable();
  bool Reset();
  inline int GetLastError() const { return last_error_code_; }

  std::string GetLastErrorMsg() const;

  bool BindBlob(const int index, const void* value, const unsigned size) {
    LazyInit();
    last_error_code_ =
      sqlite3_bind_blob(statement_, index, value, static_cast<int>(size),
                        SQLITE_STATIC);
    return Successful();
  }
  bool BindBlobTransient(const int index, const void* value,
                         const unsigned size)
  {
    LazyInit();
    last_error_code_ =
      sqlite3_bind_blob(statement_, index, value, static_cast<int>(size),
                        SQLITE_TRANSIENT);  // NOLINT
    return Successful();
  }
  bool BindDouble(const int index, const double value) {
    LazyInit();
    last_error_code_ = sqlite3_bind_double(statement_, index, value);
    return Successful();
  }
  bool BindInt(const int index, const int value) {
    LazyInit();
    last_error_code_ = sqlite3_bind_int(statement_, index, value);
    return Successful();
  }
  bool BindInt64(const int index, const sqlite3_int64 value) {
    LazyInit();
    last_error_code_ = sqlite3_bind_int64(statement_, index, value);
    return Successful();
  }
  bool BindNull(const int index) {
    LazyInit();
    last_error_code_ = sqlite3_bind_null(statement_, index);
    return Successful();
  }
  bool BindTextTransient(const int index, const std::string &value) {
    return BindTextTransient(
      index, value.data(), static_cast<int>(value.length()));
  }
  bool BindTextTransient(const int index, const char *value, const int size) {
    // NOLINTNEXTLINE(performance-no-int-to-ptr)
    return BindText(index, value, size, SQLITE_TRANSIENT);
  }
  bool BindText(const int index, const std::string &value) {
    return BindText(index, value.data(), static_cast<int>(value.length()),
                    SQLITE_STATIC);
  }
  bool BindText(const int   index,
                const char* value,
                const int   size,
                void(*dtor)(void*) = SQLITE_STATIC) {
    LazyInit();
    last_error_code_ = sqlite3_bind_text(statement_, index, value, size, dtor);
    return Successful();
  }

  template <typename T>
  inline bool Bind(const int index, const T &value);


  int RetrieveType(const int idx_column) const {
    return sqlite3_column_type(statement_, idx_column);
  }

  int RetrieveBytes(const int idx_column) const {
    return sqlite3_column_bytes(statement_, idx_column);
  }
  const void *RetrieveBlob(const int idx_column) const {
    return sqlite3_column_blob(statement_, idx_column);
  }
  double RetrieveDouble(const int idx_column) const {
    return sqlite3_column_double(statement_, idx_column);
  }
  int RetrieveNullableInt(const int idx_column, const int val_null) const {
    if (sqlite3_column_type(statement_, idx_column) == SQLITE_NULL)
      return val_null;
    return sqlite3_column_int(statement_, idx_column);
  }
  int RetrieveInt(const int idx_column) const {
    return sqlite3_column_int(statement_, idx_column);
  }
  sqlite3_int64 RetrieveInt64(const int idx_column) const {
    return sqlite3_column_int64(statement_, idx_column);
  }
  const unsigned char *RetrieveText(const int idx_column) const {
    return sqlite3_column_text(statement_, idx_column);
  }
  std::string RetrieveString(const int idx_column) const {
    return reinterpret_cast<const char*>(RetrieveText(idx_column));
  }
  template <typename T>
  inline T Retrieve(const int index);

 protected:
  Sql()
    : database_(NULL)
    , statement_(NULL)
    , query_string_(NULL)
    , last_error_code_(0) { }

  bool IsInitialized() const { return statement_ != NULL; }

  bool Init(const sqlite3 *database, const std::string &statement);

  void DeferredInit(const sqlite3 *database, const char *statement);

  inline bool Successful() const {
    return SQLITE_OK   == last_error_code_ ||
           SQLITE_ROW  == last_error_code_ ||
           SQLITE_DONE == last_error_code_;
  }

 private:
  bool Init(const char *statement);
  void LazyInit() {
    if (!IsInitialized()) {
      assert(NULL != database_);
      assert(NULL != query_string_);
      const bool success = Init(query_string_);
      assert(success);
    }
  }

  sqlite3       *database_;
  sqlite3_stmt  *statement_;
  const char    *query_string_;
  int            last_error_code_;
};

}  // namespace sqlite

#include "sql_impl.h"

#endif  // CVMFS_SQL_H_