UT_ORMQuerySet.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_ORMQuerySet.h
 *
 * COMMENTS:
 *
 *      The UT_ORMQuerySet is a powerful object that lets the developer create
 *      complex sql queries without having to worry about any of the underlying
 *      sql.
 *
 *      The provided model meta object is the model the query set acts on.
 *      Joining two tables occurs when the query set notices a foreign
 *      relationship based on the provided filter(s). For example, if there
 *      was a User model with m2m relationships to a Group model and that
 *      Group model has a m2m relationship to a Permission model. If the
 *      filter was was Permission.filter({"group__in", user_groups}) then the
 *      query set would recognize there is a foreign relationship between
 *      groups and permissions and a inner join would be required.
 *
 *      Generally speaking most queries can be performed through the object
 *      as this will aditionally update and flags and signals registered.
 *
 *      See UT_SQLORM for an explanation on the ORM system.
 *
 *      Example:
 *          * UT_ORMQuerySet(User).filter({"username"_f="myuser"}).get() will
 *          return a user with username "myuser".
 *          * UT_ORMQuerySet(Session).filter({"expiry__lt"_f=123}).get() will
 *          return any session with an expiry less than 123.
 *          * UT_ORMQuerySet(User).filter({UT::orm::FilterArg("email", School::metaInfo().primaryKey(), &school)}).get()
 *          returns any user with email equal to the schools pk (email in this example).
 *
 *      Currently supported operators
 *      - `eq` (==)
 *      - `gt` (>)
 *      - `gte` (>=) 
 *      - `lt` (<)
 *      - `lte` (<=)
 *      - `in` (IN): means the left must be in the provided list.
 */

#ifndef __UT_ORMQUERYSET_H__
#define __UT_ORMQUERYSET_H__

#include "UT_API.h"

#include "UT_ORMError.h"
#include "UT_SharedPtr.h"
#include "UT_StringSet.h"
#include "UT_ErrorCode.h"
#include "UT_SQL.h"
#include "UT_StringArray.h"
#include "UT_ORMField.h"

class UT_ORMQuerySet;
class UT_SqlOrm;
class UT_ORMModelMeta;

namespace UT::detail
{
template <typename T>
struct is_obj_container
{
    static bool const value = false;
};
template <typename T>
struct is_obj_container<UT_Array<T>>
{
    static bool const value = true;
};
template <>
struct is_obj_container<UT_StringArray>
{
    static bool const value = true;
};
template <>
struct is_obj_container<UT_ArrayStringSet>
{
    static bool const value = true;
};
};

class ut_QueryOperationInfo;

namespace UT::orm
{
template <typename... Ts>
struct overloads : Ts...
{
    using Ts::operator()...;
};
template <typename... Ts>
overloads(Ts...) -> overloads<Ts...>;

class UT_API FilterArg
{
    struct Column
    {
        Column(const UT_ORMFieldColumn* field, const void* obj) :
            myField(field), myObject(obj)
        {}

        const UT_ORMFieldColumn* myField;
        const void* myObject = nullptr;
    };
    class ArgArray : public UT_IntrusiveRefCounter<
                             ArgArray,
                             std::default_delete<ArgArray>,
                             UT_IntrusiveNonThreadSafeCounterPolicy>
    {
    public:
        virtual ~ArgArray() = default;
        ArgArray(const ArgArray&) = default;
        ArgArray& operator=(const ArgArray&) = default;
        virtual void bind(UT_SqlStatement& stmt, int& bind_index) const = 0;
        virtual exint size() const = 0;
    protected:
        ArgArray() = default;
    };
    template <typename T>
    class ArgArrayHolder final : public ArgArray
    {
    public:
        ArgArrayHolder(const T& objs) : myObjs(objs) {}
        void bind(UT_SqlStatement& stmt, int& bind_index) const override
        {
            for (auto&& obj : myObjs)
            {
                stmt.bind(bind_index, obj);
                bind_index++;
                if (stmt.getError())
                    break;
            }
        }
        exint size() const override { return myObjs.size(); }

    private:
        T myObjs;
    };
    template <typename T>
    class ArgArrayMemberHolder final : public ArgArray
    {
    public:
        ArgArrayMemberHolder(
                const T& objs,
                const UT_ORMFieldColumn* field = nullptr)
            : myObjs(objs), myField(field)
        {
        }
        void bind(UT_SqlStatement& stmt, int& bind_index) const override
        {
            for (int i = 0; i < myObjs.size(); i++)
            {
                UT_ErrorCode ec;
                myField->adapter()->bind(&myObjs[i], stmt, bind_index, ec);
                bind_index++;

                if (stmt.getError())
                    break;
            }
        }
        exint size() const override { return myObjs.size(); }

