added alter table command to fluent query builder (progress)

backends/postgres/test/CMakeLists.txt

@@ -22,6 +22,8 @@ set(TEST_SOURCES
   ../../../test/backends/QueryRecordTest.cpp
   ../../../test/backends/QueryStatementTests.cpp
   ../../../test/backends/QueryTest.cpp
+  ../../../test/backends/SchemaFixture.cpp
+  ../../../test/backends/SchemaFixture.hpp
   ../../../test/backends/SchemaTest.cpp
   ../../../test/backends/SessionFixture.cpp
   ../../../test/backends/SessionFixture.hpp

include/matador/orm/schema.hpp

@@ -26,6 +26,7 @@ private:
 
 class schema final {
 public:
+  explicit schema(sql::connection_pool &pool);
   schema(sql::connection_pool &pool, const std::string &name);
 
   template<typename Type>
@@ -38,12 +39,12 @@ public:
     return repo_.attach<Type, SuperType>(name);
   }
 
-  utils::result<void, utils::error> create() const;
+  [[nodiscard]] utils::result<void, utils::error> create() const;
-  utils::result<void, utils::error> drop() const;
+  [[nodiscard]] utils::result<void, utils::error> drop() const;
 
   template<typename Type>
-  utils::result<void, utils::error> drop_table();
+  [[nodiscard]] utils::result<void, utils::error> drop_table();
-  utils::result<void, utils::error> drop_table(const std::string &table_name) const;
+  [[nodiscard]] utils::result<void, utils::error> drop_table(const std::string &table_name) const;
 
   [[nodiscard]] utils::result<std::vector<object::attribute_definition>, utils::error> describe_table(const std::string &table_name) const;
   [[nodiscard]] utils::result<bool, utils::error> table_exists(const std::string &table_name) const;

include/matador/query/intermediates/query_alter_intermediate.hpp

@@ -0,0 +1,16 @@
+#ifndef MATADOR_QUERY_ALTER_INTERMEDIATE_HPP
+#define MATADOR_QUERY_ALTER_INTERMEDIATE_HPP
+
+#include "matador/query/intermediates/query_alter_table_intermediate.hpp"
+#include "matador/query/intermediates/query_intermediate.hpp"
+
+namespace matador::query {
+class query_alter_intermediate : public query_intermediate {
+public:
+  query_alter_intermediate();
+
+  query_alter_table_intermediate table(const sql::table &table) const;
+};
+
+}
+#endif //MATADOR_QUERY_ALTER_INTERMEDIATE_HPP

include/matador/query/intermediates/query_alter_table_intermediate.hpp

@@ -0,0 +1,52 @@
+#ifndef MATADOR_QUERY_ALTER_TABLE_INTERMEDIATE_HPP
+#define MATADOR_QUERY_ALTER_TABLE_INTERMEDIATE_HPP
+
+#include "executable_query.hpp"
+#include "matador/query/intermediates/query_intermediate.hpp"
+
+namespace matador::query {
+class query_add_primary_key_constraint_intermediate final : public query_intermediate {
+public:
+};
+
+class query_add_foreign_key_constraint_intermediate final : public query_intermediate {
+public:
+    using query_intermediate::query_intermediate;
+
+    executable_query references(const sql::table& table, const std::vector<sql::column>& columns = {});
+
+private:
+    sql::table table_;
+    std::vector<sql::column> columns_;
+};
+
+class query_add_key_constraint_intermediate final : public query_intermediate {
+public:
+    using query_intermediate::query_intermediate;
+
+    query_add_primary_key_constraint_intermediate primary_key(const sql::column& column) const;
+    query_add_primary_key_constraint_intermediate primary_keys(const std::vector<sql::column>& columns) const;
+    query_add_foreign_key_constraint_intermediate foreign_key(const sql::column& column) const;
+    query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<sql::column>& columns) const;
+};
+
+class query_drop_key_constraint_intermediate final : public query_intermediate {
+public:
+    using query_intermediate::query_intermediate;
+
+    void constraint(const std::string& name);
+    void primary_key();
+    void foreign_key(const std::string& name);
+    void foreign_keys(const std::vector<std::string>& names);
+};
+
+class query_alter_table_intermediate final : public query_intermediate {
+public:
+    using query_intermediate::query_intermediate;
+
+    query_add_key_constraint_intermediate add_constraint(const std::string& name);
+    query_drop_key_constraint_intermediate drop_constraint(const std::string& name);
+};
+}
+
+#endif //MATADOR_QUERY_ALTER_TABLE_INTERMEDIATE_HPP

