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/doc/source/tutorial/build/joedbc
// Version: 9.1.4
// joedbc compilation time: Apr 15 2025 14:46:29
// Generation of this file: 2025-04-15 12:46:31 GMT
//
/////////////////////////////////////////////////////////////////////////////
#ifndef joedb_db_multi_server_Database_declared
#define joedb_db_multi_server_Database_declared
 
#include "joedb/Freedom_Keeper.h"
#include "joedb/journal/Writable_Journal.h"
#include "joedb/journal/Memory_File.h"
#include "joedb/error/Exception.h"
#include "joedb/error/Out_Of_Date.h"
#include "joedb/error/assert.h"
#include "joedb/get_version.h"
#include "ids.h"
 
#include <string>
#include <cstdint>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string_view>
 
#include <map>
 
#include "joedb/ui/type_io.h"
#include <sstream>
 
static_assert(std::string_view(joedb::get_version()) == "9.1.4");
 
namespace joedb::db::multi_server
{
 /// @namespace joedb::db::multi_server
 ///
 /// Automatically generated by joedbc
 
 using joedb::Record_Id;
 using joedb::Table_Id;
 using joedb::Field_Id;
 
 namespace detail
 {
  extern const char * schema_string;
  inline constexpr size_t schema_string_size = 81;
 }
 class container_of_server;
 
 namespace detail
 {
  struct data_of_server
  {
   std::vector<std::string> field_value_of_file_name;
   std::vector<int32_t> field_value_of_port;
   std::vector<int32_t> field_value_of_timeout;
   std::vector<std::map<int32_t, id_of_server>::iterator> iterator_over_server_by_port;
 
   joedb::Compact_Freedom_Keeper freedom_keeper;
 
   size_t size() const {return freedom_keeper.size();}
 
   void resize(size_t new_size)
   {
    field_value_of_file_name.resize(new_size);
    field_value_of_port.resize(new_size);
    field_value_of_timeout.resize(new_size);
    iterator_over_server_by_port.resize(new_size);
    freedom_keeper.resize(new_size);
   }
  };
 }
 
 
 /// Store all the tables of the database
 class Database: public joedb::Writable
 {
  friend class Readable;
  friend class id_of_server;
  friend class container_of_server;
 
  public:
   template<typename E = joedb::Exception>
   static void throw_exception(const std::string &message)
   {
    throw E("joedb::db::multi_server: " + message);
   }
 
   size_t max_record_id;
   Table_Id current_table_id = Table_Id{0};
 
   void set_max_record_id(size_t record_id)
   {
    max_record_id = record_id;
   }
 
   bool is_valid(id_of_server id) const {return is_valid_record_id_for_server(id.get_record_id());}
 
  protected:
   detail::data_of_server storage_of_server;
   bool is_valid_record_id_for_server(Record_Id record_id) const {return storage_of_server.freedom_keeper.is_used(size_t(record_id) + 1);}
 
   std::map<int32_t, id_of_server> index_of_server_by_port;
   void remove_index_of_server_by_port(Record_Id record_id)
   {
    auto &iterator = storage_of_server.iterator_over_server_by_port[size_t(record_id) - 1];
    if (iterator != index_of_server_by_port.end())
    {
     index_of_server_by_port.erase(iterator);
     iterator = index_of_server_by_port.end();
    }
   }
   void add_index_of_server_by_port(Record_Id record_id)
   {
    auto result = index_of_server_by_port.insert
    (
     std::map<int32_t, id_of_server>::value_type
     (
      int32_t(storage_of_server.field_value_of_port[size_t(record_id) - 1]),
      id_of_server(record_id)
     )
    );
    if (!result.second)
    {
     std::ostringstream out;
     out << "server_by_port unique index failure: (";
     joedb::write_int32(out, storage_of_server.field_value_of_port[size_t(record_id) - 1]);
     out << ") at id = " << record_id << ' ';
     out << "was already at id = " << result.first->second.get_id();
     throw_exception(out.str());
    }
    storage_of_server.iterator_over_server_by_port[size_t(record_id) - 1] = result.first;
   }
 