    private:
        const UT_ORMFieldColumn* myField = nullptr;
        T myObjs;
    };

public:
    template <
            typename T,
            typename = typename std::enable_if_t<
                    !UT::detail::is_obj_container<std::decay_t<T>>::value>>
    FilterArg(const UT_StringHolder& name, T&& arg) : myName(name), myArg(arg)
    {
    }
    FilterArg(const UT_StringHolder& name, const char* arg) :
        myName(name), myArg(UT_StringHolder(arg))
    {
    }
    FilterArg(
            const UT_StringHolder& name,
            const UT_ORMFieldColumn* field,
            const void* obj)
        : myName(name), myArg(Column(field, obj))
    {
    }
    template <
            typename T,
            typename = typename std::enable_if_t<
                    UT::detail::is_obj_container<std::decay_t<T>>::value>>
    FilterArg(const UT_StringHolder& name, const T& objs)
        : myName(name), myArg(UTmakeIntrusive<ArgArrayHolder<T>>(objs))
    {
    }
    template <
            typename T,
            typename = typename std::enable_if_t<
                    UT::detail::is_obj_container<std::decay_t<T>>::value>>
    FilterArg(
            const UT_StringHolder& name,
            const UT_ORMFieldColumn* field,
            const T& objs)
        : myName(name)
        , myArg(UTmakeIntrusive<ArgArrayMemberHolder<T>>(objs, field))
    {
    }

    const UT_StringHolder& name() const { return myName; }

    void bind(UT_SqlStatement& stmt, int& bind_index) const
    {
        const auto visitor = overloads{
                [&](const Column& col)
                {
                    UT_ErrorCode ec;
                    col.myField->adapter()->bind(
                            col.myObject, stmt, bind_index, ec);
                    bind_index++;
                },
                [&](const UT_IntrusivePtr<ArgArray>& arg)
                {
                    arg->bind(stmt, bind_index);
                },
                [&](auto&& arg)
                {
                    using T = std::decay_t<decltype(arg)>;
                    stmt.bind(bind_index, std::get<T>(myArg));
                    bind_index++;
                }};
        std::visit(visitor, myArg);
    }

    void sqlParam(UT_WorkBuffer& wbuf) const
    {
        const auto visitor = overloads
        {
            [&](const UT_IntrusivePtr<ArgArray>& arg)
            {
                for (int i = 0; i < arg->size(); i++)
                {
                    if (i != 0)
                        wbuf.append(',');
                    wbuf.append('?');
                }
            },
            [&](auto&& arg)
            {
                wbuf.append('?');
            }
        };
        std::visit(visitor, myArg);
    }

private:
    UT_StringHolder myName;
    std::variant<
            int32,
            int64,
            bool,
            UT_StringHolder,
            Column,
            UT_IntrusivePtr<ArgArray>>
            myArg;
};

class UT_API UdlArgValue
{
public:
    UdlArgValue(const UT_StringHolder& str) : myStr(str) {}

    template <typename T>
    FilterArg operator=(T&& value)
    {
        return FilterArg(myStr, std::forward<T>(value));
    }

private:
    UT_StringHolder myStr;
};
}; // namespace UT::orm

namespace UT
{
inline namespace Literal
{
SYS_FORCE_INLINE UT::orm::UdlArgValue operator""_f(
        const char* s,
        const std::size_t len)
{
    return UT::orm::UdlArgValue(UT_StringHolder(s, len));
}
} // namespace Literal
} // namespace UT



class UT_API UT_ORMQuerySetResult
{
public:
    class UT_API iterator
    {
    public:
        using difference_type = exint;
        using iterator_category = std::forward_iterator_tag;
        using value_type = UT_ORMQuerySetResult;
        using pointer = value_type*;
        using refernce = value_type&;

        iterator& operator++()
        {
            if (myResult)
            {
                myResult->next();
                if (isDone())
                    myResult = nullptr;
            }
            return *this;
        }

        bool operator==(const iterator& rhs) const
        {
            if (myResult != nullptr && rhs.myResult != nullptr)
                return myResult->myStmt.isImplEqual(rhs->myStmt);
            else if (myResult == nullptr && rhs.myResult == nullptr)
                return true;
            return false;
        }
        bool operator!=(const iterator& rhs) const
        {
            return !(*this == rhs);
        }
        const UT_ORMQuerySetResult& operator*() const{
            return *myResult;
        }
        UT_ORMQuerySetResult& operator*()
        {
            return *myResult;
        }
        const UT_ORMQuerySetResult* operator->() const
        {
            return myResult;
        }
        UT_ORMQuerySetResult* operator->()
        {
            return myResult;
        }
        bool isDone() const
        {
            return myResult == nullptr || !myResult->hasResults()
                   || myResult->getError();
        }
        
    private:
        friend class UT_ORMQuerySetResult;

        iterator(UT_ORMQuerySetResult* result = nullptr) :
            myResult(result)
        {}

        UT_ORMQuerySetResult* myResult = nullptr;
    };

    iterator begin()
    {
        if (hasResults())
            return iterator(this);
        return end();
    }
    iterator end()
    {
        return iterator();
    }
    const iterator begin() const
    {
        if (hasResults())
            return iterator(SYSconst_cast(this));
        return end();
    }
    const iterator end() const
    {
        return iterator();
    }
    const iterator cbegin() const
    {
        return begin();
    }
    const iterator cend() const
    {
        return end();
    }