include/matador/query/internal/query_parts.hpp

@@ -17,6 +17,84 @@
 
 namespace matador::query::internal {
 
+class query_alter_part final : public query_part {
+public:
+  query_alter_part();
+
+  void accept(query_part_visitor &visitor) override;
+};
+
+class query_alter_table_part final : public query_part {
+public:
+  explicit query_alter_table_part(sql::table table);
+
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const sql::table& table() const;
+
+private:
+  sql::table table_;
+};
+
+class query_add_key_constraint_part final : public query_part {
+public:
+  explicit query_add_key_constraint_part(const std::string& name);
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const std::string& name() const;
+private:
+  std::string name_;
+};
+
+class query_drop_key_constraint_part final : public query_part {
+public:
+  explicit query_drop_key_constraint_part(const std::string& name);
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const std::string& name() const;
+private:
+  std::string name_;
+};
+
+class query_add_foreign_key_constraint_part final : public query_part {
+public:
+  explicit query_add_foreign_key_constraint_part( const std::vector<sql::column>& columns);
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const std::vector<sql::column>& columns() const;
+private:
+  std::vector<sql::column> columns_;
+};
+
+class query_add_foreign_key_reference_part final : public query_part {
+public:
+  explicit query_add_foreign_key_reference_part(sql::table table, const std::vector<sql::column>& columns);
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const std::vector<sql::column>& columns() const;
+
+private:
+  sql::table table_;
+  std::vector<sql::column> columns_;
+};
+
+class query_add_primary_key_constraint_part final : public query_part {
+public:
+  explicit query_add_primary_key_constraint_part( const std::vector<sql::column>& columns);
+  void accept(query_part_visitor &visitor) override;
+
+  [[nodiscard]] const std::vector<sql::column>& columns() const;
+private:
+  std::vector<sql::column> columns_;
+};
+
+class query_drop_foreign_key_constraint_part final : public query_part {
+public:
+    explicit query_drop_foreign_key_constraint_part( const std::vector<sql::column>& columns);
+    void accept(query_part_visitor &visitor) override;
+};
+
 /**
  * Represents the SQL SELECT part
  */

include/matador/query/query.hpp

@@ -31,6 +31,8 @@ public:
   [[nodiscard]] static query_insert_intermediate insert();
   [[nodiscard]] static query_update_intermediate update(const sql::table &table);
   [[nodiscard]] static query_delete_intermediate remove();
+
+  [[nodiscard]] static query_alter_intermediate alter();
 };
 
 }

include/matador/query/query_compiler.hpp

@@ -30,6 +30,14 @@ public:
                              std::optional<std::reference_wrapper<const sql::connection_impl>> conn);
 
 protected:
+  void visit(internal::query_alter_part& part) override;
+  void visit(internal::query_alter_table_part& part) override;
+  void visit(internal::query_add_key_constraint_part& part) override;
+  void visit( internal::query_add_foreign_key_constraint_part& part ) override;
+  void visit( internal::query_add_primary_key_constraint_part& part ) override;
+  void visit( internal::query_add_foreign_key_reference_part& part ) override;
+  void visit(internal::query_drop_key_constraint_part& part) override;
+
   void visit(internal::query_select_part &select_part) override;
   void visit(internal::query_from_part &from_part) override;
   void visit(internal::query_join_part &join_part) override;

include/matador/query/query_intermediates.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/query/intermediates/executable_query.hpp"
 #include "matador/query/intermediates/fetchable_query.hpp"
+#include "matador/query/intermediates/query_alter_intermediate.hpp"
 #include "matador/query/intermediates/query_create_intermediate.hpp"
 #include "matador/query/intermediates/query_delete_from_intermediate.hpp"
 #include "matador/query/intermediates/query_delete_intermediate.hpp"

include/matador/query/query_part_visitor.hpp

