Database.cpp 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. /*
  2. * Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
  3. * Copyright (c) 2021, Mahmoud Mandour <ma.mandourr@gmail.com>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/Format.h>
  8. #include <AK/RefPtr.h>
  9. #include <AK/String.h>
  10. #include <LibSQL/BTree.h>
  11. #include <LibSQL/Database.h>
  12. #include <LibSQL/Heap.h>
  13. #include <LibSQL/Meta.h>
  14. #include <LibSQL/Row.h>
  15. #include <LibSQL/Tuple.h>
  16. namespace SQL {
  17. Database::Database(String name)
  18. : m_heap(Heap::construct(move(name)))
  19. , m_serializer(m_heap)
  20. {
  21. }
  22. ResultOr<void> Database::open()
  23. {
  24. TRY(m_heap->open());
  25. m_schemas = BTree::construct(m_serializer, SchemaDef::index_def()->to_tuple_descriptor(), m_heap->schemas_root());
  26. m_schemas->on_new_root = [&]() {
  27. m_heap->set_schemas_root(m_schemas->root());
  28. };
  29. m_tables = BTree::construct(m_serializer, TableDef::index_def()->to_tuple_descriptor(), m_heap->tables_root());
  30. m_tables->on_new_root = [&]() {
  31. m_heap->set_tables_root(m_tables->root());
  32. };
  33. m_table_columns = BTree::construct(m_serializer, ColumnDef::index_def()->to_tuple_descriptor(), m_heap->table_columns_root());
  34. m_table_columns->on_new_root = [&]() {
  35. m_heap->set_table_columns_root(m_table_columns->root());
  36. };
  37. m_open = true;
  38. auto ensure_schema_exists = [&](auto schema_name) -> ResultOr<NonnullRefPtr<SchemaDef>> {
  39. if (auto result = get_schema(schema_name); result.is_error()) {
  40. if (result.error().error() != SQLErrorCode::SchemaDoesNotExist)
  41. return result.release_error();
  42. auto schema_def = SchemaDef::construct(schema_name);
  43. TRY(add_schema(*schema_def));
  44. return schema_def;
  45. } else {
  46. return result.release_value();
  47. }
  48. };
  49. (void)TRY(ensure_schema_exists("default"sv));
  50. auto master_schema = TRY(ensure_schema_exists("master"sv));
  51. auto table_def = TRY(get_table("master", "internal_describe_table"));
  52. if (!table_def) {
  53. auto describe_internal_table = TableDef::construct(master_schema, "internal_describe_table");
  54. describe_internal_table->append_column("Name", SQLType::Text);
  55. describe_internal_table->append_column("Type", SQLType::Text);
  56. TRY(add_table(*describe_internal_table));
  57. }
  58. return {};
  59. }
  60. Database::~Database() = default;
  61. ErrorOr<void> Database::commit()
  62. {
  63. VERIFY(is_open());
  64. TRY(m_heap->flush());
  65. return {};
  66. }
  67. ResultOr<void> Database::add_schema(SchemaDef const& schema)
  68. {
  69. VERIFY(is_open());
  70. if (!m_schemas->insert(schema.key()))
  71. return Result { SQLCommand::Unknown, SQLErrorCode::SchemaExists, schema.name() };
  72. return {};
  73. }
  74. Key Database::get_schema_key(String const& schema_name)
  75. {
  76. auto key = SchemaDef::make_key();
  77. key["schema_name"] = schema_name;
  78. return key;
  79. }
  80. ResultOr<NonnullRefPtr<SchemaDef>> Database::get_schema(String const& schema)
  81. {
  82. VERIFY(is_open());
  83. auto schema_name = schema;
  84. if (schema.is_empty())
  85. schema_name = "default"sv;
  86. Key key = get_schema_key(schema_name);
  87. if (auto it = m_schema_cache.find(key.hash()); it != m_schema_cache.end())
  88. return it->value;
  89. auto schema_iterator = m_schemas->find(key);
  90. if (schema_iterator.is_end() || (*schema_iterator != key))
  91. return Result { SQLCommand::Unknown, SQLErrorCode::SchemaDoesNotExist, schema_name };
  92. auto schema_def = SchemaDef::construct(*schema_iterator);
  93. m_schema_cache.set(key.hash(), schema_def);
  94. return schema_def;
  95. }
  96. ErrorOr<void> Database::add_table(TableDef& table)
  97. {
  98. VERIFY(is_open());
  99. if (!m_tables->insert(table.key())) {
  100. warnln("Duplicate table name '{}'.'{}'"sv, table.parent()->name(), table.name());
  101. return Error::from_string_literal("Duplicate table name");
  102. }
  103. for (auto& column : table.columns()) {
  104. VERIFY(m_table_columns->insert(column.key()));
  105. }
  106. return {};
  107. }
  108. Key Database::get_table_key(String const& schema_name, String const& table_name)
  109. {
  110. auto key = TableDef::make_key(get_schema_key(schema_name));
  111. key["table_name"] = table_name;
  112. return key;
  113. }
  114. ResultOr<RefPtr<TableDef>> Database::get_table(String const& schema, String const& name)
  115. {
  116. VERIFY(is_open());
  117. auto schema_name = schema;
  118. if (schema.is_null() || schema.is_empty())
  119. schema_name = "default";
  120. Key key = get_table_key(schema_name, name);
  121. auto table_def_opt = m_table_cache.get(key.hash());
  122. if (table_def_opt.has_value())
  123. return RefPtr<TableDef>(table_def_opt.value());
  124. auto table_iterator = m_tables->find(key);
  125. if (table_iterator.is_end() || (*table_iterator != key)) {
  126. return RefPtr<TableDef>(nullptr);
  127. }
  128. auto schema_def = TRY(get_schema(schema));
  129. auto ret = TableDef::construct(schema_def, name);
  130. ret->set_pointer((*table_iterator).pointer());
  131. m_table_cache.set(key.hash(), ret);
  132. auto hash = ret->hash();
  133. auto column_key = ColumnDef::make_key(ret);
  134. for (auto column_iterator = m_table_columns->find(column_key);
  135. !column_iterator.is_end() && ((*column_iterator)["table_hash"].to_u32().value() == hash);
  136. column_iterator++) {
  137. ret->append_column(*column_iterator);
  138. }
  139. return RefPtr<TableDef>(ret);
  140. }
  141. ErrorOr<Vector<Row>> Database::select_all(TableDef const& table)
  142. {
  143. VERIFY(m_table_cache.get(table.key().hash()).has_value());
  144. Vector<Row> ret;
  145. for (auto pointer = table.pointer(); pointer; pointer = ret.last().next_pointer()) {
  146. ret.append(m_serializer.deserialize_block<Row>(pointer, table, pointer));
  147. }
  148. return ret;
  149. }
  150. ErrorOr<Vector<Row>> Database::match(TableDef const& table, Key const& key)
  151. {
  152. VERIFY(m_table_cache.get(table.key().hash()).has_value());
  153. Vector<Row> ret;
  154. // TODO Match key against indexes defined on table. If found,
  155. // use the index instead of scanning the table.
  156. for (auto pointer = table.pointer(); pointer;) {
  157. auto row = m_serializer.deserialize_block<Row>(pointer, table, pointer);
  158. if (row.match(key))
  159. ret.append(row);
  160. pointer = ret.last().next_pointer();
  161. }
  162. return ret;
  163. }
  164. ErrorOr<void> Database::insert(Row& row)
  165. {
  166. VERIFY(m_table_cache.get(row.table()->key().hash()).has_value());
  167. // TODO Check constraints
  168. row.set_pointer(m_heap->new_record_pointer());
  169. row.set_next_pointer(row.table()->pointer());
  170. TRY(update(row));
  171. // TODO update indexes defined on table.
  172. auto table_key = row.table()->key();
  173. table_key.set_pointer(row.pointer());
  174. VERIFY(m_tables->update_key_pointer(table_key));
  175. row.table()->set_pointer(row.pointer());
  176. return {};
  177. }
  178. ErrorOr<void> Database::update(Row& tuple)
  179. {
  180. VERIFY(m_table_cache.get(tuple.table()->key().hash()).has_value());
  181. // TODO Check constraints
  182. m_serializer.reset();
  183. m_serializer.serialize_and_write<Tuple>(tuple);
  184. // TODO update indexes defined on table.
  185. return {};
  186. }
  187. }