Informazioni sul mapping di viste dati in oggetti visivi di Power BIUnderstand data view mapping in Power BI visuals

Questo articolo illustra il mapping di viste dati e descrive il modo in cui i ruoli dati sono correlati tra loro e consentono di specificare i requisiti condizionali per i ruoli.This article discusses data view mapping and describes how data roles relate to each other and allow you to specify conditional requirements for them. Viene inoltre descritto ogni tipo dataMappings.The article also describes each dataMappings type.

Ogni mapping valido produce una vista dati, ma attualmente è supportata l'esecuzione di una sola query per ogni oggetto visivo.Each valid mapping produces a data view, but we currently support performing only one query per visual. Normalmente si ottiene una sola vista dati.You ordinarily get only one data view. Tuttavia, è possibile fornire più mapping dei dati in determinate condizioni, che consentono:However, you can provide multiple data mappings in certain conditions, which allow:

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

Power BI crea un mapping a una vista dati solo se il mapping valido viene specificato in dataViewMappings.Power BI creates a mapping to a data view if and only if the valid mapping is filled in dataViewMappings.

In altre parole, categorical potrebbe essere definito in dataViewMappings, ma altri mapping, come table o single, potrebbero non esserlo.In other words, categorical might be defined in dataViewMappings but other mappings, such as table or single, might not be. Ad esempio:For example:

"dataViewMappings": [
    {
        "categorical": { ... }
    }
]

Power BI produce una vista dati con un unico mapping categorical, mentre table e gli altri mapping non sono definiti:Power BI produces a data view with a single categorical mapping, and table and other mappings are undefined:

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

CondizioniConditions

Questa sezione descrive le condizioni per un determinato mapping dei dati.This section describes conditions for a particular data mapping. È possibile specificare più set di condizioni per fare in modo che, se i dati corrispondono a uno dei set di condizioni descritti, l'oggetto visivo accetti i dati come validi.You can provide multiple sets of conditions and, if the data matches one of the described sets of conditions, the visual accepts the data as valid.

Attualmente, per ogni campo è possibile specificare un valore minimo e uno massimo.Currently, for each field, you can specify a minimum and maximum value. Il valore rappresenta il numero di campi che possono essere associati al ruolo dati.The value represents the number of fields that can be bound to that data role.

Nota

Se un ruolo dati viene omesso nella condizione, può essere presente un numero qualsiasi di campi.If a data role is omitted in the condition, it can have any number of fields.

Esempio 1Example 1

È possibile trascinare più campi in ogni ruolo dati.You can drag multiple fields into each data role. In questo esempio la categoria è limitata a un solo campo dati, la misura a due campi dati.In this example, you limit the category to one data field and the measure to two data fields.

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

Esempio 2Example 2

In questo esempio è necessario specificare una tra due condizioni:In this example, either of two conditions is required:

  • Esattamente un campo dati categoria e due misureExactly one category data field and exactly two measures
  • Esattamente due categorie e una misura.Exactly two categories and exactly one measure.
"conditions": [
    { "category": { "min": 1, "max": 1 }, "measure": { "min": 2, "max": 2 } },
    { "category": { "min": 2, "max": 2 }, "measure": { "min": 1, "max": 1 } }
]

Mapping dei dati singoloSingle data mapping

Il mapping dei dati singolo è la forma più semplice di mapping dei dati.Single data mapping is the simplest form of data mapping. Accetta un solo campo misura e fornisce il totale.It accepts a single measure field and gives you the total. Se il campo è numerico, restituisce la somma.If the field is numeric, it gives you the sum. In caso contrario, restituisce un conteggio di valori univoci.Otherwise, it gives you a count of unique values.

Per usare il mapping dei dati singolo, è necessario definire il nome del ruolo dati di cui si vuole eseguire il mapping.To use single data mapping, you need to define the name of the data role that you want to map. Questo mapping funziona solo con un solo campo misura.This mapping works only with a single measure field. Se si assegna un secondo campo, non viene generata alcuna vista dati. Di conseguenza, è consigliabile includere anche una condizione che limita i dati a un singolo campo.If a second field is assigned, no data view is generated, so it's also a good practice to include a condition that limits the data to a single field.

Nota

Questo mapping dei dati non può essere usato insieme ad altri mapping dei dati.This data mapping can't be used in conjunction with any other data mapping. Ha lo scopo di ridurre i dati in un singolo valore numerico.It's meant to reduce data into a single numeric value.

Esempio 3Example 3

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

