Общие сведения о сопоставлениях представлений данных в визуальных элементах Power BI

В этой статье рассматривается сопоставление представления данных и описывается, как роли данных используются для создания различных типов визуальных элементов. В ней объясняется, как задать условные требования для ролей данных, а также различных типов dataMappings.

Каждое допустимое сопоставление создает представление данных. При определенных условиях можно указать несколько сопоставлений данных. Поддерживаются следующие варианты сопоставлений:

"dataViewMappings": [
    {
        "conditions": [ ... ],
        "categorical": { ... },
        "single": { ... },
        "table": { ... },
        "matrix": { ... }
    }
]

Power BI создает сопоставление с представлением данных только в том случае, если допустимое сопоставление также определено в dataViewMappings.

Иными словами, categorical может быть определено в dataViewMappings, однако другие сопоставления, такие как table или single, могут быть не определены. В этом случае Power BI создает представление данных с одним сопоставлением categorical, тогда как table и другие сопоставления остаются неопределенными. Пример.

"dataViewMappings": [
    {
    "categorical": {
        "categories": [ ... ],
        "values": [ ... ]
    },
    "metadata": { ... }
    }
]

Условия

В разделе conditions устанавливаются правила для определенного сопоставления данных. Если данные совпадают с одним из описанных наборов условий, визуальный элемент принимает данные как допустимые.

В настоящее время для каждого поля можно указать минимальное и максимальное значения. Они представляют количество полей, которые можно привязать к этой роли данных.

Примечание

Если роль данных в условии опущена, она может иметь любое количество полей.

В следующем примере ограничение category ограничено одним полем данных и measure двумя полями данных.

"conditions": [
    { "category": { "max": 1 }, "measure": { "max": 2 } },
]

Можно также задать несколько условий для роли данных. В этом случае данные являются допустимыми, если выполняется любое из условий.

"conditions": [
    { "category": { "min": 1, "max": 1 }, "measure": { "min": 2, "max": 2 } },
    { "category": { "min": 2, "max": 2 }, "measure": { "min": 1, "max": 1 } }
]

В приведенном выше примере требуется одно из следующих двух условий:

  • Точно одно поле категории и точно две меры
  • Точно две категории и точно одна мера.

Одиночное сопоставление данных

Одиночное сопоставление данных — это простейшая форма сопоставления данных. Оно принимает одно поле меры и возвращает итог. Если поле является числовым, оно возвращает сумму. В противном случае возвращается количество уникальных значений.

Чтобы использовать одиночное сопоставление данных, определите имя роли данных, которую требуется сопоставить. Это сопоставление работает только с одним полем меры. Если присвоено второе поле, представление данных не будет создаваться. В связи с этим рекомендуется включать условие, которое ограничивает данные одним полем.

Примечание

Это сопоставление данных невозможно использовать совместно с любым другим сопоставлением данных. Оно предназначено для сокращения данных до одного числового значения.

Пример.

{
    "dataRoles": [
        {
            "displayName": "Y",
            "name": "Y",
            "kind": "Measure"
        }
    ],
    "dataViewMappings": [
        {
            "conditions": [
                {
                    "Y": {
                        "max": 1
                    }
                }
            ],
            "single": {
                "role": "Y"
            }
        }
    ]
}

Итоговое представление данных по-прежнему может содержать другие типы (табличные, категориальные и т. д.), но каждое сопоставление содержит только одно значение. Рекомендуется просто обращаться к значению по отдельности.

{
    "dataView": [
        {
            "metadata": null,
            "categorical": null,
            "matrix": null,
            "table": null,
            "tree": null,
            "single": {
                "value": 94163140.3560001
            }
        }
    ]
}

Пример кода для обработки простого сопоставления представлений данных

"use strict";
import powerbi from "powerbi-visuals-api";
import DataView = powerbi.DataView;
import DataViewSingle = powerbi.DataViewSingle;
// standard imports
// ...

export class Visual implements IVisual {
    private target: HTMLElement;
    private host: IVisualHost;
    private valueText: HTMLParagraphElement;

    constructor(options: VisualConstructorOptions) {
        // constructor body
        this.target = options.element;
        this.host = options.host;
        this.valueText = document.createElement("p");
        this.target.appendChild(this.valueText);
        // ...
    }

