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:
 *
 *  The UT_ORMField is the C++ object that defines the relationship between the
 *  c++ object member and the database column. The adapter is added to every
 *  field which defines how to bind/load the C++ member to a database value.
 *
 *  In the case of UT_ORMForeignKeyField we can lazy load the underlying model
 *  that the column relates to. This allows us to load the foreign key value
 *  and optionally fetch the related object value at a later time or not at all
 *  depending on our needs at the time.
 *
 *  See UT_SQLORM for more information on the entire system.
 */

#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 "UT_IntrusivePtr.h"

#include <variant>

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

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(
            const 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)
    {
    }
    virtual bool isSame(
            const void* obj_left,
            const void* obj_right,
            UT_ErrorCode& ec) const
            = 0;

    template <typename Cls, typename MemberT>
    void setValue(Cls& obj, const MemberT& member_value, UT_ErrorCode& ec)
    {
        mySetter(this, &obj, &member_value, ec);
    }
    
    template <typename Cls, typename MemberT>
    void getValue(const Cls& obj, MemberT& member_value, UT_ErrorCode& ec)
    {
        myGetter(this, &obj, &member_value, ec);
    }

protected:
    typedef void (*setter_func_t)(
            UT_IORMFieldAdapter* adapter,
            void* obj,
            const void* value,
            UT_ErrorCode& ec);
    typedef void (*getter_func_t)(
            UT_IORMFieldAdapter* adapter,
            const void* obj,
            void* value,
            UT_ErrorCode& ec);

    UT_IORMFieldAdapter(setter_func_t setter, getter_func_t getter)
        : mySetter(setter), myGetter(getter)
    {
    }
    setter_func_t mySetter;
    getter_func_t myGetter;
};

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,
            const UT_StringHolder& related_name = UT_StringHolder::theEmptyString)
        : UT_ORMColumn(name, adapter->sqlType(), props, ondelete)
        , myFieldPtr(std::move(adapter))
    {
    }
    /// This should almost never be called. Its mainly used with dynamic objects
    /// that arent attached to a model but we still want to generate meta
    /// information for migrations and migration validation.
    UT_ORMFieldColumn(
            const UT_StringHolder& name,
            UT_ORMColumn::Type type,
            unsigned props = UT_ORMColumn::Empty,
            UT_ORMColumn::OnDelete ondelete = UT_ORMColumn::OnDelete::DoNothing)
        : UT_ORMColumn(name, type, props, ondelete), myFieldPtr(nullptr)
    {
    }
    UT_IORMFieldAdapter* adapter()
    {
        return myFieldPtr.get();
    }
    UT_IORMFieldAdapter* adapter() const
    {
        return SYSconst_cast(this)->myFieldPtr.get();
    }

    void setAsManyToMany(
            const UT_ORMModelMeta& through_meta,
            const UT_ORMModelMeta& meta,
            const UT_StringHolder& m2m_field_name,
            const UT_ORMModelMeta& foreign_meta,
            const UT_StringHolder& m2m_reverse_field_name,
            const UT_StringHolder& related_name
            = UT_StringHolder::theEmptyString);

    bool verify(UT_SqlOrm* orm, UT_Error& ec, UT_StringHolder& err_msg);

    void connectLinks(const UT_SharedPtr<UT_ORMModelMeta>& meta);

    UT_SharedPtr<UT_ORMModelMeta> foreignModel() const
    {
        return myForeignModel.lock();
    }

    const UT_StringHolder& m2mFieldName() const
    {
        return myM2MFieldName;
    }
    const UT_StringHolder& m2mReverseFieldName() const
    {
        return myM2MReverseFieldName;
    }

protected:
    UT_UniquePtr<UT_IORMFieldAdapter> myFieldPtr;
    UT_StringHolder myThroughModelName;
    UT_WeakPtr<UT_ORMModelMeta> myForeignModel;
    UT_StringHolder myM2MFieldName;
    UT_StringHolder myM2MReverseFieldName;
};

