Informazioni sul mapping delle visualizzazioni dati negli oggetti visivi di Power BI
Questo articolo illustra il mapping delle visualizzazioni dati e descrive il modo in cui i ruoli dati vengono usati per creare tipi diversi di oggetti visivi. Illustra come specificare i requisiti condizionali per i ruoli dati e i diversi dataMappings tipi.
Ogni mapping valido produce una visualizzazione dati. È possibile fornire più mapping di dati in determinate condizioni. Le opzioni di mapping supportate sono:
"dataViewMappings": [
{
"conditions": [ ... ],
"categorical": { ... },
"single": { ... },
"table": { ... },
"matrix": { ... }
}
]
Power BI crea un mapping a una vista dati solo se il mapping valido è definito anche in dataViewMappings.
In altre parole, categorical potrebbe essere definito in dataViewMappings ma altri mapping, ad esempio table o single, potrebbero non essere. In tal caso, Power BI produce una visualizzazione dati con un singolo categorical mapping, mentre table e altri mapping rimangono indefiniti. Ad esempio:
"dataViewMappings": [
{
"categorical": {
"categories": [ ... ],
"values": [ ... ]
},
"metadata": { ... }
}
]
Condizioni
La conditions sezione stabilisce regole per un mapping di dati specifico. Se i dati corrispondono a uno dei set di condizioni descritti, l'oggetto visivo accetta i dati come validi.
Per ogni campo è possibile specificare un valore minimo e massimo. Il valore rappresenta il numero di campi che possono essere associati al ruolo dati.
Nota
Se un ruolo dati viene omesso nella condizione, può avere un numero qualsiasi di campi.
Nell'esempio seguente l'oggetto category è limitato a un campo dati e l'oggetto measure è limitato a due campi dati.
"conditions": [
{ "category": { "max": 1 }, "measure": { "max": 2 } },
]
È anche possibile impostare più condizioni per un ruolo dati. In tal caso, i dati sono validi se viene soddisfatta una delle condizioni.
"conditions": [
{ "category": { "min": 1, "max": 1 }, "measure": { "min": 2, "max": 2 } },
{ "category": { "min": 2, "max": 2 }, "measure": { "min": 1, "max": 1 } }
]
Nell'esempio precedente è necessaria una delle due condizioni seguenti:
- Esattamente un campo categoria e esattamente due misure
- Esattamente due categorie e esattamente una misura
Mapping dei dati singoli
Il mapping dei dati singolo è la forma più semplice di mapping dei dati. Accetta un singolo campo di misura e restituisce il totale. Se il campo è numerico, restituisce la somma. In caso contrario, restituisce un conteggio di valori univoci.
Per usare il mapping dei dati singoli, definire il nome del ruolo dati di cui si vuole eseguire il mapping. Questo mapping funziona solo con un singolo campo di misura. Se viene assegnato un secondo campo, non viene generata alcuna visualizzazione dati, pertanto è consigliabile includere una condizione che limita i dati a un singolo campo.
Nota
Questo mapping dei dati non può essere usato insieme ad altri mapping di dati. È progettato per ridurre i dati a un singolo valore numerico.
Ad esempio:
{
"dataRoles": [
{
"displayName": "Y",
"name": "Y",
"kind": "Measure"
}
],
"dataViewMappings": [
{
"conditions": [
{
"Y": {
"max": 1
}
}
],
"single": {
"role": "Y"
}
}
]
}
La vista dati risultante può comunque contenere altri tipi di mapping, ad esempio tabella o categorica, ma ogni mapping contiene solo il singolo valore. La procedura consigliata consiste nell'accedere al valore solo in un singolo mapping.
{
"dataView": [
{
"metadata": null,
"categorical": null,
"matrix": null,
"table": null,
"tree": null,
"single": {
"value": 94163140.3560001
}
}
]
}
L'esempio di codice seguente elabora il mapping di visualizzazioni dati semplici:
"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();
}
}
L'esempio di codice precedente restituisce la visualizzazione di un singolo valore da Power BI:
Mapping dei dati categorici
Il mapping dei dati categorici viene usato per ottenere raggruppamenti o categorie di dati indipendenti. Le categorie possono anche essere raggruppate usando "group by" nel mapping dei dati.
Mapping dei dati categorici di base
Considerare i ruoli e i mapping dei dati seguenti:
"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" } }
]
}
}
}
L'esempio precedente legge "Eseguire il mapping del category ruolo dati in modo che per ogni campo trascinato in category, i relativi dati vengono mappati a categorical.categories. Eseguire anche il mapping del measure ruolo dati a categorical.values".
- Per... in: include tutti gli elementi in questo ruolo dati nella query di dati.
- Associare... to: produce lo stesso risultato di per... in ma prevede che il ruolo dati disponga di una condizione che la limita a un singolo campo.
Raggruppare i dati categorici
Nell'esempio seguente vengono usati gli stessi due ruoli dati dell'esempio precedente e vengono aggiunti altri due ruoli dati denominati grouping e 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 differenza tra questo mapping e il mapping di base è la modalità categorical.values di mapping. Quando si esegue il mapping dei measure ruoli dati e measure2 al ruolo groupingdati , l'asse x e l'asse y possono essere ridimensionati in modo appropriato.
Raggruppare i dati gerarchici
Nell'esempio seguente i dati categorici vengono usati per creare una gerarchia, che può essere usata per supportare le azioni di drill-down .
L'esempio seguente illustra i ruoli e i mapping dei dati:
"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"
}
}
]
}
}
}
}
]
Considerare i dati categorici seguenti:
| Paese/area geografica | 2013 | 2014 | 2015 | 2016 |
|---|---|---|---|---|
| USA | x | x | 650 | 350 |
| Canada | x | 630 | 490 | x |
| Messico | 645 | x | x | x |
| Regno Unito | x | x | 831 | x |
Power BI produce una visualizzazione dati categorica con il set di categorie seguente.
{
"categorical": {
"categories": [
{
"source": {...},
"values": [
"Canada",
"USA",
"UK",
"Mexico"
],
"identity": [...],
"identityFields": [...],
}
]
}
}
Ogni category oggetto esegue il mapping a un set di values. Ognuno di questi values elementi è raggruppato in seriesbase a , espresso come anni.
Ad esempio, ogni values matrice rappresenta un anno.
values Ogni matrice ha anche quattro valori: Canada, Stati Uniti, Regno Unito e Messico.
{
"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": [...],
}
]
}
L'esempio di codice seguente è destinato all'elaborazione del mapping di visualizzazione dati categorica. Questo esempio crea la struttura gerarchica Country/Region > 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-regions
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);
}
}
Ecco l'oggetto visivo risultante:
Mapping di tabelle
La vista dati della tabella è essenzialmente un elenco di punti dati in cui è possibile aggregare i punti dati numerici.
Ad esempio, usare gli stessi dati nella sezione precedente, ma con le funzionalità seguenti:
"dataRoles": [
{
"displayName": "Column",
"name": "column",
"kind": "Grouping"
},
{
"displayName": "Value",
"name": "value",
"kind": "Measure"
}
],
"dataViewMappings": [
{
"table": {
"rows": {
"select": [
{
"for": {
"in": "column"
}
},
{
"for": {
"in": "value"
}
}
]
}
}
}
]
Visualizzare la vista dati della tabella come nell'esempio seguente:
| Paese/area geografica | Year | Sales |
|---|---|---|
| USA | 2016 | 100 |
| USA | 2015 | 50 |
| Canada | 2015 | 200 |
| Canada | 2015 | 50 |
| Messico | 2013 | 300 |
| Regno Unito | 2014 | 150 |
| USA | 2015 | 75 |
Data binding:
Power BI visualizza i dati come vista dati della tabella. Non presupporre che i dati siano ordinati.
{
"table" : {
"columns": [...],
"rows": [
[
"Canada",
2014,
630
],
[
"Canada",
2015,
490
],
[
"Mexico",
2013,
645
],
[
"UK",
2014,
831
],
[
"USA",
2015,
650
],
[
"USA",
2016,
350
]
]
}
}
Per aggregare i dati, selezionare il campo desiderato e quindi scegliere Somma.
Esempio di codice per elaborare il mapping della vista dati della tabella.
"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);
});
}
}
Il file style/visual.less degli stili di visualizzazione contiene il layout per la tabella:
table {
display: flex;
flex-direction: column;
}
tr, th {
display: flex;
flex: 1;
}
td {
flex: 1;
border: 1px solid black;
}
L'oggetto visivo risultante è simile al seguente:
Mapping dei dati matrice
Il mapping dei dati matrice è simile al mapping dei dati della tabella, ma le righe vengono presentate gerarchicamente. Qualsiasi valore del ruolo dati può essere usato come valore di intestazione di colonna.
{
"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"
}
}
]
}
}
}
]
}
Struttura gerarchica dei dati della matrice
Power BI crea una struttura di dati gerarchica. La radice della gerarchia dell'albero include i dati della colonna Padre del Category ruolo dati con elementi figlio della colonna Children della tabella dei ruoli dati.
Modello semantico:
| Principali | Children | Nipoti | Colonne | Valori |
|---|---|---|---|---|
| Parent1 | Child1 | Grand child1 | Col1 | 5 |
| Parent1 | Child1 | Grand child1 | Col2 | 6 |
| Parent1 | Child1 | Figlio 2 | Col1 | 7 |
| Parent1 | Child1 | Figlio 2 | Col2 | 8 |
| Parent1 | Child2 | Figlione 3 | Col1 | 5 |
| Parent1 | Child2 | Figlione 3 | 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 |
L'oggetto visivo matrice principale di Power BI esegue il rendering dei dati come tabella.
L'oggetto visivo ottiene la struttura dei dati come descritto nel codice seguente (vengono illustrate solo le prime due righe della tabella):
{
"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": [...]
}
}
Espandere e comprimere le intestazioni di riga
Per l'API 4.1.0 o versione successiva, i dati matrice supportano l'espansione e la compressione delle intestazioni di riga. Dall'API 4.2 è possibile espandere/comprimere l'intero livello a livello di codice. La funzionalità di espansione e compressione ottimizza il recupero dei dati in dataView consentendo all'utente di espandere o comprimere una riga senza recuperare tutti i dati per il livello successivo. Recupera solo i dati per la riga selezionata. Lo stato di espansione dell'intestazione di riga rimane coerente tra i segnalibri e anche tra i report salvati. Non è specifico di ogni oggetto visivo.
È possibile aggiungere comandi di espansione e compressione al menu di scelta rapida specificando il dataRoles parametro al showContextMenu metodo .
Per espandere un numero elevato di punti dati, usare l'API recupera più dati con l'API di espansione/compressione.
Funzionalità DELL'API
Gli elementi seguenti sono stati aggiunti all'API versione 4.1.0 per abilitare l'espansione e la compressione delle intestazioni di riga:
Flag
isCollapsedinDataViewTreeNode:interface DataViewTreeNode { //... /** * TRUE if the node is Collapsed * FALSE if it is Expanded * Undefined if it cannot be Expanded (e.g. subtotal) */ isCollapsed?: boolean; }Metodo
toggleExpandCollapsenell'interfacciaISelectionManger: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 //... }The
canBeExpandedflag in the DataViewHierarchyLevel:interface DataViewHierarchyLevel { //... /** If TRUE, this level can be expanded/collapsed */ canBeExpanded?: boolean; }
Requisiti dell'oggetto visivo
Per abilitare la funzionalità di compressione di espansione in un oggetto visivo tramite la visualizzazione dati matrice:
Aggiungere il codice seguente al file 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 } },Verificare che i ruoli siano drill-able:
"drilldown": { "roles": ["Rows"] },Per ogni nodo, creare un'istanza del generatore di selezione chiamando il
withMatrixNodemetodo nel livello della gerarchia di nodi selezionato e creando un oggettoselectionId. Ad esempio: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();Creare un'istanza del gestore di selezione e usare il
selectionManager.toggleExpandCollapse()metodo , con il parametro dell'oggettoselectionIdcreato per il nodo selezionato. Ad esempio:// handle click events to apply expand\collapse action for the selected node button.addEventListener("click", () => { this.selectionManager.toggleExpandCollapse(nodeSelectionId); });
Nota
- Se il nodo selezionato non è un nodo di riga, PowerBI ignorerà le chiamate di espansione e compressione e i comandi di espansione e compressione verranno rimossi dal menu di scelta rapida.
- Il
dataRolesparametro è obbligatorio per ilshowContextMenumetodo solo se l'oggetto visivo supportadrilldownoexpandCollapsele funzionalità. Se l'oggetto visivo supporta queste funzionalità ma i datiRoles non sono stati forniti, verrà restituito un errore nella console quando si usa l'oggetto visivo dello sviluppatore o se si esegue il debug di un oggetto visivo pubblico con la modalità di debug abilitata.
Considerazioni e limitazioni
- Dopo aver espanso un nodo, i nuovi limiti dei dati verranno applicati a DataView. Il nuovo oggetto DataView potrebbe non includere alcuni nodi presentati nel dataview precedente.
- Quando si usa l'espansione o la compressione, i totali vengono aggiunti anche se l'oggetto visivo non li ha richiesti.
- L'espansione e la compressione delle colonne non sono supportate.
Mantenere tutte le colonne di metadati
Per l'API 5.1.0 o versione successiva, mantenere supportate tutte le colonne di metadati. Questa funzionalità consente all'oggetto visivo di ricevere i metadati per tutte le colonne indipendentemente dalle proiezioni attive.
Aggiungere le righe seguenti al file capabilities.json :
"keepAllMetadataColumns": {
"type": "boolean",
"description": "Indicates that visual is going to receive all metadata columns, no matter what the active projections are"
}
L'impostazione di questa proprietà su true comporterà la ricezione di tutti i metadati, incluse le colonne compresse. Impostandolo su false o lasciandolo non definito, i metadati verranno ricevuti solo sulle colonne con proiezioni attive (ad esempio espanse).
Algoritmo di riduzione dei dati
L'algoritmo di riduzione dei dati controlla i dati e la quantità di dati ricevuti nella visualizzazione dati.
Il conteggio viene impostato sul numero massimo di valori che la vista dati può accettare. Se sono presenti più valori di conteggio , l'algoritmo di riduzione dei dati determina quali valori devono essere ricevuti.
Tipi di algoritmo di riduzione dei dati
Esistono quattro tipi di impostazioni dell'algoritmo di riduzione dei dati:
top: i primi valori del conteggio vengono ricavati dal modello semantico.bottom: gli ultimi valori del conteggio vengono ricavati dal modello semantico.sample: vengono inclusi i primi e gli ultimi elementi e vengono conteggiati il numero di elementi con intervalli uguali tra di essi. Ad esempio, se si dispone di un modello semantico [0, 1, 2, ... 100] e un conteggio di 9, si ricevono i valori [0, 10, 20 ... 100].window: carica una finestra di punti dati alla volta contenente gli elementi count .topAttualmente ewindowsono equivalenti. In futuro, un'impostazione di finestra sarà completamente supportata.
Per impostazione predefinita, tutti gli oggetti visivi di Power BI hanno l'algoritmo di riduzione dei dati superiore applicato con il conteggio impostato su 1000 punti dati. Questa impostazione predefinita equivale a impostare le proprietà seguenti nel file capabilities.json :
"dataReductionAlgorithm": {
"top": {
"count": 1000
}
}
È possibile modificare il valore count in qualsiasi valore intero fino a 30000. Gli oggetti visivi di Power BI basati su R possono supportare fino a 150000 righe.
Utilizzo dell'algoritmo di riduzione dei dati
L'algoritmo di riduzione dei dati può essere usato nel mapping di visualizzazione dati categorica, tabella o matrice.
Nel mapping dei dati categorici è possibile aggiungere l'algoritmo alla sezione "categories" e/o "group" di values per il mapping dei dati categorici.
"dataViewMappings": {
"categorical": {
"categories": {
"for": { "in": "category" },
"dataReductionAlgorithm": {
"window": {
"count": 300
}
}
},
"values": {
"group": {
"by": "series",
"select": [{
"for": {
"in": "measure"
}
}
],
"dataReductionAlgorithm": {
"top": {
"count": 100
}
}
}
}
}
}
Nel mapping delle viste dati della tabella applicare l'algoritmo di riduzione dei dati alla rows sezione della tabella di mapping vista dati.
"dataViewMappings": [
{
"table": {
"rows": {
"for": {
"in": "values"
},
"dataReductionAlgorithm": {
"top": {
"count": 2000
}
}
}
}
}
]
È possibile applicare l'algoritmo di riduzione dei dati alle rows sezioni e columns della matrice di mapping di Visualizzazione dati.
Contenuto correlato
Commenti e suggerimenti
In arrivo: Nel corso del 2024 verranno ritirati i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedi: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per