Información sobre las asignaciones de vistas de datos en objetos visuales de Power BI
En este artículo se describe la asignación de vistas de datos y cómo se usan los roles de datos para crear diferentes tipos de objetos visuales. Se explica cómo especificar los requisitos condicionales para los roles de datos, así como los distintos tipos de dataMappings.
Cada asignación válida genera una vista de datos. Puede proporcionar varias asignaciones de datos en determinadas condiciones. Las opciones de asignación admitidas son las siguientes:
"dataViewMappings": [
{
"conditions": [ ... ],
"categorical": { ... },
"single": { ... },
"table": { ... },
"matrix": { ... }
}
]
Power BI solo creará una asignación a una vista de datos si la asignación válida también se ha definido en dataViewMappings.
En otras palabras, categorical podría definirse en dataViewMappings, pero otras asignaciones, como table o single, podrían no estar definidas. En ese caso, Power BI genera una vista de datos con una sola asignación categorical, mientras que table y otras asignaciones permanecen sin definir. Por ejemplo:
"dataViewMappings": [
{
"categorical": {
"categories": [ ... ],
"values": [ ... ]
},
"metadata": { ... }
}
]
Condiciones
En la sección conditions se establecen reglas para una asignación de datos determinada. Si los datos coinciden con uno de los conjuntos de condiciones descritos, el objeto visual acepta los datos como válidos.
Actualmente, se puede especificar un valor mínimo y máximo para cada campo. El valor representa el número de campos que pueden estar enlazados a ese rol de datos.
Nota
Si se omite un rol de datos en la condición, puede tener cualquier número de campos.
En el ejemplo siguiente, category se limita a un campo de datos y measure, a dos.
"conditions": [
{ "category": { "max": 1 }, "measure": { "max": 2 } },
]
También puede establecer varias condiciones para un rol de datos. En ese caso, los datos son válidos si se cumple alguna de las condiciones.
"conditions": [
{ "category": { "min": 1, "max": 1 }, "measure": { "min": 2, "max": 2 } },
{ "category": { "min": 2, "max": 2 }, "measure": { "min": 1, "max": 1 } }
]
En el ejemplo anterior, se requiere una de las dos condiciones siguientes:
- Exactamente un campo de datos de categoría y exactamente dos medidas
- Exactamente dos categorías y exactamente una medida.
Asignación de datos única
La asignación de datos única es la forma más simple de asignación de datos. Admite un solo campo de medida y proporciona el total. Si el campo es numérico, devuelve la suma. De lo contrario, proporciona un recuento de valores únicos.
Para usar una asignación de datos única, es necesario definir el nombre del rol de datos que quiera asignar. Esta asignación solo funciona con un único campo de medida. Si se asigna un segundo campo, no se generará ninguna vista de datos, por lo que es recomendable incluir una condición que limite los datos a un solo campo.
Nota
Esta asignación de datos no se puede usar con ninguna otra asignación de datos. Su objetivo es reducir los datos a un único valor numérico.
Por ejemplo:
{
"dataRoles": [
{
"displayName": "Y",
"name": "Y",
"kind": "Measure"
}
],
"dataViewMappings": [
{
"conditions": [
{
"Y": {
"max": 1
}
}
],
"single": {
"role": "Y"
}
}
]
}
La vista de datos resultante puede seguir conteniendo los otros tipos (tabla, categórico, etc.), pero cada asignación contiene solo el valor único. El procedimiento recomendado es acceder solo al valor único.
{
"dataView": [
{
"metadata": null,
"categorical": null,
"matrix": null,
"table": null,
"tree": null,
"single": {
"value": 94163140.3560001
}
}
]
}
Ejemplo de código para procesar una asignación de vista de datos simple
"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();
}
}
El código anterior da como resultado la presentación de un único valor de Power BI:
Asignación de datos categóricos
La asignación de datos categóricos se usa para obtener agrupaciones o categorías de datos independientes. Las categorías también se pueden agrupar aún más mediante group by en la asignación de datos.
Asignación de datos categóricos básica
Tenga en cuenta los siguientes roles y asignaciones de datos:
"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" } }
]
}
}
}
En el ejemplo anterior, pone lo siguiente: "Quiero asignar mi rol de datos category para que, en todos los campos que arrastre a category, sus datos se asignen a categorical.categories. Además, también quiero asignar mi rol de datos measure a categorical.values".
- for...in: incluye todos los elementos en este rol de datos, en la consulta de datos.
- bind...to: produce el mismo resultado que for...in, pero espera que el rol de datos tenga una condición que lo restrinja a un único campo.
Agrupación de datos por categorías
En el ejemplo siguiente, se usan los mismos dos roles de datos que en el ejemplo anterior y se agregan a más roles de datos denominados grouping y 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" } }
]
}
}
}
}
La diferencia entre esta asignación y la básica es la forma en que asignamos categorical.values. Al asignar los roles de datos measure y measure2 al rol de datos grouping, podemos escalar los ejes X e Y correctamente.
Agrupación de datos jerárquicos
En el ejemplo siguiente, usamos los datos categóricos para crear una jerarquía, que se puede usar para admitir acciones de exploración en profundidad.
Estos son los roles de datos y las asignaciones:
"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"
}
}
]
}
}
}
}
]
Considere los siguientes datos categóricos:
| País | 2013 | 2014 | 2015 | 2016 |
|---|---|---|---|---|
| EE. UU. | x | x | 650 | 350 |
| Canadá | x | 630 | 490 | x |
| México | 645 | x | x | x |
| Reino Unido | x | x | 831 | x |
Power BI genera una vista de datos categóricos con el siguiente conjunto de categorías.
{
"categorical": {
"categories": [
{
"source": {...},
"values": [
"Canada",
"USA",
"UK",
"Mexico"
],
"identity": [...],
"identityFields": [...],
}
]
}
}
Cada category se asigna también a un conjunto de values. Cada uno de estos values se agrupa por series, que se expresa en años.
Por ejemplo, cada matriz values representa un año.
Además, cada matriz values tiene cuatro valores: Canadá, EE. UU., Reino Unido y México:
{
"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": [...],
}
]
}
Después, se describe el ejemplo de código para procesar una asignación de vistas de datos categóricos. En este ejemplo se crea la estructura jerárquica 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;
// standard 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);
}
}
Este es el objeto visual resultante:
Tablas de asignación
La vista de datos de tabla es básicamente una lista de puntos de datos, donde se pueden agregar puntos de datos numéricos.
Por ejemplo, con los mismos datos que en la sección anterior, pero con las siguientes funcionalidades:
"dataRoles": [
{
"displayName": "Column",
"name": "column",
"kind": "Grouping"
},
{
"displayName": "Value",
"name": "value",
"kind": "Measure"
}
],
"dataViewMappings": [
{
"table": {
"rows": {
"select": [
{
"for": {
"in": "column"
}
},
{
"for": {
"in": "value"
}
}
]
}
}
}
]
Puede visualizar la vista de datos de tabla como se muestra a continuación:
Ejemplo de datos:
| País | Year | Sales |
|---|---|---|
| EE. UU. | 2016 | 100 |
| EE. UU. | 2015 | 50 |
| Canadá | 2015 | 200 |
| Canadá | 2015 | 50 |
| México | 2013 | 300 |
| Reino Unido | 2014 | 150 |
| EE. UU. | 2015 | 75 |
Enlace de datos:
Power BI muestra los datos como la vista de datos de tabla. No debe suponer que los datos están ordenados.
{
"table" : {
"columns": [...],
"rows": [
[
"Canada",
2014,
630
],
[
"Canada",
2015,
490
],
[
"Mexico",
2013,
645
],
[
"UK",
2014,
831
],
[
"USA",
2015,
650
],
[
"USA",
2016,
350
]
]
}
}
Para agregar los datos, seleccione el campo que quiera y, después, seleccione Suma.
Ejemplo de código para procesar una asignación de vista de datos de tabla.
"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;
// standard 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);
});
}
}
El archivo de estilos de objetos visuales style/visual.less contiene el diseño de la tabla:
table {
display: flex;
flex-direction: column;
}
tr, th {
display: flex;
flex: 1;
}
td {
flex: 1;
border: 1px solid black;
}
El objeto visual resultante tiene este aspecto:
Asignación de datos de matriz
La asignación de datos de matriz es similar a la asignación de datos de tabla, pero las filas se presentan jerárquicamente. Cualquiera de los valores de los roles de datos se puede usar como un valor de encabezado de columna.
{
"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"
}
}
]
}
}
}
]
}
Estructura jerárquica de los datos de matriz
Power BI crea una estructura de datos jerárquica. La raíz de la jerarquía de árbol incluye los datos de la columna Elementos principales del rol de datos Category, con elementos secundarios de la columna Elementos secundarios de la tabla de roles de datos.
Conjunto de datos:
| Parents | Children | Elementos descendientes del secundario | Columnas | Valores |
|---|---|---|---|---|
| Principal1 | Secundario1 | Subelemento secundario1 | Col1 | 5 |
| Principal1 | Secundario1 | Subelemento secundario1 | Col2 | 6 |
| Principal1 | Secundario1 | Subelemento secundario2 | Col1 | 7 |
| Principal1 | Secundario1 | Subelemento secundario2 | Col2 | 8 |
| Principal1 | Secundario2 | Subelemento secundario3 | Col1 | 5 |
| Principal1 | Secundario2 | Subelemento secundario3 | Col2 | 3 |
| Principal1 | Secundario2 | Subelemento secundario4 | Col1 | 4 |
| Principal1 | Secundario2 | Subelemento secundario4 | Col2 | 9 |
| Principal1 | Secundario2 | Subelemento secundario5 | Col1 | 3 |
| Principal1 | Secundario2 | Subelemento secundario5 | Col2 | 5 |
| Principal2 | Secundario3 | Subelemento secundario6 | Col1 | 1 |
| Principal2 | Secundario3 | Subelemento secundario6 | Col2 | 2 |
| Principal2 | Secundario3 | Subelemento secundario7 | Col1 | 7 |
| Principal2 | Secundario3 | Subelemento secundario7 | Col2 | 1 |
| Principal2 | Secundario3 | Subelemento secundario8 | Col1 | 10 |
| Principal2 | Secundario3 | Subelemento secundario8 | Col2 | 13 |
El objeto visual de la matriz principal de Power BI representa los datos como una tabla.
El objeto visual obtiene su estructura de datos tal y como se describe en el código siguiente (aquí solo se muestran las dos primeras filas de la tabla):
{
"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": [...]
}
}
Expansión y contracción de encabezados de fila
A partir de la API 4.1.0, los datos de matriz admitirán la expansión y la contracción de encabezados de fila. La característica de expansión y contracción optimiza la captura de datos en dataView al permitir que el usuario expanda o contraiga una fila sin capturar todos los datos para el siguiente nivel. Solo captura los datos de la fila seleccionada. El estado de expansión del encabezado de fila seguirá siendo coherente entre los marcadores e incluso entre los informes guardados. No es específico de cada objeto visual.
Los comandos de expansión y contracción también se pueden agregar al menú contextual si se proporciona el parámetro dataRoles al método showContextMenu.
Características de API
Para permitir la expansión y contracción de los encabezados de fila, se ha agregado lo siguiente a la versión 4.1.0 de la API.
La marca
isCollapsedenDataViewTreeNode:interface DataViewTreeNode { //... /** * TRUE if the node is Collapsed * FALSE if it is Expanded * Undefined if it cannot be Expanded (e.g. subtotal) */ isCollapsed?: boolean; }El método
toggleExpandCollapseen la interfazISelectionManger: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 //... }La marca
canBeExpandeden DataViewHierarchyLevel:interface DataViewHierarchyLevel { //... /** If TRUE, this level can be expanded/collapsed */ canBeExpanded?: boolean; }
Requisitos de los objetos visuales
Para habilitar la característica de expansión y contracción en un objeto visual mediante la vista de datos de matriz:
Agregue lo siguiente al archivo 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 } },Asegúrese de que los roles se pueden explorar en profundidad:
"drilldown": { "roles": ["Rows"] },Para cada nodo, cree una instancia del generador de selección y llame al método
withMatrixNodeen el nivel de jerarquía de nodo seleccionado y cree una instancia deselectionId. Por ejemplo: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();Cree una instancia del administrador de selección y use el método
selectionManager.toggleExpandCollapse()con el parámetro deselectionIdque ha creado para el nodo seleccionado. Por ejemplo:// handle click events to apply expand\collapse action for the selected node button.addEventListener("click", () => { this.selectionManager.toggleExpandCollapse(nodeSelectionId); });
Nota
- Si el nodo seleccionado no es un nodo de fila, Power BI omitirá las llamadas de expansión o contracción, y los comandos de expansión y contracción se quitarán del menú contextual.
- El parámetro
dataRolessolo es necesario para el métodoshowContextMenusi el objeto visual admite características dedrilldownoexpandCollapse. Si el objeto visual admite estas características pero no se ha proporcionado dataRoles, se producirá un error en la consola cuando se use el objeto visual para desarrolladores o si se depura un objeto visual público con el modo de depuración habilitado.
Consideraciones y limitaciones
- Después de expandir un nodo, se aplicarán nuevos límites de datos a DataView. Esto significa que es posible que la nueva instancia de DataView no incluya algunos de los nodos presentados en el objeto DataView anterior.
- Al usar expandir o contraer, se agregan totales incluso si el objeto visual no los ha solicitado.
- Actualmente, no se admite la expansión y la contracción de columnas.
Mantener todas las columnas de metadatos
A partir de la API 5.1.0, se podrá mantener todas las columnas de metadatos. Esta característica permite al objeto visual recibir los metadatos de todas las columnas, independientemente de cuáles sean sus proyecciones activas.
Agregue las siguientes líneas al archivo capabilities.json:
"keepAllMetadataColumns": {
"type": "boolean",
"description": "Indicates that visual is going to receive all metadata columns, no matter what the active projections are"
}
Si establece esta propiedad en true, se recibirán todos los metadatos, incluidas las columnas contraídas. Si se establece en false o se deja sin definir, solo se recibirán metadatos en columnas con proyecciones activas (expandidas, por ejemplo).
Algoritmo de reducción de datos
El algoritmo de reducción de datos controla qué datos y cuántos se reciben en la vista de datos.
El valor de count se establece en el número máximo de valores que la vista de datos puede aceptar. Si hay más valores de los que se indica en count, el algoritmo de reducción de datos determina qué valores se deben recibir.
Tipos de algoritmos de reducción de datos
Hay cuatro tipos de valores del algoritmo de reducción de datos:
top: los primeros valores de count se obtendrán del conjunto de datos.bottom: los últimos valores de count se obtendrán del conjunto de datos.sample: se incluyen el primer y último elemento, y el número de elementos de count con intervalos iguales entre ellos. Por ejemplo, si tiene un conjunto de datos [0, 1, 2 … 100] y un valor de count de 9, recibirá los valores [0, 10, 20 ... 100].window: carga una ventana de puntos de datos que contiene elementos de count. Actualmente,topywindowson equivalentes. Estamos trabajando para admitir totalmente una configuración basada en ventanas.
De manera predeterminada, todos los objetos visuales de Power BI tienen aplicado el algoritmo de reducción de datos principal con el valor de count establecido en 1000 puntos de datos. Esto equivale a establecer las propiedades siguientes en el archivo capabilities.json:
"dataReductionAlgorithm": {
"top": {
"count": 1000
}
}
Puede modificar el valor de count por cualquier valor entero hasta 30 000. Los objetos visuales de Power BI basados en R admiten hasta 150 000 filas.
Uso de algoritmos de reducción de datos
El algoritmo de reducción de datos se puede usar en una asignación de vista de datos de matriz, de tabla o categóricos.
En la asignación de datos categóricos, puede agregar el algoritmo a la sección "categorías" o "grupo" de values para la asignación de datos categóricos.
"dataViewMappings": {
"categorical": {
"categories": {
"for": { "in": "category" },
"dataReductionAlgorithm": {
"window": {
"count": 300
}
}
},
"values": {
"group": {
"by": "series",
"select": [{
"for": {
"in": "measure"
}
}
],
"dataReductionAlgorithm": {
"top": {
"count": 100
}
}
}
}
}
}
En la asignación de vistas de datos de tabla, aplique el algoritmo de reducción de datos a la sección rows de la tabla de asignación de vistas de datos.
"dataViewMappings": [
{
"table": {
"rows": {
"for": {
"in": "values"
},
"dataReductionAlgorithm": {
"top": {
"count": 2000
}
}
}
}
}
]
Puede aplicar el algoritmo de reducción de datos a las secciones rows y columns de la matriz de asignación de vistas de datos.