db

type CalcMaps struct {
	IdToDigest   map[int]string // map of run id's to run digests
	DigestToId   map[string]int // map of run digests to run id's
	CalcIdToName map[int]string // map of calculation id to name
	CalcNameToId map[string]int // map of calculation name to id
}

type CalculateLayout struct {
	Calculate string // expression to calculate, ex.: Expr0[base] - Expr0[variant]
	CalcId    int    // calculated expression id, calc_id column in csv,     ex.: 0, 1200, 2400
	Name      string // calculated expression name, calc_name column in csv, ex.: Expr0, AVG_Expr0, RATIO_Expro0
}

type CalculateMicroLayout struct {
	Calculation []CalculateLayout // aggregation measures, ex.: OM_MIN(Salary), OM_AVG(Income[base] - Income[variant])
	GroupBy     []string          // attributes to group by
}

type CalculateTableLayout struct {
	CalculateLayout      // expression to calculate and layout
	IsAggr          bool // if true then select output table accumulator else expression
}

type CellAcc struct {
	AccId int // output table accumulator id
	SubId int // output table subvalue id
	// contains filtered or unexported fields
}

type CellAccConverter struct {
	CellTableConverter // model metadata and output table name
}

type CellAllAcc struct {
	DimIds []int     // dimensions item as enum ids or int values if dimension type simple
	SubId  int       // output table subvalue id
	IsNull []bool    // if true then value is NULL
	Value  []float64 // accumulator value(s)
}

type CellAllAccConverter struct {
	CellTableConverter        // model metadata and output table name
	ValueName          string // If ValueName is "" empty then all accumulators use for csv else one
}

type CellCodeAcc struct {
	AccId int // output table accumulator id
	SubId int // output table subvalue id
	// contains filtered or unexported fields
}

type CellCodeAllAcc struct {
	Dims   []string  // dimensions as enum codes or string of item if dimension type simple then
	SubId  int       // output table subvalue id
	IsNull []bool    // if true then value is NULL
	Value  []float64 // accumulator value(s)
}

type CellCodeExpr struct {
	ExprId int // output table expression id
	// contains filtered or unexported fields
}

type CellCodeMicro struct {
	Key  uint64      // microdata key, part of row primary key: entity_key
	Attr []attrValue // attributes value: built-in type value or enum code
}

type CellCodeMicroCalc struct {
	Attr      []attrValue // group by attributes and calculated value attribute, using enum codes for enum based attributes
	CalcName  string      // aggregation name
	RunDigest string      // model run digest
}

type CellCodeParam struct {
	SubId int // parameter subvalue id
	// contains filtered or unexported fields
}

type CellCodeTableCalc struct {
	CalcName  string // calculated expression name
	RunDigest string // model run digest
	// contains filtered or unexported fields
}

type CellEntityConverter struct {
	ModelDef    *ModelMeta     // model metadata
	Name        string         // model entity name
	EntityGen   *EntityGenMeta // model run entity generation
	IsIdCsv     bool           // if true then use enum id's else use enum codes
	DoubleFmt   string         // if not empty then format string is used to sprintf if value type is float, double, long double
	IsNoZeroCsv bool           // if true then do not write zero values into csv output
	IsNoNullCsv bool           // if true then do not write NULL values into csv output
	// contains filtered or unexported fields
}

type CellExpr struct {
	ExprId int // output table expression id
	// contains filtered or unexported fields
}

type CellExprConverter struct {
	CellTableConverter // model metadata and output table name
}

type CellIntKeys interface {

	// KeyIds return converter to copy row primary key into key []int.
	// Row primary keys are:
	//   parameter: (sub_id, dimension ids)
	//   accumulators: (acc_id, sub_id, dimension ids)
	//   all accumulators: (sub_id, dimension ids)
	//   expressions: (expr_id, dimension ids)
	KeyIds(name string) (func(interface{}, []int) error, error)
}

type CellMicro struct {
	Key  uint64      // microdata key, part of row primary key: entity_key
	Attr []attrValue // attributes value: built-in type value or enum id
}

type CellMicroCalc struct {
	Attr   []attrValue // group by attributes and calculated value attribute, using enum id's for enum based attributes
	CalcId int         // aggregation id
	RunId  int         // model run id
}

type CellMicroCalcConverter struct {
	CellEntityConverter          // model metadata, entity generation and and attributes
	CalcMaps                     // map between runs digest and id and calculations name and id
	GroupBy             []string // attributes to group by
	// contains filtered or unexported fields
}

type CellMicroConverter struct {
	CellEntityConverter // model metadata, entity generation and and attributes
}

type CellParam struct {
	SubId int // parameter subvalue id
	// contains filtered or unexported fields
}

type CellParamConverter struct {
	ModelDef  *ModelMeta // model metadata
	Name      string     // parameter name
	IsIdCsv   bool       // if true then use enum id's else use enum codes
	DoubleFmt string     // if not empty then format string is used to sprintf if value type is float, double, long double
	// contains filtered or unexported fields
}

