sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

added alter table command to fluent query builder (progress)

This commit is contained in:
Sascha Kühl 2025-11-03 16:21:26 +01:00
parent 557abecf91
commit c3c7ea57a2
22 changed files with 451 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backends/postgres/test/CMakeLists.txt
View File

@ -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

9
include/matador/orm/schema.hpp
View File

@ -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;
utils::result<void, utils::error> drop() const;
[[nodiscard]] utils::result<void, utils::error> create() const;
[[nodiscard]] utils::result<void, utils::error> drop() const;
template<typename Type>
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();
[[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;

16
include/matador/query/intermediates/query_alter_intermediate.hpp Normal file
View File

@ -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

52
include/matador/query/intermediates/query_alter_table_intermediate.hpp Normal file
View File

@ -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

78
include/matador/query/internal/query_parts.hpp
View File

@ -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
*/

2
include/matador/query/query.hpp
View File

@ -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();
};
}

8
include/matador/query/query_compiler.hpp
View File

@ -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;

1
include/matador/query/query_intermediates.hpp
View File

@ -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"

18
include/matador/query/query_part_visitor.hpp
View File

@ -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;

4
include/matador/sql/dialect.hpp
View File

@ -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"},

6
include/matador/sql/dialect_token.hpp
View File

@ -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,

16
source/orm/CMakeLists.txt
View File

@ -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
query/criteria_evaluator.cpp
../../include/matador/query/criteria/criteria_utils.hpp
../../include/matador/query/criteria/abstract_column_criteria.hpp
query/criteria/abstract_column_criteria.cpp
../../include/matador/query/intermediates/query_alter_table_intermediate.hpp
query/intermediates/query_alter_table_intermediate.cpp
)
target_include_directories(matador-orm

39
source/orm/orm/schema.cpp
View File

@ -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>();
}

14
source/orm/query/intermediates/query_alter_intermediate.cpp Normal file
View File

@ -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_};
}
}

50
source/orm/query/intermediates/query_alter_table_intermediate.cpp Normal file
View File

@ -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_};
}
}

85
source/orm/query/internal/query_parts.cpp
View File

@ -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)) {}

3
source/orm/query/query.cpp
View File

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

22
source/orm/query/query_compiler.cpp
View File

@ -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;

8
test/backends/SchemaFixture.cpp Normal file
View File

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

16
test/backends/SchemaFixture.hpp Normal file
View File

@ -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

23
test/backends/SchemaTest.cpp
View File

@ -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;
TEST_CASE("Test schema", "[schema]") {
using namespace matador::test;
sql::backend_provider::instance().register_backend("noop", std::make_unique<test::orm::test_backend_service>());
sql::connection_pool pool("noop://noop.db", 4);
matador::orm::schema repo(pool, "NoopSchema");
TEST_CASE_METHOD(SchemaFixture, "Test schema", "[schema]") {
using namespace matador::test;
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());
}

1
test/core/CMakeLists.txt
View File

@ -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)