Writable_Database.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
//
// This code was automatically generated by the joedb compiler
// https://www.joedb.org/
//
// Path to compiler: /home/rcoulom/repos/joedb/compcmake/gcc_debug/joedbc
// Version: 9.5.0
// joedbc compilation time: May  5 2025 19:51:43
// Generation of this file: 2025-05-05 17:51:47 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef joedb_db_encoded_file_Writable_Database_declared
#define joedb_db_encoded_file_Writable_Database_declared
 
#include "Database.h"
#include "joedb/Span.h"
 
namespace joedb::db::encoded_file
{
 namespace detail
 {
  class Client_Data;
 }
 
 class Client;
 class Multiplexer;
 
 /// A writable @ref Database constructed from a writable @ref joedb::Buffered_File
 class Writable_Database: public Database
 {
  friend class detail::Client_Data;
  friend class Client;
  friend class Multiplexer;
 
  private:
   joedb::Writable_Journal journal;
   bool ready_to_write;
 
   void play_journal();
   void auto_upgrade();
   void check_single_row();
 
   void initialize()
   {
    play_journal();
    check_schema();
    auto_upgrade();
    check_single_row();
   }
 
   Writable_Database
   (
    joedb::Buffered_File &file,
    bool perform_initialization
   );
 
  public:
   Writable_Database(joedb::Buffered_File &file);
 
   const joedb::Readonly_Journal &get_journal() const {return journal;}
 
   std::string read_blob(joedb::Blob blob) const
   {
    return journal.get_file().read_blob(blob);
   }
 
   joedb::Blob write_blob(const std::string &data) final
   {
    return journal.write_blob(data);
   }
 
   int64_t ahead_of_checkpoint() const
   {
    return journal.ahead_of_checkpoint();
   }
 
   void soft_checkpoint()
   {
    journal.soft_checkpoint();
   }
 
   void hard_checkpoint()
   {
    journal.hard_checkpoint();
   }
 
   void write_comment(const std::string &comment);
   void write_timestamp();
   void write_timestamp(int64_t timestamp);
   void write_valid_data();
   void flush() override {journal.flush();}
 
   void clear_buffer_table();
 
   id_of_buffer new_buffer()
   {
    id_of_buffer result(Record_Id(storage_of_buffer.freedom_keeper.get_free_record() - 1));
    storage_of_buffer.resize(storage_of_buffer.freedom_keeper.size());
    internal_insert_buffer(result.get_record_id());
 
    journal.insert_into(Table_Id(1), result.get_record_id());
    return result;
   }
 
   id_of_buffer new_vector_of_buffer(size_t size)
   {
    id_of_buffer result(Record_Id(storage_of_buffer.size() + 1));
    storage_of_buffer.resize(storage_of_buffer.size() + size);
    internal_vector_insert_buffer(result.get_record_id(), size);
    journal.insert_vector(Table_Id(1), result.get_record_id(), size);
    return result;
   }
 
   id_of_buffer new_buffer
   (
    joedb::Blob field_value_of_data,
    int64_t field_value_of_size,
    int64_t field_value_of_offset
   )
   {
    auto result = new_buffer();
    set_data(result, field_value_of_data);
    set_size(result, field_value_of_size);
    set_offset(result, field_value_of_offset);
    return result;
   }
 
   void delete_buffer(id_of_buffer record)
   {
    internal_delete_buffer(record.get_record_id());
    journal.delete_from(Table_Id(1), record.get_record_id());
   }
 
   void delete_vector_of_buffer(id_of_buffer v, size_t size)
   {
    for (size_t i = size; i > 0;)
     internal_delete_buffer(v[--i].get_record_id());
    journal.delete_vector(Table_Id(1), v.get_record_id(), size);
   }
 
   void set_data(id_of_buffer record, joedb::Blob field_value_of_data)
   {
    internal_update_buffer__data(record.get_record_id(), field_value_of_data);
    journal.update_blob(Table_Id(1), record.get_record_id(), Field_Id(1), field_value_of_data);
   }
 
   template<typename F> void update_vector_of_data(id_of_buffer record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<joedb::Blob> span(&storage_of_buffer.field_value_of_data[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_buffer__data(record.get_record_id(), size, span.begin());
    journal.update_vector_blob(Table_Id(1), record.get_record_id(), Field_Id(1), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
   void set_size(id_of_buffer record, int64_t field_value_of_size)
   {
    internal_update_buffer__size(record.get_record_id(), field_value_of_size);
    journal.update_int64(Table_Id(1), record.get_record_id(), Field_Id(2), field_value_of_size);
   }
 
   template<typename F> void update_vector_of_size(id_of_buffer record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<int64_t> span(&storage_of_buffer.field_value_of_size[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_buffer__size(record.get_record_id(), size, span.begin());
    journal.update_vector_int64(Table_Id(1), record.get_record_id(), Field_Id(2), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
   void set_offset(id_of_buffer record, int64_t field_value_of_offset)
   {
    internal_update_buffer__offset(record.get_record_id(), field_value_of_offset);
    journal.update_int64(Table_Id(1), record.get_record_id(), Field_Id(3), field_value_of_offset);
   }
 
   template<typename F> void update_vector_of_offset(id_of_buffer record, size_t size, F f)
   {
    std::exception_ptr exception;
    joedb::Span<int64_t> span(&storage_of_buffer.field_value_of_offset[record.get_id() - 1], size);
    try {f(span);}
    catch (...) {exception = std::current_exception();}
    internal_update_vector_buffer__offset(record.get_record_id(), size, span.begin());
    journal.update_vector_int64(Table_Id(1), record.get_record_id(), Field_Id(3), size, (span.begin()));
    if (exception)
     std::rethrow_exception(exception);
   }
 
 
 };}
 
#endif