type CellTableCalc struct {
	CalcId int // calculated expression id
	RunId  int // model run id
	// contains filtered or unexported fields
}

type CellTableCalcConverter struct {
	CellTableConverter // model metadata and output table name
	CalcMaps           // map between runs digest and id and calculations name and id
}

type CellTableConverter struct {
	ModelDef *ModelMeta // model metadata
	Name     string     // output table name

	IsIdCsv     bool   // if true then use enum id's else use enum codes
	DoubleFmt   string // if not empty then format string is used to sprintf if value type is float, double, long double
	IsNoZeroCsv bool   // if true then do not write zero values into csv output
	IsNoNullCsv bool   // if true then do not write NULL values into csv output
	// contains filtered or unexported fields
}

type CellToCodeConverter interface {

	// IdToCodeCell return converter from id cell to code cell.
	// Cell is dimensions and value of parameter or output table.
	// It does convert from enum id to code for all dimensions and enum-based parameter value.
	IdToCodeCell(modelDef *ModelMeta, name string) (func(interface{}) (interface{}, error), error)
}

type CellToIdConverter interface {

	// CodeToIdCell return converter from code cell to id cell.
	// Cell is dimensions and value of parameter or output table.
	// It does convert from enum code to id for all dimensions and enum-based parameter value.
	CodeToIdCell(modelDef *ModelMeta, name string) (func(interface{}) (interface{}, error), error)
}

type CsvConverter interface {
	// return file name of csv file to store parameter or output table rows
	CsvFileName() (string, error)

	// return true if csv converter is using enum id's for dimensions or attributes
	IsUseEnumId() bool

	// return first line of csv file with column names: expr_name,dim0,dim1,expr_value.
	// if IsIdCsv is true: expr_id,dim0,dim1,expr_value
	// if isAllAcc is true: sub_id,dim0,dim1,acc0,acc1,acc2
	CsvHeader() ([]string, error)

	// return converter from cell of parameter, output table or microdata to csv id's row []string.
	// converter simply sprint() dimension id's and value into []string buffer.
	// converter return isNotEmpty flag if cell value is not empty.
	ToCsvIdRow() (func(interface{}, []string) (bool, error), error)

	// return converter from cell of parameter, output table or microdata to csv row []string.
	// it does convert from enum id to code for all dimensions into []string buffer.
	// if this is a enum-based parameter value then it is also converted to enum code.
	// converter return isNotEmpty flag if cell value is not empty.
	ToCsvRow() (func(interface{}, []string) (bool, error), error)

	// return converter from csv row []string to parameter, output table or microdata cell (dimensions and value or microdata key and attributes value)
	CsvToCell() (func(row []string) (interface{}, error), error)
}

type CsvIntKeysConverter interface {
	CsvConverter // convert parameter row or output table row from or to row []string for csv file
	CellIntKeys  // provide a method to get row keys as []int, for example, get sub id and dimension ids
}

type DescrNote struct {
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Descr    string // descr     VARCHAR(255) NOT NULL
	Note     string // note      VARCHAR(32000)
}

type EntityAttrRow struct {
	ModelId    int    // model_id        INT          NOT NULL
	EntityId   int    // model_entity_id INT          NOT NULL
	AttrId     int    // attr_id         INT          NOT NULL
	Name       string // attr_name       VARCHAR(255) NOT NULL
	TypeId     int    // model_type_id   INT          NOT NULL
	IsInternal bool   // is_internal     SMALLINT     NOT NULL
	// contains filtered or unexported fields
}

type EntityAttrTxtRow struct {
	ModelId  int    // model_id        INT          NOT NULL
	EntityId int    // model_entity_id INT          NOT NULL
	AttrId   int    // attr_id         INT          NOT NULL
	LangCode string // lang_code       VARCHAR(32)  NOT NULL
	Descr    string // descr           VARCHAR(255) NOT NULL
	Note     string // note            VARCHAR(32000)
}

type EntityDicRow struct {
	ModelId   int    // model_id         INT          NOT NULL
	EntityId  int    // model_entity_id  INT          NOT NULL
	EntityHid int    // entity_hid       INT          NOT NULL, -- unique entity id
	Name      string // entity_name      VARCHAR(255) NOT NULL
	Digest    string // entity_digest    VARCHAR(32)  NOT NULL
}

type EntityGenMeta struct {
	GenAttr []entityGenAttrRow // entity generation attributes: entity_gen_attr join to entity_gen
	// contains filtered or unexported fields
}

type EntityMeta struct {
	EntityDicRow                 // model entity row: entity_dic join to model_entity_dic table
	Attr         []EntityAttrRow // entity attribute rows: entity_attr join to model_entity_dic table
}

