A Power BI-vizualizációkban végzett adatnézeti-leképezések ismertetéseUnderstand data view mapping in Power BI visuals

Ez a cikk az adatnézet-leképezést ismerteti, valamint leírja, hogy az adatszerepkörök milyen viszonyban állnak egymással, és hogyan teszik lehetővé a rájuk vonatkozó feltételes követelmények megadását.This article discusses data view mapping and describes how data roles relate to each other and allow you to specify conditional requirements for them. A cikk a dataMappings egyes típusait is ismerteti.The article also describes each dataMappings type.

Minden érvényes leképezés állít elő adatnézetet, de jelenleg vizualizációnként csak egy leképezés végrehajtását támogatjuk.Each valid mapping produces a data view, but we currently support performing only one query per visual. Általában csak egy adatnézet áll elő.You ordinarily get only one data view. Bizonyos feltételek mellett azonban több adatleképezést is megadhat. Ilyenkor használható a következő:However, you can provide multiple data mappings in certain conditions, which allow:

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

A Power BI csak akkor hoz létre leképezést az adatokhoz, ha az érvényes leképezés szerepel a dataViewMappings listában.Power BI creates a mapping to a data view if and only if the valid mapping is filled in dataViewMappings.

Másként fogalmazva a categorical esetleg definiálva van a dataViewMappings szakaszban, más leképezések, például a table vagy a single viszont nem.In other words, categorical might be defined in dataViewMappings but other mappings, such as table or single, might not be. Például:For example:

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

A Power BI egyetlen categorical leképezéssel állít elő adatnézetet, a table és a többi leképezés pedig nincs definiálva:Power BI produces a data view with a single categorical mapping, and table and other mappings are undefined:

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

FeltételekConditions

Ez a szakasz egy adott adatleképezés feltételeit írja le.This section describes conditions for a particular data mapping. Több feltételcsoportot is megadhat, és ha az adatok megfelelnek a feltételcsoportok valamelyikének, a vizualizáció érvényesként fogadja el az adathalmazt.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.

Jelenleg minden mezőnél megadhatja a minimum és a maximum értéket.Currently, for each field, you can specify a minimum and maximum value. Ez az érték az adatszerepkörhöz köthető mezők számát jelöli.The value represents the number of fields that can be bound to that data role.

Megjegyzés

Ha a feltétel nem tartalmaz adatszerepkört, akkor tetszőleges számú mezővel rendelkezhet.If a data role is omitted in the condition, it can have any number of fields.

1. példaExample 1

Több mezőt is áthúzhat az egyes adatszerepkörökbe.You can drag multiple fields into each data role. Ebben a példában a kategória egy adatmezőre, a mérték pedig két adatmezőre van korlátozva.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 } },
]

2. példaExample 2

Ebben a példában két feltétel egyikét kell megadnia:In this example, either of two conditions is required:

  • Pontosan egy kategória-adatmező és pontosan kettő mértékExactly one category data field and exactly two measures
  • Pontosan két kategória és pontosan egy mérték.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 } }
]

Egyirányú adatleképezésSingle data mapping

Az egyirányú adatleképezés az adatleképezés legegyszerűbb formája.Single data mapping is the simplest form of data mapping. Egyetlen mértékmezőt fogad el, és megadja a teljes értéket.It accepts a single measure field and gives you the total. Ha a mező numerikus, akkor az összeget adja.If the field is numeric, it gives you the sum. Ellenkező esetben az egyedi értékek számát adja.Otherwise, it gives you a count of unique values.

Egyirányú adatleképezés használatához meg kell adnia a leképezni kívánt adatszerepkör nevét.To use single data mapping, you need to define the name of the data role that you want to map. Ez a leképezés csak egyetlen mértékmezővel működik.This mapping works only with a single measure field. Egy újabb mező hozzárendelése esetén nem lesz adatnézet generálva, tehát ajánlott olyan feltételt is megadni, amely egyetlen mezőre korlátozza az adatokat.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.

Megjegyzés

Ez az adatleképezés más adatnézettel együtt nem használható.This data mapping can't be used in conjunction with any other data mapping. A célja az, hogy egyetlen numerikus értékre csökkentse az adatokat.It's meant to reduce data into a single numeric value.

3. példaExample 3

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

Az eredményül kapott adatnézet továbbra is tartalmazza a többi típust (táblázatos, kategorikus stb.), de minden leképezés csak egyetlen értéket tartalmaz.The resulting data view still contains the other types (table, categorical, and so on), but each mapping contains only the single value. Az ajánlott eljárás az, ha csak az egyedi értékhez fér hozzá.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
            }
        }
    ]
}

Mintakód az egyszerű adatnézet-leképezés feldolgozásáhozCode 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();
    }
}

A vizualizáció ennek eredményeképp egyetlen értéket jelenít meg a Power BI-ból:As a result the visual displays a single value from Power BI:

Egy adatnézet-leképezési vizualizáció

Kategorikus adatleképezésCategorical data mapping

