Jaa

Power BI -visualisointien tietonäkymän yhdistämismääritykset

  • Artikkeli

Tässä artikkelissa käsitellään tietonäkymän yhdistämismäärityksiä ja kuvataan, miten tietorooleja käytetään erityyppisten visualisointien luomiseen. Artikkelissa kerrotaan, miten tietorooleille ja eri dataMappings tyypeille määritetään ehdollisia vaatimuksia.

Jokainen kelvollinen yhdistäminen tuottaa tietonäkymän. Voit antaa useita tietojen yhdistämismäärityksiä tietyillä ehdoilla. Tuetut yhdistämismäärityksen asetukset ovat seuraavat:

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

Power BI luo tietonäkymän yhdistämismäärityksen vain, jos kelvollinen yhdistämismääritys on myös määritetty kohteessa dataViewMappings.

Toisin sanoen voidaan määrittää -yhdistämismäärityksessä, categorical mutta muissa määrityksissä dataViewMappings , kuten table tai single, ei ehkä voida. Tässä tapauksessa Power BI tuottaa tietonäkymän, jossa on yksi categorical yhdistämismääritys, kun taas table muut yhdistämismääritykset ovat määrittämättömiä. Esimerkkejä:

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

Ehdot

- conditions osa luo sääntöjä tiettyä tietojen yhdistämistä varten. Jos tiedot vastaavat jotakin kuvatuista ehtojoukoista, visualisointi hyväksyy tiedot kelvollisiksi.

Voit määrittää kullekin kentälle vähimmäis- ja enimmäisarvon. Arvo edustaa niiden kenttien määrää, jotka voidaan sitoa kyseiseen tietorooliin.

Muistiinpano

Jos tietorooli jätetään pois ehdosta, sillä voi olla mikä tahansa määrä kenttiä.

Seuraavassa esimerkissä on category rajoitettu yhteen tietokenttään ja on rajoitettu kahteen tietokenttään measure .

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

Voit myös määrittää useita ehtoja tietoroolille. Tässä tapauksessa tiedot ovat kelvollisia, jos jokin ehdoista täyttyy.

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

Edellisessä esimerkissä vaaditaan toinen seuraavista kahdesta ehdosta:

  • Täsmälleen yksi luokkakenttä ja täsmälleen kaksi mittaria
  • Täsmälleen kaksi luokkaa ja täsmälleen yksi mittari

Yksittäistietietojen yhdistäminen

Yksittäistietojen yhdistäminen on yksinkertaisin tietojen yhdistämisen muoto. Se hyväksyy yksittäisen mittarikentän ja palauttaa kokonaismäärän. Jos kenttä on numeerinen, se palauttaa summan. Muussa tapauksessa se palauttaa yksilöllisten arvojen määrän.

Jos haluat käyttää yksittäistietojen yhdistämistä, määritä sen tietoroolin nimi, jonka haluat yhdistää. Tämä yhdistäminen toimii vain yksittäisen mittarikentän kanssa. Jos toinen kenttä on määritetty, tietonäkymää ei muodostetaan. Siksi on hyvä käytäntö sisällyttää ehto, joka rajoittaa tiedot yhteen kenttään.

Muistiinpano

Tätä tietojen yhdistämistä ei voi käyttää yhdessä minkään muun tietojen yhdistämisen kanssa. Se on tarkoitettu pienentämään tiedot yksittäiseksi numeeriseksi arvoksi.

Esimerkkejä:

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

Tuloksena saatava tietonäkymä voi silti sisältää muita yhdistämismäärityksiä, kuten taulukon tai luokittaisen, mutta jokainen yhdistämismääritys sisältää vain yksittäisen arvon. Paras käytäntö on käyttää arvoa vain yksittäisessä yhdistämismäärityksessä.

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

Seuraava koodiesimerkki käsittelee yksinkertaiset tietonäkymien yhdistämismääritykset:

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

Edellinen koodiesimerkki antaa tulokseksi yksittäisen arvon näyttämisen Power BI:stä:

Näyttökuva yksittäisestä tietonäkymän yhdistämismäärityksen visualisoinnista.

Luokittainen tietojen yhdistäminen

Luokittaista tietojen yhdistämistä käytetään riippumattomien ryhmittelyjen tai tietoluokkien hankkimiseen. Luokat voidaan myös ryhmitellä yhteen tietojen yhdistämisessä ryhmittelyperuste-toiminnolla.