type EntityRunPub struct {
	Name        string   // entity name
	GenDigest   string   // digest of entity generation, not empty only as result of select from run_entity; input from "public" digest is ignored
	ValueDigest string   // value digest, not empty only as result of select from run_entity; input from "public" value digest is ignored
	RowCount    int      // if not zero then entity microdata row count
	Attr        []string // names of entity generation attributes
}

type EntityTxtRow struct {
	ModelId  int    // model_id         INT          NOT NULL
	EntityId int    // model_entity_id  INT          NOT NULL
	LangCode string // lang_code        VARCHAR(32)  NOT NULL
	Descr    string // descr            VARCHAR(255) NOT NULL
	Note     string // note             VARCHAR(32000)
}

type Facet uint8

type FilterColumn struct {
	Name   string   // dimension or attribute name
	Op     FilterOp // filter operator: equal, IN, BETWEEN
	Values []string // enum code(s): one, two or many values depending on filter condition
}

type FilterIdColumn struct {
	Name    string   // dimension or attribute name
	Op      FilterOp // filter operator: equal, IN, BETWEEN
	EnumIds []int    // enum id(s): one, two or many ids depending on filter condition
}

type FilterOp string

type GroupLstRow struct {
	ModelId  int    // model_id     INT          NOT NULL
	GroupId  int    // group_id     INT          NOT NULL
	IsParam  bool   // is_parameter SMALLINT     NOT NULL, -- if <> 0 then parameter group else output table group
	Name     string // group_name   VARCHAR(255) NOT NULL
	IsHidden bool   // is_hidden    SMALLINT     NOT NULL
}

type GroupMeta struct {
	GroupLstRow              // parameters or output tables group rows: group_lst
	GroupPc     []GroupPcRow // group parent-child relationship rows: group_pc
}

type GroupPcRow struct {
	ModelId      int // model_id       INT NOT NULL
	GroupId      int // group_id       INT NOT NULL
	ChildPos     int // child_pos      INT NOT NULL
	ChildGroupId int // child_group_id INT NULL, -- if not NULL then id of child group
	ChildLeafId  int // leaf_id        INT NULL, -- if not NULL then id of parameter or output table
}

type GroupTxtRow struct {
	ModelId   int // model_id  INT          NOT NULL
	GroupId   int // group_id  INT          NOT NULL
	DescrNote     // language, description, notes
}

type LangLstRow struct {
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Name     string // lang_name VARCHAR(255) NOT NULL
	// contains filtered or unexported fields
}

type LangMeta struct {
	Lang []langWord // language lang_lst row and lang_word rows in that language
	// contains filtered or unexported fields
}

type LangNote struct {
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Note     string // note      VARCHAR(32000)
}

type ModelDicRow struct {
	ModelId         int    // model_id         INT          NOT NULL
	Name            string // model_name       VARCHAR(255) NOT NULL
	Digest          string // model_digest     VARCHAR(32)  NOT NULL
	Type            int    // model_type       INT          NOT NULL
	Version         string // model_ver        VARCHAR(32)  NOT NULL
	CreateDateTime  string // create_dt        VARCHAR(32)  NOT NULL
	DefaultLangCode string // model default language code
}

type ModelMeta struct {
	Model  ModelDicRow  // model_dic table row
	Type   []TypeMeta   // types metadata: type name and enums
	Param  []ParamMeta  // parameters metadata: parameter name, type, dimensions
	Table  []TableMeta  // output tables metadata: table name, dimensions, accumulators, expressions
	Entity []EntityMeta // model entities and attributes
	Group  []GroupMeta  // groups of parameters or output tables
}

type ModelTxtMeta struct {
	ModelName     string             // model name for text metadata
	ModelDigest   string             // model digest for text metadata
	ModelTxt      []ModelTxtRow      // model text rows: model_dic_txt
	TypeTxt       []TypeTxtRow       // model type text rows: type_dic_txt join to model_type_dic
	TypeEnumTxt   []TypeEnumTxtRow   // type enum text rows: type_enum_txt join to model_type_dic
	ParamTxt      []ParamTxtRow      // model parameter text rows: parameter_dic_txt join to model_parameter_dic
	ParamDimsTxt  []ParamDimsTxtRow  // parameter dimension text rows: parameter_dims_txt join to model_parameter_dic
	TableTxt      []TableTxtRow      // model output table text rows: table_dic_txt join to model_table_dic
	TableDimsTxt  []TableDimsTxtRow  // output table dimension text rows: table_dims_txt join to model_table_dic
	TableAccTxt   []TableAccTxtRow   // output table accumulator text rows: table_acc_txt join to model_table_dic
	TableExprTxt  []TableExprTxtRow  // output table expression text rows: table_expr_txt join to model_table_dic
	EntityTxt     []EntityTxtRow     // model entities text rows: entity_dic_txt join to model_entity_dic table
	EntityAttrTxt []EntityAttrTxtRow // entity attributes: entity_attr_txt join to model_entity_dic table
	GroupTxt      []GroupTxtRow      // group text rows: group_txt
}