    const UT_ErrorCode& getError() const;
    void next();
    bool hasResults() const;

    template <typename... Args>
    std::tuple<Args...> fetchOne(UT_ErrorCode* ec = nullptr)
    {
        return myStmt.fetchOne<Args...>(ec);
    }
    template <typename... Args>
    UT_Array<std::tuple<Args...>> fetchAll(UT_ErrorCode* ec = nullptr)
    {
        return myStmt.fetchAll<Args...>(ec);
    }
    template <typename T>
    UT_Array<T> fetchAllFlat(UT_ErrorCode* ec = nullptr)
    {
        return myStmt.fetchAllFlat<T>(ec);
    }
    template <typename... Args>
    std::tuple<Args...> as(UT_ErrorCode* ec = nullptr)
    {
        return myStmt.as<Args...>(ec);
    }
    template <typename T>
    bool load(T& obj, UT_ErrorCode& ec)
    {
        return obj.meta().loadObject(obj, myStmt, ec);
    }

    UT_SqlStatement& stmt() { return myStmt; }
protected:
    friend class UT_ORMQuerySet;

    UT_ORMQuerySetResult(
            const UT_SharedPtr<UT_SqlStatementImpl>& impl,
            const UT_ErrorCode& ec)
        : myStmt(impl), myError(ec)
    {
    }

    UT_ErrorCode myError;
    UT_SqlStatement myStmt;
};

class UT_API UT_ORMQuerySet
{
public:
    UT_ORMQuerySet(const UT_ORMModelMeta& meta);
    ~UT_ORMQuerySet() = default;

    UT_ORMQuerySet(const UT_ORMQuerySet&) = default;
    UT_ORMQuerySet& operator=(const UT_ORMQuerySet&) = default;

    UT_ORMQuerySet all();
    UT_ORMQuerySet filter(
            const std::initializer_list<UT::orm::FilterArg>& args);
    UT_ORMQuerySet filter(const UT_Array<UT::orm::FilterArg>& args);
    UT_ORMQuerySetResult get();
    UT_ORMQuerySetResult get(const UT_ORMFieldColumn& field, void* obj);
    UT_ORMQuerySetResult remove();
    UT_ORMQuerySetResult update(
            const std::initializer_list<UT::orm::FilterArg>& args);
    UT_ORMQuerySetResult update(const UT_Array<UT::orm::FilterArg>& args);
    bool exists(UT_ErrorCode& ec);

    UT_ORMQuerySetResult create(
            const std::initializer_list<UT::orm::FilterArg>& args,
            bool ignore_conflicts = false,
            bool no_return = false);

    UT_ORMQuerySet values(
            const std::initializer_list<UT_StringHolder>& col_names)
    {
        myReturningValues.clear();
        for (auto&& name : col_names)
        {
            myReturningValues.emplace_back(name);
        }
        return UT_ORMQuerySet(*this);
    }

    UT_ORMQuerySet limit(int limit);

    UT_ORMQuerySet offset(int offset);

    UT_ORMQuerySetResult error(UT_ErrorCode ec);

    UT_ORMQuerySetResult first();

    UT_ORMQuerySet orderBy(const UT_StringHolder& order_by);

    int count(UT_ErrorCode* ec);
private:

    enum class SqlOp
    {
        SQL_SELECT,
        SQL_DELETE,
        SQL_INSERT,
        SQL_INSERT_IGNORE,
        SQL_UPDATE
    }; 

    void filterOnModel_(
            UT_WorkBuffer& wbuf,
            const UT_ORMModelMeta& meta,
            const UT::orm::FilterArg& filter_arg,
            const UT_StringView& full_arg);
    void filterOnM2M_(
            UT_WorkBuffer& wbuf,
            const UT_ORMModelMeta& through,
            const UT_ORMModelMeta& curr_meta,
            const UT::orm::FilterArg& filter_arg,
            const UT_StringView& argname,
            const UT_StringView& full_arg,
            UT_StringSet& executed_joins);
    UT_StringHolder build_(SqlOp op_type);
    void addOperationToFilter_(
            UT_WorkBuffer& wbuf,
            const UT_StringView& op,
            const UT::orm::FilterArg& filter_arg);
    bool isOperation_(const UT_StringView& op) const;
    UT_ORMQuerySetResult update_();

    static ut_QueryOperationInfo* getAvailableOperations_();

    UT_StringArray myReturningValues;
    UT_StringHolder myFilter;
    UT_StringArray myJoins;
    int myLimit = -1;
    int myOffset = -1;
    UT_Array<UT::orm::FilterArg> myArgs;
    UT_Array<UT::orm::FilterArg> myValues;
    UT_StringHolder myOrderBy;
    
    std::reference_wrapper<const UT_ORMModelMeta> myModelMeta;

    UT_ErrorCode myError;
};

#endif // __UT_ORMQUERYSET_H__