Principy mapování zobrazení dat ve vizuálech Power BIUnderstand data view mapping in Power BI visuals

Tento článek vysvětluje mapování zobrazení dat a popisuje vzájemné souvislosti rolí dat a možnost specifikovat pro ně podmíněné požadavky.This article discusses data view mapping and describes how data roles relate to each other and allow you to specify conditional requirements for them. Článek také popisuje jednotlivé typy dataMappings.The article also describes each dataMappings type.

Každé platné mapování vytvoří zobrazení dat, ale momentálně podporujeme pouze provádění jednoho dotazu na jeden vizuál.Each valid mapping produces a data view, but we currently support performing only one query per visual. Obvykle získáte pouze jedno zobrazení dat.You ordinarily get only one data view. Za určitých podmínek ale můžete zadat více mapování dat:However, you can provide multiple data mappings in certain conditions, which allow:

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

Power BI vytvoří mapování na zobrazení dat, pokud a pouze pokud je v objektu dataViewMappings vyplněno platné mapování.Power BI creates a mapping to a data view if and only if the valid mapping is filled in dataViewMappings.

Jinými slovy, categorical může být v objektu dataViewMappings definováno, ale jiná mapování, například table nebo single, už ne.In other words, categorical might be defined in dataViewMappings but other mappings, such as table or single, might not be. Například:For example:

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

Power BI vytvoří zobrazení dat s jedním mapováním categorical a mapování table a další mapování nejsou definována:Power BI produces a data view with a single categorical mapping, and table and other mappings are undefined:

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

PodmínkyConditions

Tato část popisuje podmínky pro konkrétní mapování dat.This section describes conditions for a particular data mapping. Můžete zadat několik sad podmínek, a pokud data odpovídají jedné z popsaných sad podmínek, vizuál data přijme jako platná.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.

Momentálně můžete pro každé pole zadat minimální a maximální hodnotu.Currently, for each field, you can specify a minimum and maximum value. Tato hodnota představuje počet polí, která lze s danou rolí dat svázat.The value represents the number of fields that can be bound to that data role.

Poznámka

Pokud v podmínce roli dat vynecháte, může obsahovat libovolný počet polí.If a data role is omitted in the condition, it can have any number of fields.

Příklad 1Example 1

Do každé role dat můžete přetáhnout více polí.You can drag multiple fields into each data role. V tomto příkladu omezíte kategorii na jedno datové pole a míru na dvě datová pole.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 } },
]

Příklad 2Example 2

V tomto příkladu se vyžaduje jedna ze dvou podmínek:In this example, either of two conditions is required:

  • Přesně jedno datové pole kategorie a přesně dvě míryExactly one category data field and exactly two measures
  • Přesně dvě kategorie a přesně jedna míraExactly 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 } }
]

Jednoduché mapování datSingle data mapping

Jednoduché mapování dat představuje nejjednodušší formu mapování dat.Single data mapping is the simplest form of data mapping. Přijímá jedno pole míry a vrátí celkový souhrn.It accepts a single measure field and gives you the total. Pokud je pole číselné, vrátí součet.If the field is numeric, it gives you the sum. V ostatních případech vrátí počet jedinečných hodnot.Otherwise, it gives you a count of unique values.

Pokud chcete použít jednoduché mapování dat, musíte definovat název role dat, kterou chcete mapovat.To use single data mapping, you need to define the name of the data role that you want to map. Toto mapování funguje pouze s jedním polem míry.This mapping works only with a single measure field. Pokud přiřadíte druhé pole, nevygeneruje se žádné zobrazení dat, takže je vhodné zahrnout rovněž podmínku, která omezí data na jedno pole.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.

Poznámka

Toto mapování nelze používat spolu s žádným jiným mapováním dat.This data mapping can't be used in conjunction with any other data mapping. Jeho účelem je redukovat data na jednu číselnou hodnotu.It's meant to reduce data into a single numeric value.

Příklad 3Example 3

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

Výsledné zobrazení dat i nadále obsahuje ostatní typy (table, categorical atd.), ale každé mapování obsahuje jenom jednu hodnotu.The resulting data view still contains the other types (table, categorical, and so on), but each mapping contains only the single value. Osvědčeným postupem je přístup k hodnotě jenom v jednoduchém mapování.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
            }
        }
    ]
}

Ukázka kódu pro zpracování mapování zobrazení jednoduchých datCode 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();
    }
}

V důsledku toho vizuál zobrazuje jednu hodnotu z Power BI:As a result the visual displays a single value from Power BI:

Příklad vizuálu mapování jednoho zobrazení dat

Kategorické mapování datCategorical data mapping

Kategorické mapování dat slouží k získání jedné nebo dvou nezávislých seskupení dat.Categorical data mapping is used to get one or two independent groupings of data.

Příklad 4Example 4

Tady je definice z předchozího příkladu pro role dat: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"
    }
]

Tady je mapování:Here is the mapping:

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