Luokittaisten tietojen perusmääritys

Ota huomioon seuraavat tietoroolit ja yhdistämismääritykset:

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

Edellisessä esimerkissä lukee "Map my category data role so that for every field I drag into category, its data is mapped to categorical.categories. Yhdistä myös tietoroolini measure kohteeseen categorical.values" .

  • varten... in: Sisällyttää kaikki tämän tietoroolin kohteet tietokyselyssä.
  • sitoa... to: Tuottaa saman tuloksen kuin kohteelle... -sovelluksessa mutta odottaa, että tietoroolilla on ehto, joka rajoittaa sen yksittäiseen kenttään.

Luokittaisten tietojen ryhmittely

Seuraavassa esimerkissä käytetään samaa kahta tietoroolia kuin edellisessä esimerkissä, ja lisätään kaksi muuta tietoroolia nimeltään grouping ja 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"
                            }
                        }
                    ]
                }
            }
        }
    }
]

Tämän yhdistämismäärityksen ja perusmääritysten välinen ero on se, miten categorical.values se yhdistetään. Kun yhdistät - measure ja measure2 -tietoroolit tietorooliin grouping, x-akseli ja y-akseli voidaan skaalata asianmukaisesti.

Hierarkkisten tietojen ryhmittely

Seuraavassa esimerkissä luokittaisiin tietoihin luodaan hierarkia, jonka avulla voidaan tukea alaspäin porautumistoimintoja .

Seuraavassa esimerkissä näytetään tietoroolit ja yhdistämismääritykset:

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

Ota huomioon seuraavat luokittaiset tiedot:

Maa tai alue 2013 2014 2015 2016
USA x x 650 350
Kanada x 630 490 x
Meksiko 645 x x x
Yhdistynyt kuningaskunta x x 831 x

Power BI tuottaa luokittaisen tietonäkymän, joka sisältää seuraavat luokat.

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

Jokainen category yhdistää kohteeseen values. values Ne kaikki ryhmiteltään ryhmittelyperusteena series, joka ilmaistaan vuosina.

Esimerkiksi jokainen values -matriisi edustaa yhtä vuotta. Lisäksi jokaisessa values matriisissa on neljä arvoa: Kanada, USA, Iso-Britannia ja Meksiko.

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

Seuraava koodiesimerkki on tarkoitettu luokittaisen tietonäkymän yhdistämismäärityksen käsittelyyn. Tämä malli luo hierarkkisen rakenteen Maan/alueen > vuosiarvo>.

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

Tässä on tuloksena oleva visualisointi:

Näyttökuva visualisoinnista, jossa on luokittainen tietonäkymän yhdistämismääritys.

Taulukoiden yhdistäminen

Taulukon tietonäkymä on pohjimmiltaan luettelo arvopisteistä, joista voidaan koostaa numeerisia arvopisteitä.

Käytä esimerkiksi samoja tietoja edellisessä osiossa, mutta käyttämällä seuraavia ominaisuuksia:

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

Visualisoi taulukon tietonäkymä tämän esimerkin mukaisesti:

Maa tai alue Vuosi Myynti
USA 2016 100
USA 2015 50
Kanada 2015 200
Kanada 2015 50
Meksiko 2013 300
Yhdistynyt kuningaskunta 2014 150
USA 2015 75

Tietojen sidonta:

Näyttökuva taulukon tietonäkymän yhdistämismäärityksen tietojen sidonnasta.

Power BI näyttää tietosi taulukkotietonäkymänä. Älä oleta, että tiedot on järjestetty.

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

Jos haluat koostaa tiedot, valitse haluamasi kenttä ja valitse sitten Summa.

Näyttökuva summasta valittuna kentän avattavasta valikosta.

Koodiesimerkki taulukon tietonäkymän yhdistämismäärityksen käsittelyä varten.

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

Visualisointitiedosto style/visual.less sisältää taulukon asettelun:

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

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

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

Tuloksena saatu visualisointi näyttää tältä:

Näyttökuva visualisoinnista, jossa on taulukkotietonäkymän yhdistämismääritys.

Matriisitietojen yhdistäminen

Matriisitietojen yhdistäminen on samantapaista kuin taulukkotietojen yhdistäminen, mutta rivit esitetään hierarkkisesti. Mitä tahansa tietorooliarvoista voidaan käyttää sarakeotsikon arvona.

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

Matriisitietojen hierarkkinen rakenne

