Forstå datavisningstilordninger i Power BI-visualobjekter

Denne artikkelen beskriver datavisningstilordning og hvordan dataroller brukes til å opprette ulike typer visualobjekter. Den forklarer hvordan du spesifiserer betingede krav for dataroller, i tillegg til de ulike dataMappings typene.

Hver gyldige tilordning produserer en datavisning. Du kan angi flere datatilordninger under visse betingelser. De støttede tilordningsalternativene er:

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

Power BI oppretter en tilordning til en datavisning hvis, og bare hvis, den gyldige tilordningen også er definert i dataViewMappings .

categorical kan med andre ord være definert i dataViewMappings, men andre tilordninger, for eksempel table ellersingle, er kanskje ikke det. I så fall Power BI en datavisning med én tilordning, mens og andre tilordninger categorical table forblir udefinerte. Eksempel:

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

Betingelser

-delen conditions etablerer regler for en bestemt datatilordning. Hvis dataene samsvarer med et av de beskrevne settene med betingelser, godtar visualobjektet dataene som gyldige.

For hvert felt kan du for øyeblikket angi en minimums- og en maksimumsverdi. Verdien representerer antall felter som kan bindes til den datarollen.

Obs!

Hvis en datarolle er utelatt i betingelsen, kan den ha et ubegrenset antall felter.

I eksemplet nedenfor begrenser du grensen til category ett datafelt og measure til to datafelter.

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

Du kan også angi flere betingelser for en datarolle. I så fall er dataene gyldige hvis en av betingelsene er oppfylt.

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

I eksemplet ovenfor er én av følgende to betingelser nødvendig:

  • Nøyaktig ett kategorifelt og nøyaktig to mål
  • Nøyaktig to kategorier og nøyaktig ett mål.

Enkel datatilordning

Enkel datatilordning er den enkleste formen for datatilordning. Den godtar ett enkelt målfelt og returnerer summen. Hvis feltet er numerisk, returneres summen. Ellers returneres antallet unike verdier.

Hvis du vil bruke enkel datatilordning, kan du definere navnet på datarollen du vil tilordne. Denne tilordningen fungerer bare med ett enkelt målfelt. Hvis et andre felt er tilordnet, genereres ingen datavisning, så det er god praksis å inkludere en betingelse som begrenser dataene til ett enkelt felt.

Obs!

Denne datatilordningen kan ikke brukes sammen med andre datatilordninger. Den er ment å redusere data til én numerisk verdi.

Eksempel:

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

Den resulterende datavisningen kan fortsatt inneholde andre typer (tabell, kategoriske og så videre), men hver tilordning inneholder bare enkeltverdien. Anbefalt fremgangsmåte er å få tilgang til verdien bare i enkeltform.

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

Kodeeksempel for å behandle en enkel datavisningstilordning

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

Koden ovenfor resulterer i visning av én enkelt verdi fra Power BI:

Eksempel på én enkel datavisningstilordning

Kategorisk datatilordning

Kategorisk datatilordning brukes til å få uavhengige grupperinger eller kategorier med data. Kategoriene kan også grupperes ytterligere sammen ved hjelp av grupper etter i datatilordningen.

Grunnleggende kategorisk datatilordning

Vurder følgende dataroller og -tilordninger:

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

Eksemplet ovenfor sier «Tilordne min -datarolle slik at for hvert felt jeg drar inn category i , tilordnes feltets category data til categorical.categories . Tilordne også min measure -datarolle categorical.values til .»

  • for ... i: Inkluder alle elementene i denne datarollen i dataspørringen.
  • bind ... til: Gir samme resultat som i for ... i, men forventer at -datarollen har en betingelse som begrenser den til ett enkelt felt.

Gruppere kategoriske data

Det neste eksemplet bruker de samme to datarollene som det forrige eksemplet, og legger til flere dataroller med navnet grouping og measure2 .

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

Forskjellen mellom denne tilordningen og den grunnleggende, er hvordan vi tilordner categorical.values . Ved å tilordne measure measure2 datarollene og til datarollen , kan vi riktig skalere grouping x-aksen og y-aksen.

Gruppere hierarkiske data

I det neste eksemplet bruker vi de kategoriske dataene til å opprette et hierarki, som kan brukes til å støtte neddrillingshandlinger.

Her er datarollene og -tilordningene:

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

Vurder følgende kategoriske data:

Land 2013 2014 2015 2016
USA x x 650 350
Canada x 630 490 x
Mexico 645 x x x
UK x x 831 x

Power BI gir en kategorisk datavisning med følgende sett med kategorier.

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

Hver category kart til et sett med values også. Hver av disse values er gruppert etter series , som blir uttrykt som år.

Hver -matrise representerer values for eksempel ett år. Hver values -matrise har fire verdier: Canada, USA, Storbritannia og Mexico:

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

Nedenfor finner du et kodeeksemle for behandling av kategorisk datavisningstilordning. Dette eksemplet oppretter den hierarkiske strukturen 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
        // 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
        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);
    }
}

Her er det resulterende visualobjektet:

Visualobjektet med kategorisk datavisningstilordning

Tilordningstabeller

Tabelldatavisningen er i bunn og grunn en liste over datapunkter der numeriske datapunkter kan aggregeres.

Du kan for eksempel bruke de samme dataene som i forrige del, men med følgende funksjoner:

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

Du kan visualisere tabelldatavisningen slik:

Dataeksempel:

Land År Sales
USA 2016 100
USA 2015 50
Canada 2015 200
Canada 2015 50
Mexico 2013 300
UK 2014 150
USA 2015 75

Databinding:

Databindinger for tilordning av tabelldatavisning

Power BI viser dataene som tabelldatavisningen. Ikke anta at dataene er bestilt.

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

Hvis du vil aggregere dataene, velger du ønsket felt og velger Summer.

Data aggregasjon.

Kodeeksempel for å behandle tilordning av tabelldatavisning.

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

Filen for visuelle stiler style/visual.less inneholder oppsett for tabellen:

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

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

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

Den resulterende visuelle effekten ser slik ut:

Den visuelle effekten med tilordning av tabell data visning.

Tilordning av matrisedata

Data tilordning for matrise ligner på tabell data tilordning, men radene vises hierarkisk. Og hvilken som helst av datarolleverdiene kan brukes som en verdi for kolonneoverskrift.

{
    "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 oppretter en hierarkisk datastruktur. Roten til trehierarkiet inkluderer dataene fra Overordnede-kolonnen i Category-datarollen, med underordnede fra kolonnen Underordnede i datarolletabellen.

Datasett:

Overordnede Underordnede Underordnede på andre nivå Kolonner Verdier
Overordnet1 Underordnet1 Under-underordnet1 Kol1 5
Overordnet1 Underordnet1 Under-underordnet1 Kol2 6
Overordnet1 Underordnet1 Under-underordnet2 Kol1 7
Overordnet1 Underordnet1 Under-underordnet2 Kol2 8
Overordnet1 Underordnet2 Under-underordnet3 Kol1 5
Overordnet1 Underordnet2 Under-underordnet3 Kol2 3
Overordnet1 Underordnet2 Under-underordnet4 Kol1 4
Overordnet1 Underordnet2 Under-underordnet4 Kol2 09:
Overordnet1 Underordnet2 Under-underordnet5 Kol1 3
Overordnet1 Underordnet2 Under-underordnet5 Kol2 5
Overordnet2 Underordnet3 Under-underordnet6 Kol1 1
Overordnet2 Underordnet3 Under-underordnet6 Kol2 2
Overordnet2 Underordnet3 Under-underordnet7 Kol1 7
Overordnet2 Underordnet3 Under-underordnet7 Kol2 1
Overordnet2 Underordnet3 Under-underordnet8 Kol1 10
Overordnet2 Underordnet3 Under-underordnet8 Kol2 13

Kjernematrise-visualobjektet i Power BI gjengir dataene som en tabell.

Visuell matriseskjerm.

Visualobjektet får datastrukturen som beskrevet i følgende kode (bare de første to tabellradene vises her):

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

Algoritme for datareduksjon

Algoritmen for datareduksjon kontrollerer hvilke data og hvor mye data som mottas i data visningen.

Antallet er satt til maksimalt antall verdier som data visningen kan godta. Hvis det er mer enn Count -verdier, bestemmer algoritmen for data reduksjon hvilke verdier som skal mottas.

Typer algoritmer for datareduksjon

Det finnes innstillinger for fire typer algoritme for datareduksjon:

  • top: De første telle verdiene vil bli Hentet fra data settet.
  • bottom: De siste Count -verdiene hentes fra data settet.
  • sample: Det første og siste elementet er inkludert, og Tell antall elementer med like intervaller mellom dem. Hvis du for eksempel har et data sett [0, 1, 2,... 100] og et antall 9, vil du motta verdiene [0, 10, 20... 100].
  • window: Laster inn ett vindu med datapunkter om gangen, som inneholder antall elementer. For øyeblikket er top og window tilsvarende hverandre. Vi jobber mot full støtte for en innstilling for vindu.

Som standard har alle Power BI-visualobjekter den øverste datareduksjonsalgoritmen anvendt, med antall satt til 1000 datapunkter. Dette er det samme som å angi følgende egenskaper i capabilities.jsi filen:

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

Du kan endre antall-verdien til en hvilken som helst heltallsverdi opptil 30000. R-baserte Power BI-visualobjekter kan støtte opptil 150000 rader.

Bruk av algoritmer for datareduksjon

Algoritmen for datareduksjon kan brukes i tilordningen av datavisninger som er kategoriske, tabeller eller matriser.

I kategoriske data tilordning kan du legge til algoritmen i «kategorier»-og/eller»-delen av values for kategoriske data tilordning.

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

Bruk algoritmen for data reduksjon til rows delen i tilordnings tabellen for data visning, i tabell data visnings tilordning.

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

Du kan bruke algoritmen for datareduksjon på delene rows og columns i matrisen for datavisningstilordning.

Neste trinn