Bagikan melalui

Memahami pemetaan tampilan data dalam visual Power BI

  • Artikel

Artikel ini membahas pemetaan tampilan data dan menjelaskan bagaimana peran data digunakan untuk membuat berbagai jenis visual. Ini menjelaskan cara menentukan persyaratan bersyarah untuk peran data dan berbagai dataMappings jenis.

Setiap pemetaan yang valid menghasilkan tampilan data. Anda dapat menyediakan beberapa pemetaan data dalam kondisi tertentu. Opsi pemetaan yang didukung adalah:

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

Power BI membuat pemetaan ke tampilan data hanya jika pemetaan yang valid juga ditentukan dalam dataViewMappings.

Dengan kata lain, categorical mungkin didefinisikan dalam dataViewMappings tetapi pemetaan lain, seperti table atau single, mungkin tidak. Dalam hal ini, Power BI menghasilkan tampilan data dengan satu categorical pemetaan, sementara table dan pemetaan lainnya tetap tidak terdefinisi. Contohnya:

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

Kondisi

Bagian conditions ini menetapkan aturan untuk pemetaan data tertentu. Jika data cocok dengan salah satu kumpulan kondisi yang dijelaskan, visual menerima data sebagai valid.

Untuk setiap bidang, Anda dapat menentukan nilai minimum dan maksimum. Nilai mewakili jumlah bidang yang dapat terikat ke peran data tersebut.

Catatan

Jika peran data dihilangkan dalam kondisi tersebut, peran tersebut dapat memiliki sejumlah bidang.

Dalam contoh berikut, terbatas pada category satu bidang data dan terbatas pada measure dua bidang data.

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

Anda juga dapat mengatur beberapa kondisi untuk peran data. Dalam hal ini, data valid jika salah satu kondisi terpenuhi.

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

Dalam contoh sebelumnya, salah satu dari dua kondisi berikut diperlukan:

  • Tepat satu bidang kategori dan tepat dua ukuran
  • Tepat dua kategori dan tepat satu ukuran

Pemetaan data tunggal

Pemetaan data tunggal adalah bentuk pemetaan data yang paling sederhana. Ini menerima bidang pengukuran tunggal dan mengembalikan total. Jika bidang numerik, bidang akan mengembalikan jumlah. Jika tidak, ia mengembalikan hitungan nilai unik.

Untuk menggunakan pemetaan data tunggal, tentukan nama peran data yang ingin Anda petakan. Pemetaan ini hanya berfungsi dengan satu bidang pengukuran. Jika bidang kedua ditetapkan, tidak ada tampilan data yang dihasilkan, jadi ada baiknya untuk menyertakan kondisi yang membatasi data ke satu bidang.

Catatan

Pemetaan data ini tidak dapat digunakan bersama dengan pemetaan data lainnya. Ini dimaksudkan untuk mengurangi data ke satu nilai numerik.

Contohnya:

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

Tampilan data yang dihasilkan masih dapat berisi jenis pemetaan lain, seperti tabel atau kategoris, tetapi setiap pemetaan hanya berisi nilai tunggal. Praktik terbaik adalah mengakses nilai hanya dalam pemetaan tunggal.

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

Sampel kode berikut memproses pemetaan tampilan data sederhana:

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

Sampel kode sebelumnya menghasilkan tampilan satu nilai dari Power BI:

Cuplikan layar visual pemetaan tampilan data tunggal.

Pemetaan data kategoris

Pemetaan data kategoris digunakan untuk mendapatkan pengelompokan independen atau kategori data. Kategori juga dapat dikelompokkan bersama dengan menggunakan "kelompokkan menurut" dalam pemetaan data.

Pemetaan data kategoris dasar

Pertimbangkan peran dan pemetaan data berikut:

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

Contoh sebelumnya berbunyi "Petakan peran data saya category sehingga untuk setiap bidang yang saya seret ke category, datanya dipetakan ke categorical.categories. Selain itu, petakan peran data measure saya ke categorical.values."

  • Untuk... di: Menyertakan semua item dalam peran data ini dalam kueri data.
  • Mengikat... ke: Menghasilkan hasil yang sama seperti untuk... dalam tetapi mengharapkan peran data memiliki kondisi yang membatasinya ke satu bidang.

Mengelompokkan data kategoris

Contoh berikutnya menggunakan dua peran data yang sama dengan contoh sebelumnya dan menambahkan dua peran data lagi bernama grouping dan 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"
                            }
                        }
                    ]
                }
            }
        }
    }
]

Perbedaan antara pemetaan ini dan pemetaan dasar adalah bagaimana categorical.values dipetakan. Saat Anda memetakan measure peran data dan measure2 ke peran groupingdata, sumbu x dan sumbu y dapat diskalakan dengan tepat.

Mengelompokkan data hierarkis

Dalam contoh berikutnya, data kategoris digunakan untuk membuat hierarki, yang dapat digunakan untuk mendukung tindakan telusuri paling detail .