Jedná se o jednoduchý příklad.It's a simple example. Určuje, že se role dat category má namapovat tak, aby se pro každé pole přetažené do role category jeho data namapovala k 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. Dále určuje, aby se role dat measure namapovala k categorical.values.Also map my measure data role to categorical.values."

  • for...in: Pro všechny položky v této roli dat platí, že se mají zahrnout do dotazu na data.for...in: For all the items in this data role, include them in the data query.
  • bind...to: Vrátí stejný výsledek jako for...in, ale očekává, že objekt role dat bude mít podmínku, která nastaví omezení na jedno pole.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.

Příklad 5Example 5

Tento příklad používá první dvě role dat z předchozího příkladu a dále definuje role grouping a 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"
    }
]

Tady je mapování:Here is the mapping:

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

Tady je rozdíl ve způsobu mapování categorical.values.Here the difference is in how we are mapping categorical.values. Určujeme, že se role dat measure a measure2 mají namapovat tak, aby se seskupily podle role dat grouping.We are saying that "Map my measure and measure2 data roles to be grouped by the data role grouping."

Příklad 6Example 6

Tady jsou role dat:Here are the data roles:

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

Tady je mapování zobrazení dat:Here is the data view mapping:

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

Kategorické zobrazení dat lze vizualizovat takto:The categorical data view could be visualized like this:

ZeměCountry 20132013 20142014 20152015 20162016
USAUSA xx xx 650650 350350
KanadaCanada xx 630630 490490 xx
MexikoMexico 645645 xx xx xx
UKUK xx xx 831831 xx

Power BI vytvoří kategorické zobrazení dat.Power BI produces it as the categorical data view. Jedná se o sadu kategorií.It's the set of categories.

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

Každá kategorie se namapuje také k sadě hodnot.Each category maps to a set of values as well. Každá z těchto hodnot je seskupena podle řady, která je vyjádřena jako roky.Each of these values is grouped by series, which is expressed as years.

Každé pole values například představuje data pro každý rok.For example, each values array represents data for each year. Každé pole values má také 4 hodnoty: pro Kanadu, USA, Spojené království a Mexiko: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": [...],
        }
    ]
}

Ukázka kódu pro zpracování mapování zobrazení dat kategorií je popsána níže.Code sample for processing categorical data view mapping is described below. Ukázka vytvoří hierarchickou strukturu Country => Year => Value.The 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);
    }
}

Výsledek vizuálu:The result of the visual:

Vizuál s mapováním zobrazení dat kategorií

Tabulkové mapování datTable data mapping

Zobrazení dat tabulky představuje jednoduché mapování dat.The table data view is a simple data mapping. V podstatě se jedná o seznam datových bodů, kde lze číselné datové body agregovat.Essentially, it's a list of data points, where numeric data points could be aggregated.

Příklad 7Example 7

S danými funkcemi dosáhneme tohoto: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"
                        }
                    }
                ]
            }
        }
    }
]

Zobrazení dat tabulky lze vizualizovat takto:You can visualize the table data view as the following:

Ukázka dat:Data example:

ZeměCountry Year (Rok)Year SalesSales
USAUSA 20162016 100100
USAUSA 20152015 5050
KanadaCanada 20152015 200200
KanadaCanada 20152015 5050
MexikoMexico 20132013 300300
UKUK 20142014 150150
USAUSA 20152015 7575

Datová vazba:Data binding:

Datové vazby mapování zobrazení dat tabulky

Power BI zobrazí data jako zobrazení dat tabulky.Power BI displays your data as the table data view. Neměli byste předpokládat, že data budou seřazená.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
            ]
        ]
    }
}

Data můžete agregovat tak, že vyberete požadované pole a pak vyberete Součet.You can aggregate the data by selecting the desired field and then selecting sum.

Agregace dat

Ukázka kódu pro zpracování mapování zobrazení dat tabulkyCode 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);
        });
    }
}

Soubor stylů vizuálu style/visual.less obsahuje rozložení pro tabulku: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;
}

Vizuál s mapováním zobrazení dat tabulky

Maticové mapování datMatrix data mapping

Maticové mapování dat se podobá tabulkovému mapování dat, ale řádky jsou vyjádřeny hierarchicky.Matrix data mapping is similar to table data mapping, but the rows are presented hierarchically. Některou z hodnot rolí dat můžete použít jako hodnotu záhlaví sloupce.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 vytvoří hierarchickou datovou strukturu.Power BI creates a hierarchical data structure. Kořen stromové hierarchie obsahuje data ze sloupce Nadřazené prvky v roli dat Category, s podřízenými prvky ze sloupce Podřízené prvky v tabulce rolí dat.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.

Datová sada:Dataset:

Nadřazené prvkyParents Podřízené prvkyChildren Podřízené prvky druhé úrovněGrandchildren SloupceColumns HodnotyValues
Nadřazený prvek 1Parent1 Podřízený prvek 1Child1 Podřízený prvek druhé úrovně 1Grand child1 Sloupec 1Col1 55
Nadřazený prvek 1Parent1 Podřízený prvek 1Child1 Podřízený prvek druhé úrovně 1Grand child1 Sloupec 2Col2 66
Nadřazený prvek 1Parent1 Podřízený prvek 1Child1 Podřízený prvek druhé úrovně 2Grand child2 Sloupec 1Col1 77
Nadřazený prvek 1Parent1 Podřízený prvek 1Child1 Podřízený prvek druhé úrovně 2Grand child2 Sloupec 2Col2 88
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 3Grand child3 Sloupec 1Col1 55
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 3Grand child3 Sloupec 2Col2 33
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 4Grand child4 Sloupec 1Col1 44
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 4Grand child4 Sloupec 2Col2 99
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 5Grand child5 Sloupec 1Col1 33
Nadřazený prvek 1Parent1 Podřízený prvek 2Child2 Podřízený prvek druhé úrovně 5Grand child5 Sloupec 2Col2 55
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 6Grand child6 Sloupec 1Col1 11
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 6Grand child6 Sloupec 2Col2 22
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 7Grand child7 Sloupec 1Col1 77
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 7Grand child7 Sloupec 2Col2 11
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 8Grand child8 Sloupec 1Col1 1010
Nadřazený prvek 2Parent2 Podřízený prvek 3Child3 Podřízený prvek druhé úrovně 8Grand child8 Sloupec 2Col2 1313

Základní vizuál matice Power BI vykreslí data jako tabulku.The core matrix visual of Power BI renders the data as a table.

Vizuál matice

Vizuál získá datovou strukturu podle popisu v následujícím kódu (tady jsou zobrazeny jenom první dva řádky tabulky):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": [...]
    }
}

Algoritmus redukce datData reduction algorithm

Pokud chcete řídit množství dat, které má zobrazení dat přijmout, můžete použít algoritmus redukce dat.To control the amount of data to receive in the data view, you can apply a data reduction algorithm.

Ve výchozím nastavení se u všech vizuálů Power BI používá algoritmus redukce dat typu top s hodnotou count nastavenou na 1000 datových bodů.By default, all Power BI visuals have the top data reduction algorithm applied with the count set to 1000 data points. Jedná se o ekvivalent nastavení následujících vlastností v souboru capabilities.json:It's the same as setting the following properties in the capabilities.json file:

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

Hodnotu count můžete změnit na libovolnou celočíselnou hodnotu až do výše 30 000.You can modify the count value to any integer value up to 30000. Vizuály Power BI založené na jazyce R můžou podporovat až 150 000 řádků.R-based Power BI visuals can support up to 150000 rows.

Typy algoritmu redukce datData reduction algorithm types

Existují čtyři typy nastavení algoritmu redukce dat:There are four types of data reduction algorithm settings:

  • top: Pokud chcete omezit data na hodnoty převzaté z prvních míst datové sady.top: If you want to limit the data to values taken from the top of the dataset. Z datové sady se převezme určitý počet prvních hodnot, který je určen hodnotou count.The top first count values will be taken from the dataset.
  • bottom: Pokud chcete omezit data na hodnoty převzaté z posledních míst datové sady.bottom: If you want to limit the data to values taken from the bottom of the dataset. Z datové sady se převezme určitý počet posledních hodnot, který je určen hodnotou count.The last "count" values will be taken from the dataset.
  • sample: Zmenší datovou sadu podle jednoduchého algoritmu vzorkování tak, že ji omezí na uvedený počet položek (určený hodnotou count).sample: Reduce the dataset by a simple sampling algorithm, limited to a count number of items. Zahrnou se první a poslední položky a počet položek (určený hodnotou count) má mezi sebou pravidelné intervaly.It means that the first and last items are included, and a count number of items have equal intervals between them. Pokud například máte datovou sadu [0, 1, 2, ... 100] a count má hodnotu 9, získáte hodnoty [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: Načte najednou jedno okno datových bodů obsahující určitý počet elementů (určený hodnotou count).window: Loads one window of data points at a time containing count elements. Momentálně jsou typy top a window ekvivalentní.Currently, top and window are equivalent. Pracujeme na zajištění plné podpory pro vytváření oken.We are working toward fully supporting a windowing setting.

Použití algoritmu redukce datData reduction algorithm usage

Algoritmus redukce dat lze použít u kategorického, tabulkového nebo maticového mapování zobrazení dat.The data reduction algorithm can be used in categorical, table, or matrix data view mapping.

U kategorického mapování dat můžete algoritmus nastavit do oddílu categories nebo do oddílu group v oddílu values.You can set the algorithm into categories and/or group section of values for categorical data mapping.

Příklad 8Example 8

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

Algoritmus redukce dat můžete použít v oddílu rows tabulky mapování zobrazení dat.You can apply the data reduction algorithm to the rows section of the Data View mapping table.

Příklad 9Example 9

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

Algoritmus redukce dat můžete použít v oddílech rows a columns matice mapování zobrazení dat.You can apply the data reduction algorithm to the rows and columns sections of the Data View mapping matrix.

Další krokyNext steps

Přečtěte si, jak přidat podporu přechodu k podrobnostem pro mapování zobrazení dat ve vizuálech Power BI.Read how to add Drill-Down support for data view mappings in Power BI visuals.