type ModelTxtRow struct {
	ModelId  int    // model_id     INT          NOT NULL
	LangCode string // lang_code    VARCHAR(32)  NOT NULL
	Descr    string // descr        VARCHAR(255) NOT NULL
	Note     string // note         VARCHAR(32000)
}

type ModelWordMeta struct {
	ModelName   string          // model name for text metadata
	ModelDigest string          // model digest for text metadata
	ModelWord   []modelLangWord // language and db rows of model_word in that language
}

type OrderByColumn struct {
	IndexOne int  // one-based column index
	IsDesc   bool // if true then descending order
}

type ParamDicRow struct {
	ModelId      int    // model_id           INT          NOT NULL
	ParamId      int    // model_parameter_id INT          NOT NULL
	ParamHid     int    // parameter_hid      INT          NOT NULL, -- unique parameter id
	Name         string // parameter_name     VARCHAR(255) NOT NULL
	Digest       string // parameter_digest   VARCHAR(32)  NOT NULL
	Rank         int    // parameter_rank     INT          NOT NULL
	TypeId       int    // model_type_id      INT          NOT NULL
	IsExtendable bool   // is_extendable      SMALLINT     NOT NULL
	IsHidden     bool   // is_hidden          SMALLINT     NOT NULL
	NumCumulated int    // num_cumulated      INT          NOT NULL
	DbRunTable   string // db_run_table       VARCHAR(64)  NOT NULL
	DbSetTable   string // db_set_table       VARCHAR(64)  NOT NULL
	ImportDigest string // import_digest      VARCHAR(32)  NOT NULL
}

type ParamDimsRow struct {
	ModelId int    // model_id           INT          NOT NULL
	ParamId int    // model_parameter_id INT          NOT NULL
	DimId   int    // dim_id             INT          NOT NULL
	Name    string // dim_name           VARCHAR(255) NOT NULL
	TypeId  int    // model_type_id      INT          NOT NULL
	// contains filtered or unexported fields
}

type ParamDimsTxtRow struct {
	ModelId  int    // model_id           INT          NOT NULL
	ParamId  int    // model_parameter_id INT          NOT NULL
	DimId    int    // dim_id             INT          NOT NULL
	LangCode string // lang_code          VARCHAR(32)  NOT NULL
	Descr    string // descr              VARCHAR(255) NOT NULL
	Note     string // note               VARCHAR(32000)
}

type ParamImportRow struct {
	ModelId     int    // model_id           INT          NOT NULL
	ParamId     int    // model_parameter_id INT          NOT NULL
	FromName    string // from_name          VARCHAR(255) NOT NULL
	FromModel   string // from_model_name    VARCHAR(255) NOT NULL
	IsSampleDim bool   // is_sample_dim      SMALLINT     NOT NULL
}

type ParamMeta struct {
	ParamDicRow                  // model parameter row: parameter_dic join to model_parameter_dic table
	Dim         []ParamDimsRow   // parameter dimension rows: parameter_dims join to model_parameter_dic table
	Import      []ParamImportRow // parameter import from upstream model
	// contains filtered or unexported fields
}

type ParamRunSetPub struct {
	ParamRunSetTxtPub
	SubCount     int    // number of parameter sub-values
	DefaultSubId int    // default sub-value id for that parameter workset
	ValueDigest  string // value digest, not empty only as result of select from run_parameter; input from "public" value digest is ignored
}

type ParamRunSetTxtPub struct {
	Name string     // parameter name
	Txt  []LangNote // parameter value notes by language
}

type ParamTxtRow struct {
	ModelId  int    // model_id           INT          NOT NULL
	ParamId  int    // model_parameter_id INT          NOT NULL
	LangCode string // lang_code          VARCHAR(32)  NOT NULL
	Descr    string // descr              VARCHAR(255) NOT NULL
	Note     string // note               VARCHAR(32000)
}

type ParamValuePub struct {
	ParamRunSetPub                 // parameter metadata
	Kind           string          // where to get parameter from: "value", "run", "set" or empty "" which is "value" by default
	From           string          // run digest (or name or stamp) or workset name to copy parameter from
	Value          []CellCodeParam // parameter value(s)
}

type ProfileMeta struct {
	Name string            // profile name
	Opts map[string]string // profile (key, value) options
}

type ReadCalculteMicroLayout struct {
	ReadLayout           // entity name, run id, page size, where filters and order by
	CalculateMicroLayout // microdata aggregations
}

type ReadCalculteTableLayout struct {
	ReadLayout                         // output table name, run id, page size, where filters and order by
	Calculation []CalculateTableLayout // additional measures to calculate
}

type ReadCompareMicroLayout struct {
	ReadCalculteMicroLayout          // aggregation measures and group by attributes
	Runs                    []string // runs to compare: list of digest, stamp or name
}

type ReadCompareTableLayout struct {
	ReadCalculteTableLayout          // output table, base run and comparison expressions or calculations
	Runs                    []string // runs to compare: list of digest, stamp or name
}