    public update(options: VisualUpdateOptions) {
        const dataView: DataView = options.dataViews[0];
        const singleDataView: DataViewSingle = dataView.single;

        if (!singleDataView ||
            !singleDataView.value ) {
            return
        }

        this.valueText.innerText = singleDataView.value.toString();
    }
}

Приведенный выше код приводит к отображению одного значения из Power BI:

Single dataview mapping visual example

Категориальное сопоставление данных

Категориальное сопоставление данных используется для получения независимых группирований (категорий) данных. Категории можно далее сгруппировать с помощью функции Группировать по в сопоставлении данных.

Базовое категориальное сопоставление данных

Рассмотрим следующие роли и сопоставления данных:

"dataRoles":[
    {
        "displayName": "Category",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Y Axis",
        "name": "measure",
        "kind": "Measure"
    }
],
"dataViewMappings": {
    "categorical": {
        "categories": {
            "for": { "in": "category" }
        },
        "values": {
            "select": [
                { "bind": { "to": "measure" } }
            ]
        }
    }
}

В общем виде приведенный выше пример означает следующее: "сопоставить мою роль данных category, чтобы для каждого поля, которое я перетаскиваю в category, его данные сопоставлялись с categorical.categories. Кроме того, сопоставить мою роль данных measure с categorical.values".

  • for...in — включить все элементы из этой роли данных в запрос данных.
  • bind...to — дает тот же результат, что и for...in, но ожидает, что роль данных будет иметь условие, ограничивающее его до одного поля.

Группирование данных категорий

В следующем примере используются те же две роли данных, что и в предыдущем, и добавляются дополнительные роли данных с именами grouping и measure2.

"dataRole":[
    {
        "displayName": "Category",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Y Axis",
        "name": "measure",
        "kind": "Measure"
    },
    {
        "displayName": "Grouping with",
        "name": "grouping",
        "kind": "Grouping"
    },
    {
        "displayName": "X Axis",
        "name": "measure2",
        "kind": "Grouping"
    }
],
"dataViewMappings":{
    "categorical": {
        "categories": {
            "for": { "in": "category" }
        },
        "values": {
            "group": {
                "by": "grouping",
                "select":[
                    { "bind": { "to": "measure" } },
                    { "bind": { "to": "measure2" } }
                ]
            }
        }
    }
}

Разница между этим сопоставлением и базовым заключается в способе сопоставления categorical.values. Сопоставляя роли данных measure и measure2 с ролью данных grouping, можно соответствующим образом масштабировать оси x и y.

Группирование иерархических данных

В следующем примере мы используем категориальные данные для создания иерархии, которую можно применять для поддержки действий детализации.

Вот эти роли данных и сопоставления:

"dataRoles": [
    {
        "displayName": "Categories",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Measures",
        "name": "measure",
        "kind": "Measure"
    },
    {
        "displayName": "Series",
        "name": "series",
        "kind": "Measure"
    }
],
"dataViewMappings": [
    {
        "categorical": {
            "categories": {
                "for": {
                    "in": "category"
                }
            },
            "values": {
                "group": {
                    "by": "series",
                    "select": [{
                            "for": {
                                "in": "measure"
                            }
                        }
                    ]
                }
            }
        }
    }
]

Рассмотрим следующие категориальные данные:

Страна или регион 2013 2014 2015 2016
США x x 650 350
Canada x 630 490 x
Мексика 645 x x x
Великобритания x x 831 x

Power BI создает представление категориальных данных со следующим набором категорий.

{
    "categorical": {
        "categories": [
            {
                "source": {...},
                "values": [
                    "Canada",
                    "USA",
                    "UK",
                    "Mexico"
                ],
                "identity": [...],
                "identityFields": [...],
            }
        ]
    }
}

Каждая категория category также сопоставляется с набором values. Каждый набор values группируется по series (выражается в годах).

Например, каждый массив values представляет один год. Кроме того, каждый массив values имеет четыре значения: Канада, США, Великобритания и Мексика:

{
    "values": [
        // Values for year 2013
        {
            "source": {...},
            "values": [
                null, // Value for `Canada` category
                null, // Value for `USA` category
                null, // Value for `UK` category
                645 // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2014
        {
            "source": {...},
            "values": [
                630, // Value for `Canada` category
                null, // Value for `USA` category
                null, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2015
        {
            "source": {...},
            "values": [
                490, // Value for `Canada` category
                650, // Value for `USA` category
                831, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2016
        {
            "source": {...},
            "values": [
                null, // Value for `Canada` category
                350, // Value for `USA` category
                null, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        }
    ]
}

Ниже приведен пример кода для обработки сопоставления представления категориальных данных. В этом примере создается иерархическая структура Country => Year => Value.

"use strict";
import powerbi from "powerbi-visuals-api";
import DataView = powerbi.DataView;
import DataViewCategorical = powerbi.DataViewCategorical;
import DataViewValueColumnGroup = powerbi.DataViewValueColumnGroup;
import PrimitiveValue = powerbi.PrimitiveValue;
// standart imports
// ...

export class Visual implements IVisual {
    private target: HTMLElement;
    private host: IVisualHost;
    private categories: HTMLElement;

    constructor(options: VisualConstructorOptions) {
        // constructor body
        this.target = options.element;
        this.host = options.host;
        this.categories = document.createElement("pre");
        this.target.appendChild(this.categories);
        // ...
    }

    public update(options: VisualUpdateOptions) {
        const dataView: DataView = options.dataViews[0];
        const categoricalDataView: DataViewCategorical = dataView.categorical;

        if (!categoricalDataView ||
            !categoricalDataView.categories ||
            !categoricalDataView.categories[0] ||
            !categoricalDataView.values) {
            return;
        }

        // Categories have only one column in data buckets
        // To support several columns of categories data bucket, iterate categoricalDataView.categories array.
        const categoryFieldIndex = 0;
        // Measure has only one column in data buckets.
        // To support several columns on data bucket, iterate years.values array in map function
        const measureFieldIndex = 0;
        let categories: PrimitiveValue[] = categoricalDataView.categories[categoryFieldIndex].values;
        let values: DataViewValueColumnGroup[] = categoricalDataView.values.grouped();

        let data = {};
        // iterate categories/countries
        categories.map((category: PrimitiveValue, categoryIndex: number) => {
            data[category.toString()] = {};
            // iterate series/years
            values.map((years: DataViewValueColumnGroup) => {
                if (!data[category.toString()][years.name] && years.values[measureFieldIndex].values[categoryIndex]) {
                    data[category.toString()][years.name] = []
                }
                if (years.values[0].values[categoryIndex]) {
                    data[category.toString()][years.name].push(years.values[measureFieldIndex].values[categoryIndex]);
                }
            });
        });

        this.categories.innerText = JSON.stringify(data, null, 6);
        console.log(data);
    }
}

Вот итоговый визуальный элемент:

The visual with categorical data view mapping

Таблицы соответствия

Представление табличных данных по сути представляет собой список точек данных, в котором числовые точки данных могут агрегироваться.

Например, используя те же данные, что и в предыдущем разделе, но со следующими возможностями:

"dataRoles": [
    {
        "displayName": "Column",
        "name": "column",
        "kind": "Grouping"
    },
    {
        "displayName": "Value",
        "name": "value",
        "kind": "Measure"
    }
],
"dataViewMappings": [
    {
        "table": {
            "rows": {
                "select": [
                    {
                        "for": {
                            "in": "column"
                        }
                    },
                    {
                        "for": {
                            "in": "value"
                        }
                    }
                ]
            }
        }
    }
]

Представление табличных данных можно визуализировать следующим образом:

Пример данных:

Страна или регион Year; Sales
США 2016 100
США 2015 50
Canada 2015 200
Canada 2015 50
Мексика 2013 300
Великобритания 2014 150
США 2015 75

Привязка данных:

Table data view mapping data binds

Служба Power BI отображает данные в представлении табличных данных. Изначально предполагать, что данные упорядочены, не следует.

{
    "table" : {
        "columns": [...],
        "rows": [
            [
                "Canada",
                2014,
                630
            ],
            [
                "Canada",
                2015,
                490
            ],
            [
                "Mexico",
                2013,
                645
            ],
            [
                "UK",
                2014,
                831
            ],
            [
                "USA",
                2015,
                650
            ],
            [
                "USA",
                2016,
                350
            ]
        ]
    }
}

Чтобы агрегировать данные, выберите нужное поле, а затем укажите операцию суммирования.

Data aggregation.

Пример кода для обработки сопоставления представления табличных данных.

"use strict";
import "./../style/visual.less";
import powerbi from "powerbi-visuals-api";
// ...
import DataViewMetadataColumn = powerbi.DataViewMetadataColumn;
import DataViewTable = powerbi.DataViewTable;
import DataViewTableRow = powerbi.DataViewTableRow;
import PrimitiveValue = powerbi.PrimitiveValue;
// other imports
// ...

export class Visual implements IVisual {
    private target: HTMLElement;
    private host: IVisualHost;
    private table: HTMLParagraphElement;

    constructor(options: VisualConstructorOptions) {
        // constructor body
        this.target = options.element;
        this.host = options.host;
        this.table = document.createElement("table");
        this.target.appendChild(this.table);
        // ...
    }

    public update(options: VisualUpdateOptions) {
        const dataView: DataView = options.dataViews[0];
        const tableDataView: DataViewTable = dataView.table;

        if (!tableDataView) {
            return
        }
        while(this.table.firstChild) {
            this.table.removeChild(this.table.firstChild);
        }

        //draw header
        const tableHeader = document.createElement("th");
        tableDataView.columns.forEach((column: DataViewMetadataColumn) => {
            const tableHeaderColumn = document.createElement("td");
            tableHeaderColumn.innerText = column.displayName
            tableHeader.appendChild(tableHeaderColumn);
        });
        this.table.appendChild(tableHeader);

        //draw rows
        tableDataView.rows.forEach((row: DataViewTableRow) => {
            const tableRow = document.createElement("tr");
            row.forEach((columnValue: PrimitiveValue) => {
                const cell = document.createElement("td");
                cell.innerText = columnValue.toString();
                tableRow.appendChild(cell);
            })
            this.table.appendChild(tableRow);
        });
    }
}

Файл стилей визуальных элементов style/visual.less содержит макет для таблицы:

table {
    display: flex;
    flex-direction: column;
}

tr, th {
    display: flex;
    flex: 1;
}

td {
    flex: 1;
    border: 1px solid black;
}

Итоговый визуальный элемент выглядит следующим образом:

The visual with table data view mapping.

Сопоставление матричных данных

Сопоставление матричных данных похоже на сопоставление табличных данных, однако строки в нем представляются иерархически. Кроме того, любое из значений роли данных можно использовать в качестве заголовка столбца.

{
    "dataRoles": [
        {
            "name": "Category",
            "displayName": "Category",
            "displayNameKey": "Visual_Category",
            "kind": "Grouping"
        },
        {
            "name": "Column",
            "displayName": "Column",
            "displayNameKey": "Visual_Column",
            "kind": "Grouping"
        },
        {
            "name": "Measure",
            "displayName": "Measure",
            "displayNameKey": "Visual_Values",
            "kind": "Measure"
        }
    ],
    "dataViewMappings": [
        {
            "matrix": {
                "rows": {
                    "for": {
                        "in": "Category"
                    }
                },
                "columns": {
                    "for": {
                        "in": "Column"
                    }
                },
                "values": {
                    "select": [
                        {
                            "for": {
                                "in": "Measure"
                            }
                        }
                    ]
                }
            }
        }
    ]
}

Иерархическая структура матричных данных

Служба Power BI создает иерархическую структуру данных. Корневой элемент иерархии дерева включает данные из столбца Parents (Родители) роли данных Category и столбца Children (Дети) табличной роли данных.

Набор данных:

Parents Дети Grandchildren Столбцы Значения
Parent1 Child1 Grand child1 Col1 5
Parent1 Child1 Grand child1 Col2 6
Parent1 Child1 Grand child2 Col1 7
Parent1 Child1 Grand child2 Col2 8
Parent1 Child2 Grand child3 Col1 5
Parent1 Child2 Grand child3 Col2 3
Parent1 Child2 Grand child4 Col1 4
Parent1 Child2 Grand child4 Col2 9
Parent1 Child2 Grand child5 Col1 3
Parent1 Child2 Grand child5 Col2 5
Parent2 Child3 Grand child6 Col1 1
Parent2 Child3 Grand child6 Col2 2
Parent2 Child3 Grand child7 Col1 7
Parent2 Child3 Grand child7 Col2 1
Parent2 Child3 Grand child8 Col1 10
Parent2 Child3 Grand child8 Col2 13

Базовый визуальный элемент матрицы Power BI отрисовывает данные как таблицу.

Matrix visual.

Визуальный элемент получает структуру данных, как описывается в следующем коде (здесь показаны только две первые строки таблицы):

{
    "metadata": {...},
    "matrix": {
        "rows": {
            "levels": [...],
            "root": {
                "childIdentityFields": [...],
                "children": [
                    {
                        "level": 0,
                        "levelValues": [...],
                        "value": "Parent1",
                        "identity": {...},
                        "childIdentityFields": [...],
                        "children": [
                            {
                                "level": 1,
                                "levelValues": [...],
                                "value": "Child1",
                                "identity": {...},
                                "childIdentityFields": [...],
                                "children": [
                                    {
                                        "level": 2,
                                        "levelValues": [...],
                                        "value": "Grand child1",
                                        "identity": {...},
                                        "values": {
                                            "0": {
                                                "value": 5 // value for Col1
                                            },
                                            "1": {
                                                "value": 6 // value for Col2
                                            }
                                        }
                                    },
                                    ...
                                ]
                            },
                            ...
                        ]
                    },
                    ...
                ]
            }
        },
        "columns": {
            "levels": [...],
            "root": {
                "childIdentityFields": [...],
                "children": [
                    {
                        "level": 0,
                        "levelValues": [...],
                        "value": "Col1",
                        "identity": {...}
                    },
                    {
                        "level": 0,
                        "levelValues": [...],
                        "value": "Col2",
                        "identity": {...}
                    },
                    ...
                ]
            }
        },
        "valueSources": [...]
    }
}

Развертывание и свертывание заголовков строк

Начиная с API 4.1.0, матричные данные будут поддерживать расширение и свертывание заголовков строк. Функция развертывания и свертывания оптимизирует получение данных в dataView, позволяя пользователю разворачивать или свернуть строку без получения всех данных для следующего уровня. Он получает только данные для выбранной строки. Состояние расширения заголовка строки будет оставаться согласованным в закладках и даже при сохранении отчетов. Это не зависит от каждого визуального элемента.

Команды развертывания и свертывания также можно добавить в контекстное меню, указав dataRoles параметр методу showContextMenu .

Screenshot showing context menu with expand and collapse options.

Функции API

Чтобы включить расширение и свертывание заголовков строк, в API версии 4.1.0 были добавлены следующие сведения.

  • Флаг isCollapsed в :DataViewTreeNode

    interface DataViewTreeNode {
        //...
        /**
        * TRUE if the node is Collapsed
        * FALSE if it is Expanded
        * Undefined if it cannot be Expanded (e.g. subtotal)
        */
        isCollapsed?: boolean;
    }
    
  • Метод toggleExpandCollapse в интерфейсе ISelectionManger :

    interface ISelectionManager {
        //...
        showContextMenu(selectionId: ISelectionId, position: IPoint, dataRoles?: string): IPromise<{}>; // dataRoles is the name of the role of the selected data point
        toggleExpandCollapse(selectionId: ISelectionId, entireLevel?: boolean): IPromise<{}>;  // Expand/Collapse an entire level will be available from API 4.2.0 
        //...
    }
    
  • Флаг canBeExpanded в DataViewHierarchyLevel:

    interface DataViewHierarchyLevel {
        //...
        /** If TRUE, this level can be expanded/collapsed */
        canBeExpanded?: boolean;
    }
    

Требования к визуальным элементам

Чтобы включить функцию свертывание развертывания для визуального элемента с помощью представления данных матрицы, выполните следующие действия.

  1. Добавьте следующий код в файл capabilities.json:

       "expandCollapse": {
        "roles": ["Rows"], //”Rows” is the name of rows data role
        "addDataViewFlags": {
            "defaultValue": true //indicates if the DataViewTreeNode will get the isCollapsed flag by default 
        }
    },
    
  2. Убедитесь, что роли являются детализируемыми:

        "drilldown": {
        "roles": ["Rows"]
    },
    
  3. Для каждого узла создайте экземпляр построителя выбора и вызовите withMatrixNode метод на выбранном уровне иерархии узлов и создайте .selectionId Пример:

        let nodeSelectionBuilder: ISelectionIdBuilder = visualHost.createSelectionIdBuilder();
        // parantNodes is a list of the parents of the selected node.
        // node is the current node which the selectionId is created for. 
        parentNodes.push(node);
        for (let i = 0; i < parentNodes.length; i++) {
            nodeSelectionBuilder = nodeSelectionBuilder.withMatrixNode(parentNodes[i], levels);
        }
      const nodeSelectionId: ISelectionId = nodeSelectionBuilder.createSelectionId(); 
    
  4. Создайте экземпляр диспетчера выбора и используйте selectionManager.toggleExpandCollapse() метод с параметром, созданным для выбранного selectionId узла. Пример:

        // handle click events to apply expand\collapse action for the selected node
        button.addEventListener("click", () => {
        this.selectionManager.toggleExpandCollapse(nodeSelectionId);
    });
    

Примечание

  • Если выбранный узел не является узлом строки, PowerBI будет игнорировать вызовы развертывания и свертывание, а команды expand/collapse будут удалены из контекстного меню.
  • Параметр dataRoles требуется для showContextMenu метода только в том случае, если визуальный элемент поддерживает drilldown или expandCollapse функции. Если визуальный элемент поддерживает эти функции, но dataRoles не был предоставлен, ошибка выводится в консоль при использовании визуального элемента разработчика или при отладке общедоступного визуального элемента с включенным режимом отладки.

Рекомендации и ограничения

  • После расширения узла новые ограничения данных будут применены к DataView. Это означает, что новый DataView может не включать некоторые узлы, представленные в предыдущем DataView.
  • При использовании развертывания или свертывания суммарные значения добавляются даже в том случае, если визуальный элемент не запрашивал их.
  • В настоящее время развертывание и свертывание столбцов не поддерживается.

Алгоритм сокращения данных

Алгоритм сокращения данных определяет, какие данные и какой объем данных поступает в представление данных.

Для count задается максимальное число значений, которое может принимать представление данных. Если количество значений превышает значение count, алгоритм сокращения данных определяет, какие значения следует принять.

Типы алгоритмов для сокращения данных

Предусмотрено четыре типа параметров для алгоритма сокращения данных:

  • top: из набора данных будут взяты первые count значений.
  • bottom: из набора данных будут взяты последние count значений.
  • sample: включаются первый и последний элементы, а элементы в количестве count располагаются между ними с равными интервалами. Например, если получен набор данных [0, 1, 2, ... 100] и count равно 9, вы получите значения [0, 10, 20 ... 100].
  • window: загружает одно окно точек данных за раз, содержащее определенное число (count) элементов. На данный момент top и window эквивалентны. Сейчас мы работаем над тем, чтобы обеспечить полноценную поддержку настройки окон.

По умолчанию для всех визуальных элементов Power BI применяется верхний алгоритм сокращения данных, для которого задано значение count в 1000 точек данных. Это эквивалентно установке следующих свойств в файле capabilities.json:

"dataReductionAlgorithm": {
    "top": {
        "count": 1000
    }
}

Вы можете изменить параметр count на любое целое значение не более 30 000. Визуальные элементы Power BI на основе R могут поддерживать до 150 000 строк.

Использование алгоритма сокращения данных

Алгоритм сокращения данных можно использовать в сопоставлениях представлений категориальных, табличных или матричных данных.

В сопоставлении категориальных данных можно добавить алгоритм в раздел categories и (или) group values для сопоставления категориальных данных.

"dataViewMappings": {
    "categorical": {
        "categories": {
            "for": { "in": "category" },
            "dataReductionAlgorithm": {
                "window": {
                    "count": 300
                }
            }  
        },
        "values": {
            "group": {
                "by": "series",
                "select": [{
                        "for": {
                            "in": "measure"
                        }
                    }
                ],
                "dataReductionAlgorithm": {
                    "top": {
                        "count": 100
                    }
                }  
            }
        }
    }
}

В сопоставлении представления табличных данных примените алгоритм сокращения данных к разделу rows таблицы сопоставления представления данных.

"dataViewMappings": [
    {
        "table": {
            "rows": {
                "for": {
                    "in": "values"
                },
                "dataReductionAlgorithm": {
                    "top": {
                        "count": 2000
                    }
                }
            }
        }
    }
]

Алгоритм сокращения данных можно применить к разделам rows и columns матрицы сопоставления представления данных.

Дальнейшие действия