sql_mapper.hpp

浏览该文件的文档.

#ifndef NEFORCE_DATABASE_SQL_MAPPER_HPP__
#define NEFORCE_DATABASE_SQL_MAPPER_HPP__

 
#include "NeForce/core/reflect/reflect.hpp"
#include "NeForce/core/string/string.hpp"
#include "NeForce/db/db_interface.hpp"
#include "NeForce/db/sql_builder.hpp"
NEFORCE_BEGIN_NAMESPACE__


inline string cpp_type_to_sql_type(const reflect::type_id tid) {
    using reflect::type_id_for;
    if (tid == type_id_for<short>()) {
        return "SMALLINT";
    }
    if (tid == type_id_for<unsigned short>()) {
        return "SMALLINT";
    }
    if (tid == type_id_for<int>()) {
        return "INTEGER";
    }
    if (tid == type_id_for<unsigned int>()) {
        return "INTEGER";
    }
#ifdef NEFORCE_PLATFORM_WINDOWS
    if (tid == type_id_for<long>()) {
        return "INTEGER";
    }
    if (tid == type_id_for<unsigned long>()) {
        return "INTEGER";
    }
#else
    if (tid == type_id_for<long>()) {
        return "BIGINT";
    }
    if (tid == type_id_for<unsigned long>()) {
        return "BIGINT";
    }
#endif
    if (tid == type_id_for<long long>()) {
        return "BIGINT";
    }
    if (tid == type_id_for<unsigned long long>()) {
        return "BIGINT";
    }
    if (tid == type_id_for<double>()) {
        return "DOUBLE PRECISION";
    }
    if (tid == type_id_for<float>()) {
        return "REAL";
    }
    if (tid == type_id_for<bool>()) {
        return "BOOLEAN";
    }
    if (tid == type_id_for<string>()) {
        return "TEXT";
    }
    return "TEXT";
}

inline reflect::meta_any read_column_by_type(const idb_tb_result& row, const size_t col, const reflect::type_id tid) {
    using reflect::type_id_for;
    if (tid == type_id_for<int>()) {
        return reflect::meta_any(static_cast<int>(row.get_int32(col)));
    } else if (tid == type_id_for<int64_t>()) {
        return reflect::meta_any(row.get_int64(col));
    } else if (tid == type_id_for<short>()) {
        return reflect::meta_any(static_cast<short>(row.get_int32(col)));
    } else if (tid == type_id_for<double>()) {
        return reflect::meta_any(row.get_float64(col));
    } else if (tid == type_id_for<float>()) {
        return reflect::meta_any(row.get_float32(col));
    } else if (tid == type_id_for<bool>()) {
        return reflect::meta_any(row.get_bool(col));
    } else if (tid == type_id_for<string>()) {
        return reflect::meta_any(string(row.get(col)));
    } else {
        return reflect::meta_any(string(row.get(col)));
    }
}

inline string meta_any_to_sql_literal(const reflect::meta_any& val) {
    if (!val.has_value()) {
        return "NULL";
    }
    const auto tid = val.type_id();
    using reflect::type_id_for;
 
    if (tid == type_id_for<int>()) {
        return integer32(val.get<int>()).to_string();
    } else if (tid == type_id_for<int64_t>()) {
        return integer64(val.get<int64_t>()).to_string();
    } else if (tid == type_id_for<short>()) {
        return integer32(val.get<short>()).to_string();
    } else if (tid == type_id_for<double>()) {
        return float64(val.get<double>()).to_string();
    } else if (tid == type_id_for<float>()) {
        return float64(val.get<float>()).to_string();
    } else if (tid == type_id_for<bool>()) {
        return val.get<bool>() ? "1" : "0";
    } else if (tid == type_id_for<string>()) {
        // simple quoting — caller should use parameterized queries when possible
        const auto& s = val.get<string>();
        string escaped;
        escaped.reserve(s.size() + 2);
        escaped += '\'';
        for (const auto ch: s) {
            if (ch == '\'') {
                escaped += "''";
            } else {
                escaped += ch;
            }
        }
        escaped += '\'';
        return escaped;
    }
    return "NULL";
}

template <typename T>
class sql_mapper {
private:
    static const reflect::meta_type* get_meta() {
        auto* meta = reflect::registry::instance().find(reflect::type_id_for<T>());
        if (meta == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception(
                    _NEFORCE format("sql_mapper: type '{}' not registered in reflect registry", reflect::type_name_v<T>)
                            .data()));
        }
        return meta;
    }
 
    static string resolve_table_name() {
        const auto* meta = get_meta();
        const auto tn = meta->table_name();
        if (!tn.empty()) {
            return tn;
        }
        return meta->name();
    }

    static vector<const reflect::meta_property*> collect_persistent_props(bool include_pk = true) {
        const auto* meta = get_meta();
        vector<const reflect::meta_property*> result;
        for (const auto& entry: meta->all_properties()) {
            const auto* prop = entry.second;
            if (prop->is_transient()) {
                continue;
            }
            if (!include_pk && prop->is_auto_increment()) {
                continue;
            }
            result.push_back(prop);
        }
        return result;
    }

    static const reflect::meta_property* find_pk_prop() {
        const auto* meta = get_meta();
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_primary_key()) {
                return entry.second;
            }
        }
        return nullptr;
    }
 