type ReadLayout struct {
	Name           string           // parameter name, output table name or entity microdata name
	FromId         int              // run id or set id to select input parameter, output table values or microdata from
	ReadPageLayout                  // read page first row offset, size and last page flag
	Filter         []FilterColumn   // dimension or attribute filters, final WHERE does join all filters by AND
	FilterById     []FilterIdColumn // dimension or attribute filters by enum ids, final WHERE does join filters by AND
	OrderBy        []OrderByColumn  // order by columnns, if empty then dimension id ascending order is used
}

type ReadMicroLayout struct {
	ReadLayout        // entity name, run id, page size, where filters and order by
	GenDigest  string // entity generation digest
}

type ReadPageLayout struct {
	Offset     int64 // first row to return from select, zero-based ofsset
	Size       int64 // max row count to select, if <= 0 then all rows
	IsLastPage bool  // output last page flag: return true if it was a last page of rows
	IsFullPage bool  // input last page flag: if true then adjust offset to return full last page
}

type ReadParamLayout struct {
	ReadLayout           // parameter name, run id or set id page size, where filters and order by
	IsFromSet       bool // if true then select from workset else from model run
	IsEditSet       bool // if true then workset must be editable (readonly = false)
	ReadSubIdLayout      // sub-value id filter: select rows with only one sub-value id
}

type ReadSubIdLayout struct {
	IsSubId bool // if true then select only single sub-value id
	SubId   int  // sub-value id to select rows from output table or parameter
}

type ReadTableLayout struct {
	ReadLayout             // output table name, run id, page size, where filters and order by
	ValueName       string // if not empty then expression or accumulator name to select
	IsAccum         bool   // if true then select output table accumulator else expression
	IsAllAccum      bool   // if true then select from all accumulators view else from accumulators table
	ReadSubIdLayout        // sub-value id filter: select rows with only one sub-value id
}

type RunEntityRow struct {
	RunId       int    // run_id         INT         NOT NULL
	GenHid      int    // entity_gen_hid INT NOT NULL
	RowCount    int    // row_count    INT NOT NULL, -- if not zero then entity microdata row count
	ValueDigest string // value_digest VARCHAR(32),  -- if not NULL then digest of table value for the run
}

type RunMeta struct {
	Run       RunRow            // model run master row: run_lst
	Txt       []RunTxtRow       // run text rows: run_txt
	Opts      map[string]string // options used to run the model: run_option
	Param     []runParam        // run parameters: parameter_hid, sub-value count, run_parameter_txt table rows
	Table     []runTable        // run tables: table_hid fom run_table rows
	EntityGen []EntityGenMeta   // run entity generation: entity_gen, entity_gen_attr table rows
	RunEntity []RunEntityRow    // run microdata entities: run_entity table rows
	Progress  []RunProgress     // run progress by sub-values: run_progress table rows
}

type RunParamTxtRow struct {
	RunId    int    // run_id        INT         NOT NULL
	ParamHid int    // parameter_hid INT         NOT NULL
	LangCode string // lang_code     VARCHAR(32) NOT NULL
	Note     string // note          VARCHAR(32000)
}

type RunProgress struct {
	SubId          int     // sub_id         INT         NOT NULL, -- sub-value id (zero based index)
	CreateDateTime string  // create_dt      VARCHAR(32) NOT NULL, -- start date-time
	Status         string  // status         VARCHAR(1)  NOT NULL, -- run status: i=init p=progress s=success x=exit e=error(failed)
	UpdateDateTime string  // update_dt      VARCHAR(32) NOT NULL, -- last update date-time
	Count          int     // progress_count INT         NOT NULL, -- progress count: percent completed
	Value          float64 // progress_value FLOAT       NOT NULL, -- progress value: number of cases (case based) or time (time based)
}

type RunPub struct {
	ModelName           string            // model name for that run
	ModelDigest         string            // model digest for that run
	ModelVersion        string            // model_ver     VARCHAR(32)  NOT NULL
	ModelCreateDateTime string            // create_dt     VARCHAR(32)  NOT NULL
	Name                string            // run_name      VARCHAR(255) NOT NULL
	SubCount            int               // sub_count     INT          NOT NULL, -- subvalue count
	SubStarted          int               // sub_started   INT          NOT NULL, -- number of subvalues started
	SubCompleted        int               // sub_completed INT          NOT NULL, -- number of subvalues completed
	CreateDateTime      string            // create_dt     VARCHAR(32)  NOT NULL, -- start date-time
	Status              string            // status        VARCHAR(1)   NOT NULL, -- run status: i=init p=progress s=success x=exit e=error(failed)
	UpdateDateTime      string            // update_dt     VARCHAR(32)  NOT NULL, -- last update date-time
	RunId               int               // used only as output value, input value ignored
	RunDigest           string            // run_digest    VARCHAR(32)  NULL,     -- digest of the run metadata: model digest, run name, sub count, created date-time, run stamp
	ValueDigest         string            // value_digest  VARCHAR(32),           -- if not NULL then digest of the run values: all parameters and output tables
	RunStamp            string            // run_stamp     VARCHAR(32)  NOT NULL, -- process run stamp, by default is log time stamp
	Txt                 []DescrNote       // run text: description and notes by language
	Opts                map[string]string // options used to run the model: run_option
	Param               []ParamRunSetPub  // run parameters: name, sub-value count and value notes by language
	Table               []TableRunPub     // run tables: name for tables included in run_table
	Entity              []EntityRunPub    // run entities: entity generation and attributes
	Progress            []RunProgress     // run progress by sub-values: run_progress table rows
}

