Database_Writable.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: 10.0.0
// joedbc compilation time: May 27 2025 17:38:37
// Generation of this file: 2025-05-27 15:38:58 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef tutorial_Database_Writable_declared
#define tutorial_Database_Writable_declared
 
#include "joedb/journal/Writable_Journal.h"
#include "joedb/journal/Memory_File.h"
#include "joedb/error/Out_Of_Date.h"
#include "Database.h"
 
#include <string>
#include <stdint.h>
#include <cstring>
#include <vector>
 
namespace tutorial
{
 namespace detail
 {
  extern const char * schema_string;
  inline constexpr size_t schema_string_size = 99;
 }
 
 class container_of_city;
 class container_of_person;
 
 /// implement @ref joedb::Writable in a @ref Database
 class Database_Writable: public Database, public joedb::Writable
 {
  protected:
   joedb::index_t max_record_id;
   Table_Id current_table_id = Table_Id{0};
 
   void delete_from(Table_Id table_id, Record_Id record_id) override
   {
    if (table_id == Table_Id(1))
     internal_delete_city(record_id);
    else if (table_id == Table_Id(2))
     internal_delete_person(record_id);
   }
 
   void insert_into(Table_Id table_id, Record_Id record_id) override
   {
    if (to_underlying(record_id) < 0 || (max_record_id && to_underlying(record_id) >= max_record_id))
     throw_exception("insert_into: too big");
    if (table_id == Table_Id(1))
    {
     if (is_valid_record_id_for_city(record_id))
      throw_exception("Duplicate insert into table city");
     if (storage_of_city.size() <= size_t(record_id))
      storage_of_city.resize(to_underlying(record_id) + 1);
     internal_insert_city(record_id);
    }
    else if (table_id == Table_Id(2))
    {
     if (is_valid_record_id_for_person(record_id))
      throw_exception("Duplicate insert into table person");
     if (storage_of_person.size() <= size_t(record_id))
      storage_of_person.resize(to_underlying(record_id) + 1);
     internal_insert_person(record_id);
    }
   }
 
   void delete_vector
   (
    Table_Id table_id,
    Record_Id record_id,
    size_t size
   ) override
   {
    joedb::Freedom_Keeper *fk = nullptr;
 
    if (table_id == Table_Id(1))
     fk = &storage_of_city.freedom_keeper;
    else if (table_id == Table_Id(2))
     fk = &storage_of_person.freedom_keeper;
 
    if (fk)
    {
     JOEDB_RELEASE_ASSERT(fk->is_used_vector(record_id, size));
     joedb::Writable::delete_vector(table_id, record_id, size);
    }
   }
 
   void insert_vector
   (
    Table_Id table_id,
    Record_Id record_id,
    size_t size
   ) override
   {
    if
    (
     to_underlying(record_id) < 0 ||
     (max_record_id && (to_underlying(record_id) >= max_record_id || joedb::index_t(size) >= max_record_id))
    )
    {
     throw_exception("insert_vector: null record_id, or too big");
    }
    if (table_id == Table_Id(1))
    {
     if (storage_of_city.size() < size_t(record_id) + size)
      storage_of_city.resize(to_underlying(record_id) + size);
     internal_vector_insert_city(record_id, size);
    }
    else if (table_id == Table_Id(2))
    {
     if (storage_of_person.size() < size_t(record_id) + size)
      storage_of_person.resize(to_underlying(record_id) + size);
     internal_vector_insert_person(record_id, size);
    }
   }
 
