UT_ORMColumn.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_ORMColumn.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMCOLUMN_H__
#define __UT_ORMCOLUMN_H__

#include "UT_API.h"

#include "UT_StringArray.h"
#include "UT_StringHolder.h"
#include "UT_DateTimeField.h"
#include "UT_ORMColumnType.h"
#include "UT_SharedPtr.h"

class UT_SqlStatement;
class UT_ORMModelMeta;

class UT_API UT_ORMColumn
{
public:
    using Type = UT_ORMColumnType;

    enum Properties
    {
        Empty = 0,
        PrimaryKey = 1 << 1,
        Unique = 1 << 2,
        NotNull = 1 << 3,
        ForeignKey = 1 << 4,
        AutoIncrement = 1 << 5,
        ManyToMany = 1 << 6
    };

    enum OnDelete
    {
        DoNothing = 0,
        Cascade,
        SetNull
    };

    UT_ORMColumn() = default;
    UT_ORMColumn(
            const UT_StringHolder& name,
            Type type,
            unsigned props = Properties::Empty,
            OnDelete on_delete = OnDelete::DoNothing)
        : myName(name), myType(type), myProperties(props), myOnDelete(on_delete)
    {
    }

    bool operator==(const UT_ORMColumn& rhs) const
    {
        return myName == rhs.myName && myType == rhs.myType
               && myProperties == rhs.myProperties &&
               myOnDelete == rhs.myOnDelete;
    }
    bool operator!=(const UT_ORMColumn& rhs) const { return !(*this == rhs); }

    void sql(const UT_SqlStatement& stmt, UT_WorkBuffer& wbuf);

    Type type() const { return myType; }
    UT_ORMColumn& setName(const UT_StringHolder& name)
    {
        myName = name;
        return *this;
    }
    const UT_StringHolder& name() const { return myName; }
    UT_ORMColumn& setNotNull(bool not_null)
    {
        if (not_null)
            myProperties |= Properties::NotNull;
        else
            myProperties &= ~Properties::NotNull;
        return *this;
    }
    bool isNotNull() const { return myProperties & Properties::NotNull; }
    UT_ORMColumn& setPrimaryKey(bool pk)
    {
        if (pk)
            myProperties |= Properties::PrimaryKey;
        else
            myProperties &= ~Properties::PrimaryKey;
        return *this;
    }
    bool isPrimaryKey() const
    {
        return myProperties & Properties::PrimaryKey;
    }
    UT_ORMColumn& setUnique(bool upk)
    {
        if (upk)
            myProperties |= Properties::Unique;
        else
            myProperties &= ~Properties::Unique;
        return *this;
    }
    bool isUnique() const { return myProperties & Properties::Unique; }
    UT_ORMColumn& setAutoIncrement(bool inc)
    {
        if (inc)
            myProperties |= Properties::AutoIncrement;
        else
            myProperties &= ~Properties::AutoIncrement;
        return *this;
    }
    bool isAutoIncrement() const
    {
        return myProperties & Properties::AutoIncrement;
    }
    bool isTableColumn() const { return !isManyToMany(); }
    bool isLocal() const { return !isManyToMany() && !isForeignKey(); }

    unsigned properties() const { return myProperties; }

    OnDelete onDelete() const { return myOnDelete; }
    void setOnDelete(OnDelete ondelete) { myOnDelete = ondelete; }

    const UT_StringHolder& typeString(const UT_SqlStatement& cursor) const;
    /// This is only a humar readable label. If you want the actual typename
    /// you have to use UT_SqlStatement as the underlying typename may be
    /// different for various sql backends.
    static const UT_StringHolder& typeToDisplayName(Type type);

    bool isForeignKey() const { return myProperties & Properties::ForeignKey; }
    bool isManyToMany() const { return myProperties & Properties::ManyToMany; }
    void setAsForeignKey(
            const UT_StringHolder& foreign_model,
            const UT_StringHolder& table_name,
            const UT_StringHolder& col,
            UT_ORMColumn::OnDelete ondelete = UT_ORMColumn::OnDelete::Cascade,
            const UT_StringHolder& related_name = UT_StringHolder::theEmptyString)
    {
        myProperties |= ForeignKey;
        myForeignModelName = foreign_model;
        myForeignTable = table_name;
        myForeignColumns.clear();
        myForeignColumns.emplace_back(col);
        myOnDelete = ondelete;
        setRelatedName(related_name);
    }
    void setAsForeignKey(
            const UT_StringHolder& foreign_model,
            const UT_StringHolder& table_name,
            const UT_StringArray& cols,
            UT_ORMColumn::OnDelete ondelete = UT_ORMColumn::OnDelete::Cascade,
            const UT_StringHolder& related_name = UT_StringHolder::theEmptyString)
    {
        myProperties |= ForeignKey;
        myForeignModelName = foreign_model;
        myForeignTable = table_name;
        myForeignColumns = cols;
        myOnDelete = ondelete;
        setRelatedName(related_name);
    }
    void setAsForeignKey(
            const UT_ORMModelMeta& meta,
            const UT_StringHolder& col = UT_StringHolder::theEmptyString,
            UT_ORMColumn::OnDelete = UT_ORMColumn::OnDelete::Cascade,
            const UT_StringHolder& related_name = UT_StringHolder::theEmptyString);
    const UT_StringHolder& foreignTable() const { return myForeignTable; }
    const UT_StringHolder& foreignTableModelName() const
    {
        return myForeignModelName;
    }
    const UT_StringHolder& foreignFieldName() const
    {
        return myForeignColumns[0];
    }
    const UT_StringArray& foreignColumns() const { return myForeignColumns; }
    bool isForeignKeyToModel(const UT_ORMModelMeta& model) const;
    void setRelatedName(const UT_StringHolder& related);
    const UT_StringHolder& relatedName() const { return myRelated; }

protected:
    unsigned myProperties = Properties::Empty;
    OnDelete myOnDelete = OnDelete::DoNothing;
    Type myType;
    UT_StringHolder myName;

    UT_StringHolder myForeignTable;
    UT_StringHolder myForeignModelName;
    UT_StringArray myForeignColumns;
    UT_StringHolder myRelated;
};

template <>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<int>()
{
    return UT_ORMColumn::Type::Int32;
}
template <>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<int64>()
{
    return UT_ORMColumn::Type::Int64;
}
template <>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<UT_StringHolder>()
{
    return UT_ORMColumn::Type::String;
}
template <>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<const char*>()
{
    return UT_ORMColumn::Type::String;
}

template<>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<bool>()
{
    return UT_ORMColumn::Type::Bool;
}

template<>
inline UT_ORMColumn::Type
UTsqlOrmColumnType<UT_DateTimeField>()
{
    return UT_ORMColumn::Type::DateTime;
}

#endif // __UT_ORMCOLUMN_H__