Database.cpp 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. /*
  2. * Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Format.h>
  7. #include <AK/RefPtr.h>
  8. #include <AK/String.h>
  9. #include <LibSQL/BTree.h>
  10. #include <LibSQL/Database.h>
  11. #include <LibSQL/Heap.h>
  12. #include <LibSQL/Meta.h>
  13. #include <LibSQL/Row.h>
  14. #include <LibSQL/Tuple.h>
  15. namespace SQL {
  16. Database::Database(String name)
  17. : m_heap(Heap::construct(name))
  18. , m_serializer(m_heap)
  19. , m_schemas(BTree::construct(m_serializer, SchemaDef::index_def()->to_tuple_descriptor(), m_heap->schemas_root()))
  20. , m_tables(BTree::construct(m_serializer, TableDef::index_def()->to_tuple_descriptor(), m_heap->tables_root()))
  21. , m_table_columns(BTree::construct(m_serializer, ColumnDef::index_def()->to_tuple_descriptor(), m_heap->table_columns_root()))
  22. {
  23. m_schemas->on_new_root = [&]() {
  24. m_heap->set_schemas_root(m_schemas->root());
  25. };
  26. m_tables->on_new_root = [&]() {
  27. m_heap->set_tables_root(m_tables->root());
  28. };
  29. m_table_columns->on_new_root = [&]() {
  30. m_heap->set_table_columns_root(m_table_columns->root());
  31. };
  32. auto default_schema = get_schema("default");
  33. if (!default_schema) {
  34. default_schema = SchemaDef::construct("default");
  35. add_schema(*default_schema);
  36. }
  37. }
  38. void Database::add_schema(SchemaDef const& schema)
  39. {
  40. m_schemas->insert(schema.key());
  41. }
  42. Key Database::get_schema_key(String const& schema_name)
  43. {
  44. auto key = SchemaDef::make_key();
  45. key["schema_name"] = schema_name;
  46. return key;
  47. }
  48. RefPtr<SchemaDef> Database::get_schema(String const& schema)
  49. {
  50. auto schema_name = schema;
  51. if (schema.is_null() || schema.is_empty())
  52. schema_name = "default";
  53. Key key = get_schema_key(schema_name);
  54. auto schema_def_opt = m_schema_cache.get(key.hash());
  55. if (schema_def_opt.has_value())
  56. return schema_def_opt.value();
  57. auto schema_iterator = m_schemas->find(key);
  58. if (schema_iterator.is_end() || (*schema_iterator != key)) {
  59. return nullptr;
  60. }
  61. auto ret = SchemaDef::construct(*schema_iterator);
  62. m_schema_cache.set(key.hash(), ret);
  63. return ret;
  64. }
  65. void Database::add_table(TableDef& table)
  66. {
  67. m_tables->insert(table.key());
  68. for (auto& column : table.columns()) {
  69. m_table_columns->insert(column.key());
  70. }
  71. }
  72. Key Database::get_table_key(String const& schema_name, String const& table_name)
  73. {
  74. auto key = TableDef::make_key(get_schema_key(schema_name));
  75. key["table_name"] = table_name;
  76. return key;
  77. }
  78. RefPtr<TableDef> Database::get_table(String const& schema, String const& name)
  79. {
  80. auto schema_name = schema;
  81. if (schema.is_null() || schema.is_empty())
  82. schema_name = "default";
  83. Key key = get_table_key(schema_name, name);
  84. auto table_def_opt = m_table_cache.get(key.hash());
  85. if (table_def_opt.has_value())
  86. return table_def_opt.value();
  87. auto table_iterator = m_tables->find(key);
  88. if (table_iterator.is_end() || (*table_iterator != key)) {
  89. return nullptr;
  90. }
  91. auto schema_def = get_schema(schema);
  92. VERIFY(schema_def);
  93. auto ret = TableDef::construct(schema_def, name);
  94. ret->set_pointer((*table_iterator).pointer());
  95. m_table_cache.set(key.hash(), ret);
  96. auto hash = ret->hash();
  97. auto column_key = ColumnDef::make_key(ret);
  98. for (auto column_iterator = m_table_columns->find(column_key);
  99. !column_iterator.is_end() && ((*column_iterator)["table_hash"].to_u32().value() == hash);
  100. column_iterator++) {
  101. ret->append_column(*column_iterator);
  102. }
  103. return ret;
  104. }
  105. Vector<Row> Database::select_all(TableDef const& table)
  106. {
  107. VERIFY(m_table_cache.get(table.key().hash()).has_value());
  108. Vector<Row> ret;
  109. for (auto pointer = table.pointer(); pointer; pointer = ret.last().next_pointer()) {
  110. ret.append(m_serializer.deserialize_block<Row>(pointer, table, pointer));
  111. }
  112. return ret;
  113. }
  114. Vector<Row> Database::match(TableDef const& table, Key const& key)
  115. {
  116. VERIFY(m_table_cache.get(table.key().hash()).has_value());
  117. Vector<Row> ret;
  118. // TODO Match key against indexes defined on table. If found,
  119. // use the index instead of scanning the table.
  120. for (auto pointer = table.pointer(); pointer;) {
  121. auto row = m_serializer.deserialize_block<Row>(pointer, table, pointer);
  122. if (row.match(key))
  123. ret.append(row);
  124. pointer = ret.last().next_pointer();
  125. }
  126. return ret;
  127. }
  128. bool Database::insert(Row& row)
  129. {
  130. VERIFY(m_table_cache.get(row.table()->key().hash()).has_value());
  131. row.set_pointer(m_heap->new_record_pointer());
  132. row.next_pointer(row.table()->pointer());
  133. update(row);
  134. // TODO update indexes defined on table.
  135. auto table_key = row.table()->key();
  136. table_key.set_pointer(row.pointer());
  137. VERIFY(m_tables->update_key_pointer(table_key));
  138. row.table()->set_pointer(row.pointer());
  139. return true;
  140. }
  141. bool Database::update(Row& tuple)
  142. {
  143. VERIFY(m_table_cache.get(tuple.table()->key().hash()).has_value());
  144. m_serializer.reset();
  145. return m_serializer.serialize_and_write<Tuple>(tuple, tuple.pointer());
  146. // TODO update indexes defined on table.
  147. return true;
  148. }
  149. }