La vista dati risultante contiene comunque gli altri tipi (tabella, categoria e così via), ma ogni mapping contiene solo il valore singolo.The resulting data view still contains the other types (table, categorical, and so on), but each mapping contains only the single value. La procedura consigliata consiste nell'accedere al valore solo in modalità singola.The best practice is to access the value only in single.

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

Esempio di codice per elaborare il mapping di vista dati sempliceCode sample to process simple data view mapping

"use strict";
import powerbi from "powerbi-visuals-api";
import DataView = powerbi.DataView;
import DataViewSingle = powerbi.DataViewSingle;
// standart 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();
    }
}

Di conseguenza, l'oggetto visivo mostra un valore singolo da Power BI:As a result the visual displays a single value from Power BI:

Esempio di oggetto visivo con mapping di vista dati singolo

Mapping dei dati categoricoCategorical data mapping

Il mapping dei dati categorico viene usato per ottenere uno o due raggruppamenti indipendenti di dati.Categorical data mapping is used to get one or two independent groupings of data.

Esempio 4Example 4

Ecco la definizione dall'esempio precedente per i ruoli dati:Here is the definition from the previous example for data roles:

"dataRole":[
    {
        "displayName": "Category",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Y Axis",
        "name": "measure",
        "kind": "Measure"
    }
]

Ecco il mapping:Here is the mapping:

"dataViewMappings": {
    "categorical": {
        "categories": {
            "for": { "in": "category" }
        },
        "values": {
            "select": [
                { "bind": { "to": "measure" } }
            ]
        }
    }
}

Si tratta di un semplice esempio.It's a simple example. Indica di eseguire il mapping del ruolo dati category in modo che per ogni campo trascinato in category venga eseguito il mapping a categorical.categories.It reads "Map my category data role so that for every field I drag into category, its data is mapped to categorical.categories. Indica anche di eseguire anche il mapping del ruolo dati measure a categorical.values.Also map my measure data role to categorical.values."

  • for...in: include tutti gli elementi in questo ruolo dati nella query dati.for...in: For all the items in this data role, include them in the data query.
  • bind...to: genera lo stesso risultato di for...in, ma prevede che il ruolo dati sia associato a una condizione che lo limita a un singolo campo.bind...to: Produces the same result as in for...in, but expects that the data role will have a condition restricting it to a single field.

Esempio 5Example 5

In questo esempio vengono usati i primi due ruoli dati dell'esempio precedente e vengono inoltre definiti grouping e measure2.This example uses the first two data roles from the previous example and additionally defines grouping and 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"
    }
]

Ecco il mapping:Here is the mapping:

"dataViewMappings":{
    "categorical": {
        "categories": {
            "for": { "in": "category" }
        },
        "values": {
            "group": {
                "by": "grouping",
                "select":[
                    { "bind": { "to": "measure" } },
                    { "bind": { "to": "measure2" } }
                ]
            }
        }
    }
}

Qui la differenza consiste nel modo in cui viene eseguito il mapping di categorical.values.Here the difference is in how we are mapping categorical.values. È come specificare di eseguire il mapping dei ruoli dati measure e measure2, da raggruppare in base al ruolo dati grouping.We are saying that "Map my measure and measure2 data roles to be grouped by the data role grouping."

Esempio 6Example 6

Ecco i ruoli dati:Here are the data roles:

"dataRoles": [
    {
        "displayName": "Categories",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Measures",
        "name": "measure",
        "kind": "Measure"
    },
    {
        "displayName": "Series",
        "name": "series",
        "kind": "Measure"
    }
]

Ecco il mapping della vista dati:Here is the data view mapping:

"dataViewMappings": [
    {
        "categorical": {
            "categories": {
                "for": {
                    "in": "category"
                }
            },
            "values": {
                "group": {
                    "by": "series",
                    "select": [{
                            "for": {
                                "in": "measure"
                            }
                        }
                    ]
                }
            }
        }
    }
]

La vista dati categorica potrebbe essere visualizzata in questo modo:The categorical data view could be visualized like this:

PaeseCountry 20132013 20142014 20152015 20162016
USAUSA xx xx 650650 350350
CanadaCanada xx 630630 490490 xx
MessicoMexico 645645 xx xx xx
Regno UnitoUK xx xx 831831 xx

Power BI lo produce come vista dati categorica.Power BI produces it as the categorical data view. Si tratta del set di categorie.It's the set of categories.

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

Ogni categoria viene mappata anche a un set di valori.Each category maps to a set of values as well. Ognuno di questi valori è raggruppato per serie, espresse in anni.Each of these values is grouped by series, which is expressed as years.

Ogni matrice di values rappresenta ad esempio i dati per ogni anno.For example, each values array represents data for each year. Ogni matrice di values ha anche 4 valori, rispettivamente per Canada, Stati Uniti, Regno Unito e Messico:Also each values array has 4 values, for Canada, USA, UK and Mexico respectively:

{
    "values": [
        // Values for 2013 year
        {
            "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 2014 year
        {
            "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 2015 year
        {
            "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 2016 year
        {
            "source": {...},
            "values": [
                null, // Value for `Canada` category
                350, // Value for `USA` category
                null, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        }
    ]
}

Di seguito viene descritto un esempio di codice per l'elaborazione del mapping di vista dati categorico.Code sample for processing categorical data view mapping is described below. L'esempio crea la struttura gerarchica Country => Year => ValueThe sample creates Hierarchical structure Country => Year => Value

"use strict";
import powerbi from "powerbi-visuals-api";
import DataView = powerbi.DataView;
import DataViewDataViewCategoricalSingle = 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
        // If you want to support several columns of categories data bucket, you should iterate categoricalDataView.categories array.
        const categoryFieldIndex = 0;
        // Measure has only one column in data buckets.
        // If you want to support several columns on data bucket, you should 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);
    }
}

Risultato dell'oggetto visivo:The result of the visual:

Oggetto visivo con mapping di vista dati categorico

Mapping di dati tabellaTable data mapping

La vista dati tabella è un semplice mapping dei dati.The table data view is a simple data mapping. Si tratta essenzialmente di un elenco di punti dati, in cui è possibile aggregare punti dati numerici.Essentially, it's a list of data points, where numeric data points could be aggregated.

Esempio 7Example 7

Con le funzionalità specificate:With the given capabilities:

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

È possibile visualizzare la vista dati tabella come segue:You can visualize the table data view as the following:

Esempio di dati:Data example:

PaeseCountry YearYear SalesSales
USAUSA 20162016 100100
USAUSA 20152015 5050
CanadaCanada 20152015 200200
CanadaCanada 20152015 5050
MessicoMexico 20132013 300300
Regno UnitoUK 20142014 150150
USAUSA 20152015 7575

Associazione dati:Data binding:

associazioni dati di mapping della vista dati tabella

Power BI visualizza i dati come vista dati tabella.Power BI displays your data as the table data view. I dati non sono necessariamente ordinati.You shouldn't assume that the data is ordered.

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

È possibile aggregare i dati selezionando il campo desiderato e quindi selezionando Somma.You can aggregate the data by selecting the desired field and then selecting sum.

Aggregazione dei dati

Esempio di codice per elaborare il mapping della vista dati tabella.Code sample to process table data view mapping.

"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);
        });
    }
}

Il file degli stili dell'oggetto visivo style/visual.less contiene il layout per la tabella:The visual styles file style/visual.less contains layout for table:

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

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

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

Oggetto visivo con mapping della vista dati tabella

Mapping di dati matriceMatrix data mapping

Il mapping di dati matrice è simile al mapping di dati tabella, ma le righe vengono presentate in modo gerarchico.Matrix data mapping is similar to table data mapping, but the rows are presented hierarchically. Qualsiasi dei valori dei ruoli dati può essere usato come valore di intestazione di colonna.Any of the data role values can be used as a column header value.

{
    "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 crea una struttura di dati gerarchici.Power BI creates a hierarchical data structure. La radice della gerarchia dell'albero include i dati della colonna Parents del ruolo dati Category, con elementi figlio della colonna Children della tabella del ruolo dati.The root of the tree hierarchy includes the data from the Parents column of the Category data role, with children from the Children column of the data role table.

Set di dati:Dataset:

ParentsParents ChildrenChildren GrandchildrenGrandchildren ColonneColumns ValoriValues
Parent1Parent1 Child1Child1 Grand child1Grand child1 Col1Col1 55
Parent1Parent1 Child1Child1 Grand child1Grand child1 Col2Col2 66
Parent1Parent1 Child1Child1 Grand child2Grand child2 Col1Col1 77
Parent1Parent1 Child1Child1 Grand child2Grand child2 Col2Col2 88
Parent1Parent1 Child2Child2 Grand child3Grand child3 Col1Col1 55
Parent1Parent1 Child2Child2 Grand child3Grand child3 Col2Col2 33
Parent1Parent1 Child2Child2 Grand child4Grand child4 Col1Col1 44
Parent1Parent1 Child2Child2 Grand child4Grand child4 Col2Col2 99
Parent1Parent1 Child2Child2 Grand child5Grand child5 Col1Col1 33
Parent1Parent1 Child2Child2 Grand child5Grand child5 Col2Col2 55
Parent2Parent2 Child3Child3 Grand child6Grand child6 Col1Col1 11
Parent2Parent2 Child3Child3 Grand child6Grand child6 Col2Col2 22
Parent2Parent2 Child3Child3 Grand child7Grand child7 Col1Col1 77
Parent2Parent2 Child3Child3 Grand child7Grand child7 Col2Col2 11
Parent2Parent2 Child3Child3 Grand child8Grand child8 Col1Col1 1010
Parent2Parent2 Child3Child3 Grand child8Grand child8 Col2Col2 1313

L'oggetto visivo matrice di base di Power BI esegue il rendering dei dati come tabella.The core matrix visual of Power BI renders the data as a table.

Oggetto visivo matrice

L'oggetto visivo ottiene la struttura dei dati come descritto nel codice seguente (vengono visualizzate solo le prime due righe della tabella):The visual gets its data structure as described in the following code (only the first two table rows are shown here):

{
    "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": [...]
    }
}