public:
    static string table_name() { return resolve_table_name(); }

    static string create_table_sql(string_view table_override = "") {
        const auto* meta = get_meta();
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
 
        sql_builder b;
        b.create_table_if_not_exists(tbl);
 
        for (const auto& entry: meta->all_properties()) {
            const auto* prop = entry.second;
            if (prop->is_transient()) {
                continue;
            }
 
            const string sql_type = cpp_type_to_sql_type(prop->type_id());
 
            if (prop->is_primary_key() && prop->is_auto_increment()) {
                b.column_auto_increment(prop->name(), sql_type);
            } else if (prop->is_primary_key()) {
                b.column_primary_key(prop->name(), sql_type);
            } else if (prop->is_unique()) {
                b.column_unique(prop->name(), sql_type);
            } else if (prop->is_required()) {
                b.column_not_null(prop->name(), sql_type);
            } else {
                b.column(prop->name(), sql_type);
            }
        }
 
        return b.build();
    }

    static string drop_table_sql(string_view table_override = "") {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
        sql_builder b;
        b.drop_table_if_exists(tbl);
        return b.build();
    }

    static string select_sql(string_view table_override = "") {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
 
        sql_builder b;
        const auto* meta = get_meta();
 
        for (const auto& entry: meta->all_properties()) {
            if (entry.second->is_transient()) {
                continue;
            }
            b.select(entry.second->name());
        }
        b.from(tbl);
        return b.build();
    }

    static string insert_sql(string_view table_override = "", const sql_dialect dialect = sql_dialect::GENERIC) {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
 
        const auto props = collect_persistent_props(false);
        vector<string> columns;
        columns.reserve(props.size());
        for (const auto* p: props) {
            columns.push_back(p->name());
        }
 
        sql_builder b;
        b.set_dialect(dialect);
        b.insert_into(tbl, columns);
        return b.build();
    }

    static string delete_sql(string_view table_override = "", const sql_dialect dialect = sql_dialect::GENERIC) {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
        const auto* pk = find_pk_prop();
        if (pk == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception("sql_mapper: no primary key defined for DELETE"));
        }
 
        sql_builder b;
        b.set_dialect(dialect);
        b.delete_from(tbl);
        b.where_eq(pk->name(), b.placeholder(1));
        return b.build();
    }

    static string update_sql(string_view table_override = "", const sql_dialect dialect = sql_dialect::GENERIC) {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
        const auto* pk = find_pk_prop();
        if (pk == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception("sql_mapper: no primary key defined for UPDATE"));
        }
 
        const auto props = collect_persistent_props(true);
 
        sql_builder b;
        b.set_dialect(dialect);
        b.update(tbl);
 
        for (const auto* p: props) {
            if (p->is_primary_key() || p->is_auto_increment()) {
                continue;
            }
            b.set_param(p->name());
        }
 
        b.where_eq(pk->name(), b.next_placeholder());
        return b.build();
    }

    static vector<string> get_values(const T& entity, bool include_pk = true) {
        const auto props = collect_persistent_props(include_pk);
        vector<string> values;
        values.reserve(props.size());
        for (const auto* prop: props) {
            reflect::meta_any val = prop->get(&entity);
            values.push_back(meta_any_to_sql_literal(val));
        }
        return values;
    }

    static reflect::meta_any get_pk_value(const T& entity) {
        const auto* pk = find_pk_prop();
        if (pk == nullptr) {
            return reflect::meta_any{};
        }
        return pk->get(&entity);
    }

    static T from_row(const idb_tb_result& row, const unordered_map<string, size_t>& col_map = {}) {
        const auto* meta = get_meta();
        auto obj_any = meta->create();
        if (!obj_any.has_value()) {
            NEFORCE_THROW_EXCEPTION(value_exception("sql_mapper: failed to create entity instance"));
        }
        void* raw = obj_any.raw();
 
        unordered_map<string, size_t> effective_map;
        if (col_map.empty()) {
            const auto& names = row.column_names();
            for (size_t i = 0; i < names.size(); ++i) {
                effective_map[names[i]] = i;
            }
        } else {
            effective_map = col_map;
        }
 
        for (const auto& entry: meta->all_properties()) {
            const auto* prop = entry.second;
            if (prop->is_transient() || prop->is_readonly()) {
                continue;
            }
 
            auto it = effective_map.find(prop->name());
            if (it == effective_map.end()) {
                continue;
            }
 
            reflect::meta_any val = read_column_by_type(row, it->second, prop->type_id());
            prop->set(raw, val);
        }
 
        return *static_cast<T*>(raw);
    }

    static vector<T> from_result(unique_ptr<idb_tb_result> result) {
        vector<T> entities;
        if (result == nullptr || result->empty()) {
            return entities;
        }
 
        unordered_map<string, size_t> col_map;
        const auto& names = result->column_names();
        for (size_t i = 0; i < names.size(); ++i) {
            col_map[names[i]] = i;
        }
 
        while (result->next()) {
            entities.push_back(from_row(*result, col_map));
        }
        return entities;
    }

    static string select_by_pk_sql(string_view table_override = "", const sql_dialect dialect = sql_dialect::GENERIC) {
        const string tbl = table_override.empty() ? resolve_table_name() : string(table_override);
        const auto* pk = find_pk_prop();
        if (pk == nullptr) {
            NEFORCE_THROW_EXCEPTION(value_exception("sql_mapper: no primary key defined for SELECT BY PK"));
        }
 
        const auto* meta = get_meta();
        sql_builder b;
        b.set_dialect(dialect);
        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(), b.placeholder(1));
        return b.build();
    }
};
 // SQLMapper
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_DATABASE_SQL_MAPPER_HPP__