Power BI luo hierarkkisen tietorakenteen. Puun pääkansio sisältää Päätaso-sarakkeen tiedot -tietoroolista Category ja alatasot tietoroolitaulukon Alataso-sarakkeesta.

Semanttinen malli:

Vanhemmat Children Lastenlasta Sarakkeet Arvot
Parent1 Alikohde1 Lapsenlapsi1 Sarake1 5
Parent1 Alikohde1 Lapsenlapsi1 Sarake2 6
Parent1 Alikohde1 Lapsenlapsi2 Sarake1 7
Parent1 Alikohde1 Lapsenlapsi2 Sarake2 8
Parent1 Alikohde2 Lapsenlapsi3 Sarake1 5
Parent1 Alikohde2 Lapsenlapsi3 Sarake2 3
Parent1 Alikohde2 Lapsenlapsi4 Sarake1 4
Parent1 Alikohde2 Lapsenlapsi4 Sarake2 9
Parent1 Alikohde2 Lapsenlapsi5 Sarake1 3
Parent1 Alikohde2 Lapsenlapsi5 Sarake2 5
Parent2 Alikohde3 Lapsenlapsi6 Sarake1 1
Parent2 Alikohde3 Lapsenlapsi6 Sarake2 2
Parent2 Alikohde3 Lapsenlapsi7 Sarake1 7
Parent2 Alikohde3 Lapsenlapsi7 Sarake2 1
Parent2 Alikohde3 Lapsenlapsi8 Sarake1 10
Parent2 Alikohde3 Lapsenlapsi8 Sarake2 13

Power BI:n ydinmatriisivisualisointi hahmontaa tiedot taulukkona.

Näyttökuva taulukkona hahmontamisesta matriisivisualisoinnista.

Visualisointi saa tietorakenteensa seuraavassa koodissa kuvatulla tavalla (vain kaksi ensimmäistä taulukon riviä näkyvät tässä):

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

Laajenna ja kutista riviotsikot

Ohjelmointirajapinnan versiossa 4.1.0 tai uudemmassa matriisitiedot tukevat riviotsikoiden laajentamista ja kutistamista. Ohjelmointirajapinnasta 4.2 voit laajentaa/kutistaa koko tason ohjelmallisesti. Laajennus- ja kutistamisominaisuus optimoi tietojen noutumisen dataView'hun siten, että käyttäjä voi laajentaa tai kutistaa rivin noutamatta kaikkia seuraavan tason tietoja. Se noutaa vain valitun rivin tiedot. Riviotsikon laajennustila pysyy johdonmukaisena kaikissa kirjanmerkeissä ja jopa tallennetuissa raporteissa. Se ei koske kaikkia visualisointeja.

Laajenna- ja kutista-komennot voidaan lisätä pikavalikkoon antamalla dataRoles -parametri -menetelmälle showContextMenu .

Näyttökuva, jossa näkyy pikavalikko ja laajenna- ja kutista-asetukset.

Jos haluat laajentaa suuren määrän arvopisteitä, käytä Tietojen noutaminen - ohjelmointirajapintaa laajenna/kutista-ohjelmointirajapinnalla.

Ohjelmointirajapinnan ominaisuudet

Seuraavat elementit on lisätty ohjelmointirajapinnan versioon 4.1.0, jotta riviotsikoiden laajentaminen ja kutistaminen voidaan ottaa käyttöön:

  • -isCollapsedmerkintä: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;
}

  • - toggleExpandCollapse menetelmä liittymässä ISelectionManger :

    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 
    //...
}

  • canBeExpanded DataViewHierarchyLevel-ohjausobjektin merkintä:

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

Visuaaliset vaatimukset

Laajenna kutista-toiminnon ottaminen käyttöön visualisoinnissa matriisin tietonäkymän avulla:

  1. Lisää seuraava koodi capabilities.json tiedostoon:

       "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. Vahvista, että roolit ovat porattavissa:

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

  3. Luo kullekin solmulle valinnanmuodostimen esiintymä kutsumalla withMatrixNode -menetelmää valitulla solmuhierarkiatasolla ja luomalla selectionId. Esimerkkejä:

        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. Luo valintojen hallinnan esiintymä ja käytä selectionManager.toggleExpandCollapse() -menetelmää , jonka parametrilla selectionIdloit valitulle solmulle. Esimerkki:

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

