/**

 * This file is part of the CernVM File System.

 */

#ifndef CVMFS_HISTORY_SQL_H_

#define CVMFS_HISTORY_SQL_H_

#include <string>

#include "history.h"

#include "sql.h"

namespace history {

/**

 * This class wraps the database structure of the History SQLite database files.

 * For that it inherits from sqlite::Database<>, please look there for further

 * details.

 */

 public:

  static const float kLatestSchema;

  static const float kLatestSupportedSchema;

  // backwards-compatible schema changes

  static const unsigned kLatestSchemaRevision;

  static const std::string kFqrnKey;

  bool CreateEmptyDatabase();

  bool InsertInitialValues(const std::string &repository_name);

  bool ContainsRecycleBin() const;

  bool CheckSchemaCompatibility();

  bool LiveSchemaUpgradeIfNecessary();

                                                 // database compaction.

 protected:

  // TODO(rmeusel): C++11 - constructor inheritance

  friend class sqlite::Database<HistoryDatabase>;

                  const OpenMode      open_mode) :

 private:

  bool CreateTagsTable();

  bool CreateRecycleBinTable();

  bool CreateBranchesTable();

  bool UpgradeSchemaRevision_10_1();

  bool UpgradeSchemaRevision_10_2();

  bool UpgradeSchemaRevision_10_3();

};

//------------------------------------------------------------------------------

/**

 * A mixin that allows to inject the RetrieveTag() method if it is needed in an

 * SQL query subclass.

 *

 * This allows us to orchestrate specific functionality in those classes as we

 * need it, without relying on multiple inheritance. Otherwise one would inherit

 * from sqlite::Sql more than once when inheriting from more than one of those

 * mixin classes in a query subclass.

 * In contrast, the mixins produce a clear (single) inheritance graph for each

 * of the derived classes by chaining the functionality as seen below.

 *

 * Example:

 * class SqlListRollbackTags : public SqlRetrieveTag<SqlRollback<SqlHistory>> {}

 *

 *    ################     Note: both SqlRetrieveTag and SqlRollback need the

 *    # sqlite::Sql  #           functionality provided in sqlite::Sql, thus

 *    ################           would otherwise be derived from it individually

 *          ��|`

 *           |

 *    ################      ####################      #################

 *    #  SqlHistory  # <--- #  SqlRetrieveTag  # <--- #  SqlRollback  #

 *    ################      ####################      #################

 *                                                           ��|`

 *                                                            |

 *                                                #########################

 *                                                #  SqlListRollbackTags  #

 *                                                #########################

 *

 * Note: MixinT needs to be eventually derived from sqlite::Sql as it uses

 *       Sql::Retrieve...() methods to extract information from SQLite rows.

 *

 * @param MixinT  the class that should gain RetrieveTag()'s functionality

 */

template <class MixinT>

 public:

  /**

   * Retrieves a tag from a database row

   * See SqlHistory::db_fields for a listing of the used SQLite data fields

   *

   * @return  a tag retrieved from the SQLite database row

   */

                           shash::HexPtr(MixinT::RetrieveString(1)),

                           shash::kSuffixCatalog);

                           MixinT::RetrieveInt64(4));

  }

};

 private:

  static const std::string db_placeholders;

 public:

  explicit SqlInsertTag(const HistoryDatabase *database);

  bool BindTag(const History::Tag &tag);

};

 public:

  explicit SqlRemoveTag(const HistoryDatabase *database);

  bool BindName(const std::string &name);

};

 public:

  explicit SqlFindTag(const HistoryDatabase *database);

  bool BindName(const std::string &name);

};

 public:

  explicit SqlFindTagByDate(const HistoryDatabase *database);

  bool BindTimestamp(const time_t timestamp);

};

 public:

  explicit SqlFindBranchHead(const HistoryDatabase *database);

  bool BindBranchName(const std::string &branch_name);

};

 public:

  explicit SqlCountTags(const HistoryDatabase *database);

  unsigned RetrieveCount() const;

};

 public:

  explicit SqlListTags(const HistoryDatabase *database);

};

 public:

  explicit SqlGetChannelTips(const HistoryDatabase *database);

};

 public:

  explicit SqlGetHashes(const HistoryDatabase *database);

  shash::Any RetrieveHash() const;

};

 public:

  explicit SqlListBranches(const HistoryDatabase *database);

  History::Branch RetrieveBranch() const;

};

 public:

  explicit SqlInsertBranch(const HistoryDatabase *database);

  bool BindBranch(const History::Branch &branch);

};

/**

 * Mixin to inject the rollback condition definition and the BindTargetTag()

 * method into other subclasses.

 *

 * Note: See documentation of the SqlRetrieveTag<> for further details.

 *

 * @param MixinT  the class that should gain BindTargetTags()'s functionality

 * @param offset  offset for SQLite placeholders, if used inside other complex

 *                SQL queries with preceeding placeholders

 */

template <class MixinT, int offset = 0>

 protected:

  static const std::string rollback_condition;

 public:

    return MixinT::BindInt64(offset + 1, target_tag.revision) &&

           MixinT::BindText(offset + 2, target_tag.name) &&

  }

};

template <class MixinT, int offset>

const std::string SqlRollback<MixinT, offset>::rollback_condition =

                                             "(revision > :target_rev  OR "

                                             " name     = :target_name)   "

                                             "AND channel  = :target_chan ";

 public:

  explicit SqlRollbackTag(const HistoryDatabase *database);

};

 public:

  explicit SqlListRollbackTags(const HistoryDatabase *database);

};

 protected:

  static const unsigned int kFlagCatalog = 1;

  bool CheckSchema(const HistoryDatabase *database) const;

};

 public:

  explicit SqlRecycleBinList(const HistoryDatabase *database);

  shash::Any RetrieveHash();

};

 public:

  explicit SqlRecycleBinFlush(const HistoryDatabase *database);

};

}  // namespace history

#endif  // CVMFS_HISTORY_SQL_H_