A kategorikus adatleképezés használatával egy vagy két független adatcsoportot lehet beolvasni.Categorical data mapping is used to get one or two independent groupings of data.

4. példaExample 4

Itt az előző példában használt adatszerepkörök definíciója látható: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"
    }
]

Ez pedig a leképezés:Here is the mapping:

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

A példa egyszerű.It's a simple example. Emberi nyelven így szól: „Képezd le a category adatszerepkörömet úgy, hogy minden olyan mezőnél, amelyet áthúzok a category területre, a mező adatai a categorical.categories-ra legyenek leképezve.It reads "Map my category data role so that for every field I drag into category, its data is mapped to categorical.categories. A measure adatszerepkörömet pedig képezd le a categorical.values-ra.”Also map my measure data role to categorical.values."

  • for...in: Ebben az adatszerepkörben minden elemet vegyen fel az adatlekérdezésbe.for...in: For all the items in this data role, include them in the data query.
  • bind...to: Ugyanazt az eredményt adja, mint a for...in, azonban azt várja, hogy a DataRole feltétele egyetlen mezőre lesz korlátozva.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.

5. példaExample 5

Ez a példa az előző példában szereplő első két adatszerepkört használja, továbbá definiálja a grouping és a measure2 mezőt.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"
    }
]

Ez pedig a leképezés:Here is the mapping:

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

Itt a különbség a categorical.values leképezése lesz.Here the difference is in how we are mapping categorical.values. Ez ennyit jelent: „Képezd le a measure és a measure2 adatszerepkört úgy, hogy a grouping adatszerepkör alapján legyenek csoportosítva.”We are saying that "Map my measure and measure2 data roles to be grouped by the data role grouping."

6. példaExample 6

Az alábbiak az adatszerepkörök:Here are the data roles:

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

Ez pedig az adatnézet-leképezés:Here is the data view mapping:

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

A kategorikus adatnézet a következő módon jeleníthető meg:The categorical data view could be visualized like this:

OrszágCountry 20132013 20142014 20152015 20162016
USAUSA xx xx 650650 350350
KanadaCanada xx 630630 490490 xx
MexikóMexico 645645 xx xx xx
Egyesült KirályságUK xx xx 831831 xx

A Power BI ezt a kategorikus adatnézetként állítja elő.Power BI produces it as the categorical data view. Ez a kategóriák csoportja.It's the set of categories.

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

Minden kategória egy értékcsoportra van leképezve.Each category maps to a set of values as well. Az értékek mindegyike sorozat szerint van csoportosítva, ami években van kifejezve.Each of these values is grouped by series, which is expressed as years.

Minden values tömb például minden évre vonatkozóan képvisel adatokat.For example, each values array represents data for each year. Emellett minden values tömb négy értékkel rendelkezik, Kanadához, az USA-hoz, az Egyesült Királysághoz és Mexikóhoz (ebben a sorrendben):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": [...],
        }
    ]
}

A kategorikus adatnézet-leképezés feldolgozására szolgáló kódmintát alább ismertetjük.Code sample for processing categorical data view mapping is described below. A minta egy hierarchikus szerkezetet hoz létre Country => Year => ValueThe sample creates Hierarchical structure Country => Year => Value

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

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

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

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

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

        // Categories have only one column in data buckets
        // 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);
    }
}

A vizualizáció eredménye:The result of the visual:

A kategorikus adatnézet-leképezést tartalmazó vizualizáció

Táblázatos adatleképezésTable data mapping

A táblázatos adatnézet egy egyszerű adatleképezés.The table data view is a simple data mapping. Ez lényegében adatpontok listája, ahol a numerikus adatpontok összesíthetőek.Essentially, it's a list of data points, where numeric data points could be aggregated.

7. példaExample 7

A megadott képességekkel: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"
                        }
                    }
                ]
            }
        }
    }
]

A táblázatos adatnézetet a következő módon képezheti le:You can visualize the table data view as the following:

Példaadatok:Data example:

OrszágCountry YearYear SalesSales
USAUSA 20162016 100100
USAUSA 20152015 5050
KanadaCanada 20152015 200200
KanadaCanada 20152015 5050
MexikóMexico 20132013 300300
Egyesült KirályságUK 20142014 150150
USAUSA 20152015 7575

Adatkötés:Data binding:

Táblázatos adatnézet-leképezés adatkötései

A Power BI a táblázatos adatnézetként jeleníti meg az adatokat.Power BI displays your data as the table data view. Nem feltételezhető, hogy az adatok rendezve vannak.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
            ]
        ]
    }
}

Összesítheti is az adatokat, ha kijelöli a kívánt mezőt, majd az összegzést választja.You can aggregate the data by selecting the desired field and then selecting sum.

Adatösszesítés

Mintakód a táblázatos adatnézet-leképezés feldolgozásához.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);
        });
    }
}

A vizualizációstílusok fájlja (style/visual.less) a következő táblázatelrendezést tartalmazza: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;
}

