dbMetaRow.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 OM_DB_META_ROW_H
#define OM_DB_META_ROW_H
 
#include <memory>
using namespace std;
 
#include "libopenm/omLog.h"
#include "dbCommon.h"
 
namespace openm
{
    template<class TRow> struct IMetaRow : public IRowBase
    {
        static bool keyLess(const IRowBaseUptr & i_left, const IRowBaseUptr & i_right)
        {
            return TRow::isKeyLess(*dynamic_cast<TRow *>(i_left.get()), *dynamic_cast<TRow *>(i_right.get()));
        }
 
        static bool keyEqual(const IRowBaseUptr & i_left, const IRowBaseUptr & i_right)
        {
            return TRow::isKeyEqual(*dynamic_cast<TRow *>(i_left.get()), *dynamic_cast<TRow *>(i_right.get()));
        }
    };
 
    struct LangLstRow : public IMetaRow<LangLstRow>
    {
        int langId;
 
        string code;
 
        string name;
        
        LangLstRow(int i_langId) : 
            langId(i_langId), 
            code(""), 
            name("")
        { }
 
        LangLstRow(const string & i_code) : 
            langId(0), 
            code(i_code), 
            name("")
        { }
 
        LangLstRow(void) : LangLstRow(0) { }
 
        ~LangLstRow(void) noexcept { }
 
        static bool isKeyLess(const LangLstRow & i_left, const LangLstRow & i_right);
 
        static bool isKeyEqual(const LangLstRow & i_left, const LangLstRow & i_right);
 
        static bool isCodeLess(const LangLstRow & i_left, const LangLstRow & i_right);
 
        static bool isCodeEqual(const LangLstRow & i_left, const LangLstRow & i_right);
    };
 
    struct LangWordRow : public IMetaRow<LangWordRow>
    {
        int langId;
 
        string code;
 
        string value;
        
        LangWordRow(int i_langId, const string & i_code) : 
            langId(i_langId), 
            code(i_code), 
            value("")
        { }
 
        LangWordRow(void) : LangWordRow(0, "") { }
 
        ~LangWordRow(void) noexcept { }
 
        static bool isKeyLess(const LangWordRow & i_left, const LangWordRow & i_right);
 
        static bool isKeyEqual(const LangWordRow & i_left, const LangWordRow & i_right);
    };
 
    struct ModelDicRow : public IMetaRow<ModelDicRow>
    {
        int modelId;
 
        string name;
 
        string digest;
 
        int type;
 
        string version;
 
        string createDateTime;
 
        int defaultLangId;
 
 
        ModelDicRow(int i_modelId) : 
            modelId(i_modelId), 
            name(""), 
            digest(""), 
            type(0),
            version(""),
            createDateTime(""),
            defaultLangId(0)
        { }
 
        ModelDicRow(void) : ModelDicRow(0) { }
 
        ~ModelDicRow(void) noexcept { }
 
        static bool isKeyLess(const ModelDicRow & i_left, const ModelDicRow & i_right);
 
        static bool isKeyEqual(const ModelDicRow & i_left, const ModelDicRow & i_right);
    };
 
 
    struct ModelDicLangRow : public ModelDicRow
    {
        string defaultLangCode;
    };
 
    struct ModelDicTxtRow : public IMetaRow<ModelDicTxtRow>
    {
        int modelId;
 
        int langId;
 
        string descr;
 
        string note;
 
        ModelDicTxtRow(int i_modelId, int i_langId) : 
            modelId(i_modelId), 
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        ModelDicTxtRow(void) : ModelDicTxtRow(0, 0) { }
 
        ~ModelDicTxtRow(void) noexcept { }
 
        static bool isKeyLess(const ModelDicTxtRow & i_left, const ModelDicTxtRow & i_right);
 
        static bool isKeyEqual(const ModelDicTxtRow & i_left, const ModelDicTxtRow & i_right);
    };
 
    struct ModelDicTxtLangRow : public ModelDicTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const ModelDicTxtLangRow & i_left, const ModelDicTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const ModelDicTxtLangRow & i_left, const ModelDicTxtLangRow & i_right);
    };
 
    struct ModelWordRow : public IMetaRow<ModelWordRow>
    {
        int modelId;
 
        int langId;
 
        string code;
 
        string value;
 
        ModelWordRow(int i_modelId, int i_langId, const string & i_code) : 
            modelId(i_modelId), 
            langId(i_langId),
            code(i_code), 
            value("")
        { }
 
        ModelWordRow(void) : ModelWordRow(0, 0, "") { }
 
        ~ModelWordRow(void) noexcept { }
 
        static bool isKeyLess(const ModelWordRow & i_left, const ModelWordRow & i_right);
 
        static bool isKeyEqual(const ModelWordRow & i_left, const ModelWordRow & i_right);
    };
 
    struct ModelWordLangRow : public ModelWordRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const ModelWordLangRow & i_left, const ModelWordLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const ModelWordLangRow & i_left, const ModelWordLangRow & i_right);
    };
 
    struct TypeDicRow : public IMetaRow<TypeDicRow>
    {
        int modelId;
 
        int typeId;
 
        string name;
 
        string digest;
 
        int dicId;
 
        int totalEnumId;
 
        TypeDicRow(int i_modelId, int i_typeId) :
            modelId(i_modelId),
            typeId(i_typeId),
            name(""),
            dicId(0),
            totalEnumId(0)
        { }
 
        TypeDicRow(void) : TypeDicRow(0, 0) { }
 
        ~TypeDicRow(void) noexcept { }
 
        static bool isKeyLess(const TypeDicRow & i_left, const TypeDicRow & i_right);
 
        static bool isKeyEqual(const TypeDicRow & i_left, const TypeDicRow & i_right);
 
        static vector<TypeDicRow>::const_iterator byKey(int i_modelId, int i_typeId, const vector<TypeDicRow> & i_rowVec);
 
        bool isBool(void) const { return isBoolType(name.c_str()); };
 
        bool isString(void) const { return isStringType(name.c_str()); };
 
        bool isBigInt(void) const { return isBigIntType(name.c_str()); };
 
        bool isInt(void) const { return isIntType(name.c_str(), typeId); };
 
        bool isFloat(void) const { return isFloatType(name.c_str()); };
 
        bool isTime(void) const { return isTimeType(name.c_str()); };
 
        bool isBuiltIn(void) const { return isBuiltInType(typeId); }
    };
 
    struct TypeDicTxtRow : public IMetaRow<TypeDicTxtRow>
    {
        int modelId;
 
        int typeId;
 
        int langId;
        
        string descr;
        
        string note;
        
        TypeDicTxtRow(int i_modelId, int i_typeId, int i_langId) : 
            modelId(i_modelId), 
            typeId(i_typeId), 
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        TypeDicTxtRow(void) : TypeDicTxtRow(0, 0, 0) { }
 
        ~TypeDicTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TypeDicTxtRow & i_left, const TypeDicTxtRow & i_right);
 
        static bool isKeyEqual(const TypeDicTxtRow & i_left, const TypeDicTxtRow & i_right);
    };
 
    struct TypeDicTxtLangRow : public TypeDicTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TypeDicTxtLangRow & i_left, const TypeDicTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TypeDicTxtLangRow & i_left, const TypeDicTxtLangRow & i_right);
    };
 
    struct TypeEnumLstRow : public IMetaRow<TypeEnumLstRow>
    {
        int modelId;
 
        int typeId;
 
        int enumId;
 
        string name;
 
        TypeEnumLstRow(int i_modelId, int i_typeId, int i_enumId) : 
            modelId(i_modelId), 
            typeId(i_typeId), 
            enumId(i_enumId), 
            name("")
        { }
 
        TypeEnumLstRow(void) : TypeEnumLstRow(0, 0, 0) { }
 
        ~TypeEnumLstRow(void) noexcept { }
 
        static bool isKeyLess(const TypeEnumLstRow & i_left, const TypeEnumLstRow & i_right);
 
        static bool isKeyEqual(const TypeEnumLstRow & i_left, const TypeEnumLstRow & i_right);
    };
 
    struct TypeEnumTxtRow : public IMetaRow<TypeEnumTxtRow>
    {
        int modelId;
 
        int typeId;
 
        int enumId;
        
        int langId;
        
        string descr;
        
        string note;
        
        TypeEnumTxtRow(int i_modelId, int i_typeId, int i_enumId, int i_langId) : 
            modelId(i_modelId), 
            typeId(i_typeId), 
            enumId(i_enumId),
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        TypeEnumTxtRow(void) : TypeEnumTxtRow(0, 0, 0, 0) { }
 
        ~TypeEnumTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TypeEnumTxtRow & i_left, const TypeEnumTxtRow & i_right);
 
        static bool isKeyEqual(const TypeEnumTxtRow & i_left, const TypeEnumTxtRow & i_right);
    };
 
    struct TypeEnumTxtLangRow : public TypeEnumTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TypeEnumTxtLangRow & i_left, const TypeEnumTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TypeEnumTxtLangRow & i_left, const TypeEnumTxtLangRow & i_right);
    };
 
    struct ParamDicRow : public IMetaRow<ParamDicRow>
    {
        int modelId;
 
        int paramId;
 
        string paramName;
 
        int paramHid;
 
        string digest;
 
        int rank;
 
        int typeId;
 
        bool isExtendable;
 
        bool isHidden;
 
        int numCumulated;
 
        string dbRunTable;
 
        string dbSetTable;
 
        string importDigest;
 
        ParamDicRow(int i_modelId, int i_paramId) : 
            modelId(i_modelId), 
            paramId(i_paramId), 
            paramName(""),
            paramHid(0),
            digest(""),
            rank(0),
            typeId(0),
            isExtendable(false),
            isHidden(false),
            numCumulated(0),
            dbRunTable(""),
            dbSetTable(""),
            importDigest("")
        { }
 
        ParamDicRow(void) : ParamDicRow(0, 0) { }
 
        ~ParamDicRow(void) noexcept { }
 
        static bool isKeyLess(const ParamDicRow & i_left, const ParamDicRow & i_right);
 
        static bool isKeyEqual(const ParamDicRow & i_left, const ParamDicRow & i_right);
 
        static vector<ParamDicRow>::const_iterator byKey(int i_modelId, int i_paramId, const vector<ParamDicRow> & i_rowVec);
    };
 
    struct ParamImportRow : public IMetaRow<ParamImportRow>
    {
        int modelId;
 
        int paramId;
 
        int paramHid;
 
        string fromName;
 
        string fromModel;
 
        bool isSampleDim;
 
        ParamImportRow(int i_modelId, int i_paramId) :
            modelId(i_modelId),
            paramId(i_paramId),
            paramHid(0),
            fromName(""),
            fromModel(""),
            isSampleDim(0)
        { }
 
        ParamImportRow(void) : ParamImportRow(0, 0) { }
 
        ~ParamImportRow(void) noexcept { }
 
        static bool isKeyLess(const ParamImportRow & i_left, const ParamImportRow & i_right);
 
        static bool isKeyEqual(const ParamImportRow & i_left, const ParamImportRow & i_right);
    };
 
    struct ParamDicTxtRow : public IMetaRow<ParamDicTxtRow>
    {
        int modelId;
 
        int paramId;
 
        int langId;
        
        string descr;
        
        string note;
        
        ParamDicTxtRow(int i_modelId, int i_paramId, int i_langId) : 
            modelId(i_modelId), 
            paramId(i_paramId), 
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        ParamDicTxtRow(void) : ParamDicTxtRow(0, 0, 0) { }
 
        ~ParamDicTxtRow(void) noexcept { }
 
        static bool isKeyLess(const ParamDicTxtRow & i_left, const ParamDicTxtRow & i_right);
 
        static bool isKeyEqual(const ParamDicTxtRow & i_left, const ParamDicTxtRow & i_right);
    };
 
    struct ParamDicTxtLangRow : public ParamDicTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const ParamDicTxtLangRow & i_left, const ParamDicTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const ParamDicTxtLangRow & i_left, const ParamDicTxtLangRow & i_right);
    };
 
    struct ParamDimsRow : public IMetaRow<ParamDimsRow>
    {
        int modelId;
 
        int paramId;
 
        int dimId;
 
        string name;
        
        int typeId;
 
        ParamDimsRow(int i_modelId, int i_paramId, int i_dimId) : 
            modelId(i_modelId), 
            paramId(i_paramId), 
            dimId(i_dimId),
            name(""),
            typeId(0)
        { }
 
        ParamDimsRow(void) : ParamDimsRow(0, 0, 0) { }
 
        ~ParamDimsRow(void) noexcept { }
 
        static bool isKeyLess(const ParamDimsRow & i_left, const ParamDimsRow & i_right);
 
        static bool isKeyEqual(const ParamDimsRow & i_left, const ParamDimsRow & i_right);
 
        const string columnName(void) const;
    };
 
 
    struct ParamDimsTxtRow : public IMetaRow<ParamDimsTxtRow>
    {
        int modelId;
 
        int paramId;
 
        int dimId;
 
        int langId;
 
        string descr;
 
        string note;
 
        ParamDimsTxtRow(int i_modelId, int i_paramId, int i_dimId, int i_langId) :
            modelId(i_modelId),
            paramId(i_paramId),
            dimId(i_dimId),
            langId(i_langId),
            descr(""),
            note("")
        { }
 
        ParamDimsTxtRow(void) : ParamDimsTxtRow(0, 0, 0, 0) { }
 
        ~ParamDimsTxtRow(void) noexcept { }
 
        static bool isKeyLess(const ParamDimsTxtRow & i_left, const ParamDimsTxtRow & i_right);
 
        static bool isKeyEqual(const ParamDimsTxtRow & i_left, const ParamDimsTxtRow & i_right);
    };
 
    struct ParamDimsTxtLangRow : public ParamDimsTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const ParamDimsTxtLangRow & i_left, const ParamDimsTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const ParamDimsTxtLangRow & i_left, const ParamDimsTxtLangRow & i_right);
    };
 
    struct TableDicRow : public IMetaRow<TableDicRow>
    {
        int modelId;
        
        int tableId;
        
        string tableName;
        
        int tableHid;
 
        string digest;
 
        bool isUser;
        
        int rank;
        
        bool isSparse;
        
        string dbExprTable;
 
        string dbAccTable;
 
        string dbAccAll;
 
        int exprPos;
 
        bool isHidden;
 
        string importDigest;
 
        TableDicRow(int i_modelId, int i_tableId) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            tableName(""),
            tableHid(0),
            digest(""),
            isUser(false),
            rank(1),
            isSparse(false),
            dbExprTable(""),
            dbAccTable(""),
            dbAccAll(""),
            exprPos(-1),
            isHidden(false),
            importDigest("")
        { }
 
        TableDicRow(void) : TableDicRow(0, 0) { }
 
        ~TableDicRow(void) noexcept { }
 
        static bool isKeyLess(const TableDicRow & i_left, const TableDicRow & i_right);
 
        static bool isKeyEqual(const TableDicRow & i_left, const TableDicRow & i_right);
 
        static vector<TableDicRow>::const_iterator byKey(int i_modelId, int i_tableId, const vector<TableDicRow> & i_rowVec);
    };
 
    struct TableDicTxtRow : public IMetaRow<TableDicTxtRow>
    {
        int modelId;
        
        int tableId;
        
        int langId;
        
        string descr;
        
        string note;
        
        string exprDescr;
        
        string exprNote;
        
        TableDicTxtRow(int i_modelId, int i_tableId, int i_langId) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            langId(i_langId),
            descr(""), 
            note(""),
            exprDescr(""),
            exprNote("")
        { }
 
        TableDicTxtRow(void) : TableDicTxtRow(0, 0, 0) { }
 
        ~TableDicTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TableDicTxtRow & i_left, const TableDicTxtRow & i_right);
 
        static bool isKeyEqual(const TableDicTxtRow & i_left, const TableDicTxtRow & i_right);
    };
 
    struct TableDicTxtLangRow : public TableDicTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TableDicTxtLangRow & i_left, const TableDicTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TableDicTxtLangRow & i_left, const TableDicTxtLangRow & i_right);
    };
 
    struct TableDimsRow : public IMetaRow<TableDimsRow>
    {
        int modelId;
        
        int tableId;
        
        int dimId;
 
        string name;
        
        int typeId;
        
        bool isTotal;
        
        int dimSize;
 
        TableDimsRow(int i_modelId, int i_tableId, int i_dimId) :
            modelId(i_modelId), 
            tableId(i_tableId), 
            dimId(i_dimId),
            name(""),
            typeId(0),
            isTotal(false),
            dimSize(1)
        { }
 
        TableDimsRow(void) : TableDimsRow(0, 0, 0) { }
 
        ~TableDimsRow(void) noexcept { }
 
        static bool isKeyLess(const TableDimsRow & i_left, const TableDimsRow & i_right);
        
        static bool isKeyEqual(const TableDimsRow & i_left, const TableDimsRow & i_right);
 
        const string columnName(void) const;
    };
 
    struct TableDimsTxtRow : public IMetaRow<TableDimsTxtRow>
    {
        int modelId;
        
        int tableId;
        
        int dimId;
 
        int langId;
        
        string descr;
        
        string note;
        
        TableDimsTxtRow(int i_modelId, int i_tableId, int i_dimId, int i_langId) :
            modelId(i_modelId), 
            tableId(i_tableId), 
            dimId(i_dimId),
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        TableDimsTxtRow(void) : TableDimsTxtRow(0, 0, 0, 0) { }
 
        ~TableDimsTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TableDimsTxtRow & i_left, const TableDimsTxtRow & i_right);
 
        static bool isKeyEqual(const TableDimsTxtRow & i_left, const TableDimsTxtRow & i_right);
    };
 
    struct TableDimsTxtLangRow : public TableDimsTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TableDimsTxtLangRow & i_left, const TableDimsTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TableDimsTxtLangRow & i_left, const TableDimsTxtLangRow & i_right);
    };
 
    struct TableAccRow : public IMetaRow<TableAccRow>
    {
        int modelId;
        
        int tableId;
        
        int accId;
        
        string name;
 
        bool isDerived;
        
        string accSrc;
        
        string accSql;
 
        TableAccRow(int i_modelId, int i_tableId, int i_accid) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            accId(i_accid), 
            name(""),
            isDerived(false),
            accSrc(""),
            accSql("")
        { }
 
        TableAccRow(void) : TableAccRow(0, 0, 0) { }
 
        ~TableAccRow(void) noexcept { }
 
        static bool isKeyLess(const TableAccRow & i_left, const TableAccRow & i_right);
 
        static bool isKeyEqual(const TableAccRow & i_left, const TableAccRow & i_right);
 
        static vector<TableAccRow>::const_iterator byKey(int i_modelId, int i_tableId, int i_accId, const vector<TableAccRow> & i_rowVec);
 
        const string columnName(void) const;
    };
 
    struct TableAccTxtRow : public IMetaRow<TableAccTxtRow>
    {
        int modelId;
        
        int tableId;
        
        int accId;
        
        int langId;
        
        string descr;
        
        string note;
 
        TableAccTxtRow(int i_modelId, int i_tableId, int i_accId, int i_langId) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            accId(i_accId),
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        TableAccTxtRow(void) : TableAccTxtRow(0, 0, 0, 0) { }
 
        ~TableAccTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TableAccTxtRow & i_left, const TableAccTxtRow & i_right);
 
        static bool isKeyEqual(const TableAccTxtRow & i_left, const TableAccTxtRow & i_right);
    };
 
    struct TableAccTxtLangRow : public TableAccTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TableAccTxtLangRow & i_left, const TableAccTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TableAccTxtLangRow & i_left, const TableAccTxtLangRow & i_right);
    };
 
    struct TableExprRow : public IMetaRow<TableExprRow>
    {
        int modelId;
        
        int tableId;
        
        int exprId;
        
        string name;
        
        int decimals;
        
        string srcExpr;
 
        string sqlExpr;
 
        TableExprRow(int i_modelId, int i_tableId, int i_exprId) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            exprId(i_exprId), 
            name(""),
            decimals(-1),
            srcExpr(""),
            sqlExpr("")
        { }
 
        TableExprRow(void) : TableExprRow(0, 0, 0) { }
 
        ~TableExprRow(void) noexcept { }
 
        static bool isKeyLess(const TableExprRow & i_left, const TableExprRow & i_right);
 
        static bool isKeyEqual(const TableExprRow & i_left, const TableExprRow & i_right);
 
        const string columnName(void) const;
    };
 
    struct TableExprTxtRow : public IMetaRow<TableExprTxtRow>
    {
        int modelId;
        
        int tableId;
        
        int exprId;
        
        int langId;
        
        string descr;
        
        string note;
 
        TableExprTxtRow(int i_modelId, int i_tableId, int i_exprId, int i_langId) : 
            modelId(i_modelId), 
            tableId(i_tableId), 
            exprId(i_exprId),
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        TableExprTxtRow(void) : TableExprTxtRow(0, 0, 0, 0) { }
 
        ~TableExprTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TableExprTxtRow & i_left, const TableExprTxtRow & i_right);
 
        static bool isKeyEqual(const TableExprTxtRow & i_left, const TableExprTxtRow & i_right);
    };
 
    struct TableExprTxtLangRow : public TableExprTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TableExprTxtLangRow & i_left, const TableExprTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TableExprTxtLangRow & i_left, const TableExprTxtLangRow & i_right);
    };
 
    struct EntityDicRow : public IMetaRow<EntityDicRow>
    {
        int modelId;
 
        int entityId;
 
        string entityName;
 
        int entityHid;
 
        string digest;
 
        EntityDicRow(int i_modelId, int i_entityId) :
            modelId(i_modelId),
            entityId(i_entityId),
            entityName(""),
            entityHid(0),
            digest("")
        { }
 
        EntityDicRow(void) : EntityDicRow(0, 0) { }
 
        ~EntityDicRow(void) noexcept { }
 
        static bool isKeyLess(const EntityDicRow & i_left, const EntityDicRow & i_right);
 
        static bool isKeyEqual(const EntityDicRow & i_left, const EntityDicRow & i_right);
 
        static vector<EntityDicRow>::const_iterator byKey(int i_modelId, int i_entityId, const vector<EntityDicRow> & i_rowVec);
    };
 
    struct EntityDicTxtRow : public IMetaRow<EntityDicTxtRow>
    {
        int modelId;
 
        int entityId;
 
        int langId;
 
        string descr;
 
        string note;
 
        EntityDicTxtRow(int i_modelId, int i_entityId, int i_langId) :
            modelId(i_modelId),
            entityId(i_entityId),
            langId(i_langId),
            descr(""),
            note("")
        { }
 
        EntityDicTxtRow(void) : EntityDicTxtRow(0, 0, 0) { }
 
        ~EntityDicTxtRow(void) noexcept { }
 
        static bool isKeyLess(const EntityDicTxtRow & i_left, const EntityDicTxtRow & i_right);
 
        static bool isKeyEqual(const EntityDicTxtRow & i_left, const EntityDicTxtRow & i_right);
    };
 
    struct EntityDicTxtLangRow : public EntityDicTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const EntityDicTxtLangRow & i_left, const EntityDicTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const EntityDicTxtLangRow & i_left, const EntityDicTxtLangRow & i_right);
    };
 
    struct EntityAttrRow : public IMetaRow<EntityAttrRow>
    {
        int modelId;
 
        int entityId;
 
        int attrId;
 
        string name;
 
        int typeId;
 
        bool isInternal;
 
        EntityAttrRow(int i_modelId, int i_entityId, int i_attrId) :
            modelId(i_modelId),
            entityId(i_entityId),
            attrId(i_attrId),
            name(""),
            typeId(0),
            isInternal(false)
        { }
 
        EntityAttrRow(void) : EntityAttrRow(0, 0, 0) { }
 
        ~EntityAttrRow(void) noexcept { }
 
        static bool isKeyLess(const EntityAttrRow & i_left, const EntityAttrRow & i_right);
 
        static bool isKeyEqual(const EntityAttrRow & i_left, const EntityAttrRow & i_right);
 
        const string columnName(void) const;
    };
 
    struct EntityAttrTxtRow : public IMetaRow<EntityAttrTxtRow>
    {
        int modelId;
 
        int entityId;
 
        int attrId;
 
        int langId;
 
        string descr;
 
        string note;
 
        EntityAttrTxtRow(int i_modelId, int i_entityId, int i_attrId, int i_langId) :
            modelId(i_modelId),
            entityId(i_entityId),
            attrId(i_attrId),
            langId(i_langId),
            descr(""),
            note("")
        { }
 
        EntityAttrTxtRow(void) : EntityAttrTxtRow(0, 0, 0, 0) { }
 
        ~EntityAttrTxtRow(void) noexcept { }
 
        static bool isKeyLess(const EntityAttrTxtRow & i_left, const EntityAttrTxtRow & i_right);
 
        static bool isKeyEqual(const EntityAttrTxtRow & i_left, const EntityAttrTxtRow & i_right);
    };
 
    struct EntityAttrTxtLangRow : public EntityAttrTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const EntityAttrTxtLangRow & i_left, const EntityAttrTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const EntityAttrTxtLangRow & i_left, const EntityAttrTxtLangRow & i_right);
    };
 
    struct GroupLstRow : public IMetaRow<GroupLstRow>
    {
        int modelId;
 
        int groupId;
 
        bool isParam;
 
        string name;
 
        bool isHidden;
 
        GroupLstRow(int i_modelId, int i_groupId) : 
            modelId(i_modelId), 
            groupId(i_groupId), 
            isParam(false),
            name(""),
            isHidden(false)
        { }
 
        GroupLstRow(void) : GroupLstRow(0, 0) { }
 
        ~GroupLstRow(void) noexcept { }
 
        static bool isKeyLess(const GroupLstRow & i_left, const GroupLstRow & i_right);
 
        static bool isKeyEqual(const GroupLstRow & i_left, const GroupLstRow & i_right);
    };
 
    struct GroupTxtRow : public IMetaRow<GroupTxtRow>
    {
        int modelId;
        
        int groupId;
        
        int langId;
        
        string descr;
        
        string note;
        
        GroupTxtRow(int i_modelId, int i_groupId, int i_langId) : 
            modelId(i_modelId), 
            groupId(i_groupId), 
            langId(i_langId),
            descr(""), 
            note("")
        { }
 
        GroupTxtRow(void) : GroupTxtRow(0, 0, 0) { }
 
        ~GroupTxtRow(void) noexcept { }
 
        static bool isKeyLess(const GroupTxtRow & i_left, const GroupTxtRow & i_right);
 
        static bool isKeyEqual(const GroupTxtRow & i_left, const GroupTxtRow & i_right);
    };
 
    struct GroupTxtLangRow : public GroupTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const GroupTxtLangRow & i_left, const GroupTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const GroupTxtLangRow & i_left, const GroupTxtLangRow & i_right);
    };
 
    struct GroupPcRow : public IMetaRow<GroupPcRow>
    {
        int modelId;
 
        int groupId;
 
        int childPos;
 
        int childGroupId;
 
        int leafId;
 
        GroupPcRow(int i_modelId, int i_groupId, int i_childPos) : 
            modelId(i_modelId), 
            groupId(i_groupId), 
            childPos(i_childPos), 
            childGroupId(-1), 
            leafId(-1)
        { }
 
        GroupPcRow(void) : GroupPcRow(0, 0, 0) { }
 
        ~GroupPcRow(void) noexcept { }
 
        static bool isKeyLess(const GroupPcRow & i_left, const GroupPcRow & i_right);
 
        static bool isKeyEqual(const GroupPcRow & i_left, const GroupPcRow & i_right);
    };
 
    struct ProfileLstRow : public IMetaRow<ProfileLstRow>
    {
        string name;
 
        ProfileLstRow(const string & i_name) : name(i_name) { }
 
        ProfileLstRow(void) : ProfileLstRow("") { }
 
        ~ProfileLstRow(void) noexcept { }
 
        static bool isKeyLess(const ProfileLstRow & i_left, const ProfileLstRow & i_right);
 
        static bool isKeyEqual(const ProfileLstRow & i_left, const ProfileLstRow & i_right);
    };
 
    struct ProfileOptionRow : public IMetaRow<ProfileOptionRow>
    {
        string name;
 
        string key;
 
        string value;
 
        ProfileOptionRow(const string & i_name, const string & i_key) :
            name(i_name),
            key(i_key),
            value("")
        { }
 
        ProfileOptionRow(void) : ProfileOptionRow("", "") { }
 
        ~ProfileOptionRow(void) noexcept { }
 
        static bool isKeyLess(const ProfileOptionRow & i_left, const ProfileOptionRow & i_right);
 
        static bool isKeyEqual(const ProfileOptionRow & i_left, const ProfileOptionRow & i_right);
    };
 
    struct RunLstRow : public IMetaRow<RunLstRow>
    {
        int runId;
 
        int modelId;
 
        string name;
 
        int subCount;
 
        int subStarted;
 
        int subCompleted;
 
        int subRestart;
 
        string createDateTime;
 
        string status;
 
        string updateDateTime;
 
        string runStamp;
 
        RunLstRow(int i_runId) : 
            runId(i_runId),
            modelId(0),
            name(""),
            subCount(0),
            subStarted(0),
            subCompleted(0),
            subRestart(0),
            createDateTime(""),
            status(""),
            updateDateTime(""),
            runStamp("")
        { }
 
        RunLstRow(void) : RunLstRow(0) { }
 
        ~RunLstRow(void) noexcept { }
 
        static bool isKeyLess(const RunLstRow & i_left, const RunLstRow & i_right);
 
        static bool isKeyEqual(const RunLstRow & i_left, const RunLstRow & i_right);
 
        static vector<RunLstRow>::const_iterator byKey(int i_runId, const vector<RunLstRow> & i_rowVec);
    };
 
    struct RunOptionRow : public IMetaRow<RunOptionRow>
    {
        int runId;
 
        string key;
 
        string value;
 
        RunOptionRow(int i_runId, const string & i_key) :
            runId(i_runId),
            key(i_key),
            value("")
        { }
 
        RunOptionRow(void) : RunOptionRow(0, "") { }
 
        ~RunOptionRow(void) noexcept { }
 
        static bool isKeyLess(const RunOptionRow & i_left, const RunOptionRow & i_right);
 
        static bool isKeyEqual(const RunOptionRow & i_left, const RunOptionRow & i_right);
    };
    struct WorksetLstRow : public IMetaRow<WorksetLstRow>
    {
        int setId;
 
        int baseRunId;
 
        int modelId;
 
        string name;
  
        bool isReadonly;
 
        string updateDateTime;
 
        WorksetLstRow(int i_setId) :
            setId(i_setId),
            baseRunId(0),
            modelId(0),
            name(""),
            isReadonly(false),
            updateDateTime("")
        { }
 
        WorksetLstRow(void) : WorksetLstRow(0) { }
 
        ~WorksetLstRow(void) noexcept { }
 
        static bool isKeyLess(const WorksetLstRow & i_left, const WorksetLstRow & i_right);
 
        static bool isKeyEqual(const WorksetLstRow & i_left, const WorksetLstRow & i_right);
 
        static vector<WorksetLstRow>::const_iterator byKey(int i_setId, const vector<WorksetLstRow> & i_rowVec);
    };
 
    struct WorksetTxtRow : public IMetaRow<WorksetTxtRow>
    {
        int setId;
 
        int langId;
 
        string descr;
 
        string note;
 
        WorksetTxtRow(int i_setId, int i_langId) :
            setId(i_setId),
            langId(i_langId),
            descr(""),
            note("")
        { }
 
        WorksetTxtRow(void) : WorksetTxtRow(0, 0) { }
 
        ~WorksetTxtRow(void) noexcept { }
 
        static bool isKeyLess(const WorksetTxtRow & i_left, const WorksetTxtRow & i_right);
 
        static bool isKeyEqual(const WorksetTxtRow & i_left, const WorksetTxtRow & i_right);
 
        static vector<WorksetTxtRow>::const_iterator byKey(int i_setId, int i_langId, const vector<WorksetTxtRow> & i_rowVec);
    };
 
    struct WorksetTxtLangRow : public WorksetTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const WorksetTxtLangRow & i_left, const WorksetTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const WorksetTxtLangRow & i_left, const WorksetTxtLangRow & i_right);
    };
 
    struct WorksetParamRow : public IMetaRow<WorksetParamRow>
    {
        int setId;
 
        int modelId;
 
        int paramId;
        
        int subCount;
 
        int defaultSubId;
 
        WorksetParamRow(int i_setId, int i_paramId) :
            setId(i_setId),
            modelId(0),
            paramId(i_paramId),
            subCount(0),
            defaultSubId(0)
        { }
 
        WorksetParamRow(void) : WorksetParamRow(0, 0) { }
 
        ~WorksetParamRow(void) noexcept { }
 
        static bool isKeyLess(const WorksetParamRow & i_left, const WorksetParamRow & i_right);
 
        static bool isKeyEqual(const WorksetParamRow & i_left, const WorksetParamRow & i_right);
 
        static vector<WorksetParamRow>::const_iterator byKey(int i_setId, int i_paramId, const vector<WorksetParamRow> & i_rowVec);
    };
 
    struct WorksetParamTxtRow : public IMetaRow<WorksetParamTxtRow>
    {
        int setId;
 
        int modelId;
 
        int paramId;
 
        int langId;
 
        string note;
 
        WorksetParamTxtRow(int i_setId, int i_langId, int i_paramId) :
            setId(i_setId),
            modelId(0),
            paramId(i_paramId),
            langId(i_langId),
            note("")
        { }
 
        WorksetParamTxtRow(void) : WorksetParamTxtRow(0, 0, 0) { }
 
        ~WorksetParamTxtRow(void) noexcept { }
 
        static bool isKeyLess(const WorksetParamTxtRow & i_left, const WorksetParamTxtRow & i_right);
 
        static bool isKeyEqual(const WorksetParamTxtRow & i_left, const WorksetParamTxtRow & i_right);
 
        static vector<WorksetParamTxtRow>::const_iterator byKey(
            int i_setId, int i_paramId, int i_langId, const vector<WorksetParamTxtRow> & i_rowVec
            );
    };
 
    struct WorksetParamTxtLangRow : public WorksetParamTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const WorksetParamTxtLangRow & i_left, const WorksetParamTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const WorksetParamTxtLangRow & i_left, const WorksetParamTxtLangRow & i_right);
    };
 
    struct TaskLstRow : public IMetaRow<TaskLstRow>
    {
        int taskId;
 
        int modelId;
 
        string name;
 
        TaskLstRow(int i_taskId) :
            taskId(i_taskId),
            modelId(0),
            name("")
        { }
 
        TaskLstRow(void) : TaskLstRow(0) { }
 
        ~TaskLstRow(void) noexcept { }
 
        static bool isKeyLess(const TaskLstRow & i_left, const TaskLstRow & i_right);
 
        static bool isKeyEqual(const TaskLstRow & i_left, const TaskLstRow & i_right);
 
        static vector<TaskLstRow>::const_iterator byKey(int i_taskId, const vector<TaskLstRow> & i_rowVec);
    };
 
    struct TaskTxtRow : public IMetaRow<TaskTxtRow>
    {
        int taskId;
 
        int langId;
 
        string descr;
 
        string note;
 
        TaskTxtRow(int i_taskId, int i_langId) :
            taskId(i_taskId),
            langId(i_langId),
            descr(""),
            note("")
        { }
 
        TaskTxtRow(void) : TaskTxtRow(0, 0) { }
 
        ~TaskTxtRow(void) noexcept { }
 
        static bool isKeyLess(const TaskTxtRow & i_left, const TaskTxtRow & i_right);
 
        static bool isKeyEqual(const TaskTxtRow & i_left, const TaskTxtRow & i_right);
 
        static vector<TaskTxtRow>::const_iterator byKey(int i_taskId, int i_langId, const vector<TaskTxtRow> & i_rowVec);
    };
 
    struct TaskTxtLangRow : public TaskTxtRow
    {
        string langCode;
 
        static bool uniqueLangKeyLess(const TaskTxtLangRow & i_left, const TaskTxtLangRow & i_right);
 
        static bool uniqueLangKeyEqual(const TaskTxtLangRow & i_left, const TaskTxtLangRow & i_right);
    };
 
    struct TaskSetRow : public IMetaRow<TaskSetRow>
    {
        int taskId;
 
        int setId;
 
        TaskSetRow(int i_taskId, int i_setId) :
            taskId(i_taskId),
            setId(i_setId)
        { }
 
        TaskSetRow(void) : TaskSetRow(0, 0) { }
 
        ~TaskSetRow(void) noexcept { }
 
        static bool isKeyLess(const TaskSetRow & i_left, const TaskSetRow & i_right);
 
        static bool isKeyEqual(const TaskSetRow & i_left, const TaskSetRow & i_right);
 
        static vector<TaskSetRow>::const_iterator byKey(int i_taskId, int i_setId, const vector<TaskSetRow> & i_rowVec);
    };
 
    struct TaskRunLstRow : public IMetaRow<TaskRunLstRow>
    {
        int taskRunId;
 
        int taskId;
 
        string name;
 
        int subCount;
 
        string createDateTime;
 
        string status;
 
        string updateDateTime;
 
        string runStamp;
 
        TaskRunLstRow(int i_taskRunId) :
            taskRunId(i_taskRunId),
            taskId(0),
            name(""),
            subCount(0),
            createDateTime(""),
            status(""),
            updateDateTime(""),
            runStamp("")
        { }
 
        TaskRunLstRow(void) : TaskRunLstRow(0) { }
 
        ~TaskRunLstRow(void) noexcept { }
 
        static bool isKeyLess(const TaskRunLstRow & i_left, const TaskRunLstRow & i_right);
 
        static bool isKeyEqual(const TaskRunLstRow & i_left, const TaskRunLstRow & i_right);
 
        static vector<TaskRunLstRow>::const_iterator byKey(int i_taskRunId, const vector<TaskRunLstRow> & i_rowVec);
    };
 
    struct TaskRunSetRow : public IMetaRow<TaskRunSetRow>
    {
        int taskRunId;
 
        int runId;
 
        int setId;
 
        int taskId;
 
        TaskRunSetRow(int i_taskRunId, int i_runId) :
            taskRunId(i_taskRunId),
            runId(i_runId),
            setId(0),
            taskId(0)
        { }
 
        TaskRunSetRow(void) : TaskRunSetRow(0, 0) { }
 
        ~TaskRunSetRow(void) noexcept { }
 
        static bool isKeyLess(const TaskRunSetRow & i_left, const TaskRunSetRow & i_right);
 
        static bool isKeyEqual(const TaskRunSetRow & i_left, const TaskRunSetRow & i_right);
 
        static vector<TaskRunSetRow>::const_iterator byKey(int i_taskRunId, int i_runId, const vector<TaskRunSetRow> & i_rowVec);
    };
 
    struct CodeValueRow : public IMetaRow<CodeValueRow>
    {
        string code;
 
        string value;
 
        CodeValueRow(const string & i_code, const string i_value) :
            code(i_code),
            value(i_value)
        { }
 
        CodeValueRow(const string & i_code) : CodeValueRow(i_code, "") { }
 
        CodeValueRow(void) : CodeValueRow("", "") { }
 
        ~CodeValueRow(void) noexcept { }
 
        static bool isKeyLess(const CodeValueRow & i_left, const CodeValueRow & i_right);
 
        static bool isKeyEqual(const CodeValueRow & i_left, const CodeValueRow & i_right);
    };
}
 
#endif  // OM_DB_META_ROW_H