Vysvetlenie priradenia zobrazenia údajov vo vizuáloch služby Power BI

Tento článok popisuje priradenie zobrazenia údajov a popisuje, ako sa roly údajov používajú na vytváranie rôznych typov vizuálov. Vysvetľuje, ako určiť podmienené požiadavky pre roly údajov a rôzne dataMappings typy.

Každé platné priradenie vytvorí zobrazenie údajov. Za určitých podmienok môžete zadať viacero priradení údajov. Podporované možnosti mapovania sú:

• Podmienky
• kategorický
• slobodný
• stôl
• matica

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

Power BI vytvorí priradenie zobrazenia údajov iba v prípade, že platné priradenie je definované aj v .dataViewMappings

Inými slovami, categorical priradenie (priradenia) môže byť definované v dataViewMappings priradeniach (priradeniach typu alebo ), ale iné priradenia, ako table napríklad (alebo single), nemusia byť. V takom prípade služba Power BI vytvorí zobrazenie údajov s jedným categorical priradením, zatiaľ čo table iné priradenia zostanú nedefinované. Napríklad:

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

Podmienky

Sekcia conditions vytvára pravidlá pre konkrétne priradenie údajov. Ak sa údaje zhodujú s niektorou z popísaných množín podmienok, vizuál akceptuje údaje ako platné.

Pre každé pole môžete zadať minimálnu a maximálnu hodnotu. Hodnota predstavuje počet polí, ktoré môžu byť naviazané na danú rolu údajov.

V nasledujúcom príklade category je obmedzenie na jedno údajové pole a measure pole je obmedzené na dve údajové polia.

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

Pre rolu údajov môžete nastaviť aj viaceré podmienky. V takom prípade budú údaje platné, ak je splnená niektorá z podmienok.

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

V predchádzajúcom príklade sa vyžaduje jedna z nasledujúcich dvoch podmienok:

• Presne jedno pole kategórie a presne dve mierky
• Presne dve kategórie a presne jedna mierka

Priradenie jednotlivých údajov

Priradenie jednotlivých údajov je najjednoduchšou formou priradenia údajov. Akceptuje jedno pole mierky a vráti celkový súčet. Ak je pole číselné, vráti súčet. V opačnom prípade vráti počet jedinečných hodnôt.

Ak chcete použiť priradenie jednotlivých údajov, definujte názov roly údajov, ktorú chcete priradiť. Toto priradenie funguje len s jedným poľom mierky. Ak je druhé pole priradené, negeneruje sa žiadne zobrazenie údajov, takže je vhodné zahrnúť podmienku, ktorá obmedzí údaje na jedno pole.

Napríklad:

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

Výsledné zobrazenie údajov môže stále obsahovať iné typy priradení, ako napríklad tabuľka alebo kategorické, ale každé priradenie obsahuje iba jednu hodnotu. Odporúča sa preto mať prístup k hodnote iba v jednom priradení.

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

Nasledujúca ukážka kódu spracúva jednoduché priradenie zobrazení údajov:

"use strict";
import powerbi from "powerbi-visuals-api";
import DataView = powerbi.DataView;
import DataViewSingle = powerbi.DataViewSingle;
// standard imports
// ...

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

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

    public update(options: VisualUpdateOptions) {
        const dataView: DataView = options.dataViews[0];
        const singleDataView: DataViewSingle = dataView.single;

        if (!singleDataView ||
            !singleDataView.value ) {
            return
        }

        this.valueText.innerText = singleDataView.value.toString();
    }
}

Výsledkom predchádzajúcej ukážky kódu je zobrazenie jednej hodnoty zo služby Power BI:

Priradenie kategorických údajov

Priradenie kategorických údajov sa používa na získavanie nezávislých zoskupení alebo kategórií údajov. Kategórie je tiež možné zoskupiť pomocou "zoskupiť podľa" v priradení údajov.

Základné priradenie kategorických údajov

Zvážte nasledujúce roly údajov a priradenia:

"dataRoles":[
    {
        "displayName": "Category",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Y Axis",
        "name": "measure",
        "kind": "Measure"
    }
],
"dataViewMappings": {
    "categorical": {
        "categories": {
            "for": { "in": "category" }
        },
        "values": {
            "select": [
                { "bind": { "to": "measure" } }
            ]
        }
    }
}

Predchádzajúci príklad znie "Priraď moju category rolu údajov tak, aby sa pre každé pole, do categoryktoré presuniem , priradili jeho údaje do categorical.categories. Priraďte tiež moju measure rolu údajov do categorical.values."

• za... in: Zahŕňa všetky položky v tejto role údajov do dotazu na údaje.
• viazať... do: Dáva rovnaký výsledok ako pre... in , ale očakáva, že rola údajov má podmienku obmedzujúcu ju na jedno pole.

Zoskupenie kategorických údajov

Nasledujúci príklad používa rovnaké dve roly údajov ako predchádzajúci príklad a pridá ďalšie dve roly údajov s názvami grouping a measure2.

"dataRoles":[
    {
        "displayName": "Category",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Y Axis",
        "name": "measure",
        "kind": "Measure"
    },
    {
        "displayName": "Grouping with",
        "name": "grouping",
        "kind": "Grouping"
    },
    {
        "displayName": "X Axis",
        "name": "measure2",
        "kind": "Grouping"
    }
],
"dataViewMappings": [
    {
        "categorical": {
            "categories": {
                "for": {
                    "in": "category"
                }
            },
            "values": {
                "group": {
                    "by": "grouping",
                    "select": [{
                            "bind": {
                                "to": "measure"
                            }
                        },
                        {
                            "bind": {
                                "to": "measure2"
                            }
                        }
                    ]
                }
            }
        }
    }
]

Rozdiel medzi týmto mapovaním a základným mapovaním je spôsob categorical.values mapovania. Keď rolám measure údajov priraďujete rolu údajov a measure2 k role groupingúdajov, os x a os y možno vhodne škálovať.

Zoskupenie hierarchických údajov

V nasledujúcom príklade sa kategorické údaje používajú na vytvorenie hierarchie, ktorú možno použiť na podporu akcií prechodu na detaily .

Nasledujúci príklad znázorňuje roly údajov a priradenia:

"dataRoles": [
    {
        "displayName": "Categories",
        "name": "category",
        "kind": "Grouping"
    },
    {
        "displayName": "Measures",
        "name": "measure",
        "kind": "Measure"
    },
    {
        "displayName": "Series",
        "name": "series",
        "kind": "Measure"
    }
],
"dataViewMappings": [
    {
        "categorical": {
            "categories": {
                "for": {
                    "in": "category"
                }
            },
            "values": {
                "group": {
                    "by": "series",
                    "select": [{
                            "for": {
                                "in": "measure"
                            }
                        }
                    ]
                }
            }
        }
    }
]

Zvážte nasledujúce kategorické údaje:

Power BI vytvorí zobrazenie kategorických údajov s nasledujúcou množinou kategórií.

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

Každá category množina máp sa mapuje k množine .values Každý z nich values je zoskupený podľa series, čo vyjadruje roky.

Každé pole napríklad values predstavuje jeden rok. Každé values pole má tiež štyri hodnoty: Kanada, USA, Spojené kráľovstvo a Mexiko.