@@ -4,6 +4,13 @@
 namespace matador::query {
 
 namespace internal {
+class query_alter_part;
+class query_alter_table_part;
+class query_add_key_constraint_part;
+class query_drop_key_constraint_part;
+class query_add_foreign_key_constraint_part;
+class query_add_foreign_key_reference_part;
+class query_add_primary_key_constraint_part;
 class query_select_part;
 class query_from_part;
 class query_join_part;
@@ -28,11 +35,18 @@ class query_drop_part;
 class query_drop_table_part;
 }
 
-class query_part_visitor
+class query_part_visitor {
-{
 public:
   virtual ~query_part_visitor() = default;
 
+  virtual void visit(internal::query_alter_part &part) = 0;
+  virtual void visit(internal::query_alter_table_part &part) = 0;
+  virtual void visit(internal::query_add_key_constraint_part &part) = 0;
+  virtual void visit(internal::query_add_foreign_key_constraint_part &part) = 0;
+  virtual void visit(internal::query_add_primary_key_constraint_part &part) = 0;
+  virtual void visit(internal::query_add_foreign_key_reference_part &part) = 0;
+  virtual void visit(internal::query_drop_key_constraint_part &part) = 0;
+
   virtual void visit(internal::query_select_part &select_part) = 0;
   virtual void visit(internal::query_from_part &from_part) = 0;
   virtual void visit(internal::query_join_part &join_part) = 0;

include/matador/sql/dialect.hpp

@@ -143,6 +143,7 @@ private:
     {dialect_token::Drop,        "DROP"},
     {dialect_token::Remove,      "DELETE"},
     {dialect_token::Insert,      "INSERT"},
+    {dialect_token::Alter,       "ALTER"},
     {dialect_token::Table,       "TABLE"},
     {dialect_token::Into,        "INTO"},
     {dialect_token::Values,      "VALUES"},
@@ -172,6 +173,9 @@ private:
     {dialect_token::Set,         "SET"},
     {dialect_token::NotNull,    "NOT NULL"},
     {dialect_token::PrimaryKey, "PRIMARY KEY"},
+    {dialect_token::ForeignKey, "FOREIGN KEY"},
+    {dialect_token::AddConstraint,  "Add CONSTRAINT"},
+    {dialect_token::DropConstraint, "DROP CONSTRAINT"},
     {dialect_token::Begin,       "BEGIN TRANSACTION"},
     {dialect_token::Commit,      "COMMIT TRANSACTION"},
     {dialect_token::Rollback,    "ROLLBACK TRANSACTION"},

include/matador/sql/dialect_token.hpp

@@ -13,6 +13,11 @@ enum class dialect_token : uint8_t {
   Update,
   Select,
   Alter,
+  ForeignKey,
+  PrimaryKey,
+  AddConstraint,
+  DropConstraint,
+  References,
   Schema,
   Database,
   Table,
@@ -43,7 +48,6 @@ enum class dialect_token : uint8_t {
   Set,
   UpdateValues,
   NotNull,
-  PrimaryKey,
   Begin,
   Commit,
   Rollback,

source/orm/CMakeLists.txt

@@ -4,17 +4,21 @@ add_library(matador-orm STATIC
   ../../include/matador/orm/session.hpp
   ../../include/matador/orm/session_query_builder.hpp
   ../../include/matador/query/attribute_string_writer.hpp
+  ../../include/matador/query/criteria.hpp
+  ../../include/matador/query/criteria/abstract_column_criteria.hpp
   ../../include/matador/query/criteria/abstract_criteria.hpp
   ../../include/matador/query/criteria/between_criteria.hpp
   ../../include/matador/query/criteria/collection_criteria.hpp
-  ../../include/matador/query/criteria.hpp
   ../../include/matador/query/criteria/criteria_operators.hpp
+  ../../include/matador/query/criteria/criteria_utils.hpp
   ../../include/matador/query/criteria/criteria_visitor.hpp
   ../../include/matador/query/criteria/like_criteria.hpp
   ../../include/matador/query/criteria/logical_criteria.hpp
+  ../../include/matador/query/criteria_evaluator.hpp
   ../../include/matador/query/fk_value_extractor.hpp
   ../../include/matador/query/intermediates/executable_query.hpp
   ../../include/matador/query/intermediates/fetchable_query.hpp
+  ../../include/matador/query/intermediates/query_alter_intermediate.hpp
   ../../include/matador/query/intermediates/query_create_intermediate.hpp
   ../../include/matador/query/intermediates/query_delete_from_intermediate.hpp
   ../../include/matador/query/intermediates/query_delete_intermediate.hpp
@@ -81,6 +85,7 @@ add_library(matador-orm STATIC
   orm/session.cpp
   orm/session_query_builder.cpp
   query/attribute_string_writer.cpp
+  query/criteria/abstract_column_criteria.cpp
   query/criteria/between_criteria.cpp
   query/criteria/binary_criteria.cpp
   query/criteria/collection_criteria.cpp
@@ -88,8 +93,10 @@ add_library(matador-orm STATIC
   query/criteria/like_criteria.cpp
   query/criteria/logical_criteria.cpp
   query/criteria/not_criteria.cpp
+  query/criteria_evaluator.cpp
   query/intermediates/executable_query.cpp
   query/intermediates/fetchable_query.cpp
+  query/intermediates/query_alter_intermediate.cpp
   query/intermediates/query_create_intermediate.cpp
   query/intermediates/query_delete_from_intermediate.cpp
   query/intermediates/query_delete_intermediate.cpp
@@ -145,11 +152,8 @@ add_library(matador-orm STATIC
   sql/statement.cpp
   sql/statement_cache.cpp
   sql/table.cpp
-  ../../include/matador/query/criteria_evaluator.hpp
+  ../../include/matador/query/intermediates/query_alter_table_intermediate.hpp
-  query/criteria_evaluator.cpp
+  query/intermediates/query_alter_table_intermediate.cpp
-  ../../include/matador/query/criteria/criteria_utils.hpp
-  ../../include/matador/query/criteria/abstract_column_criteria.hpp
-  query/criteria/abstract_column_criteria.cpp
 )
 
 target_include_directories(matador-orm

source/orm/orm/schema.cpp

@@ -2,11 +2,19 @@
 
 #include "matador/orm/error_code.hpp"
 #include "matador/orm/session.hpp"
+
 #include "matador/query/query.hpp"
 
+#include "matador/sql/backend_provider.hpp"
 #include "matador/sql/connection_pool.hpp"
+#include "matador/sql/dialect.hpp"
 
 namespace matador::orm {
+schema::schema(sql::connection_pool& pool)
+: repo_(sql::backend_provider::instance().connection_dialect(pool.info().type).default_schema_name())
+, pool_(pool) {
+}
+
 schema::schema(sql::connection_pool &pool, const std::string& name)
 : repo_(name)
 , pool_(pool) {}
@@ -69,6 +77,37 @@ matador::utils::result<void, matador::utils::error> matador::orm::schema::create
 }
 
 matador::utils::result<void, matador::utils::error> matador::orm::schema::drop() const {
+    std::vector<std::string> drop_sql_commands;
+    auto c = pool_.acquire();
+    for (const auto &node: repo_) {
+        auto ctx = query::query::drop()
+          .table(node->name())
+          .compile(*c);
+
+        drop_sql_commands.push_back(ctx.sql);
+        // determine constraints and drop them
+        for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
+            const auto ctx = query::query::alter()
+                .table( "" )
+                .add_constraint( it->second->node().name() )
+                .foreign_key( "" )
+                .references( "" ).compile(*c);
+
+        }
+        // for ( const auto& [sql, command] : ctx.additional_commands ) {
+        //     if (auto result = c->execute(ctx.sql); !result) {
+        //         return utils::failure(result.err());
+        //     }
+        // }
+    }
+
+    // execute additional commands (e.g. ALTER TABLE ADD FK)
+    for (const auto &sql: drop_sql_commands) {
+        std::cout << sql << std::endl;
+        if (auto result = c->execute(sql); !result) {
+            return utils::failure(result.err());
+        }
+    }
     return utils::ok<void>();
 }
 

source/orm/query/intermediates/query_alter_intermediate.cpp

@@ -0,0 +1,14 @@
+#include "matador/query/intermediates/query_alter_intermediate.hpp"
+
+#include "matador/query/internal/query_parts.hpp"
+
+namespace matador::query {
+query_alter_intermediate::query_alter_intermediate() {
+  context_->parts.push_back(std::make_unique<internal::query_alter_part>());
+}
+
+query_alter_table_intermediate query_alter_intermediate::table( const sql::table& table ) const {
+  context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(table));
+  return {context_};
+}
+}

source/orm/query/intermediates/query_alter_table_intermediate.cpp

@@ -0,0 +1,50 @@
+#include "matador/query/intermediates/query_alter_table_intermediate.hpp"
+
+#include "matador/query/internal/query_parts.hpp"
+
+namespace matador::query {
+executable_query query_add_foreign_key_constraint_intermediate::references( const sql::table& table, const std::vector<sql::column>& columns) {
+  context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(table, columns));
+
+  return {context_};
+}
+
+query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const sql::column& column) const {
+  return primary_keys({column});
+}
+
+query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<sql::column>& columns ) const {
+  context_->parts.push_back(std::make_unique<internal::query_add_primary_key_constraint_part>(columns));
+
+  return {context_};
+}
+
+query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const sql::column& column) const {
+  return foreign_keys({column});
+}
+
+query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys( const std::vector<sql::column>& columns ) const {
+  context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns));
+
+  return {context_};
+}
+
+void query_drop_key_constraint_intermediate::constraint( const std::string& name ) {}
+
+void query_drop_key_constraint_intermediate::primary_key() {}
+
+void query_drop_key_constraint_intermediate::foreign_key( const std::string& name ) {}
+
+void query_drop_key_constraint_intermediate::foreign_keys( const std::vector<std::string>& names ) {}
+
+query_add_key_constraint_intermediate query_alter_table_intermediate::add_constraint( const std::string& name ) {
+    context_->parts.push_back(std::make_unique<internal::query_add_key_constraint_part>(name));
+
+    return {context_};
+}
+
+query_drop_key_constraint_intermediate query_alter_table_intermediate::drop_constraint( const std::string& name ) {
+    context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part>(name));
+    return {context_};
+}
+}

