UT_ORMModelMeta.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_ORMModelMeta.h
 *
 * COMMENTS:
 *
 *  The UT_ORMModelMeta class describes the C++ object (model) and how this
 *  object relates to the database through tables, fields, foreign relationships
 *  etc.
 *
 *  See UT_SQLORM on how to create a meta object that descibes a model.
 */

#ifndef __UT_ORMMODELMETA_H__
#define __UT_ORMMODELMETA_H__

#include "UT_API.h"

#include "UT_ORMField.h"
#include "UT_StringHolder.h"
#include "UT_ORMError.h"
#include "UT_ORMQuerySet.h"
#include "UT_SharedPtr.h"

class UT_SqlOrm;
class UT_ORMMigrationBuilder;
class UT_ORMBaseModel;
class UT_ORMMigration;

namespace UT::detail
{
template <typename T>
struct no_op_delete
{
    void operator()(T*) {}
};
} // namespace UT::detail

template <typename Owner, typename OtherModel>
class UT_ORMManyToManyField;

class UT_API UT_ORMModelMeta
{
public:
    UT_ORMModelMeta(const UT_StringHolder& name, UT_SqlOrm* orm = nullptr)
        : myORM(orm)
    {
        setModelName(name);
        setTableName(name);
    }
    UT_ORMModelMeta() {}
    virtual ~UT_ORMModelMeta() = default;
    UT_NON_COPYABLE(UT_ORMModelMeta);

    void setTableName(const UT_StringHolder& name)
    {
        myTableName = name;
    }
    void setModelName(const UT_StringHolder& name)
    {
        myModelName = name;
        if (!myTableName)
            myTableName = name;
        if (!myVerboseName)
            myVerboseName = name;
        if (!myPluralVerboseName)
            myPluralVerboseName = name;
    }
    void setVerboseName(const UT_StringHolder& name)
    {
        myVerboseName = name;
    }
    void setPluralVerboseName(const UT_StringHolder& name)
    {
        myPluralVerboseName = name;
    }

    /// Call to build out all of your meta information.
    void build(UT_SqlOrm& orm);
    /// Called after all models concrete information has been connected
    void connectLinks();
    // Collect all migrations for this model.
    virtual void collectMigrations(
            UT_ORMMigrationBuilder& builder) const
            = 0;
    /// Called right before connecting the links on each model
    virtual void preConnectLinks() {}
    void postMigrate();

    template <typename Cls, typename FieldT>
    void addAutoField(
            const UT_StringHolder& name,
            FieldT Cls::*field,
            unsigned props = UT_ORMColumn::Empty)
    {
        myColumns.emplace_back(
                UT_ORMBasicFieldAdapter<Cls, FieldT>::createColumn(
                        name, field, props | UT_ORMColumn::AutoIncrement));
    }
    template <typename Cls, typename FieldT>
    void addField(
            const UT_StringHolder& name,
            FieldT Cls::*field,
            unsigned props = UT_ORMColumn::Empty)
    {
        myColumns.emplace_back(
                UT_ORMBasicFieldAdapter<Cls, FieldT>::createColumn(
                        name, field, props));
    }
    template <typename Cls, typename ForeignModel>
    void addField(
            const UT_StringHolder& name,
            UT_ORMForeignKeyField<ForeignModel> Cls::*field,
            unsigned props = UT_ORMColumn::Empty,
            UT_ORMColumn::OnDelete ondelete_type
            = UT_ORMColumn::OnDelete::Cascade,
            const UT_StringHolder& related_name
            = UT_StringHolder::theEmptyString,
            const UT_ORMModelMeta& foreign_meta = ForeignModel::metaInfo())
    {
        using adapter_t = UT_ORMForeignKeyFieldAdapter<
                Cls, UT_ORMForeignKeyField<ForeignModel>>;
        myColumns.emplace_back(adapter_t::createColumn(
                foreign_meta, name, field, props, ondelete_type, related_name));
    }
    template <typename Owner, typename OtherModel>
    void addField(
            const UT_StringHolder& name,
            UT_ORMManyToManyField<Owner, OtherModel> Owner::*field,
            const UT_StringHolder& related_name
            = UT_StringHolder::theEmptyString)
    {
        UT_ASSERT(modelName() == Owner::metaInfo().modelName());
        auto self = lookupMetaFromORM_(modelName());
        auto other = lookupMetaFromORM_(OtherModel::metaInfo().modelName());
        registerM2M_(self, other, name, related_name);
    }