   void update_string
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    const std::string& value
   )
   override
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_city__name(record_id, value);
      return;
     }
     return;
    }
    if (table_id == Table_Id(2))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_person__first_name(record_id, value);
      return;
     }
     if (field_id == Field_Id(2))
     {
      internal_update_person__last_name(record_id, value);
      return;
     }
     return;
    }
   }
 
   void update_reference
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    joedb::Record_Id value
   )
   override
   {
    if (table_id == Table_Id(2))
    {
     if (field_id == Field_Id(3))
     {
      internal_update_person__home(record_id, id_of_city(value));
      return;
     }
     return;
    }
   }
 
   void update_vector_string
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t size,
    const std::string *value
   )
   override
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_vector_city__name(record_id, size, value);
      return;
     }
     return;
    }
    if (table_id == Table_Id(2))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_vector_person__first_name(record_id, size, value);
      return;
     }
     if (field_id == Field_Id(2))
     {
      internal_update_vector_person__last_name(record_id, size, value);
      return;
     }
     return;
    }
   }
 
   void update_vector_reference
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t size,
    const joedb::Record_Id *value
   )
   override
   {
    if (table_id == Table_Id(2))
    {
     if (field_id == Field_Id(3))
     {
      internal_update_vector_person__home(record_id, size, reinterpret_cast<const id_of_city*>(value));
      return;
     }
     return;
    }
   }
 
   std::string *get_own_string_storage
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t &capacity
   )
   override
   {
    if (table_id == Table_Id(1))
    {
     capacity = size_t(storage_of_city.freedom_keeper.size());
     if (field_id == Field_Id(1))
     {
      return (storage_of_city.field_value_of_name.data() + to_underlying(record_id));
     }
     return nullptr;
    }
    if (table_id == Table_Id(2))
    {
     capacity = size_t(storage_of_person.freedom_keeper.size());
     if (field_id == Field_Id(1))
     {
      return (storage_of_person.field_value_of_first_name.data() + to_underlying(record_id));
     }
     if (field_id == Field_Id(2))
     {
      return (storage_of_person.field_value_of_last_name.data() + to_underlying(record_id));
     }
     return nullptr;
    }
    return nullptr;
   }
 
   joedb::Record_Id *get_own_reference_storage
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t &capacity
   )
   override
   {
    if (table_id == Table_Id(2))
    {
     capacity = size_t(storage_of_person.freedom_keeper.size());
     if (field_id == Field_Id(3))
     {
      return reinterpret_cast<Record_Id *>(storage_of_person.field_value_of_home.data() + to_underlying(record_id));
     }
     return nullptr;
    }
    return nullptr;
   }
 
   void comment(const std::string &comment) override {}
   void timestamp(int64_t timestamp) override {}
   void valid_data() override {}
 
   bool upgrading_schema = false;
   joedb::Memory_File schema_file;
   joedb::Writable_Journal schema_journal;
 
   bool requires_schema_upgrade() const
   {
    return schema_file.get_data().size() < detail::schema_string_size;
   }
 
   void check_schema()
   {
    constexpr size_t pos = joedb::Header::size;
    const size_t schema_file_size = schema_file.get_data().size();
 
    if
    (
     schema_file_size < pos ||
     schema_file_size > detail::schema_string_size ||
     std::memcmp
     (
      schema_file.get_data().data() + pos,
      detail::schema_string + pos,
      schema_file_size - pos
     ) != 0
    )
    {
     throw_exception("Trying to open a file with incompatible schema");
    }
   }
 
   void create_table(const std::string &name) override
   {
    ++current_table_id;
    schema_journal.create_table(name);
    schema_journal.soft_checkpoint();
   }
 
   void drop_table(Table_Id table_id) override
   {
    schema_journal.drop_table(table_id);
    schema_journal.soft_checkpoint();
   }
 
   void rename_table
   (
    Table_Id table_id,
    const std::string &name
   ) override
   {
    schema_journal.rename_table(table_id, name);
    schema_journal.soft_checkpoint();
   }
 
   void add_field
   (
    Table_Id table_id,
    const std::string &name,
    joedb::Type type
   ) override
   {
    schema_journal.add_field(table_id, name, type);
    schema_journal.soft_checkpoint();
   }
 
   void drop_field(Table_Id table_id, Field_Id field_id) override
   {
    schema_journal.drop_field(table_id, field_id);
    schema_journal.soft_checkpoint();
   }
 
   void rename_field
   (
    Table_Id table_id,
    Field_Id field_id,
    const std::string &name
   ) override
   {
    schema_journal.rename_field(table_id, field_id, name);
    schema_journal.soft_checkpoint();
   }
 
   void custom(const std::string &name) override
   {
    schema_journal.custom(name);
    schema_journal.soft_checkpoint();
   }
 
  public:
   Database_Writable():
    max_record_id(0),
    schema_journal(schema_file)
   {}
 
   void set_max_record_id(joedb::index_t record_id)
   {
    max_record_id = record_id;
   }
 
   int64_t get_schema_checkpoint() const
   {
    return schema_journal.get_checkpoint();
   }
 
   void initialize_with_readonly_journal(joedb::Readonly_Journal &journal)
   {
    max_record_id = size_t(journal.get_checkpoint());
    journal.replay_log(*this);
    max_record_id = 0;
 
    check_schema();
 
    if (requires_schema_upgrade())
     throw_exception<joedb::Out_Of_Date>("Schema is out of date. Can't upgrade a read-only database.");
   }
  };
}
 
#endif