UT_ORMField.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_ORMField.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMFIELD_H__
#define __UT_ORMFIELD_H__

#include "UT_API.h"

#include "UT_StringHolder.h"
#include "UT_ErrorCode.h"
#include "UT_DateTimeField.h"
#include "UT_WorkBuffer.h"
#include "UT_SQL.h"
#include "UT_Array.h"
#include "UT_Optional.h"
#include "UT_SGuid.h"
#include "UT_ORMColumn.h"

#include <variant>

class UT_JSONValue;
class UT_SqlStatement;
class UT_SqlOrm;
class UT_ORMColumn;

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

    virtual UT_ORMColumn::Type sqlType() const = 0;
    virtual void bind(
            void* obj,
            UT_SqlStatement& cursor,
            int bind_index,
            UT_ErrorCode& ec)
            = 0;
    virtual void load(
            void* obj,
            UT_SqlStatement& cursor,
            int index,
            UT_ErrorCode& ec)
            = 0;
    virtual void onDelete(
            void* obj,
            UT_ORMColumn::OnDelete ondelete,
            UT_ErrorCode& ec)
    {
    }

protected:
    UT_IORMFieldAdapter() = default;
};

class UT_API UT_ORMFieldColumn : public UT_ORMColumn
{
public:
    UT_ORMFieldColumn(
            const UT_StringHolder& name,
            UT_UniquePtr<UT_IORMFieldAdapter> adapter,
            unsigned props = UT_ORMColumn::Properties::Empty,
            UT_ORMColumn::OnDelete ondelete = UT_ORMColumn::OnDelete::DoNothing)
        : UT_ORMColumn(name, adapter->sqlType(), props, ondelete)
        , myFieldPtr(std::move(adapter))
    {
    }
    UT_IORMFieldAdapter* adapter()
    {
        return myFieldPtr.get();
    }
    UT_IORMFieldAdapter* adapter() const
    {
        return SYSconst_cast(this)->myFieldPtr.get();
    }
protected:
    UT_UniquePtr<UT_IORMFieldAdapter> myFieldPtr;
};

template <typename Cls, typename MemberT>
class UT_ORMBasicFieldAdapter : public UT_IORMFieldAdapter
{
public: 
    using model_t = Cls;
    using field_t = MemberT;

    UT_ORMBasicFieldAdapter(MemberT Cls::*member_ptr) : myMemberPtr(member_ptr)
    {
    }

    static UT_ORMFieldColumn createColumn(
            const UT_StringHolder& name,
            MemberT Cls::*member_ptr,
            unsigned props)
    {
        auto adapter = UTmakeUnique<UT_ORMBasicFieldAdapter<Cls, MemberT>>(
                member_ptr);
        UT_ORMFieldColumn col(name, std::move(adapter), props);
        return col;
    }

    UT_ORMColumn::Type sqlType() const override
    {
        return UTsqlOrmColumnType<MemberT>();
    }
    void bind(void* obj, UT_SqlStatement& stmt, int index, UT_ErrorCode& ec)
            override
    {
        MemberT& v = this->field(obj);
        stmt.bind(index, v);
        ec = stmt.getError();
    }
    void load(void* obj, UT_SqlStatement& stmt, int index, UT_ErrorCode& ec)
            override
    {
        MemberT& v = this->field(obj);
        v = stmt.get<MemberT>(index);
        ec = stmt.getError();
    }
    void setValue(void* obj, const MemberT& t)
    {
        field(obj) = t;
    }
    MemberT& getValue(void* obj)
    {
        return field(obj);
    }

protected:
    MemberT& field(void* obj)
    {
        Cls* cls = static_cast<Cls*>(obj);
        return (cls->*myMemberPtr);
    }

private:
    MemberT Cls::*myMemberPtr;

};
template <typename Cls>
using UT_ORMStringFieldAdapter = UT_ORMBasicFieldAdapter<Cls, UT_StringHolder>;
template <typename Cls>
using UT_ORMInt32FieldAdapter = UT_ORMBasicFieldAdapter<Cls, int32>;
template <typename Cls>
using UT_ORMInt64FieldAdapter = UT_ORMBasicFieldAdapter<Cls, int64>;
template <typename Cls>
using UT_ORMBoolFieldAdapter = UT_ORMBasicFieldAdapter<Cls, bool>;