Contoh berikut menunjukkan peran dan pemetaan data:

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

Pertimbangkan data kategoris berikut:

Negara/Wilayah 2013 2014 2015 2016
AS x x 650 350
Kanada x 630 490 x
Meksiko 645 x x x
Inggris x x 831 x

Power BI menghasilkan tampilan data kategoris dengan serangkaian kategori berikut.

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

Setiap category peta ke satu set values. Masing-masing values dikelompokkan menurut series, yang dinyatakan sebagai tahun.

Misalnya, setiap array values mewakili satu tahun. Selain itu, setiap values array memiliki empat nilai: Kanada, AS, Inggris, dan 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": [...],
        }
    ]
}

Sampel kode berikut adalah untuk memproses pemetaan tampilan data kategoris. Sampel ini membuat struktur hierarkis Nilai Tahun > Negara/Wilayah>.

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

Berikut adalah visual yang dihasilkan:

Cuplikan layar visual dengan pemetaan tampilan data kategoris.

Tabel pemetaan

Tampilan data tabel pada dasarnya adalah daftar titik data tempat titik data numerik dapat diagregasi.

Misalnya, gunakan data yang sama di bagian sebelumnya, tetapi dengan kemampuan berikut:

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

Visualisasikan tampilan data tabel seperti contoh ini:

Negara/Wilayah Tahun Sales
AS 2016 100
AS 2015 50
Kanada 2015 200
Kanada 2015 50
Meksiko 2013 300
Inggris 2014 150
AS 2015 75

Pengikatan data:

Cuplikan layar pengikatan data pemetaan tampilan data tabel.

Power BI menampilkan data Anda sebagai tampilan data tabel. Jangan berasumsi bahwa data diurutkan.

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

Untuk mengagregasi data, pilih bidang yang diinginkan lalu pilih Jumlah.

Cuplikan layar Jumlah dipilih dari menu dropdown bidang.

Sampel kode untuk memproses pemetaan tampilan data tabel.

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

File style/visual.less gaya visual berisi tata letak untuk tabel:

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

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

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

Visual yang dihasilkan terlihat seperti ini:

Cuplikan layar visual dengan pemetaan tampilan data tabel.

Pemetaan data matriks

Pemetaan data matriks mirip dengan pemetaan data tabel, tetapi baris disajikan secara hierarkis. Salah satu nilai peran data dapat digunakan sebagai nilai header kolom.

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

Struktur hierarkis data matriks

Power BI membuat struktur data hierarkis. Akar hierarki pohon menyertakan data dari kolom Orang Tua dari Category peran data dengan anak-anak dari kolom Anak dari tabel peran data.

Model semantik:

orang tua Anak Cucu Kolom Nilai
Orangtua1 Anak1 Cucu1 Col1 5
Orangtua1 Anak1 Cucu1 Col2 6
Orangtua1 Anak1 Cucu2 Col1 7
Orangtua1 Anak1 Cucu2 Col2 8
Orangtua1 Anak2 Cucu3 Col1 5
Orangtua1 Anak2 Cucu3 Col2 3
Orangtua1 Anak2 Cucu4 Col1 4
Orangtua1 Anak2 Cucu4 Col2 9
Orangtua1 Anak2 Cucu5 Col1 3
Orangtua1 Anak2 Cucu5 Col2 5
Orangtua2 Anak3 Cucu6 Col1 1
Orangtua2 Anak3 Cucu6 Col2 2
Orangtua2 Anak3 Cucu7 Col1 7
Orangtua2 Anak3 Cucu7 Col2 1
Orangtua2 Anak3 Cucu8 Col1 10
Orangtua2 Anak3 Cucu8 Col2 13

Visual matriks inti Power BI merender data sebagai tabel.

Cuplikan layar visual Matriks yang dirender sebagai tabel.

Visual mendapatkan struktur datanya seperti yang dijelaskan dalam kode berikut (hanya dua baris tabel pertama yang diperlihatkan di sini):

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

Memperluas dan menciutkan header baris

Untuk API 4.1.0 atau yang lebih baru, data matriks mendukung perluasan dan ciutkan header baris. Dari API 4.2 Anda dapat memperluas/menciutkan seluruh tingkat secara terprogram. Fitur perluas dan ciutkan mengoptimalkan pengambilan data ke dataView dengan memungkinkan pengguna memperluas atau menciutkan baris tanpa mengambil semua data untuk tingkat berikutnya. Ini hanya mengambil data untuk baris yang dipilih. Status ekspansi header baris tetap konsisten di seluruh marka buku dan bahkan di seluruh laporan yang disimpan. Ini tidak spesifik untuk setiap visual.

Perluas dan ciutkan perintah dapat ditambahkan ke menu konteks dengan menyediakan dataRoles parameter ke showContextMenu metode .

Cuplikan layar memperlihatkan menu konteks dengan opsi perluas dan ciutkan.

