read.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/pkgdb/read.hh
 *
 * @brief Interfaces for reading a SQLite3 package set database.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <filesystem>
#include <functional>
#include <queue>
#include <string>
#include <vector>
 
#include <nix/eval-cache.hh>
#include <nix/flake/flake.hh>
#include <nlohmann/json.hpp>
#include <sqlite3pp.hh>
 
#include "flox/core/command.hh"
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
#include "flox/package.hh"
#include "flox/pkgdb/pkg-query.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* This is passed in by `make' and is set by `<pkgdb>/version' */
#ifndef FLOX_PKGDB_VERSION
#  define FLOX_PKGDB_VERSION "NO.VERSION"
#endif
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::pkgdb {
 
/* -------------------------------------------------------------------------- */
 
struct SqlVersions
{
 
  unsigned tables;
 
  unsigned views;
 
  constexpr bool
  operator==( const SqlVersions & other ) const
  {
    return ( this->tables == other.tables ) && ( this->views == other.views );
  }
 
  constexpr bool
  operator!=( const SqlVersions & other ) const
  {
    return ! ( ( *this ) == other );
  }
 
  friend std::ostream &
  operator<<( std::ostream & oss, const SqlVersions & versions );
 
}; /* End struct `SqlVersions' */
 
std::ostream &
operator<<( std::ostream & oss, const SqlVersions & versions );
 
 
constexpr SqlVersions sqlVersions = { .tables = 2, .views = 3 };
 
 
/* -------------------------------------------------------------------------- */
 
using Fingerprint = nix::flake::Fingerprint;
using SQLiteDb    = sqlite3pp::database; 
using sql_rc      = int;                 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( PkgDbException, EC_PKG_DB, "error running pkgdb" )
/* -------------------------------------------------------------------------- */
 
 
std::filesystem::path
getPkgDbCachedir();
 
std::filesystem::path
genPkgDbName( const Fingerprint &           fingerprint,
              const std::filesystem::path & cacheDir = getPkgDbCachedir() );
 
 
/* -------------------------------------------------------------------------- */
 
class PkgDbReadOnly
{
 
  /* Data */
 
public:
 
  Fingerprint           fingerprint; 
  std::filesystem::path dbPath;      
  SQLiteDb              db;          
  struct LockedFlakeRef
  {
    std::string string; 
    nlohmann::json attrs = nlohmann::json::object();
  };
  struct LockedFlakeRef lockedRef; 
  /* Errors */
 
  // public:
 
  struct NoSuchDatabase : PkgDbException
  {
    explicit NoSuchDatabase( const PkgDbReadOnly & pdb )
      : PkgDbException(
        std::string( "No such database '" + pdb.dbPath.string() + "'." ) )
    {}
  }; /* End struct `NoSuchDatabase' */
 
 
  /* Internal Helpers */
 
protected:
 
  void
  loadLockedFlake();
 
 
private:
 
  void
  init();
 
 
  /* Constructors */
 
protected:
 
  PkgDbReadOnly() : fingerprint( nix::htSHA256 ) {}
 
 
public:
 
  explicit PkgDbReadOnly( std::string_view dbPath )
    : fingerprint( nix::htSHA256 ) /* Filled by `loadLockedFlake' later */
    , dbPath( dbPath )
  {
    this->init();
  }
 
  PkgDbReadOnly( const Fingerprint & fingerprint, std::string_view dbPath )
    : fingerprint( fingerprint ), dbPath( dbPath )
  {
    this->init();
  }
 
  explicit PkgDbReadOnly( const Fingerprint & fingerprint )
    : PkgDbReadOnly( fingerprint, genPkgDbName( fingerprint ).string() )
  {}
 
 
  /* Queries */
 
  // public:
 
  SqlVersions
  getDbVersion();
 
  row_id
  getAttrSetId( const flox::AttrPath & path );
 
  bool
  hasAttrSet( const flox::AttrPath & path );
 
  bool
  completedAttrSet( row_id row );
 
  bool
  completedAttrSet( const flox::AttrPath & path );
 
  flox::AttrPath
  getAttrSetPath( row_id row );
 
  row_id
  getPackageId( const flox::AttrPath & path );
 
  flox::AttrPath
  getPackagePath( row_id row );
 
  bool
  hasPackage( const flox::AttrPath & path );
 
 
  std::string
  getDescription( row_id descriptionId );
 
 
  std::vector<row_id>
  getPackages( const PkgQueryArgs & params );
 
 
  nlohmann::json
  getPackage( row_id row );
 
 
  nlohmann::json
  getPackage( const flox::AttrPath & path );
 
 
  nix::FlakeRef
  getLockedFlakeRef() const
  {
    return nix::FlakeRef::fromAttrs(
      nix::fetchers::jsonToAttrs( this->lockedRef.attrs ) );
  }
 
 
}; /* End class `PkgDbReadOnly' */
 
 
/* -------------------------------------------------------------------------- */
 
template<typename T>
concept pkgdb_typename = std::is_base_of<PkgDbReadOnly, T>::value;
 
 
/* -------------------------------------------------------------------------- */
 
bool
isSQLError( int rcode );
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::pkgdb
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */