repository.hpp

浏览该文件的文档.

#ifndef NEFORCE_DATABASE_REPOSITORY_HPP__
#define NEFORCE_DATABASE_REPOSITORY_HPP__

 
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/reflect/reflect.hpp"
#include "NeForce/db/db_interface.hpp"
#include "NeForce/db/sql_builder.hpp"
#include "NeForce/db/sql_mapper.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T, typename Connect = idb_tb_connect>
class repository {
    static_assert(is_base_of_v<idb_connect, Connect>, "Connect must be derived from idb_connect");
 
    Connect& conn_; 

    static string build_insert_with_values(const T& entity) {
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
        const string tbl = sql_mapper<T>::table_name();
 
        sql_builder b;
        vector<string> columns;
        vector<string> vals;
 
        for (const auto& entry: meta->all_properties()) {
            const auto* prop = entry.second;
            if (prop->is_transient() || prop->is_auto_increment()) {
                continue;
            }
            columns.push_back(prop->name());
            const reflect::meta_any val = prop->get(&entity);
            vals.push_back(meta_any_to_sql_literal(val));
        }
 
        b.insert_into(tbl, columns);
        b.values(vals);
        return b.build();
    }

    static string build_update_with_values(const T& entity) {
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
        const string tbl = sql_mapper<T>::table_name();
 
        const reflect::meta_property* pk = nullptr;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_primary_key()) {
                pk = entry.second;
                break;
            }
        }
        if (pk == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception("repository::update: no primary key defined"));
        }
 
        sql_builder b;
        b.update(tbl);
 
        for (const auto& entry: meta->all_properties()) {
            const auto* prop = entry.second;
            if (prop->is_transient() || prop->is_primary_key() || prop->is_auto_increment()) {
                continue;
            }
            const reflect::meta_any val = prop->get(&entity);
            b.set(prop->name(), meta_any_to_sql_literal(val));
        }
 
        const reflect::meta_any pk_val = pk->get(&entity);
        b.where_eq(pk->name(), meta_any_to_sql_literal(pk_val));
        return b.build();
    }

    static string build_delete_with_pk(const T& entity) {
        const auto pkv = sql_mapper<T>::get_pk_value(entity);
        const string tbl = sql_mapper<T>::table_name();
 
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
        const reflect::meta_property* pk = nullptr;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_primary_key()) {
                pk = entry.second;
                break;
            }
        }
        if (pk == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception("repository::remove: no primary key defined"));
        }
 
        sql_builder b;
        b.delete_from(tbl);
        b.where_eq(pk->name(), meta_any_to_sql_literal(pkv));
        return b.build();
    }
 
public:
    explicit repository(Connect& conn) noexcept :
    conn_(conn) {}

    NEFORCE_NODISCARD Connect& connection() noexcept { return conn_; }

    bool create_table(string_view table_override = "") {
        const string sql = sql_mapper<T>::create_table_sql(table_override);
        return conn_.update(sql);
    }

    bool drop_table(string_view table_override = "") {
        const string sql = sql_mapper<T>::drop_table_sql(table_override);
        return conn_.update(sql);
    }

    unique_ptr<T> find_by_id(const reflect::meta_any& id) {
        const string tbl = sql_mapper<T>::table_name();
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
 
        const reflect::meta_property* pk = nullptr;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_primary_key()) {
                pk = entry.second;
                break;
            }
        }
        if (pk == nullptr) {
            return nullptr;
        }
 
        sql_builder b;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_transient()) {
                continue;
            }
            b.select(entry.second->name());
        }
        b.from(tbl);
        b.where_eq(pk->name(), meta_any_to_sql_literal(id));
 
        auto result = conn_.query(b.build());
        if (result == nullptr || result->empty()) {
            return nullptr;
        }
 
        if (!result->next()) {
            return nullptr;
        }
 
        return make_unique<T>(sql_mapper<T>::from_row(*result));
    }

    vector<T> find_all() {
        const string tbl = sql_mapper<T>::table_name();
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
 
        sql_builder b;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_transient()) {
                continue;
            }
            b.select(entry.second->name());
        }
        b.from(tbl);
 
        auto result = conn_.query(b.build());
        return sql_mapper<T>::from_result(move(result));
    }

    vector<T> find_where(const string& where_clause) {
        const string tbl = sql_mapper<T>::table_name();
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
 
        sql_builder b;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_transient()) {
                continue;
            }
            b.select(entry.second->name());
        }
        b.from(tbl);
        b.where(where_clause);
 
        auto result = conn_.query(b.build());
        return sql_mapper<T>::from_result(move(result));
    }

    vector<T> find_page(const size_t page_num, const size_t page_size, string_view order_by = "") {
        const string tbl = sql_mapper<T>::table_name();
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
 
        sql_builder b;
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_transient()) {
                continue;
            }
            b.select(entry.second->name());
        }
        b.from(tbl);
 
        if (!order_by.empty()) {
            b.order_by_asc(order_by);
        }
 
        b.page(static_cast<int>(page_num), static_cast<int>(page_size));
 
        auto result = conn_.query(b.build());
        return sql_mapper<T>::from_result(move(result));
    }

    bool insert(T& entity) {
        const string sql = build_insert_with_values(entity);
        return conn_.update(sql);
    }

    bool update(const T& entity) {
        const string sql = build_update_with_values(entity);
        return conn_.update(sql);
    }

    bool remove(const T& entity) {
        const string sql = build_delete_with_pk(entity);
        return conn_.update(sql);
    }

    size_t count() {
        const string tbl = sql_mapper<T>::table_name();
        sql_builder b;
        b.select_count();
        b.from(tbl);
 
        auto result = conn_.query(b.build());
        if (result == nullptr || result->empty()) {
            return 0;
        }
        if (!result->next()) {
            return 0;
        }
        return static_cast<size_t>(result->get_int64(0));
    }

    bool table_exists() { return conn_.table_exists(sql_mapper<T>::table_name()); }
};
 // Repository
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_DATABASE_REPOSITORY_HPP__