UT_ORMDDLReference.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_ORMDDLReference.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMDDLREFERENCE_H__
#define __UT_ORMDDLREFERENCE_H__

#include "UT_API.h"

#include "UT_ArrayStringMap.h"
#include "UT_Function.h"
#include "UT_NonCopyable.h"
#include "UT_StringArray.h"
#include "UT_StringHolder.h"
#include "UT_UniquePtr.h"
#include "UT_WorkBuffer.h"

class UT_IORMDDLReference;

class UT_ORMDDLTemplate
{
public:
    explicit UT_ORMDDLTemplate(const UT_StringHolder& ddl_template) :
        myDDLTemplate(ddl_template)
    {}

    // Replace a single item from the template. This is mainly helpful in cases
    // where under certain circumstances we dont need a ddl reference and can
    // swap the condition immediately. Generally generate() should be called to
    // build the entire template given the references.
    void replace(const UT_StringView& key, const UT_StringHolder& string);
    UT_StringHolder generate(
            const UT_ArrayStringMap<UT_UniquePtr<UT_IORMDDLReference>>&
                    ddl_references) const;

private:
    using ddl_replace_func_t = UT_Function<std::pair<bool, UT_StringHolder>(
            const UT_StringView&)>;
    UT_StringHolder generate_(
            const ddl_replace_func_t& func,
            const UT_StringHolder& replace_key) const;

    UT_StringHolder myDDLTemplate;
};

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

    virtual bool referencesTable(const UT_StringHolder& table) const
    {
        return false;
    }
    virtual bool referencesColumn(
            const UT_StringHolder& table,
            const UT_StringHolder& column) const
    {
        return false;
    }
    virtual void renameTableReferences(
            const UT_StringHolder& old_table,
            const UT_StringHolder& new_table)
    {
    }
    virtual void renameColumnReferences(
            const UT_StringHolder& table,
            const UT_StringHolder& old_column,
            const UT_StringHolder& new_column)
    {
    }
    virtual UT_StringHolder toString() const = 0;

protected:
    UT_IORMDDLReference() = default;
};

class UT_API UT_ORMDDLTableReference : public UT_IORMDDLReference
{
public:
    UT_ORMDDLTableReference(const UT_StringHolder& table) :
        myTableName(table)
    {}

    bool referencesTable(const UT_StringHolder& table) const override
    {
        return myTableName == table;
    }

    void renameTableReferences(
            const UT_StringHolder& old_table,
            const UT_StringHolder& new_table) override
    {
        if (myTableName == old_table)
            myTableName = new_table;
    }

    UT_StringHolder toString() const override
    {
        return myTableName;
    }

protected:
    UT_StringHolder myTableName;
};

class UT_API UT_ORMDDLBaseTableColumnsReference : public UT_ORMDDLTableReference
{
public:

    bool referencesColumn(
            const UT_StringHolder& table,
            const UT_StringHolder& column) const override
    {
        return myTableName == table && hasColumn_(column);
    }

    void renameColumnReferences(
            const UT_StringHolder& table,
            const UT_StringHolder& old_column,
            const UT_StringHolder& new_column) override
    {
        if (myTableName == table)
        {
            // Its possible that a specific column is referenced multiple times
            // so we cant exit on first match
            for (int i = myColumns.size(); i-- > 0;)
            {
                if (myColumns[i] == old_column)
                {
                    myColumns[i] = new_column;
                }
            }
        }
    }

protected:
    UT_ORMDDLBaseTableColumnsReference(
            const UT_StringHolder& table,
            const UT_StringArray& columns)
        : UT_ORMDDLTableReference(table), myColumns(columns)
    {
    }

    bool hasColumn_(const UT_StringRef& column) const
    {
        for (auto&& col : myColumns)
        {
            if (col == column)
                return true;
        }
        return false;
    }

    UT_StringArray myColumns;
};

class UT_API UT_ORMDDLColumnsReference
    : public UT_ORMDDLBaseTableColumnsReference
{
public:
    UT_ORMDDLColumnsReference(
            const UT_StringHolder& table,
            const UT_StringArray& columns,
            const UT_StringArray& column_suffixes = UT_StringArray{})
        : UT_ORMDDLBaseTableColumnsReference(table, columns)
        , myColumnSuffixes(column_suffixes)
    {
    }

    UT_StringHolder toString() const override
    {
        UT_WorkBuffer wbuf;

        for (int i = 0, s = myColumnSuffixes.size(); i < s; i++)
        {
            if (i != 0)
                wbuf.append(',');
            wbuf.append(myColumns[i]);
            if (i < myColumnSuffixes.size())
                wbuf.append(myColumnSuffixes[i]);
        }

        return wbuf;
    }

protected:
    UT_StringArray myColumnSuffixes;
};

