dbMetaTable.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef DB_META_TABLE_H
#define DB_META_TABLE_H
 
#include <algorithm>
#include <functional>
#include <mutex>
using namespace std;
 
#include "dbExec.h"
#include "libopenm/db/dbMetaRow.h"
 
namespace openm
{
    template<class TRow> struct IMetaTable
    {
    public:
        virtual ~IMetaTable<TRow>(void) noexcept { }
 
    protected:
        static vector<TRow> rows(const IRowBaseVec & i_rowVec)
        {
            vector<TRow> vec;
            for (IRowBaseVec::const_iterator rowIt = i_rowVec.begin(); rowIt != i_rowVec.end(); ++rowIt) {
                vec.push_back( *dynamic_cast<TRow *>(rowIt->get()) );
            }
            return vec;
        }
    };
 
    template<class TRow> struct IMetaLoadedTable : public IMetaTable<TRow>
    {
        typedef function<bool(const TRow & i_dbRow)> RowEqual;
 
        virtual ~IMetaLoadedTable<TRow>(void) noexcept { }
 
        virtual const IRowBaseVec & rowsCRef(void) const = 0;
 
        virtual IRowBaseVec & rowsRef(void) = 0;
 
        IRowBaseVec::difference_type rowCount(void) const { return rowsCRef().size(); }
 
        vector<TRow> rows(void) const
        {
            vector<TRow> vec;
            for (IRowBaseVec::const_iterator rowIt = rowsCRef().cbegin(); rowIt != rowsCRef().cend(); ++rowIt) {
                vec.push_back(*dynamic_cast<TRow *>(rowIt->get()));
            }
            return vec;
        }
 
        const TRow * firstRow(void) const
        {
            return dynamic_cast<TRow *>(!rowsCRef().empty() ? rowsCRef()[0].get() : nullptr);
        }
 
        vector<TRow> findAll(RowEqual i_cmp) const
        {
            vector<TRow> vec;
            for (IRowBaseVec::const_iterator rowIt = rowsCRef().cbegin(); rowIt != rowsCRef().cend(); ++rowIt) {
                if (i_cmp(*dynamic_cast<TRow *>(rowIt->get()))) vec.push_back(*dynamic_cast<TRow *>(rowIt->get()));
            }
            return vec;
        }
 
        const TRow * findFirst(RowEqual i_cmp) const { return byIndex(indexOf(i_cmp)); }
 
        const TRow * byIndex(IRowBaseVec::difference_type i_index) const 
        {
            return (0 <= i_index && i_index < rowCount()) ? dynamic_cast<TRow *>(rowsCRef()[i_index].get()) : nullptr;
        }
 
        IRowBaseVec::difference_type indexOf(RowEqual i_cmp, IRowBaseVec::difference_type i_startPos = 0) const
        {
            if (i_startPos >= 0) {
                for (IRowBaseVec::size_type pos = i_startPos; pos < rowsCRef().size(); pos++) {
                    if (i_cmp(*dynamic_cast<TRow *>(rowsCRef()[pos].get()))) return pos;
                }
            }
            return -1;
        }
 
        IRowBaseVec::size_type countOf(RowEqual i_cmp) const
        {
            IRowBaseVec::size_type nCount = 0;
            for (IRowBaseVec::const_iterator rowIt = rowsCRef().cbegin(); rowIt != rowsCRef().cend(); ++rowIt) {
                if (i_cmp(*dynamic_cast<TRow *>(rowIt->get()))) nCount++;
            }
            return nCount;
        }
 
    protected:
        static IRowBaseVec load(const string & i_sqlSelect, IDbExec * i_dbExec, const IRowAdapter & i_adapter)
        {
            if (i_dbExec == nullptr) throw DbException("invalid (NULL) database connection");
 
            IRowBaseVec vec = i_dbExec->selectRowVector(i_sqlSelect, i_adapter);
            stable_sort(vec.begin(), vec.end(), TRow::keyLess);
            return vec;
        }
 
        const TRow * findKey(const IRowBaseUptr & i_row) const
        {
            IRowBaseVec::const_iterator rowIt = lower_bound(rowsCRef().cbegin(), rowsCRef().cend(), i_row, TRow::keyLess);
            return dynamic_cast<TRow *>((rowIt != rowsCRef().cend() && TRow::keyEqual(*rowIt, i_row)) ? rowIt->get() : nullptr);
        }
    };
 