Muistiinpano

  • Jos valittu solmu ei ole rivisolmu, PowerBI ohittaa laajenna- ja kutista-kutsut ja laajenna- ja kutista-komennot poistetaan pikavalikosta.
  • - dataRoles parametri vaaditaan -menetelmälle showContextMenu vain, jos visualisointi tukee drilldown tai expandCollapse ominaisuuksia. Jos visualisointi tukee näitä ominaisuuksia, mutta dataRoles-parametria ei ole annettu, virhesanoma tulostuu konsoliin kehittäjävisualisointia käytettäessä tai jos virheenkorjaus julkisissa visualisoinneissa, joissa virheenkorjaustila on käytössä.

Huomioitavat asiat ja rajoitukset

  • Kun olet laajentanut solmun, DataView-kohteessa käytetään uusia tietorajoja. Uusi DataView ei välttämättä sisällä joitakin edellisessä DataView-kohteessa esiteltyjä solmuja.
  • Kun käytät Laajenna- tai Kutista-toimintoa, kokonaissummat lisätään, vaikka visualisointi ei pyytäisi niitä.
  • Sarakkeiden laajentamista ja kutistamista ei tueta.

Säilytä kaikki metatietosarakkeet

Ohjelmointirajapinnan versiossa 5.1.0 tai uudemmissa versioissa tuetaan kaikkien metatietosarakkeiden säilyttämistä. Tämän ominaisuuden avulla visualisointi voi vastaanottaa metatiedot kaikille sarakkeille riippumatta niiden aktiivisista ennusteista.

Lisää seuraavat rivit capabilities.json-tiedostoon :

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

Kun tämän ominaisuuden arvoksi true määritetään, kaikki metatiedot, myös kutistetut sarakkeet, vastaanotetaan. Jos määrität sen arvoksi false tai jätät sen määrittämättömäksi, metatiedot saavat metatietoja vain sarakkeissa, joissa on aktiiviset projektiot (esimerkiksi laajennettuna).

Tietojen vähentämisen algoritmi

Tietojen vähentämisen algoritmi määrittää, mitä tietoja ja kuinka paljon tietoja vastaanotetaan tietonäkymässä.

Määrä on määritetty tietonäkymän hyväksymien arvojen enimmäismäärään. Jos määrä-arvoja on enemmän kuin, tietojen vähentämisen algoritmi määrittää, mitkä arvot tulee vastaanottaa.

Tietojen vähentämisen algoritmityypit

Tietojenvähennysalgoritmin asetuksia on neljää tyyppiä:

  • top: Ensimmäiset määrä-arvot otetaan semanttisesta mallista.
  • bottom: Viimeiset määrä-arvot otetaan semanttisesta mallista.
  • sample: Ensimmäiset ja viimeiset kohteet sisällytetään samoin kuin niiden välisten kohteiden määrä. Jos sinulla on esimerkiksi semanttinen malli [0, 1, 2, ... 100] ja määrä 9, saat arvot [0, 10, 20... 100].
  • window: Lataa kerrallaan yhden arvopisteiden ikkunan , joka sisältää määrä-elementtejä . top Tällä hetkellä ja window vastaavat toisiaan. Ikkunointiasetusta tuetaan jatkossa täysin.

Oletusarvon mukaan kaikissa Power BI -visualisoinneissa on käytössä tietojenvähennysalgoritmi, jonka määrä-arvo on 1000 arvopistettä. Tämä oletus on sama kuin seuraavien ominaisuuksien määrittäminen capabilities.json tiedostossa:

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

Voit muokata määrä-arvoa mihin tahansa kokonaislukuarvoon, joka on enintään 30 000. R-pohjaiset Power BI -visualisoinnit voivat tukea enintään 150 000 riviä.

Tietojen vähentämisen algoritmin käyttö

Tietojen vähentämisen algoritmia voidaan käyttää tietojen luokittaisessa, taulukko- tai matriisinäkymän yhdistämismäärityksessä.

Luokittaisessa tietojen yhdistämisessä voit lisätä algoritmin kohteen "luokat" ja/tai "ryhmä" -osaan values luokittaista tietojen yhdistämistä varten.

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

Käytä taulukon tietonäkymän yhdistämismäärityksessä tietojenvähennysalgoritmia tietonäkymän rows yhdistämismääritystaulukon -osassa.

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

Voit käyttää tietojenvähennysalgoritmia rows tietonäkymän yhdistämismatriisin - ja columns -osissa.

Liittyvä sisältö