A táblázatos adatnézet-leképezést tartalmazó vizualizáció

Mátrixos adatleképezésMatrix data mapping

A mátrixos adatleképezés hasonló a táblázatos adatleképezéshez, de a sorok hierarchikusan jelennek meg.Matrix data mapping is similar to table data mapping, but the rows are presented hierarchically. Bármelyik adatszerepkör-érték használható oszlopfejléc értékeként.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"
                            }
                        }
                    ]
                }
            }
        }
    ]
}

A Power BI hierarchikus adatstruktúrát hoz létre.Power BI creates a hierarchical data structure. A fahierarchia gyökere tartalmazza a Category szerepkör Szülőelemek oszlopából származó adatokat, az adatszerepkör-tábla Gyermekelemek oszlopából származó gyermekelemekkel.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.

Adatkészlet:Dataset:

SzülőkParents GyermekekChildren UnokákGrandchildren OszlopokColumns ÉrtékekValues
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

A Power BI alap mátrix vizualizációja az adatokat táblázatként jeleníti meg.The core matrix visual of Power BI renders the data as a table.

Mátrix vizualizáció

A vizualizáció az alábbi kódban leírtak alapján kap adatstruktúrát (itt csak az első két táblázatsor látható):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": [...]
    }
}

Adatcsökkentési algoritmusData reduction algorithm

Az adatnézetben kapott adatok mennyiségének szabályozására adatcsökkentési algoritmust alkalmazhat.To control the amount of data to receive in the data view, you can apply a data reduction algorithm.

Alapértelmezés szerint minden Power BI-vizualizációnál alkalmazva van a top adatcsökkentési algoritmus, és a count (darabszám) értéke 1000 adatpontra van beállítva.By default, all Power BI visuals have the top data reduction algorithm applied with the count set to 1000 data points. Ez ugyanazzal az eredménnyel jár, mint a következő tulajdonságok módosítása a capabilities.json fájlban:It's the same as setting the following properties in the capabilities.json file:

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

A count értékét tetszőleges egész számra módosíthatja, amely akár 30000 is lehet.You can modify the count value to any integer value up to 30000. Az R-alapú Power BI-vizualizációk akár 150 000 sort is támogatnak.R-based Power BI visuals can support up to 150000 rows.

Az adatcsökkentési algoritmusok típusaiData reduction algorithm types

Az adatcsökkentési algoritmusok négyféle típusa állítható be:There are four types of data reduction algorithm settings:

  • top: Ha az adatokat az adathalmaz elejétől kapott értékekre kívánja korlátozni.top: If you want to limit the data to values taken from the top of the dataset. Az első count számú érték lesz felhasználva az adathalmazból.The top first count values will be taken from the dataset.
  • bottom: Ha az adatokat az adathalmaz végéről kapott értékekre kívánja korlátozni.bottom: If you want to limit the data to values taken from the bottom of the dataset. Az utolsó „count” számú érték lesz felhasználva az adathalmazból.The last "count" values will be taken from the dataset.
  • sample: Egy egyszerű mintavételezési algoritmussal csökkenti az adatok mennyiségét, amely count számú elemre korlátozódik.sample: Reduce the dataset by a simple sampling algorithm, limited to a count number of items. Ez azt jelenti, hogy az első és az utolsó elem is szerepel, és az összesen count számú elem között egyenlők a távolságok.It means that the first and last items are included, and a count number of items have equal intervals between them. Ha az adathalmaz például {0; 1; 2;... 100}, és a count értéke 9, a következő értékeket fogja kapni: {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: Egyszerre az adatpontok egy count számú elemet tartalmazó tartományát tölti be.window: Loads one window of data points at a time containing count elements. A top és a window jelenleg egyenértékű.Currently, top and window are equivalent. A tartomány beállítás teljes támogatásán még dolgozunk.We are working toward fully supporting a windowing setting.

Az adatcsökkentési algoritmus használataData reduction algorithm usage

Az adatcsökkentési algoritmus kategorikus, táblázatos vagy mátrix adatnézet-leképezésben használható.The data reduction algorithm can be used in categorical, table, or matrix data view mapping.

Kategorikus adatleképezéshez az algoritmust beállíthatja a categories-ra, és/vagy a values csoportszakaszaira.You can set the algorithm into categories and/or group section of values for categorical data mapping.

8. példaExample 8

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

Az adatcsökkentési algoritmust alkalmazhatja az adatnézet-leképezési táblázat rows szakaszára.You can apply the data reduction algorithm to the rows section of the Data View mapping table.

9. példaExample 9

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

Az adatcsökkentési algoritmust alkalmazhatja az adatnézet-leképezési mátrix rows és columns szakaszára.You can apply the data reduction algorithm to the rows and columns sections of the Data View mapping matrix.

Következő lépésekNext steps

Olvassa el, hogyan adhat lehatolási támogatást Power BI-vizualizációk adatnézeti leképezéseihez.Read how to add Drill-Down support for data view mappings in Power BI visuals.