source/orm/query/internal/query_parts.cpp

@@ -3,6 +3,89 @@
 #include <utility>
 
 namespace matador::query::internal {
+query_alter_part::query_alter_part()
+: query_part(sql::dialect_token::Alter) {}
+
+void query_alter_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+query_alter_table_part::query_alter_table_part(sql::table table )
+: query_part(sql::dialect_token::Table)
+, table_(std::move(table)) {}
+
+void query_alter_table_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const sql::table& query_alter_table_part::table() const {
+  return table_;
+}
+
+query_add_key_constraint_part::query_add_key_constraint_part(const std::string& name)
+: query_part(sql::dialect_token::AddConstraint)
+, name_(name){}
+
+void query_add_key_constraint_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const std::string& query_add_key_constraint_part::name() const {
+   return name_;
+}
+
+query_drop_key_constraint_part::query_drop_key_constraint_part( const std::string& name )
+: query_part( sql::dialect_token::DropConstraint )
+, name_( name ){}
+
+void query_drop_key_constraint_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const std::string& query_drop_key_constraint_part::name() const {
+  return name_;
+}
+
+query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<sql::column>& columns)
+: query_part(sql::dialect_token::ForeignKey)
+, columns_(columns) {}
+
+void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const std::vector<sql::column>& query_add_foreign_key_constraint_part::columns() const {
+  return columns_;
+}
+
+query_add_foreign_key_reference_part::query_add_foreign_key_reference_part( sql::table table, const std::vector<sql::column>& columns )
+: query_part(sql::dialect_token::References)
+, table_(std::move(table))
+, columns_(columns) {}
+
+void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const sql::table& query_add_foreign_key_reference_part::table() const {
+  return table_;
+}
+
+const std::vector<sql::column>& query_add_foreign_key_reference_part::columns() const {
+  return columns_;
+}
+
+query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<sql::column>& columns)
+: query_part(sql::dialect_token::PrimaryKey)
+, columns_(columns) {}
+
+void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor ) {
+  visitor.visit(*this);
+}
+
+const std::vector<sql::column>& query_add_primary_key_constraint_part::columns() const {
+  return columns_;
+}
 
 query_select_part::query_select_part(std::vector<sql::column> columns)
   : query_part(sql::dialect_token::Select)