type RunRow struct {
	RunId          int    // run_id        INT          NOT NULL, -- unique run id
	ModelId        int    // model_id      INT          NOT NULL
	Name           string // run_name      VARCHAR(255) NOT NULL, -- model run name
	SubCount       int    // sub_count     INT          NOT NULL, -- subvalue count
	SubStarted     int    // sub_started   INT          NOT NULL, -- number of subvalues started
	SubCompleted   int    // sub_completed INT          NOT NULL, -- number of subvalues completed
	CreateDateTime string // create_dt     VARCHAR(32)  NOT NULL, -- start date-time
	Status         string // status        VARCHAR(1)   NOT NULL, -- run status: i=init p=progress s=success x=exit e=error(failed)
	UpdateDateTime string // update_dt     VARCHAR(32)  NOT NULL, -- last update date-time
	RunDigest      string // run_digest    VARCHAR(32)  NULL,     -- digest of the run metadata: model digest, run name, sub count, created date-time, run stamp
	ValueDigest    string // value_digest  VARCHAR(32),           -- if not NULL then digest of the run values: all parameters and output tables
	RunStamp       string // run_stamp     VARCHAR(32)  NOT NULL, -- process run stamp, by default is log time stamp
}

type RunTxtRow struct {
	RunId    int    // run_id    INT          NOT NULL
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Descr    string // descr     VARCHAR(255) NOT NULL
	Note     string // note      VARCHAR(32000)
}

type TableAccRow struct {
	ModelId   int    // model_id       INT          NOT NULL
	TableId   int    // model_table_id INT           NOT NULL
	AccId     int    // acc_id         INT           NOT NULL
	Name      string // acc_name       VARCHAR(255)  NOT NULL
	IsDerived bool   // is_derived     SMALLINT      NOT NULL
	SrcAcc    string // acc_src        VARCHAR(255)  NOT NULL
	AccSql    string // acc_sql        VARCHAR(2048) NOT NULL
	// contains filtered or unexported fields
}

type TableAccTxtRow struct {
	ModelId  int    // model_id       INT          NOT NULL
	TableId  int    // model_table_id INT          NOT NULL
	AccId    int    // acc_id         INT          NOT NULL
	LangCode string // lang_code      VARCHAR(32)  NOT NULL
	Descr    string // descr          VARCHAR(255) NOT NULL
	Note     string // note           VARCHAR(32000)
}

type TableDicRow struct {
	ModelId      int    // model_id        INT          NOT NULL
	TableId      int    // model_table_id  INT          NOT NULL
	TableHid     int    // table_hid       INT          NOT NULL, -- unique table id
	Name         string // table_name      VARCHAR(255) NOT NULL
	Digest       string // table_digest    VARCHAR(32)  NOT NULL
	IsUser       bool   // is_user         SMALLINT     NOT NULL
	Rank         int    // table_rank      INT          NOT NULL
	IsSparse     bool   // is_sparse       SMALLINT     NOT NULL
	DbExprTable  string // db_expr_table   VARCHAR(64)  NOT NULL
	DbAccTable   string // db_acc_table    VARCHAR(64)  NOT NULL
	DbAccAllView string // db_acc_all_view VARCHAR(64)  NOT NULL
	ExprPos      int    // expr_dim_pos    INT          NOT NULL
	IsHidden     bool   // is_hidden       SMALLINT     NOT NULL
	ImportDigest string // import_digest   VARCHAR(32)  NOT NULL
}

type TableDimsRow struct {
	ModelId int    // model_id       INT          NOT NULL
	TableId int    // model_table_id INT          NOT NULL
	DimId   int    // dim_id         INT          NOT NULL
	Name    string // dim_name       VARCHAR(255) NOT NULL
	TypeId  int    // model_type_id  INT          NOT NULL
	IsTotal bool   // is_total       SMALLINT     NOT NULL
	DimSize int    // dim_size       INT          NOT NULL
	// contains filtered or unexported fields
}

type TableDimsTxtRow struct {
	ModelId  int    // model_id       INT          NOT NULL
	TableId  int    // model_table_id INT          NOT NULL
	DimId    int    // dim_id         INT          NOT NULL
	LangCode string // lang_code      VARCHAR(32)  NOT NULL
	Descr    string // descr          VARCHAR(255) NOT NULL
	Note     string // note           VARCHAR(32000)
}

type TableExprRow struct {
	ModelId  int    // model_id       INT           NOT NULL
	TableId  int    // model_table_id INT           NOT NULL
	ExprId   int    // expr_id        INT           NOT NULL
	Name     string // expr_name      VARCHAR(255)  NOT NULL
	Decimals int    // expr_decimals  INT           NOT NULL
	SrcExpr  string // expr_src       VARCHAR(255)  NOT NULL
	ExprSql  string // expr_sql       VARCHAR(2048) NOT NULL
	// contains filtered or unexported fields
}

type TableExprTxtRow struct {
	ModelId  int    // model_id       INT          NOT NULL
	TableId  int    // model_table_id INT          NOT NULL
	ExprId   int    // expr_id        INT           NOT NULL
	LangCode string // lang_code      VARCHAR(32)  NOT NULL
	Descr    string // descr          VARCHAR(255) NOT NULL
	Note     string // note           VARCHAR(32000)
}

type TableMeta struct {
	TableDicRow                // model output table row: table_dic join to model_table_dic
	Dim         []TableDimsRow // output table dimension rows: table_dims join to model_table_dic
	Acc         []TableAccRow  // output table accumulator rows: table_acc join to model_table_dic
	Expr        []TableExprRow // output table expression rows: table_expr join to model_table_dic
	// contains filtered or unexported fields
}

type TableRunPub struct {
	Name        string // parameter name
	ValueDigest string // value digest, not empty only as result of select from table_parameter; input from "public" value digest is ignored
}

type TableTxtRow struct {
	ModelId   int    // model_id       INT          NOT NULL
	TableId   int    // model_table_id INT          NOT NULL
	LangCode  string // lang_code      VARCHAR(32)  NOT NULL
	Descr     string // descr          VARCHAR(255) NOT NULL
	Note      string // note           VARCHAR(32000)
	ExprDescr string // expr_descr     VARCHAR(255) NOT NULL
	ExprNote  string // expr_note      VARCHAR(32000)
}

type TaskDef struct {
	Task TaskRow      // modeling task row: task_lst
	Txt  []TaskTxtRow // task text rows: task_txt
	Set  []int        // task body (current list of workset id's): task_set
}

type TaskDefPub struct {
	ModelName           string      // model name for that task list
	ModelDigest         string      // model digest for that task list
	ModelVersion        string      // model_ver     VARCHAR(32)  NOT NULL
	ModelCreateDateTime string      // create_dt     VARCHAR(32)  NOT NULL
	Name                string      // task_name    VARCHAR(255) NOT NULL
	Txt                 []DescrNote // task text: description and notes by language
	Set                 []string    // task body: list of workset names
}

type TaskMeta struct {
	TaskDef               // task definition: metadata and input worksets
	TaskRun []taskRunItem // task run history: task_run_lst and task_run_set rows
}

type TaskPub struct {
	TaskDefPub              // task definition: metadata and input worksets
	TaskRun    []taskRunPub // task run history: task_run_lst
}

type TaskRow struct {
	TaskId  int    // task_id      INT          NOT NULL, -- unique task id
	ModelId int    // model_id     INT          NOT NULL
	Name    string // task_name    VARCHAR(255) NOT NULL
}

type TaskRunRow struct {
	TaskRunId      int    // task_run_id INT          NOT NULL, -- unique task run id
	TaskId         int    // task_id     INT          NOT NULL
	Name           string // run_name    VARCHAR(255) NOT NULL, -- task run name
	SubCount       int    // sub_count   INT          NOT NULL, -- subvalue count of task run
	CreateDateTime string // create_dt   VARCHAR(32)  NOT NULL, -- start date-time
	Status         string // status      VARCHAR(1)   NOT NULL, -- task status: i=init p=progress w=wait s=success x=exit e=error(failed)
	UpdateDateTime string // update_dt   VARCHAR(32)  NOT NULL, -- last update date-time
	RunStamp       string // run_stamp   VARCHAR(32)  NOT NULL, -- process run stamp, by default is log time stamp
}

type TaskRunSetRow struct {
	TaskRunId int // task_run_id INT NOT NULL
	RunId     int // run_id      INT NOT NULL, -- if > 0 then result run id
	SetId     int // set_id      INT NOT NULL, -- if > 0 then input working set id
	TaskId    int // task_id     INT NOT NULL
}

type TaskRunSetTxt struct {
	SetTxt map[string][]DescrNote // map workset name to description and notes by language
	RunTxt map[string][]DescrNote // map run digest-or-name to description and notes by language
}

type TaskTxtRow struct {
	TaskId   int    // task_id  INT           NOT NULL
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Descr    string // descr     VARCHAR(255) NOT NULL
	Note     string // note      VARCHAR(32000)
}

type TypeDicRow struct {
	ModelId     int    // model_id      INT          NOT NULL
	TypeId      int    // model_type_id INT          NOT NULL
	TypeHid     int    // type_hid      INT          NOT NULL, -- unique type id
	Name        string // type_name     VARCHAR(255) NOT NULL, -- type name: int, double, etc.
	Digest      string // type_digest   VARCHAR(32)  NOT NULL
	DicId       int    // dic_id        INT NOT NULL, -- dictionary id: 0=simple 1=logical 2=classification 3=range 4=partition 5=link
	TotalEnumId int    // total_enum_id INT NOT NULL, -- if total enabled this is enum_value of total item =max+1
	IsRange     bool   // if true then it is range type and enums calculated
	MinEnumId   int    // min enum id
	MaxEnumId   int    // max enum id
	// contains filtered or unexported fields
}

type TypeEnumRow struct {
	ModelId int    // model_id      INT NOT NULL
	TypeId  int    // model_type_id INT NOT NULL
	EnumId  int    // enum_id       INT NOT NULL
	Name    string // enum_name     VARCHAR(255) NOT NULL
}

type TypeEnumTxtRow struct {
	ModelId  int    // model_id      INT          NOT NULL
	TypeId   int    // model_type_id INT          NOT NULL
	EnumId   int    // enum_id       INT          NOT NULL
	LangCode string // lang_code     VARCHAR(32)  NOT NULL
	Descr    string // descr         VARCHAR(255) NOT NULL
	Note     string // note          VARCHAR(32000)
}

type TypeMeta struct {
	TypeDicRow               // model type rows: type_dic join to model_type_dic
	Enum       []TypeEnumRow // type enum rows: type_enum_lst join to model_type_dic
}

type TypeTxtRow struct {
	ModelId  int    // model_id      INT          NOT NULL
	TypeId   int    // model_type_id INT          NOT NULL
	LangCode string // lang_code     VARCHAR(32)  NOT NULL
	Descr    string // descr         VARCHAR(255) NOT NULL
	Note     string // note          VARCHAR(32000)
}

type WorksetCreatePub struct {
	WorksetHdrPub
	Param []ParamValuePub // workset parameters: name, text (value notes by language) and value
}

type WorksetHdrPub struct {
	ModelName           string      // model name for that workset
	ModelDigest         string      // model digest for that workset
	ModelVersion        string      // model_ver     VARCHAR(32)  NOT NULL
	ModelCreateDateTime string      // create_dt     VARCHAR(32)  NOT NULL
	Name                string      // workset name: set_name VARCHAR(255) NOT NULL
	BaseRunDigest       string      // if not empty then digest of the base run
	IsReadonly          bool        // readonly flag
	UpdateDateTime      string      // last update date-time
	IsCleanBaseRun      bool        // if true then update set base run digest to NULL
	Txt                 []DescrNote // workset text: description and notes by language
}

type WorksetMeta struct {
	Set   WorksetRow      // workset master row: workset_lst
	Txt   []WorksetTxtRow // workset text rows: workset_txt
	Param []worksetParam  // workset parameter: parameter_hid, sub-value count and workset_parameter_txt rows
}

type WorksetParamTxtRow struct {
	SetId    int    // set_id        INT NOT NULL
	ParamHid int    // parameter_hid INT NOT NULL
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Note     string // note          VARCHAR(32000), -- parameter value note
}

type WorksetPub struct {
	WorksetHdrPub
	Param []ParamRunSetPub // workset parameters: name and text (value notes by language)
}

type WorksetRow struct {
	SetId          int    // unique working set id
	BaseRunId      int    // if not NULL and positive then base run id (source run id)
	ModelId        int    // model_id     INT          NOT NULL
	Name           string // set_name     VARCHAR(255) NOT NULL
	IsReadonly     bool   // is_readonly  SMALLINT     NOT NULL
	UpdateDateTime string // update_dt    VARCHAR(32)  NOT NULL, -- last update date-time
	// contains filtered or unexported fields
}

type WorksetTxtRow struct {
	SetId    int    // set_id    INT          NOT NULL
	LangCode string // lang_code VARCHAR(32)  NOT NULL
	Descr    string // descr     VARCHAR(255) NOT NULL
	Note     string // note      VARCHAR(32000)
}

type WriteLayout struct {
	Name string // parameter name or output table name
	ToId int    // run id or set id to write parameter or output table values
}

type WriteMicroLayout struct {
	WriteLayout        // common write layout: entity name and run id
	DoubleFmt   string // used for float model types digest calculation
}

type WriteParamLayout struct {
	WriteLayout        // common write layout: parameter name, run or set id
	SubCount    int    // sub-values count
	IsToRun     bool   // if true then write into into model run else into workset
	IsPage      bool   // if true then write only page of data else all parameter values
	DoubleFmt   string // used for float model types digest calculation
}

type WriteTableLayout struct {
	WriteLayout        // common write layout: output table name and run id
	SubCount    int    // sub-values count
	DoubleFmt   string // used for float model types digest calculation
}