    struct ILangLstTable : public IMetaLoadedTable<LangLstRow>
    {
        virtual ~ILangLstTable() noexcept = 0;
 
        static ILangLstTable * create(IDbExec * i_dbExec);
 
        virtual const LangLstRow * byKey(int i_langId) const = 0;
 
        virtual const LangLstRow * byCode(const string & i_code) const = 0;
 
        static ILangLstTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ILangWordTable : public IMetaLoadedTable<LangWordRow>
    {
        virtual ~ILangWordTable() noexcept = 0;
 
        static ILangWordTable * create(IDbExec * i_dbExec, int i_langId = -1);
 
        virtual const LangWordRow * byKey(int i_langId, const string & i_code) const = 0;
 
        static ILangWordTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IModelDicTable : public IMetaLoadedTable<ModelDicRow>
    {
        virtual ~IModelDicTable() noexcept = 0;
 
        static IModelDicTable * create(IDbExec * i_dbExec, const char * i_name = nullptr, const char * i_digest = nullptr);
 
        static IModelDicTable * create(IDbExec * i_dbExec, int i_modelId);
 
        virtual const ModelDicRow * byKey(int i_modelId) const = 0;
 
        virtual const ModelDicRow * byNameDigest(const string & i_name, const string & i_digest) const = 0;
 
        static IModelDicTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IModelDicTxtTable : public IMetaLoadedTable<ModelDicTxtRow>
    {
        virtual ~IModelDicTxtTable() noexcept = 0;
 
        static IModelDicTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const ModelDicTxtRow * byKey(int i_modelId, int i_langId) const = 0;
 
        static IModelDicTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IModelWordTable : public IMetaLoadedTable<ModelWordRow>
    {
        virtual ~IModelWordTable() noexcept = 0;
 
        static IModelWordTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const ModelWordRow * byKey(int i_modelId, int i_langId, const string & i_code) const = 0;
 
        static IModelWordTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITypeDicTable : public IMetaLoadedTable<TypeDicRow>
    {
        virtual ~ITypeDicTable() noexcept = 0;
 
        static ITypeDicTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const TypeDicRow * byKey(int i_modelId, int i_typeId) const = 0;
 
        static ITypeDicTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITypeDicTxtTable : public IMetaLoadedTable<TypeDicTxtRow>
    {
        virtual ~ITypeDicTxtTable() noexcept = 0;
 
        static ITypeDicTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TypeDicTxtRow * byKey(int i_modelId, int i_typeId, int i_langId) const = 0;
 
        static ITypeDicTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITypeEnumLstTable : public IMetaLoadedTable<TypeEnumLstRow>
    {
        virtual ~ITypeEnumLstTable() noexcept = 0;
 
        static ITypeEnumLstTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const TypeEnumLstRow * byKey(int i_modelId, int i_typeId, int i_enumId) const = 0;
 
        virtual vector<TypeEnumLstRow> byModelId(int i_modelId) const = 0;
 
        virtual vector<TypeEnumLstRow> byModelIdTypeId(int i_modelId, int i_typeId) const = 0;
 
        virtual const TypeEnumLstRow * byName(int i_modelId, int i_typeId, const char * i_name) const = 0;
 
        static ITypeEnumLstTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITypeEnumTxtTable : public IMetaLoadedTable<TypeEnumTxtRow>
    {
        virtual ~ITypeEnumTxtTable() noexcept = 0;
 
        static ITypeEnumTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TypeEnumTxtRow * byKey(int i_modelId, int i_typeId, int i_enumId, int i_langId) const = 0;
 
        static ITypeEnumTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IParamDicTable : public IMetaLoadedTable<ParamDicRow>
    {
        virtual ~IParamDicTable() noexcept = 0;
 
        static IParamDicTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const ParamDicRow * byKey(int i_modelId, int i_paramId) const = 0;
 
        virtual vector<ParamDicRow> byModelId(int i_modelId) const = 0;
 
        virtual const ParamDicRow * byModelIdName(int i_modelId, const string & i_name) const = 0;
 
        static IParamDicTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IParamImportTable : public IMetaLoadedTable<ParamImportRow>
    {
        virtual ~IParamImportTable() noexcept = 0;
 
        static IParamImportTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const ParamImportRow * byKey(int i_modelId, int i_paramId) const = 0;
 
        virtual vector<ParamImportRow> byModelId(int i_modelId) const = 0;
 
        static IParamImportTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IParamDicTxtTable : public IMetaLoadedTable<ParamDicTxtRow>
    {
        virtual ~IParamDicTxtTable() noexcept = 0;
 
        static IParamDicTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const ParamDicTxtRow * byKey(int i_modelId, int i_paramId, int i_langId) const = 0;
 
        static IParamDicTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IParamDimsTable : public IMetaLoadedTable<ParamDimsRow>
    {
        virtual ~IParamDimsTable() noexcept = 0;
 
        static IParamDimsTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const ParamDimsRow * byKey(int i_modelId, int i_paramId, int i_dimId) const = 0;
 
        virtual vector<ParamDimsRow> byModelIdParamId(int i_modelId, int i_paramId) const = 0;
 
        static IParamDimsTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IParamDimsTxtTable : public IMetaLoadedTable<ParamDimsTxtRow>
    {
        virtual ~IParamDimsTxtTable() noexcept = 0;
 
        static IParamDimsTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const ParamDimsTxtRow * byKey(int i_modelId, int i_paramId, int i_dimId, int i_langId) const = 0;
 
        static IParamDimsTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableDicTable : public IMetaLoadedTable<TableDicRow>
    {
        virtual ~ITableDicTable() noexcept = 0;
 
        static ITableDicTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const TableDicRow * byKey(int i_modelId, int i_tableId) const = 0;
 
        virtual vector<TableDicRow> byModelId(int i_modelId) const = 0;
 
        virtual const TableDicRow * byModelIdName(int i_modelId, const string & i_name) const = 0;
 
        static ITableDicTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableDicTxtTable : public IMetaLoadedTable<TableDicTxtRow>
    {
        virtual ~ITableDicTxtTable() noexcept = 0;
 
        static ITableDicTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TableDicTxtRow * byKey(int i_modelId, int i_tableId, int i_langId) const = 0;
 
        static ITableDicTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableDimsTable : public IMetaLoadedTable<TableDimsRow>
    {
        virtual ~ITableDimsTable() noexcept = 0;
 
        static ITableDimsTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const TableDimsRow * byKey(int i_modelId, int i_tableId, int i_dimId) const = 0;
 
        virtual vector<TableDimsRow> byModelIdTableId(int i_modelId, int i_tableId) const = 0;
 
        static ITableDimsTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableDimsTxtTable : public IMetaLoadedTable<TableDimsTxtRow>
    {
        virtual ~ITableDimsTxtTable() noexcept = 0;
 
        static ITableDimsTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TableDimsTxtRow * byKey(int i_modelId, int i_tableId, int i_dimId, int i_langId) const = 0;
 
        static ITableDimsTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableAccTable : public IMetaLoadedTable<TableAccRow>
    {
        virtual ~ITableAccTable() noexcept = 0;
 
        static ITableAccTable * create(IDbExec * i_dbExec, int i_modelId = 0, bool i_isIncludeDerived = false);
 
        virtual const TableAccRow * byKey(int i_modelId, int i_tableId, int i_accId) const = 0;
 
        virtual vector<TableAccRow> byModelId(int i_modelId) const = 0;
 
        virtual vector<TableAccRow> byModelIdTableId(int i_modelId, int i_tableId) const = 0;
 
        static ITableAccTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableAccTxtTable : public IMetaLoadedTable<TableAccTxtRow>
    {
        virtual ~ITableAccTxtTable() noexcept = 0;
 
        static ITableAccTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TableAccTxtRow * byKey(int i_modelId, int i_tableId, int i_accId, int i_langId) const = 0;
 
        static ITableAccTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableExprTable : public IMetaLoadedTable<TableExprRow>
    {
        virtual ~ITableExprTable() noexcept = 0;
 
        static ITableExprTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const TableExprRow * byKey(int i_modelId, int i_tableId, int i_exprId) const = 0;
 
        virtual vector<TableExprRow> byModelId(int i_modelId) const = 0;
 
        virtual vector<TableExprRow> byModelIdTableId(int i_modelId, int i_tableId) const = 0;
 
        static ITableExprTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct ITableExprTxtTable : public IMetaLoadedTable<TableExprTxtRow>
    {
        virtual ~ITableExprTxtTable() noexcept = 0;
 
        static ITableExprTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const TableExprTxtRow * byKey(int i_modelId, int i_tableId, int i_exprId, int i_langId) const = 0;
 
        static ITableExprTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IEntityDicTable : public IMetaLoadedTable<EntityDicRow>
    {
        virtual ~IEntityDicTable() noexcept = 0;
 
        static IEntityDicTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const EntityDicRow * byKey(int i_modelId, int i_entityId) const = 0;
 
        virtual vector<EntityDicRow> byModelId(int i_modelId) const = 0;
 
        virtual const EntityDicRow * byModelIdName(int i_modelId, const string & i_name) const = 0;
 
        static IEntityDicTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IEntityDicTxtTable : public IMetaLoadedTable<EntityDicTxtRow>
    {
        virtual ~IEntityDicTxtTable() noexcept = 0;
 
        static IEntityDicTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const EntityDicTxtRow * byKey(int i_modelId, int i_entityId, int i_langId) const = 0;
 
        static IEntityDicTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IEntityAttrTable : public IMetaLoadedTable<EntityAttrRow>
    {
        virtual ~IEntityAttrTable() noexcept = 0;
 
        static IEntityAttrTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const EntityAttrRow * byKey(int i_modelId, int i_entityId, int i_attrId) const = 0;
 
        virtual vector<EntityAttrRow> byModelIdEntityId(int i_modelId, int i_entityId) const = 0;
 
        static IEntityAttrTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IEntityAttrTxtTable : public IMetaLoadedTable<EntityAttrTxtRow>
    {
        virtual ~IEntityAttrTxtTable() noexcept = 0;
 
        static IEntityAttrTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const EntityAttrTxtRow * byKey(int i_modelId, int i_entityId, int i_attrId, int i_langId) const = 0;
 
        static IEntityAttrTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IGroupLstTable : public IMetaLoadedTable<GroupLstRow>
    {
        virtual ~IGroupLstTable() noexcept = 0;
 
        static IGroupLstTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const GroupLstRow * byKey(int i_modelId, int i_groupId) const = 0;
 
        virtual vector<GroupLstRow> byModelId(int i_modelId, bool i_isParam) const = 0;
 
        static IGroupLstTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IGroupTxtTable : public IMetaLoadedTable<GroupTxtRow>
    {
        virtual ~IGroupTxtTable() noexcept = 0;
 
        static IGroupTxtTable * create(IDbExec * i_dbExec, int i_modelId = 0, int i_langId = -1);
 
        virtual const GroupTxtRow * byKey(int i_modelId, int i_groupId, int i_langId) const = 0;
 
        static IGroupTxtTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IGroupPcTable : public IMetaLoadedTable<GroupPcRow>
    {
        virtual ~IGroupPcTable() noexcept = 0;
 
        static IGroupPcTable * create(IDbExec * i_dbExec, int i_modelId = 0);
 
        virtual const GroupPcRow * byKey(int i_modelId, int i_groupId, int i_chidPos) const = 0;
 
        virtual vector<GroupPcRow> byModelId(int i_modelId) const = 0;
 
        virtual vector<int> groupLeafs(int i_modelId, int i_groupId) const = 0;
 
        static IGroupPcTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IProfileLstTable : public IMetaLoadedTable<ProfileLstRow>
    {
        virtual ~IProfileLstTable() noexcept = 0;
 
        static IProfileLstTable * create(IDbExec * i_dbExec);
 
        virtual const ProfileLstRow * byKey(const string & i_name) const = 0;
 
        static IProfileLstTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IProfileOptionTable : public IMetaLoadedTable<ProfileOptionRow>
    {
        virtual ~IProfileOptionTable() noexcept = 0;
 
        static IProfileOptionTable * create(IDbExec * i_dbExec, const string & i_name = "");
 
        virtual const ProfileOptionRow * byKey(const string & i_name, const string & i_key) const = 0;
 
        virtual vector<ProfileOptionRow> byName(const string & i_name) const = 0;
 
        static IProfileOptionTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IRunLstTable : public IMetaTable<RunLstRow>
    {
        virtual ~IRunLstTable() noexcept = 0;
 
        static vector<RunLstRow> select(IDbExec * i_dbExec, int i_modelId = 0);
 
        static vector<RunLstRow> byKey(IDbExec * i_dbExec, int i_runId);
 
        static string digestRunValue(IDbExec * i_dbExec, int i_modelId, int i_runId);
 
        static string digestRunMeta(const string & i_modelDigest, const RunLstRow & i_runRow);
    };
 
    struct IRunOptionTable : public IMetaLoadedTable<RunOptionRow>
    {
        virtual ~IRunOptionTable() noexcept = 0;
 
        static IRunOptionTable * create(IDbExec * i_dbExec, int i_runId = 0);
 
        virtual const RunOptionRow * byKey(int i_runId, const string & i_key) const = 0;
 
        virtual bool isExist(int i_runId, const char * i_key) const noexcept = 0;
 
        virtual string strValue(int i_runId, const char * i_key, const string & i_default = "") const noexcept = 0;
 
        virtual bool boolValue(int i_runId, const char * i_key) const noexcept = 0;
 
        virtual int boolValueToInt(int i_runId, const char * i_key) const noexcept = 0;
 
        virtual int intValue(int i_runId, const char * i_key, int i_default) const noexcept = 0;
 
        virtual long long longValue(int i_runId, const char * i_key, long long i_default) const noexcept = 0;
 
        virtual double doubleValue(int i_runId, const char * i_key, double i_default) const noexcept = 0;
 
        static IRunOptionTable * create(IRowBaseVec & io_rowVec);
 
        virtual IRowBaseVec & rowsRef(void) = 0;
    };
 
    struct IWorksetLstTable : public IMetaTable<WorksetLstRow>
    {
        virtual ~IWorksetLstTable() noexcept = 0;
 
        static vector<WorksetLstRow> select(IDbExec * i_dbExec, int i_modelId = 0);
 
        static vector<WorksetLstRow> byKey(IDbExec * i_dbExec, int i_setId);
    };
 
    struct IWorksetTxtTable : public IMetaTable<WorksetTxtRow>
    {
        virtual ~IWorksetTxtTable() noexcept = 0;
 
        static vector<WorksetTxtRow> select(IDbExec * i_dbExec, int i_setId, int i_langId = -1);
 
        static vector<WorksetTxtRow> byKey(IDbExec * i_dbExec, int i_setId, int i_langId);
    };
 
    struct IWorksetParamTable : public IMetaTable<WorksetParamRow>
    {
        virtual ~IWorksetParamTable() noexcept = 0;
 
        static vector<WorksetParamRow> select(IDbExec * i_dbExec, int i_setId = 0);
 
        static vector<WorksetParamRow> byKey(IDbExec * i_dbExec, int i_setId, int i_paramId);
    };
 
    struct IWorksetParamTxtTable : public IMetaTable<WorksetParamTxtRow>
    {
        virtual ~IWorksetParamTxtTable() noexcept = 0;
 
        static vector<WorksetParamTxtRow> select(IDbExec * i_dbExec, int i_setId = 0, int i_langId = -1);
 
        static vector<WorksetParamTxtRow> byKey(IDbExec * i_dbExec, int i_setId, int i_paramId, int i_langId);
    };
 
 
    struct ITaskLstTable : public IMetaTable<TaskLstRow>
    {
        virtual ~ITaskLstTable() noexcept = 0;
 
        static vector<TaskLstRow> select(IDbExec * i_dbExec, int i_modelId = 0);
 
        static vector<TaskLstRow> byKey(IDbExec * i_dbExec, int i_taskId);
    };
 
    struct ITaskTxtTable : public IMetaTable<TaskTxtRow>
    {
        virtual ~ITaskTxtTable() noexcept = 0;
 
        static vector<TaskTxtRow> select(IDbExec * i_dbExec, int i_langId = -1);
 
        static vector<TaskTxtRow> byKey(IDbExec * i_dbExec, int i_taskId, int i_langId);
    };
 
    struct ITaskSetTable : public IMetaTable<TaskSetRow>
    {
        virtual ~ITaskSetTable() noexcept = 0;
 
        static vector<TaskSetRow> select(IDbExec * i_dbExec, int i_taskId = 0);
 
        static vector<TaskSetRow> byKey(IDbExec * i_dbExec, int i_taskId, int i_setId);
    };
 
    struct ITaskRunLstTable : public IMetaTable<TaskRunLstRow>
    {
        virtual ~ITaskRunLstTable() noexcept = 0;
 
        static vector<TaskRunLstRow> select(IDbExec * i_dbExec, int i_taskId = 0);
 
        static vector<TaskRunLstRow> byKey(IDbExec * i_dbExec, int i_taskRunId);
    };
 
    struct ITaskRunSetTable : public IMetaTable<TaskRunSetRow>
    {
        virtual ~ITaskRunSetTable() noexcept = 0;
 
        static vector<TaskRunSetRow> select(IDbExec * i_dbExec, int i_taskRunId = 0);
 
        static vector<TaskRunSetRow> byKey(IDbExec * i_dbExec, int i_taskRunId, int i_runId);
    };
}
 
#endif  // DB_META_TABLE_H