    const UT_StringHolder& tableName() const { return myTableName; }
    const UT_StringHolder& modelName() const { return myModelName; }
    const UT_StringHolder& verboseName() const { return myVerboseName; }
    const UT_StringHolder& pluralVerboseName() const
    {
        return myPluralVerboseName;
    }
    const UT_ORMFieldColumn* primaryKey() const { return myPrimaryKey; }
    const UT_Array<UT_ORMFieldColumn>& columns() const { return myColumns; }
    const UT_Array<const UT_ORMFieldColumn*>& foreignKeys() const
    {
        return myForeignKeys;
    }
    const UT_Array<const UT_ORMFieldColumn*>& uniqueColumns() const
    {
        return myUniqueColumns;
    }

    template <typename T>
    bool save(
            T& obj,
            UT_ErrorCode& ec,
            bool force_insert = false,
            bool force_update = false) const;
    template <typename T>
    void remove(T& obj, UT_ErrorCode& ec) const;
    template <typename T>
    void remove(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;
    template <typename T, typename PK>
    UT_Optional<T> fetch(const PK& pk, UT_ErrorCode& ec) const;
    template <typename T>
    UT_Array<T> fetch(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;
    template <typename T>
    UT_Array<T> fetchAll(UT_ErrorCode& ec) const;
    template <typename T>
    UT_Optional<T> filter(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;
    template <typename T>
    std::pair<T, bool> getOrCreate(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;
    template <typename T>
    UT_Optional<T> create(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;
    template <typename T, typename ArrayT>
    UT_Array<T> bulkFetch(
            const ArrayT& pks,
            UT_ErrorCode& ec,
            const UT_StringRef& col_name
            = UT_StringHolder::theEmptyString) const;
    template <typename T>
    void bulkSave(const UT_Array<T>& items, UT_ErrorCode& ec) const;
    template <typename T, typename... Args>
    T fromDB(Args&&... args) const
    {
        T obj(std::forward<Args>(args)...);
        obj.myOrmAdding = false;
        return obj;
    }
    template <typename T>
    bool exists(
            const std::initializer_list<UT::orm::FilterArg>& args,
            UT_ErrorCode& ec) const;

    UT_SqlOrm* orm() const { return SYSconst_cast(this)->myORM; }
    UT_SqlStatement cursor() const;
    UT_SqlDatabase& db();
    UT_SqlDatabase& db() const;

    template <typename T>
    bool loadObject(T& obj, UT_SqlStatement& stmt, UT_ErrorCode& ec) const
    {
        for (int i = 0; i < myColumns.size(); i++)
        {
            const UT_ORMFieldColumn& column = myColumns[i];
            if (!column.isManyToMany())
            {
                if (UT_IORMFieldAdapter* adapter = column.adapter(); adapter)
                {
                    adapter->load(&obj, stmt, i, ec);
                    if (ec)
                        return false;
                }
                else
                {
                    ec = UTmakeErrorCode(
                            UT::SqlOrmError::UT_ORM_OPERATION_FAILED);
                    UT_ASSERT(!"Type not handled");
                }
            }
        }

        // If the object is being loaded from the db then at some point it
        // was saved.
        obj.myOrmAdding = false;

        return true;
    }
    template <typename T>
    UT_Array<T> loadAllObjects(UT_SqlStatement& stmt, UT_ErrorCode& ec)
    {
        UT_Array<T> items;
        while (stmt.hasRow() && !stmt.getError())
        {
            T obj(*this);
            if (loadObject(obj, stmt, ec))
                items.emplace_back(obj);
            else
                break;
        }
        if (!ec)
            ec = stmt.getError();
        if (ec)
            items.clear();
        return items;
    }

    void resetInternals()
    {
        myHasBuilt = false;
        myHasPostBuilt = false;
        myHasPostMigrate = false;
        myIsThroughTable = false;
        myColumns.clear();
        myForeignKeys.clear();
        myUniqueColumns.clear();
        myRelated.clear();
        myPrimaryKey = nullptr;
        myORM = nullptr;
    } 

    bool hasField(const UT_StringView& name) const
    {
        for (auto&& col : myColumns)
        {
            if (UT_StringView(col.name()) == name)
                return true;
        }
        return false;
    }

    const UT_ORMFieldColumn* findField(const UT_StringView& name) const
    {
        for (auto&& col : myColumns)
        {
            if (UT_StringView(col.name()) == name)
                return &col;
        }
        return nullptr;
    }
    /// Find a foreign concrete field based on the column name. The column name
    /// passed in must be for a local field that is a foreign key
    const UT_ORMFieldColumn* findForeignRelatedField(
            const UT_StringView& name) const
    {
        const UT_ORMFieldColumn* local_field = findField(name);
        if (local_field != nullptr)
        {
            UT_SharedPtr<UT_ORMModelMeta> foreign_model
                    = local_field->foreignModel();
            if (foreign_model != nullptr)
            {
                UT_StringHolder foreign_related_field_name
                        = local_field->foreignFieldName();
                const UT_ORMFieldColumn* foreign_field
                        = foreign_model->findField(foreign_related_field_name);
                return foreign_field;
            }
        }
        return nullptr;
    }

    bool registerRelated(
            const UT_SharedPtr<UT_ORMModelMeta>& related,
            const UT_StringHolder& related_name,
            const UT_StringHolder& fk_field_name
            = UT_StringHolder::theEmptyString);
    UT_SharedPtr<UT_ORMModelMeta> findRelated(
            const UT_StringView& name,
            UT_StringHolder& fk_field_name) const;

    /// On a lookup table split the two columns up based on the provided model.
    /// This is helpful for quickly determining which column on the lookup
    /// table belongs to the provided concrete model and the other model.
    void lookupTableColumns(
            const UT_StringRef& model_name,
            const UT_ORMFieldColumn*& fk_model,
            const UT_ORMFieldColumn*& fk_other_model) const;

    bool isThroughTable() const { return myIsThroughTable; }

    UT_ORMQuerySet querySet() const
    {
        return UT_ORMQuerySet(*this);
    }

protected:
    struct Related
    {
        Related(const UT_StringHolder& name,
                const UT_StringHolder& fk_name,
                const UT_SharedPtr<UT_ORMModelMeta>& foreign_meta)
            : myName(name)
            , myForeignKeyName(fk_name)
            , myForeignMeta(foreign_meta)
        {
        }
        // Related name of the model. This is mainly used for searching
        UT_StringHolder myName;
        // If the relation is by reverse foreign key then this is the name of
        // the foreign key field of the model. This is necessary for the join
        // statement
        UT_StringHolder myForeignKeyName;
        // This is the related model. If its a M2M relationship this is the
        // lookup table which the actual models can be found from. If its a
        // related foreign key then this is the actual foreign model.
        UT_WeakPtr<UT_ORMModelMeta> myForeignMeta;
    };

    virtual void doBuild() = 0;
    virtual void doPostBuild() {}
    virtual void doPostMigrate();

    /// Configure any cacheable information that is used often.
    void configureConcrete_();

    void registerM2M_(
            const UT_SharedPtr<UT_ORMModelMeta>& left,
            const UT_SharedPtr<UT_ORMModelMeta>& right,
            const UT_StringHolder& field_name,
            const UT_StringHolder& related_name);

    UT_SharedPtr<UT_ORMModelMeta> lookupMetaFromORM_(
            const UT_StringView& name) const;

    template <typename T>
    bool doUpdate_(T& obj, UT_ErrorCode& ec) const;
    template <typename T>
    bool doInsert_(T& obj, UT_ErrorCode& ec) const;

    static void addDynamicColumn_(
            UT_ORMModelMeta& meta,
            UT_ORMFieldColumn&& field)
    {
        meta.myColumns.emplace_back(std::forward<UT_ORMFieldColumn>(field));
    }

    bool myHasBuilt = false;
    bool myHasPostBuilt = false;
    bool myHasPostMigrate = false;
    bool myIsThroughTable = false;
    UT_StringHolder myTableName;
    UT_StringHolder myModelName;
    UT_StringHolder myVerboseName;
    UT_StringHolder myPluralVerboseName;
    const UT_ORMFieldColumn* myPrimaryKey = nullptr;
    UT_Array<const UT_ORMFieldColumn*> myForeignKeys;
    UT_Array<const UT_ORMFieldColumn*> myUniqueColumns;
    UT_Array<UT_ORMFieldColumn> myColumns;
    UT_Array<Related> myRelated;
    UT_SqlOrm* myORM = nullptr;
};

template <typename T>
bool
UT_ORMModelMeta::save(
        T& obj,
        UT_ErrorCode& ec,
        bool force_insert,
        bool force_update) const
{
    // If we arent forcing anything but also havent added the object then
    // force an insert.
    if (!force_insert && !force_update && obj.myOrmAdding)
        force_insert = true;

    bool updated = false;
    if (!force_insert)
    {
        updated = doUpdate_(obj, ec);

        if (force_update && !updated)
        {
            // TODO: error
            return false;
        }
    }

    if (!updated)
    {
        updated = doInsert_(obj, ec);
    }

    obj.myOrmAdding = false;

    return updated;
}

template <typename T>
bool
UT_ORMModelMeta::doUpdate_(T& obj, UT_ErrorCode& ec) const
{
    UT_Array<UT::orm::FilterArg> values;
    for (auto&& col : myColumns)
    {
        if (!col.isPrimaryKey() && !col.isManyToMany())
        {
            values.emplace_back(UT::orm::FilterArg(col.name(), &col, &obj));
        }
    }

    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result
            = qset.filter({UT::orm::FilterArg(
                                  primaryKey()->name(), primaryKey(), &obj)})
                      .update(values);

    ec = result.getError();
    return result.stmt().changes() > 0 && !(bool)ec;
}

template <typename T>
bool
UT_ORMModelMeta::doInsert_(T& obj, UT_ErrorCode& ec) const
{
    UT_WorkBuffer sql_query("INSERT INTO ");

    UT_Array<const UT_ORMFieldColumn*> values;
    UT_Array<const UT_ORMFieldColumn*> outputs;

    for (auto&& col : myColumns)
    {
        if (!col.isManyToMany())
        {
            if (col.isAutoIncrement())
                outputs.emplace_back(&col);
            else
                // When the value is auto incremented we need to capture the
                // value as the current value is likely not correct to the DB.
                values.emplace_back(&col);
        }
    }

    sql_query.append(tableName());
    sql_query.append(" (");
    for (exint i = 0; i < values.size(); i++)
    {
        const UT_ORMFieldColumn* col = values[i];
        if (!col->isAutoIncrement())
        {
            if (i != 0)
                sql_query.append(',');
            sql_query.append(col->name());
        }
    }
    sql_query.append(')');


    sql_query.append(" VALUES (");
    for (exint i = 0; i < values.size(); i++)
    {
        const UT_ORMFieldColumn* col = values[i];
        if (!col->isAutoIncrement())
        {
            if (i != 0)
                sql_query.append(',');
            sql_query.append('?');
        }
    }
    sql_query.append(')');

    if (outputs.size() > 0)
    {
        sql_query.append(" RETURNING ");
        // Add any outputs we might need to capture
        for (exint i = 0, c = outputs.size(); i < c; i++)
        {
            if (i != 0)
                sql_query.append(',');
            sql_query.appendFormat("{}", outputs[i]->name());
        }
    }
    sql_query.append(';');

    UT_ASSERT(myORM);
    UT_SqlStatement stmt(cursor());

    if (stmt.getError())
    {
        ec = stmt.getError();
        return false;
    }

    if (!stmt.prepare(sql_query, ec))
    {
        return false;
    }
    for (int i = 0; i < values.size(); i++)
    {
        const UT_ORMFieldColumn* col = values[i];
        if (!col->isAutoIncrement())
        {
            if (UT_IORMFieldAdapter* adapter = col->adapter(); adapter)
                adapter->bind(&obj, stmt, i+1, ec);
            else
            {
                ec = UTmakeErrorCode(UT::SqlOrmError::UT_ORM_OPERATION_FAILED);
            }
            if (ec)
                return false;
        }
    }

    stmt.step();
    
    int changes = stmt.changes();

    // If the insert was a success load any outputs into the columns.
    if (changes > 0 && outputs.size() > 0)
    {
        for (exint i = 0, c= outputs.size(); i < c; i++)
        {
            const UT_ORMFieldColumn* output = outputs[i];
            if (UT_IORMFieldAdapter* adapter = output->adapter(); adapter)
            {
                adapter->load(&obj, stmt, i, ec);
            }
        }

        stmt.step();
    }

    if (stmt.getError())
        ec = stmt.getError();

    return changes > 0;
}

template <typename T>
void
UT_ORMModelMeta::remove(T& obj, UT_ErrorCode& ec) const
{
    const UT_ORMFieldColumn* column = primaryKey();

    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result
            = qset.filter({UT::orm::FilterArg(column->name(), column, &obj)})
                      .remove();

    if (result.getError())
    {
        ec = result.getError();
        return;
    }

    // Object has been removed from the db let the c++ object know in the
    // event it has to do some extra work
    for (auto&& meta_column : myColumns)
    {
        UT_IORMFieldAdapter* adapter = column->adapter();
        adapter->onDelete(&obj, meta_column.onDelete(), ec);

        if (ec)
            return;
    }
}

template <typename T>
void
UT_ORMModelMeta::remove(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result = qset.filter(args).remove();
    ec = result.getError();
}

template <typename T>
UT_Array<T>
UT_ORMModelMeta::fetch(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result = qset.filter(args).get();

    UT_Array<T> items;
    for (auto&& record : result)
    {
        T item(*this);
        if (loadObject(item, record.stmt(), ec))
            items.emplace_back(std::move(item));
        else
            return UT_Array<T>{};
    }

    if (result.getError())
        ec = result.getError();

    return items;
}

template <typename T, typename PK>
UT_Optional<T>
UT_ORMModelMeta::fetch(const PK& pk, UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result
            = qset.filter({UT::orm::FilterArg(primaryKey()->name(), pk)}).get();

    if (!result.hasResults())
        return std::nullopt;

    T item(*this);
    if (loadObject(item, result.stmt(), ec))
    {
        return std::make_optional<T>(item);
    }

    return std::nullopt;
}

template <typename T>
UT_Array<T>
UT_ORMModelMeta::fetchAll(UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result = qset.get();

    UT_Array<T> items;
    for (auto&& record : result)
    {
        T item(*this);
        if (loadObject(item, record.stmt(), ec))
            items.emplace_back(std::move(item));
        else
            return UT_Array<T>{};
    }

    if (result.getError())
        ec = result.getError();

    return items;
}

template <typename T>
UT_Optional<T>
UT_ORMModelMeta::filter(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result = qset.filter(args).limit(1).get();

    if (!result.hasResults())
        return std::nullopt;

    T item(*this);
    if (loadObject(item, result.stmt(), ec))
        return item;

    return std::nullopt;
}

template <typename T>
UT_Optional<T>
UT_ORMModelMeta::create(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    UT_ORMQuerySetResult result = qset.create(args);

    ec = result.getError();
    if (ec)
        return std::nullopt;

    if (result.hasResults())
    {
        T obj;
        if (result.load(obj, ec))
            return obj;
    }

    return std::nullopt;
}

template <typename T>
std::pair<T, bool>
UT_ORMModelMeta::getOrCreate(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    if (auto&& found_obj = filter<T>(args, ec); found_obj)
    {
        return std::make_pair(std::move(found_obj.value()), false);
    }

    if (ec)
        return std::make_pair(T(), false);

    {
        UT_SqlTransaction trans(db());
        if (auto&& created_obj = create<T>(args, ec); created_obj)
        {
            trans.commit();
            return std::make_pair(std::move(created_obj.value()), true);
        }
    }

    if (ec != UT::SqlError::UT_SQL_CONSTRAINT)
        return std::make_pair(T(), false);

    if (auto&& found_obj = filter<T>(args, ec); found_obj)
    {
        return std::make_pair(std::move(found_obj.value()), false);
    } 

    // This should basically never happen but there is an outside chance so we
    // need to make sure we communicate that we neither got or created an
    // object so the operation failed.
    if (!ec)
        ec = UTmakeErrorCode(UT::SqlOrmError::UT_ORM_OPERATION_FAILED);

    return std::make_pair(T(), false); 
}

template <typename T, typename ArrayT>
UT_Array<T>
UT_ORMModelMeta::bulkFetch(
        const ArrayT& pks,
        UT_ErrorCode& ec,
        const UT_StringRef& col_name) const
{
    UT_WorkBuffer wbuf;
    wbuf.append("SELECT ");
    for (int i = 0, count = 0; i < myColumns.size(); i++)
    {
        // M2M isnt an actual column on a model.
        if (!myColumns[i].isManyToMany())
        {
            if (count != 0)
                wbuf.append(',');
            wbuf.append(myColumns[i].name());
            count++;
        }
    }
    wbuf.append(" FROM ");
    wbuf.append(tableName());
    wbuf.append(" WHERE ");
    if (!col_name)
    {
        if (const UT_ORMFieldColumn* col = findField(col_name); col)
            wbuf.append(col->name());
        else
            return UT_Array<T>();
    }
    else
    {
        wbuf.append(primaryKey()->name());
    }
    wbuf.append(" IN (");
    for (int i = 0, c=pks.size(); i<c; i++)
    {
        if (i != 0)
            wbuf.append(" , ");
        wbuf.append("?");
    }
    wbuf.append(")");

    UT_SqlStatement stmt(cursor());

    if (!stmt.prepare(wbuf, ec))
        return UT_Array<T>();

    int index = 1;
    for (auto&& pk : pks)
    {
        stmt.bind(index, pk);
        index++;
    }

    UT_Array<T> items;
    while (stmt.step() && !stmt.getError())
    {
        T item(*this);
        if (loadObject(item, stmt, ec))
            items.emplace_back(std::move(item));
        else
            return UT_Array<T>{};
    }

    return items;
}

template <typename T>
void
UT_ORMModelMeta::bulkSave(const UT_Array<T>& items, UT_ErrorCode& ec) const
{
    UT_SqlStatement stmt = cursor();

    UT_WorkBuffer wbuf;
    wbuf.append("INSERT INTO ");
    wbuf.append(tableName());
    wbuf.append(" (");

    UT_WorkBuffer values_str;
    values_str.append('(');
    for (int i = 0, c = myColumns.size(), cl=0; i < c; i++)
    {
        if (!myColumns[i].isAutoIncrement())
        {
            if (cl != 0)
            {
                wbuf.append(',');
                values_str.append(',');
            }
            values_str.append('?');
            wbuf.append(myColumns[i].name());
            cl++;
        }
    }
    values_str.append(')');
    wbuf.append(") VALUES ");
    for (int i = 0, c = items.size(); i < c; i++)
    {
        if (i != 0)
            wbuf.append(',');
        wbuf.append(values_str);
    }
    wbuf.append(';');

    if (!stmt.prepare(wbuf, ec))
        return;

    int bind_index = 1;
    for (auto&& item : items)
    {
        for (auto&& col : myColumns)
        {
            if (!col.isAutoIncrement())
            {
                if (UT_IORMFieldAdapter* adapter = col.adapter(); adapter)
                {
                    adapter->bind(SYSconst_cast(&item), stmt, bind_index, ec);
                    if (ec)
                        return;
                }
                else
                {
                    ec = UTmakeErrorCode(
                            UT::SqlOrmError::UT_ORM_OPERATION_FAILED);
                    UT_ASSERT(!"Type not handled");
                }
                bind_index++;
            }
        }
    }

    stmt.step();
    if (stmt.getError())
        ec = stmt.getError();
}

template <typename T>
bool
UT_ORMModelMeta::exists(
        const std::initializer_list<UT::orm::FilterArg>& args,
        UT_ErrorCode& ec) const
{
    UT_ORMQuerySet qset(*this);
    return qset.filter(args).exists(ec);
}

#endif // __UT_ORMMODELMETA_H__