pkg-query.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/pkgdb/pkg-query.hh
 *
 * @brief Interfaces for constructing complex `Packages' queries.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <cstdint>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <nix/config.hh>
#include <nix/globals.hh>
#include <nlohmann/json.hpp>
 
#include "compat/concepts.hh"
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* Forward Declarations. */
 
namespace sqlite3pp {
class database;
class query;
}  // namespace sqlite3pp
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::pkgdb {
 
/* -------------------------------------------------------------------------- */
 
using row_id = uint64_t; 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( InvalidPkgQueryArg,
                       EC_INVALID_PKG_QUERY_ARG,
                       "invalid package query argument" )
/* -------------------------------------------------------------------------- */
 
 
struct PkgQueryArgs
{
 
  std::optional<std::string> name;    
  std::optional<std::string> pname;   
  std::optional<std::string> version; 
  std::optional<std::string> semver;  
  std::optional<std::string> partialMatch;
 
  std::optional<std::string> partialNameMatch;
 
  std::optional<std::string> pnameOrAttrName;
 
  std::optional<std::vector<std::string>> licenses;
 
  bool allowBroken = false;
 
  bool allowUnfree = true;
 
  bool preferPreReleases = false;
 
  std::optional<std::vector<Subtree>> subtrees;
 
  std::vector<System> systems = { nix::settings.thisSystem.get() };
 
  std::optional<flox::AttrPath> relPath;
 
 
  void
  clear();
 
  void
  check() const;
 
 
}; /* End struct `PkgQueryArgs' */
 
/* -------------------------------------------------------------------------- */
 
void
to_json( nlohmann::json & jto, const PkgQueryArgs & descriptor );
 
 
/* -------------------------------------------------------------------------- */
 
class PkgQuery : public PkgQueryArgs
{
 
private:
 
  std::stringstream selects;
  bool firstSelect = true;
 
  std::stringstream orders;
  bool firstOrder = true;
 
  std::stringstream wheres;
  bool firstWhere = true;
 
  std::unordered_map<std::string, std::string> binds;
 
  std::vector<std::string> exportedColumns = { "id", "semver" };
 
 
  /* Member Functions */
 
  void
  clearBuilt();
 
  void
  addSelection( std::string_view column );
 
  void
  addOrderBy( std::string_view order );
 
  void
  addWhere( std::string_view cond );
 
  [[nodiscard]] std::unordered_set<std::string>
  filterSemvers( const std::unordered_set<std::string> & versions ) const;
 
  void
  initMatch();
 
  void
  initSubtrees();
 
  void
  initSystems();
 
  void
  initOrderBy();
 
  void
  init();
 
 
public:
 
  PkgQuery() { this->init(); }
 
  explicit PkgQuery( const PkgQueryArgs & params ) : PkgQueryArgs( params )
  {
    this->init();
  }
 
  PkgQuery( const PkgQueryArgs &     params,
            std::vector<std::string> exportedColumns )
    : PkgQueryArgs( params ), exportedColumns( std::move( exportedColumns ) )
  {
    this->init();
  }
 
  [[nodiscard]] std::string
  str() const;
 
  [[nodiscard]] std::shared_ptr<sqlite3pp::query>
  bind( sqlite3pp::database & pdb ) const;
 
  [[nodiscard]] std::vector<row_id>
  execute( sqlite3pp::database & pdb ) const;
 
 
}; /* End class `PkgQuery' */
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::pkgdb
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */