UT_ORMMigrationBuilder.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_ORMMigrationBuilder.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMMIGRATIONBUILDER_H__
#define __UT_ORMMIGRATIONBUILDER_H__

#include "UT_API.h"

#include "UT_StringHolder.h"
#include "UT_Array.h"
#include "UT_UniquePtr.h"
#include "UT_Map.h"
#include "UT_NonCopyable.h"
#include "UT_ORMColumn.h"
#include "UT_ErrorCode.h"

class UT_IORMOperation;
class UT_ORMCreateTableOperation;
class UT_ORMDropTableOperation;
class UT_ORMAddFieldOperation;
class UT_ORMRenameFieldOperation;
class UT_ORMRemoveFieldOperation;
class UT_ORMMigrationBuilder;
class UT_ORMModelMeta;
class UT_ORMMigrationResult;

namespace UT
{
enum class OrmMigError
{
    UT_MIG_OK,
    UT_MIG_MISSING_FIELD,
    UT_MIG_MISSING_MODEL,
    UT_MIG_FIELD_ALREADY_EXISTS,
    UT_MIG_MODEL_MISSING,
    UT_MIG_MODEL_ALREADY_EXISTS
};

UT_API const UT_ErrorCategory& GetOrmMigErrorCategory();

inline UT_ErrorCode
make_error_code(UT::OrmMigError e)
{
    return UT_ErrorCode{static_cast<int>(e), GetOrmMigErrorCategory()};
}
} // namespace UT

namespace std
{
template <>
struct is_error_code_enum<UT::OrmMigError> : true_type
{
};
} // namespace std

class UT_ORMMigrationChangeNotifier
{
public:
    UT_ORMMigrationChangeNotifier(UT_ORMMigrationBuilder& builder)
        : myBuilder(builder)
    {
    }
    ~UT_ORMMigrationChangeNotifier() = default;
    UT_NON_COPYABLE(UT_ORMMigrationChangeNotifier);

    void createModel(
            const UT_StringHolder& table_name,
            const UT_Array<UT_ORMColumn>& columns,
            UT_ErrorCode& ec);
    void dropModel(const UT_StringRef& table_name, UT_ErrorCode& ec);
    void addField(
            const UT_StringRef& model_name,
            const UT_ORMColumn& col,
            UT_ErrorCode& ec);
    void renameField(
            const UT_StringRef& model_name,
            const UT_StringRef& cur_name,
            const UT_StringHolder& new_name,
            UT_ErrorCode& ec);
    void removeField(
            const UT_StringRef& model_name,
            const UT_StringRef& name,
            UT_ErrorCode& ec);

private:
    UT_ORMMigrationBuilder& myBuilder;
};

class UT_API UT_ORMMigration
{
public:
    explicit UT_ORMMigration(
            const UT_StringHolder& model_name,
            const UT_StringHolder& name)
        : myModelName(model_name), myName(name)
    {
    }
    ~UT_ORMMigration() = default;
    UT_NON_COPYABLE(UT_ORMMigration);

    UT_ORMCreateTableOperation& createModel(const UT_StringHolder& table_name);
    UT_ORMDropTableOperation& dropModel(const UT_StringHolder& table_name);
    UT_ORMAddFieldOperation& addField(
            const UT_StringHolder& model_name,
            UT_ORMColumn&& col);
    UT_ORMRenameFieldOperation& renameField(
            const UT_StringHolder& model_name,
            const UT_StringHolder& cur_name,
            const UT_StringHolder& new_name);
    UT_ORMRemoveFieldOperation& removeField(
            const UT_StringHolder& model_name,
            const UT_StringHolder& name);

    const UT_StringHolder myModelName;
    const UT_StringHolder myName;
    UT_Array<UT_UniquePtr<UT_IORMOperation>> myOperations;
};

class UT_API UT_ORMMigrationBuilder
{
public:
    struct Model
    {
        UT_StringHolder myName;
        UT_Array<UT_ORMColumn> myFields;
    };

    UT_ORMMigrationBuilder() = default;
    UT_NON_COPYABLE(UT_ORMMigrationBuilder);
    ~UT_ORMMigrationBuilder();

    bool hasModel(const UT_StringRef& name);

    UT_ORMMigration& addMigration(
            const UT_StringHolder& table_name,
            const UT_StringHolder& name);

    UT_Map<UT_StringHolder, Model>& models() { return myModels; }
    const UT_Map<UT_StringHolder, Model>& models() const { return myModels; }

    const UT_Array<UT_ORMMigration>& migrations() const { return myMigrations; }

    const UT_Array<const UT_ORMModelMeta*>& registeredModelMetas() const
    {
        return myRegisteredMetas;
    }
    void registerModelMeta(const UT_ORMModelMeta* meta)
    {
        myRegisteredMetas.emplace_back(meta);
    }

private:
    friend class UT_ORMMigration;
    friend class UT_ORMMigrationChangeNotifier;

    void createModel_(
            const UT_StringHolder& table_name,
            const UT_Array<UT_ORMColumn>& cols,
            UT_ErrorCode& ec);
    void dropModel_(const UT_StringRef& table_name, UT_ErrorCode& ec);
    void addField_(
            const UT_StringRef& model_name,
            const UT_ORMColumn& field,
            UT_ErrorCode& ec);
    void renameField_(
            const UT_StringRef& model_name,
            const UT_StringRef& cur_name,
            const UT_StringHolder& new_name,
            UT_ErrorCode& ec);
    void removeField_(
            const UT_StringRef& model_name,
            const UT_StringRef& name,
            UT_ErrorCode& ec);

    UT_Array<const UT_ORMModelMeta*> myRegisteredMetas;
    UT_Map<UT_StringHolder, Model> myModels;
    UT_Array<UT_ORMMigration> myMigrations;
};

#endif // __UT_ORMMIGRATIONBUILDER_H__