template <typename ModelT>
class UT_ORMForeignKeyField
{
public:
    using model_t = ModelT;
    using foreign_key_t = typename ModelT::Meta::primary_key_t;

    UT_ORMForeignKeyField() = default;
    UT_ORMForeignKeyField(foreign_key_t pk) :
        myID(pk)
    {}

    bool operator==(const UT_ORMForeignKeyField& rhs) const
    {
        return myID == rhs.myID;
    }
    bool operator!=(const UT_ORMForeignKeyField& rhs) const
    {
        return !(*this == rhs);
    }

    ModelT* get()
    {
        if (!myValue)
        {
            UT_ErrorCode ec;
            load_(ec);
        }
        UT_ASSERT(myValue);
        return myValue.get();
    }

    foreign_key_t id()
    {
        return myID;
    }
    void setId(const foreign_key_t& id)
    {
        myID = id;
        myValue.reset();
    }
    void setValue(const ModelT& value)
    {
        using foreign_field_t = UT_ORMBasicFieldAdapter<ModelT, foreign_key_t>;

        auto&& meta = ModelT::metaInfo();
        UT_ErrorCode ec;
        UT_IORMFieldAdapter* adapter = meta.primaryKey()->adapter();
        if (auto fadp = dynamic_cast<foreign_field_t*>(adapter); fadp)
        {
            myID = fadp->getValue(SYSconst_cast(&value));
            myValue = UTmakeUnique<ModelT>(value);
        }
    }

    void clear()
    {
        myID = foreign_key_t();
        myValue.reset();
    }

private:
    void load_(UT_ErrorCode &ec)
    {
        if (auto&& opt = ModelT::fetch(myID, ec); opt)
        {
            myValue = UTmakeUnique<ModelT>(opt.value());
        }
    }

    foreign_key_t myID;
    UT_UniquePtr<ModelT> myValue;
};

template <typename Cls, typename ForeignKey>
class UT_ORMForeignKeyFieldAdapter : public UT_IORMFieldAdapter
{
public:
    using model_t = typename ForeignKey::model_t;
    using field_t = ForeignKey;
    using id_t = typename ForeignKey::foreign_key_t;

    UT_ORMForeignKeyFieldAdapter(ForeignKey Cls::*member_ptr)
        : myMemberPtr(member_ptr)
    {}

    static UT_ORMFieldColumn createColumn(
            const UT_StringHolder& name,
            ForeignKey Cls::*member_ptr,
            unsigned props,
            UT_ORMColumn::OnDelete ondelete)
    {
        auto&& meta = model_t::metaInfo();
        const UT_ORMFieldColumn* pk_col = meta.primaryKey();

        auto adapter
                = UTmakeUnique<UT_ORMForeignKeyFieldAdapter<Cls, ForeignKey>>(
                        member_ptr);
        UT_ORMFieldColumn col(name, std::move(adapter), props);
        col.setAsForeignKey(meta.tableName(), pk_col->name());
        col.setOnDelete(ondelete);

        return col;
    }

    UT_ORMColumn::Type sqlType() const override
    {
        return UTsqlOrmColumnType<id_t>();
    }
    void bind(
            void* obj,
            UT_SqlStatement& stmt,
            int bind_index,
            UT_ErrorCode& ec) override
    {
        stmt.bind(bind_index, field(obj).id());
        ec = stmt.getError();
    }
    void load(void* obj, UT_SqlStatement& stmt, int index, UT_ErrorCode& ec)
            override
    {
        field(obj).setId(stmt.get<id_t>(index));
        ec = stmt.getError();
    }
    void onDelete(void* obj, UT_ORMColumn::OnDelete ondelete, UT_ErrorCode& ec)
            override
    {
        if (ondelete != UT_ORMColumn::OnDelete::DoNothing)
        {
            ForeignKey& f = field(obj);
            f.clear();
        }
    }

protected:
    ForeignKey& field(void* obj)
    {
        Cls* cls = static_cast<Cls*>(obj);
        return (cls->*myMemberPtr);
    }

private:
    ForeignKey Cls::*myMemberPtr;
};

#endif // __UT_ORMFIELD_H__