{
    "values": [
        // Values for year 2013
        {
            "source": {...},
            "values": [
                null, // Value for `Canada` category
                null, // Value for `USA` category
                null, // Value for `UK` category
                645 // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2014
        {
            "source": {...},
            "values": [
                630, // Value for `Canada` category
                null, // Value for `USA` category
                null, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2015
        {
            "source": {...},
            "values": [
                490, // Value for `Canada` category
                650, // Value for `USA` category
                831, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        },
        // Values for year 2016
        {
            "source": {...},
            "values": [
                null, // Value for `Canada` category
                350, // Value for `USA` category
                null, // Value for `UK` category
                null // Value for `Mexico` category
            ],
            "identity": [...],
        }
    ]
}

Nasledujúca ukážka kódu je na spracovanie priradenia zobrazenia kategorických údajov. Táto ukážka vytvorí hierarchickú štruktúru Hodnota roka > pre krajinu alebo oblasť>.

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

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

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

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

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

        // Categories have only one column in data buckets
        // To support several columns of categories data bucket, iterate categoricalDataView.categories array.
        const categoryFieldIndex = 0;
        // Measure has only one column in data buckets.
        // To support several columns on data bucket, iterate years.values array in map function
        const measureFieldIndex = 0;
        let categories: PrimitiveValue[] = categoricalDataView.categories[categoryFieldIndex].values;
        let values: DataViewValueColumnGroup[] = categoricalDataView.values.grouped();

        let data = {};
        // iterate categories/countries-regions
        categories.map((category: PrimitiveValue, categoryIndex: number) => {
            data[category.toString()] = {};
            // iterate series/years
            values.map((years: DataViewValueColumnGroup) => {
                if (!data[category.toString()][years.name] && years.values[measureFieldIndex].values[categoryIndex]) {
                    data[category.toString()][years.name] = []
                }
                if (years.values[0].values[categoryIndex]) {
                    data[category.toString()][years.name].push(years.values[measureFieldIndex].values[categoryIndex]);
                }
            });
        });

        this.categories.innerText = JSON.stringify(data, null, 6);
        console.log(data);
    }
}

Výsledný vizuál je tu:

Mapovanie tabuliek

Zobrazenie tabuľkových údajov je v podstate zoznam údajových bodov, kde sa dajú agregovať číselné údajové body.

Použite napríklad rovnaké údaje v predchádzajúcej časti, ale s nasledujúcimi možnosťami:

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

Vizualizujte zobrazenie údajov tabuľky, ako je tento príklad:

Údajová väzba:

Power BI zobrazí vaše údaje v zobrazení tabuľkových údajov. Nepredpokladajte, že sú údaje zoradené.

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

Ak chcete údaje agregovať, vyberte požadované pole a potom vyberte položku Súčet.

Ukážka kódu na spracovanie priradenia zobrazenia tabuľkového údajov.

"use strict";
import "./../style/visual.less";
import powerbi from "powerbi-visuals-api";
// ...
import DataViewMetadataColumn = powerbi.DataViewMetadataColumn;
import DataViewTable = powerbi.DataViewTable;
import DataViewTableRow = powerbi.DataViewTableRow;
import PrimitiveValue = powerbi.PrimitiveValue;
// standard imports
// ...

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

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

    public update(options: VisualUpdateOptions) {
        const dataView: DataView = options.dataViews[0];
        const tableDataView: DataViewTable = dataView.table;

        if (!tableDataView) {
            return
        }
        while(this.table.firstChild) {
            this.table.removeChild(this.table.firstChild);
        }

        //draw header
        const tableHeader = document.createElement("th");
        tableDataView.columns.forEach((column: DataViewMetadataColumn) => {
            const tableHeaderColumn = document.createElement("td");
            tableHeaderColumn.innerText = column.displayName
            tableHeader.appendChild(tableHeaderColumn);
        });
        this.table.appendChild(tableHeader);

        //draw rows
        tableDataView.rows.forEach((row: DataViewTableRow) => {
            const tableRow = document.createElement("tr");
            row.forEach((columnValue: PrimitiveValue) => {
                const cell = document.createElement("td");
                cell.innerText = columnValue.toString();
                tableRow.appendChild(cell);
            })
            this.table.appendChild(tableRow);
        });
    }
}

Súbor style/visual.less štýlov vizuálu obsahuje rozloženie pre tabuľku:

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

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

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

Výsledný vizuál vyzerá takto:

Priradenie maticovej údajov

Priradenie maticových údajov je podobné priradeniu tabuľkových údajov, ale riadky sa prezentujú hierarchicky. Akákoľvek z hodnôt roly údajov sa dá použiť ako hodnota hlavičky stĺpca.

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

Hierarchická štruktúra maticových údajov

Power BI vytvorí hierarchickú štruktúru údajov. Koreň stromovej hierarchie zahŕňa údaje zo stĺpca Category Rodičia roly údajov s deťmi zo stĺpca Deti tabuľky roly údajov.

Sémantický model:

Vizuál základnej matice služby Power BI vykreslí údaje ako tabuľku.

Vizuál získa svoju štruktúru údajov tak, ako je popísané v nasledujúcom kóde (sú tu zobrazené len prvé dva riadky tabuľky):

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

Rozbalenie a zbalenie hlavičiek riadkov

V prípade rozhrania API 4.1.0 alebo novšej podporujú maticové údaje rozbalenie a zbalenie hlavičiek riadkov. Od rozhrania API 4.2 môžete pomocou programovania rozbaliť alebo zbaliť celú úroveň. Funkcia rozbalenia a zbalenia optimalizuje načítavanie údajov do zobrazenia údajov DataView tým, že používateľovi umožňuje rozbaliť alebo zbaliť riadok bez toho, aby načítal všetky údaje na ďalšiu úroveň. Načítanie údajov iba pre vybratý riadok. Stav rozbalení hlavičky riadka zostáva konzistentný v rámci záložiek a dokonca aj v rámci uložených zostáv. Nie je špecifický pre každý vizuál.

Príkazy na rozbalenie a zbalenie dataRoles možno pridať do kontextovej ponuky zadaním parametra showContextMenu do metódy .

Ak chcete rozbaliť veľký počet údajových bodov, použite rozhranie API načítania väčšieho množstva údajov s rozbalením alebo zbalením rozhrania API.

Funkcie rozhrania API

Do rozhrania API verzie 4.1.0 boli pridané nasledujúce prvky, ktoré umožňujú rozbalenie a zbalenie hlavičiek riadkov:

• Príznak isCollapsed v :DataViewTreeNode

  interface DataViewTreeNode {
      //...
      /**
      * TRUE if the node is Collapsed
      * FALSE if it is Expanded
      * Undefined if it cannot be Expanded (e.g. subtotal)
      */
      isCollapsed?: boolean;
  }
  

• Metóda toggleExpandCollapse v ISelectionManger rozhraní:

  interface ISelectionManager {
      //...
      showContextMenu(selectionId: ISelectionId, position: IPoint, dataRoles?: string): IPromise<{}>; // dataRoles is the name of the role of the selected data point
      toggleExpandCollapse(selectionId: ISelectionId, entireLevel?: boolean): IPromise<{}>;  // Expand/Collapse an entire level will be available from API 4.2.0 
      //...
  }
  

• Príznak canBeExpanded v dataViewHierarchyLevel:

  interface DataViewHierarchyLevel {
      //...
      /** If TRUE, this level can be expanded/collapsed */
      canBeExpanded?: boolean;
  }
  

Požiadavky vizuálu

Ak chcete povoliť funkciu rozbalenia zbalenia vo vizuáli pomocou zobrazenia matice údajov:

1. Do súboru capabilities.json pridajte nasledujúci kód:

      "expandCollapse": {
       "roles": ["Rows"], //”Rows” is the name of rows data role
       "addDataViewFlags": {
           "defaultValue": true //indicates if the DataViewTreeNode will get the isCollapsed flag by default 
       }
   },
   

2. Potvrďte, že roly môžu prejsť na detaily:

       "drilldown": {
       "roles": ["Rows"]
   },
   

3. Pre každý uzol vytvorte inštanciu zostavovača výberu zavolaním withMatrixNode metódy na vybratej úrovni hierarchie uzla a vytvorením selectionIdmetódy . Napríklad:

       let nodeSelectionBuilder: ISelectionIdBuilder = visualHost.createSelectionIdBuilder();
       // parantNodes is a list of the parents of the selected node.
       // node is the current node which the selectionId is created for. 
       parentNodes.push(node);
       for (let i = 0; i < parentNodes.length; i++) {
           nodeSelectionBuilder = nodeSelectionBuilder.withMatrixNode(parentNodes[i], levels);
       }
     const nodeSelectionId: ISelectionId = nodeSelectionBuilder.createSelectionId(); 
   

4. Vytvorte inštanciu funkcie Selection Manager a použite metódu selectionManager.toggleExpandCollapse() s parametrom selectionId, ktorú ste vytvorili pre vybratý uzol. Napríklad:

       // handle click events to apply expand\collapse action for the selected node
       button.addEventListener("click", () => {
       this.selectionManager.toggleExpandCollapse(nodeSelectionId);
   });
   

Dôležité informácie a obmedzenia

• Po rozbalení uzla sa na DataView použijú nové limity údajov. Nové zobrazenie údajov nemusí obsahovať niektoré uzly prezentované v predchádzajúcom zobrazení údajov.
• Pri použití funkcie rozbaliť alebo zbaliť sa súčty pridajú dokonca aj vtedy, ak o ne vizuál nežiadal.
• Rozbalenie a zbalenie stĺpcov nie je podporované.

Ponechať všetky stĺpce metaúdajov

Pre rozhranie API 5.1.0 alebo novšiu verziu je podporované ponechať všetky stĺpce metaúdajov. Táto funkcia umožňuje vizuálu získať metaúdaje pre všetky stĺpce bez ohľadu na to, aké sú ich aktívne projekcie.

Do súboru capabilities.json pridajte nasledujúce riadky:

"keepAllMetadataColumns": {
    "type": "boolean",
    "description": "Indicates that visual is going to receive all metadata columns, no matter what the active projections are"
}

Ak nastavíte túto vlastnosť, true výsledkom bude prijímanie všetkých metaúdajov vrátane zo zbalených stĺpcov. Ak ju nastavíte alebo false ponecháte ako nedefinovanú, bude mať za následok prijímanie metaúdajov iba v stĺpcoch s aktívnymi projekciami (napríklad rozbalené).

Algoritmus znižovania údajov

Algoritmus znižovania údajov určuje, ktoré údaje a koľko údajov sa prijíma v zobrazení údajov.

Počet je nastavený na maximálny počet hodnôt, ktoré môže zobrazenie údajov akceptovať. Ak existuje viac hodnôt ako počet , algoritmus znižovania údajov určuje, ktoré hodnoty sa majú prijímať.

Typy algoritmov znižovania údajov

Existujú štyri typy nastavení algoritmu znižovania údajov:

• top: Prvé hodnoty počtu sa prevezmú zo sémantického modelu.
• bottom: Hodnoty posledného počtu sa prevezmú zo sémantického modelu.
• sample: Zahrnuté sú prvé a posledné položky a počet položiek s rovnakými intervalmi medzi nimi. Ak máte napríklad sémantický model [0, 1, 2, ... 100] a počet položiek "count " 9, dostanete hodnoty [0, 10, 20 ... 100].
• window: Načíta naraz jedno okno údajových bodov obsahujúce počet prvkov "count ". top A window sú v súčasnosti rovnocenné. V budúcnosti bude plne podporované nastavenie pomocou okien.

V predvolenom nastavení majú všetky vizuály služby Power BI najvyšší algoritmus znižovania údajov s nastaveným počtom ("count ") na 1 000 údajových bodov. Toto predvolené nastavenie je ekvivalentné s nastavením nasledujúcich vlastností v súbore capabilities.json :

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

Hodnotu "count" môžete upraviť na ľubovoľnú celočíselnú hodnotu až do 30 000. Vizuály služby Power BI založené na R môžu podporovať až 150 000 riadkov.

Použitie algoritmov znižovania údajov

Algoritmus znižovania údajov sa dá použiť v kategorickom, tabuľkovom alebo maticovom priradení zobrazenia údajov.

V priradení kategorických údajov môžete pridať algoritmus do sekcie "kategórie" a/alebo "skupina" pre values priradenie kategorických údajov.

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

V priradení zobrazenia tabuľkových údajov použite algoritmus znižovania údajov v sekcii rows tabuľky priradenia zobrazenia údajov.

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

Algoritmus znižovania údajov sa dá použiť v rows sekciách a columns v matici priradenia zobrazenia údajov.

Súvisiaci obsah

• Pridanie podpory pre prechod na detaily
• Vytváranie vlastných vizuálov Power BI bez údajovej väzby