Creating Calculated Dictionary

Executing the example requires that the repository contains a unit with the UserDimMod identifier containing a macro for creating an element tree of calculated dictionary. Assume that macro contains the following code:

Sub UserMacro(User: IUserDimension; Builder: IDimBuilder; Param: IMetabaseObjectParamValues);
Var
    DimBlock: IUserDimBlock;
    BlockRoot, Block: IDimBlockLoader;
    i, i1, j, k, k1, l: Integer;
Begin
    DimBlock := User.Blocks.Item(0);
    BlockRoot := Builder.CreateRootBlockLoader(DimBlock.Key);
    Block := Builder.CreateBlockLoader(DimBlock.Key, DimBlock.Key);
    i1 := Param.Item(0).Value As Integer;
    k1 := Param.Item(1).Value As Integer;
    For i := 0 To i1 - 1 Do
        j := BlockRoot.AddRow;
        BlockRoot.Value(j, 0) := j;
        BlockRoot.Value(j, 1) := "Element " + j.ToString;
        BlockRoot.Value(j, 2) := j;
        l := j;
        For k := 0 To k1 - 1 Do
            j := Block.AddRow;
            Block.Value(j, 0) := j + 100;
            Block.Value(j, 1) := "Child element " + l.ToString + "_" + k.ToString;
            Block.Value(j, 2) := j + 100;
            Block.Value(j, 3) := l;
        End For;
    End For;
End Sub UserMacro;

Due to setting element value in embedded loop by the column, the number of which is 1 more than the number of attributes, a two-level hierarchy is created in the dictionary. Value by this column is the key of parent element.

Sub UserProc;
Var
    MB: IMetabase;
    MObj: IMetabaseObject;
    Params: IMetabaseObjectParams;
    Param: IMetabaseObjectParam;
    CrInfo: IMetabaseObjectCreateInfo;
    UserDim: IUserDimension;
    Attrs: IUserDimAttributes;
    Attr: IUserDimAttribute;
    Orders: IUserDimOrders;
    Block: IUserDimBlock;
    BlockAttr: IUserDimIndexAttributes;
    Levels: IUserDimLevels;
Begin
    MB := MetabaseClass.Active;
    CrInfo := MB.CreateCreateInfo;
    CrInfo.ClassID := MetabaseObjectClass.KE_CLASS_USERDIM;
    CrInfo.Id := "NewUserDim";
    CrInfo.Name := "New calculated dictionary";
    CrInfo.Parent := MB.Root;
    MObj := MB.CreateObject(CrInfo).Edit;
    // Dictionary parameters
    Params := MObj.Params;
    Param := Params.Add;
    Param.Id := "i1";
    Param.Name := "Number of main elements";
    Param.DataType := DbDataType.Integer;
    Param := Params.Add;
    Param.Id := "k1";
    Param.Name := "Number of child elements";
    Param.DataType := DbDataType.Integer;
    UserDim := MObj As IUserDimension;
    Attrs := UserDim.Attributes;

    // Create attributes
    Attr := Attrs.Add;
    Attr.DataType := DbDataType.Integer;
    Attr.Id := "Id";
    Attr.Name := "Identifier";
    Attrs.Id := Attr;
    Attr := Attrs.Add;
    Attr.DataType := DbDataType.String;
    Attr.Id := "Name";
    Attr.Name := "Name";
    Attrs.Name := Attr;
    Attr := Attrs.Add;
    Attr.DataType := DbDataType.Integer;
    Attr.Id := "Order";
    Attr.Name := "Order";
    Attrs.Order := Attr;
    // Sort by attributes
    Orders := Attrs.Orders;
    Orders.Add(Attrs.Name, False);
    Orders.Add(Attrs.Order, False);
    // Single block
    Block := UserDim.Blocks.Add;
    // Primary index of block by the Identifier attribute
    BlockAttr := Block.Indexes.PrimaryIndex.Attributes;
    BlockAttr.Add(Attrs.Id);
    // Two levels for dictionary
    Levels := UserDim.Levels;
    Levels.Add.Name := "First level";
    Levels.Add.Name := "Second level";
    // Set unit and macro
    UserDim.ForeModule := MB.ItemById("UserDimMod").Bind As IModule;
    UserDim.ForeSub := "UserMacro";
    (UserDim As IMetabaseObject).Save;
End Sub UserProc;

After executing the example the repository root contains a calculated dictionary. The dictionary contains three attributes and one block, sorting order of elements is set. The primary block index contains the ID attribute. Two dictionary levels are created, module and macro that creates element tree are set.

Two parameters are also created for the dictionary. If the above mentioned macro is used to create an element tree, these parameters are used to set the number of root elements and the number of child elements for every root one, respectively.