template <typename Cls, typename MemberT>
class UT_ORMBasicFieldAdapter : public UT_IORMFieldAdapter
{
private:
    static void memberSetter(
            UT_IORMFieldAdapter* me,
            void* obj,
            const void* member_value,
            UT_ErrorCode& ec)
    {
        auto value = static_cast<const MemberT*>(member_value);
        static_cast<UT_ORMBasicFieldAdapter<Cls, MemberT>*>(me)->field(obj)
                = *value;
    }
    static void memberGetter(
            UT_IORMFieldAdapter* me,
            const void* obj,
            void* member_value,
            UT_ErrorCode& ec)
    {
        auto value = static_cast<MemberT*>(member_value);
        *value = static_cast<UT_ORMBasicFieldAdapter<Cls, MemberT>*>(me)->field(
                obj);
    }

public:
    using model_t = Cls;
    using field_t = MemberT;

    UT_ORMBasicFieldAdapter(MemberT Cls::*member_ptr) : 
        UT_IORMFieldAdapter(&memberSetter, &memberGetter),
        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(
            const void* obj,
            UT_SqlStatement& stmt,
            int index,
            UT_ErrorCode& ec) override
    {
        const 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); }
    bool isSame(const void* obj_left, const void* obj_right, UT_ErrorCode& ec)
            const final override
    {
        const MemberT& left_value = field(obj_left);
        const MemberT& right_value = field(obj_right);
        return left_value == right_value;
    }

protected:
    MemberT& field(void* obj)
    {
        Cls* cls = static_cast<Cls*>(obj);
        return (cls->*myMemberPtr);
    }
    const MemberT& field(const void* obj) const
    {
        const Cls* cls = static_cast<const 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
{
private:
    struct PointerHolder : public UT_IntrusiveRefCounter<
                                   PointerHolder,
                                   std::default_delete<PointerHolder>,
                                   UT_IntrusiveNonThreadSafeCounterPolicy>
    {
        PointerHolder(const ModelT& m) :
            myModel(m)
        {}
        PointerHolder(ModelT&& m) :
            myModel(std::move(m))
        {}

        ModelT& operator*() { return myModel; }
        ModelT myModel;
    };

public:
    using model_pointer_t = UT_IntrusivePtr<PointerHolder>;
    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->myModel);
    }
    const ModelT* get() const
    {
        return SYSconst_cast(this)->get();
    }

    foreign_key_t id() const
    {
        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>;

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

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

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

    foreign_key_t myID;
    model_pointer_t 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)
        : UT_IORMFieldAdapter(&memberSetter, &memberGetter)
        , myMemberPtr(member_ptr)
    {
    }

    static UT_ORMFieldColumn createColumn(
            const UT_ORMModelMeta& meta,
            const UT_StringHolder& name,
            ForeignKey Cls::*member_ptr,
            unsigned props,
            UT_ORMColumn::OnDelete ondelete,
            const UT_StringHolder& related_name
            = UT_StringHolder::theEmptyString)
    {
        auto adapter
                = UTmakeUnique<UT_ORMForeignKeyFieldAdapter<Cls, ForeignKey>>(
                        member_ptr);
        UT_ORMFieldColumn col(name, std::move(adapter), props);
        col.setAsForeignKey(meta, related_name);
        col.setOnDelete(ondelete);

        return col;
    }

    static void memberSetter(
            UT_IORMFieldAdapter* me,
            void* obj,
            const void* value,
            UT_ErrorCode& ec)
    {
        auto member_value = static_cast<const id_t*>(value);
        static_cast<UT_ORMForeignKeyFieldAdapter<Cls, ForeignKey>*>(me)
                ->field(obj)
                .setId(*member_value);
    }
    static void memberGetter(
            UT_IORMFieldAdapter* me,
            const void* obj,
            void* value,
            UT_ErrorCode& ec)
    {
        auto member_value = static_cast<id_t*>(value);
        *member_value
                = static_cast<UT_ORMForeignKeyFieldAdapter<Cls, ForeignKey>*>(
                          me)
                          ->field(obj)
                          .id();
    }

    UT_ORMColumn::Type sqlType() const override
    {
        return UTsqlOrmColumnType<id_t>();
    }
    void bind(
            const 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();
        }
    }
    bool isSame(const void* obj_left, const void* obj_right, UT_ErrorCode& ec)
            const final override
    {
        const ForeignKey& left = field(obj_left);
        const ForeignKey& right = field(obj_right);
        return left.id() == right.id();
    }

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

private:
    ForeignKey Cls::*myMemberPtr;
};

#endif // __UT_ORMFIELD_H__