   void internal_delete_server(Record_Id record_id)
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record_id));
    remove_index_of_server_by_port(record_id);
    storage_of_server.field_value_of_file_name[size_t(record_id) - 1].clear();
    storage_of_server.field_value_of_port[size_t(record_id) - 1] = 0;
    storage_of_server.field_value_of_timeout[size_t(record_id) - 1] = 0;
    storage_of_server.freedom_keeper.free(size_t(record_id) + 1);
   }
 
   void internal_insert_server(Record_Id record_id)
   {
    storage_of_server.iterator_over_server_by_port[size_t(record_id) - 1] = index_of_server_by_port.end();
    storage_of_server.freedom_keeper.use(size_t(record_id) + 1);
   }
 
   void internal_vector_insert_server(Record_Id record_id, size_t size)
   {
    storage_of_server.freedom_keeper.use_vector(size_t(record_id) + 1, size);
    std::fill_n
    (
     &storage_of_server.iterator_over_server_by_port[size_t(record_id) - 1],
     size,
     index_of_server_by_port.end()
    );
   }
 
   void internal_update_server__file_name
   (
    Record_Id record_id,
    const std::string& field_value_of_file_name
   )
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record_id));
    storage_of_server.field_value_of_file_name[size_t(record_id) - 1] = field_value_of_file_name;
   }
 
   void internal_update_vector_server__file_name
   (
    Record_Id record_id,
    size_t size,
    const std::string *value
   )
   {
    for (size_t i = 0; i < size; i++)
     JOEDB_ASSERT(is_valid_record_id_for_server(record_id + i));
    std::string *target = &storage_of_server.field_value_of_file_name[size_t(record_id) - 1];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
   void internal_update_server__port
   (
    Record_Id record_id,
    int32_t field_value_of_port
   )
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record_id));
    storage_of_server.field_value_of_port[size_t(record_id) - 1] = field_value_of_port;
    remove_index_of_server_by_port(record_id);
    add_index_of_server_by_port(record_id);
   }
 
   void internal_update_vector_server__port
   (
    Record_Id record_id,
    size_t size,
    const int32_t *value
   )
   {
    for (size_t i = 0; i < size; i++)
     JOEDB_ASSERT(is_valid_record_id_for_server(record_id + i));
    int32_t *target = &storage_of_server.field_value_of_port[size_t(record_id) - 1];
    if (target != value)
     std::copy_n(value, size, target);
    for (size_t i = 0; i < size; i++)
     remove_index_of_server_by_port(record_id + i);
    for (size_t i = 0; i < size; i++)
     add_index_of_server_by_port(record_id + i);
   }
 
   void internal_update_server__timeout
   (
    Record_Id record_id,
    int32_t field_value_of_timeout
   )
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record_id));
    storage_of_server.field_value_of_timeout[size_t(record_id) - 1] = field_value_of_timeout;
   }
 
   void internal_update_vector_server__timeout
   (
    Record_Id record_id,
    size_t size,
    const int32_t *value
   )
   {
    for (size_t i = 0; i < size; i++)
     JOEDB_ASSERT(is_valid_record_id_for_server(record_id + i));
    int32_t *target = &storage_of_server.field_value_of_timeout[size_t(record_id) - 1];
    if (target != value)
     std::copy_n(value, size, target);
   }
 
 
   void delete_from(Table_Id table_id, Record_Id record_id) final
   {
    if (table_id == Table_Id(1))
     internal_delete_server(record_id);
   }
 
   void insert_into(Table_Id table_id, Record_Id record_id) final
   {
    if (size_t(record_id) <= 0 || (max_record_id && size_t(record_id) > max_record_id))
     throw_exception("insert_into: too big");
    if (table_id == Table_Id(1))
    {
     if (is_valid_record_id_for_server(record_id))
      throw_exception("Duplicate insert into table server");
     if (storage_of_server.size() < size_t(record_id))
      storage_of_server.resize(size_t(record_id));
     internal_insert_server(record_id);
    }
   }
 
 
   void insert_vector
   (
    Table_Id table_id,
    Record_Id record_id,
    size_t size
   ) final
   {
    if
    (
     size_t(record_id) <= 0 ||
     (max_record_id && (size_t(record_id) > max_record_id || size > max_record_id))
    )
    {
     throw_exception("insert_vector: null record_id, or too big");
    }
    if (table_id == Table_Id(1))
    {
     if (storage_of_server.size() < size_t(record_id) + size - 1)
      storage_of_server.resize(size_t(record_id) + size - 1);
     internal_vector_insert_server(record_id, size);
    }
   }
 
   void update_string
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    const std::string& value
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_server__file_name(record_id, value);
      return;
     }
     return;
    }
   }
 
   void update_int32
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    int32_t value
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(2))
     {
      internal_update_server__port(record_id, value);
      return;
     }
     if (field_id == Field_Id(3))
     {
      internal_update_server__timeout(record_id, 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
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(1))
     {
      internal_update_vector_server__file_name(record_id, size, value);
      return;
     }
     return;
    }
   }
 
   void update_vector_int32
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t size,
    const int32_t *value
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     if (field_id == Field_Id(2))
     {
      internal_update_vector_server__port(record_id, size, value);
      return;
     }
     if (field_id == Field_Id(3))
     {
      internal_update_vector_server__timeout(record_id, size, value);
      return;
     }
     return;
    }
   }
 
   std::string *get_own_string_storage
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t &capacity
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     capacity = size_t(storage_of_server.freedom_keeper.size());
     if (field_id == Field_Id(1))
     {
      return (storage_of_server.field_value_of_file_name.data() + size_t(record_id) - 1);
     }
     return nullptr;
    }
    return nullptr;
   }
 
   int32_t *get_own_int32_storage
   (
    Table_Id table_id,
    Record_Id record_id,
    Field_Id field_id,
    size_t &capacity
   )
   final
   {
    if (table_id == Table_Id(1))
    {
     capacity = size_t(storage_of_server.freedom_keeper.size());
     if (field_id == Field_Id(2))
     {
      return (storage_of_server.field_value_of_port.data() + size_t(record_id) - 1);
     }
     if (field_id == Field_Id(3))
     {
      return (storage_of_server.field_value_of_timeout.data() + size_t(record_id) - 1);
     }
     return nullptr;
    }
    return nullptr;
   }
 
   void comment(const std::string &comment) override {}
   void timestamp(int64_t timestamp) override {}
   void valid_data() final {}
 
   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 = size_t(joedb::Writable_Journal::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.default_checkpoint();
   }
 
   void drop_table(Table_Id table_id) final
   {
    schema_journal.drop_table(table_id);
    schema_journal.default_checkpoint();
   }
 
   void rename_table
   (
    Table_Id table_id,
    const std::string &name
   ) final
   {
    schema_journal.rename_table(table_id, name);
    schema_journal.default_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.default_checkpoint();
   }
 
   void drop_field(Table_Id table_id, Field_Id field_id) final
   {
    schema_journal.drop_field(table_id, field_id);
    schema_journal.default_checkpoint();
   }
 
   void rename_field
   (
    Table_Id table_id,
    Field_Id field_id,
    const std::string &name
   ) final
   {
    schema_journal.rename_field(table_id, field_id, name);
    schema_journal.default_checkpoint();
   }
 
   void custom(const std::string &name) override
   {
    schema_journal.custom(name);
    schema_journal.default_checkpoint();
   }
 
  public:
   Database():
    max_record_id(0),
    schema_journal(schema_file)
   {}
 
   int64_t get_schema_checkpoint() const
   {
    return schema_journal.get_checkpoint_position();
   }
 
   void initialize_with_readonly_journal(joedb::Readonly_Journal &journal)
   {
    max_record_id = size_t(journal.get_checkpoint_position());
    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.");
   }
 
   container_of_server get_server_table() const;
 
   id_of_server next(id_of_server id) const
   {
    return id_of_server
    (
     Record_Id(storage_of_server.freedom_keeper.get_next(id.get_id() + 1) - 1)
    );
   }
 
   id_of_server previous(id_of_server id) const
   {
    return id_of_server
    (
     Record_Id(storage_of_server.freedom_keeper.get_previous(id.get_id() + 1) - 1)
    );
   }
 
   template<class Comparator>
   std::vector<id_of_server> sorted_server(Comparator comparator) const;
 
   static id_of_server null_server()
   {
    return id_of_server();
   }
 
   const std::string& get_file_name(id_of_server record) const
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record.get_record_id()));
    return (const std::string&)(storage_of_server.field_value_of_file_name[record.get_id() - 1]);
   }
 
   int32_t get_port(id_of_server record) const
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record.get_record_id()));
    return (int32_t)(storage_of_server.field_value_of_port[record.get_id() - 1]);
   }
 
   int32_t get_timeout(id_of_server record) const
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(record.get_record_id()));
    return (int32_t)(storage_of_server.field_value_of_timeout[record.get_id() - 1]);
   }
 
   const std::map<int32_t, id_of_server> &get_index_of_server_by_port()
   {
    return index_of_server_by_port;
   }
 
   id_of_server next_server_by_port(id_of_server id)
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(id.get_record_id()));
    auto iterator = storage_of_server.iterator_over_server_by_port[id.get_id() - 1];
    ++iterator;
    if (iterator != index_of_server_by_port.end())
     return iterator->second;
    else
     return id_of_server();
   }
   id_of_server previous_server_by_port(id_of_server id)
   {
    JOEDB_ASSERT(is_valid_record_id_for_server(id.get_record_id()));
    auto iterator = storage_of_server.iterator_over_server_by_port[id.get_id() - 1];
    if (iterator != index_of_server_by_port.begin())
     return (--iterator)->second;
    else
     return id_of_server();
   }
   id_of_server find_server_by_port(int32_t field_value_of_port) const
   {
    const auto i = index_of_server_by_port.find(int32_t(field_value_of_port));
    if (i == index_of_server_by_port.end())
     return id_of_server();
    else
     return i->second;
   }
 };
 /// returned by @ref Database::get_server_table
 class container_of_server
 {
  friend class Database;
 
  private:
   const Database &db;
   container_of_server(const Database &db): db(db) {}
 
  public:
   class iterator
   {
    friend class container_of_server;
    private:
     const joedb::Compact_Freedom_Keeper *fk;
     size_t index;
     iterator(const detail::data_of_server &data): fk(&data.freedom_keeper), index(0) {}
    public:
     typedef std::forward_iterator_tag iterator_category;
     typedef id_of_server value_type;
     typedef std::ptrdiff_t difference_type;
     typedef value_type* pointer;
     typedef value_type& reference;
 
     bool operator==(const iterator &i) const {return index == i.index;}
     bool operator!=(const iterator &i) const {return index != i.index;}
     iterator &operator++() {index = fk->get_next(index); return *this;}
     iterator operator++(int) {auto copy = *this; index = fk->get_next(index); return copy;}
     iterator &operator--() {index = fk->get_previous(index); return *this;}
     iterator operator--(int) {auto copy = *this; index = fk->get_previous(index); return copy;}
     id_of_server operator*() const {return id_of_server(Record_Id(index - 1));}
   };
 
   iterator begin() const {return ++iterator(db.storage_of_server);}
   iterator end() const {return iterator(db.storage_of_server);}
   bool is_empty() const {return db.storage_of_server.freedom_keeper.is_empty();}
   size_t get_size() const {return db.storage_of_server.freedom_keeper.get_used_count();}
   static id_of_server get_at(size_t i) {return id_of_server(Record_Id(i));}
   bool is_valid_at(size_t i) {return db.storage_of_server.freedom_keeper.is_used(i + 1);}
   id_of_server first() const {return *begin();}
   id_of_server last() const {return *--end();}
   id_of_server get_end() const {return *end();}
 };
 
 inline container_of_server Database::get_server_table() const
 {
  return container_of_server(*this);
 }
 
 template<class Comparator>
 std::vector<id_of_server> Database::sorted_server(Comparator comparator) const
 {
  std::vector<id_of_server> result;
  for (auto x: get_server_table())
   result.emplace_back(x);
  std::sort(result.begin(), result.end(), comparator);
  return result;
 }
}
 
#endif