@@ -74,7 +157,7 @@ const abstract_criteria &query_where_part::condition() const
   return *condition_;
 }
 
-query_table_name_part::query_table_name_part(sql::dialect_token token, std::string table_name)
+query_table_name_part::query_table_name_part(const sql::dialect_token token, std::string table_name)
 : query_part(token)
 , table_name_(std::move(table_name)) {}
 

source/orm/query/query.cpp

@@ -68,4 +68,7 @@ query_delete_intermediate query::remove() {
   return {};
 }
 
+query_alter_intermediate query::alter() {
+    return {};
+}
 }

source/orm/query/query_compiler.cpp

@@ -51,6 +51,28 @@ std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const
     return d->prepare_identifier(col);
 }
 
+void query_compiler::visit(internal::query_alter_part& part) {
+  query_.sql = dialect_->token_at(sql::dialect_token::Create);
+}
+
+void query_compiler::visit(internal::query_alter_table_part& part) {
+  query_.command = sql::sql_command::SQL_ALTER_TABLE;
+  query_.sql += " " + dialect_->token_at(sql::dialect_token::Table) + " " +
+    dialect_->prepare_identifier_string(part.table().name);
+}
+
+void query_compiler::visit(internal::query_add_key_constraint_part& part) {
+    query_.sql += " " + dialect_->token_at(sql::dialect_token::AddConstraint) + " " + part.name();
+}
+
+void query_compiler::visit( internal::query_add_foreign_key_constraint_part& part ) {}
+
+void query_compiler::visit( internal::query_add_primary_key_constraint_part& part ) {}
+
+void query_compiler::visit( internal::query_add_foreign_key_reference_part& part ) {}
+
+void query_compiler::visit(internal::query_drop_key_constraint_part& part) {}
+
 void query_compiler::visit(internal::query_select_part &select_part)
 {
   query_.command = sql::sql_command::SQL_SELECT;

test/backends/SchemaFixture.cpp

@@ -0,0 +1,8 @@
+#include "SchemaFixture.hpp"
+
+#include "connection.hpp"
+
+namespace matador::test {
+SchemaFixture::SchemaFixture()
+: pool(connection::dns, 4) {}
+}

test/backends/SchemaFixture.hpp

@@ -0,0 +1,16 @@
+#ifndef MATADOR_QUERY_SCHEMA_FIXTURE_HPP
+#define MATADOR_QUERY_SCHEMA_FIXTURE_HPP
+
+#include "matador/sql/connection_pool.hpp"
+
+namespace matador::test {
+class SchemaFixture {
+public:
+    SchemaFixture();
+
+protected:
+    sql::connection_pool pool;
+};
+}
+
+#endif //MATADOR_QUERY_SCHEMA_FIXTURE_HPP

test/backends/SchemaTest.cpp

@@ -1,24 +1,20 @@
 #include <catch2/catch_test_macros.hpp>
 
+#include "SchemaFixture.hpp"
+
 #include "matador/sql/backend_provider.hpp"
 #include "matador/sql/connection_pool.hpp"
 
 #include "matador/orm/schema.hpp"
 
-#include "../orm/backend/test_connection.hpp"
-#include "../orm/backend/test_backend_service.hpp"
-
 #include "../models/department.hpp"
 
 using namespace matador;
+using namespace matador::test;
 
-TEST_CASE("Test schema", "[schema]") {
+TEST_CASE_METHOD(SchemaFixture, "Test schema", "[schema]") {
     using namespace matador::test;
-    sql::backend_provider::instance().register_backend("noop", std::make_unique<test::orm::test_backend_service>());
+    matador::orm::schema repo(pool/*, "NoopSchema"*/);
-
-    sql::connection_pool pool("noop://noop.db", 4);
-
-    matador::orm::schema repo(pool, "NoopSchema");
 
     auto result = repo.attach<department>("departments")
        .and_then( [&repo] { return repo.attach<employee>("employees"); } );
@@ -27,7 +23,14 @@ TEST_CASE("Test schema", "[schema]") {
     result = repo.create();
     REQUIRE(result);
 
-    const auto exists_result = repo.table_exists("departments");
+    auto exists_result = repo.table_exists("departments");
     REQUIRE(exists_result.is_ok());
     REQUIRE(exists_result.value());
+
+    result = repo.drop();
+    REQUIRE(result);
+
+    exists_result = repo.table_exists("departments");
+    REQUIRE(exists_result.is_ok());
+    REQUIRE(!exists_result.value());
 }

test/core/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(CoreTests
   object/PrimaryKeyResolverTest.cpp
   object/SchemaTest.cpp
   utils/MessageBusTest.cpp
+  ../backends/SchemaFixture.hpp
 )
 
 target_link_libraries(CoreTests matador-core Catch2::Catch2WithMain)