Untuk memperluas sejumlah besar titik data, gunakan ambil lebih banyak API data dengan API perluas/ciutkan.

Fitur API

Elemen berikut telah ditambahkan ke API versi 4.1.0 untuk mengaktifkan perluasan dan ciutkan header baris:

  • Bendera isCollapsed di 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;
}

  • Metode toggleExpandCollapse dalam antarmuka 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 
    //...
}

  • Bendera canBeExpanded di DataViewHierarchyLevel:

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

Persyaratan visual

Untuk mengaktifkan fitur ciutkan perluas pada visual dengan menggunakan tampilan data matriks:

  1. Tambahkan kode berikut ke file capabilities.json:

       "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. Konfirmasikan bahwa peran dapat dibor:

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

  3. Untuk setiap simpul, buat instans pembangun pilihan dengan memanggil withMatrixNode metode dalam tingkat hierarki simpul yang dipilih dan membuat selectionId. Contohnya:

        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. Buat instans manajer pilihan, dan gunakan selectionManager.toggleExpandCollapse() metode , dengan parameter selectionId, yang Anda buat untuk simpul yang dipilih. Contoh:

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

Catatan

  • Jika simpul yang dipilih bukan simpul baris, PowerBI akan mengabaikan perluas dan ciutkan panggilan dan perintah perluas dan ciutkan akan dihapus dari menu konteks.
  • Parameter dataRoles diperlukan untuk metode showContextMenu hanya jika visual mendukung fitur drilldown atau expandCollapse. Jika visual mendukung fitur-fitur ini tetapi dataRoles tidak disediakan, kesalahan akan dihasilkan ke konsol saat menggunakan visual pengembang atau jika penelusuran kesalahan visual publik dengan mode debug diaktifkan.

Pertimbangan dan batasan

  • Setelah Anda memperluas simpul, batas data baru akan diterapkan ke DataView. DataView baru mungkin tidak menyertakan beberapa simpul yang disajikan di DataView sebelumnya.
  • Saat menggunakan perluas atau ciutkan, total ditambahkan meskipun visual tidak memintanya.
  • Memperluas dan menciutkan kolom tidak didukung.

Pertahankan semua kolom metadata

Untuk API 5.1.0 atau yang lebih baru, menjaga semua kolom metadata didukung. Fitur ini memungkinkan visual untuk menerima metadata untuk semua kolom apa pun proyeksi aktifnya.

Tambahkan baris berikut ke file capabilities.json Anda:

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

Mengatur properti ini ke true akan mengakibatkan penerimaan semua metadata, termasuk dari kolom yang diciutkan. Mengaturnya ke false atau membiarkannya tidak terdefinisi akan mengakibatkan penerimaan metadata hanya pada kolom dengan proyeksi aktif (diperluas, misalnya).

Algoritma pengurangan data

Algoritma pengurangan data mengontrol data mana dan berapa banyak data yang diterima dalam tampilan data.

Hitungan diatur ke jumlah maksimum nilai yang dapat diterima tampilan data. Jika ada lebih dari nilai hitungan, algoritma pengurangan data menentukan nilai mana yang harus diterima.

Jenis algoritma pengurangan data

Ada empat jenis pengaturan algoritma pengurangan data:

  • top: Nilai hitungan pertama diambil dari model semantik.
  • bottom: Nilai hitungan terakhir diambil dari model semantik.
  • sample: Item pertama dan terakhir disertakan, dan hitung jumlah item dengan interval yang sama di antaranya. Misalnya, jika Anda memiliki model semantik [0, 1, 2, ... 100] dan hitungan 9, Anda menerima nilai [0, 10, 20 ... 100].
  • window: Memuat satu jendela titik data pada satu waktu yang berisi elemen hitungan. Saat ini, top dan window setara. Di masa mendatang, pengaturan windowing akan didukung sepenuhnya.

Secara default, semua visual Power BI memiliki algoritma pengurangan data teratas yang diterapkan dengan jumlah yang diatur ke 1000 titik data. Default ini setara dengan mengatur properti berikut dalam file capabilities.json :

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

Anda dapat mengubah nilai hitungan ke nilai bilangan bulat apa pun hingga 30000. Visual Power BI berbasis R dapat mendukung hingga 150000 baris.

Penggunaan algoritma pengurangan data

Algoritma pengurangan data dapat digunakan dalam pemetaan tampilan data kategoris, tabel, atau matriks.

Dalam pemetaan data kategoris, Anda dapat menambahkan algoritma ke bagian values "kategori" dan/atau "grup" untuk pemetaan data kategoris.

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

Dalam pemetaan tampilan data tabel, terapkan algoritma pengurangan data ke bagian rows tabel pemetaan Tampilan Data.

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

Anda dapat menerapkan algoritma pengurangan data ke bagian rows dan columns dari matriks pemetaan Tampilan Data.

Konten terkait