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"

class UT_SqlStatement;

class UT_API UT_ORMColumn
{
public:
    enum class Type
    {
        Error,
        Nullptr,
        String,
        Int32,
        Int64,
        Bool,
        Real,
        DateTime,
        Blob
    };

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

    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)
               || (myProperties & Properties::Unique);
    }
    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;
    }

    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;
    static const UT_StringHolder& typeToString(Type type);

    bool isForeignKey() const { return myProperties & Properties::ForeignKey; }
    void setAsForeignKey(
            const UT_StringHolder& table_name,
            const UT_StringHolder& col)
    {
        myProperties |= ForeignKey;
        myForeignTable = table_name;
        myForeignColumns.clear();
        myForeignColumns.emplace_back(col);
    }
    void setAsForeignKey(
            const UT_StringHolder& table_name,
            const UT_StringArray& cols)
    {
        myProperties |= ForeignKey;
        myForeignTable = table_name;
        myForeignColumns = cols;
    }
    const UT_StringHolder& foreignTable() const { return myForeignTable; }
    const UT_StringArray& foreignColumns() const { return myForeignColumns; }

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

    UT_StringHolder myForeignTable;
    UT_StringArray myForeignColumns;
};

template <typename T>
UT_ORMColumn::Type
UTsqlOrmColumnType()
{
    return UT_ORMColumn::Type::Error;
}


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__