Algoritmo di riduzione dei datiData reduction algorithm

Per controllare la quantità di dati da ricevere nella vista dati, è possibile applicare un algoritmo di riduzione dei dati.To control the amount of data to receive in the data view, you can apply a data reduction algorithm.

Per impostazione predefinita, a tutti gli oggetti visivi di Power BI viene applicato l'algoritmo di riduzione dei dati superiore con count impostato su 1000 punti dati.By default, all Power BI visuals have the top data reduction algorithm applied with the count set to 1000 data points. Questo equivale a impostare le proprietà seguenti nel file capabilities.json:It's the same as setting the following properties in the capabilities.json file:

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

È possibile modificare il valore count con qualsiasi valore intero fino a 30000.You can modify the count value to any integer value up to 30000. Gli oggetti visivi di Power BI basati su R possono supportare fino a 150.000 righe.R-based Power BI visuals can support up to 150000 rows.

Tipi di algoritmo di riduzione dei datiData reduction algorithm types

Sono disponibili quattro tipi di impostazioni per l'algoritmo di riduzione dei dati:There are four types of data reduction algorithm settings:

  • top: se si vuole limitare i dati ai valori acquisiti dalla parte superiore del set di dati.top: If you want to limit the data to values taken from the top of the dataset. Dal set di dati vengono acquisiti i primi valori superiori, in base al numero count.The top first count values will be taken from the dataset.
  • bottom: se si vuole limitare i dati ai valori acquisiti dalla parte inferiore del set di dati.bottom: If you want to limit the data to values taken from the bottom of the dataset. Dal set di dati vengono acquisiti gli ultimi valori, in base al numero "count".The last "count" values will be taken from the dataset.
  • sample: riduce il set di dati in base a un semplice algoritmo di campionamento limitato a un numero count di elementi.sample: Reduce the dataset by a simple sampling algorithm, limited to a count number of items. Significa che vengono inclusi il primo e l'ultimo elemento, insieme a un numero count di elementi con intervalli uguali tra loro.It means that the first and last items are included, and a count number of items have equal intervals between them. Ad esempio, con un set di dati [0, 1, 2,... 100] e un numero count pari a 9, si riceveranno i valori [0, 10, 20... 100].For example, if you have a dataset [0, 1, 2, ... 100] and a count of 9, you'll receive the values [0, 10, 20 ... 100].
  • window: carica una finestra di punti dati per volta contenente elementi count.window: Loads one window of data points at a time containing count elements. Attualmente, top e window sono equivalenti.Currently, top and window are equivalent. A breve sarà disponibile il supporto completo per un'impostazione di definizione delle finestre.We are working toward fully supporting a windowing setting.

Uso dell'algoritmo di riduzione dei datiData reduction algorithm usage

L'algoritmo di riduzione dei dati può essere usato in mapping di viste dati categoriche, tabella o matrice.The data reduction algorithm can be used in categorical, table, or matrix data view mapping.

È possibile impostare l'algoritmo in categories e/o nella sezione di gruppo values per il mapping dei dati categorico.You can set the algorithm into categories and/or group section of values for categorical data mapping.

Esempio 8Example 8

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

È possibile applicare l'algoritmo di riduzione dei dati alla sezione rows della tabella di mapping della vista dati.You can apply the data reduction algorithm to the rows section of the Data View mapping table.

Esempio 9Example 9

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

È possibile applicare l'algoritmo di riduzione dei dati alle sezioni rows e columns della matrice di mapping della vista dati.You can apply the data reduction algorithm to the rows and columns sections of the Data View mapping matrix.

Passaggi successiviNext steps

Informazioni su come aggiungere il supporto per il drill-down per i mapping delle viste dati in oggetti visivi di Power BI.Read how to add Drill-Down support for data view mappings in Power BI visuals.