class UT_API UT_ORMForeignKeyNameReference
    : public UT_ORMDDLBaseTableColumnsReference
{
public:
    using create_fk_name_t = UT_Function<
            UT_StringHolder(const UT_StringHolder&, const UT_StringArray&)>;

    UT_ORMForeignKeyNameReference(
            const UT_StringHolder& from_table,
            const UT_StringArray& from_columns,
            const UT_StringHolder& to_table,
            const UT_StringArray& to_columns,
            create_fk_name_t&& create_fk_name)
        : UT_ORMDDLBaseTableColumnsReference(from_table, from_columns)
        , myToReference(to_table, to_columns)
        , myCreateFKName(create_fk_name)
    {
    }

    bool referencesTable(const UT_StringHolder& table) const override
    {
        return UT_ORMDDLBaseTableColumnsReference::referencesTable(table)
               || myToReference.referencesTable(table);
    }

    bool referencesColumn(
            const UT_StringHolder& table,
            const UT_StringHolder& column) const override
    {
        return UT_ORMDDLBaseTableColumnsReference::referencesColumn(
                       table, column)
               || myToReference.referencesColumn(table, column);
    }

    void renameTableReferences(
            const UT_StringHolder& old_table,
            const UT_StringHolder& new_table) override
    {
        UT_ORMDDLBaseTableColumnsReference::renameTableReferences(
                old_table, new_table);
        myToReference.renameTableReferences(old_table, new_table);
    }

    void renameColumnReferences(
            const UT_StringHolder& table,
            const UT_StringHolder& old_column,
            const UT_StringHolder& new_column) override
    {
        UT_ORMDDLBaseTableColumnsReference::renameColumnReferences(
                table, old_column, new_column);
        myToReference.renameColumnReferences(table, old_column, new_column);
    }

    UT_StringHolder toString() const override
    {
        return myCreateFKName(myTableName, myColumns);
    }

protected:
    create_fk_name_t myCreateFKName;
    UT_ORMDDLColumnsReference myToReference;
};

class UT_API UT_ORMDDLStatement : public UT_IORMDDLReference
{
public:
    using ddl_ref_map_t = UT_ArrayStringMap<UT_UniquePtr<UT_IORMDDLReference>>;

    UT_ORMDDLStatement(
            const UT_ORMDDLTemplate& ddl_template,
            ddl_ref_map_t&& refs)
        : myDDLTemplate(ddl_template), myReferences(std::move(refs))
    {}
    UT_ORMDDLStatement(const UT_ORMDDLTemplate& ddl_template) :
        myDDLTemplate(ddl_template)
    {}
    ~UT_ORMDDLStatement() override = default;
    UT_NON_COPYABLE(UT_ORMDDLStatement);

    bool referencesTable(const UT_StringHolder& table) const override
    {
        for (auto&& [key, part] : myReferences)
        {
            if (part->referencesTable(table))
                return true;
        }
        return false;
    }

    bool referencesColumn(
            const UT_StringHolder& table,
            const UT_StringHolder& column) const override
    {
        for (auto&& [key, part] : myReferences)
        {
            if (part->referencesColumn(table, column))
                return true;
        }
        return false;
    }

    void renameTableReferences(
            const UT_StringHolder& old_table,
            const UT_StringHolder& new_table) override
    {
        for (auto&& [key, part] : myReferences)
        {
            part->renameTableReferences(old_table, new_table);
        }
    }

    void renameColumnReferences(
            const UT_StringHolder& table,
            const UT_StringHolder& old_column,
            const UT_StringHolder& new_column) override
    {
        for (auto&& [key, part] : myReferences)
        {
            part->renameColumnReferences(table, old_column, new_column);
        }
    }

    UT_StringHolder toString() const override
    {
        return myDDLTemplate.generate(myReferences);
    }

private:
    UT_ORMDDLTemplate myDDLTemplate;
    ddl_ref_map_t myReferences;
};

#endif // __UT_ORMDDLREFERENCE_H__