UT_ORMOperation.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_ORMOperation.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMOPERATION_H__
#define __UT_ORMOPERATION_H__

#include "UT_API.h"

#include "UT_Array.h"
#include "UT_ErrorCode.h"
#include "UT_ORMColumn.h"
#include "UT_StringHolder.h"
#include "UT_UniquePtr.h"
#include "UT_ORMConstraint.h"
#include "UT_ORMModelState.h"

class UT_WorkBuffer;
class UT_JSONValue;
class UT_ORMMigrationChangeNotifier;
class UT_IORMSchemaEditor;
class UT_ORMMigrationState;

class UT_API UT_IORMOperation
{
public:
    virtual ~UT_IORMOperation() = default;
    UT_IORMOperation(const UT_IORMOperation&) = default;
    UT_IORMOperation& operator=(const UT_IORMOperation&) = default;

    virtual const UT_StringHolder& name() const = 0;
    virtual void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec)
            = 0;
    virtual void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) = 0;

protected:
    UT_IORMOperation() = default;

private:
};

class UT_API UT_ORMCreateTableOperation : public UT_IORMOperation
{
public:
    UT_ORMCreateTableOperation() = default;
    explicit UT_ORMCreateTableOperation(const UT_StringHolder& table_name)
    {
        setTableName(table_name);
    }

    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

    UT_ORMCreateTableOperation& setTableName(const UT_StringHolder& table_name)
    {
        myTableName = table_name;
        return *this;
    }
    UT_ORMCreateTableOperation& addField(UT_ORMModelStateField&& field)
    {
        myFields.emplace_back(std::move(field));
        return *this;
    }
    UT_ORMColumn& addForeignField(
            const UT_StringHolder& name,
            UT_ORMColumn::Type type,
            const UT_StringHolder& foreign_table,
            const UT_StringHolder& foreign_col,
            unsigned props = UT_ORMColumn::Properties::Empty,
            UT_ORMColumn::OnDelete ondelete = UT_ORMColumn::OnDelete::Cascade)
    {
        UT_ORMModelStateField field(name, type, props);
        // The migration columns dont need the type since we only care about the
        // actual table names for this.
        field.setAsForeignKey(
                foreign_table, foreign_table, foreign_col, ondelete);
        exint i = myFields.emplace_back(std::move(field));
        return myFields[i];
    }
    UT_ORMColumn& addField(
            const UT_StringHolder& name,
            UT_ORMColumn::Type type,
            UT_ORMColumn::Properties props = UT_ORMColumn::Properties::Empty)
    {
        exint i = myFields.emplace_back(name, type, props);
        return myFields[i];
    }
    UT_ORMColumn& addAutoField(
            const UT_StringHolder& name,
            UT_ORMColumn::Type type,
            UT_ORMColumn::Properties props = UT_ORMColumn::Properties::Empty)
    {
        exint i = myFields.emplace_back(
                name, type, props | UT_ORMColumn::Properties::AutoIncrement);
        return myFields[i];
    }

private:
    UT_StringHolder myTableName;
    UT_Array<UT_ORMModelStateField> myFields;
};

class UT_API UT_ORMDropTableOperation : public UT_IORMOperation
{
public:
    UT_ORMDropTableOperation() = default;
    explicit UT_ORMDropTableOperation(const UT_StringHolder& model_name)
    {
        setModelName(model_name);
    }

    void setModelName(const UT_StringHolder& model_name)
    {
        myModelName = model_name;
    }
    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

private:
    UT_StringHolder myModelName;
};

class UT_API UT_ORMRenameModelOperation : public UT_IORMOperation
{
public:
    UT_ORMRenameModelOperation() = default;
    UT_ORMRenameModelOperation(
            const UT_StringHolder& old_model,
            const UT_StringHolder& new_model)
        : myOldModelName(old_model), myNewModelName(new_model)
    {
    }

    void setModel(
            const UT_StringHolder& old_model,
            const UT_StringHolder& new_model)
    {
        myOldModelName = old_model;
        myNewModelName = new_model;
    }

    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

    const UT_StringHolder& oldModelName() const { return myOldModelName; }
    const UT_StringHolder& newModelName() const { return myNewModelName; }
private:
    UT_StringHolder myOldModelName;
    UT_StringHolder myNewModelName;
};

class UT_API UT_ORMAddFieldOperation : public UT_IORMOperation
{
public:
    UT_ORMAddFieldOperation() = default;
    explicit UT_ORMAddFieldOperation(
            const UT_StringHolder& model_name,
            UT_ORMModelStateField&& field)
    {
        setField(model_name, std::move(field));
    }

    void setField(
            const UT_StringHolder& model_name,
            UT_ORMModelStateField&& field)
    {
        myModelName = model_name;
        myField = std::move(field);
    }
    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec)
            override;

private:
    UT_StringHolder myModelName;
    UT_ORMModelStateField myField;
};

class UT_API UT_ORMRemoveFieldOperation : public UT_IORMOperation
{
public:
    UT_ORMRemoveFieldOperation() = default;
    explicit UT_ORMRemoveFieldOperation(
            const UT_StringHolder& model_name,
            const UT_StringHolder& field_name)
    {
        setField(model_name, field_name);
    }

    void setField(
            const UT_StringHolder& model_name,
            const UT_StringHolder& field_name)
    {
        myModelName = model_name;
        myFieldName = field_name;
    }
    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

private:
    UT_StringHolder myModelName;
    UT_StringHolder myFieldName;
};

class UT_API UT_ORMRenameFieldOperation : public UT_IORMOperation
{
public:
    UT_ORMRenameFieldOperation() = default;
    explicit UT_ORMRenameFieldOperation(
            const UT_StringHolder& model_name,
            const UT_StringHolder& from_name,
            const UT_StringHolder& to_name)
    {
        setField(model_name, from_name, to_name);
    }

    void setField(
            const UT_StringHolder& model_name,
            const UT_StringHolder& from_name,
            const UT_StringHolder& to_name)
    {
        myModelName = model_name;
        myFromName = from_name;
        myToName = to_name;
    }
    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

private:
    UT_StringHolder myModelName;
    UT_StringHolder myFromName;
    UT_StringHolder myToName;
};

class UT_API UT_ORMAddConstraintOperation : public UT_IORMOperation
{
public:
    UT_ORMAddConstraintOperation() = default;
    explicit UT_ORMAddConstraintOperation(
            const UT_StringHolder& model_name,
            UT_UniquePtr<UT_IORMConstraint>&& constraint)
    {
        setConstraint(model_name, std::move(constraint));
    }

    void setConstraint(
            const UT_StringHolder& model_name,
            UT_UniquePtr<UT_IORMConstraint> constraint)
    {
        myModelName = model_name;
        myConstraint = std::move(constraint);
    }
    const UT_StringHolder& name() const override;
    void databaseForwards(
            UT_IORMSchemaEditor& editor,
            const UT_ORMMigrationState& from_state,
            const UT_ORMMigrationState& to_state,
            UT_ErrorCode& ec) override;
    void stateForwards(UT_ORMMigrationState& state, UT_ErrorCode& ec) override;

private:
    UT_StringHolder myModelName;
    UT_UniquePtr<UT_IORMConstraint> myConstraint;
};

#endif // __UT_ORMOPERATION_H__